# sql/elements.py

# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors

# <see AUTHORS file>

#

# This module is part of SQLAlchemy and is released under

# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""Core SQL expression elements, including :class:`_expression.ClauseElement`,

:class:`_expression.ColumnElement`, and derived classes.

"""

from __future__ import unicode_literals

import itertools

import operator

import re

from . import coercions

from . import operators

from . import roles

from . import traversals

from . import type_api

from .annotation import Annotated

from .annotation import SupportsWrappingAnnotations

from .base import _clone

from .base import _generative

from .base import Executable

from .base import HasMemoized

from .base import Immutable

from .base import NO_ARG

from .base import PARSE_AUTOCOMMIT

from .base import SingletonConstant

from .coercions import _document_text_coercion

from .traversals import _copy_internals

from .traversals import _get_children

from .traversals import MemoizedHasCacheKey

from .traversals import NO_CACHE

from .visitors import cloned_traverse

from .visitors import InternalTraversal

from .visitors import traverse

from .visitors import Traversible

from .. import exc

from .. import inspection

from .. import util

if util.TYPE_CHECKING:

from typing import Any

from typing import Optional

from typing import Union

def collate(expression, collation):

"""Return the clause ``expression COLLATE collation``.

e.g.::

collate(mycolumn, 'utf8_bin')

produces::

mycolumn COLLATE utf8_bin

The collation expression is also quoted if it is a case sensitive

identifier, e.g. contains uppercase characters.

.. versionchanged:: 1.2 quoting is automatically applied to COLLATE

expressions if they are case sensitive.

"""

expr = coercions.expect(roles.ExpressionElementRole, expression)

return BinaryExpression(

expr, CollationClause(collation), operators.collate, type_=expr.type

)

def between(expr, lower_bound, upper_bound, symmetric=False):

"""Produce a ``BETWEEN`` predicate clause.

E.g.::

from sqlalchemy import between

stmt = select([users_table]).where(between(users_table.c.id, 5, 7))

Would produce SQL resembling::

SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2

The :func:`.between` function is a standalone version of the

:meth:`_expression.ColumnElement.between` method available on all

SQL expressions, as in::

stmt = select([users_table]).where(users_table.c.id.between(5, 7))

All arguments passed to :func:`.between`, including the left side

column expression, are coerced from Python scalar values if a

the value is not a :class:`_expression.ColumnElement` subclass.

For example,

three fixed values can be compared as in::

print(between(5, 3, 7))

Which would produce::

:param_1 BETWEEN :param_2 AND :param_3

:param expr: a column expression, typically a

:class:`_expression.ColumnElement`

instance or alternatively a Python scalar expression to be coerced

into a column expression, serving as the left side of the ``BETWEEN``

expression.

:param lower_bound: a column or Python scalar expression serving as the

lower bound of the right side of the ``BETWEEN`` expression.

:param upper_bound: a column or Python scalar expression serving as the

upper bound of the right side of the ``BETWEEN`` expression.

:param symmetric: if True, will render " BETWEEN SYMMETRIC ". Note

that not all databases support this syntax.

.. versionadded:: 0.9.5

.. seealso::

:meth:`_expression.ColumnElement.between`

"""

expr = coercions.expect(roles.ExpressionElementRole, expr)

return expr.between(lower_bound, upper_bound, symmetric=symmetric)

def literal(value, type_=None):

r"""Return a literal clause, bound to a bind parameter.

Literal clauses are created automatically when non-

:class:`_expression.ClauseElement` objects (such as strings, ints, dates,

etc.) are

used in a comparison operation with a :class:`_expression.ColumnElement`

subclass,

such as a :class:`~sqlalchemy.schema.Column` object. Use this function

to force the generation of a literal clause, which will be created as a

:class:`BindParameter` with a bound value.

:param value: the value to be bound. Can be any Python object supported by

the underlying DB-API, or is translatable via the given type argument.

:param type\_: an optional :class:`~sqlalchemy.types.TypeEngine` which

will provide bind-parameter translation for this literal.

"""

return BindParameter(None, value, type_=type_, unique=True)

def outparam(key, type_=None):

"""Create an 'OUT' parameter for usage in functions (stored procedures),

for databases which support them.

The ``outparam`` can be used like a regular function parameter.

The "output" value will be available from the

:class:`~sqlalchemy.engine.CursorResult` object via its ``out_parameters``

attribute, which returns a dictionary containing the values.

"""

return BindParameter(key, None, type_=type_, unique=False, isoutparam=True)

def not_(clause):

"""Return a negation of the given clause, i.e. ``NOT(clause)``.

