Query#

Query classes in RedisVL provide a structured way to define simple or complex queries for different use cases. Each query class wraps the redis-py Query module redis/redis-py with extended functionality for ease-of-use.

VectorQuery#

class VectorQuery(vector, vector_field_name, return_fields=None, filter_expression=None, dtype='float32', num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, hybrid_policy=None, batch_size=None, normalize_vector_distance=False)[source]#

Bases: BaseVectorQuery, BaseQuery

A query for running a vector search along with an optional filter expression.

Parameters:

vector (List[float]) – The vector to perform the vector search with.
vector_field_name (str) – The name of the vector field to search against in the database.
return_fields (List[str]) – The declared fields to return with search results.
filter_expression (Union[str, FilterExpression], optional) – A filter to apply along with the vector search. Defaults to None.
dtype (str, optional) – The dtype of the vector. Defaults to “float32”.
num_results (int, optional) – The top k results to return from the vector search. Defaults to 10.
return_score (bool, optional) – Whether to return the vector distance. Defaults to True.
dialect (int, optional) – The RediSearch query dialect. Defaults to 2.
sort_by (Optional[str]) – The field to order the results by. Defaults to None. Results will be ordered by vector distance.
in_order (bool) – Requires the terms in the field to have the same order as the terms in the query filter, regardless of the offsets between them. Defaults to False.
hybrid_policy (Optional[str]) – Controls how filters are applied during vector search. Options are “BATCHES” (paginates through small batches of nearest neighbors) or “ADHOC_BF” (computes scores for all vectors passing the filter). “BATCHES” mode is typically faster for queries with selective filters. “ADHOC_BF” mode is better when filters match a large portion of the dataset. Defaults to None, which lets Redis auto-select the optimal policy.
batch_size (Optional[int]) – When hybrid_policy is “BATCHES”, controls the number of vectors to fetch in each batch. Larger values may improve performance at the cost of memory usage. Only applies when hybrid_policy=”BATCHES”. Defaults to None, which lets Redis auto-select an appropriate batch size.
normalize_vector_distance (bool) – Redis supports 3 distance metrics: L2 (euclidean), IP (inner product), and COSINE. By default, L2 distance returns an unbounded value. COSINE distance returns a value between 0 and 2. IP returns a value determined by the magnitude of the vector. Setting this flag to true converts COSINE and L2 distance to a similarity score between 0 and 1. Note: setting this flag to true for IP will throw a warning since by definition COSINE similarity is normalized IP.

Raises:

TypeError – If filter_expression is not of type redisvl.query.FilterExpression

Note

Learn more about vector queries in Redis: https://redis.io/docs/interact/search-and-query/search/vectors/#knn-search

dialect(dialect)#

Add a dialect field to the query.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: Query

expander(expander)#

Add a expander field to the query.

expander - the name of the expander

Parameters:: expander (str)
Return type:: Query

in_order()#

Match only documents where the query terms appear in the same order in the document. i.e. for the query “hello world”, we do not match “world hello”

Return type:: Query

language(language)#

Analyze the query as being in the specified language.

Parameters:: language (str) – The language (e.g. chinese or english)
Return type:: Query

limit_fields(*fields)#

Limit the search to specific TEXT fields only.

fields: A list of strings, case sensitive field names

from the defined schema.

Parameters:: fields (List[str])
Return type:: Query

limit_ids(*ids)#

Limit the results to a specific set of pre-known document ids of any length.

Return type:: Query

no_content()#

Set the query to only return ids and not the document content.

Return type:: Query

no_stopwords()#

Prevent the query from being filtered for stopwords. Only useful in very big queries that you are certain contain no stopwords.

Return type:: Query

paging(offset, num)#

Set the paging for the query (defaults to 0..10).

offset: Paging offset for the results. Defaults to 0
num: How many results do we want

Parameters:

offset (int)
num (int)

Return type:

Query

query_string()#

Return the query string of this query only.

Return type:: str

return_fields(*fields)#

Add fields to return fields.

Return type:: Query

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: Query

set_batch_size(batch_size)[source]#

Set the batch size for the query.

Parameters:

batch_size (int) – The batch size to use when hybrid_policy is “BATCHES”.

Raises:

TypeError – If batch_size is not an integer
ValueError – If batch_size is not positive

set_filter(filter_expression=None)#

Set the filter expression for the query.

