import java.util.Set;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
stepIndex++;
return this;
}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public QueryBuilder<Path> path(){
+ this.traversal.path();
+ stepIndex++;
+ return (QueryBuilder<Path>)this;
+ }
@Override
public QueryBuilder<Edge> outE() {
return this.completeTraversal.toList();
}
+ protected QueryBuilder<Edge> has(String key, String value) {
+ traversal.has(key, value);
+
+ return (QueryBuilder<Edge>)this;
+ }
}
import java.util.Map;
import java.util.Set;
+import com.google.common.base.Joiner;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Direction;
stepIndex++;
return this;
}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public QueryBuilder<Path> path(){
+ this.list.add(".path()");
+ stepIndex++;
+ return (QueryBuilder<Path>)this;
+ }
@Override
public QueryBuilder<Edge> outE() {
return (List<E>)this.completeTraversal.toList();
}
+
+ protected QueryBuilder<Edge> has(String key, String value) {
+ this.list.add(".has('" + key + "','" + value + "')");
+
+ return (QueryBuilder<Edge>)this;
+ }
}
import javax.ws.rs.core.MultivaluedMap;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.introspection.Loader;
import org.onap.aai.parsers.query.QueryParser;
import org.onap.aai.parsers.query.QueryParserStrategy;
+import org.onap.aai.serialization.db.AAIDirection;
+import org.onap.aai.serialization.db.EdgeProperty;
import org.onap.aai.serialization.db.EdgeType;
/**
* @return a QueryBuilder with the simplePath step appended to its traversal
*/
public abstract QueryBuilder<E> simplePath();
+
+ /**
+ *
+ * @return QueryBuilder with the path step appended to its traversal
+ */
+ public abstract QueryBuilder<Path> path();
public abstract void markContainer();
public abstract QueryBuilder<E> getContainerQuery();
public abstract List<E> toList();
-
+
+ /**
+ * Used to skip step if there is an optional property missing.
+ * @param key
+ * @param value
+ * @return
+ */
public QueryBuilder<Vertex> getVerticesByProperty(String key, MissingOptionalParameter value) {
return (QueryBuilder<Vertex>) this;
}
-
+ /**
+ * TODO the edge direction is hardcoded here, make it more generic
+ * Returns the parent edge of the vertex
+ * @return
+ */
+ public QueryBuilder<Edge> getParentEdge() {
+ this.outE().has(EdgeProperty.CONTAINS.toString(), AAIDirection.IN.toString());
+ return (QueryBuilder<Edge>)this;
+ }
+
+ /**
+ * TODO the edge direction is hardcoded here, make it more generic
+ * Returns the parent vertex of the vertex
+ * @return
+ */
+ public QueryBuilder<Vertex> getParentVertex() {
+ this.getParentEdge().inV();
+ return (QueryBuilder<Vertex>)this;
+ }
+
+ protected abstract QueryBuilder<Edge> has(String key, String value);
}
*/
package org.onap.aai.query.builder;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
return new GremlinTraversal<>(loader, g, testEdgeRules);
}
+ @Override
+ protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v) {
+ return new GremlinTraversal<>(loader, g, v, testEdgeRules);
+ }
+
+ @Override
+ protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules() {
+ return new GremlinTraversal<>(loader, g, testEdgeRules);
+ }
+
}
*/
package org.onap.aai.query.builder;
-import org.janusgraph.core.JanusGraphFactory;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.janusgraph.core.JanusGraphFactory;
import org.junit.*;
import org.onap.aai.AAISetup;
import org.onap.aai.db.props.AAIProperties;
import java.util.Collections;
import java.util.List;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
import static org.junit.Assert.*;
public abstract class QueryBuilderTestAbstraction extends AAISetup {
}
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void createEdgeLinterfaceToLogicalLinkTraversal_Path() throws AAIException {
+ Vertex pInterface = g.addV("aai-node-type","p-interface","interface-name","p-interface-a").next();
+ Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
+ Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
+ testEdgeRules.addEdge(g, lInterface, logicalLink);
+ testEdgeRules.addTreeEdge(g, pInterface, lInterface);
+
+ QueryBuilder<Path> tQ = getNewPathTraversalWithTestEdgeRules(pInterface).createEdgeTraversal(EdgeType.TREE,
+ loader.introspectorFromName("p-interface" ), loader.introspectorFromName("l-interface")).createEdgeTraversal(EdgeType.COUSIN,
+ loader.introspectorFromName("l-interface" ), loader.introspectorFromName("logical-link")).path();
+
+ Path path = tQ.next();
+ assertThat(path.objects(), contains(pInterface, lInterface, logicalLink));
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void parentVertexTest() throws AAIException {
+ Vertex pInterface = g.addV("aai-node-type","p-interface","interface-name","p-interface-a").next();
+ Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
+
+ testEdgeRules.addTreeEdge(g, pInterface, lInterface);
+
+ QueryBuilder<Vertex> tQ = getNewEdgeTraversalWithTestEdgeRules(lInterface).getParentVertex();
+
+ Vertex parent = tQ.next();
+ assertThat(parent, is(pInterface));
+ }
+
@Test
public void createEdgeLinterfaceToLogicalLinkIntrospectorTraversal() throws AAIException {
protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules();
+ protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v);
+
+ protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules();
}
*/
package org.onap.aai.query.builder;
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
protected QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules() {
return new TraversalQuery<>(loader, g, testEdgeRules);
}
+
+ @Override
+ protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v) {
+ return new TraversalQuery<>(loader, g, v, testEdgeRules);
+ }
+
+ @Override
+ protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules() {
+ return new TraversalQuery<>(loader, g, testEdgeRules);
+ }
@Test
public void unionQuery() {
"prevent-delete": "NONE",
"default": "true",
"description": "Hard to describe"
+ },
+ {
+ "from": "l-interface",
+ "to": "p-interface",
+ "label": "tosca.relationships.network.BindsTo",
+ "direction": "OUT",
+ "multiplicity": "MANY2ONE",
+ "contains-other-v": "!${direction}",
+ "SVC-INFRA": "${direction}",
+ "delete-other-v": "!${direction}",
+ "prevent-delete": "NONE",
+ "default": "true"
}
]
}