org.umlg.sqlg.test.gremlincompile.TestGremlinCompileE Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sqlg-test Show documentation
There is a newer version: 3.1.1
package org.umlg.sqlg.test.gremlincompile;

import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
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.BeforeClass;
import org.junit.Test;
import org.umlg.sqlg.structure.SqlgGraph;
import org.umlg.sqlg.test.BaseTest;

import java.util.List;

/**
 * Date: 2015/01/18
 * Time: 5:30 PM
 */
public class TestGremlinCompileE extends BaseTest {

    @BeforeClass
    public static void beforeClass() {
        BaseTest.beforeClass();
        if (isPostgres()) {
            configuration.addProperty("distributed", true);
        }
    }

    @Test
    public void testOutE() throws InterruptedException {
        Vertex a1 = this.sqlgGraph.addVertex(T.label, "A");
        Vertex b1 = this.sqlgGraph.addVertex(T.label, "B");
        Edge e = a1.addEdge("outB", b1);
        this.sqlgGraph.tx().commit();
        testOutE_assert(this.sqlgGraph, a1, e);
        if (this.sqlgGraph1 != null) {
            Thread.sleep(SLEEP_TIME);
            testOutE_assert(this.sqlgGraph, a1, e);
        }
    }

    private void testOutE_assert(SqlgGraph sqlgGraph, Vertex a1, Edge e) {
        DefaultGraphTraversal traversal = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, a1).outE().count();
        Assert.assertEquals(3, traversal.getSteps().size());
        Assert.assertEquals(1, traversal.next().intValue());
        Assert.assertEquals(3, traversal.getSteps().size());