Parameters:: filter_expression (Optional[Union[str, FilterExpression]], optional) – The filter expression or query string to use on the query.
Raises:: TypeError – If filter_expression is not a valid FilterExpression or string.

set_hybrid_policy(hybrid_policy)[source]#

Set the hybrid policy for the query.

Parameters:: hybrid_policy (str) – The hybrid policy to use. Options are “BATCHES” or “ADHOC_BF”.
Raises:: ValueError – If hybrid_policy is not one of the valid options

slop(slop)#

Allow a maximum of N intervening non matched terms between phrase terms (0 means exact phrase).

Parameters:: slop (int)
Return type:: Query

sort_by(field, asc=True)#

Add a sortby field to the query.

field - the name of the field to sort by
asc - when True, sorting will be done in asceding order

Parameters:

field (str)
asc (bool)

Return type:

Query

timeout(timeout)#

overrides the timeout parameter of the module

Parameters:: timeout (float)
Return type:: Query

verbatim()#

Set the query to be verbatim, i.e. use no query expansion or stemming.

Return type:: Query

with_payloads()#

Ask the engine to return document payloads.

Return type:: Query

with_scores()#

Ask the engine to return document search scores.

Return type:: Query

property batch_size: int | None#

Return the batch size for the query.

Returns:: The batch size for the query.
Return type:: Optional[int]

property filter: str | FilterExpression#: The filter expression for the query.

property hybrid_policy: str | None#

Return the hybrid policy for the query.

Returns:: The hybrid policy for the query.
Return type:: Optional[str]

property params: Dict[str, Any]#

Return the parameters for the query.

Returns:: The parameters for the query.
Return type:: Dict[str, Any]

property query: BaseQuery#: Return self as the query object.

VectorRangeQuery#

class VectorRangeQuery(vector, vector_field_name, return_fields=None, filter_expression=None, dtype='float32', distance_threshold=0.2, epsilon=None, num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, hybrid_policy=None, batch_size=None, normalize_vector_distance=False)[source]#

Bases: BaseVectorQuery, BaseQuery

A query for running a filtered vector search based on semantic distance threshold.

Parameters:

vector (List[float]) – The vector to perform the range query with.
vector_field_name (str) – The name of the vector field to search against in the database.
return_fields (List[str]) – The declared fields to return with search results.
filter_expression (Union[str, FilterExpression], optional) – A filter to apply along with the range query. Defaults to None.
dtype (str, optional) – The dtype of the vector. Defaults to “float32”.
distance_threshold (float) – The threshold for vector distance. A smaller threshold indicates a stricter semantic search. Defaults to 0.2.
epsilon (Optional[float]) – The relative factor for vector range queries, setting boundaries for candidates within radius * (1 + epsilon). This controls how extensive the search is beyond the specified radius. Higher values increase recall at the expense of performance. Defaults to None, which uses the index-defined epsilon (typically 0.01).
num_results (int) – The MAX number of results to return. Defaults to 10.
return_score (bool, optional) – Whether to return the vector distance. Defaults to True.
dialect (int, optional) – The RediSearch query dialect. Defaults to 2.
sort_by (Optional[str]) – The field to order the results by. Defaults to None. Results will be ordered by vector distance.
in_order (bool) – Requires the terms in the field to have the same order as the terms in the query filter, regardless of the offsets between them. Defaults to False.
hybrid_policy (Optional[str]) – Controls how filters are applied during vector search. Options are “BATCHES” (paginates through small batches of nearest neighbors) or “ADHOC_BF” (computes scores for all vectors passing the filter). “BATCHES” mode is typically faster for queries with selective filters. “ADHOC_BF” mode is better when filters match a large portion of the dataset. Defaults to None, which lets Redis auto-select the optimal policy.
batch_size (Optional[int]) – When hybrid_policy is “BATCHES”, controls the number of vectors to fetch in each batch. Larger values may improve performance at the cost of memory usage. Only applies when hybrid_policy=”BATCHES”. Defaults to None, which lets Redis auto-select an appropriate batch size.
normalize_vector_distance (bool) – Redis supports 3 distance metrics: L2 (euclidean), IP (inner product), and COSINE. By default, L2 distance returns an unbounded value. COSINE distance returns a value between 0 and 2. IP returns a value determined by the magnitude of the vector. Setting this flag to true converts COSINE and L2 distance to a similarity score between 0 and 1. Note: setting this flag to true for IP will throw a warning since by definition COSINE similarity is normalized IP.

