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

Example 1 with AndP

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

the class BaseStrategy method optimizeInside.

private List<HasContainer> optimizeInside(ReplacedStep<?, ?> replacedStep, List<HasContainer> hasContainers) {
    List<HasContainer> result = new ArrayList<>();
    for (HasContainer hasContainer : hasContainers) {
        if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof AndP) {
            AndP<?> andP = (AndP) hasContainer.getPredicate();
            List<? extends P<?>> predicates = andP.getPredicates();
            if (predicates.size() == 2) {
                if (predicates.get(0).getBiPredicate() == Compare.gt && predicates.get(1).getBiPredicate() == Compare.lt) {
                    replacedStep.addHasContainer(hasContainer);
                    result.add(hasContainer);
                }
            }
        }
    }
    return result;
}

Example 2 with AndP

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

the class JdbcPredicatesTranslator method handleConnectiveP.

private Condition handleConnectiveP(String key, ConnectiveP predicate) {
    List<P> predicates = predicate.getPredicates();
    List<Condition> queries = predicates.stream().map(p -> {
        if (p instanceof ConnectiveP)
            return handleConnectiveP(key, (ConnectiveP) p);
        Object pValue = p.getValue();
        BiPredicate pBiPredicate = p.getBiPredicate();
        return predicateToQuery(key, pValue, pBiPredicate);
    }).collect(Collectors.toList());
    Condition condition = queries.get(0);
    if (predicate instanceof AndP) {
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.and(queries.get(i));
        }
    } else if (predicate instanceof OrP) {
        for (int i = 1; i < queries.size(); i++) {
            condition = condition.or(queries.get(i));
        }
    } else
        throw new IllegalArgumentException("Connective predicate not supported by unipop");
    return condition;
}

Example 3 with AndP

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

the class JanusGraphPSerializer method read.

@Override
public P read(Kryo kryo, Input input, Class<P> aClass) {
    final String predicate = input.readString();
    final boolean isCollection = input.readByte() == (byte) 0;
    final Object value;
    if (isCollection) {
        value = new ArrayList();
        final int size = input.readInt();
        for (int ix = 0; ix < size; ix++) {
            ((List) value).add(kryo.readClassAndObject(input));
        }
    } else {
        value = kryo.readClassAndObject(input);
    }
    try {
        if (value instanceof Collection) {
            switch(predicate) {
                case "and":
                    return new AndP((List<P>) value);
                case "or":
                    return new OrP((List<P>) value);
                case "between":
                    return P.between(((List) value).get(0), ((List) value).get(1));
                case "inside":
                    return P.inside(((List) value).get(0), ((List) value).get(1));
                case "outside":
                    return P.outside(((List) value).get(0), ((List) value).get(1));
                case "within":
                    return P.within((Collection) value);
                case "without":
                    return P.without((Collection) value);
                default:
                    return (P) P.class.getMethod(predicate, Collection.class).invoke(null, (Collection) value);
            }
        } else {
            switch(predicate) {
                case "geoIntersect":
                    return Geo.geoIntersect(value);
                case "geoDisjoint":
                    return Geo.geoDisjoint(value);
                case "geoWithin":
                    return Geo.geoWithin(value);
                case "geoContains":
                    return Geo.geoContains(value);
                case "textContains":
                    return Text.textContains(value);
                case "textContainsFuzzy":
                    return Text.textContainsFuzzy(value);
                case "textContainsPrefix":
                    return Text.textContainsPrefix(value);
                case "textContainsRegex":
                    return Text.textContainsRegex(value);
                case "textFuzzy":
                    return Text.textFuzzy(value);
                case "textPrefix":
                    return Text.textPrefix(value);
                case "textRegex":
                    return Text.textRegex(value);
                default:
                    return (P) P.class.getMethod(predicate, Object.class).invoke(null, value);
            }
        }
    } catch (final Exception e) {
        log.info("Couldn't deserialize class: " + aClass + ", predicate: " + predicate + ", isCollection: " + isCollection + ",value: " + value, e);
        throw new IllegalStateException(e.getMessage(), e);
    }
}

