"Invalid sort order: " + termQuery);
                }
            } else {
                sortOrder = SortOrder.ASC;
            }
            context.addSorts(createFieldSortBuilder(sortField, sortOrder));
        }));
        return null;
    }

    /**
     * Converts a term query for the default field with fuzzy matching support.
     *

        buildRoleQuery(queryContext, searchRequestType);
        buildVirtualHostQuery(queryContext, searchRequestType);

        if (!queryContext.hasSorts() && defaultSortBuilders != null) {
            queryContext.addSorts(defaultSortBuilders);
        }
        return queryContext;
    }

    /**
     * Builds virtual host query filters to restrict search results to the current virtual host.

        this.queryBuilder = queryBuilder;
    }

    /**
     * Adds a sort builder.
     * @param sortBuilder The sort builder.
     */
    public void addSort(final SortBuilder<?> sortBuilder) {
        sortList.add(sortBuilder);
    }

    /**
     * Sets the limit document number percentage.
     * @param limitPercentage The limit percentage as a string (e.g., "50%").

            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

        if (_conditionAggregation != null) {
            _conditionAggregation.getAggregationBuilderList().forEach(builder::addAggregation);
        }

                            flist.toArray(new FunctionScoreQueryBuilder.FilterFunctionBuilder[flist.size()]))
                    .boostMode(CombineFunction.MULTIPLY));
            reader.addSort(SortBuilders.fieldSort(fessConfig.getIndexFieldClickCount()));
            reader.addSort(SortBuilders.scoreSort());
            return reader;
        }, docPerReq, () -> {
            systemHelper.calibrateCpuLoad();
            ThreadUtil.sleep(interval);

        // set query.
        final QueryBuilder q = buildQuery(query, fields);

        // set function score
        final QueryBuilder queryBuilder = buildFunctionScoreQuery(query, q);
        builder.addSort("_score", SortOrder.DESC);

        // set filter query.
        final List<QueryBuilder> filterList = new ArrayList<>(10);
        if (!tags.isEmpty()) {

                final int maxDocumentCacheSize = fessConfig.getIndexerWebfsMaxDocumentCacheSizeAsInteger();
                builder.setSize(maxDocumentCacheSize <= 0 ? 1 : maxDocumentCacheSize);
                builder.addSort(OpenSearchAccessResult.CREATE_TIME, SortOrder.ASC);
            };

            final DocList docList = new DocList();
            final List<OpenSearchAccessResult> accessResultList = new ArrayList<>();

                builder.setQuery(QueryBuilders.matchAllQuery());
            }
            if (sortBuilders != null) {
                for (SortBuilder<?> sortBuilder : sortBuilders) {
                    builder.addSort(sortBuilder);
                }
            }
            if (from != null) {
                builder.setFrom(from);
            }
            if (size != null) {
                builder.setSize(size);