public ActionRequestValidationException validate()

in server/src/main/java/org/elasticsearch/search/builder/SearchSourceBuilder.java [2203:2338]
133 lines of code
45 McCabe index (conditional complexity)

    public ActionRequestValidationException validate(
        ActionRequestValidationException validationException,
        boolean isScroll,
        boolean allowPartialSearchResults
    ) {
        if (retriever() != null) {
            validationException = retriever().validate(this, validationException, isScroll, allowPartialSearchResults);
            List<String> specified = new ArrayList<>();
            if (subSearches().isEmpty() == false) {
                specified.add(QUERY_FIELD.getPreferredName());
            }
            if (knnSearch().isEmpty() == false) {
                specified.add(KNN_FIELD.getPreferredName());
            }
            if (searchAfter() != null) {
                specified.add(SEARCH_AFTER.getPreferredName());
            }
            if (terminateAfter() != DEFAULT_TERMINATE_AFTER) {
                specified.add(TERMINATE_AFTER_FIELD.getPreferredName());
            }
            if (sorts() != null) {
                specified.add(SORT_FIELD.getPreferredName());
            }
            if (rankBuilder() != null) {
                specified.add(RANK_FIELD.getPreferredName());
            }
            if (rescores() != null) {
                specified.add(RESCORE_FIELD.getPreferredName());
            }
            if (specified.isEmpty() == false) {
                validationException = addValidationError(
                    "cannot specify [" + RETRIEVER.getPreferredName() + "] and " + specified,
                    validationException
                );
            }
        }
        if (isScroll) {
            if (trackTotalHitsUpTo() != null && trackTotalHitsUpTo() != SearchContext.TRACK_TOTAL_HITS_ACCURATE) {
                validationException = addValidationError(
                    "disabling [track_total_hits] is not allowed in a scroll context",
                    validationException
                );
            }
            if (from() > 0) {
                validationException = addValidationError("using [from] is not allowed in a scroll context", validationException);
            }
            if (size() == 0) {
                validationException = addValidationError("[size] cannot be [0] in a scroll context", validationException);
            }
            if (rescores() != null && rescores().isEmpty() == false) {
                validationException = addValidationError("using [rescore] is not allowed in a scroll context", validationException);
            }
            if (CollectionUtils.isEmpty(searchAfter()) == false) {
                validationException = addValidationError("[search_after] cannot be used in a scroll context", validationException);
            }
            if (collapse() != null) {
                validationException = addValidationError("cannot use `collapse` in a scroll context", validationException);
            }
        }
        if (slice() != null) {
            if (pointInTimeBuilder() == null && (isScroll == false)) {
                validationException = addValidationError(
                    "[slice] can only be used with [scroll] or [point-in-time] requests",
                    validationException
                );
            }
        }
        if (from() > 0 && CollectionUtils.isEmpty(searchAfter()) == false) {
            validationException = addValidationError("[from] parameter must be set to 0 when [search_after] is used", validationException);
        }
        if (storedFields() != null) {
            if (storedFields().fetchFields() == false) {
                if (fetchSource() != null && fetchSource().fetchSource()) {
                    validationException = addValidationError(
                        "[stored_fields] cannot be disabled if [_source] is requested",
                        validationException
                    );
                }
                if (fetchFields() != null) {
                    validationException = addValidationError(
                        "[stored_fields] cannot be disabled when using the [fields] option",
                        validationException
                    );
                }
            }
        }
        if (subSearches().size() >= 2 && rankBuilder() == null) {
            validationException = addValidationError("[sub_searches] requires [rank]", validationException);
        }
        if (aggregations() != null) {
            validationException = aggregations().validate(validationException);
        }

        if (rankBuilder() != null) {
            int s = size() == -1 ? SearchService.DEFAULT_SIZE : size();
            if (s == 0) {
                validationException = addValidationError("[rank] requires [size] greater than [0]", validationException);
            }
            if (s > rankBuilder().rankWindowSize()) {
                validationException = addValidationError(
                    "[rank] requires [rank_window_size: "
                        + rankBuilder().rankWindowSize()
                        + "]"
                        + " be greater than or equal to [size: "
                        + s
                        + "]",
                    validationException
                );
            }
            int queryCount = subSearches().size() + knnSearch().size();
            if (rankBuilder().isCompoundBuilder() && queryCount < 2) {
                validationException = addValidationError(
                    "[rank] requires a minimum of [2] result sets using a combination of sub searches and/or knn searches",
                    validationException
                );
            }
            if (isScroll) {
                validationException = addValidationError("[rank] cannot be used in a scroll context", validationException);
            }
            if (rescores() != null && rescores().isEmpty() == false) {
                validationException = addValidationError("[rank] cannot be used with [rescore]", validationException);
            }

            if (suggest() != null && suggest().getSuggestions().isEmpty() == false) {
                validationException = addValidationError("[rank] cannot be used with [suggest]", validationException);
            }
        }

        if (rescores() != null) {
            for (@SuppressWarnings("rawtypes")
            var rescorer : rescores()) {
                validationException = rescorer.validate(this, validationException);
            }
        }
        return validationException;
    }