Raises:

TypeError – If filter_expression is not of type redisvl.query.FilterExpression

Note

Learn more about vector range queries: https://redis.io/docs/interact/search-and-query/search/vectors/#range-query

dialect(dialect)#

Add a dialect field to the query.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: Query

expander(expander)#

Add a expander field to the query.

expander - the name of the expander

Parameters:: expander (str)
Return type:: Query

in_order()#

Match only documents where the query terms appear in the same order in the document. i.e. for the query “hello world”, we do not match “world hello”

Return type:: Query

language(language)#

Analyze the query as being in the specified language.

Parameters:: language (str) – The language (e.g. chinese or english)
Return type:: Query

limit_fields(*fields)#

Limit the search to specific TEXT fields only.

fields: A list of strings, case sensitive field names

from the defined schema.

Parameters:: fields (List[str])
Return type:: Query

limit_ids(*ids)#

Limit the results to a specific set of pre-known document ids of any length.

Return type:: Query

no_content()#

Set the query to only return ids and not the document content.

Return type:: Query

no_stopwords()#

Prevent the query from being filtered for stopwords. Only useful in very big queries that you are certain contain no stopwords.

Return type:: Query

paging(offset, num)#

Set the paging for the query (defaults to 0..10).

offset: Paging offset for the results. Defaults to 0
num: How many results do we want

Parameters:

offset (int)
num (int)

Return type:

Query

query_string()#

Return the query string of this query only.

Return type:: str

return_fields(*fields)#

Add fields to return fields.

Return type:: Query

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: Query

set_batch_size(batch_size)[source]#

Set the batch size for the query.

Parameters:

batch_size (int) – The batch size to use when hybrid_policy is “BATCHES”.

Raises:

TypeError – If batch_size is not an integer
ValueError – If batch_size is not positive

set_distance_threshold(distance_threshold)[source]#

Set the distance threshold for the query.

Parameters:

distance_threshold (float) – Vector distance threshold.

Raises:

TypeError – If distance_threshold is not a float or int
ValueError – If distance_threshold is negative

set_epsilon(epsilon)[source]#

Set the epsilon parameter for the range query.

Parameters:

epsilon (float) – The relative factor for vector range queries, setting boundaries for candidates within radius * (1 + epsilon).

Raises:

TypeError – If epsilon is not a float or int
ValueError – If epsilon is negative

set_filter(filter_expression=None)#

Set the filter expression for the query.

Parameters:: filter_expression (Optional[Union[str, FilterExpression]], optional) – The filter expression or query string to use on the query.
Raises:: TypeError – If filter_expression is not a valid FilterExpression or string.

set_hybrid_policy(hybrid_policy)[source]#

Set the hybrid policy for the query.

Parameters:: hybrid_policy (str) – The hybrid policy to use. Options are “BATCHES” or “ADHOC_BF”.
Raises:: ValueError – If hybrid_policy is not one of the valid options

slop(slop)#

Allow a maximum of N intervening non matched terms between phrase terms (0 means exact phrase).

Parameters:: slop (int)
Return type:: Query

sort_by(field, asc=True)#

Add a sortby field to the query.

field - the name of the field to sort by
asc - when True, sorting will be done in asceding order

Parameters:

field (str)
asc (bool)

Return type:

Query

timeout(timeout)#

overrides the timeout parameter of the module

Parameters:: timeout (float)
Return type:: Query

verbatim()#

Set the query to be verbatim, i.e. use no query expansion or stemming.

Return type:: Query

with_payloads()#

Ask the engine to return document payloads.

Return type:: Query

with_scores()#

Ask the engine to return document search scores.

Return type:: Query

property batch_size: int | None#

Return the batch size for the query.

Returns:: The batch size for the query.
Return type:: Optional[int]

property distance_threshold: float#

Return the distance threshold for the query.

Returns:: The distance threshold for the query.
Return type:: float

property epsilon: float | None#

Return the epsilon for the query.

Returns:: The epsilon for the query, or None if not set.
Return type:: Optional[float]

property filter: str | FilterExpression#: The filter expression for the query.

property hybrid_policy: str | None#

Return the hybrid policy for the query.

Returns:: The hybrid policy for the query.
Return type:: Optional[str]

property params: Dict[str, Any]#

Return the parameters for the query.

Returns:: The parameters for the query.
Return type:: Dict[str, Any]

property query: BaseQuery#: Return self as the query object.

