Examples with Order org.apache.tinkerpop.gremlin.process.traversal.Order used on opensource projects

Example 6 with Order

use of org.apache.tinkerpop.gremlin.process.traversal.Order in project sqlg by pietermartin.

the class TestOptionalWithOrder method testOptionalWithOrder.

@Test
public void testOptionalWithOrder() {
    Vertex a1 = this.sqlgGraph.addVertex(T.label, "A", "name", "a");
    Vertex a2 = this.sqlgGraph.addVertex(T.label, "A", "name", "aa");
    Vertex a3 = this.sqlgGraph.addVertex(T.label, "A", "name", "aaa");
    Vertex b1 = this.sqlgGraph.addVertex(T.label, "B", "name", "d");
    Vertex b2 = this.sqlgGraph.addVertex(T.label, "B", "name", "c");
    Vertex b3 = this.sqlgGraph.addVertex(T.label, "B", "name", "b");
    Vertex bb1 = this.sqlgGraph.addVertex(T.label, "BB", "name", "g");
    Vertex bb2 = this.sqlgGraph.addVertex(T.label, "BB", "name", "f");
    Vertex bb3 = this.sqlgGraph.addVertex(T.label, "BB", "name", "e");
    Vertex c1 = this.sqlgGraph.addVertex(T.label, "C", "name", "h");
    Vertex c2 = this.sqlgGraph.addVertex(T.label, "C", "name", "i");
    Vertex c3 = this.sqlgGraph.addVertex(T.label, "C", "name", "j");
    Vertex cc1 = this.sqlgGraph.addVertex(T.label, "CC", "name", "k");
    Vertex cc2 = this.sqlgGraph.addVertex(T.label, "CC", "name", "l");
    Vertex cc3 = this.sqlgGraph.addVertex(T.label, "CC", "name", "m");
    a1.addEdge("ab", b1);
    a1.addEdge("ab", b2);
    a1.addEdge("ab", b3);
    a1.addEdge("abb", bb1);
    a1.addEdge("abb", bb2);
    a1.addEdge("abb", bb3);
    b1.addEdge("bc", c1);
    b1.addEdge("bc", c2);
    b1.addEdge("bc", c3);
    b2.addEdge("bcc", cc1);
    b2.addEdge("bcc", cc2);
    b2.addEdge("bcc", cc3);
    this.sqlgGraph.tx().commit();
    DefaultGraphTraversal<Vertex, Path> traversal = (DefaultGraphTraversal<Vertex, Path>) this.sqlgGraph.traversal().V().hasLabel("A").optional(__.out().order().by("name").optional(__.out().order().by("name", Order.decr))).path();
    Assert.assertEquals(4, traversal.getSteps().size());
    List<Path> paths = traversal.toList();
    Assert.assertEquals(2, traversal.getSteps().size());
    assertStep(traversal.getSteps().get(0), true, true, true, true);
    Assert.assertEquals(12, paths.size());
    // assert the order
    // all the paths of length 2 and 3 must be sorted
    List<Path> pathsOfLength3 = paths.stream().filter(p -> p.size() == 3).collect(Collectors.toList());
    Vertex v = (Vertex) pathsOfLength3.get(5).objects().get(2);
    Assert.assertEquals("h", v.value("name"));
    v = (Vertex) pathsOfLength3.get(4).objects().get(2);
    Assert.assertEquals("i", v.value("name"));
    v = (Vertex) pathsOfLength3.get(3).objects().get(2);
    Assert.assertEquals("j", v.value("name"));
    v = (Vertex) pathsOfLength3.get(2).objects().get(2);
    Assert.assertEquals("k", v.value("name"));
    v = (Vertex) pathsOfLength3.get(1).objects().get(2);
    Assert.assertEquals("l", v.value("name"));
    v = (Vertex) pathsOfLength3.get(0).objects().get(2);
    Assert.assertEquals("m", v.value("name"));
    List<Path> pathsOfLength2 = paths.stream().filter(p -> p.size() == 2).collect(Collectors.toList());
    v = (Vertex) pathsOfLength2.get(0).objects().get(1);
    Assert.assertEquals("b", v.value("name"));
    v = (Vertex) pathsOfLength2.get(1).objects().get(1);
    Assert.assertEquals("e", v.value("name"));
    v = (Vertex) pathsOfLength2.get(2).objects().get(1);
    Assert.assertEquals("f", v.value("name"));
    v = (Vertex) pathsOfLength2.get(3).objects().get(1);
    Assert.assertEquals("g", v.value("name"));
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c1)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c1)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c2)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c2)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c3)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b1) && p.get(2).equals(c3)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc1)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc1)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc2)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc2)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc3)));
    paths.remove(paths.stream().filter(p -> p.size() == 3 && p.get(0).equals(a1) && p.get(1).equals(b2) && p.get(2).equals(cc3)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb1)));
    paths.remove(paths.stream().filter(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb1)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb2)));
    paths.remove(paths.stream().filter(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb2)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb3)));
    paths.remove(paths.stream().filter(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(bb3)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(b3)));
    paths.remove(paths.stream().filter(p -> p.size() == 2 && p.get(0).equals(a1) && p.get(1).equals(b3)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 1 && p.get(0).equals(a2)));
    paths.remove(paths.stream().filter(p -> p.size() == 1 && p.get(0).equals(a2)).findAny().get());
    Assert.assertTrue(paths.stream().anyMatch(p -> p.size() == 1 && p.get(0).equals(a3)));
    paths.remove(paths.stream().filter(p -> p.size() == 1 && p.get(0).equals(a3)).findAny().get());
    Assert.assertTrue(paths.isEmpty());
}

