@Override public List<Topology.TopologyValidationError> validateTopology(DatabaseMetaData metadata) { List<Topology.TopologyValidationError> validationErrors = new ArrayList<>(); for (PropertyColumn propertyColumn : getProperties().values()) { List<Triple<String, Integer, String>> columns = this.sqlgGraph.getSqlDialect().getTableColumns(metadata, null, this.getSchema().getName(), "E_" + this.getLabel(), propertyColumn.getName()); if (columns.isEmpty()) { validationErrors.add(new Topology.TopologyValidationError(propertyColumn)); } // try (ResultSet propertyRs = metadata.getColumns(null, this.getSchema().getName(), "E_" + this.getLabel(), propertyColumn.getName())) { // if (!propertyRs.next()) { // validationErrors.add(new Topology.TopologyValidationError(propertyColumn)); // } // } } return validationErrors; }
private static EdgeLabel ensureEdgeLabelExist(Topology topology, String label, VertexLabel out, VertexLabel in, Map<String, PropertyType> columns, List<String> nonUniqueIndexNames) { EdgeLabel edgeLabel = topology.ensureEdgeLabelExist(label, out, in, columns); nonUniqueIndexNames.stream() .flatMap(fromOptional(edgeLabel::getProperty)) .map(Collections::singletonList) .forEach(properties -> edgeLabel.ensureIndexExists(NON_UNIQUE, properties)); return edgeLabel; }
private EdgeLabel internalEnsureEdgeTableExists(EdgeLabel edgeLabel, VertexLabel outVertexLabel, VertexLabel inVertexLabel, Map<String, PropertyType> columns) { edgeLabel.ensureEdgeVertexLabelExist(Direction.OUT, outVertexLabel); edgeLabel.ensureEdgeVertexLabelExist(Direction.IN, inVertexLabel); edgeLabel.ensurePropertiesExist(columns); return edgeLabel; }
/** * delete a given column from the table * * @param column The column to delete. */ private void deleteColumn(String column) { removeColumn(getSchema().getName(), EDGE_PREFIX + getLabel(), column); }
void addToInEdgeLabels(EdgeLabel edgeLabel) { edgeLabel.addToInVertexLabel(this); this.inEdgeLabels.put(edgeLabel.getSchema().getName() + "." + edgeLabel.getLabel(), edgeLabel); }
.getSchema(schemaTable.getSchema()).orElseThrow(() -> new IllegalStateException(String.format("Schema %s not found", schemaTable.getSchema()))) .getEdgeLabel(schemaTable.getTable()).orElseThrow(() -> new IllegalStateException(String.format("EdgeLabel %s not found", schemaTable.getTable()))); Map<String, PropertyColumn> propertyColumns = edgeLabel.getProperties(); if (!columns.isEmpty()) { Map<String, PropertyType> propertyTypeMap = new HashMap<>(); if (edgeLabel.hasIDPrimaryKey()) { sql.append(sqlgGraph.getSqlDialect().maybeWrapInQoutes(Topology.ID)); sql.append(" = ?"); } else { for (String identifier : edgeLabel.getIdentifiers()) { sql.append(sqlgGraph.getSqlDialect().maybeWrapInQoutes(identifier)); sql.append(" = ?");
default String drop(EdgeLabel edgeLabel, Collection<RecordId.ID> ids) { StringBuilder sql = new StringBuilder(); sql.append("DELETE FROM\n\t"); sql.append(maybeWrapInQoutes(edgeLabel.getSchema().getName())); sql.append("."); sql.append(maybeWrapInQoutes(Topology.EDGE_PREFIX + edgeLabel.getName())); sql.append(" WHERE "); if (edgeLabel.hasIDPrimaryKey()) { sql.append(maybeWrapInQoutes("ID")); } else { int cnt = 1; sql.append("("); for (String identifier : edgeLabel.getIdentifiers()) { sql.append(maybeWrapInQoutes(identifier)); if (cnt++ < edgeLabel.getIdentifiers().size()) { sql.append(","); int count = 1; for (RecordId.ID id : ids) { if (edgeLabel.hasIDPrimaryKey()) { sql.append(id.getSequenceId()); if (count++ < ids.size()) {
public static void executeDropEdges(SqlgGraph sqlgGraph, EdgeLabel edgeLabel, String sql, List<EventCallback<Event>> mutatingCallbacks) { try { Connection conn = sqlgGraph.tx().getConnection(); if (logger.isDebugEnabled()) { logger.debug(sql); } try (Statement statement = conn.createStatement()) { if (mutatingCallbacks.isEmpty()) { statement.execute(sql); } else { ResultSet resultSet = statement.executeQuery(sql); while (resultSet.next()) { Long id = resultSet.getLong(1); final Event removeEvent; removeEvent = new Event.EdgeRemovedEvent(SqlgEdge.of(sqlgGraph, id, edgeLabel.getSchema().getName(), edgeLabel.getName())); for (EventCallback<Event> eventCallback : mutatingCallbacks) { eventCallback.accept(removeEvent); } } } } } catch (SQLException e) { throw new RuntimeException(e); } }
for (Map.Entry<String, EdgeLabel> edgeLabelEntry : lastVertexLabel.getOutEdgeLabels().entrySet()) { EdgeLabel edgeLabel = edgeLabelEntry.getValue(); if (!edgeLabel.equals(lastEdgeLabel)) { sb.append(maybeWrapInQoutes(edgeLabel.getSchema().getName())); sb.append("."); sb.append(maybeWrapInQoutes(Topology.EDGE_PREFIX + edgeLabel.getName())); sb.append("\nWHERE "); sb.append(maybeWrapInQoutes(lastVertexLabel.getSchema().getName() + "." + lastVertexLabel.getName() + Topology.OUT_VERTEX_COLUMN_END)); sb.append(leafElementsToDelete); sb.append(")"); sqls.add(Triple.of(SqlgSqlExecutor.DROP_QUERY.NORMAL, sb.toString(), SchemaTable.of(edgeLabel.getSchema().getName(), Topology.EDGE_PREFIX + edgeLabel.getName()))); if (!edgeLabel.equals(lastEdgeLabel)) { sb.append(maybeWrapInQoutes(edgeLabel.getSchema().getName())); sb.append("."); sb.append(maybeWrapInQoutes(Topology.EDGE_PREFIX + edgeLabel.getName())); sb.append("\nWHERE "); sb.append(maybeWrapInQoutes(lastVertexLabel.getSchema().getName() + "." + lastVertexLabel.getName() + Topology.IN_VERTEX_COLUMN_END)); sb.append(leafElementsToDelete); sb.append(")"); sqls.add(Triple.of(SqlgSqlExecutor.DROP_QUERY.NORMAL, sb.toString(), SchemaTable.of(edgeLabel.getSchema().getName(), Topology.EDGE_PREFIX + edgeLabel.getName())));
PartitionType partitionType = PartitionType.valueOf(uncommittedOutEdgeLabel.get("partitionType").asText()); if (partitionType.isNone()) { edgeLabel = new EdgeLabel(this.getSchema().getTopology(), edgeLabelName); } else { String partitionExpression = uncommittedOutEdgeLabel.get("partitionExpression").asText(); edgeLabel = new EdgeLabel(this.getSchema().getTopology(), edgeLabelName, partitionType, partitionExpression); edgeLabel.addToOutVertexLabel(this); this.outEdgeLabels.put(schemaName + "." + edgeLabel.getLabel(), edgeLabel); edgeLabel.fromPropertyNotifyJson(uncommittedOutEdgeLabel, edgeLabelOptional.isPresent()); this.getSchema().getTopology().addToAllTables(getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), edgeLabel.getPropertyTypeMap()); this.getSchema().addToAllEdgeCache(edgeLabel); this.getSchema().getTopology().addOutForeignKeysToVertexLabel(this, edgeLabel); this.getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), foreignKey ); lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(), foreignKey );
Pair<Set<SchemaTable>, Set<SchemaTable>> getUncommittedSchemaTableForeignKeys() { Pair<Set<SchemaTable>, Set<SchemaTable>> result = Pair.of(new HashSet<>(), new HashSet<>()); for (Map.Entry<String, EdgeLabel> uncommittedEdgeLabelEntry : this.uncommittedOutEdgeLabels.entrySet()) { result.getRight().add(SchemaTable.of(this.getSchema().getName(), EDGE_PREFIX + uncommittedEdgeLabelEntry.getValue().getLabel())); } for (Map.Entry<String, EdgeLabel> uncommittedEdgeLabelEntry : this.uncommittedInEdgeLabels.entrySet()) { result.getLeft().add(SchemaTable.of(uncommittedEdgeLabelEntry.getValue().getSchema().getName(), EDGE_PREFIX + uncommittedEdgeLabelEntry.getValue().getLabel())); } return result; }
sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes("ID")); appendProperties(edgeLabel, sql); for (VertexLabel vertexLabel : edgeLabel.getOutVertexLabels()) { sql.append(", "); sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(vertexLabel.getSchema().getName() + "." + vertexLabel.getName() + Topology.OUT_VERTEX_COLUMN_END)); for (VertexLabel vertexLabel : edgeLabel.getInVertexLabels()) { sql.append(", "); sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(vertexLabel.getSchema().getName() + "." + vertexLabel.getName() + Topology.IN_VERTEX_COLUMN_END)); sql.append(" WHERE "); if (edgeLabel.hasIDPrimaryKey()) { sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes("ID")); sql.append(" = ?"); } else { int count = 1; for (String identifier : edgeLabel.getIdentifiers()) { sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(identifier)); sql.append(" = ?"); if (count++ < edgeLabel.getIdentifiers().size()) { sql.append(" AND "); if (edgeLabel.hasIDPrimaryKey()) { preparedStatement.setLong(1, this.recordId.sequenceId()); } else {
@Override public boolean equals(Object other) { if (!super.equals(other)) { return false; } if (!(other instanceof EdgeLabel)) { return false; } EdgeLabel otherEdgeLabel = (EdgeLabel) other; if (isValid()) { if (this.getSchema().getTopology().isSqlWriteLockHeldByCurrentThread() && !this.uncommittedInVertexLabels.isEmpty()) { VertexLabel vertexLabel = this.uncommittedOutVertexLabels.iterator().next(); VertexLabel otherVertexLabel = otherEdgeLabel.uncommittedOutVertexLabels.iterator().next(); return vertexLabel.getSchema().equals(otherVertexLabel.getSchema()) && otherEdgeLabel.getLabel().equals(this.getLabel()); } else { VertexLabel vertexLabel = this.outVertexLabels.iterator().next(); VertexLabel otherVertexLabel = otherEdgeLabel.outVertexLabels.iterator().next(); return vertexLabel.getSchema().equals(otherVertexLabel.getSchema()) && otherEdgeLabel.getLabel().equals(this.getLabel()); } } return otherEdgeLabel.getLabel().equals(this.getLabel()); }
public void ensurePropertiesExist(Map<String, PropertyType> columns) { for (Map.Entry<String, PropertyType> column : columns.entrySet()) { if (!this.properties.containsKey(column.getKey())) { Preconditions.checkState(!this.getSchema().isSqlgSchema(), "schema may not be %s", SQLG_SCHEMA); if (!this.uncommittedProperties.containsKey(column.getKey())) { this.getSchema().getTopology().lock(); if (!getProperty(column.getKey()).isPresent()) { TopologyManager.addEdgeColumn(this.sqlgGraph, this.getSchema().getName(), EDGE_PREFIX + getLabel(), column, new ListOrderedSet<>()); addColumn(this.getSchema().getName(), EDGE_PREFIX + getLabel(), ImmutablePair.of(column.getKey(), column.getValue())); PropertyColumn propertyColumn = new PropertyColumn(this, column.getKey(), column.getValue()); propertyColumn.setCommitted(false); this.uncommittedProperties.put(column.getKey(), propertyColumn); this.getSchema().getTopology().fire(propertyColumn, "", TopologyChangeAction.CREATE); } } } } }
/** * remove a given edge label * * @param edgeLabel the edge label * @param preserveData should we keep the SQL data */ void removeEdgeLabel(EdgeLabel edgeLabel, boolean preserveData) { getTopology().lock(); String fn = this.name + "." + EDGE_PREFIX + edgeLabel.getName(); if (!uncommittedRemovedEdgeLabels.contains(fn)) { uncommittedRemovedEdgeLabels.add(fn); TopologyManager.removeEdgeLabel(this.sqlgGraph, edgeLabel); for (VertexLabel lbl : edgeLabel.getOutVertexLabels()) { lbl.removeOutEdge(edgeLabel); } for (VertexLabel lbl : edgeLabel.getInVertexLabels()) { lbl.removeInEdge(edgeLabel); } if (!preserveData) { edgeLabel.delete(); } getTopology().fire(edgeLabel, "", TopologyChangeAction.DELETE); } }
public void ensureEdgeVertexLabelExist(Direction direction, VertexLabel vertexLabel) { //if the direction is OUT then the vertexLabel must be in the same schema as the edgeLabel (this) if (direction == Direction.OUT) { Preconditions.checkState(vertexLabel.getSchema().equals(getSchema()), "For Direction.OUT the VertexLabel must be in the same schema as the edge. Found %s and %s", vertexLabel.getSchema().getName(), getSchema().getName()); } SchemaTable foreignKey = SchemaTable.of(vertexLabel.getSchema().getName(), vertexLabel.getLabel() + (direction == Direction.IN ? Topology.IN_VERTEX_COLUMN_END : Topology.OUT_VERTEX_COLUMN_END)); if (!foreignKeysContains(direction, vertexLabel)) { //Make sure the current thread/transaction owns the lock Schema schema = this.getSchema(); schema.getTopology().lock(); if (!foreignKeysContains(direction, vertexLabel)) { TopologyManager.addLabelToEdge(this.sqlgGraph, this.getSchema().getName(), EDGE_PREFIX + getLabel(), direction == Direction.IN, foreignKey); if (direction == Direction.IN) { this.uncommittedInVertexLabels.add(vertexLabel); vertexLabel.addToUncommittedInEdgeLabels(schema, this); } else { this.uncommittedOutVertexLabels.add(vertexLabel); vertexLabel.addToUncommittedOutEdgeLabels(schema, this); } SchemaTable vertexSchemaTable = SchemaTable.of(vertexLabel.getSchema().getName(), vertexLabel.getLabel()); addEdgeForeignKey(schema.getName(), EDGE_PREFIX + getLabel(), foreignKey, vertexSchemaTable); this.getSchema().getTopology().fire(this, vertexSchemaTable.toString(), TopologyChangeAction.ADD_IN_VERTEX_LABELTO_EDGE); } } }
@Override public void remove(boolean preserveData) { getSchema().removeEdgeLabel(this, preserveData); }
if (!edgeLabel.hasIDPrimaryKey()) { Preconditions.checkArgument(columns.keySet().containsAll(edgeLabel.getIdentifiers()), "identifiers must be present %s", edgeLabel.getIdentifiers());
public Set<VertexLabel> getInVertexLabels() { Set<VertexLabel> result = new HashSet<>(this.inVertexLabels); if (isValid() && this.getSchema().getTopology().isSqlWriteLockHeldByCurrentThread()) { result.addAll(this.uncommittedInVertexLabels); result.removeAll(this.uncommittedRemovedInVertexLabels); } return Collections.unmodifiableSet(result); }
Preconditions.checkState(edgeLabelOptional.isPresent()); edgeLabelOptional.get() .ensureIndexExists( IndexType.NON_UNIQUE, new ArrayList<>(edgeLabelOptional.get().getProperties().values()) );