Refine search
public JanusGraphStep(final GraphStep<S, E> originalStep) { super(originalStep.getTraversal(), originalStep.getReturnClass(), originalStep.isStartStep(), originalStep.getIds()); originalStep.getLabels().forEach(this::addLabel); this.setIteratorSupplier(() -> { if (this.ids == null) { return Collections.emptyIterator(); } else if (this.ids.length > 0) { final Graph graph = (Graph)traversal.asAdmin().getGraph().get(); return iteratorList((Iterator)graph.vertices(this.ids)); } if (hasLocalContainers.isEmpty()) { hasLocalContainers.put(new ArrayList<>(), new QueryInfo(new ArrayList<>(), 0, BaseQuery.NO_LIMIT)); } final JanusGraphTransaction tx = JanusGraphTraversalUtil.getTx(traversal); final GraphCentricQuery globalQuery = buildGlobalGraphCentricQuery(tx); final Multimap<Integer, GraphCentricQuery> queries = ArrayListMultimap.create(); if (globalQuery != null && !globalQuery.getSubQuery(0).getBackendQuery().isEmpty()) { queries.put(0, globalQuery); } else { hasLocalContainers.entrySet().forEach(c -> queries.put(c.getValue().getLowLimit(), buildGraphCentricQuery(tx, c))); } final GraphCentricQueryBuilder builder = (GraphCentricQueryBuilder) tx.query(); final List<Iterator<E>> responses = new ArrayList<>(); queries.entries().forEach(q -> executeGraphCentryQuery(builder, responses, q)); return new MultiDistinctOrderedIterator<E>(lowLimit, highLimit, responses, orders); }); }
@Override public String toString() { if (hasLocalContainers.isEmpty() && hasContainers.isEmpty()){ return super.toString(); } if (hasLocalContainers.isEmpty()) { return StringFactory.stepString(this, Arrays.toString(this.ids), hasContainers); } if (hasLocalContainers.size() == 1){ final List<HasContainer> containers = new ArrayList<>(hasContainers); containers.addAll(hasLocalContainers.keySet().iterator().next()); return StringFactory.stepString(this, Arrays.toString(this.ids), containers); } final StringBuilder sb = new StringBuilder(""); if (!hasContainers.isEmpty()) { sb.append(StringFactory.stepString(this, Arrays.toString(ids), hasContainers)).append("."); } sb.append("Or("); final Iterator<List<HasContainer>> itContainers = this.hasLocalContainers.keySet().iterator(); sb.append(StringFactory.stepString(this, Arrays.toString(this.ids), itContainers.next())); while(itContainers.hasNext()){ sb.append(",").append(StringFactory.stepString(this, Arrays.toString(this.ids), itContainers.next())); } sb.append(")"); return sb.toString(); }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + (hasContainers != null ? this.hasContainers.hashCode() : 0); result = 31 * result + (hasLocalContainers != null ? this.hasLocalContainers.hashCode() : 0); result = 31 * result + lowLimit; result = 31 * result + highLimit; result = 31 * result + (orders != null ? orders.hashCode() : 0); return result; } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.onGraphComputer(traversal)) return; TraversalHelper.getStepsOfClass(GraphStep.class, traversal).forEach(originalGraphStep -> { if (originalGraphStep.getIds() == null || originalGraphStep.getIds().length == 0) { //Try to optimize for index calls final JanusGraphStep<?, ?> janusGraphStep = new JanusGraphStep<>(originalGraphStep); TraversalHelper.replaceStep(originalGraphStep, janusGraphStep, traversal); HasStepFolder.foldInIds(janusGraphStep, traversal); HasStepFolder.foldInHasContainer(janusGraphStep, traversal, traversal); HasStepFolder.foldInOrder(janusGraphStep, janusGraphStep.getNextStep(), traversal, traversal, janusGraphStep.returnsVertex(), null); HasStepFolder.foldInRange(janusGraphStep, JanusGraphTraversalUtil.getNextNonIdentityStep(janusGraphStep), traversal, null); } else { //Make sure that any provided "start" elements are instantiated in the current transaction final Object[] ids = originalGraphStep.getIds(); ElementUtils.verifyArgsMustBeEitherIdOrElement(ids); if (ids[0] instanceof Element) { //GraphStep constructor ensures that the entire array is elements final Object[] elementIds = new Object[ids.length]; for (int i = 0; i < ids.length; i++) { elementIds[i] = ((Element) ids[i]).id(); } originalGraphStep.setIteratorSupplier(() -> originalGraphStep.returnsVertex() ? ((Graph) originalGraphStep.getTraversal().getGraph().get()).vertices(elementIds) : ((Graph) originalGraphStep.getTraversal().getGraph().get()).edges(elementIds)); } } }); }
@Override protected SqlgStep constructSqlgStep(Step startStep) { Preconditions.checkArgument(startStep instanceof GraphStep, "Expected a GraphStep, found instead a " + startStep.getClass().getName()); GraphStep<?, ?> graphStep = (GraphStep) startStep; //noinspection unchecked return new SqlgGraphStep(this.sqlgGraph, this.traversal, graphStep.getReturnClass(), graphStep.isStartStep(), graphStep.getIds()); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep) || TraversalHelper.onGraphComputer(traversal)) return; final List<Step> steps = traversal.getSteps(); if (steps.size() < 2 || !(steps.get(0) instanceof GraphStep) || 0 != ((GraphStep) steps.get(0)).getIds().length || !(steps.get(steps.size() - 1) instanceof CountGlobalStep)) return; for (int i = 1; i < steps.size() - 1; i++) { final Step current = steps.get(i); if (!(//current instanceof MapStep || // MapSteps will not necessarily emit an element as demonstrated in https://issues.apache.org/jira/browse/TINKERPOP-1958 current instanceof IdentityStep || current instanceof NoOpBarrierStep || current instanceof CollectingBarrierStep) || (current instanceof TraversalParent && TraversalHelper.anyStepRecursively(s -> (s instanceof SideEffectStep || s instanceof AggregateStep), (TraversalParent) current))) return; } final Class<? extends Element> elementClass = ((GraphStep<?, ?>) steps.get(0)).getReturnClass(); TraversalHelper.removeAllSteps(traversal); traversal.addStep(new TinkerCountGlobalStep<>(traversal, elementClass)); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.onGraphComputer(traversal) || traversal.getTraverserRequirements().contains(TraverserRequirement.PATH) || (IS_TESTING && ((TraversalHelper.hasStepOfAssignableClass(ProfileStep.class, TraversalHelper.getRootTraversal(traversal)) || TraversalHelper.hasStepOfAssignableClass(ProfileSideEffectStep.class, TraversalHelper.getRootTraversal(traversal)))))) // necessary cause ProfileTest analyzes counts for (int i = 0; i < traversal.getSteps().size(); i++) { final Step<?, ?> step = traversal.getSteps().get(i); !(step instanceof VertexStep && ((VertexStep) step).returnsEdge()) || (step instanceof GraphStep && (i > 0 || ((GraphStep) step).getIds().length >= BIG_START_SIZE || (((GraphStep) step).getIds().length == 0 && !(step.getNextStep() instanceof HasStep))))) { if (foundFlatMap && !labeledPath && !(step.getNextStep() instanceof Barrier) &&
traverser.setStepId(this.traversal.get().getStartStep().getId()); activeTraversers.add(traverser); }); assert haltedTraversers.isEmpty(); if (this.traversal.get().getStartStep() instanceof GraphStep) { final GraphStep<Element, Element> graphStep = (GraphStep<Element, Element>) this.traversal.get().getStartStep(); graphStep.reset(); activeTraversers.forEach(traverser -> graphStep.addStart((Traverser.Admin) traverser)); activeTraversers.clear(); if (graphStep.returnsVertex()) graphStep.setIteratorSupplier(() -> ElementHelper.idExists(vertex.id(), graphStep.getIds()) ? (Iterator) IteratorUtils.of(vertex) : EmptyIterator.instance()); else graphStep.setIteratorSupplier(() -> (Iterator) IteratorUtils.filter(vertex.edges(Direction.OUT), edge -> ElementHelper.idExists(edge.id(), graphStep.getIds()))); graphStep.forEachRemaining(traverser -> { if (traverser.isHalted()) { if (this.returnHaltedTraversers)
final Set<String> stepLabels = currentStep.getLabels(); hasContainerHolder.getHasContainers().forEach(hasContainer -> { if (GraphStep.processHasContainerIds(graphStep, hasContainer)) { stepLabels.forEach(janusgraphStep::addLabel); traversal.removeStep(currentStep);
public GraphStep(final Traversal.Admin traversal, final Class<E> returnClass, final boolean isStart, final Object... ids) { super(traversal); this.returnClass = returnClass; this.ids = (ids.length == 1 && ids[0] instanceof Collection) ? ((Collection) ids[0]).toArray(new Object[((Collection) ids[0]).size()]) : ids; this.isStart = isStart; this.iteratorSupplier = () -> (Iterator<E>) (Vertex.class.isAssignableFrom(this.returnClass) ? this.getTraversal().getGraph().get().vertices(this.ids) : this.getTraversal().getGraph().get().edges(this.ids)); }
.forEach(hasStep -> ((HasStep<?>) hasStep).getHasContainers().get(0).setKey(this.idPropertyKey)); if (traversal.getStartStep() instanceof GraphStep) { final GraphStep graphStep = (GraphStep) traversal.getStartStep(); if (graphStep.getIds().length > 0 && !(graphStep.getIds()[0] instanceof Element)) { if (graphStep instanceof HasContainerHolder) ((HasContainerHolder) graphStep).addHasContainer(new HasContainer(this.idPropertyKey, P.within(Arrays.asList(graphStep.getIds())))); else TraversalHelper.insertAfterStep(new HasStep(traversal, new HasContainer(this.idPropertyKey, P.within(Arrays.asList(graphStep.getIds())))), graphStep, traversal); graphStep.clearIds(); traversal.getSteps().forEach(step -> { if (step instanceof AddVertexStep || step instanceof AddVertexStartStep || step instanceof AddEdgeStep) { final Parameterizing parameterizing = (Parameterizing) step;
private static boolean legalCurrentStep(final Step<?, ?> step) { return !(step instanceof EmptyStep || step instanceof ProfileSideEffectStep || step instanceof HasNextStep || step instanceof ComputerAwareStep.EndStep || (step instanceof StartStep && !StartStep.isVariableStartStep(step)) || GraphStep.isStartStep(step)); }
final GraphStep graphStep = (GraphStep) this.step; @SuppressWarnings("unchecked") final boolean isVertex = graphStep.getReturnClass().isAssignableFrom(Vertex.class); final boolean isEdge = !isVertex;
/** * Spawns a {@link GraphTraversal} starting with all edges or some subset of edges as specified by their unique * identifier. */ public GraphTraversal<Edge, Edge> E(final Object... edgesIds) { final GraphTraversalSource clone = this.clone(); clone.bytecode.addStep(GraphTraversal.Symbols.E, edgesIds); final GraphTraversal.Admin<Edge, Edge> traversal = new DefaultGraphTraversal<>(clone); return traversal.addStep(new GraphStep<>(traversal, Edge.class, true, edgesIds)); }
@Override protected SqlgStep constructSqlgStep(Step startStep) { Preconditions.checkArgument(startStep instanceof GraphStep, "Expected a GraphStep, found instead a " + startStep.getClass().getName()); GraphStep<?, ?> graphStep = (GraphStep) startStep; //noinspection unchecked return new SqlgGraphStep(this.sqlgGraph, this.traversal, graphStep.getReturnClass(), graphStep.isStartStep(), graphStep.getIds()); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep) || TraversalHelper.onGraphComputer(traversal)) return; final List<Step> steps = traversal.getSteps(); if (steps.size() < 2 || !(steps.get(0) instanceof GraphStep) || 0 != ((GraphStep) steps.get(0)).getIds().length || !(steps.get(steps.size() - 1) instanceof CountGlobalStep)) return; for (int i = 1; i < steps.size() - 1; i++) { final Step current = steps.get(i); if (!(//current instanceof MapStep || // MapSteps will not necessarily emit an element as demonstrated in https://issues.apache.org/jira/browse/TINKERPOP-1958 current instanceof IdentityStep || current instanceof NoOpBarrierStep || current instanceof CollectingBarrierStep) || (current instanceof TraversalParent && TraversalHelper.anyStepRecursively(s -> (s instanceof SideEffectStep || s instanceof AggregateStep), (TraversalParent) current))) return; } final Class<? extends Element> elementClass = ((GraphStep<?, ?>) steps.get(0)).getReturnClass(); TraversalHelper.removeAllSteps(traversal); traversal.addStep(new TinkerCountGlobalStep<>(traversal, elementClass)); }
@Override public JavaPairRDD<Object, VertexWritable> apply(final TraversalVertexProgram vertexProgram, final JavaPairRDD<Object, VertexWritable> inputRDD, final SparkMemory memory) { vertexProgram.setup(memory); final Traversal.Admin<Vertex, Object> traversal = (Traversal.Admin) vertexProgram.getTraversal().getPure().clone(); final GraphStep<Vertex, Vertex> graphStep = ((GraphStep) traversal.getStartStep()); final Object[] graphStepIds = graphStep.getIds(); // any V(1,2,3)-style ids to filter on final ReducingBarrierStep endStep = (ReducingBarrierStep) traversal.getEndStep(); // needed for the final traverser generation traversal.removeStep(0); // remove GraphStep traversal.removeStep(traversal.getSteps().size() - 1); // remove ReducingBarrierStep
traverser.setStepId(this.traversal.get().getStartStep().getId()); activeTraversers.add(traverser); }); assert haltedTraversers.isEmpty(); if (this.traversal.get().getStartStep() instanceof GraphStep) { final GraphStep<Element, Element> graphStep = (GraphStep<Element, Element>) this.traversal.get().getStartStep(); graphStep.reset(); activeTraversers.forEach(traverser -> graphStep.addStart((Traverser.Admin) traverser)); activeTraversers.clear(); if (graphStep.returnsVertex()) graphStep.setIteratorSupplier(() -> ElementHelper.idExists(vertex.id(), graphStep.getIds()) ? (Iterator) IteratorUtils.of(vertex) : EmptyIterator.instance()); else graphStep.setIteratorSupplier(() -> (Iterator) IteratorUtils.filter(vertex.edges(Direction.OUT), edge -> ElementHelper.idExists(edge.id(), graphStep.getIds()))); graphStep.forEachRemaining(traverser -> { if (traverser.isHalted()) { if (this.returnHaltedTraversers)
public static void extractHasContainer(HugeGraphStep<?, ?> newStep, Traversal.Admin<?, ?> traversal) { Step<?, ?> step = newStep; do { step = step.getNextStep(); if (step instanceof HasStep) { HasContainerHolder holder = (HasContainerHolder) step; for (HasContainer has : holder.getHasContainers()) { if (!GraphStep.processHasContainerIds(newStep, has)) { newStep.addHasContainer(has); } } TraversalHelper.copyLabels(step, step.getPreviousStep(), false); traversal.removeStep(step); } } while (step instanceof HasStep || step instanceof NoOpBarrierStep); }
@Override protected Traverser.Admin<E> processNextStart() { while (true) { if (this.iterator.hasNext()) { return this.isStart ? this.getTraversal().getTraverserGenerator().generate(this.iterator.next(), (Step) this, 1l) : this.head.split(this.iterator.next(), this); } else { if (this.isStart) { if (this.done) throw FastNoSuchElementException.instance(); else { this.done = true; this.iterator = null == this.iteratorSupplier ? EmptyIterator.instance() : this.iteratorSupplier.get(); } } else { this.head = this.starts.next(); this.iterator = null == this.iteratorSupplier ? EmptyIterator.instance() : this.iteratorSupplier.get(); } } } }