Example 7 with Order

use of org.apache.tinkerpop.gremlin.process.traversal.Order in project janusgraph by JanusGraph.

the class IndexSerializer method getOrders.

private ImmutableList<IndexQuery.OrderEntry> getOrders(IndexQueryBuilder query, final ElementCategory resultType, final StandardJanusGraphTx transaction, MixedIndexType index) {
    if (query.getOrders() == null) {
        return ImmutableList.of();
    }
    Preconditions.checkArgument(index.getElement() == resultType, "Index is not configured for the desired result type: %s", resultType);
    List<IndexQuery.OrderEntry> orderReplacement = new ArrayList<>();
    for (Parameter<Order> order : query.getOrders()) {
        if (transaction.containsRelationType(order.key())) {
            final PropertyKey key = transaction.getPropertyKey(order.key());
            Preconditions.checkNotNull(key);
            Preconditions.checkArgument(index.indexesKey(key), "The used key [%s] is not indexed in the targeted index [%s]", key.name(), query.getIndex());
            orderReplacement.add(new IndexQuery.OrderEntry(key2Field(index, key), org.janusgraph.graphdb.internal.Order.convert(order.value()), key.dataType()));
        } else {
            Preconditions.checkArgument(query.getUnknownKeyName() != null, "Found reference to nonexistent property key in query orders %s", order.key());
        }
    }
    return ImmutableList.copyOf(orderReplacement);
}

Example 8 with Order

use of org.apache.tinkerpop.gremlin.process.traversal.Order in project titan by thinkaurelius.

the class HasStepFolder method validTitanOrder.

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;
}

Example 9 with Order

use of org.apache.tinkerpop.gremlin.process.traversal.Order in project unipop by unipop-graph.

the class UniGraphOrderStrategy method apply.

@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);
                }
            }
        }
    });
}

Example 10 with Order

use of org.apache.tinkerpop.gremlin.process.traversal.Order in project unipop by unipop-graph.

the class DocumentController method createSearchBuilder.

private <E extends Element, S extends DocumentSchema<E>> Pair<S, SearchSourceBuilder> createSearchBuilder(Map.Entry<S, QueryBuilder> kv, SearchQuery<E> query) {
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(kv.getValue()).size(query.getLimit() == -1 ? 10000 : query.getLimit());
    if (query.getPropertyKeys() == null)
        searchSourceBuilder.fetchSource(true);
    else {
        Set<String> fields = kv.getKey().toFields(query.getPropertyKeys());
        if (fields.size() == 0)
            searchSourceBuilder.fetchSource(false);
        else
            searchSourceBuilder.fetchSource(fields.toArray(new String[fields.size()]), null);
    }
    List<Pair<String, Order>> orders = query.getOrders();
    if (orders != null) {
        orders.forEach(order -> {
            Order orderValue = order.getValue1();
            switch(orderValue) {
                case decr:
                    searchSourceBuilder.sort(kv.getKey().getFieldByPropertyKey(order.getValue0()), SortOrder.DESC);
                    break;
                case incr:
                    searchSourceBuilder.sort(kv.getKey().getFieldByPropertyKey(order.getValue0()), SortOrder.ASC);
                    break;
                case shuffle:
                    break;
            }
        });
    }
    return Pair.with(kv.getKey(), searchSourceBuilder);
}