Refs #24485 -- Renamed some expression types (88d798d7) · Commits · Dom Sekotill / django

django/contrib/gis/db/models/fields.py

+3 −3

Original line number	Diff line number	Diff line
		@@ -2,7 +2,7 @@ from django.contrib.gis import forms
		from django.contrib.gis.db.models.lookups import gis_lookups
		from django.contrib.gis.db.models.proxy import GeometryProxy
		from django.contrib.gis.geometry.backend import Geometry, GeometryException
		from django.db.models.expressions import ExpressionNode
		from django.db.models.expressions import Expression
		from django.db.models.fields import Field
		from django.utils import six
		from django.utils.translation import ugettext_lazy as _
		@@ -188,7 +188,7 @@ class GeometryField(GeoSelectFormatMixin, Field):
		returning to the caller.
		"""
		value = super(GeometryField, self).get_prep_value(value)
		if isinstance(value, ExpressionNode):
		if isinstance(value, Expression):
		return value
		elif isinstance(value, (tuple, list)):
		geom = value[0]
		@@ -282,7 +282,7 @@ class GeometryField(GeoSelectFormatMixin, Field):
		pass
		else:
		params += value[1:]
		elif isinstance(value, ExpressionNode):
		elif isinstance(value, Expression):
		params = []
		else:
		params = [connection.ops.Adapter(value)]

django/contrib/gis/db/models/lookups.py

+2 −2

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@ import re

		from django.core.exceptions import FieldDoesNotExist
		from django.db.models.constants import LOOKUP_SEP
		from django.db.models.expressions import Col, ExpressionNode
		from django.db.models.expressions import Col, Expression
		from django.db.models.lookups import Lookup
		from django.utils import six

		@@ -80,7 +80,7 @@ class GISLookup(Lookup):
		if not hasattr(geo_fld, 'srid'):
		raise ValueError('No geographic field found in expression.')
		self.rhs.srid = geo_fld.srid
		elif isinstance(self.rhs, ExpressionNode):
		elif isinstance(self.rhs, Expression):
		raise ValueError('Complex expressions not supported for GeometryField')
		elif isinstance(self.rhs, (list, tuple)):
		geom = self.rhs[0]

django/db/models/init.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,7 @@ from functools import wraps

		from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured # NOQA
		from django.db.models.query import Q, QuerySet, Prefetch # NOQA
		from django.db.models.expressions import ExpressionNode, F, Value, Func, Case, When # NOQA
		from django.db.models.expressions import Expression, F, Value, Func, Case, When # NOQA
		from django.db.models.manager import Manager # NOQA
		from django.db.models.base import Model # NOQA
		from django.db.models.aggregates import * # NOQA

django/db/models/expressions.py

+19 −19

Original line number	Diff line number	Diff line
		@@ -42,8 +42,8 @@ class Combinable(object):
		other = Value(other)

		if reversed:
		return Expression(other, connector, self)
		return Expression(self, connector, other)
		return CombinedExpression(other, connector, self)
		return CombinedExpression(self, connector, other)

		#############
		# OPERATORS #
		@@ -156,8 +156,8 @@ class BaseExpression(object):
		```
		def override_as_sql(self, compiler, connection):
		# custom logic
		return super(ExpressionNode, self).as_sql(compiler, connection)
		setattr(ExpressionNode, 'as_' + connection.vendor, override_as_sql)
		return super(Expression, self).as_sql(compiler, connection)
		setattr(Expression, 'as_' + connection.vendor, override_as_sql)
		```

		Arguments:
		@@ -193,7 +193,7 @@ class BaseExpression(object):
		* summarize: a terminal aggregate clause
		* for_save: whether this expression about to be used in a save or update

		Returns: an ExpressionNode to be added to the query.
		Returns: an Expression to be added to the query.
		"""
		c = self.copy()
		c.is_summary = summarize
		@@ -330,17 +330,17 @@ class BaseExpression(object):
		return self


		class ExpressionNode(BaseExpression, Combinable):
		class Expression(BaseExpression, Combinable):
		"""
		An expression that can be combined with other expressions.
		"""
		pass


		class Expression(ExpressionNode):
		class CombinedExpression(Expression):

		def __init__(self, lhs, connector, rhs, output_field=None):
		super(Expression, self).__init__(output_field=output_field)
		super(CombinedExpression, self).__init__(output_field=output_field)
		self.connector = connector
		self.lhs = lhs
		self.rhs = rhs
		@@ -391,7 +391,7 @@ class Expression(ExpressionNode):
		return c


		class DurationExpression(Expression):
		class DurationExpression(CombinedExpression):
		def compile(self, side, compiler, connection):
		if not isinstance(side, DurationValue):
		try:
		@@ -447,7 +447,7 @@ class F(Combinable):
		return OrderBy(self, descending=True)


		class Func(ExpressionNode):
		class Func(Expression):
		"""
		A SQL function call.
		"""
		@@ -504,7 +504,7 @@ class Func(ExpressionNode):
		return copy


		class Value(ExpressionNode):
		class Value(Expression):
		"""
		Represents a wrapped value as a node within an expression
		"""
		@@ -557,7 +557,7 @@ class DurationValue(Value):
		return connection.ops.date_interval_sql(self.value)


		class RawSQL(ExpressionNode):
		class RawSQL(Expression):
		def __init__(self, sql, params, output_field=None):
		if output_field is None:
		output_field = fields.Field()
		@@ -574,7 +574,7 @@ class RawSQL(ExpressionNode):
		return [self]


		class Random(ExpressionNode):
		class Random(Expression):
		def __init__(self):
		super(Random, self).__init__(output_field=fields.FloatField())

		@@ -585,7 +585,7 @@ class Random(ExpressionNode):
		return connection.ops.random_function_sql(), []


		class Col(ExpressionNode):
		class Col(Expression):
		def __init__(self, alias, target, output_field=None):
		if output_field is None:
		output_field = target
		@@ -613,7 +613,7 @@ class Col(ExpressionNode):
		self.target.get_db_converters(connection))


		class Ref(ExpressionNode):
		class Ref(Expression):
		"""
		Reference to column alias of the query. For example, Ref('sum_cost') in
		qs.annotate(sum_cost=Sum('cost')) query.
		@@ -646,7 +646,7 @@ class Ref(ExpressionNode):
		return [self]


		class When(ExpressionNode):
		class When(Expression):
		template = 'WHEN %(condition)s THEN %(result)s'

		def __init__(self, condition=None, then=None, **lookups):
		@@ -702,7 +702,7 @@ class When(ExpressionNode):
		return cols


		class Case(ExpressionNode):
		class Case(Expression):
		"""
		An SQL searched CASE expression:

		@@ -769,7 +769,7 @@ class Case(ExpressionNode):
		return sql, sql_params


		class Date(ExpressionNode):
		class Date(Expression):
		"""
		Add a date selection column.
		"""
		@@ -816,7 +816,7 @@ class Date(ExpressionNode):
		return value


		class DateTime(ExpressionNode):
		class DateTime(Expression):
		"""
		Add a datetime selection column.
		"""

