1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810 |
- import copy
- import datetime
- import functools
- import inspect
- import warnings
- from collections import defaultdict
- from decimal import Decimal
- from uuid import UUID
-
- from django.core.exceptions import EmptyResultSet, FieldError
- from django.db import DatabaseError, NotSupportedError, connection
- from django.db.models import fields
- from django.db.models.constants import LOOKUP_SEP
- from django.db.models.query_utils import Q
- from django.utils.deconstruct import deconstructible
- from django.utils.deprecation import RemovedInDjango50Warning
- from django.utils.functional import cached_property
- from django.utils.hashable import make_hashable
-
-
- class SQLiteNumericMixin:
- """
- Some expressions with output_field=DecimalField() must be cast to
- numeric to be properly filtered.
- """
-
- def as_sqlite(self, compiler, connection, **extra_context):
- sql, params = self.as_sql(compiler, connection, **extra_context)
- try:
- if self.output_field.get_internal_type() == "DecimalField":
- sql = "CAST(%s AS NUMERIC)" % sql
- except FieldError:
- pass
- return sql, params
-
-
- class Combinable:
- """
- Provide the ability to combine one or two objects with
- some connector. For example F('foo') + F('bar').
- """
-
- # Arithmetic connectors
- ADD = "+"
- SUB = "-"
- MUL = "*"
- DIV = "/"
- POW = "^"
- # The following is a quoted % operator - it is quoted because it can be
- # used in strings that also have parameter substitution.
- MOD = "%%"
-
- # Bitwise operators - note that these are generated by .bitand()
- # and .bitor(), the '&' and '|' are reserved for boolean operator
- # usage.
- BITAND = "&"
- BITOR = "|"
- BITLEFTSHIFT = "<<"
- BITRIGHTSHIFT = ">>"
- BITXOR = "#"
-
- def _combine(self, other, connector, reversed):
- if not hasattr(other, "resolve_expression"):
- # everything must be resolvable to an expression
- other = Value(other)
-
- if reversed:
- return CombinedExpression(other, connector, self)
- return CombinedExpression(self, connector, other)
-
- #############
- # OPERATORS #
- #############
-
- def __neg__(self):
- return self._combine(-1, self.MUL, False)
-
- def __add__(self, other):
- return self._combine(other, self.ADD, False)
-
- def __sub__(self, other):
- return self._combine(other, self.SUB, False)
-
- def __mul__(self, other):
- return self._combine(other, self.MUL, False)
-
- def __truediv__(self, other):
- return self._combine(other, self.DIV, False)
-
- def __mod__(self, other):
- return self._combine(other, self.MOD, False)
-
- def __pow__(self, other):
- return self._combine(other, self.POW, False)
-
- def __and__(self, other):
- if getattr(self, "conditional", False) and getattr(other, "conditional", False):
- return Q(self) & Q(other)
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
- def bitand(self, other):
- return self._combine(other, self.BITAND, False)
-
- def bitleftshift(self, other):
- return self._combine(other, self.BITLEFTSHIFT, False)
-
- def bitrightshift(self, other):
- return self._combine(other, self.BITRIGHTSHIFT, False)
-
- def __xor__(self, other):
- if getattr(self, "conditional", False) and getattr(other, "conditional", False):
- return Q(self) ^ Q(other)
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
- def bitxor(self, other):
- return self._combine(other, self.BITXOR, False)
-
- def __or__(self, other):
- if getattr(self, "conditional", False) and getattr(other, "conditional", False):
- return Q(self) | Q(other)
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
- def bitor(self, other):
- return self._combine(other, self.BITOR, False)
-
- def __radd__(self, other):
- return self._combine(other, self.ADD, True)
-
- def __rsub__(self, other):
- return self._combine(other, self.SUB, True)
-
- def __rmul__(self, other):
- return self._combine(other, self.MUL, True)
-
- def __rtruediv__(self, other):
- return self._combine(other, self.DIV, True)
-
- def __rmod__(self, other):
- return self._combine(other, self.MOD, True)
-
- def __rpow__(self, other):
- return self._combine(other, self.POW, True)
-
- def __rand__(self, other):
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
- def __ror__(self, other):
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
- def __rxor__(self, other):
- raise NotImplementedError(
- "Use .bitand(), .bitor(), and .bitxor() for bitwise logical operations."
- )
-
-
- class BaseExpression:
- """Base class for all query expressions."""
-
- empty_result_set_value = NotImplemented
- # aggregate specific fields
- is_summary = False
- _output_field_resolved_to_none = False
- # Can the expression be used in a WHERE clause?
- filterable = True
- # Can the expression can be used as a source expression in Window?
- window_compatible = False
-
- def __init__(self, output_field=None):
- if output_field is not None:
- self.output_field = output_field
-
- def __getstate__(self):
- state = self.__dict__.copy()
- state.pop("convert_value", None)
- return state
-
- def get_db_converters(self, connection):
- return (
- []
- if self.convert_value is self._convert_value_noop
- else [self.convert_value]
- ) + self.output_field.get_db_converters(connection)
-
- def get_source_expressions(self):
- return []
-
- def set_source_expressions(self, exprs):
- assert not exprs
-
- def _parse_expressions(self, *expressions):
- return [
- arg
- if hasattr(arg, "resolve_expression")
- else (F(arg) if isinstance(arg, str) else Value(arg))
- for arg in expressions
- ]
-
- def as_sql(self, compiler, connection):
- """
- 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`.
- """
- raise NotImplementedError("Subclasses must implement as_sql()")
-
- @cached_property
- def contains_aggregate(self):
- return any(
- expr and expr.contains_aggregate for expr in self.get_source_expressions()
- )
-
- @cached_property
- def contains_over_clause(self):
- return any(
- expr and expr.contains_over_clause for expr in self.get_source_expressions()
- )
-
- @cached_property
- def contains_column_references(self):
- return any(
- expr and expr.contains_column_references
- for expr in self.get_source_expressions()
- )
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- """
- 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.
- """
- c = self.copy()
- c.is_summary = summarize
- c.set_source_expressions(
- [
- expr.resolve_expression(query, allow_joins, reuse, summarize)
- if expr
- else None
- for expr in c.get_source_expressions()
- ]
- )
- return c
-
- @property
- def conditional(self):
- return isinstance(self.output_field, fields.BooleanField)
-
- @property
- def field(self):
- return self.output_field
-
- @cached_property
- def output_field(self):
- """Return the output type of this expressions."""
- output_field = self._resolve_output_field()
- if output_field is None:
- self._output_field_resolved_to_none = True
- raise FieldError("Cannot resolve expression type, unknown output_field")
- return output_field
-
- @cached_property
- def _output_field_or_none(self):
- """
- Return the output field of this expression, or None if
- _resolve_output_field() didn't return an output type.
- """
- try:
- return self.output_field
- except FieldError:
- if not self._output_field_resolved_to_none:
- raise
-
- def _resolve_output_field(self):
- """
- Attempt to infer the output type of the expression.
-
- As a guess, if the output fields of all source fields match then simply
- infer the same type here.
-
- If a source's output field resolves to None, exclude it from this check.
- If all sources are None, then an error is raised higher up the stack in
- the output_field property.
- """
- # This guess is mostly a bad idea, but there is quite a lot of code
- # (especially 3rd party Func subclasses) that depend on it, we'd need a
- # deprecation path to fix it.
- sources_iter = (
- source for source in self.get_source_fields() if source is not None
- )
- for output_field in sources_iter:
- for source in sources_iter:
- if not isinstance(output_field, source.__class__):
- raise FieldError(
- "Expression contains mixed types: %s, %s. You must "
- "set output_field."
- % (
- output_field.__class__.__name__,
- source.__class__.__name__,
- )
- )
- return output_field
-
- @staticmethod
- def _convert_value_noop(value, expression, connection):
- return value
-
- @cached_property
- def convert_value(self):
- """
- 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.
- """
- field = self.output_field
- internal_type = field.get_internal_type()
- if internal_type == "FloatField":
- return (
- lambda value, expression, connection: None
- if value is None
- else float(value)
- )
- elif internal_type.endswith("IntegerField"):
- return (
- lambda value, expression, connection: None
- if value is None
- else int(value)
- )
- elif internal_type == "DecimalField":
- return (
- lambda value, expression, connection: None
- if value is None
- else Decimal(value)
- )
- return self._convert_value_noop
-
- def get_lookup(self, lookup):
- return self.output_field.get_lookup(lookup)
-
- def get_transform(self, name):
- return self.output_field.get_transform(name)
-
- def relabeled_clone(self, change_map):
- clone = self.copy()
- clone.set_source_expressions(
- [
- e.relabeled_clone(change_map) if e is not None else None
- for e in self.get_source_expressions()
- ]
- )
- return clone
-
- def replace_references(self, references_map):
- clone = self.copy()
- clone.set_source_expressions(
- [
- expr.replace_references(references_map)
- for expr in self.get_source_expressions()
- ]
- )
- return clone
-
- def copy(self):
- return copy.copy(self)
-
- def prefix_references(self, prefix):
- clone = self.copy()
- clone.set_source_expressions(
- [
- F(f"{prefix}{expr.name}")
- if isinstance(expr, F)
- else expr.prefix_references(prefix)
- for expr in self.get_source_expressions()
- ]
- )
- return clone
-
- def get_group_by_cols(self, alias=None):
- if not self.contains_aggregate:
- return [self]
- cols = []
- for source in self.get_source_expressions():
- cols.extend(source.get_group_by_cols())
- return cols
-
- def get_source_fields(self):
- """Return the underlying field types used by this aggregate."""
- return [e._output_field_or_none for e in self.get_source_expressions()]
-
- def asc(self, **kwargs):
- return OrderBy(self, **kwargs)
-
- def desc(self, **kwargs):
- return OrderBy(self, descending=True, **kwargs)
-
- def reverse_ordering(self):
- return self
-
- def flatten(self):
- """
- Recursively yield this expression and all subexpressions, in
- depth-first order.
- """
- yield self
- for expr in self.get_source_expressions():
- if expr:
- if hasattr(expr, "flatten"):
- yield from expr.flatten()
- else:
- yield expr
-
- def select_format(self, compiler, sql, params):
- """
- Custom format for select clauses. For example, EXISTS expressions need
- to be wrapped in CASE WHEN on Oracle.
- """
- if hasattr(self.output_field, "select_format"):
- return self.output_field.select_format(compiler, sql, params)
- return sql, params
-
-
- @deconstructible
- class Expression(BaseExpression, Combinable):
- """An expression that can be combined with other expressions."""
-
- @cached_property
- def identity(self):
- constructor_signature = inspect.signature(self.__init__)
- args, kwargs = self._constructor_args
- signature = constructor_signature.bind_partial(*args, **kwargs)
- signature.apply_defaults()
- arguments = signature.arguments.items()
- identity = [self.__class__]
- for arg, value in arguments:
- if isinstance(value, fields.Field):
- if value.name and value.model:
- value = (value.model._meta.label, value.name)
- else:
- value = type(value)
- else:
- value = make_hashable(value)
- identity.append((arg, value))
- return tuple(identity)
-
- def __eq__(self, other):
- if not isinstance(other, Expression):
- return NotImplemented
- return other.identity == self.identity
-
- def __hash__(self):
- return hash(self.identity)
-
-
- # Type inference for CombinedExpression.output_field.
- # Missing items will result in FieldError, by design.
- #
- # The current approach for NULL is based on lowest common denominator behavior
- # i.e. if one of the supported databases is raising an error (rather than
- # return NULL) for `val <op> NULL`, then Django raises FieldError.
- NoneType = type(None)
-
- _connector_combinations = [
- # Numeric operations - operands of same type.
- {
- connector: [
- (fields.IntegerField, fields.IntegerField, fields.IntegerField),
- (fields.FloatField, fields.FloatField, fields.FloatField),
- (fields.DecimalField, fields.DecimalField, fields.DecimalField),
- ]
- for connector in (
- Combinable.ADD,
- Combinable.SUB,
- Combinable.MUL,
- # Behavior for DIV with integer arguments follows Postgres/SQLite,
- # not MySQL/Oracle.
- Combinable.DIV,
- Combinable.MOD,
- Combinable.POW,
- )
- },
- # Numeric operations - operands of different type.
- {
- connector: [
- (fields.IntegerField, fields.DecimalField, fields.DecimalField),
- (fields.DecimalField, fields.IntegerField, fields.DecimalField),
- (fields.IntegerField, fields.FloatField, fields.FloatField),
- (fields.FloatField, fields.IntegerField, fields.FloatField),
- ]
- for connector in (
- Combinable.ADD,
- Combinable.SUB,
- Combinable.MUL,
- Combinable.DIV,
- )
- },
- # Bitwise operators.
- {
- connector: [
- (fields.IntegerField, fields.IntegerField, fields.IntegerField),
- ]
- for connector in (
- Combinable.BITAND,
- Combinable.BITOR,
- Combinable.BITLEFTSHIFT,
- Combinable.BITRIGHTSHIFT,
- Combinable.BITXOR,
- )
- },
- # Numeric with NULL.
- {
- connector: [
- (field_type, NoneType, field_type),
- (NoneType, field_type, field_type),
- ]
- for connector in (
- Combinable.ADD,
- Combinable.SUB,
- Combinable.MUL,
- Combinable.DIV,
- Combinable.MOD,
- Combinable.POW,
- )
- for field_type in (fields.IntegerField, fields.DecimalField, fields.FloatField)
- },
- # Date/DateTimeField/DurationField/TimeField.
- {
- Combinable.ADD: [
- # Date/DateTimeField.
- (fields.DateField, fields.DurationField, fields.DateTimeField),
- (fields.DateTimeField, fields.DurationField, fields.DateTimeField),
- (fields.DurationField, fields.DateField, fields.DateTimeField),
- (fields.DurationField, fields.DateTimeField, fields.DateTimeField),
- # DurationField.
- (fields.DurationField, fields.DurationField, fields.DurationField),
- # TimeField.
- (fields.TimeField, fields.DurationField, fields.TimeField),
- (fields.DurationField, fields.TimeField, fields.TimeField),
- ],
- },
- {
- Combinable.SUB: [
- # Date/DateTimeField.
- (fields.DateField, fields.DurationField, fields.DateTimeField),
- (fields.DateTimeField, fields.DurationField, fields.DateTimeField),
- (fields.DateField, fields.DateField, fields.DurationField),
- (fields.DateField, fields.DateTimeField, fields.DurationField),
- (fields.DateTimeField, fields.DateField, fields.DurationField),
- (fields.DateTimeField, fields.DateTimeField, fields.DurationField),
- # DurationField.
- (fields.DurationField, fields.DurationField, fields.DurationField),
- # TimeField.
- (fields.TimeField, fields.DurationField, fields.TimeField),
- (fields.TimeField, fields.TimeField, fields.DurationField),
- ],
- },
- ]
-
- _connector_combinators = defaultdict(list)
-
-
- def register_combinable_fields(lhs, connector, rhs, result):
- """
- Register combinable types:
- lhs <connector> rhs -> result
- e.g.
- register_combinable_fields(
- IntegerField, Combinable.ADD, FloatField, FloatField
- )
- """
- _connector_combinators[connector].append((lhs, rhs, result))
-
-
- for d in _connector_combinations:
- for connector, field_types in d.items():
- for lhs, rhs, result in field_types:
- register_combinable_fields(lhs, connector, rhs, result)
-
-
- @functools.lru_cache(maxsize=128)
- def _resolve_combined_type(connector, lhs_type, rhs_type):
- combinators = _connector_combinators.get(connector, ())
- for combinator_lhs_type, combinator_rhs_type, combined_type in combinators:
- if issubclass(lhs_type, combinator_lhs_type) and issubclass(
- rhs_type, combinator_rhs_type
- ):
- return combined_type
-
-
- class CombinedExpression(SQLiteNumericMixin, Expression):
- def __init__(self, lhs, connector, rhs, output_field=None):
- super().__init__(output_field=output_field)
- self.connector = connector
- self.lhs = lhs
- self.rhs = rhs
-
- def __repr__(self):
- return "<{}: {}>".format(self.__class__.__name__, self)
-
- def __str__(self):
- return "{} {} {}".format(self.lhs, self.connector, self.rhs)
-
- def get_source_expressions(self):
- return [self.lhs, self.rhs]
-
- def set_source_expressions(self, exprs):
- self.lhs, self.rhs = exprs
-
- def _resolve_output_field(self):
- # We avoid using super() here for reasons given in
- # Expression._resolve_output_field()
- combined_type = _resolve_combined_type(
- self.connector,
- type(self.lhs._output_field_or_none),
- type(self.rhs._output_field_or_none),
- )
- if combined_type is None:
- raise FieldError(
- f"Cannot infer type of {self.connector!r} expression involving these "
- f"types: {self.lhs.output_field.__class__.__name__}, "
- f"{self.rhs.output_field.__class__.__name__}. You must set "
- f"output_field."
- )
- return combined_type()
-
- def as_sql(self, compiler, connection):
- expressions = []
- expression_params = []
- sql, params = compiler.compile(self.lhs)
- expressions.append(sql)
- expression_params.extend(params)
- sql, params = compiler.compile(self.rhs)
- expressions.append(sql)
- expression_params.extend(params)
- # order of precedence
- expression_wrapper = "(%s)"
- sql = connection.ops.combine_expression(self.connector, expressions)
- return expression_wrapper % sql, expression_params
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- lhs = self.lhs.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- rhs = self.rhs.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- if not isinstance(self, (DurationExpression, TemporalSubtraction)):
- try:
- lhs_type = lhs.output_field.get_internal_type()
- except (AttributeError, FieldError):
- lhs_type = None
- try:
- rhs_type = rhs.output_field.get_internal_type()
- except (AttributeError, FieldError):
- rhs_type = None
- if "DurationField" in {lhs_type, rhs_type} and lhs_type != rhs_type:
- return DurationExpression(
- self.lhs, self.connector, self.rhs
- ).resolve_expression(
- query,
- allow_joins,
- reuse,
- summarize,
- for_save,
- )
- datetime_fields = {"DateField", "DateTimeField", "TimeField"}
- if (
- self.connector == self.SUB
- and lhs_type in datetime_fields
- and lhs_type == rhs_type
- ):
- return TemporalSubtraction(self.lhs, self.rhs).resolve_expression(
- query,
- allow_joins,
- reuse,
- summarize,
- for_save,
- )
- c = self.copy()
- c.is_summary = summarize
- c.lhs = lhs
- c.rhs = rhs
- return c
-
-
- class DurationExpression(CombinedExpression):
- def compile(self, side, compiler, connection):
- try:
- output = side.output_field
- except FieldError:
- pass
- else:
- if output.get_internal_type() == "DurationField":
- sql, params = compiler.compile(side)
- return connection.ops.format_for_duration_arithmetic(sql), params
- return compiler.compile(side)
-
- def as_sql(self, compiler, connection):
- if connection.features.has_native_duration_field:
- return super().as_sql(compiler, connection)
- connection.ops.check_expression_support(self)
- expressions = []
- expression_params = []
- sql, params = self.compile(self.lhs, compiler, connection)
- expressions.append(sql)
- expression_params.extend(params)
- sql, params = self.compile(self.rhs, compiler, connection)
- expressions.append(sql)
- expression_params.extend(params)
- # order of precedence
- expression_wrapper = "(%s)"
- sql = connection.ops.combine_duration_expression(self.connector, expressions)
- return expression_wrapper % sql, expression_params
-
- def as_sqlite(self, compiler, connection, **extra_context):
- sql, params = self.as_sql(compiler, connection, **extra_context)
- if self.connector in {Combinable.MUL, Combinable.DIV}:
- try:
- lhs_type = self.lhs.output_field.get_internal_type()
- rhs_type = self.rhs.output_field.get_internal_type()
- except (AttributeError, FieldError):
- pass
- else:
- allowed_fields = {
- "DecimalField",
- "DurationField",
- "FloatField",
- "IntegerField",
- }
- if lhs_type not in allowed_fields or rhs_type not in allowed_fields:
- raise DatabaseError(
- f"Invalid arguments for operator {self.connector}."
- )
- return sql, params
-
-
- class TemporalSubtraction(CombinedExpression):
- output_field = fields.DurationField()
-
- def __init__(self, lhs, rhs):
- super().__init__(lhs, self.SUB, rhs)
-
- def as_sql(self, compiler, connection):
- connection.ops.check_expression_support(self)
- lhs = compiler.compile(self.lhs)
- rhs = compiler.compile(self.rhs)
- return connection.ops.subtract_temporals(
- self.lhs.output_field.get_internal_type(), lhs, rhs
- )
-
-
- @deconstructible(path="django.db.models.F")
- class F(Combinable):
- """An object capable of resolving references to existing query objects."""
-
- def __init__(self, name):
- """
- Arguments:
- * name: the name of the field this expression references
- """
- self.name = name
-
- def __repr__(self):
- return "{}({})".format(self.__class__.__name__, self.name)
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- return query.resolve_ref(self.name, allow_joins, reuse, summarize)
-
- def replace_references(self, references_map):
- return references_map.get(self.name, self)
-
- def asc(self, **kwargs):
- return OrderBy(self, **kwargs)
-
- def desc(self, **kwargs):
- return OrderBy(self, descending=True, **kwargs)
-
- def __eq__(self, other):
- return self.__class__ == other.__class__ and self.name == other.name
-
- def __hash__(self):
- return hash(self.name)
-
-
- class ResolvedOuterRef(F):
- """
- An object that contains a reference to an outer query.
-
- In this case, the reference to the outer query has been resolved because
- the inner query has been used as a subquery.
- """
-
- contains_aggregate = False
-
- def as_sql(self, *args, **kwargs):
- raise ValueError(
- "This queryset contains a reference to an outer query and may "
- "only be used in a subquery."
- )
-
- def resolve_expression(self, *args, **kwargs):
- col = super().resolve_expression(*args, **kwargs)
- # FIXME: Rename possibly_multivalued to multivalued and fix detection
- # for non-multivalued JOINs (e.g. foreign key fields). This should take
- # into account only many-to-many and one-to-many relationships.
- col.possibly_multivalued = LOOKUP_SEP in self.name
- return col
-
- def relabeled_clone(self, relabels):
- return self
-
- def get_group_by_cols(self, alias=None):
- return []
-
-
- class OuterRef(F):
- contains_aggregate = False
-
- def resolve_expression(self, *args, **kwargs):
- if isinstance(self.name, self.__class__):
- return self.name
- return ResolvedOuterRef(self.name)
-
- def relabeled_clone(self, relabels):
- return self
-
-
- @deconstructible(path="django.db.models.Func")
- class Func(SQLiteNumericMixin, Expression):
- """An SQL function call."""
-
- function = None
- template = "%(function)s(%(expressions)s)"
- arg_joiner = ", "
- arity = None # The number of arguments the function accepts.
-
- def __init__(self, *expressions, output_field=None, **extra):
- if self.arity is not None and len(expressions) != self.arity:
- raise TypeError(
- "'%s' takes exactly %s %s (%s given)"
- % (
- self.__class__.__name__,
- self.arity,
- "argument" if self.arity == 1 else "arguments",
- len(expressions),
- )
- )
- super().__init__(output_field=output_field)
- self.source_expressions = self._parse_expressions(*expressions)
- self.extra = extra
-
- def __repr__(self):
- args = self.arg_joiner.join(str(arg) for arg in self.source_expressions)
- extra = {**self.extra, **self._get_repr_options()}
- if extra:
- extra = ", ".join(
- str(key) + "=" + str(val) for key, val in sorted(extra.items())
- )
- return "{}({}, {})".format(self.__class__.__name__, args, extra)
- return "{}({})".format(self.__class__.__name__, args)
-
- def _get_repr_options(self):
- """Return a dict of extra __init__() options to include in the repr."""
- return {}
-
- def get_source_expressions(self):
- return self.source_expressions
-
- def set_source_expressions(self, exprs):
- self.source_expressions = exprs
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- c = self.copy()
- c.is_summary = summarize
- for pos, arg in enumerate(c.source_expressions):
- c.source_expressions[pos] = arg.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- return c
-
- def as_sql(
- self,
- compiler,
- connection,
- function=None,
- template=None,
- arg_joiner=None,
- **extra_context,
- ):
- connection.ops.check_expression_support(self)
- sql_parts = []
- params = []
- for arg in self.source_expressions:
- try:
- arg_sql, arg_params = compiler.compile(arg)
- except EmptyResultSet:
- empty_result_set_value = getattr(
- arg, "empty_result_set_value", NotImplemented
- )
- if empty_result_set_value is NotImplemented:
- raise
- arg_sql, arg_params = compiler.compile(Value(empty_result_set_value))
- sql_parts.append(arg_sql)
- params.extend(arg_params)
- data = {**self.extra, **extra_context}
- # Use the first supplied value in this order: the parameter to this
- # method, a value supplied in __init__()'s **extra (the value in
- # `data`), or the value defined on the class.
- if function is not None:
- data["function"] = function
- else:
- data.setdefault("function", self.function)
- template = template or data.get("template", self.template)
- arg_joiner = arg_joiner or data.get("arg_joiner", self.arg_joiner)
- data["expressions"] = data["field"] = arg_joiner.join(sql_parts)
- return template % data, params
-
- def copy(self):
- copy = super().copy()
- copy.source_expressions = self.source_expressions[:]
- copy.extra = self.extra.copy()
- return copy
-
-
- @deconstructible(path="django.db.models.Value")
- class Value(SQLiteNumericMixin, Expression):
- """Represent a wrapped value as a node within an expression."""
-
- # Provide a default value for `for_save` in order to allow unresolved
- # instances to be compiled until a decision is taken in #25425.
- for_save = False
-
- def __init__(self, value, output_field=None):
- """
- Arguments:
- * value: the value this expression represents. The value will be
- added into the sql parameter list and properly quoted.
-
- * output_field: an instance of the model field type that this
- expression will return, such as IntegerField() or CharField().
- """
- super().__init__(output_field=output_field)
- self.value = value
-
- def __repr__(self):
- return f"{self.__class__.__name__}({self.value!r})"
-
- def as_sql(self, compiler, connection):
- connection.ops.check_expression_support(self)
- val = self.value
- output_field = self._output_field_or_none
- if output_field is not None:
- if self.for_save:
- val = output_field.get_db_prep_save(val, connection=connection)
- else:
- val = output_field.get_db_prep_value(val, connection=connection)
- if hasattr(output_field, "get_placeholder"):
- return output_field.get_placeholder(val, compiler, connection), [val]
- if val is None:
- # cx_Oracle does not always convert None to the appropriate
- # NULL type (like in case expressions using numbers), so we
- # use a literal SQL NULL
- return "NULL", []
- return "%s", [val]
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- c = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
- c.for_save = for_save
- return c
-
- def get_group_by_cols(self, alias=None):
- return []
-
- def _resolve_output_field(self):
- if isinstance(self.value, str):
- return fields.CharField()
- if isinstance(self.value, bool):
- return fields.BooleanField()
- if isinstance(self.value, int):
- return fields.IntegerField()
- if isinstance(self.value, float):
- return fields.FloatField()
- if isinstance(self.value, datetime.datetime):
- return fields.DateTimeField()
- if isinstance(self.value, datetime.date):
- return fields.DateField()
- if isinstance(self.value, datetime.time):
- return fields.TimeField()
- if isinstance(self.value, datetime.timedelta):
- return fields.DurationField()
- if isinstance(self.value, Decimal):
- return fields.DecimalField()
- if isinstance(self.value, bytes):
- return fields.BinaryField()
- if isinstance(self.value, UUID):
- return fields.UUIDField()
-
- @property
- def empty_result_set_value(self):
- return self.value
-
-
- class RawSQL(Expression):
- def __init__(self, sql, params, output_field=None):
- if output_field is None:
- output_field = fields.Field()
- self.sql, self.params = sql, params
- super().__init__(output_field=output_field)
-
- def __repr__(self):
- return "{}({}, {})".format(self.__class__.__name__, self.sql, self.params)
-
- def as_sql(self, compiler, connection):
- return "(%s)" % self.sql, self.params
-
- def get_group_by_cols(self, alias=None):
- return [self]
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- # Resolve parents fields used in raw SQL.
- if query.model:
- for parent in query.model._meta.get_parent_list():
- for parent_field in parent._meta.local_fields:
- _, column_name = parent_field.get_attname_column()
- if column_name.lower() in self.sql.lower():
- query.resolve_ref(
- parent_field.name, allow_joins, reuse, summarize
- )
- break
- return super().resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
-
-
- class Star(Expression):
- def __repr__(self):
- return "'*'"
-
- def as_sql(self, compiler, connection):
- return "*", []
-
-
- class Col(Expression):
- contains_column_references = True
- possibly_multivalued = False
-
- def __init__(self, alias, target, output_field=None):
- if output_field is None:
- output_field = target
- super().__init__(output_field=output_field)
- self.alias, self.target = alias, target
-
- def __repr__(self):
- alias, target = self.alias, self.target
- identifiers = (alias, str(target)) if alias else (str(target),)
- return "{}({})".format(self.__class__.__name__, ", ".join(identifiers))
-
- def as_sql(self, compiler, connection):
- alias, column = self.alias, self.target.column
- identifiers = (alias, column) if alias else (column,)
- sql = ".".join(map(compiler.quote_name_unless_alias, identifiers))
- return sql, []
-
- def relabeled_clone(self, relabels):
- if self.alias is None:
- return self
- return self.__class__(
- relabels.get(self.alias, self.alias), self.target, self.output_field
- )
-
- def get_group_by_cols(self, alias=None):
- return [self]
-
- def get_db_converters(self, connection):
- if self.target == self.output_field:
- return self.output_field.get_db_converters(connection)
- return self.output_field.get_db_converters(
- connection
- ) + self.target.get_db_converters(connection)
-
-
- class Ref(Expression):
- """
- Reference to column alias of the query. For example, Ref('sum_cost') in
- qs.annotate(sum_cost=Sum('cost')) query.
- """
-
- def __init__(self, refs, source):
- super().__init__()
- self.refs, self.source = refs, source
-
- def __repr__(self):
- return "{}({}, {})".format(self.__class__.__name__, self.refs, self.source)
-
- def get_source_expressions(self):
- return [self.source]
-
- def set_source_expressions(self, exprs):
- (self.source,) = exprs
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- # The sub-expression `source` has already been resolved, as this is
- # just a reference to the name of `source`.
- return self
-
- def relabeled_clone(self, relabels):
- return self
-
- def as_sql(self, compiler, connection):
- return connection.ops.quote_name(self.refs), []
-
- def get_group_by_cols(self, alias=None):
- return [self]
-
-
- class ExpressionList(Func):
- """
- An expression containing multiple expressions. Can be used to provide a
- list of expressions as an argument to another expression, like a partition
- clause.
- """
-
- template = "%(expressions)s"
-
- def __init__(self, *expressions, **extra):
- if not expressions:
- raise ValueError(
- "%s requires at least one expression." % self.__class__.__name__
- )
- super().__init__(*expressions, **extra)
-
- def __str__(self):
- return self.arg_joiner.join(str(arg) for arg in self.source_expressions)
-
- def as_sqlite(self, compiler, connection, **extra_context):
- # Casting to numeric is unnecessary.
- return self.as_sql(compiler, connection, **extra_context)
-
-
- class OrderByList(Func):
- template = "ORDER BY %(expressions)s"
-
- def __init__(self, *expressions, **extra):
- expressions = (
- (
- OrderBy(F(expr[1:]), descending=True)
- if isinstance(expr, str) and expr[0] == "-"
- else expr
- )
- for expr in expressions
- )
- super().__init__(*expressions, **extra)
-
- def as_sql(self, *args, **kwargs):
- if not self.source_expressions:
- return "", ()
- return super().as_sql(*args, **kwargs)
-
-
- @deconstructible(path="django.db.models.ExpressionWrapper")
- class ExpressionWrapper(SQLiteNumericMixin, Expression):
- """
- An expression that can wrap another expression so that it can provide
- extra context to the inner expression, such as the output_field.
- """
-
- def __init__(self, expression, output_field):
- super().__init__(output_field=output_field)
- self.expression = expression
-
- def set_source_expressions(self, exprs):
- self.expression = exprs[0]
-
- def get_source_expressions(self):
- return [self.expression]
-
- def get_group_by_cols(self, alias=None):
- if isinstance(self.expression, Expression):
- expression = self.expression.copy()
- expression.output_field = self.output_field
- return expression.get_group_by_cols(alias=alias)
- # For non-expressions e.g. an SQL WHERE clause, the entire
- # `expression` must be included in the GROUP BY clause.
- return super().get_group_by_cols()
-
- def as_sql(self, compiler, connection):
- return compiler.compile(self.expression)
-
- def __repr__(self):
- return "{}({})".format(self.__class__.__name__, self.expression)
-
-
- @deconstructible(path="django.db.models.When")
- class When(Expression):
- template = "WHEN %(condition)s THEN %(result)s"
- # This isn't a complete conditional expression, must be used in Case().
- conditional = False
-
- def __init__(self, condition=None, then=None, **lookups):
- if lookups:
- if condition is None:
- condition, lookups = Q(**lookups), None
- elif getattr(condition, "conditional", False):
- condition, lookups = Q(condition, **lookups), None
- if condition is None or not getattr(condition, "conditional", False) or lookups:
- raise TypeError(
- "When() supports a Q object, a boolean expression, or lookups "
- "as a condition."
- )
- if isinstance(condition, Q) and not condition:
- raise ValueError("An empty Q() can't be used as a When() condition.")
- super().__init__(output_field=None)
- self.condition = condition
- self.result = self._parse_expressions(then)[0]
-
- def __str__(self):
- return "WHEN %r THEN %r" % (self.condition, self.result)
-
- def __repr__(self):
- return "<%s: %s>" % (self.__class__.__name__, self)
-
- def get_source_expressions(self):
- return [self.condition, self.result]
-
- def set_source_expressions(self, exprs):
- self.condition, self.result = exprs
-
- def get_source_fields(self):
- # We're only interested in the fields of the result expressions.
- return [self.result._output_field_or_none]
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- c = self.copy()
- c.is_summary = summarize
- if hasattr(c.condition, "resolve_expression"):
- c.condition = c.condition.resolve_expression(
- query, allow_joins, reuse, summarize, False
- )
- c.result = c.result.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- return c
-
- def as_sql(self, compiler, connection, template=None, **extra_context):
- connection.ops.check_expression_support(self)
- template_params = extra_context
- sql_params = []
- condition_sql, condition_params = compiler.compile(self.condition)
- template_params["condition"] = condition_sql
- sql_params.extend(condition_params)
- result_sql, result_params = compiler.compile(self.result)
- template_params["result"] = result_sql
- sql_params.extend(result_params)
- template = template or self.template
- return template % template_params, sql_params
-
- def get_group_by_cols(self, alias=None):
- # This is not a complete expression and cannot be used in GROUP BY.
- cols = []
- for source in self.get_source_expressions():
- cols.extend(source.get_group_by_cols())
- return cols
-
-
- @deconstructible(path="django.db.models.Case")
- class Case(SQLiteNumericMixin, Expression):
- """
- An SQL searched CASE expression:
-
- CASE
- WHEN n > 0
- THEN 'positive'
- WHEN n < 0
- THEN 'negative'
- ELSE 'zero'
- END
- """
-
- template = "CASE %(cases)s ELSE %(default)s END"
- case_joiner = " "
-
- def __init__(self, *cases, default=None, output_field=None, **extra):
- if not all(isinstance(case, When) for case in cases):
- raise TypeError("Positional arguments must all be When objects.")
- super().__init__(output_field)
- self.cases = list(cases)
- self.default = self._parse_expressions(default)[0]
- self.extra = extra
-
- def __str__(self):
- return "CASE %s, ELSE %r" % (
- ", ".join(str(c) for c in self.cases),
- self.default,
- )
-
- def __repr__(self):
- return "<%s: %s>" % (self.__class__.__name__, self)
-
- def get_source_expressions(self):
- return self.cases + [self.default]
-
- def set_source_expressions(self, exprs):
- *self.cases, self.default = exprs
-
- def resolve_expression(
- self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
- ):
- c = self.copy()
- c.is_summary = summarize
- for pos, case in enumerate(c.cases):
- c.cases[pos] = case.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- c.default = c.default.resolve_expression(
- query, allow_joins, reuse, summarize, for_save
- )
- return c
-
- def copy(self):
- c = super().copy()
- c.cases = c.cases[:]
- return c
-
- def as_sql(
- self, compiler, connection, template=None, case_joiner=None, **extra_context
- ):
- connection.ops.check_expression_support(self)
- if not self.cases:
- return compiler.compile(self.default)
- template_params = {**self.extra, **extra_context}
- case_parts = []
- sql_params = []
- for case in self.cases:
- try:
- case_sql, case_params = compiler.compile(case)
- except EmptyResultSet:
- continue
- case_parts.append(case_sql)
- sql_params.extend(case_params)
- default_sql, default_params = compiler.compile(self.default)
- if not case_parts:
- return default_sql, default_params
- case_joiner = case_joiner or self.case_joiner
- template_params["cases"] = case_joiner.join(case_parts)
- template_params["default"] = default_sql
- sql_params.extend(default_params)
- template = template or template_params.get("template", self.template)
- sql = template % template_params
- if self._output_field_or_none is not None:
- sql = connection.ops.unification_cast_sql(self.output_field) % sql
- return sql, sql_params
-
- def get_group_by_cols(self, alias=None):
- if not self.cases:
- return self.default.get_group_by_cols(alias)
- return super().get_group_by_cols(alias)
-
-
- class Subquery(BaseExpression, Combinable):
- """
- An explicit subquery. It may contain OuterRef() references to the outer
- query which will be resolved when it is applied to that query.
- """
-
- template = "(%(subquery)s)"
- contains_aggregate = False
- empty_result_set_value = None
-
- def __init__(self, queryset, output_field=None, **extra):
- # Allow the usage of both QuerySet and sql.Query objects.
- self.query = getattr(queryset, "query", queryset).clone()
- self.query.subquery = True
- self.extra = extra
- super().__init__(output_field)
-
- def get_source_expressions(self):
- return [self.query]
-
- def set_source_expressions(self, exprs):
- self.query = exprs[0]
-
- def _resolve_output_field(self):
- return self.query.output_field
-
- def copy(self):
- clone = super().copy()
- clone.query = clone.query.clone()
- return clone
-
- @property
- def external_aliases(self):
- return self.query.external_aliases
-
- def get_external_cols(self):
- return self.query.get_external_cols()
-
- def as_sql(self, compiler, connection, template=None, query=None, **extra_context):
- connection.ops.check_expression_support(self)
- template_params = {**self.extra, **extra_context}
- query = query or self.query
- subquery_sql, sql_params = query.as_sql(compiler, connection)
- template_params["subquery"] = subquery_sql[1:-1]
-
- template = template or template_params.get("template", self.template)
- sql = template % template_params
- return sql, sql_params
-
- def get_group_by_cols(self, alias=None):
- # If this expression is referenced by an alias for an explicit GROUP BY
- # through values() a reference to this expression and not the
- # underlying .query must be returned to ensure external column
- # references are not grouped against as well.
- if alias:
- return [Ref(alias, self)]
- return self.query.get_group_by_cols()
-
-
- class Exists(Subquery):
- template = "EXISTS(%(subquery)s)"
- output_field = fields.BooleanField()
-
- def __init__(self, queryset, negated=False, **kwargs):
- self.negated = negated
- super().__init__(queryset, **kwargs)
-
- def __invert__(self):
- clone = self.copy()
- clone.negated = not self.negated
- return clone
-
- def get_group_by_cols(self, alias=None):
- # self.query only gets limited to a single row in the .exists() call
- # from self.as_sql() so deferring to Query.get_group_by_cols() is
- # inappropriate.
- if alias is None:
- return [self]
- return super().get_group_by_cols(alias)
-
- def as_sql(self, compiler, connection, template=None, **extra_context):
- query = self.query.exists(using=connection.alias)
- try:
- sql, params = super().as_sql(
- compiler,
- connection,
- template=template,
- query=query,
- **extra_context,
- )
- except EmptyResultSet:
- if self.negated:
- features = compiler.connection.features
- if not features.supports_boolean_expr_in_select_clause:
- return "1=1", ()
- return compiler.compile(Value(True))
- raise
- if self.negated:
- sql = "NOT {}".format(sql)
- return sql, params
-
- def select_format(self, compiler, sql, params):
- # Wrap EXISTS() with a CASE WHEN expression if a database backend
- # (e.g. Oracle) doesn't support boolean expression in SELECT or GROUP
- # BY list.
- if not compiler.connection.features.supports_boolean_expr_in_select_clause:
- sql = "CASE WHEN {} THEN 1 ELSE 0 END".format(sql)
- return sql, params
-
-
- @deconstructible(path="django.db.models.OrderBy")
- class OrderBy(Expression):
- template = "%(expression)s %(ordering)s"
- conditional = False
-
- def __init__(self, expression, descending=False, nulls_first=None, nulls_last=None):
- if nulls_first and nulls_last:
- raise ValueError("nulls_first and nulls_last are mutually exclusive")
- if nulls_first is False or nulls_last is False:
- # When the deprecation ends, replace with:
- # raise ValueError(
- # "nulls_first and nulls_last values must be True or None."
- # )
- warnings.warn(
- "Passing nulls_first=False or nulls_last=False is deprecated, use None "
- "instead.",
- RemovedInDjango50Warning,
- stacklevel=2,
- )
- self.nulls_first = nulls_first
- self.nulls_last = nulls_last
- self.descending = descending
- if not hasattr(expression, "resolve_expression"):
- raise ValueError("expression must be an expression type")
- self.expression = expression
-
- def __repr__(self):
- return "{}({}, descending={})".format(
- self.__class__.__name__, self.expression, self.descending
- )
-
- def set_source_expressions(self, exprs):
- self.expression = exprs[0]
-
- def get_source_expressions(self):
- return [self.expression]
-
- def as_sql(self, compiler, connection, template=None, **extra_context):
- template = template or self.template
- if connection.features.supports_order_by_nulls_modifier:
- if self.nulls_last:
- template = "%s NULLS LAST" % template
- elif self.nulls_first:
- template = "%s NULLS FIRST" % template
- else:
- if self.nulls_last and not (
- self.descending and connection.features.order_by_nulls_first
- ):
- template = "%%(expression)s IS NULL, %s" % template
- elif self.nulls_first and not (
- not self.descending and connection.features.order_by_nulls_first
- ):
- template = "%%(expression)s IS NOT NULL, %s" % template
- connection.ops.check_expression_support(self)
- expression_sql, params = compiler.compile(self.expression)
- placeholders = {
- "expression": expression_sql,
- "ordering": "DESC" if self.descending else "ASC",
- **extra_context,
- }
- params *= template.count("%(expression)s")
- return (template % placeholders).rstrip(), params
-
- def as_oracle(self, compiler, connection):
- # Oracle doesn't allow ORDER BY EXISTS() or filters unless it's wrapped
- # in a CASE WHEN.
- if connection.ops.conditional_expression_supported_in_where_clause(
- self.expression
- ):
- copy = self.copy()
- copy.expression = Case(
- When(self.expression, then=True),
- default=False,
- )
- return copy.as_sql(compiler, connection)
- return self.as_sql(compiler, connection)
-
- def get_group_by_cols(self, alias=None):
- cols = []
- for source in self.get_source_expressions():
- cols.extend(source.get_group_by_cols())
- return cols
-
- def reverse_ordering(self):
- self.descending = not self.descending
- if self.nulls_first:
- self.nulls_last = True
- self.nulls_first = None
- elif self.nulls_last:
- self.nulls_first = True
- self.nulls_last = None
- return self
-
- def asc(self):
- self.descending = False
-
- def desc(self):
- self.descending = True
-
-
- class Window(SQLiteNumericMixin, Expression):
- template = "%(expression)s OVER (%(window)s)"
- # Although the main expression may either be an aggregate or an
- # expression with an aggregate function, the GROUP BY that will
- # be introduced in the query as a result is not desired.
- contains_aggregate = False
- contains_over_clause = True
- filterable = False
-
- def __init__(
- self,
- expression,
- partition_by=None,
- order_by=None,
- frame=None,
- output_field=None,
- ):
- self.partition_by = partition_by
- self.order_by = order_by
- self.frame = frame
-
- if not getattr(expression, "window_compatible", False):
- raise ValueError(
- "Expression '%s' isn't compatible with OVER clauses."
- % expression.__class__.__name__
- )
-
- if self.partition_by is not None:
- if not isinstance(self.partition_by, (tuple, list)):
- self.partition_by = (self.partition_by,)
- self.partition_by = ExpressionList(*self.partition_by)
-
- if self.order_by is not None:
- if isinstance(self.order_by, (list, tuple)):
- self.order_by = OrderByList(*self.order_by)
- elif isinstance(self.order_by, (BaseExpression, str)):
- self.order_by = OrderByList(self.order_by)
- else:
- raise ValueError(
- "Window.order_by must be either a string reference to a "
- "field, an expression, or a list or tuple of them."
- )
- super().__init__(output_field=output_field)
- self.source_expression = self._parse_expressions(expression)[0]
-
- def _resolve_output_field(self):
- return self.source_expression.output_field
-
- def get_source_expressions(self):
- return [self.source_expression, self.partition_by, self.order_by, self.frame]
-
- def set_source_expressions(self, exprs):
- self.source_expression, self.partition_by, self.order_by, self.frame = exprs
-
- def as_sql(self, compiler, connection, template=None):
- connection.ops.check_expression_support(self)
- if not connection.features.supports_over_clause:
- raise NotSupportedError("This backend does not support window expressions.")
- expr_sql, params = compiler.compile(self.source_expression)
- window_sql, window_params = [], ()
-
- if self.partition_by is not None:
- sql_expr, sql_params = self.partition_by.as_sql(
- compiler=compiler,
- connection=connection,
- template="PARTITION BY %(expressions)s",
- )
- window_sql.append(sql_expr)
- window_params += tuple(sql_params)
-
- if self.order_by is not None:
- order_sql, order_params = compiler.compile(self.order_by)
- window_sql.append(order_sql)
- window_params += tuple(order_params)
-
- if self.frame:
- frame_sql, frame_params = compiler.compile(self.frame)
- window_sql.append(frame_sql)
- window_params += tuple(frame_params)
-
- template = template or self.template
-
- return (
- template % {"expression": expr_sql, "window": " ".join(window_sql).strip()},
- (*params, *window_params),
- )
-
- def as_sqlite(self, compiler, connection):
- if isinstance(self.output_field, fields.DecimalField):
- # Casting to numeric must be outside of the window expression.
- copy = self.copy()
- source_expressions = copy.get_source_expressions()
- source_expressions[0].output_field = fields.FloatField()
- copy.set_source_expressions(source_expressions)
- return super(Window, copy).as_sqlite(compiler, connection)
- return self.as_sql(compiler, connection)
-
- def __str__(self):
- return "{} OVER ({}{}{})".format(
- str(self.source_expression),
- "PARTITION BY " + str(self.partition_by) if self.partition_by else "",
- str(self.order_by or ""),
- str(self.frame or ""),
- )
-
- def __repr__(self):
- return "<%s: %s>" % (self.__class__.__name__, self)
-
- def get_group_by_cols(self, alias=None):
- return []
-
-
- class WindowFrame(Expression):
- """
- Model the frame clause in window expressions. There are two types of frame
- clauses which are subclasses, however, all processing and validation (by no
- means intended to be complete) is done here. Thus, providing an end for a
- frame is optional (the default is UNBOUNDED FOLLOWING, which is the last
- row in the frame).
- """
-
- template = "%(frame_type)s BETWEEN %(start)s AND %(end)s"
-
- def __init__(self, start=None, end=None):
- self.start = Value(start)
- self.end = Value(end)
-
- def set_source_expressions(self, exprs):
- self.start, self.end = exprs
-
- def get_source_expressions(self):
- return [self.start, self.end]
-
- def as_sql(self, compiler, connection):
- connection.ops.check_expression_support(self)
- start, end = self.window_frame_start_end(
- connection, self.start.value, self.end.value
- )
- return (
- self.template
- % {
- "frame_type": self.frame_type,
- "start": start,
- "end": end,
- },
- [],
- )
-
- def __repr__(self):
- return "<%s: %s>" % (self.__class__.__name__, self)
-
- def get_group_by_cols(self, alias=None):
- return []
-
- def __str__(self):
- if self.start.value is not None and self.start.value < 0:
- start = "%d %s" % (abs(self.start.value), connection.ops.PRECEDING)
- elif self.start.value is not None and self.start.value == 0:
- start = connection.ops.CURRENT_ROW
- else:
- start = connection.ops.UNBOUNDED_PRECEDING
-
- if self.end.value is not None and self.end.value > 0:
- end = "%d %s" % (self.end.value, connection.ops.FOLLOWING)
- elif self.end.value is not None and self.end.value == 0:
- end = connection.ops.CURRENT_ROW
- else:
- end = connection.ops.UNBOUNDED_FOLLOWING
- return self.template % {
- "frame_type": self.frame_type,
- "start": start,
- "end": end,
- }
-
- def window_frame_start_end(self, connection, start, end):
- raise NotImplementedError("Subclasses must implement window_frame_start_end().")
-
-
- class RowRange(WindowFrame):
- frame_type = "ROWS"
-
- def window_frame_start_end(self, connection, start, end):
- return connection.ops.window_frame_rows_start_end(start, end)
-
-
- class ValueRange(WindowFrame):
- frame_type = "RANGE"
-
- def window_frame_start_end(self, connection, start, end):
- return connection.ops.window_frame_range_start_end(start, end)
|