The ``~`` operator is also overloaded on all

:class:`_expression.ColumnElement` subclasses to produce the

same result.

"""

return operators.inv(coercions.expect(roles.ExpressionElementRole, clause))

@inspection._self_inspects

class ClauseElement(

roles.SQLRole,

SupportsWrappingAnnotations,

MemoizedHasCacheKey,

Traversible,

):

"""Base class for elements of a programmatically constructed SQL

expression.

"""

__visit_name__ = "clause"

_propagate_attrs = util.immutabledict()

"""like annotations, however these propagate outwards liberally

as SQL constructs are built, and are set up at construction time.

"""

supports_execution = False

_from_objects = []

bind = None

description = None

_is_clone_of = None

is_clause_element = True

is_selectable = False

_is_textual = False

_is_from_clause = False

_is_returns_rows = False

_is_text_clause = False

_is_from_container = False

_is_select_container = False

_is_select_statement = False

_is_bind_parameter = False

_is_clause_list = False

_order_by_label_element = None

_cache_key_traversal = None

def _set_propagate_attrs(self, values):

# usually, self._propagate_attrs is empty here. one case where it's

# not is a subquery against ORM select, that is then pulled as a

# property of an aliased class. should all be good

# assert not self._propagate_attrs

self._propagate_attrs = util.immutabledict(values)

return self

def _clone(self):

"""Create a shallow copy of this ClauseElement.

This method may be used by a generative API. Its also used as

part of the "deep" copy afforded by a traversal that combines

the _copy_internals() method.

"""

skip = self._memoized_keys

c = self.__class__.__new__(self.__class__)

c.__dict__ = {k: v for k, v in self.__dict__.items() if k not in skip}

# this is a marker that helps to "equate" clauses to each other

# when a Select returns its list of FROM clauses. the cloning

# process leaves around a lot of remnants of the previous clause

# typically in the form of column expressions still attached to the

# old table.

c._is_clone_of = self

return c

def _with_binary_element_type(self, type_):

"""in the context of binary expression, convert the type of this

object to the one given.

applies only to :class:`_expression.ColumnElement` classes.

"""

return self

@property

def _constructor(self):

"""return the 'constructor' for this ClauseElement.

This is for the purposes for creating a new object of

this type. Usually, its just the element's __class__.

However, the "Annotated" version of the object overrides

to return the class of its proxied element.

"""

return self.__class__

@HasMemoized.memoized_attribute

def _cloned_set(self):

"""Return the set consisting all cloned ancestors of this

ClauseElement.

Includes this ClauseElement. This accessor tends to be used for

FromClause objects to identify 'equivalent' FROM clauses, regardless

of transformative operations.

"""

s = util.column_set()

f = self

# note this creates a cycle, asserted in test_memusage. however,

# turning this into a plain @property adds tends of thousands of method

# calls to Core / ORM performance tests, so the small overhead

# introduced by the relatively small amount of short term cycles

# produced here is preferable

while f is not None:

s.add(f)

f = f._is_clone_of

return s

def __getstate__(self):

d = self.__dict__.copy()

d.pop("_is_clone_of", None)

d.pop("_generate_cache_key", None)

return d

def _execute_on_connection(

self, connection, multiparams, params, execution_options

):

if self.supports_execution:

return connection._execute_clauseelement(

self, multiparams, params, execution_options

)

else:

raise exc.ObjectNotExecutableError(self)

def unique_params(self, *optionaldict, **kwargs):

"""Return a copy with :func:`bindparam()` elements replaced.

Same functionality as ``params()``, except adds `unique=True`

to affected bind parameters so that multiple statements can be

used.

"""

return self._replace_params(True, optionaldict, kwargs)

def params(self, *optionaldict, **kwargs):

"""Return a copy with :func:`bindparam()` elements replaced.

Returns a copy of this ClauseElement with :func:`bindparam()`

elements replaced with values taken from the given dictionary::

>>> clause = column('x') + bindparam('foo')

>>> print(clause.compile().params)

{'foo':None}

>>> print(clause.params({'foo':7}).compile().params)

{'foo':7}

"""

return self._replace_params(False, optionaldict, kwargs)

def _replace_params(self, unique, optionaldict, kwargs):

if len(optionaldict) == 1:

kwargs.update(optionaldict[0])

elif len(optionaldict) > 1:

raise exc.ArgumentError(

"params() takes zero or one positional dictionary argument"

)

def visit_bindparam(bind):

if bind.key in kwargs:

bind.value = kwargs[bind.key]

bind.required = False

if unique:

bind._convert_to_unique()

return cloned_traverse(self, {}, {"bindparam": visit_bindparam})

def compare(self, other, **kw):

r"""Compare this ClauseElement to the given ClauseElement.

