django.db.models.sql.query.Query

class documentation

class Query(BaseExpression): (source)

Known subclasses: django.db.models.sql.subqueries.AggregateQuery, django.db.models.sql.subqueries.DeleteQuery, django.db.models.sql.subqueries.InsertQuery, django.db.models.sql.subqueries.UpdateQuery

View In Hierarchy

A single SQL query.

Method __deepcopy__ Limit the amount of work when a Query is deepcopied.
Method __init__ Undocumented
Method __str__ Return the query as a string of SQL with the parameter values substituted in (use sql_with_params() to see the unsubstituted string).
Method add_annotation Add a single annotation expression to the Query.
Method add_deferred_loading Add the given list of model field names to the set of fields to exclude from loading from the database when automatic column selection is done. Add the new field names to any existing field names that are deferred (or removed from any existing field names that are marked as the only ones for immediate loading).
Method add_distinct_fields Add and resolve the given fields to the query's "distinct on" clause.
Method add_extra Add data to the various extra_* attributes for user-created additions to the query.
Method add_fields Add the given (model) fields to the select set. Add the field names in the order specified.
Method add_filter Undocumented
Method add_filtered_relation Undocumented
Method add_immediate_loading Add the given list of model field names to the set of fields to retrieve when the SQL is executed ("immediate loading" fields). The field names replace any existing immediate loading field names. If there are field names already specified for deferred loading, remove those names from the new field_names before storing the new names for immediate loading...
Method add_ordering Add items from the 'ordering' sequence to the query's "order by" clause. These items are either field names (not column names) -- possibly with a direction prefix ('-' or '?') -- or OrderBy expressions.
Method add_q A preprocessor for the internal _add_q(). Responsible for doing final join promotion.
Method add_select_col Undocumented
Method add_select_related Set up the select_related data structure so that we only select certain related models (as opposed to all models, when self.select_related=True).
Method append_annotation_mask Undocumented
Method as_sql Responsible for returning a (sql, [params]) tuple to be included in the current query.
Method build_filter Build a WhereNode for a single filter clause but don't add it to this Query. Query.add_q() will then add this filter to the where Node.
Method build_filtered_relation_q Add a FilteredRelation object to the current filter.
Method build_lookup Try to extract transforms and lookup from given lhs.
Method build_where Undocumented
Method bump_prefix Change the alias prefix to the next letter in the alphabet in a way that the other query's aliases and this query's aliases will not conflict. Even tables that previously had no alias will get an alias after this call...
Method can_filter Return True if adding filters to this instance is still possible.
Method chain Return a copy of the current Query that's ready for another operation. The klass argument changes the type of the Query, e.g. UpdateQuery.
Method change_aliases Change the aliases in change_map (which maps old-alias -> new-alias), relabelling any references to them in select columns and the where clause.
Method check_alias Undocumented
Method check_filterable Raise an error if expression cannot be used in a WHERE clause.
Method check_query_object_type Check whether the object passed while querying is of the correct type. If not, raise a ValueError specifying the wrong object.
Method check_related_objects Check the type of object passed to query relations.
Method clear_deferred_loading Remove any fields from the deferred loading set.
Method clear_limits Clear any existing limits.
Method clear_ordering Remove any ordering settings if the current query allows it without side effects, set 'force' to True to clear the ordering regardless. If 'clear_default' is True, there will be no ordering in the resulting query (not even the model's default).
Method clear_select_clause Remove all fields from SELECT clause.
Method clear_select_fields Clear the list of fields to select (but not extra_select columns). Some queryset types completely replace any existing list of select columns.
Method clear_where Undocumented
Method clone Return a copy of the current Query. A lightweight alternative to deepcopy().
Method combine Merge the 'rhs' query into the current one (with any 'rhs' effects being applied *after* (that is, "to the right of") anything in the current query. 'rhs' is not modified during a call to this function.
Method count_active_tables Return the number of tables in this query with a non-zero reference count. After execution, the reference counts are zeroed, so tables added in compiler will not be seen by this method.
Method deferred_to_data Convert the self.deferred_loading data structure to an alternate data structure, describing the field that *will* be loaded. This is used to compute the columns to select from the database and also by the QuerySet class to work out which fields are being initialized on each model...
Method demote_joins Change join type from LOUTER to INNER for all joins in aliases.
Method exists Undocumented
Method explain Undocumented
Method get_aggregation Return the dictionary with the values of the existing aggregations.
Method get_compiler Undocumented
Method get_count Perform a COUNT() query using the current filter constraints.
Method get_external_cols Undocumented
Method get_group_by_cols Undocumented
Method get_initial_alias Return the first alias for this query, after increasing its reference count.
Method get_meta Return the Options instance (the model._meta) from which to start processing. Normally, this is self.model._meta, but it can be changed by subclasses.
Method has_filters Undocumented
Method has_limit_one Undocumented
Method has_results Undocumented
Method is_empty Undocumented
Method is_nullable Check if the given field should be treated as nullable.
Method join Return an alias for the 'join', either reusing an existing alias for that join or creating a new one. 'join' is either a base_table_class or join_class.
Method join_parent_model Make sure the given 'model' is joined in the query. If 'model' isn't a parent of 'opts' or if it is None this method is a no-op.
Method names_to_path Walk the list of names and turns them into PathInfo tuples. A single name in 'names' can generate multiple PathInfos (m2m, for example).
Method promote_joins Promote recursively the join type of given aliases and its children to an outer join. If 'unconditional' is False, only promote the join if it is nullable or the parent join is an outer join.
Method ref_alias Increases the reference count for this alias.
Method relabeled_clone Undocumented
Method reset_refcounts Reset reference counts for aliases so that they match the value passed in `to_counts`.
Method resolve_expression Provide the chance to do any preprocessing or validation before being added to the query.
Method resolve_lookup_value Undocumented
Method resolve_ref Undocumented
Method rewrite_cols Undocumented
Method set_annotation_mask Set the mask of annotations that will be returned by the SELECT.
Method set_empty Undocumented
Method set_extra_mask Set the mask of extra select items that will be returned by SELECT. Don't remove them from the Query since they might be used later.
Method set_group_by Expand the GROUP BY clause required by the query.
Method set_limits Adjust the limits on the rows retrieved. Use low/high to set these, as it makes it more Pythonic to read and write. When the SQL query is created, convert them to the appropriate offset and limit values.
Method set_select Undocumented
Method set_values Undocumented
Method setup_joins Compute the necessary table joins for the passage through the fields given in 'names'. 'opts' is the Options class for the current model (which gives the table we are starting from), 'alias' is the alias for the table to start the joining from.
Method solve_lookup_type Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains').
Method split_exclude When doing an exclude against any kind of N-to-many relation, we need to use a subquery. This method constructs the nested query, given the original exclude filter (filter_expr) and the portion up to the first N-to-many relation field.
Method sql_with_params Return the query as an SQL string and the parameters that will be substituted into the query.
Method table_alias Return a table alias for the given table_name and whether this is a new alias or not.
Method trim_joins The 'target' parameter is the final field being joined to, 'joins' is the full list of join aliases. The 'path' contain the PathInfos used to create the joins.
Method trim_start Trim joins from the start of the join path. The candidates for trim are the PathInfos in names_with_path structure that are m2m joins.
Method try_transform Helper method for build_lookup(). Try to fetch and initialize a transform for name parameter from lhs.
Method unref_alias Decreases the reference count for this alias.
Class Variable combinator Undocumented
Class Variable combinator_all Undocumented
Class Variable combined_queries Undocumented
Class Variable compiler Undocumented
Class Variable empty_result_set_value Undocumented
Class Variable explain_info Undocumented
Class Variable extra_tables Undocumented
Class Variable filter_is_sticky Undocumented
Class Variable max_depth Undocumented
Class Variable select_for_no_key_update Undocumented
Class Variable select_for_update Undocumented
Class Variable select_for_update_nowait Undocumented
Class Variable select_for_update_of Undocumented
Class Variable select_for_update_skip_locked Undocumented
Class Variable standard_ordering Undocumented
Class Variable subquery Undocumented
Instance Variable alias_cols Undocumented
Instance Variable alias_map Undocumented
Instance Variable alias_prefix Undocumented
Instance Variable alias_refcount Undocumented
Instance Variable annotation_select_mask Undocumented
Instance Variable annotations Undocumented
Instance Variable default_cols Undocumented
Instance Variable default_ordering Undocumented
Instance Variable deferred_loading Undocumented
Instance Variable distinct Undocumented
Instance Variable distinct_fields Undocumented
Instance Variable external_aliases Undocumented
Instance Variable extra Undocumented
Instance Variable extra_order_by Undocumented
Instance Variable extra_select_mask Undocumented
Instance Variable group_by Undocumented
Instance Variable high_mark Undocumented
Instance Variable low_mark Undocumented
Instance Variable model Undocumented
Instance Variable order_by Undocumented
Instance Variable select Undocumented
Instance Variable select_related Undocumented
Instance Variable subq_aliases Undocumented
Instance Variable table_map Undocumented
Instance Variable used_aliases Undocumented
Instance Variable values_select Undocumented
Instance Variable where Undocumented
Property annotation_select Return the dictionary of aggregate columns that are not masked and should be used in the SELECT clause. Cache this result for performance.
Property base_table Undocumented
Property extra_select Undocumented
Property has_select_fields Undocumented
Property is_sliced Undocumented
Property output_field Return the output type of this expressions.
Class Method _gen_col_aliases Undocumented
Class Method _gen_cols Undocumented
Method _add_q Add a Q-object to the current filter.
Method _get_col Undocumented
Instance Variable _annotation_select_cache Undocumented
Instance Variable _extra_select_cache Undocumented
Instance Variable _filtered_relations Undocumented
Instance Variable _lookup_joins Undocumented

Inherited from BaseExpression:

Method __getstate__ Undocumented
Method asc Undocumented
Method copy Undocumented
Method desc Undocumented
Method flatten Recursively yield this expression and all subexpressions, in depth-first order.
Method get_db_converters Undocumented
Method get_lookup Undocumented
Method get_source_expressions Undocumented
Method get_source_fields Return the underlying field types used by this aggregate.
Method get_transform Undocumented
Method prefix_references Undocumented
Method replace_references Undocumented
Method reverse_ordering Undocumented
Method select_format Custom format for select clauses. For example, EXISTS expressions need to be wrapped in CASE WHEN on Oracle.
Method set_source_expressions Undocumented
Class Variable filterable Undocumented
Class Variable is_summary Undocumented
Class Variable window_compatible Undocumented
Property conditional Undocumented
Property contains_aggregate Undocumented
Property contains_column_references Undocumented
Property contains_over_clause Undocumented
Property convert_value Expressions provide their own converters because users have the option of manually specifying the output_field which may be a different type from the one the database returns.
Property field Undocumented
Static Method _convert_value_noop Undocumented
Method _parse_expressions Undocumented
Method _resolve_output_field Attempt to infer the output type of the expression.
Class Variable _output_field_resolved_to_none Undocumented
Property _output_field_or_none Return the output field of this expression, or None if _resolve_output_field() didn't return an output type.
def __deepcopy__(self, memo): (source)

Limit the amount of work when a Query is deepcopied.

def __init__(self, model, alias_cols=True): (source)
overrides django.db.models.expressions.BaseExpression.__init__
overridden in django.db.models.sql.subqueries.AggregateQuery, django.db.models.sql.subqueries.InsertQuery, django.db.models.sql.subqueries.UpdateQuery

Undocumented

def __str__(self): (source)

Return the query as a string of SQL with the parameter values substituted in (use sql_with_params() to see the unsubstituted string). Parameter values won't necessarily be quoted correctly, since that is done by the database interface at execution time.

def add_annotation(self, annotation, alias, is_summary=False, select=True): (source)

Add a single annotation expression to the Query.

def add_deferred_loading(self, field_names): (source)

Add the given list of model field names to the set of fields to exclude from loading from the database when automatic column selection is done. Add the new field names to any existing field names that are deferred (or removed from any existing field names that are marked as the only ones for immediate loading).

def add_distinct_fields(self, *field_names): (source)

Add and resolve the given fields to the query's "distinct on" clause.

def add_extra(self, select, select_params, where, params, tables, order_by): (source)

Add data to the various extra_* attributes for user-created additions to the query.

def add_fields(self, field_names, allow_m2m=True): (source)

Add the given (model) fields to the select set. Add the field names in the order specified.

def add_filter(self, filter_lhs, filter_rhs): (source)

Undocumented

def add_filtered_relation(self, filtered_relation, alias): (source)

Undocumented

def add_immediate_loading(self, field_names): (source)

Add the given list of model field names to the set of fields to retrieve when the SQL is executed ("immediate loading" fields). The field names replace any existing immediate loading field names. If there are field names already specified for deferred loading, remove those names from the new field_names before storing the new names for immediate loading. (That is, immediate loading overrides any existing immediate values, but respects existing deferrals.)

def add_ordering(self, *ordering): (source)

Add items from the 'ordering' sequence to the query's "order by" clause. These items are either field names (not column names) -- possibly with a direction prefix ('-' or '?') -- or OrderBy expressions. If 'ordering' is empty, clear all ordering from the query.

def add_q(self, q_object): (source)

A preprocessor for the internal _add_q(). Responsible for doing final join promotion.

def add_select_col(self, col, name): (source)

Undocumented

def add_select_related(self, fields): (source)

Set up the select_related data structure so that we only select certain related models (as opposed to all models, when self.select_related=True).

def append_annotation_mask(self, names): (source)

Undocumented

def as_sql(self, compiler, connection): (source)
overrides django.db.models.expressions.BaseExpression.as_sql

Responsible for returning a (sql, [params]) tuple to be included in the current query. Different backends can provide their own implementation, by providing an `as_{vendor}` method and patching the Expression: ``` def override_as_sql(self, compiler, connection): # custom logic return super().as_sql(compiler, connection) setattr(Expression, 'as_' + connection.vendor, override_as_sql) ``` Arguments: * compiler: the query compiler responsible for generating the query. Must have a compile method, returning a (sql, [params]) tuple. Calling compiler(value) will return a quoted `value`. * connection: the database connection used for the current query. Return: (sql, params) Where `sql` is a string containing ordered sql parameters to be replaced with the elements of the list `params`.

def build_filter(self, filter_expr, branch_negated=False, current_negated=False, can_reuse=None, allow_joins=True, split_subq=True, reuse_with_filtered_relation=False, check_filterable=True): (source)

Build a WhereNode for a single filter clause but don't add it to this Query. Query.add_q() will then add this filter to the where Node. The 'branch_negated' tells us if the current branch contains any negations. This will be used to determine if subqueries are needed. The 'current_negated' is used to determine if the current filter is negated or not and this will be used to determine if IS NULL filtering is needed. The difference between current_negated and branch_negated is that branch_negated is set on first negation, but current_negated is flipped for each negation. Note that add_filter will not do any negating itself, that is done upper in the code by add_q(). The 'can_reuse' is a set of reusable joins for multijoins. If 'reuse_with_filtered_relation' is True, then only joins in can_reuse will be reused. The method will create a filter clause that can be added to the current query. However, if the filter isn't added to the query then the caller is responsible for unreffing the joins used.

def build_filtered_relation_q(self, q_object, reuse, branch_negated=False, current_negated=False): (source)

Add a FilteredRelation object to the current filter.

def build_lookup(self, lookups, lhs, rhs): (source)

Try to extract transforms and lookup from given lhs. The lhs value is something that works like SQLExpression. The rhs value is what the lookup is going to compare against. The lookups is a list of names to extract using get_lookup() and get_transform().

def build_where(self, filter_expr): (source)

Undocumented

def bump_prefix(self, other_query, exclude=None): (source)

Change the alias prefix to the next letter in the alphabet in a way that the other query's aliases and this query's aliases will not conflict. Even tables that previously had no alias will get an alias after this call. To prevent changing aliases use the exclude parameter.

def can_filter(self): (source)

Return True if adding filters to this instance is still possible. Typically, this means no limits or offsets have been put on the results.

def chain(self, klass=None): (source)

Return a copy of the current Query that's ready for another operation. The klass argument changes the type of the Query, e.g. UpdateQuery.

def change_aliases(self, change_map): (source)

Change the aliases in change_map (which maps old-alias -> new-alias), relabelling any references to them in select columns and the where clause.

def check_alias(self, alias): (source)

Undocumented

def check_filterable(self, expression): (source)

Raise an error if expression cannot be used in a WHERE clause.

def check_query_object_type(self, value, opts, field): (source)

Check whether the object passed while querying is of the correct type. If not, raise a ValueError specifying the wrong object.

def check_related_objects(self, field, value, opts): (source)

Check the type of object passed to query relations.

def clear_deferred_loading(self): (source)

Remove any fields from the deferred loading set.

def clear_limits(self): (source)

Clear any existing limits.

def clear_ordering(self, force=False, clear_default=True): (source)

Remove any ordering settings if the current query allows it without side effects, set 'force' to True to clear the ordering regardless. If 'clear_default' is True, there will be no ordering in the resulting query (not even the model's default).

def clear_select_clause(self): (source)

Remove all fields from SELECT clause.

def clear_select_fields(self): (source)

Clear the list of fields to select (but not extra_select columns). Some queryset types completely replace any existing list of select columns.

def clear_where(self): (source)

Undocumented

def clone(self): (source)
overridden in django.db.models.sql.subqueries.UpdateQuery

Return a copy of the current Query. A lightweight alternative to deepcopy().

def combine(self, rhs, connector): (source)

Merge the 'rhs' query into the current one (with any 'rhs' effects being applied *after* (that is, "to the right of") anything in the current query. 'rhs' is not modified during a call to this function. The 'connector' parameter describes how to connect filters from the 'rhs' query.

def count_active_tables(self): (source)

Return the number of tables in this query with a non-zero reference count. After execution, the reference counts are zeroed, so tables added in compiler will not be seen by this method.

def deferred_to_data(self, target): (source)

Convert the self.deferred_loading data structure to an alternate data structure, describing the field that *will* be loaded. This is used to compute the columns to select from the database and also by the QuerySet class to work out which fields are being initialized on each model. Models that have all their fields included aren't mentioned in the result, only those that have field restrictions in place. The "target" parameter is the instance that is populated (in place).

def demote_joins(self, aliases): (source)

Change join type from LOUTER to INNER for all joins in aliases. Similarly to promote_joins(), this method must ensure no join chains containing first an outer, then an inner join are generated. If we are demoting b->c join in chain a LOUTER b LOUTER c then we must demote a->b automatically, or otherwise the demotion of b->c doesn't actually change anything in the query results. .

def exists(self, using, limit=True): (source)

Undocumented

def explain(self, using, format=None, **options): (source)

Undocumented

def get_aggregation(self, using, added_aggregate_names): (source)

Return the dictionary with the values of the existing aggregations.

def get_compiler(self, using=None, connection=None, elide_empty=True): (source)

Undocumented

def get_count(self, using): (source)

Perform a COUNT() query using the current filter constraints.

def get_external_cols(self): (source)

Undocumented

def get_group_by_cols(self, alias=None): (source)
overrides django.db.models.expressions.BaseExpression.get_group_by_cols

Undocumented

def get_initial_alias(self): (source)

Return the first alias for this query, after increasing its reference count.

def get_meta(self): (source)

Return the Options instance (the model._meta) from which to start processing. Normally, this is self.model._meta, but it can be changed by subclasses.

def has_filters(self): (source)

Undocumented

def has_limit_one(self): (source)

Undocumented

def has_results(self, using): (source)

Undocumented

def is_empty(self): (source)

Undocumented

def is_nullable(self, field): (source)

Check if the given field should be treated as nullable. Some backends treat '' as null and Django treats such fields as nullable for those backends. In such situations field.null can be False even if we should treat the field as nullable.

def join(self, join, reuse=None, reuse_with_filtered_relation=False): (source)

Return an alias for the 'join', either reusing an existing alias for that join or creating a new one. 'join' is either a base_table_class or join_class. The 'reuse' parameter can be either None which means all joins are reusable, or it can be a set containing the aliases that can be reused. The 'reuse_with_filtered_relation' parameter is used when computing FilteredRelation instances. A join is always created as LOUTER if the lhs alias is LOUTER to make sure chains like t1 LOUTER t2 INNER t3 aren't generated. All new joins are created as LOUTER if the join is nullable.

def join_parent_model(self, opts, model, alias, seen): (source)

Make sure the given 'model' is joined in the query. If 'model' isn't a parent of 'opts' or if it is None this method is a no-op. The 'alias' is the root alias for starting the join, 'seen' is a dict of model -> alias of existing joins. It must also contain a mapping of None -> some alias. This will be returned in the no-op case.

def names_to_path(self, names, opts, allow_many=True, fail_on_missing=False): (source)

Walk the list of names and turns them into PathInfo tuples. A single name in 'names' can generate multiple PathInfos (m2m, for example). 'names' is the path of names to travel, 'opts' is the model Options we start the name resolving from, 'allow_many' is as for setup_joins(). If fail_on_missing is set to True, then a name that can't be resolved will generate a FieldError. Return a list of PathInfo tuples. In addition return the final field (the last used join field) and target (which is a field guaranteed to contain the same value as the final field). Finally, return those names that weren't found (which are likely transforms and the final lookup).

def promote_joins(self, aliases): (source)

Promote recursively the join type of given aliases and its children to an outer join. If 'unconditional' is False, only promote the join if it is nullable or the parent join is an outer join. The children promotion is done to avoid join chains that contain a LOUTER b INNER c. So, if we have currently a INNER b INNER c and a->b is promoted, then we must also promote b->c automatically, or otherwise the promotion of a->b doesn't actually change anything in the query results.

def ref_alias(self, alias): (source)

Increases the reference count for this alias.

def relabeled_clone(self, change_map): (source)
overrides django.db.models.expressions.BaseExpression.relabeled_clone

Undocumented

def reset_refcounts(self, to_counts): (source)

Reset reference counts for aliases so that they match the value passed in `to_counts`.

def resolve_expression(self, query, *args, **kwargs): (source)
overrides django.db.models.expressions.BaseExpression.resolve_expression

Provide the chance to do any preprocessing or validation before being added to the query. Arguments: * query: the backend query implementation * allow_joins: boolean allowing or denying use of joins in this query * reuse: a set of reusable joins for multijoins * summarize: a terminal aggregate clause * for_save: whether this expression about to be used in a save or update Return: an Expression to be added to the query.

def resolve_lookup_value(self, value, can_reuse, allow_joins): (source)

Undocumented

def resolve_ref(self, name, allow_joins=True, reuse=None, summarize=False): (source)

Undocumented

def rewrite_cols(self, annotation, col_cnt): (source)

Undocumented

def set_annotation_mask(self, names): (source)

Set the mask of annotations that will be returned by the SELECT.

def set_empty(self): (source)

Undocumented

def set_extra_mask(self, names): (source)

Set the mask of extra select items that will be returned by SELECT. Don't remove them from the Query since they might be used later.

def set_group_by(self, allow_aliases=True): (source)

Expand the GROUP BY clause required by the query. This will usually be the set of all non-aggregate fields in the return data. If the database backend supports grouping by the primary key, and the query would be equivalent, the optimization will be made automatically.

def set_limits(self, low=None, high=None): (source)

Adjust the limits on the rows retrieved. Use low/high to set these, as it makes it more Pythonic to read and write. When the SQL query is created, convert them to the appropriate offset and limit values. Apply any limits passed in here to the existing constraints. Add low to the current low value and clamp both to any existing high value.

def set_select(self, cols): (source)

Undocumented

def set_values(self, fields): (source)

Undocumented

def setup_joins(self, names, opts, alias, can_reuse=None, allow_many=True, reuse_with_filtered_relation=False): (source)

Compute the necessary table joins for the passage through the fields given in 'names'. 'opts' is the Options class for the current model (which gives the table we are starting from), 'alias' is the alias for the table to start the joining from. The 'can_reuse' defines the reverse foreign key joins we can reuse. It can be None in which case all joins are reusable or a set of aliases that can be reused. Note that non-reverse foreign keys are always reusable when using setup_joins(). The 'reuse_with_filtered_relation' can be used to force 'can_reuse' parameter and force the relation on the given connections. If 'allow_many' is False, then any reverse foreign key seen will generate a MultiJoin exception. Return the final field involved in the joins, the target field (used for any 'where' constraint), the final 'opts' value, the joins, the field path traveled to generate the joins, and a transform function that takes a field and alias and is equivalent to `field.get_col(alias)` in the simple case but wraps field transforms if they were included in names. The target field is the field containing the concrete value. Final field can be something different, for example foreign key pointing to that value. Final field is needed for example in some value conversions (convert 'obj' in fk__id=obj to pk val using the foreign key field for example).

def solve_lookup_type(self, lookup): (source)

Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains').

def split_exclude(self, filter_expr, can_reuse, names_with_path): (source)

When doing an exclude against any kind of N-to-many relation, we need to use a subquery. This method constructs the nested query, given the original exclude filter (filter_expr) and the portion up to the first N-to-many relation field. For example, if the origin filter is ~Q(child__name='foo'), filter_expr is ('child__name', 'foo') and can_reuse is a set of joins usable for filters in the original query. We will turn this into equivalent of: WHERE NOT EXISTS( SELECT 1 FROM child WHERE name = 'foo' AND child.parent_id = parent.id LIMIT 1 )

def sql_with_params(self): (source)

Return the query as an SQL string and the parameters that will be substituted into the query.

def table_alias(self, table_name, create=False, filtered_relation=None): (source)

Return a table alias for the given table_name and whether this is a new alias or not. If 'create' is true, a new alias is always created. Otherwise, the most recently created alias for the table (if one exists) is reused.

def trim_joins(self, targets, joins, path): (source)

The 'target' parameter is the final field being joined to, 'joins' is the full list of join aliases. The 'path' contain the PathInfos used to create the joins. Return the final target field and table alias and the new active joins. Always trim any direct join if the target column is already in the previous table. Can't trim reverse joins as it's unknown if there's anything on the other side of the join.

def trim_start(self, names_with_path): (source)

Trim joins from the start of the join path. The candidates for trim are the PathInfos in names_with_path structure that are m2m joins. Also set the select column so the start matches the join. This method is meant to be used for generating the subquery joins & cols in split_exclude(). Return a lookup usable for doing outerq.filter(lookup=self) and a boolean indicating if the joins in the prefix contain a LEFT OUTER join. _

def try_transform(self, lhs, name): (source)

Helper method for build_lookup(). Try to fetch and initialize a transform for name parameter from lhs.

def unref_alias(self, alias, amount=1): (source)

Decreases the reference count for this alias.

combinator = (source)

Undocumented

combinator_all: bool = (source)

Undocumented

combined_queries: tuple = (source)

Undocumented

compiler: str = (source)
overridden in django.db.models.sql.subqueries.AggregateQuery, django.db.models.sql.subqueries.DeleteQuery, django.db.models.sql.subqueries.InsertQuery, django.db.models.sql.subqueries.UpdateQuery

Undocumented

empty_result_set_value = (source)

Undocumented

explain_info = (source)

Undocumented

extra_tables: tuple = (source)

Undocumented

filter_is_sticky: bool = (source)

Undocumented

max_depth: int = (source)

Undocumented

select_for_no_key_update: bool = (source)

Undocumented

select_for_update: bool = (source)

Undocumented

select_for_update_nowait: bool = (source)

Undocumented

select_for_update_of: tuple = (source)

Undocumented

select_for_update_skip_locked: bool = (source)

Undocumented

standard_ordering: bool = (source)

Undocumented

subquery: bool = (source)

Undocumented

alias_cols = (source)

Undocumented

alias_map: dict = (source)
overridden in django.db.models.sql.subqueries.DeleteQuery

Undocumented

alias_prefix = (source)

Undocumented

alias_refcount: dict = (source)

Undocumented

annotation_select_mask = (source)

Undocumented

annotations = (source)

Undocumented

default_cols: bool = (source)

Undocumented

default_ordering: bool = (source)

Undocumented

deferred_loading = (source)

Undocumented

distinct: bool = (source)

Undocumented

distinct_fields = (source)

Undocumented

external_aliases = (source)

Undocumented

extra: dict = (source)

Undocumented

extra_order_by = (source)

Undocumented

extra_select_mask = (source)

Undocumented

group_by = (source)

Undocumented

high_mark = (source)

Undocumented

low_mark = (source)

Undocumented

model = (source)

Undocumented

order_by: tuple = (source)

Undocumented

select = (source)

Undocumented

select_related: bool = (source)

Undocumented

subq_aliases = (source)

Undocumented

table_map: dict = (source)

Undocumented

used_aliases = (source)

Undocumented

values_select = (source)

Undocumented

where = (source)
overridden in django.db.models.sql.subqueries.DeleteQuery

Undocumented

@property
annotation_select = (source)

Return the dictionary of aggregate columns that are not masked and should be used in the SELECT clause. Cache this result for performance.

@cached_property
base_table = (source)

Undocumented

@property
extra_select = (source)

Undocumented

@property
has_select_fields = (source)

Undocumented

@property
is_sliced = (source)

Undocumented

@property
output_field = (source)
overrides django.db.models.expressions.BaseExpression.output_field

Return the output type of this expressions.

@classmethod
def _gen_col_aliases(cls, exprs): (source)

Undocumented

@classmethod
def _gen_cols(cls, exprs, include_external=False): (source)

Undocumented

def _add_q(self, q_object, used_aliases, branch_negated=False, current_negated=False, allow_joins=True, split_subq=True, check_filterable=True): (source)

Add a Q-object to the current filter.

def _get_col(self, target, field, alias): (source)

Undocumented

_annotation_select_cache = (source)

Undocumented

_extra_select_cache = (source)

Undocumented

_filtered_relations: dict = (source)

Undocumented

_lookup_joins = (source)

Undocumented