private Query deserializeNode()

in nouveau/src/main/java/org/apache/couchdb/nouveau/lucene9/QueryDeserializer.java [51:115]
65 lines of code
15 McCabe index (conditional complexity)

    private Query deserializeNode(final JsonParser parser, final DeserializationContext context, final JsonNode node)
            throws IOException, JsonProcessingException {
        final String type = get(parser, node, "@type").asText();
        switch (type) {
            case "term": {
                final String field = get(parser, node, "field").asText();
                final String text = get(parser, node, "text").asText();
                return new TermQuery(new Term(field, text));
            }
            case "boolean": {
                if (!get(parser, node, "clauses").isArray()) {
                    throw new JsonParseException(parser, "boolean clauses must be an array");
                }
                final BooleanQuery.Builder builder = new BooleanQuery.Builder();
                final Iterator<JsonNode> it = get(parser, node, "clauses").elements();
                while (it.hasNext()) {
                    final Query q = deserializeNode(parser, context, it.next());
                    builder.add(q, null);
                }
                return builder.build();
            }
            case "wildcard": {
                final String field = get(parser, node, "field").asText();
                final String text = get(parser, node, "text").asText();
                return new WildcardQuery(new Term(field, text));
            }
            case "phrase": {
                final String field = get(parser, node, "field").asText();
                if (!get(parser, node, "terms").isArray()) {
                    throw new JsonParseException(parser, "phrase terms must be an array");
                }
                final PhraseQuery.Builder builder = new PhraseQuery.Builder();
                final Iterator<JsonNode> it = get(parser, node, "terms").elements();
                while (it.hasNext()) {
                    builder.add(new Term(field, it.next().asText()));
                }
                builder.setSlop(getInt(parser, node, "slop", 0));
                return builder.build();
            }
            case "prefix": {
                final String field = get(parser, node, "field").asText();
                final String text = get(parser, node, "text").asText();
                return new PrefixQuery(new Term(field, text));
            }
            case "fuzzy": {
                final String field = get(parser, node, "field").asText();
                final String text = get(parser, node, "text").asText();
                final int maxEdits = getInt(parser, node, "max_edits", 2);
                final int prefixLength = getInt(parser, node, "prefix_length", 0);
                return new FuzzyQuery(new Term(field, text), maxEdits, prefixLength);
            }
            case "regexp": {
                final String field = get(parser, node, "field").asText();
                final String text = get(parser, node, "text").asText();
                return new RegexpQuery(new Term(field, text));
            }
            case "term_range": {
            }
            case "point_range": {
            }
            case "match_all":
                return new MatchAllDocsQuery();
        }
        throw new JsonParseException(parser, type + " not a supported query type");
    }