private AtlasGraphTraversal traverse()

in repository/src/main/java/org/apache/atlas/query/executors/GremlinClauseToTraversalTranslator.java [99:257]
120 lines of code
38 McCabe index (conditional complexity)

        private AtlasGraphTraversal traverse(AtlasGraphTraversal traversal, Stack<List<AtlasGraphTraversal>> trLists, GremlinQueryComposer.GremlinClauseValue clauseValue) {
            GremlinClause clause = clauseValue.getClause();
            String[]      values = clauseValue.getValues();

            switch (clause) {
                case G:
                    break;

                case V:
                    traversal = graph.V();
                    break;

                case AS:
                    traversal.as(values[0]);
                    break;

                case AND: {
                    if (trLists != null && !trLists.peek().isEmpty()) {
                        List<AtlasGraphTraversal> subTraversals = trLists.pop();

                        traversal.and(subTraversals.toArray(new Traversal[0]));
                    } else {
                        throw new RuntimeException("subTraversals not expected to be NULL: " + clause);
                    }
                }
                break;

                case OR: {
                    if (trLists != null && !trLists.peek().isEmpty()) {
                        List<AtlasGraphTraversal> subTraversals = trLists.pop();

                        traversal.or(subTraversals.toArray(new Traversal[0]));
                    } else {
                        throw new RuntimeException("subTraversals not expected to be NULL: " + clause);
                    }
                }
                break;

                case HAS_PROPERTY:
                    traversal.has(values[0]);
                    break;

                case HAS_NOT_PROPERTY:
                    traversal.hasNot(values[0]);
                    break;

                case HAS_OPERATOR:
                    P<?> predicate = getPredicate(values[1], values[2], clauseValue.getRawValue());

                    traversal.has(values[0], predicate);
                    break;

                case HAS_NOT_OPERATOR:
                    traversal.or(traversal.startAnonymousTraversal().has(values[0], P.neq(values[1])), traversal.startAnonymousTraversal().hasNot(values[0]));
                    break;

                case HAS_TYPE:
                    traversal.has(Constants.TYPE_NAME_PROPERTY_KEY, values[0]);
                    break;

                case HAS_WITHIN:
                    traversal.has(values[0], values[1]);
                    break;

                case IN:
                    traversal.in(removeRedundantQuotes(values[0]));
                    break;

                case OUT:
                    traversal.out(removeRedundantQuotes(values[0]));
                    break;

                case ANY_TRAIT:
                    traversal.or(traversal.startAnonymousTraversal().has(EDGE_NAME_TRAIT_NAMES), traversal.startAnonymousTraversal().has(EDGE_NAME_PROPAGATED_TRAIT_NAMES));
                    break;

                case TRAIT:
                    traversal.outE(EDGE_NAME_CLASSIFIED_AS).has(ATTR_PROPERTY_NAME, P.within(values[0])).outV();
                    break;

                case NO_TRAIT:
                    traversal.and(traversal.startAnonymousTraversal().hasNot(EDGE_NAME_TRAIT_NAMES), traversal.startAnonymousTraversal().hasNot(EDGE_NAME_PROPAGATED_TRAIT_NAMES));
                    break;

                case DEDUP:
                    traversal.dedup();
                    break;

                case LIMIT:
                    traversal.limit(Scope.global, Long.parseLong(values[0]));
                    break;

                case TO_LIST:
                    traversal.getAtlasVertexList();
                    break;

                case NESTED_START:
                    traversal = traversal.startAnonymousTraversal();

                    trLists.peek().add(traversal);
                    break;

                case HAS_TYPE_WITHIN:
                    String[] subTypes = StringUtils.split(removeRedundantQuotes(values[0]), ',');

                    traversal.has("__typeName", P.within(subTypes));
                    break;

                case GROUP_BY:
                    traversal.has(values[0]).group().by(values[0]);
                    break;

                case ORDER_BY:
                    traversal.has(values[0]).order().by(values[0]);
                    break;

                case ORDER_BY_DESC:
                    traversal.has(values[0]).order().by(values[0], Order.desc);
                    break;

                case STRING_CONTAINS:
                    traversal.textRegEx(values[0], removeRedundantQuotes(values[1]));
                    break;

                case TEXT_CONTAINS:
                    traversal.textContainsRegEx(values[0], removeRedundantQuotes(values[1]));
                    break;

                case RANGE:
                    traversal.dedup();

                    long low = Long.parseLong(values[1]);
                    long high = low + Long.parseLong(values[2]);

                    traversal.range(Scope.global, low, high);
                    break;

                case SELECT_FN:
                case SELECT_NOOP_FN:
                case SELECT_ONLY_AGG_GRP_FN:
                case INLINE_TRANSFORM_CALL:
                case SELECT_MULTI_ATTR_GRP_FN:
                    break;

                case TERM:
                    String term = String.format("AtlasGlossaryTerm.%s", values[0]);

                    traversal.where(traversal.startAnonymousTraversal()
                                    .in(org.apache.atlas.repository.Constants.TERM_ASSIGNMENT_LABEL)
                                    .has(term, P.eq(values[1])));
                    break;

                default:
                    LOG.warn("Clause not translated: {}. Can potentially lead to incorrect results.", clause);
                    break;
            }

            return traversal;
        }