HybridQuery#

class HybridQuery(text, text_field_name, vector, vector_field_name, text_scorer='BM25STD', filter_expression=None, alpha=0.7, dtype='float32', num_results=10, return_fields=None, stopwords='english', dialect=2)[source]#

Bases: AggregationQuery

HybridQuery combines text and vector search in Redis. It allows you to perform a hybrid search using both text and vector similarity. It scores documents based on a weighted combination of text and vector similarity.

from redisvl.query import HybridQuery
from redisvl.index import SearchIndex

index = SearchIndex.from_yaml("path/to/index.yaml")

query = HybridQuery(
    text="example text",
    text_field_name="text_field",
    vector=[0.1, 0.2, 0.3],
    vector_field_name="vector_field",
    text_scorer="BM25STD",
    filter_expression=None,
    alpha=0.7,
    dtype="float32",
    num_results=10,
    return_fields=["field1", "field2"],
    stopwords="english",
    dialect=2,
)

results = index.query(query)

Instantiates a HybridQuery object.

Parameters:

text (str) – The text to search for.
text_field_name (str) – The text field name to search in.
vector (Union[bytes, List[float]]) – The vector to perform vector similarity search.
vector_field_name (str) – The vector field name to search in.
text_scorer (str, optional) – The text scorer to use. Options are {TFIDF, TFIDF.DOCNORM, BM25, DISMAX, DOCSCORE, BM25STD}. Defaults to “BM25STD”.
filter_expression (Optional[FilterExpression], optional) – The filter expression to use. Defaults to None.
alpha (float, optional) – The weight of the vector similarity. Documents will be scored as: hybrid_score = (alpha) * vector_score + (1-alpha) * text_score. Defaults to 0.7.
dtype (str, optional) – The data type of the vector. Defaults to “float32”.
num_results (int, optional) – The number of results to return. Defaults to 10.
return_fields (Optional[List[str]], optional) – The fields to return. Defaults to None.
stopwords (Optional[Union[str, Set[str]]], optional) – The stopwords to remove from the provided text prior to searchuse. If a string such as “english” “german” is provided then a default set of stopwords for that language will be used. if a list, set, or tuple of strings is provided then those will be used as stopwords. Defaults to “english”. if set to “None” then no stopwords will be removed.
dialect (int, optional) – The Redis dialect version. Defaults to 2.

Raises:

ValueError – If the text string is empty, or if the text string becomes empty after stopwords are removed.
TypeError – If the stopwords are not a set, list, or tuple of strings.

add_scores()#

If set, includes the score as an ordinary field of the row.

Return type:: AggregateRequest

apply(**kwexpr)#

Specify one or more projection expressions to add to each result

### Parameters

kwexpr: One or more key-value pairs for a projection. The key is
the alias for the projection, and the value is the projection expression itself, for example apply(square_root=”sqrt(@foo)”)

Return type:: AggregateRequest

dialect(dialect)#

Add a dialect field to the aggregate command.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: AggregateRequest

filter(expressions)#

Specify filter for post-query results using predicates relating to values in the result set.

### Parameters

fields: Fields to group by. This can either be a single string,
or a list of strings.

Parameters:: expressions (str | List[str])
Return type:: AggregateRequest

group_by(fields, *reducers)#

Specify by which fields to group the aggregation.

### Parameters

fields: Fields to group by. This can either be a single string,
or a list of strings. both cases, the field should be specified as @field.
reducers: One or more reducers. Reducers may be found in the
aggregation module.

Parameters:

fields (List[str])
reducers (Reducer | List[Reducer])

Return type:

AggregateRequest

limit(offset, num)#

Sets the limit for the most recent group or query.

If no group has been defined yet (via group_by()) then this sets the limit for the initial pool of results from the query. Otherwise, this limits the number of items operated on from the previous group.

Setting a limit on the initial search results may be useful when attempting to execute an aggregation on a sample of a large data set.

### Parameters

offset: Result offset from which to begin paging
num: Number of results to return

Example of sorting the initial results:

` AggregateRequest("@sale_amount:[10000, inf]") .limit(0, 10) .group_by("@state", r.count()) `

Will only group by the states found in the first 10 results of the query @sale_amount:[10000, inf]. On the other hand,

` AggregateRequest("@sale_amount:[10000, inf]") .limit(0, 1000) .group_by("@state", r.count() .limit(0, 10) `