Example 4 with AndP

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

the class BaseStrategy method handleConnectiveStepInternal.

private Optional<AndOrHasContainer> handleConnectiveStepInternal(ConnectiveStep connectiveStep) {
    AndOrHasContainer.TYPE type = AndOrHasContainer.TYPE.from(connectiveStep);
    AndOrHasContainer outerAndOrHasContainer = new AndOrHasContainer(type);
    List<Traversal.Admin<?, ?>> localTraversals = connectiveStep.getLocalChildren();
    for (Traversal.Admin<?, ?> localTraversal : localTraversals) {
        if (!TraversalHelper.hasAllStepsOfClass(localTraversal, HasStep.class, ConnectiveStep.class)) {
            return Optional.empty();
        }
        AndOrHasContainer andOrHasContainer = new AndOrHasContainer(AndOrHasContainer.TYPE.NONE);
        outerAndOrHasContainer.addAndOrHasContainer(andOrHasContainer);
        for (Step<?, ?> step : localTraversal.getSteps()) {
            if (step instanceof HasStep) {
                HasStep<?> hasStep = (HasStep) step;
                for (HasContainer hasContainer : hasStep.getHasContainers()) {
                    if (hasContainerKeyNotIdOrLabel(hasContainer) && SUPPORTED_BI_PREDICATE.contains(hasContainer.getBiPredicate())) {
                        andOrHasContainer.addHasContainer(hasContainer);
                    } else if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof AndP) {
                        AndP<?> andP = (AndP) hasContainer.getPredicate();
                        List<? extends P<?>> predicates = andP.getPredicates();
                        if (predicates.size() == 2) {
                            if (predicates.get(0).getBiPredicate() == Compare.gte && predicates.get(1).getBiPredicate() == Compare.lt) {
                                andOrHasContainer.addHasContainer(hasContainer);
                            } else if (predicates.get(0).getBiPredicate() == Compare.gt && predicates.get(1).getBiPredicate() == Compare.lt) {
                                andOrHasContainer.addHasContainer(hasContainer);
                            }
                        }
                    } else if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof OrP) {
                        OrP<?> orP = (OrP) hasContainer.getPredicate();
                        List<? extends P<?>> predicates = orP.getPredicates();
                        if (predicates.size() == 2) {
                            if (predicates.get(0).getBiPredicate() == Compare.lt && predicates.get(1).getBiPredicate() == Compare.gt) {
                                andOrHasContainer.addHasContainer(hasContainer);
                            }
                        }
                    } else if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getBiPredicate() instanceof Text || hasContainer.getBiPredicate() instanceof FullText) {
                        andOrHasContainer.addHasContainer(hasContainer);
                    } else {
                        return Optional.empty();
                    }
                }
            } else {
                ConnectiveStep connectiveStepLocalChild = (ConnectiveStep) step;
                Optional<AndOrHasContainer> result = handleConnectiveStepInternal(connectiveStepLocalChild);
                if (result.isPresent()) {
                    andOrHasContainer.addAndOrHasContainer(result.get());
                } else {
                    return Optional.empty();
                }
            }
        }
    }
    return Optional.of(outerAndOrHasContainer);
}

Example 5 with AndP

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

the class BaseStrategy method optimizeBetween.

private List<HasContainer> optimizeBetween(ReplacedStep<?, ?> replacedStep, List<HasContainer> hasContainers) {
    List<HasContainer> result = new ArrayList<>();
    for (HasContainer hasContainer : hasContainers) {
        if (hasContainerKeyNotIdOrLabel(hasContainer) && hasContainer.getPredicate() instanceof AndP) {
            AndP<?> andP = (AndP) hasContainer.getPredicate();
            List<? extends P<?>> predicates = andP.getPredicates();
            if (predicates.size() == 2) {
                if (predicates.get(0).getBiPredicate() == Compare.gte && predicates.get(1).getBiPredicate() == Compare.lt) {
                    replacedStep.addHasContainer(hasContainer);
                    result.add(hasContainer);
                }
            }
        }
    }
    return result;
}