def _is_literal(element):
return not isinstance(element, Visitable) and not hasattr(element, '__clause_element__')
-def _from_objects(*elements, **kwargs):
- return itertools.chain(*[element._get_from_objects(**kwargs) for element in elements])
+def _from_objects(*elements):
+ return itertools.chain(*[element._from_objects for element in elements])
def _labeled(element):
if not hasattr(element, 'name'):
_annotations = {}
supports_execution = False
+ _from_objects = []
def _clone(self):
"""Create a shallow copy of this ClauseElement.
d.pop('_is_clone_of', None)
return d
- def _get_from_objects(self, **modifiers):
- """Return objects represented in this ``ClauseElement`` that
- should be added to the ``FROM`` list of a query, when this
- ``ClauseElement`` is placed in the column clause of a
- ``Select`` statement.
-
- """
- raise NotImplementedError(repr(self))
-
def _annotate(self, values):
"""return a copy of this ClauseElement with the given annotations dictionary."""
return other.__clause_element__()
elif not isinstance(other, ClauseElement):
return self._bind_param(other)
+ elif isinstance(other, _SelectBaseMixin):
+ return other.as_scalar()
else:
return other
quote = None
schema = None
- def _get_from_objects(self, **modifiers):
- return []
-
def count(self, whereclause=None, **params):
"""return a SELECT COUNT generated against this ``FromClause``."""
self.unique = True
self.key = _generated_label("%%(%d %s)s" % (id(self), self._orig_key or 'param'))
- def _get_from_objects(self, **modifiers):
- return []
-
def bind_processor(self, dialect):
return self.type.dialect_impl(dialect).bind_processor(dialect)
def __init__(self, type):
self.type = type
- def _get_from_objects(self, **modifiers):
- return []
class _TextClause(ClauseElement):
"""Represent a literal SQL text fragment.
def get_children(self, **kwargs):
return self.bindparams.values()
- def _get_from_objects(self, **modifiers):
- return []
class _Null(ColumnElement):
"""Represent the NULL keyword in a SQL statement.
"""
def __init__(self):
- ColumnElement.__init__(self)
self.type = sqltypes.NULLTYPE
- def _get_from_objects(self, **modifiers):
- return []
class ClauseList(ClauseElement):
"""Describe a list of clauses, separated by an operator.
def get_children(self, **kwargs):
return self.clauses
- def _get_from_objects(self, **modifiers):
- return list(itertools.chain(*[c._get_from_objects(**modifiers) for c in self.clauses]))
+ @property
+ def _from_objects(self):
+ return list(itertools.chain(*[c._from_objects for c in self.clauses]))
def self_group(self, against=None):
if self.group and self.operator != against and operators.is_precedent(self.operator, against):
__visit_name__ = 'calculatedclause'
def __init__(self, name, *clauses, **kwargs):
- ColumnElement.__init__(self)
self.name = name
self.type = sqltypes.to_instance(kwargs.get('type_', None))
self._bind = kwargs.get('bind', None)
def get_children(self, **kwargs):
return self.clause_expr,
- def _get_from_objects(self, **modifiers):
- return self.clauses._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.clauses._from_objects
def _bind_param(self, obj):
return _BindParamClause(self.name, obj, type_=self.type, unique=True)
class _Cast(ColumnElement):
def __init__(self, clause, totype, **kwargs):
- ColumnElement.__init__(self)
self.type = sqltypes.to_instance(totype)
self.clause = _literal_as_binds(clause, None)
self.typeclause = _TypeClause(self.type)
def get_children(self, **kwargs):
return self.clause, self.typeclause
- def _get_from_objects(self, **modifiers):
- return self.clause._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.clause._from_objects
class _UnaryExpression(ColumnElement):
def __init__(self, element, operator=None, modifier=None, type_=None, negate=None):
- ColumnElement.__init__(self)
self.operator = operator
self.modifier = modifier
self.type = sqltypes.to_instance(type_)
self.negate = negate
- def _get_from_objects(self, **modifiers):
- return self.element._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.element._from_objects
def _copy_internals(self, clone=_clone):
self.element = clone(self.element)
"""Represent an expression that is ``LEFT <operator> RIGHT``."""
def __init__(self, left, right, operator, type_=None, negate=None, modifiers=None):
- ColumnElement.__init__(self)
self.left = _literal_as_text(left).self_group(against=operator)
self.right = _literal_as_text(right).self_group(against=operator)
self.operator = operator
else:
self.modifiers = modifiers
- def _get_from_objects(self, **modifiers):
- return self.left._get_from_objects(**modifiers) + self.right._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.left._from_objects + self.right._from_objects
def _copy_internals(self, clone=_clone):
self.left = clone(self.left)
class _Exists(_UnaryExpression):
__visit_name__ = _UnaryExpression.__visit_name__
-
+ _from_objects = []
+
def __init__(self, *args, **kwargs):
if args and isinstance(args[0], _SelectBaseMixin):
s = args[0]
e.element = self.element.correlate(fromclause).self_group()
return e
- def _get_from_objects(self, **modifiers):
- return []
-
def select_from(self, clause):
"""return a new exists() construct with the given expression set as its FROM clause."""
def _hide_froms(self):
return itertools.chain(*[_from_objects(x.left, x.right) for x in self._cloned_set])
- def _get_from_objects(self, **modifiers):
+ @property
+ def _from_objects(self):
return [self] + \
- self.onclause._get_from_objects(**modifiers) + \
- self.left._get_from_objects(**modifiers) + \
- self.right._get_from_objects(**modifiers)
+ self.onclause._from_objects + \
+ self.left._from_objects + \
+ self.right._from_objects
class Alias(FromClause):
"""Represents an table or selectable alias (AS).
if aliased_selectables:
yield self.element
- def _get_from_objects(self, **modifiers):
+ @property
+ def _from_objects(self):
return [self]
@property
"""Represent a grouping within a column expression"""
def __init__(self, element):
- ColumnElement.__init__(self)
self.element = element
self.type = getattr(element, 'type', None)
def get_children(self, **kwargs):
return self.element,
- def _get_from_objects(self, **modifiers):
- return self.element._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.element._from_objects
def __getattr__(self, attr):
return getattr(self.element, attr)
def _copy_internals(self, clone=_clone):
self.element = clone(self.element)
- def _get_from_objects(self, **modifiers):
- return self.element._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.element._from_objects
def __getattr__(self, attr):
return getattr(self.element, attr)
def _copy_internals(self, clone=_clone):
self.element = clone(self.element)
- def _get_from_objects(self, **modifiers):
- return self.element._get_from_objects(**modifiers)
+ @property
+ def _from_objects(self):
+ return self.element._from_objects
def _make_proxy(self, selectable, name = None):
if isinstance(self.element, (Selectable, ColumnElement)):
"""
def __init__(self, text, selectable=None, type_=None, is_literal=False):
- ColumnElement.__init__(self)
self.key = self.name = text
self.table = selectable
self.type = sqltypes.to_instance(type_)
else:
return super(_ColumnClause, self).label(name)
- def _get_from_objects(self, **modifiers):
+ @property
+ def _from_objects(self):
if self.table:
return [self.table]
else:
def delete(self, whereclause=None, **kwargs):
return delete(self, whereclause, **kwargs)
- def _get_from_objects(self, **modifiers):
+ @property
+ def _from_objects(self):
return [self]
@util.decorator
clauses = list(self._group_by_clause) + list(clauses)
self._group_by_clause = ClauseList(*clauses)
- def _get_from_objects(self, is_where=False, **modifiers):
- if is_where:
- return []
- else:
- return [self]
+ @property
+ def _from_objects(self):
+ return [self]
+
class _ScalarSelect(_Grouping):
__visit_name__ = 'grouping'
-
+ _from_objects = []
+
def __init__(self, element):
self.element = element
cols = list(element.c)
def _make_proxy(self, selectable, name):
return list(self.inner_columns)[0]._make_proxy(selectable, name)
- def _get_from_objects(self, **modifiers):
- return []
-
class CompoundSelect(_SelectBaseMixin, FromClause):
def __init__(self, keyword, *selects, **kwargs):
self._should_correlate = kwargs.pop('correlate', False)
if whereclause:
self._whereclause = _literal_as_text(whereclause)
- self._froms.update(_from_objects(self._whereclause, is_where=True))
+ self._froms.update(_from_objects(self._whereclause))
else:
self._whereclause = None
"""
whereclause = _literal_as_text(whereclause)
- self._froms = self._froms.union(_from_objects(whereclause, is_where=True))
+ self._froms = self._froms.union(_from_objects(whereclause))
if self._whereclause is not None:
self._whereclause = and_(self._whereclause, whereclause)
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