Will group all the results matching the query, but only return the first 10 groups.

If you only wish to return a top-N style query, consider using sort_by() instead.

Parameters:

offset (int)
num (int)

Return type:

AggregateRequest

load(*fields)#

Indicate the fields to be returned in the response. These fields are returned in addition to any others implicitly specified.

### Parameters

fields: If fields not specified, all the fields will be loaded.

Otherwise, fields should be given in the format of @field.

Parameters:: fields (List[str])
Return type:: AggregateRequest

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: AggregateRequest

sort_by(*fields, **kwargs)#

Indicate how the results should be sorted. This can also be used for top-N style queries

### Parameters

fields: The fields by which to sort. This can be either a single
field or a list of fields. If you wish to specify order, you can use the Asc or Desc wrapper classes.
max: Maximum number of results to return. This can be
used instead of LIMIT and is also faster.

Example of sorting by foo ascending and bar descending:

` sort_by(Asc("@foo"), Desc("@bar")) `

Return the top 10 customers:

` AggregateRequest() .group_by("@customer", r.sum("@paid").alias(FIELDNAME)) .sort_by(Desc("@paid"), max=10) `

Parameters:: fields (List[str])
Return type:: AggregateRequest

with_schema()#

If set, the schema property will contain a list of [field, type] entries in the result object.

Return type:: AggregateRequest

property params: Dict[str, Any]#

Return the parameters for the aggregation.

Returns:: The parameters for the aggregation.
Return type:: Dict[str, Any]

property stopwords: Set[str]#: Return the stopwords used in the query. :returns: The stopwords used in the query. :rtype: Set[str]

TextQuery#

class TextQuery(text, text_field_name, text_scorer='BM25STD', filter_expression=None, return_fields=None, num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, params=None, stopwords='english')[source]#

Bases: BaseQuery

TextQuery is a query for running a full text search, along with an optional filter expression.

from redisvl.query import TextQuery
from redisvl.index import SearchIndex

index = SearchIndex.from_yaml(index.yaml)

query = TextQuery(
    text="example text",
    text_field_name="text_field",
    text_scorer="BM25STD",
    filter_expression=None,
    num_results=10,
    return_fields=["field1", "field2"],
    stopwords="english",
    dialect=2,
)

results = index.query(query)

A query for running a full text search, along with an optional filter expression.

Parameters:

text (str) – The text string to perform the text search with.
text_field_name (str) – The name of the document field to perform text search on.
text_scorer (str, optional) – The text scoring algorithm to use. Defaults to BM25STD. Options are {TFIDF, BM25STD, BM25, TFIDF.DOCNORM, DISMAX, DOCSCORE}. See https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/scoring/
filter_expression (Union[str, FilterExpression], optional) – A filter to apply along with the text search. Defaults to None.
return_fields (List[str]) – The declared fields to return with search results.
num_results (int, optional) – The top k results to return from the search. Defaults to 10.
return_score (bool, optional) – Whether to return the text score. Defaults to True.
dialect (int, optional) – The RediSearch query dialect. Defaults to 2.
sort_by (Optional[str]) – The field to order the results by. Defaults to None. Results will be ordered by text score.
in_order (bool) – Requires the terms in the field to have the same order as the terms in the query filter, regardless of the offsets between them. Defaults to False.
params (Optional[Dict[str, Any]], optional) – The parameters for the query. Defaults to None.
stopwords (Optional[Union[str, Set[str]]) – The set of stop words to remove from the query text. If a language like ‘english’ or ‘spanish’ is provided a default set of stopwords for that language will be used. Users may specify their own stop words by providing a List or Set of words. if set to None, then no words will be removed. Defaults to ‘english’.

Raises:

ValueError – if stopwords language string cannot be loaded.
TypeError – If stopwords is not a valid iterable set of strings.

dialect(dialect)#

Add a dialect field to the query.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: Query

expander(expander)#

Add a expander field to the query.

expander - the name of the expander

Parameters:: expander (str)
Return type:: Query

in_order()#

Match only documents where the query terms appear in the same order in the document. i.e. for the query “hello world”, we do not match “world hello”

Return type:: Query

language(language)#

Analyze the query as being in the specified language.

Parameters:: language (str) – The language (e.g. chinese or english)
Return type:: Query

limit_fields(*fields)#

Limit the search to specific TEXT fields only.

fields: A list of strings, case sensitive field names

from the defined schema.

Parameters:: fields (List[str])
Return type:: Query

limit_ids(*ids)#

Limit the results to a specific set of pre-known document ids of any length.

Return type:: Query

no_content()#

Set the query to only return ids and not the document content.

Return type:: Query

no_stopwords()#

Prevent the query from being filtered for stopwords. Only useful in very big queries that you are certain contain no stopwords.

Return type:: Query

paging(offset, num)#

Set the paging for the query (defaults to 0..10).

offset: Paging offset for the results. Defaults to 0
num: How many results do we want

Parameters:

offset (int)
num (int)

Return type:

Query

query_string()#

Return the query string of this query only.

Return type:: str

return_fields(*fields)#

Add fields to return fields.

Return type:: Query

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: Query

set_filter(filter_expression=None)#

Set the filter expression for the query.

Parameters:: filter_expression (Optional[Union[str, FilterExpression]], optional) – The filter expression or query string to use on the query.
Raises:: TypeError – If filter_expression is not a valid FilterExpression or string.

slop(slop)#

Allow a maximum of N intervening non matched terms between phrase terms (0 means exact phrase).

Parameters:: slop (int)
Return type:: Query

sort_by(field, asc=True)#

Add a sortby field to the query.

field - the name of the field to sort by
asc - when True, sorting will be done in asceding order

Parameters:

field (str)
asc (bool)

Return type:

Query

timeout(timeout)#

overrides the timeout parameter of the module

Parameters:: timeout (float)
Return type:: Query

verbatim()#

Set the query to be verbatim, i.e. use no query expansion or stemming.

Return type:: Query

with_payloads()#

Ask the engine to return document payloads.

Return type:: Query

with_scores()#

Ask the engine to return document search scores.

Return type:: Query

property filter: str | FilterExpression#: The filter expression for the query.

property params: Dict[str, Any]#: Return the query parameters.

property query: BaseQuery#: Return self as the query object.

FilterQuery#

class FilterQuery(filter_expression=None, return_fields=None, num_results=10, dialect=2, sort_by=None, in_order=False, params=None)[source]#

Bases: BaseQuery

A query for running a filtered search with a filter expression.

Parameters:

filter_expression (Optional[Union[str, FilterExpression]]) – The optional filter expression to query with. Defaults to ‘*’.
return_fields (Optional[List[str]], optional) – The fields to return.
num_results (Optional[int], optional) – The number of results to return. Defaults to 10.
dialect (int, optional) – The query dialect. Defaults to 2.
sort_by (Optional[str], optional) – The field to order the results by. Defaults to None.
in_order (bool, optional) – Requires the terms in the field to have the same order as the terms in the query filter. Defaults to False.
params (Optional[Dict[str, Any]], optional) – The parameters for the query. Defaults to None.

Raises:

TypeError – If filter_expression is not of type redisvl.query.FilterExpression

dialect(dialect)#

Add a dialect field to the query.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: Query

expander(expander)#

Add a expander field to the query.

expander - the name of the expander

Parameters:: expander (str)
Return type:: Query

in_order()#

Match only documents where the query terms appear in the same order in the document. i.e. for the query “hello world”, we do not match “world hello”

Return type:: Query

language(language)#

Analyze the query as being in the specified language.

Parameters:: language (str) – The language (e.g. chinese or english)
Return type:: Query

limit_fields(*fields)#

Limit the search to specific TEXT fields only.

fields: A list of strings, case sensitive field names

from the defined schema.

Parameters:: fields (List[str])
Return type:: Query

limit_ids(*ids)#

Limit the results to a specific set of pre-known document ids of any length.

Return type:: Query

no_content()#

Set the query to only return ids and not the document content.

Return type:: Query

no_stopwords()#

Prevent the query from being filtered for stopwords. Only useful in very big queries that you are certain contain no stopwords.

Return type:: Query

paging(offset, num)#

Set the paging for the query (defaults to 0..10).

offset: Paging offset for the results. Defaults to 0
num: How many results do we want

Parameters:

offset (int)
num (int)

Return type:

Query

query_string()#

Return the query string of this query only.

Return type:: str

return_fields(*fields)#

Add fields to return fields.

Return type:: Query

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: Query

set_filter(filter_expression=None)#

Set the filter expression for the query.

Parameters:: filter_expression (Optional[Union[str, FilterExpression]], optional) – The filter expression or query string to use on the query.
Raises:: TypeError – If filter_expression is not a valid FilterExpression or string.

slop(slop)#

Allow a maximum of N intervening non matched terms between phrase terms (0 means exact phrase).

Parameters:: slop (int)
Return type:: Query

sort_by(field, asc=True)#

Add a sortby field to the query.

field - the name of the field to sort by
asc - when True, sorting will be done in asceding order

Parameters:

field (str)
asc (bool)

Return type:

Query

timeout(timeout)#

overrides the timeout parameter of the module

Parameters:: timeout (float)
Return type:: Query

verbatim()#

Set the query to be verbatim, i.e. use no query expansion or stemming.

Return type:: Query

with_payloads()#

Ask the engine to return document payloads.

Return type:: Query

with_scores()#

Ask the engine to return document search scores.

Return type:: Query

property filter: str | FilterExpression#: The filter expression for the query.

property params: Dict[str, Any]#: Return the query parameters.

property query: BaseQuery#: Return self as the query object.

CountQuery#

class CountQuery(filter_expression=None, dialect=2, params=None)[source]#

Bases: BaseQuery

A query for a simple count operation provided some filter expression.

Parameters:

filter_expression (Optional[Union[str, FilterExpression]]) – The filter expression to query with. Defaults to None.
params (Optional[Dict[str, Any]], optional) – The parameters for the query. Defaults to None.
dialect (int)

Raises:

TypeError – If filter_expression is not of type redisvl.query.FilterExpression

from redisvl.query import CountQuery
from redisvl.query.filter import Tag

t = Tag("brand") == "Nike"
query = CountQuery(filter_expression=t)

count = index.query(query)

dialect(dialect)#

Add a dialect field to the query.

dialect - dialect version to execute the query under

Parameters:: dialect (int)
Return type:: Query

expander(expander)#

Add a expander field to the query.

expander - the name of the expander

Parameters:: expander (str)
Return type:: Query

in_order()#

Match only documents where the query terms appear in the same order in the document. i.e. for the query “hello world”, we do not match “world hello”

Return type:: Query

language(language)#

Analyze the query as being in the specified language.

Parameters:: language (str) – The language (e.g. chinese or english)
Return type:: Query

limit_fields(*fields)#

Limit the search to specific TEXT fields only.

fields: A list of strings, case sensitive field names

from the defined schema.

Parameters:: fields (List[str])
Return type:: Query

limit_ids(*ids)#

Limit the results to a specific set of pre-known document ids of any length.

Return type:: Query

no_content()#

Set the query to only return ids and not the document content.

Return type:: Query

no_stopwords()#

Prevent the query from being filtered for stopwords. Only useful in very big queries that you are certain contain no stopwords.

Return type:: Query

paging(offset, num)#

Set the paging for the query (defaults to 0..10).

offset: Paging offset for the results. Defaults to 0
num: How many results do we want

Parameters:

offset (int)
num (int)

Return type:

Query

query_string()#

Return the query string of this query only.

Return type:: str

return_fields(*fields)#

Add fields to return fields.

Return type:: Query

scorer(scorer)#

Use a different scoring function to evaluate document relevance. Default is TFIDF.

Parameters:: scorer (str) – The scoring function to use (e.g. TFIDF.DOCNORM or BM25)
Return type:: Query

set_filter(filter_expression=None)#

Set the filter expression for the query.

Parameters:: filter_expression (Optional[Union[str, FilterExpression]], optional) – The filter expression or query string to use on the query.
Raises:: TypeError – If filter_expression is not a valid FilterExpression or string.

slop(slop)#

Allow a maximum of N intervening non matched terms between phrase terms (0 means exact phrase).

Parameters:: slop (int)
Return type:: Query

sort_by(field, asc=True)#

Add a sortby field to the query.

field - the name of the field to sort by
asc - when True, sorting will be done in asceding order

Parameters:

field (str)
asc (bool)

Return type:

Query

timeout(timeout)#

overrides the timeout parameter of the module

Parameters:: timeout (float)
Return type:: Query

verbatim()#

Set the query to be verbatim, i.e. use no query expansion or stemming.

Return type:: Query

with_payloads()#

Ask the engine to return document payloads.

Return type:: Query

with_scores()#

Ask the engine to return document search scores.

Return type:: Query

property filter: str | FilterExpression#: The filter expression for the query.

property params: Dict[str, Any]#: Return the query parameters.

property query: BaseQuery#: Return self as the query object.