Coverage Summary for Class: TestWhereWithSelect (org.umlg.sqlg.test.where)

Class Class, % Method, % Branch, % Line, %
TestWhereWithSelect 0% (0/1) 0% (0/8) 0% (0/37) 0% (0/129)


 package org.umlg.sqlg.test.where;
 
 import org.apache.tinkerpop.gremlin.process.traversal.P;
 import org.apache.tinkerpop.gremlin.process.traversal.Scope;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.junit.Assert;
 import org.junit.Test;
 import org.umlg.sqlg.test.BaseTest;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
 /**
  * @author <a href="https://github.com/pietermartin">Pieter Martin</a>
  * Date: 2017/10/22
  */
 public class TestWhereWithSelect extends BaseTest {
 
  @Test
  public void g_V_matchXa__a_out_b__notXa_created_bXX() {
  loadModern();
  final Traversal<Vertex, Map<String, Object>> traversal = this.sqlgGraph.traversal().V().match(
  __.as("a").out().as("b"),
  __.not(__.as("a").out("created").as("b")));
  printTraversalForm(traversal);
  checkResults(makeMapList(2,
  "a", convertToVertex(this.sqlgGraph, "marko"), "b", convertToVertex(this.sqlgGraph, "josh"),
  "a", convertToVertex(this.sqlgGraph, "marko"), "b", convertToVertex(this.sqlgGraph, "vadas")), traversal);
  }
 
  @Test
  public void coworkerSummaryOLTP() {
  loadModern();
  final Traversal<Vertex, Map<String, Map<String, Map<String, Object>>>> traversal = this.sqlgGraph.traversal()
  .V().hasLabel("person").filter(__.outE("created")).as("p1")
  .V().hasLabel("person").where(P.neq("p1")).filter(__.outE("created")).as("p2")
  .map(__.out("created").where(__.in("created").as("p1")).values("name").fold())
  .<String, Map<String, Map<String, Object>>>group().by(__.select("p1").by("name")).
  by(__.group().by(__.select("p2").by("name")).
  by(__.project("numCoCreated", "coCreated").by(__.count(Scope.local)).by()));
  printTraversalForm(traversal);
  Assert.assertTrue(traversal.hasNext());
  checkCoworkerSummary(traversal.next());
  Assert.assertFalse(traversal.hasNext());
  }
 
  private static void checkCoworkerSummary(final Map<String, Map<String, Map<String, Object>>> summary) {
  Assert.assertNotNull(summary);
  Assert.assertEquals(3, summary.size());
  Assert.assertTrue(summary.containsKey("marko"));
  Assert.assertTrue(summary.containsKey("josh"));
  Assert.assertTrue(summary.containsKey("peter"));
  for (final Map.Entry<String, Map<String, Map<String, Object>>> entry : summary.entrySet()) {
  Assert.assertEquals(2, entry.getValue().size());
  switch (entry.getKey()) {
  case "marko":
  Assert.assertTrue(entry.getValue().containsKey("josh") && entry.getValue().containsKey("peter"));
  break;
  case "josh":
  Assert.assertTrue(entry.getValue().containsKey("peter") && entry.getValue().containsKey("marko"));
  break;
  case "peter":
  Assert.assertTrue(entry.getValue().containsKey("marko") && entry.getValue().containsKey("josh"));
  break;
  }
  for (final Map<String, Object> m : entry.getValue().values()) {
  Assert.assertTrue(m.containsKey("numCoCreated"));
  Assert.assertTrue(m.containsKey("coCreated"));
  Assert.assertTrue(m.get("numCoCreated") instanceof Number);
  Assert.assertTrue(m.get("coCreated") instanceof Collection);
  Assert.assertEquals(1, ((Number) m.get("numCoCreated")).intValue());
  Assert.assertEquals(1, ((Collection) m.get("coCreated")).size());
  Assert.assertEquals("lop", ((Collection) m.get("coCreated")).iterator().next());
  }
  }
  }
 
  @Test
  public void g_V_asXaX_out_asXbX_whereXin_count_isXeqX3XX_or_whereXoutXcreatedX_and_hasXlabel_personXXX_selectXa_bX() {
  loadModern();
  final Traversal<Vertex, Map<String, Object>> traversal = this.sqlgGraph.traversal()
  .V().as("a").out().as("b")
  .where(
  __.as("b").in().count().is(P.eq(3))
  .or()
  .where(
  __.as("b").out("created").and().as("b").has(T.label, "person"))
  )
  .select("a", "b");
  printTraversalForm(traversal);
 // while (traversal.hasNext()) {
 // System.out.println(traversal.next());
 // }
  checkResults(makeMapList(2,
  "a", convertToVertex(this.sqlgGraph, "marko"), "b", convertToVertex(this.sqlgGraph, "josh"),
  "a", convertToVertex(this.sqlgGraph, "marko"), "b", convertToVertex(this.sqlgGraph, "lop"),
  "a", convertToVertex(this.sqlgGraph, "peter"), "b", convertToVertex(this.sqlgGraph, "lop"),
  "a", convertToVertex(this.sqlgGraph, "josh"), "b", convertToVertex(this.sqlgGraph, "lop")), traversal);
  }
 
  @Test
  public void g_V_hasXageX_asXaX_out_in_hasXageX_asXbX_selectXa_bX_whereXb_hasXname_markoXX() {
  loadModern();
 
  final Traversal<Vertex, Map<String, Object>> traversal = this.sqlgGraph.traversal()
  .V().has("age").as("a")
  .out().in().has("age").as("b")
  .select("a", "b")
  .where(__.as("a").out("knows").as("b"));
 
  printTraversalForm(traversal);
  int counter = 0;
  while (traversal.hasNext()) {
  counter++;
  final Map<String, Object> map = traversal.next();
  Assert.assertEquals(2, map.size());
  Assert.assertTrue(map.containsKey("a"));
  Assert.assertTrue(map.containsKey("b"));
  Assert.assertEquals(convertToVertexId("marko"), ((Vertex) map.get("a")).id());
  Assert.assertEquals(convertToVertexId("josh"), ((Vertex) map.get("b")).id());
  }
  Assert.assertEquals(1, counter);
  Assert.assertFalse(traversal.hasNext());
  }
 
  @Test
  public void testWhere() {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a1");
  Vertex a2 = this.sqlgGraph.addVertex(T.label, "A", "name", "a2");
  Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "b1");
  Vertex b2 = this.sqlgGraph.addVertex(T.label, "B", "name", "b2");
  a1.addEdge("ab", b1);
  a1.addEdge("ab", b2);
  a2.addEdge("ab", b1);
  a2.addEdge("ab", b2);
  this.sqlgGraph.tx().commit();
 
  GraphTraversal<Vertex, Vertex> traversal = sqlgGraph.traversal()
  .V().hasLabel("A").as("a")
  .where(
  __.as("a")
  .out()
  )
  .select("a");
  List<Vertex> result = traversal.toList();
  Assert.assertEquals(2, result.size());
  Assert.assertTrue(result.contains(a1) && result.contains(a2));
  }
 
  @Test
  public void testWhere2Labels() {
  Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a1");
  Vertex a2 = this.sqlgGraph.addVertex(T.label, "A", "name", "a2");
  Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "b1");
  Vertex b2 = this.sqlgGraph.addVertex(T.label, "B", "name", "b2");
  a1.addEdge("ab", b1);
  a1.addEdge("ab", b2);
  a2.addEdge("ab", b1);
  a2.addEdge("ab", b2);
  this.sqlgGraph.tx().commit();
 
  GraphTraversal<Vertex, Map<String, Vertex>> traversal = this.sqlgGraph.traversal()
  .V().hasLabel("A").as("a").out().as("b")
  .where(
  __.as("a").out().as("b")
  )
  .select("a", "b");
  List<Map<String, Vertex>> result = traversal.toList();
  Assert.assertEquals(4, result.size());
  for (Map<String, Vertex> stringVertexMap : result) {
  Assert.assertEquals(2, stringVertexMap.size());
  Assert.assertTrue(stringVertexMap.containsKey("a"));
  Assert.assertTrue(stringVertexMap.containsKey("b"));
  }
  boolean found1 = false;
  boolean found2 = false;
  boolean found3 = false;
  boolean found4 = false;
  for (Map<String, Vertex> stringVertexMap : result) {
  if (!found1) {
  found1 = stringVertexMap.get("a").equals(a1) && stringVertexMap.get("b").equals(b1);
  }
  if (!found2) {
  found2 = stringVertexMap.get("a").equals(a1) && stringVertexMap.get("b").equals(b2);
  }
  if (!found3) {
  found3 = stringVertexMap.get("a").equals(a2) && stringVertexMap.get("b").equals(b1);
  }
  if (!found4) {
  found4 = stringVertexMap.get("a").equals(a2) && stringVertexMap.get("b").equals(b2);
  }
  }
  Assert.assertTrue(found1);
  Assert.assertTrue(found2);
  Assert.assertTrue(found3);
  Assert.assertTrue(found4);
  System.out.println(result);
  }
 
 }