void ensureTemporaryVertexTableExist(final String label, final Map<String, PropertyType> columns) { Objects.requireNonNull(label, "Given table must not be null"); Preconditions.checkArgument(!label.startsWith(VERTEX_PREFIX), "label may not be prefixed with %s", VERTEX_PREFIX); final String prefixedTable = VERTEX_PREFIX + label; if (!this.threadLocalTemporaryTables.get().containsKey(prefixedTable)) { this.topology.lock(); if (!this.threadLocalTemporaryTables.get().containsKey(prefixedTable)) { this.threadLocalTemporaryTables.get().put(prefixedTable, columns); createTempTable(prefixedTable, columns); } } }
@Override AbstractLabel getAbstractLabel(Schema schema) { return schema.getEdgeLabel(this.table).orElseThrow(() -> new IllegalStateException(String.format("VertexLabel %s not found.", this.table))); } }
@Override public int hashCode() { return (this.schema.getName() + this.getLabel()).hashCode(); }
/** * Creates the 'public' schema that always already exist and is pre-loaded in {@link Topology()} @see {@link Topology#cacheTopology()} * * @param publicSchemaName The 'public' schema's name. Sometimes its upper case (Hsqldb) sometimes lower (Postgresql) * @param topology The {@link Topology} that contains the public schema. * @return The Schema that represents 'public' */ static Schema createPublicSchema(SqlgGraph sqlgGraph, Topology topology, String publicSchemaName) { Schema schema = new Schema(topology, publicSchemaName); if (!existPublicSchema(sqlgGraph)) { schema.createSchemaOnDb(); } schema.committed = false; return schema; }
void ensureEdgeColumnsExist(String label, Map<String, PropertyType> columns) { Preconditions.checkArgument(!label.startsWith(EDGE_PREFIX), "label may not start with \"%s\"", EDGE_PREFIX); Preconditions.checkState(!isSqlgSchema(), "Schema.ensureEdgePropertiesExist may not be called for \"%s\"", SQLG_SCHEMA); Optional<EdgeLabel> edgeLabel = getEdgeLabel(label); Preconditions.checkState(edgeLabel.isPresent(), "BUG: edgeLabel \"%s\" must exist", label); //noinspection OptionalGetWithoutIsPresent edgeLabel.get().ensurePropertiesExist(columns); }
void ensureVertexColumnsExist(String label, Map<String, PropertyType> columns) { Preconditions.checkArgument(!label.startsWith(VERTEX_PREFIX), "label may not start with \"%s\"", VERTEX_PREFIX); Preconditions.checkState(!isSqlgSchema(), "Schema.ensureVertexLabelPropertiesExist may not be called for \"%s\"", SQLG_SCHEMA); Optional<VertexLabel> vertexLabel = getVertexLabel(label); Preconditions.checkState(vertexLabel.isPresent(), "BUG: vertexLabel \"%s\" must exist", label); //noinspection OptionalGetWithoutIsPresent vertexLabel.get().ensurePropertiesExist(columns); }
Schema sqlgSchema = Schema.instantiateSqlgSchema(this); this.metaSchemas.put(SQLG_SCHEMA, sqlgSchema); columns.put(CREATED_ON, PropertyType.LOCALDATETIME); columns.put(UPDATED_ON, PropertyType.LOCALDATETIME); VertexLabel graphVertexLabel = sqlgSchema.createSqlgSchemaVertexLabel(SQLG_SCHEMA_GRAPH, columns); this.sqlgSchemaAbstractLabels.add(graphVertexLabel); columns.put(SQLG_SCHEMA_PROPERTY_NAME, PropertyType.STRING); columns.put(CREATED_ON, PropertyType.LOCALDATETIME); VertexLabel schemaVertexLabel = sqlgSchema.createSqlgSchemaVertexLabel(SQLG_SCHEMA_SCHEMA, columns); this.sqlgSchemaAbstractLabels.add(schemaVertexLabel); columns.put(SQLG_SCHEMA_VERTEX_LABEL_PARTITION_EXPRESSION, PropertyType.STRING); columns.put(SQLG_SCHEMA_VERTEX_LABEL_DISTRIBUTION_SHARD_COUNT, PropertyType.INTEGER); VertexLabel vertexVertexLabel = sqlgSchema.createSqlgSchemaVertexLabel(SQLG_SCHEMA_VERTEX_LABEL, columns); this.sqlgSchemaAbstractLabels.add(vertexVertexLabel); columns.put(SQLG_SCHEMA_EDGE_LABEL_PARTITION_EXPRESSION, PropertyType.STRING); columns.put(SQLG_SCHEMA_EDGE_LABEL_DISTRIBUTION_SHARD_COUNT, PropertyType.INTEGER); VertexLabel edgeVertexLabel = sqlgSchema.createSqlgSchemaVertexLabel(SQLG_SCHEMA_EDGE_LABEL, columns); this.sqlgSchemaAbstractLabels.add(edgeVertexLabel); columns.put(SQLG_SCHEMA_PARTITION_PARTITION_TYPE, PropertyType.STRING); columns.put(SQLG_SCHEMA_PARTITION_PARTITION_EXPRESSION, PropertyType.STRING); partitionVertexLabel = sqlgSchema.createSqlgSchemaVertexLabel(SQLG_SCHEMA_PARTITION, columns); this.sqlgSchemaAbstractLabels.add(partitionVertexLabel); columns.put(CREATED_ON, PropertyType.LOCALDATETIME);
Map<String, PropertyColumn> getPropertiesWithGlobalUniqueIndexFor(SchemaTable schemaTable) { Preconditions.checkArgument(schemaTable.getTable().startsWith(VERTEX_PREFIX) || schemaTable.getTable().startsWith(EDGE_PREFIX), "label must start with \"%s\" or \"%s\"", VERTEX_PREFIX, EDGE_PREFIX); if (schemaTable.isVertexTable()) { Optional<VertexLabel> vertexLabelOptional = getVertexLabel(schemaTable.withOutPrefix().getTable()); if (vertexLabelOptional.isPresent()) { return vertexLabelOptional.get().getGlobalUniqueIndexProperties(); } } else { Optional<EdgeLabel> edgeLabelOptional = getEdgeLabel(schemaTable.withOutPrefix().getTable()); if (edgeLabelOptional.isPresent()) { return edgeLabelOptional.get().getGlobalUniqueIndexProperties(); } } return Collections.emptyMap(); }
SQLServerVertexCacheBulkRecord(SQLServerBulkCopy bulkCopy, SqlgGraph sqlgGraph, SchemaTable schemaTable, Pair<SortedSet<String>, Map<SqlgVertex, Map<String, Object>>> vertices) throws SQLServerException { this.rowIter = vertices.getRight().entrySet().iterator(); if (!schemaTable.isTemporary()) { this.propertyColumns = sqlgGraph.getTopology() .getSchema(schemaTable.getSchema()).orElseThrow(() -> new IllegalStateException(String.format("Schema %s not found", schemaTable.getSchema()))) .getVertexLabel(schemaTable.getTable()).orElseThrow(() -> new IllegalStateException(String.format("VertexLabel %s not found", schemaTable.getTable()))) .getProperties(); } else { this.properties = sqlgGraph.getTopology().getPublicSchema().getTemporaryTable(VERTEX_PREFIX + schemaTable.getTable()); } int i = 1; this.columns = vertices.getLeft(); this.dummy = this.columns.isEmpty(); if (this.dummy) { bulkCopy.addColumnMapping(i, "dummy"); this.columnMetadata.put(i, new ColumnMetadata( "dummy", sqlgGraph.getSqlDialect().propertyTypeToJavaSqlType(PropertyType.INTEGER)[0], 0, 0, null, PropertyType.INTEGER )); } else { addMetaData(bulkCopy, sqlgGraph); } }
@SuppressWarnings("OptionalGetWithoutIsPresent") private EdgeLabel createEdgeLabel( final String edgeLabelName, final VertexLabel outVertexLabel, final VertexLabel inVertexLabel, final Map<String, PropertyType> columns, final ListOrderedSet<String> identifiers) { Preconditions.checkArgument(this.topology.isSqlWriteLockHeldByCurrentThread(), "Lock must be held by the thread to call createEdgeLabel"); Preconditions.checkArgument(!edgeLabelName.startsWith(EDGE_PREFIX), "edgeLabelName may not start with " + EDGE_PREFIX); Preconditions.checkState(!this.isSqlgSchema(), "createEdgeLabel may not be called for \"%s\"", SQLG_SCHEMA); Schema inVertexSchema = inVertexLabel.getSchema(); //Edge may not already exist. Preconditions.checkState(!getEdgeLabel(edgeLabelName).isPresent(), "BUG: Edge \"%s\" already exists!", edgeLabelName); SchemaTable foreignKeyOut = SchemaTable.of(this.name, outVertexLabel.getLabel()); SchemaTable foreignKeyIn = SchemaTable.of(inVertexSchema.name, inVertexLabel.getLabel()); TopologyManager.addEdgeLabel(this.sqlgGraph, this.getName(), EDGE_PREFIX + edgeLabelName, foreignKeyOut, foreignKeyIn, columns, identifiers); if (this.sqlgGraph.getSqlDialect().needsSchemaCreationPrecommit()) { try { this.sqlgGraph.tx().getConnection().commit(); } catch (SQLException e) { throw new RuntimeException(e); } } return outVertexLabel.addEdgeLabel(edgeLabelName, inVertexLabel, columns, identifiers); }
Optional<EdgeLabel> edgeLabelOptional = this.getEdgeLabel(edgeLabelName); if (!edgeLabelOptional.isPresent()) { this.topology.lock(); edgeLabelOptional = this.getEdgeLabel(edgeLabelName); if (!edgeLabelOptional.isPresent()) { edgeLabel = this.createEdgeLabel(edgeLabelName, outVertexLabel, inVertexLabel, columns, identifiers); this.uncommittedRemovedEdgeLabels.remove(this.name + "." + EDGE_PREFIX + edgeLabelName); this.uncommittedOutEdgeLabels.put(this.name + "." + EDGE_PREFIX + edgeLabelName, edgeLabel); this.getTopology().fire(edgeLabel, "", TopologyChangeAction.CREATE); edgeLabel = internalEnsureEdgeTableExists(edgeLabelOptional.get(), outVertexLabel, inVertexLabel, columns); edgeLabel = internalEnsureEdgeTableExists(edgeLabelOptional.get(), outVertexLabel, inVertexLabel, columns);
for (JsonNode uncommittedOutEdgeLabel : uncommittedOutEdgeLabels) { String schemaName = uncommittedOutEdgeLabel.get("schema").asText(); Preconditions.checkState(schemaName.equals(getSchema().getName()), "out edges must be for the same schema that the edge specifies"); String edgeLabelName = uncommittedOutEdgeLabel.get("label").asText(); Optional<EdgeLabel> edgeLabelOptional = this.schema.getEdgeLabel(edgeLabelName); EdgeLabel edgeLabel; if (!edgeLabelOptional.isPresent()) { 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); this.getSchema().getTopology().addToAllTables(getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), edgeLabel.getPropertyTypeMap()); this.getSchema().addToAllEdgeCache(edgeLabel); this.getSchema().getTopology().addOutForeignKeysToVertexLabel(this, edgeLabel); ForeignKey foreignKey; if (this.hasIDPrimaryKey()) { this.getSchema().getTopology().addToEdgeForeignKeyCache( this.getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), foreignKey ); this.getSchema().getTopology().fire(edgeLabel, "", TopologyChangeAction.CREATE); this.getSchema().getTopology().removeFromEdgeForeignKeyCache( lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(),
Preconditions.checkState(!this.isSqlgSchema(), "createPartitionedEdgeLabel may not be called for \"%s\"", SQLG_SCHEMA); Preconditions.checkState(!getEdgeLabel(edgeLabelName).isPresent(), "BUG: Edge \"%s\" already exists!", edgeLabelName); this.getName(), EDGE_PREFIX + edgeLabelName, foreignKeyOut,
Optional<EdgeLabel> edgeLabelOptional = this.getEdgeLabel(edgeLabelName); if (!edgeLabelOptional.isPresent()) { this.topology.lock(); edgeLabelOptional = this.getEdgeLabel(edgeLabelName); if (!edgeLabelOptional.isPresent()) { edgeLabel = this.createPartitionedEdgeLabel( edgeLabelName, outVertexLabel, this.uncommittedRemovedEdgeLabels.remove(this.name + "." + EDGE_PREFIX + edgeLabelName); this.uncommittedOutEdgeLabels.put(this.name + "." + EDGE_PREFIX + edgeLabelName, edgeLabel); this.getTopology().fire(edgeLabel, "", TopologyChangeAction.CREATE); edgeLabel = internalEnsureEdgeTableExists(edgeLabelOptional.get(), outVertexLabel, inVertexLabel, columns); edgeLabel = internalEnsureEdgeTableExists(edgeLabelOptional.get(), outVertexLabel, inVertexLabel, columns);
String schemaName = uncommittedInEdgeLabel.get("schema").asText(); String edgeLabelName = uncommittedInEdgeLabel.get("label").asText(); Optional<Schema> schemaOptional = getSchema().getTopology().getSchema(schemaName); Preconditions.checkState(schemaOptional.isPresent(), "Schema %s must be present", schemaName); @SuppressWarnings("OptionalGetWithoutIsPresent") Optional<EdgeLabel> edgeLabelOptional = schemaOptional.get().getEdgeLabel(edgeLabelName); this.inEdgeLabels.put(schemaName + "." + edgeLabel.getLabel(), edgeLabel); edgeLabel.fromPropertyNotifyJson(uncommittedInEdgeLabel, false); this.getSchema().getTopology().addInForeignKeysToVertexLabel(this, edgeLabel); ForeignKey foreignKey; if (this.hasIDPrimaryKey()) { this.getSchema().getTopology().addToEdgeForeignKeyCache( edgeLabel.getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), foreignKey ); this.getSchema().getTopology().removeFromEdgeForeignKeyCache( lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(), foreignKey ); this.getSchema().getTopology().removeInForeignKeysFromVertexLabel(this, lbl); this.getSchema().getTopology().fire(lbl, "", TopologyChangeAction.DELETE); break; case ROLE: this.getSchema().getTopology().fire(new EdgeRole(this, lbl, Direction.IN, true), "", TopologyChangeAction.DELETE); break;
@Override void removeProperty(PropertyColumn propertyColumn, boolean preserveData) { this.getSchema().getTopology().lock(); if (!uncommittedRemovedProperties.contains(propertyColumn.getName())) { uncommittedRemovedProperties.add(propertyColumn.getName()); TopologyManager.removeVertexColumn(this.sqlgGraph, this.schema.getName(), VERTEX_PREFIX + getLabel(), propertyColumn.getName()); if (!preserveData) { removeColumn(this.schema.getName(), VERTEX_PREFIX + getLabel(), propertyColumn.getName()); } this.getSchema().getTopology().fire(propertyColumn, "", TopologyChangeAction.DELETE); } }
void addDistributionColocate(Vertex colocate) { Preconditions.checkState(this.getSchema().getTopology().isSqlWriteLockHeldByCurrentThread()); this.distributionColocateAbstractLabel = getSchema().getVertexLabel(colocate.value(SQLG_SCHEMA_VERTEX_LABEL_NAME)).orElseThrow(() -> new IllegalStateException("Distribution Co-locate vertex label %s not found", colocate.value(SQLG_SCHEMA_VERTEX_LABEL_NAME))); }
@Override AbstractLabel getAbstractLabel(Schema schema) { return schema.getVertexLabel(this.table).orElseThrow(() -> new IllegalStateException(String.format("VertexLabel %s not found.", this.table))); }
EdgeLabel edgeLabel = this.sqlgGraph.getTopology().getSchema(this.schema).orElseThrow(()-> new IllegalStateException(String.format("Schema %s not found", this.schema))).getEdgeLabel(this.table).orElseThrow(()-> new IllegalStateException(String.format("EdgeLabel %s not found", this.table))); StringBuilder sql = new StringBuilder("SELECT\n\t"); sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes("ID")); for (VertexLabel vertexLabel : edgeLabel.getOutVertexLabels()) { sql.append(", "); sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(vertexLabel.getSchema().getName() + "." + vertexLabel.getName() + Topology.OUT_VERTEX_COLUMN_END)); sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(vertexLabel.getSchema().getName() + "." + vertexLabel.getName() + Topology.IN_VERTEX_COLUMN_END));
void afterCommit() { Preconditions.checkState(this.schema.getTopology().isSqlWriteLockHeldByCurrentThread(), "VertexLabel.afterCommit must hold the write lock"); super.afterCommit(); Iterator<Map.Entry<String, EdgeLabel>> edgeLabelEntryIter = this.uncommittedOutEdgeLabels.entrySet().iterator(); this.outEdgeLabels.put(edgeLabelName, edgeLabel); edgeLabel.afterCommit(); this.getSchema().addToAllEdgeCache(edgeLabel); edgeLabelEntryIter.remove(); this.getSchema().getTopology().removeFromEdgeForeignKeyCache( lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(), foreignKey); this.getSchema().getTopology().removeOutForeignKeysFromVertexLabel(this, lbl); this.getSchema().getTopology().removeFromEdgeForeignKeyCache( lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(), foreignKey); this.getSchema().getTopology().removeInForeignKeysFromVertexLabel(this, lbl);