Subclasses should override the default behavior, which is a

straight identity comparison.

\**kw are arguments consumed by subclass compare() methods and

may be used to modify the criteria for comparison.

(see :class:`_expression.ColumnElement`)

"""

return traversals.compare(self, other, **kw)

def _copy_internals(self, omit_attrs=(), **kw):

"""Reassign internal elements to be clones of themselves.

Called during a copy-and-traverse operation on newly

shallow-copied elements to create a deep copy.

The given clone function should be used, which may be applying

additional transformations to the element (i.e. replacement

traversal, cloned traversal, annotations).

"""

try:

traverse_internals = self._traverse_internals

except AttributeError:

return

for attrname, obj, meth in _copy_internals.run_generated_dispatch(

self, traverse_internals, "_generated_copy_internals_traversal"

):

if attrname in omit_attrs:

continue

if obj is not None:

result = meth(self, attrname, obj, **kw)

if result is not None:

setattr(self, attrname, result)

def get_children(self, omit_attrs=(), **kw):

r"""Return immediate child :class:`.Traversible` elements of this

:class:`.Traversible`.

This is used for visit traversal.

\**kw may contain flags that change the collection that is

returned, for example to return a subset of items in order to

cut down on larger traversals, or to return child items from a

different context (such as schema-level collections instead of

clause-level).

"""

try:

traverse_internals = self._traverse_internals

except AttributeError:

return []

return itertools.chain.from_iterable(

meth(obj, **kw)

for attrname, obj, meth in _get_children.run_generated_dispatch(

self, traverse_internals, "_generated_get_children_traversal"

)

if attrname not in omit_attrs and obj is not None

)

def self_group(self, against=None):

# type: (Optional[Any]) -> ClauseElement

"""Apply a 'grouping' to this :class:`_expression.ClauseElement`.

This method is overridden by subclasses to return a "grouping"

construct, i.e. parenthesis. In particular it's used by "binary"

expressions to provide a grouping around themselves when placed into a

larger expression, as well as by :func:`_expression.select`

constructs when placed into the FROM clause of another

:func:`_expression.select`. (Note that subqueries should be

normally created using the :meth:`_expression.Select.alias` method,

as many

platforms require nested SELECT statements to be named).

As expressions are composed together, the application of

:meth:`self_group` is automatic - end-user code should never

need to use this method directly. Note that SQLAlchemy's

clause constructs take operator precedence into account -

so parenthesis might not be needed, for example, in

an expression like ``x OR (y AND z)`` - AND takes precedence

over OR.

The base :meth:`self_group` method of

:class:`_expression.ClauseElement`

just returns self.

"""

return self

def _ungroup(self):

"""Return this :class:`_expression.ClauseElement` """

"""without any groupings."""

return self

@util.preload_module("sqlalchemy.engine.default")

def compile(self, bind=None, dialect=None, **kw):

"""Compile this SQL expression.

The return value is a :class:`~.Compiled` object.

Calling ``str()`` or ``unicode()`` on the returned value will yield a

string representation of the result. The

:class:`~.Compiled` object also can return a

dictionary of bind parameter names and values

using the ``params`` accessor.

:param bind: An ``Engine`` or ``Connection`` from which a

``Compiled`` will be acquired. This argument takes precedence over

this :class:`_expression.ClauseElement`'s bound engine, if any.

:param column_keys: Used for INSERT and UPDATE statements, a list of

column names which should be present in the VALUES clause of the

compiled statement. If ``None``, all columns from the target table

object are rendered.

:param dialect: A ``Dialect`` instance from which a ``Compiled``

will be acquired. This argument takes precedence over the `bind`

argument as well as this :class:`_expression.ClauseElement`

's bound engine,

if any.

:param inline: Used for INSERT statements, for a dialect which does

not support inline retrieval of newly generated primary key

columns, will force the expression used to create the new primary

key value to be rendered inline within the INSERT statement's

VALUES clause. This typically refers to Sequence execution but may

also refer to any server-side default generation function

associated with a primary key `Column`.

:param compile_kwargs: optional dictionary of additional parameters

that will be passed through to the compiler within all "visit"

methods. This allows any custom flag to be passed through to

a custom compilation construct, for example. It is also used

for the case of passing the ``literal_binds`` flag through::

from sqlalchemy.sql import table, column, select

t = table('t', column('x'))

s = select([t]).where(t.c.x == 5)

print(s.compile(compile_kwargs={"literal_binds": True}))

.. versionadded:: 0.9.0

.. seealso::

:ref:`faq_sql_expression_string`

"""

default = util.preloaded.engine_default

if not dialect:

if bind:

dialect = bind.dialect

elif self.bind:

dialect = self.bind.dialect

bind = self.bind

else:

dialect = default.StrCompileDialect()

return self._compiler(dialect, bind=bind, **kw)

def _compiler(self, dialect, **kw):

"""Return a compiler appropriate for this ClauseElement, given a

Dialect."""

return dialect.statement_compiler(dialect, self, **kw)

def __str__(self):

if util.py3k:

return str(self.compile())

else:

return unicode(self.compile()).encode( # noqa

"ascii", "backslashreplace"

) # noqa

def __invert__(self):

# undocumented element currently used by the ORM for

# relationship.contains()

if hasattr(self, "negation_clause"):

return self.negation_clause

else:

return self._negate()

def _negate(self):

return UnaryExpression(

self.self_group(against=operators.inv), operator=operators.inv

)

def __bool__(self):

raise TypeError("Boolean value of this clause is not defined")

__nonzero__ = __bool__

def __repr__(self):

friendly = self.description

if friendly is None:

return object.__repr__(self)

else:

return "<%s.%s at 0x%x; %s>" % (

self.__module__,

self.__class__.__name__,

id(self),

friendly,

)

class ColumnElement(

roles.ColumnArgumentOrKeyRole,

roles.StatementOptionRole,

roles.WhereHavingRole,

roles.BinaryElementRole,

roles.OrderByRole,

roles.ColumnsClauseRole,

roles.LimitOffsetRole,

roles.DMLColumnRole,

roles.DDLConstraintColumnRole,

roles.DDLExpressionRole,

operators.ColumnOperators,

ClauseElement,

):

"""Represent a column-oriented SQL expression suitable for usage in the

"columns" clause, WHERE clause etc. of a statement.

While the most familiar kind of :class:`_expression.ColumnElement` is the

:class:`_schema.Column` object, :class:`_expression.ColumnElement`

serves as the basis

for any unit that may be present in a SQL expression, including

the expressions themselves, SQL functions, bound parameters,

literal expressions, keywords such as ``NULL``, etc.

:class:`_expression.ColumnElement`

is the ultimate base class for all such elements.

A wide variety of SQLAlchemy Core functions work at the SQL expression

level, and are intended to accept instances of

:class:`_expression.ColumnElement` as

arguments. These functions will typically document that they accept a

"SQL expression" as an argument. What this means in terms of SQLAlchemy

usually refers to an input which is either already in the form of a

:class:`_expression.ColumnElement` object,

or a value which can be **coerced** into

one. The coercion rules followed by most, but not all, SQLAlchemy Core

functions with regards to SQL expressions are as follows:

* a literal Python value, such as a string, integer or floating

point value, boolean, datetime, ``Decimal`` object, or virtually

any other Python object, will be coerced into a "literal bound

value". This generally means that a :func:`.bindparam` will be

produced featuring the given value embedded into the construct; the

resulting :class:`.BindParameter` object is an instance of

:class:`_expression.ColumnElement`.

The Python value will ultimately be sent

to the DBAPI at execution time as a parameterized argument to the

``execute()`` or ``executemany()`` methods, after SQLAlchemy

type-specific converters (e.g. those provided by any associated

:class:`.TypeEngine` objects) are applied to the value.

* any special object value, typically ORM-level constructs, which

feature an accessor called ``__clause_element__()``. The Core

expression system looks for this method when an object of otherwise

unknown type is passed to a function that is looking to coerce the

argument into a :class:`_expression.ColumnElement` and sometimes a

:class:`_expression.SelectBase` expression.

It is used within the ORM to

convert from ORM-specific objects like mapped classes and

mapped attributes into Core expression objects.

* The Python ``None`` value is typically interpreted as ``NULL``,

which in SQLAlchemy Core produces an instance of :func:`.null`.

A :class:`_expression.ColumnElement` provides the ability to generate new

:class:`_expression.ColumnElement`

objects using Python expressions. This means that Python operators

such as ``==``, ``!=`` and ``<`` are overloaded to mimic SQL operations,

and allow the instantiation of further :class:`_expression.ColumnElement`

instances

which are composed from other, more fundamental

:class:`_expression.ColumnElement`

objects. For example, two :class:`.ColumnClause` objects can be added

together with the addition operator ``+`` to produce

a :class:`.BinaryExpression`.

Both :class:`.ColumnClause` and :class:`.BinaryExpression` are subclasses

of :class:`_expression.ColumnElement`::

>>> from sqlalchemy.sql import column

>>> column('a') + column('b')

<sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>

>>> print(column('a') + column('b'))

a + b

.. seealso::

:class:`_schema.Column`

:func:`_expression.column`

"""

__visit_name__ = "column_element"

primary_key = False

foreign_keys = []

_proxies = ()

_label = None

"""The named label that can be used to target

this column in a result set.

This label is almost always the label used when

rendering <expr> AS <label> in a SELECT statement. It also

refers to a name that this column expression can be located from

in a result set.

For a regular Column bound to a Table, this is typically the label

<tablename>_<columnname>. For other constructs, different rules

may apply, such as anonymized labels and others.

"""

key = None

"""the 'key' that in some circumstances refers to this object in a

Python namespace.

This typically refers to the "key" of the column as present in the

``.c`` collection of a selectable, e.g. sometable.c["somekey"] would

return a Column with a .key of "somekey".

"""

_key_label = None

"""A label-based version of 'key' that in some circumstances refers

to this object in a Python namespace.

_key_label comes into play when a select() statement is constructed with

apply_labels(); in this case, all Column objects in the ``.c`` collection

are rendered as <tablename>_<columnname> in SQL; this is essentially the

value of ._label. But to locate those columns in the ``.c`` collection,

the name is along the lines of <tablename>_<key>; that's the typical

value of .key_label.

"""

_render_label_in_columns_clause = True

"""A flag used by select._columns_plus_names that helps to determine

we are actually going to render in terms of "SELECT <col> AS <label>".

This flag can be returned as False for some Column objects that want

to be rendered as simple "SELECT <col>"; typically columns that don't have

any parent table and are named the same as what the label would be

in any case.

"""

_resolve_label = None

"""The name that should be used to identify this ColumnElement in a

select() object when "label resolution" logic is used; this refers

to using a string name in an expression like order_by() or group_by()

that wishes to target a labeled expression in the columns clause.

The name is distinct from that of .name or ._label to account for the case

where anonymizing logic may be used to change the name that's actually

rendered at compile time; this attribute should hold onto the original

name that was user-assigned when producing a .label() construct.

"""

_allow_label_resolve = True

"""A flag that can be flipped to prevent a column from being resolvable

by string label name."""

_is_implicitly_boolean = False

_alt_names = ()

def self_group(self, against=None):

# type: (Optional[Any]) -> ClauseElement

if (

against in (operators.and_, operators.or_, operators._asbool)

and self.type._type_affinity is type_api.BOOLEANTYPE._type_affinity

):

return AsBoolean(self, operators.istrue, operators.isfalse)

elif against in (operators.any_op, operators.all_op):

return Grouping(self)

else:

return self

def _negate(self):

if self.type._type_affinity is type_api.BOOLEANTYPE._type_affinity:

return AsBoolean(self, operators.isfalse, operators.istrue)

else:

return super(ColumnElement, self)._negate()

@util.memoized_property

def type(self):

return type_api.NULLTYPE

@HasMemoized.memoized_attribute

def comparator(self):

try:

comparator_factory = self.type.comparator_factory

except AttributeError as err:

util.raise_(

TypeError(

"Object %r associated with '.type' attribute "

"is not a TypeEngine class or object" % self.type

),

replace_context=err,

)

else:

return comparator_factory(self)

def __getattr__(self, key):

try:

return getattr(self.comparator, key)

except AttributeError as err:

util.raise_(

AttributeError(

"Neither %r object nor %r object has an attribute %r"

% (

type(self).__name__,

type(self.comparator).__name__,

key,

)

),

replace_context=err,

)

def operate(self, op, *other, **kwargs):

return op(self.comparator, *other, **kwargs)

def reverse_operate(self, op, other, **kwargs):

return op(other, self.comparator, **kwargs)

def _bind_param(self, operator, obj, type_=None, expanding=False):

return BindParameter(

None,

obj,

_compared_to_operator=operator,

type_=type_,

_compared_to_type=self.type,

unique=True,

expanding=expanding,

)

@property

def expression(self):

"""Return a column expression.

Part of the inspection interface; returns self.

"""

return self

@property

def _select_iterable(self):

return (self,)

@util.memoized_property

def base_columns(self):

return util.column_set(c for c in self.proxy_set if not c._proxies)

@util.memoized_property

def proxy_set(self):

s = util.column_set([self])

for c in self._proxies:

s.update(c.proxy_set)

return s

def _uncached_proxy_set(self):

"""An 'uncached' version of proxy set.

This is so that we can read annotations from the list of columns

without breaking the caching of the above proxy_set.

"""

s = util.column_set([self])

for c in self._proxies:

s.update(c._uncached_proxy_set())

return s

def shares_lineage(self, othercolumn):

"""Return True if the given :class:`_expression.ColumnElement`

has a common ancestor to this :class:`_expression.ColumnElement`."""

return bool(self.proxy_set.intersection(othercolumn.proxy_set))

def _compare_name_for_result(self, other):

"""Return True if the given column element compares to this one

when targeting within a result row."""

return (

hasattr(other, "name")

and hasattr(self, "name")

and other.name == self.name

)

@util.memoized_property

def _proxy_key(self):

if self.key:

return self.key

else:

try:

return str(self)

except exc.UnsupportedCompilationError:

return self.anon_label

def _make_proxy(

self, selectable, name=None, name_is_truncatable=False, **kw

):

"""Create a new :class:`_expression.ColumnElement` representing this

:class:`_expression.ColumnElement`

as it appears in the select list of a

descending selectable.

"""

if name is None:

name = self.anon_label

key = self._proxy_key

else:

key = name

co = ColumnClause(

coercions.expect(roles.TruncatedLabelRole, name)

if name_is_truncatable

else name,

type_=getattr(self, "type", None),

_selectable=selectable,

)

co._propagate_attrs = selectable._propagate_attrs

co._proxies = [self]

if selectable._is_clone_of is not None:

co._is_clone_of = selectable._is_clone_of.columns.get(key)

return key, co

def cast(self, type_):

"""Produce a type cast, i.e. ``CAST(<expression> AS <type>)``.

This is a shortcut to the :func:`_expression.cast` function.

.. seealso::

:ref:`coretutorial_casts`

:func:`_expression.cast`

:func:`_expression.type_coerce`

.. versionadded:: 1.0.7

"""

return Cast(self, type_)

def label(self, name):

"""Produce a column label, i.e. ``<columnname> AS <name>``.

This is a shortcut to the :func:`_expression.label` function.

if 'name' is None, an anonymous label name will be generated.

"""

return Label(name, self, self.type)

def _anon_label(self, seed):

while self._is_clone_of is not None:

self = self._is_clone_of

# as of 1.4 anonymous label for ColumnElement uses hash(), not id(),

# as the identifier, because a column and its annotated version are

# the same thing in a SQL statement

if isinstance(seed, _anonymous_label):

return _anonymous_label("%s%%(%d %s)s" % (seed, hash(self), ""))

return _anonymous_label("%%(%d %s)s" % (hash(self), seed or "anon"))

@util.memoized_property

def anon_label(self):

"""provides a constant 'anonymous label' for this ColumnElement.

This is a label() expression which will be named at compile time.

The same label() is returned each time anon_label is called so

that expressions can reference anon_label multiple times, producing

the same label name at compile time.

the compiler uses this function automatically at compile time

for expressions that are known to be 'unnamed' like binary

expressions and function calls.

"""

return self._anon_label(getattr(self, "name", None))

@util.memoized_property

def _dedupe_anon_label(self):

label = getattr(self, "name", None) or "anon"

return self._anon_label(label + "_")

@util.memoized_property

def _label_anon_label(self):

return self._anon_label(getattr(self, "_label", None))

@util.memoized_property

def _dedupe_label_anon_label(self):

label = getattr(self, "_label", None) or "anon"

return self._anon_label(label + "_")

class WrapsColumnExpression(object):

"""Mixin that defines a :class:`_expression.ColumnElement`

as a wrapper with special

labeling behavior for an expression that already has a name.

.. versionadded:: 1.4

.. seealso::

:ref:`change_4449`

"""

@property

def wrapped_column_expression(self):

raise NotImplementedError()

@property

def _label(self):

wce = self.wrapped_column_expression

if hasattr(wce, "_label"):

return wce._label

else:

return None

@property

def anon_label(self):

wce = self.wrapped_column_expression

if hasattr(wce, "name"):

return wce.name

elif hasattr(wce, "anon_label"):

return wce.anon_label

else:

return super(WrapsColumnExpression, self).anon_label