import copy

import datetime

import functools

from collections import defaultdict

from decimal import Decimal

from enum import Enum

from itertools import chain

from types import NoneType

from uuid import UUID

from django.core.exceptions import EmptyResultSet, FieldError, FullResultSet

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, classproperty

from django.utils.hashable import make_hashable

from django.utils.inspect import signature

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."

)

def __invert__(self):

return NegatedExpression(self)

class OutputFieldIsNoneError(FieldError):

pass

class BaseExpression:

"""Base class for all query expressions."""

empty_result_set_value = NotImplemented

# aggregate specific fields

is_summary = False

# Can the expression be used in a WHERE clause?

filterable = True

# Can the expression be used as a source expression in Window?

window_compatible = False

# Can the expression be used as a database default value?

allowed_default = False

# Can the expression be used during a constraint validation?

constraint_validation_compatible = True

# Does the expression possibly return more than one row?

set_returning = False

# Does the expression allow composite expressions?

allows_composite_expressions = 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()

)

@cached_property

def contains_subquery(self):

return any(

expr and (getattr(expr, "subquery", False) or expr.contains_subquery)

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

source_expressions = [

(

expr.resolve_expression(query, allow_joins, reuse, summarize, for_save)

if expr is not None

else None

)

for expr in c.get_source_expressions()

]

if not self.allows_composite_expressions and any(

isinstance(expr, ColPairs) for expr in source_expressions

):

raise ValueError(

f"{self.__class__.__name__} expression does not support "

"composite primary keys."

)

c.set_source_expressions(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:

raise OutputFieldIsNoneError(

"Cannot resolve expression type, unknown output_field"

)

return output_field

@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 OutputFieldIsNoneError:

return

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_expressions(self, replacements):

if not replacements:

return self

if replacement := replacements.get(self):

return replacement

if not (source_expressions := self.get_source_expressions()):

return self

clone = self.copy()

clone.set_source_expressions(

[

None if expr is None else expr.replace_expressions(replacements)

for expr in source_expressions

]

)

return clone

def get_refs(self):

refs = set()

for expr in self.get_source_expressions():

if expr is None:

continue

refs |= expr.get_refs()

return refs

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):

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

def get_expression_for_validation(self):

# Ignore expressions that cannot be used during a constraint

# validation.

if not getattr(self, "constraint_validation_compatible", True):

try:

(expression,) = self.get_source_expressions()

except ValueError as e:

raise ValueError(

"Expressions with constraint_validation_compatible set to False "

"must have only one source expression."

) from e

else:

return expression

return self

@deconstructible

class Expression(BaseExpression, Combinable):

"""An expression that can be combined with other expressions."""

@classproperty

@functools.lru_cache(maxsize=128)

def _constructor_signature(cls):

return signature(cls.__init__)

@classmethod

def _identity(cls, value):

if isinstance(value, tuple):

return tuple(map(cls._identity, value))

if isinstance(value, dict):

return tuple((key, cls._identity(val)) for key, val in value.items())

if isinstance(value, fields.Field):

if value.name and value.model:

return value.model._meta.label, value.name

return type(value)

return make_hashable(value)

@cached_property

def identity(self):

args, kwargs = self._constructor_args

signature = self._constructor_signature.bind_partial(self, *args, **kwargs)

signature.apply_defaults()

arguments = iter(signature.arguments.items())

next(arguments)

identity = [self.__class__]

for arg, value in arguments:

# If __init__() makes use of *args or **kwargs captures `value`

# will respectively be a tuple or a dict that must have its

# constituents unpacked (mainly if contain Field instances).

value = self._identity(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.

_connector_combinations = [

# Numeric operations - operands of same type.

# PositiveIntegerField should take precedence over IntegerField (except

# subtraction).

{

connector: [

(

fields.PositiveIntegerField,

fields.PositiveIntegerField,

fields.PositiveIntegerField,

),

]

for connector in (

Combinable.ADD,

Combinable.MUL,

Combinable.DIV,

Combinable.MOD,

Combinable.POW,

)

},

# Other numeric operands.

{

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,

Combinable.MOD,

)

},

# 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: list(

chain.from_iterable(

[(field_type, NoneType, field_type), (NoneType, field_type, field_type)]

for field_type in (

fields.IntegerField,

fields.DecimalField,

fields.FloatField,

)

)

)

for connector in (

Combinable.ADD,

Combinable.SUB,

Combinable.MUL,

Combinable.DIV,

Combinable.MOD,

Combinable.POW,

)

},

# 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

):

resolved = super().resolve_expression(

query,

allow_joins,

reuse,

summarize,

for_save,

)

if not isinstance(self, (DurationExpression, TemporalSubtraction)):

try:

lhs_type = resolved.lhs.output_field.get_internal_type()

except (AttributeError, FieldError):

lhs_type = None

try:

rhs_type = resolved.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(

resolved.lhs, resolved.connector, resolved.rhs

)

datetime_fields = {"DateField", "DateTimeField", "TimeField"}

if (

self.connector == self.SUB

and lhs_type in datetime_fields

and lhs_type == rhs_type

):

return TemporalSubtraction(resolved.lhs, resolved.rhs)

return resolved

@cached_property

def allowed_default(self):

return self.lhs.allowed_default and self.rhs.allowed_default

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."""

allowed_default = False

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 __getitem__(self, subscript):

return Sliced(self, subscript)

def __contains__(self, other):

# Disable old-style iteration protocol inherited from implementing

# __getitem__() to prevent this method from hanging.

raise TypeError(f"argument of type '{self.__class__.__name__}' is not iterable")

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_expressions(self, replacements):

if (replacement := replacements.get(self)) is not None:

return replacement

field_name, *transforms = self.name.split(LOOKUP_SEP)

# Avoid unnecessarily looking up replacements with field_name again as

# in the vast majority of cases F instances won't be composed of any

# lookups.

if not transforms:

return self

if (

replacement := replacements.get(F(field_name))

) is None or replacement._output_field_or_none is None:

return self

for transform in transforms:

transform_class = replacement.get_transform(transform)

if transform_class is None:

return self

replacement = transform_class(replacement)

return replacement

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)

def copy(self):

return copy.copy(self)

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

contains_over_clause = 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)

if col.contains_over_clause:

raise NotSupportedError(

f"Referencing outer query window expression is not supported: "

f"{self.name}."

)

# 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):

return []

class OuterRef(F):

contains_aggregate = False

contains_over_clause = 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 Sliced(F):

"""

An object that contains a slice of an F expression.

Object resolves the column on which the slicing is applied, and then

applies the slicing if possible.

"""

def __init__(self, obj, subscript):