t.Errorf("select max(id)")
	}
}

func TestComplexScopes(t *testing.T) {
	tests := []struct {
		name     string
		queryFn  func(tx *gorm.DB) *gorm.DB
		expected string
	}{
		{
			name: "depth_1",
			queryFn: func(tx *gorm.DB) *gorm.DB {
				return tx.Scopes(
					func(d *gorm.DB) *gorm.DB { return d.Where("a = 1") },
					func(d *gorm.DB) *gorm.DB {

 */
package org.codelibs.fess.query;

import java.io.IOException;
import java.util.Objects;

import org.apache.lucene.search.Query;
import org.opensearch.core.common.io.stream.StreamOutput;
import org.opensearch.core.xcontent.XContentBuilder;
import org.opensearch.index.query.BoolQueryBuilder;
import org.opensearch.index.query.DisMaxQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

     * @return the parsed Query object
     * @throws QueryParseException if the query cannot be parsed
     */
    public Query parse(final String query) {
        return filterChain.parse(query);
    }

    /**
     * Creates a new Lucene query parser with the current configuration.
     * The parser is configured with the default field, analyzer, wildcard settings,
     * and default operator.
     *

    /**
     * Gets the class name of the query this command handles.
     * @return The query class name.
     */
    protected abstract String getQueryClassName();

    /**
     * Registers this query command with the query processor.
     * Associates this command with its query class name in the processor.
     */

                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a wildcard query to an appropriate OpenSearch QueryBuilder.
     *
     * @param context The query context containing field and search information
     * @param wildcardQuery The Lucene wildcard query to convert
     * @param boost The boost factor to apply to the query
     * @return The converted OpenSearch QueryBuilder

import org.opensearch.index.query.BoolQueryBuilder;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
import org.opensearch.index.query.functionscore.ScoreFunctionBuilder;
import org.opensearch.index.query.functionscore.ScoreFunctionBuilders;

                    },
                    "summary": "Get Query",
                    "operationId": "get_query_query_get",
                    "parameters": [
                        {
                            "required": True,
                            "schema": {"title": "Query"},
                            "name": "query",
                            "in": "query",
                        }
                    ],

                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a phrase query to a query builder.
     *
     * @param context the query context
     * @param phraseQuery the phrase query
     * @param boost the boost factor
     * @return the query builder
     */

		var first, last User
		if err := DB.Where("id = ?", users[0].ID).First(&first).Error; err != nil {
			t.Errorf("errors happened when query before user: %v", err)
		}
		CheckUser(t, first, *users[0])

		if err := DB.Where("id = ?", users[2].ID).First(&last).Error; err != nil {
			t.Errorf("errors happened when query after user: %v", err)
		}
		CheckUser(t, last, *users[2])
	}

	if err := DB.Create(&users).Error; err != nil {

     */
    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final FuzzyQuery fuzzyQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("FuzzyQuery: query={}, boost={}", query, boost);
            }
            return convertFuzzyQuery(context, fuzzyQuery, boost);
        }