org.umlg.sqlg.test.schema.TestLoadSchemaViaNotify Maven / Gradle / Ivy
package org.umlg.sqlg.test.schema;
import org.apache.commons.collections4.IteratorUtils;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.lang3.tuple.Triple;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Edge;
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.BeforeClass;
import org.junit.Test;
import org.umlg.sqlg.structure.*;
import org.umlg.sqlg.structure.topology.*;
import org.umlg.sqlg.test.BaseTest;
import org.umlg.sqlg.test.topology.TestTopologyChangeListener;
import java.net.URL;
import java.util.*;
/**
* Date: 2014/11/03
* Time: 6:22 PM
*/
public class TestLoadSchemaViaNotify extends BaseTest {
@BeforeClass
public static void beforeClass() {
URL sqlProperties = Thread.currentThread().getContextClassLoader().getResource("sqlg.properties");
try {
configuration = new PropertiesConfiguration(sqlProperties);
Assume.assumeTrue(isPostgres());
configuration.addProperty("distributed", true);
if (!configuration.containsKey("jdbc.url"))
throw new IllegalArgumentException(String.format("SqlGraph configuration requires that the %s be set", "jdbc.url"));
} catch (ConfigurationException e) {
throw new RuntimeException(e);
}
}
@Test
public void testLoadSchemaForeignKeyOutSchemaToPublic() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Vertex person = this.sqlgGraph.addVertex(T.label, "Mammal.Person", "name", "a");
Vertex car = this.sqlgGraph.addVertex(T.label, "Car", "name", "a");
person.addEdge("drives", car);
this.sqlgGraph.tx().commit();
Thread.sleep(1_000);
car = sqlgGraph1.traversal().V(car.id()).next();
Iterator verticesIter = car.vertices(Direction.IN, "drives");
int size = IteratorUtils.toList(verticesIter).size();
Assert.assertEquals(1, size);
}
}
@Test
public void testLoadSchemaForeignKeyInSchemaToPublic() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Vertex person = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
Vertex car = this.sqlgGraph.addVertex(T.label, "Fleet.Car", "name", "a");
person.addEdge("drives", car);
this.sqlgGraph.tx().commit();
Thread.sleep(1_000);
car = sqlgGraph1.traversal().V(car.id()).next();
Iterator verticesIter = car.vertices(Direction.IN, "drives");
int size = IteratorUtils.toList(verticesIter).size();
Assert.assertEquals(1, size);
}
}
@Test
public void testLazyLoadTableViaVertexHas() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
//add a vertex in the old, the new should only see it after a commit
this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
this.sqlgGraph.tx().commit();
//postgresql notify only happens after the commit, need to wait a bit.
Thread.sleep(1000);
Assert.assertEquals(1, sqlgGraph1.traversal().V().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Person").count().next().intValue());
Assert.assertEquals("a", sqlgGraph1.traversal().V().has(T.label, "Person").next().value("name"));
sqlgGraph1.tx().rollback();
}
}
@Test
public void testLazyLoadTableViaVertexHasWithKey() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
//add a vertex in the old, the new should only see it after a commit
this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
this.sqlgGraph.tx().commit();
Thread.sleep(1000);
Assert.assertEquals(1, sqlgGraph1.traversal().V().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Person").has("name", "a").count().next().intValue());
sqlgGraph1.tx().rollback();
}
}
@Test
public void testLazyLoadTableViaVertexHasWithKeyMissingColumn() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
//add a vertex in the old, the new should only see it after a commit
Vertex v1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
this.sqlgGraph.tx().commit();
Thread.sleep(1000);
Assert.assertEquals(1, sqlgGraph1.traversal().V().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Person").has("name", "a").count().next().intValue());
Vertex v11 = sqlgGraph1.traversal().V().has(T.label, "Person").has("name", "a").next();
Assert.assertFalse(v11.property("surname").isPresent());
//the next alter will lock if this transaction is still active
sqlgGraph1.tx().rollback();
//add column in one
v1.property("surname", "bbb");
this.sqlgGraph.tx().commit();
Thread.sleep(1_000);
Vertex v12 = sqlgGraph1.addVertex(T.label, "Person", "surname", "ccc");
Assert.assertEquals("ccc", v12.value("surname"));
sqlgGraph1.tx().rollback();
}
}
//Fails via maven for Hsqldb
@Test
public void testLazyLoadTableViaEdgeCreation() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
//add a vertex in the old, the new should only see it after a commit
Vertex v1 = null;
Vertex v2 = null;
for (int i = 0; i < 3; i++) {
try {
v1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
v2 = this.sqlgGraph.addVertex(T.label, "Person", "name", "b");
this.sqlgGraph.tx().commit();
break;
} catch (Exception e) {
//retry
this.sqlgGraph.tx().rollback();
}
}
Thread.sleep(1000);
Vertex v11 = null;
Vertex v12 = null;
for (int i = 0; i < 3; i++) {
try {
v11 = sqlgGraph1.addVertex(T.label, "Person", "surname", "ccc");
v12 = sqlgGraph1.addVertex(T.label, "Person", "surname", "ccc");
sqlgGraph1.tx().commit();
} catch (Exception e) {
sqlgGraph1.tx().rollback();
}
}
Assert.assertNotNull(v1);
for (int i = 0; i < 3; i++) {
try {
v1.addEdge("friend", v2);
this.sqlgGraph.tx().commit();
} catch (Exception e) {
this.sqlgGraph.tx().rollback();
}
}
Thread.sleep(1000);
Assert.assertNotNull(v11);
v11.addEdge("friend", v12);
sqlgGraph1.tx().commit();
Assert.assertEquals(1, vertexTraversal(sqlgGraph1, v11).out("friend").count().next().intValue());
sqlgGraph1.tx().rollback();
}
}
@Test
public void testLazyLoadTableViaEdgesHas() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
//add a vertex in the old, the new should only see it after a commit
Vertex v1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
Vertex v2 = this.sqlgGraph.addVertex(T.label, "Person", "name", "b");
v1.addEdge("friend", v2);
this.sqlgGraph.tx().commit();
Thread.sleep(1000);
Assert.assertEquals(1, this.sqlgGraph.traversal().E().has(T.label, "friend").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().has(T.label, "friend").count().next().intValue());
Assert.assertEquals(2, sqlgGraph1.traversal().V().has(T.label, "Person").count().next().intValue());
sqlgGraph1.tx().rollback();
}
}
@Test
public void testLoadSchemaRemembersUncommittedSchemas() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Vertex v1 = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
Vertex v2 = this.sqlgGraph.addVertex(T.label, "Person", "name", "b");
v1.addEdge("friend", v2);
this.sqlgGraph.tx().commit();
this.sqlgGraph.addVertex(T.label, "Animal", "name", "b");
this.sqlgGraph.addVertex(T.label, "Car", "name", "b");
Assert.assertEquals(1, this.sqlgGraph.traversal().E().has(T.label, "friend").count().next().intValue());
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1000);
Assert.assertEquals(1, sqlgGraph1.traversal().E().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().has(T.label, "friend").count().next().intValue());
Assert.assertEquals(2, sqlgGraph1.traversal().V().has(T.label, "Person").count().next().intValue());
sqlgGraph1.tx().rollback();
}
}
@Test
public void testLoadSchemaEdge() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Vertex personVertex = this.sqlgGraph.addVertex(T.label, "Person", "name", "a");
Vertex dogVertex = this.sqlgGraph.addVertex(T.label, "Dog", "name", "b");
Edge petEdge = personVertex.addEdge("pet", dogVertex, "test", "this");
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
Assert.assertEquals(1, sqlgGraph1.traversal().E().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().has(T.label, "pet").count().next().intValue());
Assert.assertEquals("this", sqlgGraph1.traversal().E().has(T.label, "pet").next().value("test"));
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Person").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Dog").count().next().intValue());
Assert.assertEquals(dogVertex, sqlgGraph1.traversal().V(personVertex.id()).out("pet").next());
Assert.assertEquals(personVertex, sqlgGraph1.traversal().V(dogVertex.id()).in("pet").next());
Assert.assertEquals("a", sqlgGraph1.traversal().V(personVertex.id()).next().value("name"));
Assert.assertEquals("b", sqlgGraph1.traversal().V(dogVertex.id()).next().value("name"));
sqlgGraph1.tx().rollback();
//add a property to the vertex
personVertex.property("surname", "AAA");
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
Assert.assertEquals("AAA", sqlgGraph1.traversal().V(personVertex.id()).next().value("surname"));
sqlgGraph1.tx().rollback();
//add property to the edge
petEdge.property("edgeProperty1", "a");
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
Assert.assertEquals("a", sqlgGraph1.traversal().E(petEdge.id()).next().value("edgeProperty1"));
sqlgGraph1.tx().rollback();
//add an edge
Vertex addressVertex = this.sqlgGraph.addVertex(T.label, "Address", "name", "1 Nowhere");
personVertex.addEdge("homeAddress", addressVertex);
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
Assert.assertEquals(2, sqlgGraph1.traversal().E().count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().has(T.label, "pet").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().E().has(T.label, "homeAddress").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Person").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Dog").count().next().intValue());
Assert.assertEquals(1, sqlgGraph1.traversal().V().has(T.label, "Address").count().next().intValue());
}
}
@SuppressWarnings("OptionalGetWithoutIsPresent")
@Test
public void loadIndex() throws Exception {
//Create a new sqlgGraph
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Map properties = new HashMap<>();
properties.put("name", PropertyType.STRING);
VertexLabel vertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist("A", properties);
vertexLabel.ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(vertexLabel.getProperty("name").get()));
this.sqlgGraph.tx().commit();
Optional index = this.sqlgGraph.getTopology().getPublicSchema()
.getVertexLabel("A").get()
.getIndex(this.sqlgGraph.getSqlDialect()
.indexName(
SchemaTable.of(this.sqlgGraph.getSqlDialect().getPublicSchema(), "A"),
Topology.VERTEX_PREFIX,
Collections.singletonList("name")));
Assert.assertTrue(index.isPresent());
//allow time for notification to happen
Thread.sleep(1_000);
index = sqlgGraph1.getTopology().getPublicSchema()
.getVertexLabel("A").get()
.getIndex(this.sqlgGraph.getSqlDialect()
.indexName(
SchemaTable.of(this.sqlgGraph.getSqlDialect().getPublicSchema(), "A"),
Topology.VERTEX_PREFIX,
Collections.singletonList("name")));
Assert.assertTrue(index.isPresent());
}
}
@Test
public void testGlobalUniqueIndexViaNotify() throws Exception {
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Map properties = new HashMap<>();
properties.put("name1", PropertyType.STRING);
properties.put("name2", PropertyType.STRING);
VertexLabel aVertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist("A", properties);
properties.clear();
properties.put("name3", PropertyType.STRING);
properties.put("name4", PropertyType.STRING);
VertexLabel bVertexLabel = this.sqlgGraph.getTopology().getPublicSchema().ensureVertexLabelExist("B", properties);
properties.clear();
properties.put("name5", PropertyType.STRING);
properties.put("name6", PropertyType.STRING);
EdgeLabel edgeLabel = aVertexLabel.ensureEdgeLabelExist("ab", bVertexLabel, properties);
Set globalUniqueIndexPropertyColumns = new HashSet<>();
globalUniqueIndexPropertyColumns.addAll(new HashSet<>(aVertexLabel.getProperties().values()));
globalUniqueIndexPropertyColumns.addAll(new HashSet<>(bVertexLabel.getProperties().values()));
globalUniqueIndexPropertyColumns.addAll(new HashSet<>(edgeLabel.getProperties().values()));
this.sqlgGraph.getTopology().ensureGlobalUniqueIndexExist(globalUniqueIndexPropertyColumns);
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
Assert.assertEquals(1, sqlgGraph1.getTopology().getGlobalUniqueIndexes().size());
sqlgGraph1.addVertex(T.label, "A", "name1", "123");
sqlgGraph1.tx().commit();
try {
sqlgGraph.addVertex(T.label, "A", "name1", "123");
Assert.fail("GlobalUniqueIndex should prevent this from happening");
} catch (Exception e) {
//swallow
}
}
}
@Test
public void testViaNotifyIsCommitted() throws Exception {
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
Vertex a1 = this.sqlgGraph.addVertex(T.label, "A.A", "name", "halo");
Vertex b1 = this.sqlgGraph.addVertex(T.label, "B.B", "name", "halo");
a1.addEdge("ab", b1, "name", "asd");
this.sqlgGraph.getTopology().getSchema("A").orElseThrow().getVertexLabel("A")
.ifPresent(v -> v.ensureIndexExists(IndexType.UNIQUE, Collections.singletonList(v.getProperty("name").orElseThrow())));
Schema aSchema = this.sqlgGraph.getTopology().getSchema("A").orElseThrow();
Assert.assertTrue(aSchema.isUncommitted());
VertexLabel vertexLabel = aSchema.getVertexLabel("A").orElseThrow();
Assert.assertTrue(vertexLabel.isUncommitted());
PropertyColumn namePropertyColumn = vertexLabel.getProperty("name").orElseThrow();
Assert.assertTrue(namePropertyColumn.isUncommitted());
String indexName = this.sqlgGraph.getSqlDialect().indexName(SchemaTable.of("A", "A"), Topology.VERTEX_PREFIX, Collections.singletonList("name"));
Index index = vertexLabel.getIndex(indexName).orElseThrow();
Assert.assertTrue(index.isUncommitted());
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
aSchema = sqlgGraph1.getTopology().getSchema("A").orElseThrow();
Assert.assertTrue(aSchema.isCommitted());
vertexLabel = aSchema.getVertexLabel("A").orElseThrow();
Assert.assertTrue(vertexLabel.isCommitted());
namePropertyColumn = vertexLabel.getProperty("name").orElseThrow();
Assert.assertTrue(namePropertyColumn.isCommitted());
indexName = sqlgGraph1.getSqlDialect().indexName(SchemaTable.of("A", "A"), Topology.VERTEX_PREFIX, Collections.singletonList("name"));
index = vertexLabel.getIndex(indexName).orElseThrow();
Assert.assertTrue(index.isCommitted());
}
}
@Test
public void testDistributedTopologyListener() throws Exception {
try (SqlgGraph sqlgGraph1 = SqlgGraph.open(configuration)) {
List> topologyListenerTriple = new ArrayList<>();
TestTopologyChangeListener.TopologyListenerTest topologyListenerTest = new TestTopologyChangeListener.TopologyListenerTest(topologyListenerTriple);
sqlgGraph1.getTopology().registerListener(topologyListenerTest);
Vertex a1 = this.sqlgGraph.addVertex(T.label, "A.A", "name", "asda");
Vertex a2 = this.sqlgGraph.addVertex(T.label, "A.A", "name", "asdasd");
Edge e1 = a1.addEdge("aa", a2);
a1.property("surname", "asdasd");
e1.property("special", "");
Vertex b1 = this.sqlgGraph.addVertex(T.label, "A.B", "name", "asdasd");
a1.addEdge("aa", b1);
Schema schema = this.sqlgGraph.getTopology().getSchema("A").orElseThrow();
VertexLabel aVertexLabel = schema.getVertexLabel("A").orElseThrow();
EdgeLabel edgeLabel = aVertexLabel.getOutEdgeLabel("aa").orElseThrow();
VertexLabel bVertexLabel = schema.getVertexLabel("B").orElseThrow();
Index index = aVertexLabel.ensureIndexExists(IndexType.UNIQUE, new ArrayList<>(aVertexLabel.getProperties().values()));
//This adds a schema and 2 indexes and the globalUniqueIndex, so 4 elements in all
GlobalUniqueIndex globalUniqueIndex = schema.ensureGlobalUniqueIndexExist(new HashSet<>(aVertexLabel.getProperties().values()));
this.sqlgGraph.tx().commit();
//allow time for notification to happen
Thread.sleep(1_000);
// we're not getting property notification since we get vertex label notification, these include all properties committed
Assert.assertEquals(9, topologyListenerTriple.size());
Assert.assertEquals(schema, topologyListenerTriple.get(0).getLeft());
Assert.assertEquals("", topologyListenerTriple.get(0).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(0).getRight());
Assert.assertEquals(aVertexLabel, topologyListenerTriple.get(1).getLeft());
Assert.assertEquals("", topologyListenerTriple.get(1).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(1).getRight());
Map props = ((VertexLabel) topologyListenerTriple.get(1).getLeft()).getProperties();
Assert.assertTrue(props.containsKey("name"));
Assert.assertTrue(props.containsKey("surname"));
Assert.assertEquals(index, topologyListenerTriple.get(2).getLeft());
Assert.assertEquals("", topologyListenerTriple.get(2).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(2).getRight());
Assert.assertEquals(edgeLabel, topologyListenerTriple.get(3).getLeft());
String s = topologyListenerTriple.get(3).getLeft().toString();
Assert.assertTrue(s.contains(edgeLabel.getSchema().getName()));
props = ((EdgeLabel) topologyListenerTriple.get(3).getLeft()).getProperties();
Assert.assertTrue(props.containsKey("special"));
Assert.assertEquals("", topologyListenerTriple.get(3).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(3).getRight());
Assert.assertEquals(bVertexLabel, topologyListenerTriple.get(4).getLeft());
Assert.assertEquals("", topologyListenerTriple.get(4).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(4).getRight());
Assert.assertEquals(globalUniqueIndex, topologyListenerTriple.get(5).getLeft());
Assert.assertEquals("", topologyListenerTriple.get(5).getMiddle());
Assert.assertEquals(TopologyChangeAction.CREATE, topologyListenerTriple.get(5).getRight());
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy