Lookup API reference¶
This document has the API references of lookups, the Django API for building
WHERE clause of a database query. To learn how to use lookups, see
Making queries; to learn how to create new lookups, see
How to write custom lookups.
The lookup API has two components: a
that registers lookups, and the Query Expression API, a
set of methods that a class has to implement to be registrable as a lookup.
Django has two base classes that follow the query expression API and from where all Django builtin lookups are derived:
A lookup expression consists of three parts:
- Fields part (e.g.
- Transforms part (may be omitted) (e.g.
- A lookup (e.g.
__icontains) that, if omitted, defaults to
RegisterLookupMixin to give a class the interface to
register lookups on itself or its instances. The two prominent examples are
Field, the base class of all model fields, and
Transform, the base class of all Django transforms.
A mixin that implements the lookup API on a class.
Registers a new lookup in the class or class instance. For example:
MonthExactlookup on the
User.date_joined(you can use Field Access API to retrieve a single field instance). It overrides a lookup that already exists with the same name. Lookups registered on field instances take precedence over the lookups registered on classes.
lookup_namewill be used for this lookup if provided, otherwise
lookup.lookup_namewill be used.
lookup_nameregistered in the class or class instance depending on what calls it. The default implementation looks recursively on all parent classes and checks if any has a registered lookup named
lookup_name, returning the first match. Instance lookups would override any class lookups with the same
Returns a dictionary of each lookup name registered in the class or class instance mapped to the
For a class to be a lookup, it must follow the Query Expression API.
follow this API.
Support for registering lookups on
instances was added.
The Query Expression API¶
The query expression API is a common set of methods that classes define to be
usable in query expressions to translate themselves into SQL expressions. Direct
field references, aggregates, and
Transform are examples that follow this
API. A class is said to follow the query expression API when it implements the
Generates the SQL fragment for the expression. Returns a tuple
(sql, params), where
sqlis the SQL string, and
paramsis the list or tuple of query parameters. The
SQLCompilerobject, which has a
compile()method that can be used to compile other expressions. The
connectionis the connection used to execute the query.
expression.as_sql()is usually incorrect - instead
compiler.compile(expression)should be used. The
compiler.compile()method will take care of calling vendor-specific methods of the expression.
Custom keyword arguments may be defined on this method if it’s likely that
as_vendorname()methods or subclasses will need to supply data to override the generation of the SQL string. See
Func.as_sql()for example usage.
as_sql()method. When an expression is compiled by
compiler.compile(), Django will first try to call
vendornameis the vendor name of the backend used for executing the query. The
vendornameis one of
mysqlfor Django’s built-in backends.
Must return the lookup named
lookup_name. For instance, by returning
Must return the lookup named
transform_name. For instance, by returning
Transformis a generic class to implement field transformations. A prominent example is
__yearthat transforms a
The notation to use a
Transformin a lookup expression is
This class follows the Query Expression API, which implies that you can use
<expression>__<transform1>__<transform2>. It’s a specialized Func() expression that only accepts one argument. It can also be used on the right hand side of a filter or directly as an annotation.
A boolean indicating whether this transformation should apply to both
rhs. Bilateral transformations will be applied to
rhsin the same order as they appear in the lookup expression. By default it is set to
False. For example usage, see How to write custom lookups.
The left-hand side - what is being transformed. It must follow the Query Expression API.
The name of the lookup, used for identifying it on parsing query expressions. It cannot contain the string
Lookupis a generic class to implement lookups. A lookup is a query expression with a left-hand side,
lhs; a right-hand side,
rhs; and a
lookup_namethat is used to produce a boolean comparison between
lhs in rhsor
lhs > rhs.
The primary notation to use a lookup in an expression is
<lhs>__<lookup_name>=<rhs>. Lookups can also be used directly in
The left-hand side - what is being looked up. The object typically follows the Query Expression API. It may also be a plain value.
The right-hand side - what
lhsis being compared against. It can be a plain value, or something that compiles into SQL, typically an
F()object or a
The name of this lookup, used to identify it on parsing query expressions. It cannot contain the string
process_lhs(compiler, connection, lhs=None)[source]¶
Returns a tuple
(lhs_string, lhs_params), as returned by
compiler.compile(lhs). This method can be overridden to tune how the
SQLCompilerobject, to be used like
connectioncan be used for compiling vendor specific SQL. If
None, use it as the processed
Behaves the same way as
process_lhs(), for the right-hand side.