docs/ref/models/expressions.txt

+6 −6

Original line number	Diff line number	Diff line
		@@ -280,9 +280,9 @@ should define the desired ``output_field``. For example, adding an
		arithmetic between different types, it's necessary to surround the
		expression in another expression::

		from django.db.models import DateTimeField, ExpressionNode, F
		from django.db.models import DateTimeField, Expression, F

		Race.objects.annotate(finish=ExpressionNode(
		Race.objects.annotate(finish=Expression(
		F('start') + F('duration'), output_field=DateTimeField()))

		.. versionchanged:: 1.8
		@@ -365,13 +365,13 @@ Expression API

		Query expressions implement the :ref:`query expression API <query-expression>`,
		but also expose a number of extra methods and attributes listed below. All
		query expressions must inherit from ``ExpressionNode()`` or a relevant
		query expressions must inherit from ``Expression()`` or a relevant
		subclass.

		When a query expression wraps another expression, it is responsible for
		calling the appropriate methods on the wrapped expression.

		.. class:: ExpressionNode
		.. class:: Expression

		.. attribute:: contains_aggregate

		@@ -485,9 +485,9 @@ We'll start by defining the template to be used for SQL generation and
		an ``__init__()`` method to set some attributes::

		import copy
		from django.db.models import ExpressionNode
		from django.db.models import Expression

		class Coalesce(ExpressionNode):
		class Coalesce(Expression):
		template = 'COALESCE( %(expressions)s )'

		def __init__(self, expressions, output_field, **extra):