1464 lines
52 KiB
Python
1464 lines
52 KiB
Python
import copy
|
||
import datetime
|
||
import functools
|
||
import inspect
|
||
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.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() and .bitor() 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 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() and .bitor() 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() and .bitor() for bitwise logical operations."
|
||
)
|
||
|
||
def __ror__(self, other):
|
||
raise NotImplementedError(
|
||
"Use .bitand() and .bitor() 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. If the output
|
||
fields of all source fields match then, simply infer the same type
|
||
here. This isn't always correct, but it makes sense most of the time.
|
||
|
||
Consider the difference between `2 + 2` and `2 / 3`. Inferring
|
||
the type here is a convenience for the common case. The user should
|
||
supply their own output_field with more complex computations.
|
||
|
||
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.
|
||
"""
|
||
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 copy(self):
|
||
return copy.copy(self)
|
||
|
||
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)
|
||
|
||
|
||
_connector_combinators = {
|
||
connector: [
|
||
(fields.IntegerField, fields.IntegerField, fields.IntegerField),
|
||
(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)
|
||
}
|
||
|
||
|
||
@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):
|
||
try:
|
||
return super()._resolve_output_field()
|
||
except FieldError:
|
||
combined_type = _resolve_combined_type(
|
||
self.connector,
|
||
type(self.lhs.output_field),
|
||
type(self.rhs.output_field),
|
||
)
|
||
if combined_type is None:
|
||
raise
|
||
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
|
||
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 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
|
||
|
||
|
||
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
|
||
|
||
|
||
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.
|
||
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 an
|
||
ordering 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 ExpressionWrapper(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)
|
||
|
||
|
||
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
|
||
|
||
|
||
class Case(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)
|
||
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 alias:
|
||
return [Ref(alias, self)]
|
||
external_cols = self.get_external_cols()
|
||
if any(col.possibly_multivalued for col in external_cols):
|
||
return [self]
|
||
return external_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 as_sql(self, compiler, connection, template=None, **extra_context):
|
||
query = self.query.exists(using=connection.alias)
|
||
sql, params = super().as_sql(
|
||
compiler,
|
||
connection,
|
||
template=template,
|
||
query=query,
|
||
**extra_context,
|
||
)
|
||
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
|
||
|
||
|
||
class OrderBy(Expression):
|
||
template = '%(expression)s %(ordering)s'
|
||
conditional = False
|
||
|
||
def __init__(self, expression, descending=False, nulls_first=False, nulls_last=False):
|
||
if nulls_first and nulls_last:
|
||
raise ValueError('nulls_first and nulls_last are mutually exclusive')
|
||
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 or self.nulls_last:
|
||
self.nulls_first = not self.nulls_first
|
||
self.nulls_last = not self.nulls_last
|
||
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 = ExpressionList(*self.order_by)
|
||
elif not isinstance(self.order_by, BaseExpression):
|
||
raise ValueError(
|
||
'order_by must be either an Expression or a sequence of '
|
||
'expressions.'
|
||
)
|
||
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.extend(sql_expr)
|
||
window_params.extend(sql_params)
|
||
|
||
if self.order_by is not None:
|
||
window_sql.append(' ORDER BY ')
|
||
order_sql, order_params = compiler.compile(self.order_by)
|
||
window_sql.extend(order_sql)
|
||
window_params.extend(order_params)
|
||
|
||
if self.frame:
|
||
frame_sql, frame_params = compiler.compile(self.frame)
|
||
window_sql.append(' ' + frame_sql)
|
||
window_params.extend(frame_params)
|
||
|
||
params.extend(window_params)
|
||
template = template or self.template
|
||
|
||
return template % {
|
||
'expression': expr_sql,
|
||
'window': ''.join(window_sql).strip()
|
||
}, 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 '',
|
||
'ORDER BY ' + str(self.order_by) if self.order_by else '',
|
||
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)
|