        DefaultGraphTraversal traversal1 = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, a1).outE();
        Assert.assertEquals(2, traversal1.getSteps().size());
        Assert.assertEquals(e, traversal1.next());
        Assert.assertEquals(1, traversal1.getSteps().size());
    }

    @Test
    public void testInE() throws InterruptedException {
        Vertex a1 = this.sqlgGraph.addVertex(T.label, "A");
        Vertex b1 = this.sqlgGraph.addVertex(T.label, "B");
        Edge e = a1.addEdge("outB", b1);
        this.sqlgGraph.tx().commit();
        testInE_assert(this.sqlgGraph, b1, e);
        if (this.sqlgGraph1 != null) {
            Thread.sleep(SLEEP_TIME);
            testInE_assert(this.sqlgGraph1, b1, e);
        }
    }

    private void testInE_assert(SqlgGraph sqlgGraph, Vertex b1, Edge e) {
        DefaultGraphTraversal traversal = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, b1).inE().count();
        Assert.assertEquals(3, traversal.getSteps().size());
        Assert.assertEquals(1, traversal.next().intValue());
        Assert.assertEquals(3, traversal.getSteps().size());

        DefaultGraphTraversal traversal1 = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, b1).inE();
        Assert.assertEquals(2, traversal1.getSteps().size());
        Assert.assertEquals(e, traversal1.next());
        Assert.assertEquals(1, traversal1.getSteps().size());
    }

    @Test
    public void testEdgeOut() throws InterruptedException {
        Vertex a1 = this.sqlgGraph.addVertex(T.label, "A");
        Vertex b1 = this.sqlgGraph.addVertex(T.label, "B");
        Edge e = a1.addEdge("outB", b1);
        this.sqlgGraph.tx().commit();
        testEdgeOut_assert(this.sqlgGraph, a1, e);
        if (this.sqlgGraph1 != null) {
            Thread.sleep(SLEEP_TIME);
            testEdgeOut_assert(this.sqlgGraph1, a1, e);
        }
    }

    private void testEdgeOut_assert(SqlgGraph sqlgGraph, Vertex a1, Edge e) {
        DefaultGraphTraversal traversal = (DefaultGraphTraversal) edgeTraversal(sqlgGraph, e).outV();
        Assert.assertEquals(2, traversal.getSteps().size());
        Assert.assertEquals(a1, traversal.next());
        Assert.assertEquals(1, traversal.getSteps().size());
        Assert.assertEquals(1, edgeTraversal(sqlgGraph, e).outV().outE().count().next().intValue());

        DefaultGraphTraversal traversal1 = (DefaultGraphTraversal) edgeTraversal(sqlgGraph, e).outV().outE();
        Assert.assertEquals(3, traversal1.getSteps().size());
        Assert.assertEquals(e, traversal1.next());
        Assert.assertEquals(1, traversal1.getSteps().size());
    }

    @Test
    public void testOutEOut() throws InterruptedException {
        Vertex a1 = this.sqlgGraph.addVertex(T.label, "A");
        Vertex b1 = this.sqlgGraph.addVertex(T.label, "B");
        Vertex b2 = this.sqlgGraph.addVertex(T.label, "B");
        Vertex c1 = this.sqlgGraph.addVertex(T.label, "C");
        Vertex c2 = this.sqlgGraph.addVertex(T.label, "C");
        Vertex c3 = this.sqlgGraph.addVertex(T.label, "C");
        Vertex c4 = this.sqlgGraph.addVertex(T.label, "C");
        Vertex c5 = this.sqlgGraph.addVertex(T.label, "C");
        Vertex c6 = this.sqlgGraph.addVertex(T.label, "C");
        Edge e1 = a1.addEdge("outB", b1);
        Edge e2 = a1.addEdge("outB", b2);
        Edge e3 = b1.addEdge("outC", c1);
        Edge e4 = b1.addEdge("outC", c2);
        Edge e5 = b1.addEdge("outC", c3);
        Edge e6 = b1.addEdge("outC", c4);
        Edge e7 = b1.addEdge("outC", c5);
        Edge e8 = b1.addEdge("outC", c6);
        this.sqlgGraph.tx().commit();

        testOutEOut_assert(this.sqlgGraph, a1, e3, e4, e5, e6, e7, e8);
        if (this.sqlgGraph1 != null) {
            Thread.sleep(SLEEP_TIME);
            testOutEOut_assert(this.sqlgGraph1, a1, e3, e4, e5, e6, e7, e8);
        }
    }

    private void testOutEOut_assert(SqlgGraph sqlgGraph, Vertex a1, Edge e3, Edge e4, Edge e5, Edge e6, Edge e7, Edge e8) {
        DefaultGraphTraversal traversal = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, a1).outE().count();
        Assert.assertEquals(3, traversal.getSteps().size());
        Assert.assertEquals(2, traversal.next().intValue());
        Assert.assertEquals(3, traversal.getSteps().size());

        DefaultGraphTraversal traversal1 = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, a1).out().outE().count();
        Assert.assertEquals(4, traversal1.getSteps().size());
        Assert.assertEquals(6, traversal1.next().intValue());
        Assert.assertEquals(3, traversal1.getSteps().size());

        DefaultGraphTraversal traversal2 = (DefaultGraphTraversal) vertexTraversal(sqlgGraph, a1).out().outE();
        Assert.assertEquals(3, traversal2.getSteps().size());
        List edges = traversal2.toList();
        Assert.assertEquals(1, traversal2.getSteps().size());
        Assert.assertTrue(edges.contains(e3));
        Assert.assertTrue(edges.contains(e4));
        Assert.assertTrue(edges.contains(e5));
        Assert.assertTrue(edges.contains(e6));
        Assert.assertTrue(edges.contains(e7));
        Assert.assertTrue(edges.contains(e8));
    }

    @Test
    public void testBothEOnEdgeToSelf() {
        final Vertex v1 = this.sqlgGraph.addVertex("name", "marko");
        final Vertex v2 = this.sqlgGraph.addVertex("name", "puppy");
        v1.addEdge("knows", v2, "since", 2010);
        v1.addEdge("pets", v2);
        v1.addEdge("walks", v2, "location", "arroyo");
        v2.addEdge("knows", v1, "since", 2010);
        this.sqlgGraph.tx().setLazyQueries(false);
        Assert.assertEquals(4, vertexTraversal(this.sqlgGraph, v1).bothE().count().next().intValue());
        Assert.assertEquals(4, vertexTraversal(this.sqlgGraph, v2).bothE().count().next().intValue());
        v1.edges(Direction.BOTH).forEachRemaining(edge -> {
            v1.addEdge("livesWith", v2);
            v1.addEdge("walks", v2, "location", "river");
            edge.remove();
        });

        this.sqlgGraph.tx().commit();

        DefaultGraphTraversal traversal = (DefaultGraphTraversal) vertexTraversal(this.sqlgGraph, v1).outE().count();
        Assert.assertEquals(3, traversal.getSteps().size());
        Assert.assertEquals(8, traversal.next().intValue());
        Assert.assertEquals(3, traversal.getSteps().size());

        DefaultGraphTraversal traversal1 = (DefaultGraphTraversal) vertexTraversal(this.sqlgGraph, v2).outE().count();
        Assert.assertEquals(3, traversal1.getSteps().size());
        Assert.assertEquals(0, traversal1.next().intValue());
        Assert.assertEquals(3, traversal1.getSteps().size());

        v1.edges(Direction.BOTH).forEachRemaining(Edge::remove);

        DefaultGraphTraversal traversal2 = (DefaultGraphTraversal) vertexTraversal(this.sqlgGraph, v1).bothE().count();
        Assert.assertEquals(3, traversal2.getSteps().size());
        Assert.assertEquals(0, traversal2.next().intValue());
        Assert.assertEquals(3, traversal2.getSteps().size());

        DefaultGraphTraversal traversal3 = (DefaultGraphTraversal) vertexTraversal(this.sqlgGraph, v2).bothE().count();
        Assert.assertEquals(3, traversal3.getSteps().size());
        Assert.assertEquals(0, traversal3.next().intValue());
        Assert.assertEquals(3, traversal3.getSteps().size());
    }
}