| package org.umlg.sqlg.test.index; |
| |
| import com.fasterxml.jackson.databind.ObjectMapper; |
| import org.apache.tinkerpop.gremlin.process.traversal.P; |
| import org.apache.tinkerpop.gremlin.structure.T; |
| import org.apache.tinkerpop.gremlin.structure.Vertex; |
| import org.junit.Assert; |
| import org.junit.Assume; |
| import org.junit.Test; |
| import org.umlg.sqlg.structure.PropertyDefinition; |
| import org.umlg.sqlg.structure.PropertyType; |
| import org.umlg.sqlg.structure.SchemaTable; |
| import org.umlg.sqlg.structure.SqlgGraph; |
| import org.umlg.sqlg.structure.topology.*; |
| import org.umlg.sqlg.test.BaseTest; |
| |
| import java.sql.Connection; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.util.*; |
| |
| |
| |
| |
| |
| @SuppressWarnings("DuplicatedCode") |
| public class TestIndex extends BaseTest { |
| |
| @Test |
| public void testIndexViaTopology() { |
| Assume.assumeTrue(this.sqlgGraph.getSqlDialect().supportsTransactionalSchema()); |
| this.sqlgGraph.traversal().V().hasLabel("Person").values(T.id.getAccessor()); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "john"); |
| } |
| this.sqlgGraph.tx().commit(); |
| Optional<VertexLabel> personVertexOptional = this.sqlgGraph.getTopology().getVertexLabel(this.sqlgGraph.getSqlDialect().getPublicSchema(), "Person"); |
| Assert.assertTrue(personVertexOptional.isPresent()); |
| Optional<PropertyColumn> namePropertyOptional = personVertexOptional.get().getProperty("name"); |
| Assert.assertTrue(namePropertyOptional.isPresent()); |
| Optional<Index> indexOptional = personVertexOptional.get().getIndex("name"); |
| Assert.assertFalse(indexOptional.isPresent()); |
| |
| this.sqlgGraph.tx().rollback(); |
| |
| indexOptional = personVertexOptional.get().getIndex("name"); |
| Assert.assertFalse(indexOptional.isPresent()); |
| |
| Index index = personVertexOptional.get().ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(namePropertyOptional.get())); |
| this.sqlgGraph.tx().commit(); |
| Assert.assertSame(index.getIndexType(), IndexType.NON_UNIQUE); |
| |
| |
| Connection conn = this.sqlgGraph.tx().getConnection(); |
| try (Statement statement = conn.createStatement()) { |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"V_Person\" a WHERE a.\"name\" = 'john'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| System.out.println(result); |
| Assert.assertTrue(result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| } |
| } catch (SQLException e) { |
| Assert.fail(e.getMessage()); |
| } |
| this.sqlgGraph.tx().rollback(); |
| } |
| |
| @Test |
| public void testUniqueIndexViaTopolgy() { |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "john"); |
| this.sqlgGraph.tx().commit(); |
| Optional<VertexLabel> personVertexLabelOptional = this.sqlgGraph.getTopology().getVertexLabel(this.sqlgGraph.getSqlDialect().getPublicSchema(), "Person"); |
| Assert.assertTrue(personVertexLabelOptional.isPresent()); |
| Optional<PropertyColumn> propertyOptional = personVertexLabelOptional.get().getProperty("name"); |
| Assert.assertTrue(propertyOptional.isPresent()); |
| |
| personVertexLabelOptional.get().ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(propertyOptional.get())); |
| this.sqlgGraph.tx().commit(); |
| try { |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "john"); |
| Assert.fail("Unique index did not work."); |
| } catch (RuntimeException ignored) { |
| |
| } |
| this.sqlgGraph.tx().rollback(); |
| } |
| |
| @Test |
| public void testIndexOnInteger() { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| put("age", PropertyDefinition.of(PropertyType.INTEGER)); |
| }}); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, new ArrayList<>(vertexLabel.getProperties().values())); |
| |
| this.sqlgGraph.tx().commit(); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "john" + i, "age", i); |
| } |
| this.sqlgGraph.tx().commit(); |
| |
| Connection conn = this.sqlgGraph.tx().getConnection(); |
| try (Statement statement = conn.createStatement()) { |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"V_Person\" a WHERE a.\"name\" = 'john50'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| System.out.println(result); |
| Assert.assertTrue(result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| } |
| } catch (SQLException e) { |
| Assert.fail(e.getMessage()); |
| } |
| this.sqlgGraph.tx().rollback(); |
| } |
| |
| @Test |
| public void testIndexOnVertex2() throws SQLException { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new HashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, new ArrayList<>(vertexLabel.getProperties().values())); |
| this.sqlgGraph.tx().commit(); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "john" + i); |
| } |
| this.sqlgGraph.tx().commit(); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "Person").has("name", "john50").count().next(), 0); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "Person").has("name", P.eq("john50")).count().next().intValue()); |
| |
| |
| Connection conn = this.sqlgGraph.tx().getConnection(); |
| Statement statement = conn.createStatement(); |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"V_Person\" a WHERE a.\"name\" = 'john50'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| Assert.assertTrue(result, result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| } |
| this.sqlgGraph.tx().rollback(); |
| } |
| |
| @Test |
| public void testIndexOnVertex() throws SQLException { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name1", PropertyDefinition.of(PropertyType.STRING)); |
| put("name2", PropertyDefinition.of(PropertyType.STRING)); |
| put("name3", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| PropertyColumn name1 = vertexLabel.getProperty("name1").orElseThrow(IllegalStateException::new); |
| PropertyColumn name2 = vertexLabel.getProperty("name2").orElseThrow(IllegalStateException::new); |
| PropertyColumn name3 = vertexLabel.getProperty("name3").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Arrays.asList(name1, name2, name3)); |
| |
| this.sqlgGraph.tx().commit(); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "Person", "name1", "john" + i, "name2", "tom" + i, "name3", "piet" + i); |
| } |
| this.sqlgGraph.tx().commit(); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "Person").has("name1", "john50").count().next(), 0); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "Person").has("name1", P.eq("john50")).count().next().intValue()); |
| |
| |
| Connection conn = this.sqlgGraph.tx().getConnection(); |
| Statement statement = conn.createStatement(); |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"V_Person\" a WHERE a.\"name1\" = 'john50'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| Assert.assertTrue(result, result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| } |
| this.sqlgGraph.tx().rollback(); |
| } |
| |
| @Test |
| public void testIndexOnVertex1() throws SQLException { |
| |
| Assume.assumeTrue(this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")); |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name1", PropertyDefinition.of(PropertyType.STRING)); |
| put("name2", PropertyDefinition.of(PropertyType.STRING)); |
| put("name3", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| PropertyColumn name1 = vertexLabel.getProperty("name1").orElseThrow(IllegalStateException::new); |
| PropertyColumn name2 = vertexLabel.getProperty("name2").orElseThrow(IllegalStateException::new); |
| PropertyColumn name3 = vertexLabel.getProperty("name3").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Arrays.asList(name1, name2, name3)); |
| |
| this.sqlgGraph.tx().commit(); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "Person", "name1", "john" + i, "name2", "tom" + i, "name3", "piet" + i); |
| } |
| this.sqlgGraph.tx().commit(); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "Person").has("name1", "john50").count().next(), 0); |
| Connection conn = this.sqlgGraph.getConnection(); |
| Statement statement = conn.createStatement(); |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"V_Person\" a WHERE a.\"name1\" = 'john50'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| Assert.assertTrue(result, result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| conn.close(); |
| } |
| } |
| |
| @Test |
| public void testIndexOnVertex1Schema() throws SQLException { |
| |
| Assume.assumeTrue(this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")); |
| |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureSchemaExist("MySchema").ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name1", PropertyDefinition.of(PropertyType.STRING)); |
| put("name2", PropertyDefinition.of(PropertyType.STRING)); |
| put("name3", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| PropertyColumn name1 = vertexLabel.getProperty("name1").orElseThrow(IllegalStateException::new); |
| PropertyColumn name2 = vertexLabel.getProperty("name2").orElseThrow(IllegalStateException::new); |
| PropertyColumn name3 = vertexLabel.getProperty("name3").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Arrays.asList(name1, name2, name3)); |
| |
| this.sqlgGraph.tx().commit(); |
| for (int i = 0; i < 5000; i++) { |
| this.sqlgGraph.addVertex(T.label, "MySchema.Person", "name1", "john" + i, "name2", "tom" + i, "name3", "piet" + i); |
| } |
| this.sqlgGraph.tx().commit(); |
| Assert.assertEquals(1, this.sqlgGraph.traversal().V().has(T.label, "MySchema.Person").has("name1", "john50").count().next(), 0); |
| Connection conn = this.sqlgGraph.getConnection(); |
| Statement statement = conn.createStatement(); |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"MySchema\".\"V_Person\" a WHERE a.\"name1\" = 'john50'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| Assert.assertTrue(result, result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| conn.close(); |
| } |
| } |
| |
| @Test |
| public void testIndexExist() { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| PropertyColumn name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| this.sqlgGraph.tx().commit(); |
| |
| this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| |
| this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| this.sqlgGraph.tx().commit(); |
| |
| this.sqlgGraph.close(); |
| this.sqlgGraph = SqlgGraph.open(configuration); |
| this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| } |
| |
| @Test |
| public void testIndexExistSchema() { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().ensureSchemaExist("MySchema").ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| PropertyColumn name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| |
| vertexLabel = this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| |
| this.sqlgGraph.tx().commit(); |
| |
| vertexLabel = this.sqlgGraph.getTopology().ensureSchemaExist("MySchema").ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| |
| vertexLabel = this.sqlgGraph.getTopology().ensureSchemaExist("MySchema").ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| this.sqlgGraph.tx().commit(); |
| |
| this.sqlgGraph.close(); |
| this.sqlgGraph = SqlgGraph.open(configuration); |
| vertexLabel = this.sqlgGraph.getTopology().ensureSchemaExist("MySchema").ensureVertexLabelExist("Person", new LinkedHashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| }}); |
| name = vertexLabel.getProperty("name").orElseThrow(IllegalStateException::new); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(name)); |
| } |
| |
| @Test |
| public void testIndexOnEdge() throws Exception { |
| Map<String, PropertyDefinition> columns = new HashMap<>(); |
| columns.put("name", PropertyDefinition.of(PropertyType.STRING)); |
| |
| String publicSchema = this.sqlgGraph.getSqlDialect().getPublicSchema(); |
| this.sqlgGraph.getTopology().ensureVertexLabelExist("Person", columns); |
| this.sqlgGraph.getTopology().ensureVertexLabelExist("Address", columns); |
| this.sqlgGraph.getTopology().ensureEdgeLabelExist("person_address", SchemaTable.of(publicSchema, "Person"), SchemaTable.of(publicSchema, "Address"), columns); |
| EdgeLabel edgeLabel = this.sqlgGraph.getTopology().getEdgeLabel(publicSchema, "person_address").orElseThrow(IllegalStateException::new); |
| edgeLabel.ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(edgeLabel.getProperty("name").orElseThrow(IllegalStateException::new))); |
| this.sqlgGraph.tx().commit(); |
| |
| for (int i = 0; i < 5000; i++) { |
| Vertex person1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "john"); |
| Vertex address1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "john"); |
| person1.addEdge("person_address", address1, "name", "address" + i); |
| } |
| this.sqlgGraph.tx().commit(); |
| |
| if (this.sqlgGraph.getSqlDialect().getClass().getSimpleName().contains("Postgres")) { |
| Connection conn = this.sqlgGraph.getConnection(); |
| Statement statement = conn.createStatement(); |
| ResultSet rs = statement.executeQuery("explain analyze SELECT * FROM \"public\".\"E_person_address\" a WHERE a.\"name\" = 'address1001'"); |
| Assert.assertTrue(rs.next()); |
| String result = rs.getString(1); |
| Assert.assertTrue(result, result.contains("Index Scan") || result.contains("Bitmap Heap Scan")); |
| statement.close(); |
| conn.close(); |
| } |
| |
| this.sqlgGraph.close(); |
| this.sqlgGraph = SqlgGraph.open(configuration); |
| edgeLabel = this.sqlgGraph.getTopology().getEdgeLabel(publicSchema, "person_address").orElseThrow(IllegalStateException::new); |
| edgeLabel.ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(edgeLabel.getProperty("name").orElseThrow(IllegalStateException::new))); |
| |
| |
| } |
| |
| @Test |
| public void testIndexOnEdgeAcrossSchemas() { |
| Vertex aa1 = this.sqlgGraph.addVertex(T.label, "A.A", "name", "aa"); |
| Vertex bb1 = this.sqlgGraph.addVertex(T.label, "B.B", "name", "bb"); |
| Vertex cc1 = this.sqlgGraph.addVertex(T.label, "C.C", "name", "cc"); |
| aa1.addEdge("test", bb1, "name", "ola"); |
| bb1.addEdge("test", cc1, "name", "ola"); |
| this.sqlgGraph.tx().commit(); |
| |
| EdgeLabel edgeLabel = this.sqlgGraph.getTopology().getEdgeLabel("A", "test").orElseThrow(IllegalStateException::new); |
| edgeLabel.ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(edgeLabel.getProperty("name").orElseThrow(IllegalStateException::new))); |
| this.sqlgGraph.tx().commit(); |
| |
| Assert.assertEquals(IndexType.UNIQUE, edgeLabel.getIndex(this.sqlgGraph.getSqlDialect().indexName(SchemaTable.of("A", "test"), Topology.EDGE_PREFIX, Collections.singletonList("name"))).orElseThrow(IllegalStateException::new).getIndexType()); |
| Assert.assertFalse(edgeLabel.getIndex(this.sqlgGraph.getSqlDialect().indexName(SchemaTable.of("B", "test"), Topology.EDGE_PREFIX, Collections.singletonList("name"))).isPresent()); |
| |
| try { |
| aa1.addEdge("test", bb1, "name", "ola"); |
| Assert.fail("Unique constraint should prevent this from happening"); |
| } catch (Exception e) { |
| |
| } |
| this.sqlgGraph.tx().rollback(); |
| |
| |
| bb1.addEdge("test", cc1, "name", "ola"); |
| this.sqlgGraph.tx().commit(); |
| } |
| |
| @Test |
| public void testIndexTypeFromJSON() throws Exception { |
| IndexType it1 = IndexType.fromNotifyJson(new ObjectMapper().readTree("{\"name\":\"UNIQUE\"}")); |
| Assert.assertEquals(IndexType.UNIQUE, it1); |
| IndexType it2 = IndexType.fromNotifyJson(new ObjectMapper().readTree("\"UNIQUE\"")); |
| Assert.assertEquals(IndexType.UNIQUE, it2); |
| |
| it1 = IndexType.fromNotifyJson(new ObjectMapper().readTree("{\"name\":\"NON_UNIQUE\"}")); |
| Assert.assertEquals(IndexType.NON_UNIQUE, it1); |
| it2 = IndexType.fromNotifyJson(new ObjectMapper().readTree("\"NON_UNIQUE\"")); |
| Assert.assertEquals(IndexType.NON_UNIQUE, it2); |
| |
| } |
| |
| @Test |
| public void testLongIndexName() { |
| String i1 = buildLongIndex(sqlgGraph); |
| String i2 = buildLongIndex(sqlgGraph); |
| Assert.assertEquals(i1, i2); |
| sqlgGraph.close(); |
| sqlgGraph = SqlgGraph.open(getConfigurationClone()); |
| String i3 = buildLongIndex(sqlgGraph); |
| Assert.assertEquals(i1, i3); |
| } |
| |
| private String buildLongIndex(SqlgGraph g) { |
| Schema sch = g.getTopology().ensureSchemaExist("longIndex"); |
| Map<String, PropertyDefinition> columns = new HashMap<>(); |
| columns.put("longpropertyname1", PropertyDefinition.of(PropertyType.STRING)); |
| columns.put("longpropertyname2", PropertyDefinition.of(PropertyType.STRING)); |
| columns.put("longpropertyname3", PropertyDefinition.of(PropertyType.STRING)); |
| VertexLabel label = sch.ensureVertexLabelExist("LongIndex", columns); |
| List<PropertyColumn> properties = Arrays.asList( |
| label.getProperty("longpropertyname1").orElseThrow(IllegalStateException::new) |
| , label.getProperty("longpropertyname2").orElseThrow(IllegalStateException::new) |
| , label.getProperty("longpropertyname3").orElseThrow(IllegalStateException::new)); |
| Index idx = label.ensureIndexExists(IndexType.NON_UNIQUE, properties); |
| |
| g.tx().commit(); |
| return idx.getName(); |
| } |
| |
| @Test |
| public void testShortIndexName() { |
| String i1 = buildShortIndex(sqlgGraph); |
| String i2 = buildShortIndex(sqlgGraph); |
| Assert.assertEquals(i1, i2); |
| sqlgGraph.close(); |
| sqlgGraph = SqlgGraph.open(getConfigurationClone()); |
| String i3 = buildShortIndex(sqlgGraph); |
| Assert.assertEquals(i1, i3); |
| } |
| |
| private String buildShortIndex(SqlgGraph g) { |
| Schema sch = g.getTopology().ensureSchemaExist("longIndex"); |
| Map<String, PropertyDefinition> columns = new HashMap<>(); |
| columns.put("short1", PropertyDefinition.of(PropertyType.STRING)); |
| columns.put("short2", PropertyDefinition.of(PropertyType.STRING)); |
| columns.put("short3", PropertyDefinition.of(PropertyType.STRING)); |
| VertexLabel label = sch.ensureVertexLabelExist("LongIndex", columns); |
| List<PropertyColumn> properties = Arrays.asList( |
| label.getProperty("short1").orElseThrow(IllegalStateException::new) |
| , label.getProperty("short2").orElseThrow(IllegalStateException::new) |
| , label.getProperty("short3").orElseThrow(IllegalStateException::new)); |
| Index idx = label.ensureIndexExists(IndexType.NON_UNIQUE, properties); |
| |
| g.tx().commit(); |
| return idx.getName(); |
| } |
| |
| @Test |
| public void testMultipleIndexesOnLabel() { |
| |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist( |
| "Person", |
| new HashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| put("surname", PropertyDefinition.of(PropertyType.STRING)); |
| }} |
| ); |
| PropertyColumn propertyColumn = vertexLabel.getProperty("name").orElseThrow(() -> new RuntimeException("its a bug")); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(propertyColumn)); |
| this.sqlgGraph.tx().commit(); |
| |
| propertyColumn = vertexLabel.getProperty("surname").orElseThrow(() -> new RuntimeException("its a bug")); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(propertyColumn)); |
| this.sqlgGraph.tx().commit(); |
| |
| this.sqlgGraph.addVertex(T.label, "Person", "name", "John", "surname", "Smith"); |
| this.sqlgGraph.tx().commit(); |
| |
| this.sqlgGraph.close(); |
| this.sqlgGraph = SqlgGraph.open(configuration); |
| Optional<VertexLabel> vertexLabelOptional = this.sqlgGraph.getTopology().getPublicSchema().getVertexLabel("Person"); |
| Assert.assertTrue(vertexLabelOptional.isPresent()); |
| Map<String, Index> indexMap = vertexLabelOptional.get().getIndexes(); |
| Assert.assertEquals(2, indexMap.size()); |
| } |
| |
| @Test |
| public void testDropIndex() { |
| VertexLabel vertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist( |
| "Person", |
| new HashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| put("surname", PropertyDefinition.of(PropertyType.STRING)); |
| }} |
| ); |
| PropertyColumn propertyColumn = vertexLabel.getProperty("name").orElseThrow(() -> new RuntimeException("its a bug")); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(propertyColumn)); |
| this.sqlgGraph.tx().commit(); |
| |
| Optional<VertexLabel> vertexLabelOptional = this.sqlgGraph.getTopology().getPublicSchema().getVertexLabel("Person"); |
| Assert.assertTrue(vertexLabelOptional.isPresent()); |
| VertexLabel personVertexLabel = vertexLabelOptional.get(); |
| Assert.assertEquals(2, personVertexLabel.getProperties().size()); |
| Map<String, Index> indexMap = personVertexLabel.getIndexes(); |
| Assert.assertEquals(1, indexMap.size()); |
| new ArrayList<>(indexMap.values()).get(0).remove(); |
| this.sqlgGraph.tx().commit(); |
| |
| vertexLabelOptional = this.sqlgGraph.getTopology().getPublicSchema().getVertexLabel("Person"); |
| Assert.assertTrue(vertexLabelOptional.isPresent()); |
| personVertexLabel = vertexLabelOptional.get(); |
| Assert.assertEquals(2, personVertexLabel.getProperties().size()); |
| indexMap = personVertexLabel.getIndexes(); |
| Assert.assertTrue(indexMap.isEmpty()); |
| |
| |
| vertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist( |
| "Person", |
| new HashMap<>() {{ |
| put("name", PropertyDefinition.of(PropertyType.STRING)); |
| put("surname", PropertyDefinition.of(PropertyType.STRING)); |
| }} |
| ); |
| propertyColumn = vertexLabel.getProperty("name").orElseThrow(() -> new RuntimeException("its a bug")); |
| vertexLabel.ensureIndexExists(IndexType.NON_UNIQUE, Collections.singletonList(propertyColumn)); |
| this.sqlgGraph.tx().commit(); |
| |
| vertexLabelOptional = this.sqlgGraph.getTopology().getPublicSchema().getVertexLabel("Person"); |
| Assert.assertTrue(vertexLabelOptional.isPresent()); |
| personVertexLabel = vertexLabelOptional.get(); |
| Assert.assertEquals(2, personVertexLabel.getProperties().size()); |
| indexMap = personVertexLabel.getIndexes(); |
| Assert.assertEquals(1, indexMap.size()); |
| |
| } |
| } |