public static boolean validTitanHas(HasContainer has) { return TitanPredicate.Converter.supports(has.getBiPredicate()); }
private void addConstraint(final JanusGraphQuery query, final List<HasContainer> localContainers) { for (final HasContainer condition : hasContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (final HasContainer condition : localContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } }
static List<HasContainer> splitAndP(final List<HasContainer> hasContainers, final Iterable<HasContainer> has) { has.forEach(hasContainer -> { if (hasContainer.getPredicate() instanceof AndP) { for (final P<?> predicate : ((AndP<?>) hasContainer.getPredicate()).getPredicates()) { hasContainers.add(new HasContainer(hasContainer.getKey(), predicate)); } } else hasContainers.add(hasContainer); }); return hasContainers; }
static boolean validJanusGraphHas(HasContainer has) { if (has.getPredicate() instanceof ConnectiveP) { final List<? extends P<?>> predicates = ((ConnectiveP<?>) has.getPredicate()).getPredicates(); return predicates.stream().allMatch(p-> validJanusGraphHas(new HasContainer(has.getKey(), p))); } else { return JanusGraphPredicate.Converter.supports(has.getBiPredicate()); } }
@SuppressWarnings("deprecation") private void initialize() { assert !initialized; initialized = true; if (useMultiQuery) { if (!starts.hasNext()) throw FastNoSuchElementException.instance(); TitanMultiVertexQuery mquery = TitanTraversalUtil.getTx(traversal).multiQuery(); List<Traverser.Admin<Vertex>> vertices = new ArrayList<>(); starts.forEachRemaining(v -> { vertices.add(v); mquery.addVertex(v.get()); }); starts.add(vertices.iterator()); assert vertices.size() > 0; makeQuery(mquery); multiQueryResults = (Vertex.class.isAssignableFrom(getReturnClass())) ? mquery.vertices() : mquery.edges(); } }
private <A extends Element> Iterator<A> iteratorList(final Iterator<A> iterator) { final List<A> list = new ArrayList<>(); while (iterator.hasNext()) { final A e = iterator.next(); if (HasContainer.testAll(e, this.getHasContainers())) list.add(e); } return list.iterator(); }
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; }
private static boolean isChildOf(Step<?, ?> currentStep, List<Class<? extends Step>> stepClasses) { Step<?, ?> parent = currentStep.getTraversal().getParent().asStep(); while (!parent.equals(EmptyStep.instance())) { final Step<?, ?> p = parent; if(stepClasses.stream().filter(stepClass -> stepClass.isInstance(p)).findFirst().isPresent()) { return true; } parent = parent.getTraversal().getParent().asStep(); } return false; }
public MultiDistinctOrderedIterator(final Integer lowLimit, final Integer highLimit, final List<Iterator<E>> iterators, final List<OrderEntry> orders) { this.limit = highLimit; Comparator<E> comparator = null; if (orders.isEmpty()) { final Stream<E> stream = StreamSupport.stream(Spliterators.spliteratorUnknownSize(Iterators.concat(iterators.iterator()), Spliterator.ORDERED), false); this.iterators.put(0, stream.iterator()); } else { final List<Comparator<E>> comp = new ArrayList<>(); orders.forEach(o -> comp.add(new ElementValueComparator(o.key, o.order))); comparator = new MultiComparator<>(comp); for (int i = 0; i < iterators.size(); i++) { this.iterators.put(i, iterators.get(i)); } } currentElements = new TreeMap<>(comparator); long i = 0; while (i < lowLimit && this.hasNext()) { this.next(); i++; } }
private <Q extends BaseVertexQuery> Q makeQuery(Q query) { String[] keys = getPropertyKeys(); query.keys(keys); for (HasContainer condition : hasContainers) { query.has(condition.getKey(), TitanPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (OrderEntry order : orders) query.orderBy(order.key, order.order); if (limit != BaseQuery.NO_LIMIT) query.limit(limit); ((BasicVertexCentricQueryBuilder) query).profiler(queryProfiler); return query; }
public static HasContainer convert(final HasContainer container){ if (!(container.getPredicate() instanceof ConnectiveP)) { return container; } final ConnectiveJanusPredicate connectivePredicate = instanceConnectiveJanusPredicate(container.getPredicate()); return new HasContainer(container.getKey(), new ConnectiveJanusGraphP(connectivePredicate, convert(((ConnectiveP<?>) container.getPredicate()), connectivePredicate))); }
@SuppressWarnings("deprecation") private void initialize() { assert !initialized; initialized = true; assert getReturnType().forProperties() || (orders.isEmpty() && hasContainers.isEmpty()); if (!starts.hasNext()) throw FastNoSuchElementException.instance(); List<Traverser.Admin<Element>> elements = new ArrayList<>(); starts.forEachRemaining(v -> elements.add(v)); starts.add(elements.iterator()); assert elements.size() > 0; useMultiQuery = useMultiQuery && elements.stream().noneMatch(e -> !(e.get() instanceof Vertex)); if (useMultiQuery) { TitanMultiVertexQuery mquery = TitanTraversalUtil.getTx(traversal).multiQuery(); elements.forEach(e -> mquery.addVertex((Vertex) e.get())); makeQuery(mquery); multiQueryResults = mquery.properties(); } }
titanStep.orderBy(evc.getPropertyKey(), (Order) evc.getValueComparator());
private <Q extends BaseVertexQuery> Q makeQuery(Q query) { final String[] keys = getPropertyKeys(); query.keys(keys); for (final HasContainer condition : hasContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (final OrderEntry order : orders) query.orderBy(order.key, order.order); if (limit != BaseQuery.NO_LIMIT) query.limit(limit); ((BasicVertexCentricQueryBuilder) query).profiler(queryProfiler); return query; }
@SuppressWarnings("deprecation") private void initialize() { assert !initialized; initialized = true; if (useMultiQuery) { if (!starts.hasNext()) { throw FastNoSuchElementException.instance(); } final JanusGraphMultiVertexQuery multiQuery = JanusGraphTraversalUtil.getTx(traversal).multiQuery(); final List<Traverser.Admin<Vertex>> vertices = new ArrayList<>(); starts.forEachRemaining(v -> { vertices.add(v); multiQuery.addVertex(v.get()); }); starts.add(vertices.iterator()); assert vertices.size() > 0; makeQuery(multiQuery); multiQueryResults = (Vertex.class.isAssignableFrom(getReturnClass())) ? multiQuery.vertices() : multiQuery.edges(); } }
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; }
public <Q extends BaseVertexQuery> Q makeQuery(Q query) { query.labels(getEdgeLabels()); query.direction(getDirection()); for (HasContainer condition : hasContainers) { query.has(condition.getKey(), TitanPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (OrderEntry order : orders) query.orderBy(order.key, order.order); if (limit != BaseQuery.NO_LIMIT) query.limit(limit); ((BasicVertexCentricQueryBuilder) query).profiler(queryProfiler); return query; }
@SuppressWarnings("deprecation") private void initialize() { assert !initialized; initialized = true; assert getReturnType().forProperties() || (orders.isEmpty() && hasContainers.isEmpty()); if (!starts.hasNext()) throw FastNoSuchElementException.instance(); final List<Traverser.Admin<Element>> elements = new ArrayList<>(); starts.forEachRemaining(elements::add); starts.add(elements.iterator()); assert elements.size() > 0; useMultiQuery = useMultiQuery && elements.stream().allMatch(e -> e.get() instanceof Vertex); if (useMultiQuery) { final JanusGraphMultiVertexQuery multiQuery = JanusGraphTraversalUtil.getTx(traversal).multiQuery(); elements.forEach(e -> multiQuery.addVertex((Vertex) e.get())); makeQuery(multiQuery); multiQueryResults = multiQuery.properties(); } }
public <Q extends BaseVertexQuery> Q makeQuery(Q query) { query.labels(getEdgeLabels()); query.direction(getDirection()); for (final HasContainer condition : hasContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (final OrderEntry order : orders) query.orderBy(order.key, order.order); if (limit != BaseQuery.NO_LIMIT) query.limit(limit); ((BasicVertexCentricQueryBuilder) query).profiler(queryProfiler); return query; }
public TitanGraphStep(final GraphStep<E> originalStep) { super(originalStep.getTraversal(), originalStep.getReturnClass(), originalStep.getIds()); originalStep.getLabels().forEach(this::addLabel); this.setIteratorSupplier(() -> { TitanTransaction tx = TitanTraversalUtil.getTx(traversal); TitanGraphQuery query = tx.query(); for (HasContainer condition : hasContainers) { query.has(condition.getKey(), TitanPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (OrderEntry order : orders) query.orderBy(order.key, order.order); if (limit != BaseQuery.NO_LIMIT) query.limit(limit); ((GraphCentricQueryBuilder) query).profiler(queryProfiler); return Vertex.class.isAssignableFrom(this.returnClass) ? query.vertices().iterator() : query.edges().iterator(); }); }