def test_query_repr_str():
    assert repr(Query("teststr")) == "Query(teststr)"


def test_query_repr_none():
    assert repr(Query(None)) == "Query(None)"


def test_query_repr_ellipsis():
    assert repr(Query(...)) == "Query(PydanticUndefined)"


def test_query_repr_number():
    assert repr(Query(1)) == "Query(1)"


def test_query_repr_list():
    assert repr(Query([])) == "Query([])"

而你不需要為該參數宣告其他內容，所以其實不需要用 `Query`。

但你仍需要為路徑參數 `item_id` 使用 `Path`，而且基於某些理由你不想用 `Annotated`。

如果你把有「預設值」的參數放在沒有「預設值」的參數之前，Python 會抱怨。

但你可以調整它們的順序，先放沒有預設值（查詢參數 `q`）的參數。

對 **FastAPI** 來說沒差。它會依參數名稱、型別與預設宣告（`Query`、`Path` 等）來辨識參數，並不在意順序。

因此，你可以這樣宣告你的函式：

{* ../../docs_src/path_params_numeric_validations/tutorial002_py310.py hl[7] *}

但請記住，若使用 `Annotated`，你就不會有這個問題，因為你不是用函式參數預設值來放 `Query()` 或 `Path()`。

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

    /**
     * Converts a prefix query to a query builder.
     *
     * @param context the query context
     * @param prefixQuery the prefix query
     * @param boost the boost factor
     * @return the query builder
     */

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(
    q: str | None = Query(
        default=None,
        title="Query string",
        description="Query string for the items to search in the database that have a good match",
        min_length=3,
    ),
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})

	stmt, err := db.prepare(ctx, db.ConnPool, false, query)
	if err == nil {
		rows, err = stmt.QueryContext(ctx, args...)
		if errors.Is(err, driver.ErrBadConn) {
			db.Stmts.Delete(query)
		}
	}
	return rows, err
}

func (db *PreparedStmtDB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {

                "ratio of equals/hashCode/compareTo operations to query %s with %s entries versus"
                    + " %s entries",
                query, largeSize, smallSize)
            .that(ratio)
            .isAtMost(
                2 * query.expectedAsymptotic(largeSize) / query.expectedAsymptotic(smallSize));
        // allow up to 2x wobble in the constant factors
      }
    }
  }

  private long getWorstCaseOps(

 */
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;

        assertTrue(str.contains("query"));
        assertTrue(str.contains(query));
    }

    @Test
    public void test_query_complexFessSyntax() {
        final String query = "title:\"security policy\"^2 OR (+security +policy (guide OR document))";
        final IntentDetectionResult result = IntentDetectionResult.search(query, "complex query");

        assertEquals(query, result.getQuery());
    }

    @Test

import org.opensearch.core.xcontent.XContentParser;
import org.opensearch.index.query.AbstractQueryBuilder;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryShardContext;

/**
 * A query builder for a stored LTR (Learning to Rank) query.
 * This builder constructs a query that uses a pre-trained LTR model
 * to re-rank search results based on a given set of features.
 */

        public IndexSearcher searcher() {
            return null;
        }

        @Override
        public Query buildQuery(QueryBuilder builder) throws IOException {
            throw new UnsupportedOperationException();
        }

        @Override
        public Query filterQuery(Query query) {
            throw new UnsupportedOperationException();
        }

        @Override