public static boolean validTitanOrder(OrderGlobalStep ostep, Traversal rootTraversal, boolean isVertexOrder) { for (Comparator comp : (List<Comparator>) ostep.getComparators()) { if (!(comp instanceof ElementValueComparator)) return false; ElementValueComparator evc = (ElementValueComparator) comp; if (!(evc.getValueComparator() instanceof Order)) return false; TitanTransaction tx = TitanTraversalUtil.getTx(rootTraversal.asAdmin()); String key = evc.getPropertyKey(); PropertyKey pkey = tx.getPropertyKey(key); if (pkey == null || !(Comparable.class.isAssignableFrom(pkey.dataType()))) return false; if (isVertexOrder && pkey.cardinality() != Cardinality.SINGLE) return false; } return true; }
if (currentStep instanceof OrderGlobalStep) { if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered) lastOrder.getLabels().forEach(titanStep::addLabel); traversal.removeStep(lastOrder); if (validTitanOrder(lastOrder, rootTraversal, isVertexOrder)) { for (Comparator comp : (List<Comparator>) ((OrderGlobalStep) lastOrder).getComparators()) { ElementValueComparator evc = (ElementValueComparator) comp; titanStep.orderBy(evc.getPropertyKey(), (Order) evc.getValueComparator()); lastOrder.getLabels().forEach(titanStep::addLabel); traversal.removeStep(lastOrder);
@Override public void modulateBy(final Traversal.Admin<?, ?> traversal, final Comparator comparator) { this.addComparator((Traversal.Admin<S, C>) traversal, comparator); }
@Override public void apply(Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfAssignableClass(OrderGlobalStep.class, traversal).forEach(orderGlobalStep -> { List<Pair<Traversal.Admin, Comparator>> comparators = orderGlobalStep.getComparators(); List<Pair<String, Order>> collect = comparators.stream() .filter(pair -> pair.getValue0() instanceof ElementValueTraversal) .filter(pair -> pair.getValue1() instanceof Order) .map(pair -> Pair.with(((ElementValueTraversal) pair.getValue0()).getPropertyKey(), ((Order) pair.getValue1()))) .collect(Collectors.toList()); Collection<Orderable> orderableStepOf = getOrderableStepOf(orderGlobalStep, traversal); if (orderableStepOf != null && orderableStepOf.size() == 1) { Orderable step = orderableStepOf.iterator().next(); step.setOrders(collect); Step nextStep = orderGlobalStep.getNextStep(); if (nextStep instanceof RangeGlobalStep){ if (step instanceof ReceivesPredicatesHolder) { RangeGlobalStep rangeGlobalStep = (RangeGlobalStep) nextStep; int limit = rangeGlobalStep.getHighRange() > Integer.MAX_VALUE ? -1 : (int) rangeGlobalStep.getHighRange(); ((ReceivesPredicatesHolder) step).setLimit(limit); } } } }); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!TraversalHelper.onGraphComputer(traversal)) return; final List<OrderGlobalStep> orders = TraversalHelper.getStepsOfClass(OrderGlobalStep.class, traversal); for (final OrderGlobalStep order : orders) { RangeGlobalStep range = null; Step<?, ?> currentStep = order.getNextStep(); while (true) { if (currentStep instanceof RangeGlobalStep) { range = (RangeGlobalStep) currentStep; break; } else if (!LEGAL_STEPS.contains(currentStep.getClass())) break; else currentStep = currentStep.getNextStep(); } if (null != range) order.setLimit(range.getHighRange()); } }
@Test @IgnoreEngine(TraversalEngine.Type.STANDARD) // validating the internal sort/limit works in GraphComputer @LoadGraphWith(MODERN) public void g_V_both_hasLabelXpersonX_order_byXage_descX_name() { final Traversal<Vertex, String> traversal = get_g_V_both_hasLabelXpersonX_order_byXage_descX_name(); traversal.asAdmin().applyStrategies(); if (!TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).isPresent()) return; // total hack to avoid providers that don't compile to OrderGlobalStep TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().setLimit(1); printTraversalForm(traversal); final List<String> results = traversal.toList(); assertTrue(results.size() < 8); assertFalse(traversal.hasNext()); }
/** * Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence. * * @return the traversal with an appended {@link OrderGlobalStep}. * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#order-step" target="_blank">Reference Documentation - Order Step</a> * @since 3.0.0-incubating */ public default GraphTraversal<S, E> order() { this.asAdmin().getBytecode().addStep(Symbols.order); return this.asAdmin().addStep(new OrderGlobalStep<>(this.asAdmin())); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!TraversalHelper.onGraphComputer(traversal)) return; final List<OrderGlobalStep> orders = TraversalHelper.getStepsOfClass(OrderGlobalStep.class, traversal); for (final OrderGlobalStep order : orders) { RangeGlobalStep range = null; Step<?, ?> currentStep = order.getNextStep(); while (true) { if (currentStep instanceof RangeGlobalStep) { range = (RangeGlobalStep) currentStep; break; } else if (!LEGAL_STEPS.contains(currentStep.getClass())) break; else currentStep = currentStep.getNextStep(); } if (null != range) order.setLimit(range.getHighRange()); } }
@Test @IgnoreEngine(TraversalEngine.Type.STANDARD) // validating the internal sort/limit works in GraphComputer @LoadGraphWith(MODERN) public void g_V_both_hasLabelXpersonX_order_byXage_descX_name() { final Traversal<Vertex, String> traversal = get_g_V_both_hasLabelXpersonX_order_byXage_descX_name(); traversal.asAdmin().applyStrategies(); if (!TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).isPresent()) return; // total hack to avoid providers that don't compile to OrderGlobalStep TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().setLimit(1); printTraversalForm(traversal); final List<String> results = traversal.toList(); assertTrue(results.size() < 8); assertFalse(traversal.hasNext()); }
/** * Order either the {@link Scope#local} object (e.g. a list, map, etc.) or the entire {@link Scope#global} traversal stream. * * @param scope whether the ordering is the current local object or the entire global stream. * @return the traversal with an appended {@link OrderGlobalStep} or {@link OrderLocalStep} depending on the {@code scope}. * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#order-step" target="_blank">Reference Documentation - Order Step</a> * @since 3.0.0-incubating */ public default GraphTraversal<S, E> order(final Scope scope) { this.asAdmin().getBytecode().addStep(Symbols.order, scope); return this.asAdmin().addStep(scope.equals(Scope.global) ? new OrderGlobalStep<>(this.asAdmin()) : new OrderLocalStep<>(this.asAdmin())); }
static boolean validJanusGraphOrder(OrderGlobalStep orderGlobalStep, Traversal rootTraversal, boolean isVertexOrder) { final List<Pair<Traversal.Admin, Object>> comparators = orderGlobalStep.getComparators(); for(final Pair<Traversal.Admin, Object> comp : comparators) { final String key; if (comp.getValue0() instanceof ElementValueTraversal && comp.getValue1() instanceof Order) { key = ((ElementValueTraversal) comp.getValue0()).getPropertyKey(); } else if (comp.getValue1() instanceof ElementValueComparator) { final ElementValueComparator evc = (ElementValueComparator) comp.getValue1(); if (!(evc.getValueComparator() instanceof Order)) return false; key = evc.getPropertyKey(); } else { // do not fold comparators that include nested traversals that are not simple ElementValues return false; } final JanusGraphTransaction tx = JanusGraphTraversalUtil.getTx(rootTraversal.asAdmin()); final PropertyKey pKey = tx.getPropertyKey(key); if (pKey == null || !(Comparable.class.isAssignableFrom(pKey.dataType())) || (isVertexOrder && pKey.cardinality() != Cardinality.SINGLE)) { return false; } } return true; }
if (currentStep instanceof OrderGlobalStep) { if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered) lastOrder.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(lastOrder); for (final Pair<Traversal.Admin<Object, Comparable>, Comparator<Object>> comp : (List<Pair<Traversal.Admin<Object, Comparable>, Comparator<Object>>>) ((OrderGlobalStep) lastOrder).getComparators()) { final String key; final Order order; lastOrder.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(lastOrder);
/** * Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence. * * @return the traversal with an appended {@link OrderGlobalStep}. * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#order-step" target="_blank">Reference Documentation - Order Step</a> * @since 3.0.0-incubating */ public default GraphTraversal<S, E> order() { this.asAdmin().getBytecode().addStep(Symbols.order); return this.asAdmin().addStep(new OrderGlobalStep<>(this.asAdmin())); }
@Override public void modulateBy(final Traversal.Admin<?, ?> traversal, final Comparator comparator) { this.addComparator((Traversal.Admin<S, C>) traversal, comparator); }
public static void extractOrder(Step<?, ?> newStep, Traversal.Admin<?, ?> traversal) { Step<?, ?> step = newStep; do { step = step.getNextStep(); if (step instanceof OrderGlobalStep) { QueryHolder holder = (QueryHolder) newStep; @SuppressWarnings("resource") OrderGlobalStep<?, ?> orderStep = (OrderGlobalStep<?, ?>) step; orderStep.getComparators().forEach(comp -> { ElementValueComparator<?> comparator = (ElementValueComparator<?>) comp.getValue1(); holder.orderBy(comparator.getPropertyKey(), (Order) comparator.getValueComparator()); }); TraversalHelper.copyLabels(step, newStep, false); traversal.removeStep(step); } step = step.getNextStep(); } while (step instanceof OrderGlobalStep || step instanceof IdentityStep); }
if (currentStep instanceof OrderGlobalStep) { if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered) lastOrder.getLabels().forEach(titanStep::addLabel); traversal.removeStep(lastOrder); if (validTitanOrder(lastOrder, rootTraversal, isVertexOrder)) { for (Comparator comp : (List<Comparator>) ((OrderGlobalStep) lastOrder).getComparators()) { ElementValueComparator evc = (ElementValueComparator) comp; titanStep.orderBy(evc.getPropertyKey(), (Order) evc.getValueComparator()); lastOrder.getLabels().forEach(titanStep::addLabel); traversal.removeStep(lastOrder);
/** * Order either the {@link Scope#local} object (e.g. a list, map, etc.) or the entire {@link Scope#global} traversal stream. * * @param scope whether the ordering is the current local object or the entire global stream. * @return the traversal with an appended {@link OrderGlobalStep} or {@link OrderLocalStep} depending on the {@code scope}. * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#order-step" target="_blank">Reference Documentation - Order Step</a> * @since 3.0.0-incubating */ public default GraphTraversal<S, E> order(final Scope scope) { this.asAdmin().getBytecode().addStep(Symbols.order, scope); return this.asAdmin().addStep(scope.equals(Scope.global) ? new OrderGlobalStep<>(this.asAdmin()) : new OrderLocalStep<>(this.asAdmin())); }
private boolean optimizableOrderGlobalStep(OrderGlobalStep step) { @SuppressWarnings("unchecked") List<Pair<Traversal.Admin<?, ?>, Comparator<?>>> comparators = step.getComparators(); for (Pair<Traversal.Admin<?, ?>, Comparator<?>> comparator : comparators) { Traversal.Admin<?, ?> defaultGraphTraversal = comparator.getValue0(); List<CountGlobalStep> countGlobalSteps = TraversalHelper.getStepsOfAssignableClassRecursively(CountGlobalStep.class, defaultGraphTraversal); if (!countGlobalSteps.isEmpty()) { return false; } List<LambdaMapStep> lambdaMapSteps = TraversalHelper.getStepsOfAssignableClassRecursively(LambdaMapStep.class, defaultGraphTraversal); if (!lambdaMapSteps.isEmpty()) { return false; } // if (comparator.getValue1().toString().contains("$Lambda")) { // return false; // } } return true; }
private boolean optimizableOrderGlobalStep(OrderGlobalStep step) { @SuppressWarnings("unchecked") List<Pair<Traversal.Admin<?, ?>, Comparator<?>>> comparators = step.getComparators(); for (Pair<Traversal.Admin<?, ?>, Comparator<?>> comparator : comparators) { Traversal.Admin<?, ?> defaultGraphTraversal = comparator.getValue0(); List<CountGlobalStep> countGlobalSteps = TraversalHelper.getStepsOfAssignableClassRecursively(CountGlobalStep.class, defaultGraphTraversal); if (!countGlobalSteps.isEmpty()) { return false; } List<LambdaMapStep> lambdaMapSteps = TraversalHelper.getStepsOfAssignableClassRecursively(LambdaMapStep.class, defaultGraphTraversal); if (!lambdaMapSteps.isEmpty()) { return false; } // if (comparator.getValue1().toString().contains("$Lambda")) { // return false; // } } return true; }
public static boolean validTitanOrder(OrderGlobalStep ostep, Traversal rootTraversal, boolean isVertexOrder) { for (Comparator comp : (List<Comparator>) ostep.getComparators()) { if (!(comp instanceof ElementValueComparator)) return false; ElementValueComparator evc = (ElementValueComparator) comp; if (!(evc.getValueComparator() instanceof Order)) return false; TitanTransaction tx = TitanTraversalUtil.getTx(rootTraversal.asAdmin()); String key = evc.getPropertyKey(); PropertyKey pkey = tx.getPropertyKey(key); if (pkey == null || !(Comparable.class.isAssignableFrom(pkey.dataType()))) return false; if (isVertexOrder && pkey.cardinality() != Cardinality.SINGLE) return false; } return true; }