AlkantarClanX12
Your IP : 3.12.161.151
# orm/context.py
# Copyright (C) 2005-2024 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: https://www.opensource.org/licenses/mit-license.php
# mypy: ignore-errors
from __future__ import annotations
import itertools
from typing import Any
from typing import cast
from typing import Dict
from typing import Iterable
from typing import List
from typing import Optional
from typing import Set
from typing import Tuple
from typing import Type
from typing import TYPE_CHECKING
from typing import TypeVar
from typing import Union
from . import attributes
from . import interfaces
from . import loading
from .base import _is_aliased_class
from .interfaces import ORMColumnDescription
from .interfaces import ORMColumnsClauseRole
from .path_registry import PathRegistry
from .util import _entity_corresponds_to
from .util import _ORMJoin
from .util import _TraceAdaptRole
from .util import AliasedClass
from .util import Bundle
from .util import ORMAdapter
from .util import ORMStatementAdapter
from .. import exc as sa_exc
from .. import future
from .. import inspect
from .. import sql
from .. import util
from ..sql import coercions
from ..sql import expression
from ..sql import roles
from ..sql import util as sql_util
from ..sql import visitors
from ..sql._typing import _TP
from ..sql._typing import is_dml
from ..sql._typing import is_insert_update
from ..sql._typing import is_select_base
from ..sql.base import _select_iterables
from ..sql.base import CacheableOptions
from ..sql.base import CompileState
from ..sql.base import Executable
from ..sql.base import Generative
from ..sql.base import Options
from ..sql.dml import UpdateBase
from ..sql.elements import GroupedElement
from ..sql.elements import TextClause
from ..sql.selectable import CompoundSelectState
from ..sql.selectable import LABEL_STYLE_DISAMBIGUATE_ONLY
from ..sql.selectable import LABEL_STYLE_NONE
from ..sql.selectable import LABEL_STYLE_TABLENAME_PLUS_COL
from ..sql.selectable import Select
from ..sql.selectable import SelectLabelStyle
from ..sql.selectable import SelectState
from ..sql.selectable import TypedReturnsRows
from ..sql.visitors import InternalTraversal
if TYPE_CHECKING:
from ._typing import _InternalEntityType
from ._typing import OrmExecuteOptionsParameter
from .loading import PostLoad
from .mapper import Mapper
from .query import Query
from .session import _BindArguments
from .session import Session
from ..engine import Result
from ..engine.interfaces import _CoreSingleExecuteParams
from ..sql._typing import _ColumnsClauseArgument
from ..sql.compiler import SQLCompiler
from ..sql.dml import _DMLTableElement
from ..sql.elements import ColumnElement
from ..sql.selectable import _JoinTargetElement
from ..sql.selectable import _LabelConventionCallable
from ..sql.selectable import _SetupJoinsElement
from ..sql.selectable import ExecutableReturnsRows
from ..sql.selectable import SelectBase
from ..sql.type_api import TypeEngine
_T = TypeVar("_T", bound=Any)
_path_registry = PathRegistry.root
_EMPTY_DICT = util.immutabledict()
LABEL_STYLE_LEGACY_ORM = SelectLabelStyle.LABEL_STYLE_LEGACY_ORM
class QueryContext:
__slots__ = (
"top_level_context",
"compile_state",
"query",
"params",
"load_options",
"bind_arguments",
"execution_options",
"session",
"autoflush",
"populate_existing",
"invoke_all_eagers",
"version_check",
"refresh_state",
"create_eager_joins",
"propagated_loader_options",
"attributes",
"runid",
"partials",
"post_load_paths",
"identity_token",
"yield_per",
"loaders_require_buffering",
"loaders_require_uniquing",
)
runid: int
post_load_paths: Dict[PathRegistry, PostLoad]
compile_state: ORMCompileState
class default_load_options(Options):
_only_return_tuples = False
_populate_existing = False
_version_check = False
_invoke_all_eagers = True
_autoflush = True
_identity_token = None
_yield_per = None
_refresh_state = None
_lazy_loaded_from = None
_legacy_uniquing = False
_sa_top_level_orm_context = None
_is_user_refresh = False
def __init__(
self,
compile_state: CompileState,
statement: Union[Select[Any], FromStatement[Any]],
params: _CoreSingleExecuteParams,
session: Session,
load_options: Union[
Type[QueryContext.default_load_options],
QueryContext.default_load_options,
],
execution_options: Optional[OrmExecuteOptionsParameter] = None,
bind_arguments: Optional[_BindArguments] = None,
):
self.load_options = load_options
self.execution_options = execution_options or _EMPTY_DICT
self.bind_arguments = bind_arguments or _EMPTY_DICT
self.compile_state = compile_state
self.query = statement
self.session = session
self.loaders_require_buffering = False
self.loaders_require_uniquing = False
self.params = params
self.top_level_context = load_options._sa_top_level_orm_context
cached_options = compile_state.select_statement._with_options
uncached_options = statement._with_options
# see issue #7447 , #8399 for some background
# propagated loader options will be present on loaded InstanceState
# objects under state.load_options and are typically used by
# LazyLoader to apply options to the SELECT statement it emits.
# For compile state options (i.e. loader strategy options), these
# need to line up with the ".load_path" attribute which in
# loader.py is pulled from context.compile_state.current_path.
# so, this means these options have to be the ones from the
# *cached* statement that's travelling with compile_state, not the
# *current* statement which won't match up for an ad-hoc
# AliasedClass
self.propagated_loader_options = tuple(
opt._adapt_cached_option_to_uncached_option(self, uncached_opt)
for opt, uncached_opt in zip(cached_options, uncached_options)
if opt.propagate_to_loaders
)
self.attributes = dict(compile_state.attributes)
self.autoflush = load_options._autoflush
self.populate_existing = load_options._populate_existing
self.invoke_all_eagers = load_options._invoke_all_eagers
self.version_check = load_options._version_check
self.refresh_state = load_options._refresh_state
self.yield_per = load_options._yield_per
self.identity_token = load_options._identity_token
def _get_top_level_context(self) -> QueryContext:
return self.top_level_context or self
_orm_load_exec_options = util.immutabledict(
{"_result_disable_adapt_to_context": True}
)
class AbstractORMCompileState(CompileState):
is_dml_returning = False
def _init_global_attributes(
self, statement, compiler, *, toplevel, process_criteria_for_toplevel
):
self.attributes = {}
if compiler is None:
# this is the legacy / testing only ORM _compile_state() use case.
# there is no need to apply criteria options for this.
self.global_attributes = ga = {}
assert toplevel
return
else:
self.global_attributes = ga = compiler._global_attributes
if toplevel:
ga["toplevel_orm"] = True
if process_criteria_for_toplevel:
for opt in statement._with_options:
if opt._is_criteria_option:
opt.process_compile_state(self)
return
elif ga.get("toplevel_orm", False):
return
stack_0 = compiler.stack[0]
try:
toplevel_stmt = stack_0["selectable"]
except KeyError:
pass
else:
for opt in toplevel_stmt._with_options:
if opt._is_compile_state and opt._is_criteria_option:
opt.process_compile_state(self)
ga["toplevel_orm"] = True
@classmethod
def create_for_statement(
cls,
statement: Union[Select, FromStatement],
compiler: Optional[SQLCompiler],
**kw: Any,
) -> AbstractORMCompileState:
"""Create a context for a statement given a :class:`.Compiler`.
This method is always invoked in the context of SQLCompiler.process().
For a Select object, this would be invoked from
SQLCompiler.visit_select(). For the special FromStatement object used
by Query to indicate "Query.from_statement()", this is called by
FromStatement._compiler_dispatch() that would be called by
SQLCompiler.process().
"""
return super().create_for_statement(statement, compiler, **kw)
@classmethod
def orm_pre_session_exec(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
is_pre_event,
):
raise NotImplementedError()
@classmethod
def orm_execute_statement(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
conn,
) -> Result:
result = conn.execute(
statement, params or {}, execution_options=execution_options
)
return cls.orm_setup_cursor_result(
session,
statement,
params,
execution_options,
bind_arguments,
result,
)
@classmethod
def orm_setup_cursor_result(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
result,
):
raise NotImplementedError()
class AutoflushOnlyORMCompileState(AbstractORMCompileState):
"""ORM compile state that is a passthrough, except for autoflush."""
@classmethod
def orm_pre_session_exec(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
is_pre_event,
):
# consume result-level load_options. These may have been set up
# in an ORMExecuteState hook
(
load_options,
execution_options,
) = QueryContext.default_load_options.from_execution_options(
"_sa_orm_load_options",
{
"autoflush",
},
execution_options,
statement._execution_options,
)
if not is_pre_event and load_options._autoflush:
session._autoflush()
return statement, execution_options
@classmethod
def orm_setup_cursor_result(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
result,
):
return result
class ORMCompileState(AbstractORMCompileState):
class default_compile_options(CacheableOptions):
_cache_key_traversal = [
("_use_legacy_query_style", InternalTraversal.dp_boolean),
("_for_statement", InternalTraversal.dp_boolean),
("_bake_ok", InternalTraversal.dp_boolean),
("_current_path", InternalTraversal.dp_has_cache_key),
("_enable_single_crit", InternalTraversal.dp_boolean),
("_enable_eagerloads", InternalTraversal.dp_boolean),
("_only_load_props", InternalTraversal.dp_plain_obj),
("_set_base_alias", InternalTraversal.dp_boolean),
("_for_refresh_state", InternalTraversal.dp_boolean),
("_render_for_subquery", InternalTraversal.dp_boolean),
("_is_star", InternalTraversal.dp_boolean),
]
# set to True by default from Query._statement_20(), to indicate
# the rendered query should look like a legacy ORM query. right
# now this basically indicates we should use tablename_columnname
# style labels. Generally indicates the statement originated
# from a Query object.
_use_legacy_query_style = False
# set *only* when we are coming from the Query.statement
# accessor, or a Query-level equivalent such as
# query.subquery(). this supersedes "toplevel".
_for_statement = False
_bake_ok = True
_current_path = _path_registry
_enable_single_crit = True
_enable_eagerloads = True
_only_load_props = None
_set_base_alias = False
_for_refresh_state = False
_render_for_subquery = False
_is_star = False
attributes: Dict[Any, Any]
global_attributes: Dict[Any, Any]
statement: Union[Select[Any], FromStatement[Any]]
select_statement: Union[Select[Any], FromStatement[Any]]
_entities: List[_QueryEntity]
_polymorphic_adapters: Dict[_InternalEntityType, ORMAdapter]
compile_options: Union[
Type[default_compile_options], default_compile_options
]
_primary_entity: Optional[_QueryEntity]
use_legacy_query_style: bool
_label_convention: _LabelConventionCallable
primary_columns: List[ColumnElement[Any]]
secondary_columns: List[ColumnElement[Any]]
dedupe_columns: Set[ColumnElement[Any]]
create_eager_joins: List[
# TODO: this structure is set up by JoinedLoader
Tuple[Any, ...]
]
current_path: PathRegistry = _path_registry
_has_mapper_entities = False
def __init__(self, *arg, **kw):
raise NotImplementedError()
if TYPE_CHECKING:
@classmethod
def create_for_statement(
cls,
statement: Union[Select, FromStatement],
compiler: Optional[SQLCompiler],
**kw: Any,
) -> ORMCompileState: ...
def _append_dedupe_col_collection(self, obj, col_collection):
dedupe = self.dedupe_columns
if obj not in dedupe:
dedupe.add(obj)
col_collection.append(obj)
@classmethod
def _column_naming_convention(
cls, label_style: SelectLabelStyle, legacy: bool
) -> _LabelConventionCallable:
if legacy:
def name(col, col_name=None):
if col_name:
return col_name
else:
return getattr(col, "key")
return name
else:
return SelectState._column_naming_convention(label_style)
@classmethod
def get_column_descriptions(cls, statement):
return _column_descriptions(statement)
@classmethod
def orm_pre_session_exec(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
is_pre_event,
):
# consume result-level load_options. These may have been set up
# in an ORMExecuteState hook
(
load_options,
execution_options,
) = QueryContext.default_load_options.from_execution_options(
"_sa_orm_load_options",
{
"populate_existing",
"autoflush",
"yield_per",
"identity_token",
"sa_top_level_orm_context",
},
execution_options,
statement._execution_options,
)
# default execution options for ORM results:
# 1. _result_disable_adapt_to_context=True
# this will disable the ResultSetMetadata._adapt_to_context()
# step which we don't need, as we have result processors cached
# against the original SELECT statement before caching.
if "sa_top_level_orm_context" in execution_options:
ctx = execution_options["sa_top_level_orm_context"]
execution_options = ctx.query._execution_options.merge_with(
ctx.execution_options, execution_options
)
if not execution_options:
execution_options = _orm_load_exec_options
else:
execution_options = execution_options.union(_orm_load_exec_options)
# would have been placed here by legacy Query only
if load_options._yield_per:
execution_options = execution_options.union(
{"yield_per": load_options._yield_per}
)
if (
getattr(statement._compile_options, "_current_path", None)
and len(statement._compile_options._current_path) > 10
and execution_options.get("compiled_cache", True) is not None
):
execution_options: util.immutabledict[str, Any] = (
execution_options.union(
{
"compiled_cache": None,
"_cache_disable_reason": "excess depth for "
"ORM loader options",
}
)
)
bind_arguments["clause"] = statement
# new in 1.4 - the coercions system is leveraged to allow the
# "subject" mapper of a statement be propagated to the top
# as the statement is built. "subject" mapper is the generally
# standard object used as an identifier for multi-database schemes.
# we are here based on the fact that _propagate_attrs contains
# "compile_state_plugin": "orm". The "plugin_subject"
# needs to be present as well.
try:
plugin_subject = statement._propagate_attrs["plugin_subject"]
except KeyError:
assert False, "statement had 'orm' plugin but no plugin_subject"
else:
if plugin_subject:
bind_arguments["mapper"] = plugin_subject.mapper
if not is_pre_event and load_options._autoflush:
session._autoflush()
return statement, execution_options
@classmethod
def orm_setup_cursor_result(
cls,
session,
statement,
params,
execution_options,
bind_arguments,
result,
):
execution_context = result.context
compile_state = execution_context.compiled.compile_state
# cover edge case where ORM entities used in legacy select
# were passed to session.execute:
# session.execute(legacy_select([User.id, User.name]))
# see test_query->test_legacy_tuple_old_select
load_options = execution_options.get(
"_sa_orm_load_options", QueryContext.default_load_options
)
if compile_state.compile_options._is_star:
return result
querycontext = QueryContext(
compile_state,
statement,
params,
session,
load_options,
execution_options,
bind_arguments,
)
return loading.instances(result, querycontext)
@property
def _lead_mapper_entities(self):
"""return all _MapperEntity objects in the lead entities collection.
Does **not** include entities that have been replaced by
with_entities(), with_only_columns()
"""
return [
ent for ent in self._entities if isinstance(ent, _MapperEntity)
]
def _create_with_polymorphic_adapter(self, ext_info, selectable):
"""given MapperEntity or ORMColumnEntity, setup polymorphic loading
if called for by the Mapper.
As of #8168 in 2.0.0rc1, polymorphic adapters, which greatly increase
the complexity of the query creation process, are not used at all
except in the quasi-legacy cases of with_polymorphic referring to an
alias and/or subquery. This would apply to concrete polymorphic
loading, and joined inheritance where a subquery is
passed to with_polymorphic (which is completely unnecessary in modern
use).
"""
if (
not ext_info.is_aliased_class
and ext_info.mapper.persist_selectable
not in self._polymorphic_adapters
):
for mp in ext_info.mapper.iterate_to_root():
self._mapper_loads_polymorphically_with(
mp,
ORMAdapter(
_TraceAdaptRole.WITH_POLYMORPHIC_ADAPTER,
mp,
equivalents=mp._equivalent_columns,
selectable=selectable,
),
)
def _mapper_loads_polymorphically_with(self, mapper, adapter):
for m2 in mapper._with_polymorphic_mappers or [mapper]:
self._polymorphic_adapters[m2] = adapter
for m in m2.iterate_to_root():
self._polymorphic_adapters[m.local_table] = adapter
@classmethod
def _create_entities_collection(cls, query, legacy):
raise NotImplementedError(
"this method only works for ORMSelectCompileState"
)
class DMLReturningColFilter:
"""an adapter used for the DML RETURNING case.
Has a subset of the interface used by
:class:`.ORMAdapter` and is used for :class:`._QueryEntity`
instances to set up their columns as used in RETURNING for a
DML statement.
"""
__slots__ = ("mapper", "columns", "__weakref__")
def __init__(self, target_mapper, immediate_dml_mapper):
if (
immediate_dml_mapper is not None
and target_mapper.local_table
is not immediate_dml_mapper.local_table
):
# joined inh, or in theory other kinds of multi-table mappings
self.mapper = immediate_dml_mapper
else:
# single inh, normal mappings, etc.
self.mapper = target_mapper
self.columns = self.columns = util.WeakPopulateDict(
self.adapt_check_present # type: ignore
)
def __call__(self, col, as_filter):
for cc in sql_util._find_columns(col):
c2 = self.adapt_check_present(cc)
if c2 is not None:
return col
else:
return None
def adapt_check_present(self, col):
mapper = self.mapper
prop = mapper._columntoproperty.get(col, None)
if prop is None:
return None
return mapper.local_table.c.corresponding_column(col)
@sql.base.CompileState.plugin_for("orm", "orm_from_statement")
class ORMFromStatementCompileState(ORMCompileState):
_from_obj_alias = None
_has_mapper_entities = False
statement_container: FromStatement
requested_statement: Union[SelectBase, TextClause, UpdateBase]
dml_table: Optional[_DMLTableElement] = None
_has_orm_entities = False
multi_row_eager_loaders = False
eager_adding_joins = False
compound_eager_adapter = None
extra_criteria_entities = _EMPTY_DICT
eager_joins = _EMPTY_DICT
@classmethod
def create_for_statement(
cls,
statement_container: Union[Select, FromStatement],
compiler: Optional[SQLCompiler],
**kw: Any,
) -> ORMFromStatementCompileState:
assert isinstance(statement_container, FromStatement)
if compiler is not None and compiler.stack:
raise sa_exc.CompileError(
"The ORM FromStatement construct only supports being "
"invoked as the topmost statement, as it is only intended to "
"define how result rows should be returned."
)
self = cls.__new__(cls)
self._primary_entity = None
self.use_legacy_query_style = (
statement_container._compile_options._use_legacy_query_style
)
self.statement_container = self.select_statement = statement_container
self.requested_statement = statement = statement_container.element
if statement.is_dml:
self.dml_table = statement.table
self.is_dml_returning = True
self._entities = []
self._polymorphic_adapters = {}
self.compile_options = statement_container._compile_options
if (
self.use_legacy_query_style
and isinstance(statement, expression.SelectBase)
and not statement._is_textual
and not statement.is_dml
and statement._label_style is LABEL_STYLE_NONE
):
self.statement = statement.set_label_style(
LABEL_STYLE_TABLENAME_PLUS_COL
)
else:
self.statement = statement
self._label_convention = self._column_naming_convention(
(
statement._label_style
if not statement._is_textual and not statement.is_dml
else LABEL_STYLE_NONE
),
self.use_legacy_query_style,
)
_QueryEntity.to_compile_state(
self,
statement_container._raw_columns,
self._entities,
is_current_entities=True,
)
self.current_path = statement_container._compile_options._current_path
self._init_global_attributes(
statement_container,
compiler,
process_criteria_for_toplevel=False,
toplevel=True,
)
if statement_container._with_options:
for opt in statement_container._with_options:
if opt._is_compile_state:
opt.process_compile_state(self)
if statement_container._with_context_options:
for fn, key in statement_container._with_context_options:
fn(self)
self.primary_columns = []
self.secondary_columns = []
self.dedupe_columns = set()
self.create_eager_joins = []
self._fallback_from_clauses = []
self.order_by = None
if isinstance(self.statement, expression.TextClause):
# TextClause has no "column" objects at all. for this case,
# we generate columns from our _QueryEntity objects, then
# flip on all the "please match no matter what" parameters.
self.extra_criteria_entities = {}
for entity in self._entities:
entity.setup_compile_state(self)
compiler._ordered_columns = compiler._textual_ordered_columns = (
False
)
# enable looser result column matching. this is shown to be
# needed by test_query.py::TextTest
compiler._loose_column_name_matching = True
for c in self.primary_columns:
compiler.process(
c,
within_columns_clause=True,
add_to_result_map=compiler._add_to_result_map,
)
else:
# for everyone else, Select, Insert, Update, TextualSelect, they
# have column objects already. After much
# experimentation here, the best approach seems to be, use
# those columns completely, don't interfere with the compiler
# at all; just in ORM land, use an adapter to convert from
# our ORM columns to whatever columns are in the statement,
# before we look in the result row. Adapt on names
# to accept cases such as issue #9217, however also allow
# this to be overridden for cases such as #9273.
self._from_obj_alias = ORMStatementAdapter(
_TraceAdaptRole.ADAPT_FROM_STATEMENT,
self.statement,
adapt_on_names=statement_container._adapt_on_names,
)
return self
def _adapt_col_list(self, cols, current_adapter):
return cols
def _get_current_adapter(self):
return None
def setup_dml_returning_compile_state(self, dml_mapper):
"""used by BulkORMInsert (and Update / Delete?) to set up a handler
for RETURNING to return ORM objects and expressions
"""
target_mapper = self.statement._propagate_attrs.get(
"plugin_subject", None
)
adapter = DMLReturningColFilter(target_mapper, dml_mapper)
if self.compile_options._is_star and (len(self._entities) != 1):
raise sa_exc.CompileError(
"Can't generate ORM query that includes multiple expressions "
"at the same time as '*'; query for '*' alone if present"
)
for entity in self._entities:
entity.setup_dml_returning_compile_state(self, adapter)
class FromStatement(GroupedElement, Generative, TypedReturnsRows[_TP]):
"""Core construct that represents a load of ORM objects from various
:class:`.ReturnsRows` and other classes including:
:class:`.Select`, :class:`.TextClause`, :class:`.TextualSelect`,
:class:`.CompoundSelect`, :class`.Insert`, :class:`.Update`,
and in theory, :class:`.Delete`.
"""
__visit_name__ = "orm_from_statement"
_compile_options = ORMFromStatementCompileState.default_compile_options
_compile_state_factory = ORMFromStatementCompileState.create_for_statement
_for_update_arg = None
element: Union[ExecutableReturnsRows, TextClause]
_adapt_on_names: bool
_traverse_internals = [
("_raw_columns", InternalTraversal.dp_clauseelement_list),
("element", InternalTraversal.dp_clauseelement),
] + Executable._executable_traverse_internals
_cache_key_traversal = _traverse_internals + [
("_compile_options", InternalTraversal.dp_has_cache_key)
]
is_from_statement = True
def __init__(
self,
entities: Iterable[_ColumnsClauseArgument[Any]],
element: Union[ExecutableReturnsRows, TextClause],
_adapt_on_names: bool = True,
):
self._raw_columns = [
coercions.expect(
roles.ColumnsClauseRole,
ent,
apply_propagate_attrs=self,
post_inspect=True,
)
for ent in util.to_list(entities)
]
self.element = element
self.is_dml = element.is_dml
self.is_select = element.is_select
self.is_delete = element.is_delete
self.is_insert = element.is_insert
self.is_update = element.is_update
self._label_style = (
element._label_style if is_select_base(element) else None
)
self._adapt_on_names = _adapt_on_names
def _compiler_dispatch(self, compiler, **kw):
"""provide a fixed _compiler_dispatch method.
This is roughly similar to using the sqlalchemy.ext.compiler
``@compiles`` extension.
"""
compile_state = self._compile_state_factory(self, compiler, **kw)
toplevel = not compiler.stack
if toplevel:
compiler.compile_state = compile_state
return compiler.process(compile_state.statement, **kw)
@property
def column_descriptions(self):
"""Return a :term:`plugin-enabled` 'column descriptions' structure
referring to the columns which are SELECTed by this statement.
See the section :ref:`queryguide_inspection` for an overview
of this feature.
.. seealso::
:ref:`queryguide_inspection` - ORM background
"""
meth = cast(
ORMSelectCompileState, SelectState.get_plugin_class(self)
).get_column_descriptions
return meth(self)
def _ensure_disambiguated_names(self):
return self
def get_children(self, **kw):
yield from itertools.chain.from_iterable(
element._from_objects for element in self._raw_columns
)
yield from super().get_children(**kw)
@property
def _all_selected_columns(self):
return self.element._all_selected_columns
@property
def _return_defaults(self):
return self.element._return_defaults if is_dml(self.element) else None
@property
def _returning(self):
return self.element._returning if is_dml(self.element) else None
@property
def _inline(self):
return self.element._inline if is_insert_update(self.element) else None
@sql.base.CompileState.plugin_for("orm", "compound_select")
class CompoundSelectCompileState(
AutoflushOnlyORMCompileState, CompoundSelectState
):
pass
@sql.base.CompileState.plugin_for("orm", "select")
class ORMSelectCompileState(ORMCompileState, SelectState):
_already_joined_edges = ()
_memoized_entities = _EMPTY_DICT
_from_obj_alias = None
_has_mapper_entities = False
_has_orm_entities = False
multi_row_eager_loaders = False
eager_adding_joins = False
compound_eager_adapter = None
correlate = None
correlate_except = None
_where_criteria = ()
_having_criteria = ()
@classmethod
def create_for_statement(
cls,
statement: Union[Select, FromStatement],
compiler: Optional[SQLCompiler],
**kw: Any,
) -> ORMSelectCompileState:
"""compiler hook, we arrive here from compiler.visit_select() only."""
self = cls.__new__(cls)
if compiler is not None:
toplevel = not compiler.stack
else:
toplevel = True
select_statement = statement
# if we are a select() that was never a legacy Query, we won't
# have ORM level compile options.
statement._compile_options = cls.default_compile_options.safe_merge(
statement._compile_options
)
if select_statement._execution_options:
# execution options should not impact the compilation of a
# query, and at the moment subqueryloader is putting some things
# in here that we explicitly don't want stuck in a cache.
self.select_statement = select_statement._clone()
self.select_statement._execution_options = util.immutabledict()
else:
self.select_statement = select_statement
# indicates this select() came from Query.statement
self.for_statement = select_statement._compile_options._for_statement
# generally if we are from Query or directly from a select()
self.use_legacy_query_style = (
select_statement._compile_options._use_legacy_query_style
)
self._entities = []
self._primary_entity = None
self._polymorphic_adapters = {}
self.compile_options = select_statement._compile_options
if not toplevel:
# for subqueries, turn off eagerloads and set
# "render_for_subquery".
self.compile_options += {
"_enable_eagerloads": False,
"_render_for_subquery": True,
}
# determine label style. we can make different decisions here.
# at the moment, trying to see if we can always use DISAMBIGUATE_ONLY
# rather than LABEL_STYLE_NONE, and if we can use disambiguate style
# for new style ORM selects too.
if (
self.use_legacy_query_style
and self.select_statement._label_style is LABEL_STYLE_LEGACY_ORM
):
if not self.for_statement:
self.label_style = LABEL_STYLE_TABLENAME_PLUS_COL
else:
self.label_style = LABEL_STYLE_DISAMBIGUATE_ONLY
else:
self.label_style = self.select_statement._label_style
if select_statement._memoized_select_entities:
self._memoized_entities = {
memoized_entities: _QueryEntity.to_compile_state(
self,
memoized_entities._raw_columns,
[],
is_current_entities=False,
)
for memoized_entities in (
select_statement._memoized_select_entities
)
}
# label_convention is stateful and will yield deduping keys if it
# sees the same key twice. therefore it's important that it is not
# invoked for the above "memoized" entities that aren't actually
# in the columns clause
self._label_convention = self._column_naming_convention(
statement._label_style, self.use_legacy_query_style
)
_QueryEntity.to_compile_state(
self,
select_statement._raw_columns,
self._entities,
is_current_entities=True,
)
self.current_path = select_statement._compile_options._current_path
self.eager_order_by = ()
self._init_global_attributes(
select_statement,
compiler,
toplevel=toplevel,
process_criteria_for_toplevel=False,
)
if toplevel and (
select_statement._with_options
or select_statement._memoized_select_entities
):
for (
memoized_entities
) in select_statement._memoized_select_entities:
for opt in memoized_entities._with_options:
if opt._is_compile_state:
opt.process_compile_state_replaced_entities(
self,
[
ent
for ent in self._memoized_entities[
memoized_entities
]
if isinstance(ent, _MapperEntity)
],
)
for opt in self.select_statement._with_options:
if opt._is_compile_state:
opt.process_compile_state(self)
# uncomment to print out the context.attributes structure
# after it's been set up above
# self._dump_option_struct()
if select_statement._with_context_options:
for fn, key in select_statement._with_context_options:
fn(self)
self.primary_columns = []
self.secondary_columns = []
self.dedupe_columns = set()
self.eager_joins = {}
self.extra_criteria_entities = {}
self.create_eager_joins = []
self._fallback_from_clauses = []
# normalize the FROM clauses early by themselves, as this makes
# it an easier job when we need to assemble a JOIN onto these,
# for select.join() as well as joinedload(). As of 1.4 there are now
# potentially more complex sets of FROM objects here as the use
# of lambda statements for lazyload, load_on_pk etc. uses more
# cloning of the select() construct. See #6495
self.from_clauses = self._normalize_froms(
info.selectable for info in select_statement._from_obj
)
# this is a fairly arbitrary break into a second method,
# so it might be nicer to break up create_for_statement()
# and _setup_for_generate into three or four logical sections
self._setup_for_generate()
SelectState.__init__(self, self.statement, compiler, **kw)
return self
def _dump_option_struct(self):
print("\n---------------------------------------------------\n")
print(f"current path: {self.current_path}")
for key in self.attributes:
if isinstance(key, tuple) and key[0] == "loader":
print(f"\nLoader: {PathRegistry.coerce(key[1])}")
print(f" {self.attributes[key]}")
print(f" {self.attributes[key].__dict__}")
elif isinstance(key, tuple) and key[0] == "path_with_polymorphic":
print(f"\nWith Polymorphic: {PathRegistry.coerce(key[1])}")
print(f" {self.attributes[key]}")
def _setup_for_generate(self):
query = self.select_statement
self.statement = None
self._join_entities = ()
if self.compile_options._set_base_alias:
# legacy Query only
self._set_select_from_alias()
for memoized_entities in query._memoized_select_entities:
if memoized_entities._setup_joins:
self._join(
memoized_entities._setup_joins,
self._memoized_entities[memoized_entities],
)
if query._setup_joins:
self._join(query._setup_joins, self._entities)
current_adapter = self._get_current_adapter()
if query._where_criteria:
self._where_criteria = query._where_criteria
if current_adapter:
self._where_criteria = tuple(
current_adapter(crit, True)
for crit in self._where_criteria
)
# TODO: some complexity with order_by here was due to mapper.order_by.
# now that this is removed we can hopefully make order_by /
# group_by act identically to how they are in Core select.
self.order_by = (
self._adapt_col_list(query._order_by_clauses, current_adapter)
if current_adapter and query._order_by_clauses not in (None, False)
else query._order_by_clauses
)
if query._having_criteria:
self._having_criteria = tuple(
current_adapter(crit, True) if current_adapter else crit
for crit in query._having_criteria
)
self.group_by = (
self._adapt_col_list(
util.flatten_iterator(query._group_by_clauses), current_adapter
)
if current_adapter and query._group_by_clauses not in (None, False)
else query._group_by_clauses or None
)
if self.eager_order_by:
adapter = self.from_clauses[0]._target_adapter
self.eager_order_by = adapter.copy_and_process(self.eager_order_by)
if query._distinct_on:
self.distinct_on = self._adapt_col_list(
query._distinct_on, current_adapter
)
else:
self.distinct_on = ()
self.distinct = query._distinct
if query._correlate:
# ORM mapped entities that are mapped to joins can be passed
# to .correlate, so here they are broken into their component
# tables.
self.correlate = tuple(
util.flatten_iterator(
sql_util.surface_selectables(s) if s is not None else None
for s in query._correlate
)
)
elif query._correlate_except is not None:
self.correlate_except = tuple(
util.flatten_iterator(
sql_util.surface_selectables(s) if s is not None else None
for s in query._correlate_except
)
)
elif not query._auto_correlate:
self.correlate = (None,)
# PART II
self._for_update_arg = query._for_update_arg
if self.compile_options._is_star and (len(self._entities) != 1):
raise sa_exc.CompileError(
"Can't generate ORM query that includes multiple expressions "
"at the same time as '*'; query for '*' alone if present"
)
for entity in self._entities:
entity.setup_compile_state(self)
for rec in self.create_eager_joins:
strategy = rec[0]
strategy(self, *rec[1:])
# else "load from discrete FROMs" mode,
# i.e. when each _MappedEntity has its own FROM
if self.compile_options._enable_single_crit:
self._adjust_for_extra_criteria()
if not self.primary_columns:
if self.compile_options._only_load_props:
assert False, "no columns were included in _only_load_props"
raise sa_exc.InvalidRequestError(
"Query contains no columns with which to SELECT from."
)
if not self.from_clauses:
self.from_clauses = list(self._fallback_from_clauses)
if self.order_by is False:
self.order_by = None
if (
self.multi_row_eager_loaders
and self.eager_adding_joins
and self._should_nest_selectable
):
self.statement = self._compound_eager_statement()
else:
self.statement = self._simple_statement()
if self.for_statement:
ezero = self._mapper_zero()
if ezero is not None:
# TODO: this goes away once we get rid of the deep entity
# thing
self.statement = self.statement._annotate(
{"deepentity": ezero}
)
@classmethod
def _create_entities_collection(cls, query, legacy):
"""Creates a partial ORMSelectCompileState that includes
the full collection of _MapperEntity and other _QueryEntity objects.
Supports a few remaining use cases that are pre-compilation
but still need to gather some of the column / adaption information.
"""
self = cls.__new__(cls)
self._entities = []
self._primary_entity = None
self._polymorphic_adapters = {}
self._label_convention = self._column_naming_convention(
query._label_style, legacy
)
# entities will also set up polymorphic adapters for mappers
# that have with_polymorphic configured
_QueryEntity.to_compile_state(
self, query._raw_columns, self._entities, is_current_entities=True
)
return self
@classmethod
def determine_last_joined_entity(cls, statement):
setup_joins = statement._setup_joins
return _determine_last_joined_entity(setup_joins, None)
@classmethod
def all_selected_columns(cls, statement):
for element in statement._raw_columns:
if (
element.is_selectable
and "entity_namespace" in element._annotations
):
ens = element._annotations["entity_namespace"]
if not ens.is_mapper and not ens.is_aliased_class:
yield from _select_iterables([element])
else:
yield from _select_iterables(ens._all_column_expressions)
else:
yield from _select_iterables([element])
@classmethod
def get_columns_clause_froms(cls, statement):
return cls._normalize_froms(
itertools.chain.from_iterable(
(
element._from_objects
if "parententity" not in element._annotations
else [
element._annotations[
"parententity"
].__clause_element__()
]
)
for element in statement._raw_columns
)
)
@classmethod
def from_statement(cls, statement, from_statement):
from_statement = coercions.expect(
roles.ReturnsRowsRole,
from_statement,
apply_propagate_attrs=statement,
)
stmt = FromStatement(statement._raw_columns, from_statement)
stmt.__dict__.update(
_with_options=statement._with_options,
_with_context_options=statement._with_context_options,
_execution_options=statement._execution_options,
_propagate_attrs=statement._propagate_attrs,
)
return stmt
def _set_select_from_alias(self):
"""used only for legacy Query cases"""
query = self.select_statement # query
assert self.compile_options._set_base_alias
assert len(query._from_obj) == 1
adapter = self._get_select_from_alias_from_obj(query._from_obj[0])
if adapter:
self.compile_options += {"_enable_single_crit": False}
self._from_obj_alias = adapter
def _get_select_from_alias_from_obj(self, from_obj):
"""used only for legacy Query cases"""
info = from_obj
if "parententity" in info._annotations:
info = info._annotations["parententity"]
if hasattr(info, "mapper"):
if not info.is_aliased_class:
raise sa_exc.ArgumentError(
"A selectable (FromClause) instance is "
"expected when the base alias is being set."
)
else:
return info._adapter
elif isinstance(info.selectable, sql.selectable.AliasedReturnsRows):
equivs = self._all_equivs()
assert info is info.selectable
return ORMStatementAdapter(
_TraceAdaptRole.LEGACY_SELECT_FROM_ALIAS,
info.selectable,
equivalents=equivs,
)
else:
return None
def _mapper_zero(self):
"""return the Mapper associated with the first QueryEntity."""
return self._entities[0].mapper
def _entity_zero(self):
"""Return the 'entity' (mapper or AliasedClass) associated
with the first QueryEntity, or alternatively the 'select from'
entity if specified."""
for ent in self.from_clauses:
if "parententity" in ent._annotations:
return ent._annotations["parententity"]
for qent in self._entities:
if qent.entity_zero:
return qent.entity_zero
return None
def _only_full_mapper_zero(self, methname):
if self._entities != [self._primary_entity]:
raise sa_exc.InvalidRequestError(
"%s() can only be used against "
"a single mapped class." % methname
)
return self._primary_entity.entity_zero
def _only_entity_zero(self, rationale=None):
if len(self._entities) > 1:
raise sa_exc.InvalidRequestError(
rationale
or "This operation requires a Query "
"against a single mapper."
)
return self._entity_zero()
def _all_equivs(self):
equivs = {}
for memoized_entities in self._memoized_entities.values():
for ent in [
ent
for ent in memoized_entities
if isinstance(ent, _MapperEntity)
]:
equivs.update(ent.mapper._equivalent_columns)
for ent in [
ent for ent in self._entities if isinstance(ent, _MapperEntity)
]:
equivs.update(ent.mapper._equivalent_columns)
return equivs
def _compound_eager_statement(self):
# for eager joins present and LIMIT/OFFSET/DISTINCT,
# wrap the query inside a select,
# then append eager joins onto that
if self.order_by:
# the default coercion for ORDER BY is now the OrderByRole,
# which adds an additional post coercion to ByOfRole in that
# elements are converted into label references. For the
# eager load / subquery wrapping case, we need to un-coerce
# the original expressions outside of the label references
# in order to have them render.
unwrapped_order_by = [
(
elem.element
if isinstance(elem, sql.elements._label_reference)
else elem
)
for elem in self.order_by
]
order_by_col_expr = sql_util.expand_column_list_from_order_by(
self.primary_columns, unwrapped_order_by
)
else:
order_by_col_expr = []
unwrapped_order_by = None
# put FOR UPDATE on the inner query, where MySQL will honor it,
# as well as if it has an OF so PostgreSQL can use it.
inner = self._select_statement(
self.primary_columns
+ [c for c in order_by_col_expr if c not in self.dedupe_columns],
self.from_clauses,
self._where_criteria,
self._having_criteria,
self.label_style,
self.order_by,
for_update=self._for_update_arg,
hints=self.select_statement._hints,
statement_hints=self.select_statement._statement_hints,
correlate=self.correlate,
correlate_except=self.correlate_except,
**self._select_args,
)
inner = inner.alias()
equivs = self._all_equivs()
self.compound_eager_adapter = ORMStatementAdapter(
_TraceAdaptRole.COMPOUND_EAGER_STATEMENT, inner, equivalents=equivs
)
statement = future.select(
*([inner] + self.secondary_columns) # use_labels=self.labels
)
statement._label_style = self.label_style
# Oracle however does not allow FOR UPDATE on the subquery,
# and the Oracle dialect ignores it, plus for PostgreSQL, MySQL
# we expect that all elements of the row are locked, so also put it
# on the outside (except in the case of PG when OF is used)
if (
self._for_update_arg is not None
and self._for_update_arg.of is None
):
statement._for_update_arg = self._for_update_arg
from_clause = inner
for eager_join in self.eager_joins.values():
# EagerLoader places a 'stop_on' attribute on the join,
# giving us a marker as to where the "splice point" of
# the join should be
from_clause = sql_util.splice_joins(
from_clause, eager_join, eager_join.stop_on
)
statement.select_from.non_generative(statement, from_clause)
if unwrapped_order_by:
statement.order_by.non_generative(
statement,
*self.compound_eager_adapter.copy_and_process(
unwrapped_order_by
),
)
statement.order_by.non_generative(statement, *self.eager_order_by)
return statement
def _simple_statement(self):
statement = self._select_statement(
self.primary_columns + self.secondary_columns,
tuple(self.from_clauses) + tuple(self.eager_joins.values()),
self._where_criteria,
self._having_criteria,
self.label_style,
self.order_by,
for_update=self._for_update_arg,
hints=self.select_statement._hints,
statement_hints=self.select_statement._statement_hints,
correlate=self.correlate,
correlate_except=self.correlate_except,
**self._select_args,
)
if self.eager_order_by:
statement.order_by.non_generative(statement, *self.eager_order_by)
return statement
def _select_statement(
self,
raw_columns,
from_obj,
where_criteria,
having_criteria,
label_style,
order_by,
for_update,
hints,
statement_hints,
correlate,
correlate_except,
limit_clause,
offset_clause,
fetch_clause,
fetch_clause_options,
distinct,
distinct_on,
prefixes,
suffixes,
group_by,
independent_ctes,
independent_ctes_opts,
):
statement = Select._create_raw_select(
_raw_columns=raw_columns,
_from_obj=from_obj,
_label_style=label_style,
)
if where_criteria:
statement._where_criteria = where_criteria
if having_criteria:
statement._having_criteria = having_criteria
if order_by:
statement._order_by_clauses += tuple(order_by)
if distinct_on:
statement.distinct.non_generative(statement, *distinct_on)
elif distinct:
statement.distinct.non_generative(statement)
if group_by:
statement._group_by_clauses += tuple(group_by)
statement._limit_clause = limit_clause
statement._offset_clause = offset_clause
statement._fetch_clause = fetch_clause
statement._fetch_clause_options = fetch_clause_options
statement._independent_ctes = independent_ctes
statement._independent_ctes_opts = independent_ctes_opts
if prefixes:
statement._prefixes = prefixes
if suffixes:
statement._suffixes = suffixes
statement._for_update_arg = for_update
if hints:
statement._hints = hints
if statement_hints:
statement._statement_hints = statement_hints
if correlate:
statement.correlate.non_generative(statement, *correlate)
if correlate_except is not None:
statement.correlate_except.non_generative(
statement, *correlate_except
)
return statement
def _adapt_polymorphic_element(self, element):
if "parententity" in element._annotations:
search = element._annotations["parententity"]
alias = self._polymorphic_adapters.get(search, None)
if alias:
return alias.adapt_clause(element)
if isinstance(element, expression.FromClause):
search = element
elif hasattr(element, "table"):
search = element.table
else:
return None
alias = self._polymorphic_adapters.get(search, None)
if alias:
return alias.adapt_clause(element)
def _adapt_col_list(self, cols, current_adapter):
if current_adapter:
return [current_adapter(o, True) for o in cols]
else:
return cols
def _get_current_adapter(self):
adapters = []
if self._from_obj_alias:
# used for legacy going forward for query set_ops, e.g.
# union(), union_all(), etc.
# 1.4 and previously, also used for from_self(),
# select_entity_from()
#
# for the "from obj" alias, apply extra rule to the
# 'ORM only' check, if this query were generated from a
# subquery of itself, i.e. _from_selectable(), apply adaption
# to all SQL constructs.
adapters.append(
(
True,
self._from_obj_alias.replace,
)
)
# this was *hopefully* the only adapter we were going to need
# going forward...however, we unfortunately need _from_obj_alias
# for query.union(), which we can't drop
if self._polymorphic_adapters:
adapters.append((False, self._adapt_polymorphic_element))
if not adapters:
return None
def _adapt_clause(clause, as_filter):
# do we adapt all expression elements or only those
# tagged as 'ORM' constructs ?
def replace(elem):
is_orm_adapt = (
"_orm_adapt" in elem._annotations
or "parententity" in elem._annotations
)
for always_adapt, adapter in adapters:
if is_orm_adapt or always_adapt:
e = adapter(elem)
if e is not None:
return e
return visitors.replacement_traverse(clause, {}, replace)
return _adapt_clause
def _join(self, args, entities_collection):
for right, onclause, from_, flags in args:
isouter = flags["isouter"]
full = flags["full"]
right = inspect(right)
if onclause is not None:
onclause = inspect(onclause)
if isinstance(right, interfaces.PropComparator):
if onclause is not None:
raise sa_exc.InvalidRequestError(
"No 'on clause' argument may be passed when joining "
"to a relationship path as a target"
)
onclause = right
right = None
elif "parententity" in right._annotations:
right = right._annotations["parententity"]
if onclause is None:
if not right.is_selectable and not hasattr(right, "mapper"):
raise sa_exc.ArgumentError(
"Expected mapped entity or "
"selectable/table as join target"
)
of_type = None
if isinstance(onclause, interfaces.PropComparator):
# descriptor/property given (or determined); this tells us
# explicitly what the expected "left" side of the join is.
of_type = getattr(onclause, "_of_type", None)
if right is None:
if of_type:
right = of_type
else:
right = onclause.property
try:
right = right.entity
except AttributeError as err:
raise sa_exc.ArgumentError(
"Join target %s does not refer to a "
"mapped entity" % right
) from err
left = onclause._parententity
prop = onclause.property
if not isinstance(onclause, attributes.QueryableAttribute):
onclause = prop
# check for this path already present. don't render in that
# case.
if (left, right, prop.key) in self._already_joined_edges:
continue
if from_ is not None:
if (
from_ is not left
and from_._annotations.get("parententity", None)
is not left
):
raise sa_exc.InvalidRequestError(
"explicit from clause %s does not match left side "
"of relationship attribute %s"
% (
from_._annotations.get("parententity", from_),
onclause,
)
)
elif from_ is not None:
prop = None
left = from_
else:
# no descriptor/property given; we will need to figure out
# what the effective "left" side is
prop = left = None
# figure out the final "left" and "right" sides and create an
# ORMJoin to add to our _from_obj tuple
self._join_left_to_right(
entities_collection,
left,
right,
onclause,
prop,
isouter,
full,
)
def _join_left_to_right(
self,
entities_collection,
left,
right,
onclause,
prop,
outerjoin,
full,
):
"""given raw "left", "right", "onclause" parameters consumed from
a particular key within _join(), add a real ORMJoin object to
our _from_obj list (or augment an existing one)
"""
if left is None:
# left not given (e.g. no relationship object/name specified)
# figure out the best "left" side based on our existing froms /
# entities
assert prop is None
(
left,
replace_from_obj_index,
use_entity_index,
) = self._join_determine_implicit_left_side(
entities_collection, left, right, onclause
)
else:
# left is given via a relationship/name, or as explicit left side.
# Determine where in our
# "froms" list it should be spliced/appended as well as what
# existing entity it corresponds to.
(
replace_from_obj_index,
use_entity_index,
) = self._join_place_explicit_left_side(entities_collection, left)
if left is right:
raise sa_exc.InvalidRequestError(
"Can't construct a join from %s to %s, they "
"are the same entity" % (left, right)
)
# the right side as given often needs to be adapted. additionally
# a lot of things can be wrong with it. handle all that and
# get back the new effective "right" side
r_info, right, onclause = self._join_check_and_adapt_right_side(
left, right, onclause, prop
)
if not r_info.is_selectable:
extra_criteria = self._get_extra_criteria(r_info)
else:
extra_criteria = ()
if replace_from_obj_index is not None:
# splice into an existing element in the
# self._from_obj list
left_clause = self.from_clauses[replace_from_obj_index]
self.from_clauses = (
self.from_clauses[:replace_from_obj_index]
+ [
_ORMJoin(
left_clause,
right,
onclause,
isouter=outerjoin,
full=full,
_extra_criteria=extra_criteria,
)
]
+ self.from_clauses[replace_from_obj_index + 1 :]
)
else:
# add a new element to the self._from_obj list
if use_entity_index is not None:
# make use of _MapperEntity selectable, which is usually
# entity_zero.selectable, but if with_polymorphic() were used
# might be distinct
assert isinstance(
entities_collection[use_entity_index], _MapperEntity
)
left_clause = entities_collection[use_entity_index].selectable
else:
left_clause = left
self.from_clauses = self.from_clauses + [
_ORMJoin(
left_clause,
r_info,
onclause,
isouter=outerjoin,
full=full,
_extra_criteria=extra_criteria,
)
]
def _join_determine_implicit_left_side(
self, entities_collection, left, right, onclause
):
"""When join conditions don't express the left side explicitly,
determine if an existing FROM or entity in this query
can serve as the left hand side.
"""
# when we are here, it means join() was called without an ORM-
# specific way of telling us what the "left" side is, e.g.:
#
# join(RightEntity)
#
# or
#
# join(RightEntity, RightEntity.foo == LeftEntity.bar)
#
r_info = inspect(right)
replace_from_obj_index = use_entity_index = None
if self.from_clauses:
# we have a list of FROMs already. So by definition this
# join has to connect to one of those FROMs.
indexes = sql_util.find_left_clause_to_join_from(
self.from_clauses, r_info.selectable, onclause
)
if len(indexes) == 1:
replace_from_obj_index = indexes[0]
left = self.from_clauses[replace_from_obj_index]
elif len(indexes) > 1:
raise sa_exc.InvalidRequestError(
"Can't determine which FROM clause to join "
"from, there are multiple FROMS which can "
"join to this entity. Please use the .select_from() "
"method to establish an explicit left side, as well as "
"providing an explicit ON clause if not present already "
"to help resolve the ambiguity."
)
else:
raise sa_exc.InvalidRequestError(
"Don't know how to join to %r. "
"Please use the .select_from() "
"method to establish an explicit left side, as well as "
"providing an explicit ON clause if not present already "
"to help resolve the ambiguity." % (right,)
)
elif entities_collection:
# we have no explicit FROMs, so the implicit left has to
# come from our list of entities.
potential = {}
for entity_index, ent in enumerate(entities_collection):
entity = ent.entity_zero_or_selectable
if entity is None:
continue
ent_info = inspect(entity)
if ent_info is r_info: # left and right are the same, skip
continue
# by using a dictionary with the selectables as keys this
# de-duplicates those selectables as occurs when the query is
# against a series of columns from the same selectable
if isinstance(ent, _MapperEntity):
potential[ent.selectable] = (entity_index, entity)
else:
potential[ent_info.selectable] = (None, entity)
all_clauses = list(potential.keys())
indexes = sql_util.find_left_clause_to_join_from(
all_clauses, r_info.selectable, onclause
)
if len(indexes) == 1:
use_entity_index, left = potential[all_clauses[indexes[0]]]
elif len(indexes) > 1:
raise sa_exc.InvalidRequestError(
"Can't determine which FROM clause to join "
"from, there are multiple FROMS which can "
"join to this entity. Please use the .select_from() "
"method to establish an explicit left side, as well as "
"providing an explicit ON clause if not present already "
"to help resolve the ambiguity."
)
else:
raise sa_exc.InvalidRequestError(
"Don't know how to join to %r. "
"Please use the .select_from() "
"method to establish an explicit left side, as well as "
"providing an explicit ON clause if not present already "
"to help resolve the ambiguity." % (right,)
)
else:
raise sa_exc.InvalidRequestError(
"No entities to join from; please use "
"select_from() to establish the left "
"entity/selectable of this join"
)
return left, replace_from_obj_index, use_entity_index
def _join_place_explicit_left_side(self, entities_collection, left):
"""When join conditions express a left side explicitly, determine
where in our existing list of FROM clauses we should join towards,
or if we need to make a new join, and if so is it from one of our
existing entities.
"""
# when we are here, it means join() was called with an indicator
# as to an exact left side, which means a path to a
# Relationship was given, e.g.:
#
# join(RightEntity, LeftEntity.right)
#
# or
#
# join(LeftEntity.right)
#
# as well as string forms:
#
# join(RightEntity, "right")
#
# etc.
#
replace_from_obj_index = use_entity_index = None
l_info = inspect(left)
if self.from_clauses:
indexes = sql_util.find_left_clause_that_matches_given(
self.from_clauses, l_info.selectable
)
if len(indexes) > 1:
raise sa_exc.InvalidRequestError(
"Can't identify which entity in which to assign the "
"left side of this join. Please use a more specific "
"ON clause."
)
# have an index, means the left side is already present in
# an existing FROM in the self._from_obj tuple
if indexes:
replace_from_obj_index = indexes[0]
# no index, means we need to add a new element to the
# self._from_obj tuple
# no from element present, so we will have to add to the
# self._from_obj tuple. Determine if this left side matches up
# with existing mapper entities, in which case we want to apply the
# aliasing / adaptation rules present on that entity if any
if (
replace_from_obj_index is None
and entities_collection
and hasattr(l_info, "mapper")
):
for idx, ent in enumerate(entities_collection):
# TODO: should we be checking for multiple mapper entities
# matching?
if isinstance(ent, _MapperEntity) and ent.corresponds_to(left):
use_entity_index = idx
break
return replace_from_obj_index, use_entity_index
def _join_check_and_adapt_right_side(self, left, right, onclause, prop):
"""transform the "right" side of the join as well as the onclause
according to polymorphic mapping translations, aliasing on the query
or on the join, special cases where the right and left side have
overlapping tables.
"""
l_info = inspect(left)
r_info = inspect(right)
overlap = False
right_mapper = getattr(r_info, "mapper", None)
# if the target is a joined inheritance mapping,
# be more liberal about auto-aliasing.
if right_mapper and (
right_mapper.with_polymorphic
or isinstance(right_mapper.persist_selectable, expression.Join)
):
for from_obj in self.from_clauses or [l_info.selectable]:
if sql_util.selectables_overlap(
l_info.selectable, from_obj
) and sql_util.selectables_overlap(
from_obj, r_info.selectable
):
overlap = True
break
if overlap and l_info.selectable is r_info.selectable:
raise sa_exc.InvalidRequestError(
"Can't join table/selectable '%s' to itself"
% l_info.selectable
)
right_mapper, right_selectable, right_is_aliased = (
getattr(r_info, "mapper", None),
r_info.selectable,
getattr(r_info, "is_aliased_class", False),
)
if (
right_mapper
and prop
and not right_mapper.common_parent(prop.mapper)
):
raise sa_exc.InvalidRequestError(
"Join target %s does not correspond to "
"the right side of join condition %s" % (right, onclause)
)
# _join_entities is used as a hint for single-table inheritance
# purposes at the moment
if hasattr(r_info, "mapper"):
self._join_entities += (r_info,)
need_adapter = False
# test for joining to an unmapped selectable as the target
if r_info.is_clause_element:
if prop:
right_mapper = prop.mapper
if right_selectable._is_lateral:
# orm_only is disabled to suit the case where we have to
# adapt an explicit correlate(Entity) - the select() loses
# the ORM-ness in this case right now, ideally it would not
current_adapter = self._get_current_adapter()
if current_adapter is not None:
# TODO: we had orm_only=False here before, removing
# it didn't break things. if we identify the rationale,
# may need to apply "_orm_only" annotation here.
right = current_adapter(right, True)
elif prop:
# joining to selectable with a mapper property given
# as the ON clause
if not right_selectable.is_derived_from(
right_mapper.persist_selectable
):
raise sa_exc.InvalidRequestError(
"Selectable '%s' is not derived from '%s'"
% (
right_selectable.description,
right_mapper.persist_selectable.description,
)
)
# if the destination selectable is a plain select(),
# turn it into an alias().
if isinstance(right_selectable, expression.SelectBase):
right_selectable = coercions.expect(
roles.FromClauseRole, right_selectable
)
need_adapter = True
# make the right hand side target into an ORM entity
right = AliasedClass(right_mapper, right_selectable)
util.warn_deprecated(
"An alias is being generated automatically against "
"joined entity %s for raw clauseelement, which is "
"deprecated and will be removed in a later release. "
"Use the aliased() "
"construct explicitly, see the linked example."
% right_mapper,
"1.4",
code="xaj1",
)
# test for overlap:
# orm/inheritance/relationships.py
# SelfReferentialM2MTest
aliased_entity = right_mapper and not right_is_aliased and overlap
if not need_adapter and aliased_entity:
# there are a few places in the ORM that automatic aliasing
# is still desirable, and can't be automatic with a Core
# only approach. For illustrations of "overlaps" see
# test/orm/inheritance/test_relationships.py. There are also
# general overlap cases with many-to-many tables where automatic
# aliasing is desirable.
right = AliasedClass(right, flat=True)
need_adapter = True
util.warn(
"An alias is being generated automatically against "
"joined entity %s due to overlapping tables. This is a "
"legacy pattern which may be "
"deprecated in a later release. Use the "
"aliased(<entity>, flat=True) "
"construct explicitly, see the linked example." % right_mapper,
code="xaj2",
)
if need_adapter:
# if need_adapter is True, we are in a deprecated case and
# a warning has been emitted.
assert right_mapper
adapter = ORMAdapter(
_TraceAdaptRole.DEPRECATED_JOIN_ADAPT_RIGHT_SIDE,
inspect(right),
equivalents=right_mapper._equivalent_columns,
)
# if an alias() on the right side was generated,
# which is intended to wrap a the right side in a subquery,
# ensure that columns retrieved from this target in the result
# set are also adapted.
self._mapper_loads_polymorphically_with(right_mapper, adapter)
elif (
not r_info.is_clause_element
and not right_is_aliased
and right_mapper._has_aliased_polymorphic_fromclause
):
# for the case where the target mapper has a with_polymorphic
# set up, ensure an adapter is set up for criteria that works
# against this mapper. Previously, this logic used to
# use the "create_aliases or aliased_entity" case to generate
# an aliased() object, but this creates an alias that isn't
# strictly necessary.
# see test/orm/test_core_compilation.py
# ::RelNaturalAliasedJoinsTest::test_straight
# and similar
self._mapper_loads_polymorphically_with(
right_mapper,
ORMAdapter(
_TraceAdaptRole.WITH_POLYMORPHIC_ADAPTER_RIGHT_JOIN,
right_mapper,
selectable=right_mapper.selectable,
equivalents=right_mapper._equivalent_columns,
),
)
# if the onclause is a ClauseElement, adapt it with any
# adapters that are in place right now
if isinstance(onclause, expression.ClauseElement):
current_adapter = self._get_current_adapter()
if current_adapter:
onclause = current_adapter(onclause, True)
# if joining on a MapperProperty path,
# track the path to prevent redundant joins
if prop:
self._already_joined_edges += ((left, right, prop.key),)
return inspect(right), right, onclause
@property
def _select_args(self):
return {
"limit_clause": self.select_statement._limit_clause,
"offset_clause": self.select_statement._offset_clause,
"distinct": self.distinct,
"distinct_on": self.distinct_on,
"prefixes": self.select_statement._prefixes,
"suffixes": self.select_statement._suffixes,
"group_by": self.group_by or None,
"fetch_clause": self.select_statement._fetch_clause,
"fetch_clause_options": (
self.select_statement._fetch_clause_options
),
"independent_ctes": self.select_statement._independent_ctes,
"independent_ctes_opts": (
self.select_statement._independent_ctes_opts
),
}
@property
def _should_nest_selectable(self):
kwargs = self._select_args
return (
kwargs.get("limit_clause") is not None
or kwargs.get("offset_clause") is not None
or kwargs.get("distinct", False)
or kwargs.get("distinct_on", ())
or kwargs.get("group_by", False)
)
def _get_extra_criteria(self, ext_info):
if (
"additional_entity_criteria",
ext_info.mapper,
) in self.global_attributes:
return tuple(
ae._resolve_where_criteria(ext_info)
for ae in self.global_attributes[
("additional_entity_criteria", ext_info.mapper)
]
if (ae.include_aliases or ae.entity is ext_info)
and ae._should_include(self)
)
else:
return ()
def _adjust_for_extra_criteria(self):
"""Apply extra criteria filtering.
For all distinct single-table-inheritance mappers represented in
the columns clause of this query, as well as the "select from entity",
add criterion to the WHERE
clause of the given QueryContext such that only the appropriate
subtypes are selected from the total results.
Additionally, add WHERE criteria originating from LoaderCriteriaOptions
associated with the global context.
"""
for fromclause in self.from_clauses:
ext_info = fromclause._annotations.get("parententity", None)
if (
ext_info
and (
ext_info.mapper._single_table_criterion is not None
or ("additional_entity_criteria", ext_info.mapper)
in self.global_attributes
)
and ext_info not in self.extra_criteria_entities
):
self.extra_criteria_entities[ext_info] = (
ext_info,
ext_info._adapter if ext_info.is_aliased_class else None,
)
search = set(self.extra_criteria_entities.values())
for ext_info, adapter in search:
if ext_info in self._join_entities:
continue
single_crit = ext_info.mapper._single_table_criterion
if self.compile_options._for_refresh_state:
additional_entity_criteria = []
else:
additional_entity_criteria = self._get_extra_criteria(ext_info)
if single_crit is not None:
additional_entity_criteria += (single_crit,)
current_adapter = self._get_current_adapter()
for crit in additional_entity_criteria:
if adapter:
crit = adapter.traverse(crit)
if current_adapter:
crit = sql_util._deep_annotate(crit, {"_orm_adapt": True})
crit = current_adapter(crit, False)
self._where_criteria += (crit,)
def _column_descriptions(
query_or_select_stmt: Union[Query, Select, FromStatement],
compile_state: Optional[ORMSelectCompileState] = None,
legacy: bool = False,
) -> List[ORMColumnDescription]:
if compile_state is None:
compile_state = ORMSelectCompileState._create_entities_collection(
query_or_select_stmt, legacy=legacy
)
ctx = compile_state
d = [
{
"name": ent._label_name,
"type": ent.type,
"aliased": getattr(insp_ent, "is_aliased_class", False),
"expr": ent.expr,
"entity": (
getattr(insp_ent, "entity", None)
if ent.entity_zero is not None
and not insp_ent.is_clause_element
else None
),
}
for ent, insp_ent in [
(_ent, _ent.entity_zero) for _ent in ctx._entities
]
]
return d
def _legacy_filter_by_entity_zero(
query_or_augmented_select: Union[Query[Any], Select[Any]]
) -> Optional[_InternalEntityType[Any]]:
self = query_or_augmented_select
if self._setup_joins:
_last_joined_entity = self._last_joined_entity
if _last_joined_entity is not None:
return _last_joined_entity
if self._from_obj and "parententity" in self._from_obj[0]._annotations:
return self._from_obj[0]._annotations["parententity"]
return _entity_from_pre_ent_zero(self)
def _entity_from_pre_ent_zero(
query_or_augmented_select: Union[Query[Any], Select[Any]]
) -> Optional[_InternalEntityType[Any]]:
self = query_or_augmented_select
if not self._raw_columns:
return None
ent = self._raw_columns[0]
if "parententity" in ent._annotations:
return ent._annotations["parententity"]
elif isinstance(ent, ORMColumnsClauseRole):
return ent.entity
elif "bundle" in ent._annotations:
return ent._annotations["bundle"]
else:
return ent
def _determine_last_joined_entity(
setup_joins: Tuple[_SetupJoinsElement, ...],
entity_zero: Optional[_InternalEntityType[Any]] = None,
) -> Optional[Union[_InternalEntityType[Any], _JoinTargetElement]]:
if not setup_joins:
return None
(target, onclause, from_, flags) = setup_joins[-1]
if isinstance(
target,
attributes.QueryableAttribute,
):
return target.entity
else:
return target
class _QueryEntity:
"""represent an entity column returned within a Query result."""
__slots__ = ()
supports_single_entity: bool
_non_hashable_value = False
_null_column_type = False
use_id_for_hash = False
_label_name: Optional[str]
type: Union[Type[Any], TypeEngine[Any]]
expr: Union[_InternalEntityType, ColumnElement[Any]]
entity_zero: Optional[_InternalEntityType]
def setup_compile_state(self, compile_state: ORMCompileState) -> None:
raise NotImplementedError()
def setup_dml_returning_compile_state(
self,
compile_state: ORMCompileState,
adapter: DMLReturningColFilter,
) -> None:
raise NotImplementedError()
def row_processor(self, context, result):
raise NotImplementedError()
@classmethod
def to_compile_state(
cls, compile_state, entities, entities_collection, is_current_entities
):
for idx, entity in enumerate(entities):
if entity._is_lambda_element:
if entity._is_sequence:
cls.to_compile_state(
compile_state,
entity._resolved,
entities_collection,
is_current_entities,
)
continue
else:
entity = entity._resolved
if entity.is_clause_element:
if entity.is_selectable:
if "parententity" in entity._annotations:
_MapperEntity(
compile_state,
entity,
entities_collection,
is_current_entities,
)
else:
_ColumnEntity._for_columns(
compile_state,
entity._select_iterable,
entities_collection,
idx,
is_current_entities,
)
else:
if entity._annotations.get("bundle", False):
_BundleEntity(
compile_state,
entity,
entities_collection,
is_current_entities,
)
elif entity._is_clause_list:
# this is legacy only - test_composites.py
# test_query_cols_legacy
_ColumnEntity._for_columns(
compile_state,
entity._select_iterable,
entities_collection,
idx,
is_current_entities,
)
else:
_ColumnEntity._for_columns(
compile_state,
[entity],
entities_collection,
idx,
is_current_entities,
)
elif entity.is_bundle:
_BundleEntity(compile_state, entity, entities_collection)
return entities_collection
class _MapperEntity(_QueryEntity):
"""mapper/class/AliasedClass entity"""
__slots__ = (
"expr",
"mapper",
"entity_zero",
"is_aliased_class",
"path",
"_extra_entities",
"_label_name",
"_with_polymorphic_mappers",
"selectable",
"_polymorphic_discriminator",
)
expr: _InternalEntityType
mapper: Mapper[Any]
entity_zero: _InternalEntityType
is_aliased_class: bool
path: PathRegistry
_label_name: str
def __init__(
self, compile_state, entity, entities_collection, is_current_entities
):
entities_collection.append(self)
if is_current_entities:
if compile_state._primary_entity is None:
compile_state._primary_entity = self
compile_state._has_mapper_entities = True
compile_state._has_orm_entities = True
entity = entity._annotations["parententity"]
entity._post_inspect
ext_info = self.entity_zero = entity
entity = ext_info.entity
self.expr = entity
self.mapper = mapper = ext_info.mapper
self._extra_entities = (self.expr,)
if ext_info.is_aliased_class:
self._label_name = ext_info.name
else:
self._label_name = mapper.class_.__name__
self.is_aliased_class = ext_info.is_aliased_class
self.path = ext_info._path_registry
self.selectable = ext_info.selectable
self._with_polymorphic_mappers = ext_info.with_polymorphic_mappers
self._polymorphic_discriminator = ext_info.polymorphic_on
if mapper._should_select_with_poly_adapter:
compile_state._create_with_polymorphic_adapter(
ext_info, self.selectable
)
supports_single_entity = True
_non_hashable_value = True
use_id_for_hash = True
@property
def type(self):
return self.mapper.class_
@property
def entity_zero_or_selectable(self):
return self.entity_zero
def corresponds_to(self, entity):
return _entity_corresponds_to(self.entity_zero, entity)
def _get_entity_clauses(self, compile_state):
adapter = None
if not self.is_aliased_class:
if compile_state._polymorphic_adapters:
adapter = compile_state._polymorphic_adapters.get(
self.mapper, None
)
else:
adapter = self.entity_zero._adapter
if adapter:
if compile_state._from_obj_alias:
ret = adapter.wrap(compile_state._from_obj_alias)
else:
ret = adapter
else:
ret = compile_state._from_obj_alias
return ret
def row_processor(self, context, result):
compile_state = context.compile_state
adapter = self._get_entity_clauses(compile_state)
if compile_state.compound_eager_adapter and adapter:
adapter = adapter.wrap(compile_state.compound_eager_adapter)
elif not adapter:
adapter = compile_state.compound_eager_adapter
if compile_state._primary_entity is self:
only_load_props = compile_state.compile_options._only_load_props
refresh_state = context.refresh_state
else:
only_load_props = refresh_state = None
_instance = loading._instance_processor(
self,
self.mapper,
context,
result,
self.path,
adapter,
only_load_props=only_load_props,
refresh_state=refresh_state,
polymorphic_discriminator=self._polymorphic_discriminator,
)
return _instance, self._label_name, self._extra_entities
def setup_dml_returning_compile_state(
self,
compile_state: ORMCompileState,
adapter: DMLReturningColFilter,
) -> None:
loading._setup_entity_query(
compile_state,
self.mapper,
self,
self.path,
adapter,
compile_state.primary_columns,
with_polymorphic=self._with_polymorphic_mappers,
only_load_props=compile_state.compile_options._only_load_props,
polymorphic_discriminator=self._polymorphic_discriminator,
)
def setup_compile_state(self, compile_state):
adapter = self._get_entity_clauses(compile_state)
single_table_crit = self.mapper._single_table_criterion
if (
single_table_crit is not None
or ("additional_entity_criteria", self.mapper)
in compile_state.global_attributes
):
ext_info = self.entity_zero
compile_state.extra_criteria_entities[ext_info] = (
ext_info,
ext_info._adapter if ext_info.is_aliased_class else None,
)
loading._setup_entity_query(
compile_state,
self.mapper,
self,
self.path,
adapter,
compile_state.primary_columns,
with_polymorphic=self._with_polymorphic_mappers,
only_load_props=compile_state.compile_options._only_load_props,
polymorphic_discriminator=self._polymorphic_discriminator,
)
compile_state._fallback_from_clauses.append(self.selectable)
class _BundleEntity(_QueryEntity):
_extra_entities = ()
__slots__ = (
"bundle",
"expr",
"type",
"_label_name",
"_entities",
"supports_single_entity",
)
_entities: List[_QueryEntity]
bundle: Bundle
type: Type[Any]
_label_name: str
supports_single_entity: bool
expr: Bundle
def __init__(
self,
compile_state,
expr,
entities_collection,
is_current_entities,
setup_entities=True,
parent_bundle=None,
):
compile_state._has_orm_entities = True
expr = expr._annotations["bundle"]
if parent_bundle:
parent_bundle._entities.append(self)
else:
entities_collection.append(self)
if isinstance(
expr, (attributes.QueryableAttribute, interfaces.PropComparator)
):
bundle = expr.__clause_element__()
else:
bundle = expr
self.bundle = self.expr = bundle
self.type = type(bundle)
self._label_name = bundle.name
self._entities = []
if setup_entities:
for expr in bundle.exprs:
if "bundle" in expr._annotations:
_BundleEntity(
compile_state,
expr,
entities_collection,
is_current_entities,
parent_bundle=self,
)
elif isinstance(expr, Bundle):
_BundleEntity(
compile_state,
expr,
entities_collection,
is_current_entities,
parent_bundle=self,
)
else:
_ORMColumnEntity._for_columns(
compile_state,
[expr],
entities_collection,
None,
is_current_entities,
parent_bundle=self,
)
self.supports_single_entity = self.bundle.single_entity
@property
def mapper(self):
ezero = self.entity_zero
if ezero is not None:
return ezero.mapper
else:
return None
@property
def entity_zero(self):
for ent in self._entities:
ezero = ent.entity_zero
if ezero is not None:
return ezero
else:
return None
def corresponds_to(self, entity):
# TODO: we might be able to implement this but for now
# we are working around it
return False
@property
def entity_zero_or_selectable(self):
for ent in self._entities:
ezero = ent.entity_zero_or_selectable
if ezero is not None:
return ezero
else:
return None
def setup_compile_state(self, compile_state):
for ent in self._entities:
ent.setup_compile_state(compile_state)
def setup_dml_returning_compile_state(
self,
compile_state: ORMCompileState,
adapter: DMLReturningColFilter,
) -> None:
return self.setup_compile_state(compile_state)
def row_processor(self, context, result):
procs, labels, extra = zip(
*[ent.row_processor(context, result) for ent in self._entities]
)
proc = self.bundle.create_row_processor(context.query, procs, labels)
return proc, self._label_name, self._extra_entities
class _ColumnEntity(_QueryEntity):
__slots__ = (
"_fetch_column",
"_row_processor",
"raw_column_index",
"translate_raw_column",
)
@classmethod
def _for_columns(
cls,
compile_state,
columns,
entities_collection,
raw_column_index,
is_current_entities,
parent_bundle=None,
):
for column in columns:
annotations = column._annotations
if "parententity" in annotations:
_entity = annotations["parententity"]
else:
_entity = sql_util.extract_first_column_annotation(
column, "parententity"
)
if _entity:
if "identity_token" in column._annotations:
_IdentityTokenEntity(
compile_state,
column,
entities_collection,
_entity,
raw_column_index,
is_current_entities,
parent_bundle=parent_bundle,
)
else:
_ORMColumnEntity(
compile_state,
column,
entities_collection,
_entity,
raw_column_index,
is_current_entities,
parent_bundle=parent_bundle,
)
else:
_RawColumnEntity(
compile_state,
column,
entities_collection,
raw_column_index,
is_current_entities,
parent_bundle=parent_bundle,
)
@property
def type(self):
return self.column.type
@property
def _non_hashable_value(self):
return not self.column.type.hashable
@property
def _null_column_type(self):
return self.column.type._isnull
def row_processor(self, context, result):
compile_state = context.compile_state
# the resulting callable is entirely cacheable so just return
# it if we already made one
if self._row_processor is not None:
getter, label_name, extra_entities = self._row_processor
if self.translate_raw_column:
extra_entities += (
context.query._raw_columns[self.raw_column_index],
)
return getter, label_name, extra_entities
# retrieve the column that would have been set up in
# setup_compile_state, to avoid doing redundant work
if self._fetch_column is not None:
column = self._fetch_column
else:
# fetch_column will be None when we are doing a from_statement
# and setup_compile_state may not have been called.
column = self.column
# previously, the RawColumnEntity didn't look for from_obj_alias
# however I can't think of a case where we would be here and
# we'd want to ignore it if this is the from_statement use case.
# it's not really a use case to have raw columns + from_statement
if compile_state._from_obj_alias:
column = compile_state._from_obj_alias.columns[column]
if column._annotations:
# annotated columns perform more slowly in compiler and
# result due to the __eq__() method, so use deannotated
column = column._deannotate()
if compile_state.compound_eager_adapter:
column = compile_state.compound_eager_adapter.columns[column]
getter = result._getter(column)
ret = getter, self._label_name, self._extra_entities
self._row_processor = ret
if self.translate_raw_column:
extra_entities = self._extra_entities + (
context.query._raw_columns[self.raw_column_index],
)
return getter, self._label_name, extra_entities
else:
return ret
class _RawColumnEntity(_ColumnEntity):
entity_zero = None
mapper = None
supports_single_entity = False
__slots__ = (
"expr",
"column",
"_label_name",
"entity_zero_or_selectable",
"_extra_entities",
)
def __init__(
self,
compile_state,
column,
entities_collection,
raw_column_index,
is_current_entities,
parent_bundle=None,
):
self.expr = column
self.raw_column_index = raw_column_index
self.translate_raw_column = raw_column_index is not None
if column._is_star:
compile_state.compile_options += {"_is_star": True}
if not is_current_entities or column._is_text_clause:
self._label_name = None
else:
if parent_bundle:
self._label_name = column._proxy_key
else:
self._label_name = compile_state._label_convention(column)
if parent_bundle:
parent_bundle._entities.append(self)
else:
entities_collection.append(self)
self.column = column
self.entity_zero_or_selectable = (
self.column._from_objects[0] if self.column._from_objects else None
)
self._extra_entities = (self.expr, self.column)
self._fetch_column = self._row_processor = None
def corresponds_to(self, entity):
return False
def setup_dml_returning_compile_state(
self,
compile_state: ORMCompileState,
adapter: DMLReturningColFilter,
) -> None:
return self.setup_compile_state(compile_state)
def setup_compile_state(self, compile_state):
current_adapter = compile_state._get_current_adapter()
if current_adapter:
column = current_adapter(self.column, False)
if column is None:
return
else:
column = self.column
if column._annotations:
# annotated columns perform more slowly in compiler and
# result due to the __eq__() method, so use deannotated
column = column._deannotate()
compile_state.dedupe_columns.add(column)
compile_state.primary_columns.append(column)
self._fetch_column = column
class _ORMColumnEntity(_ColumnEntity):
"""Column/expression based entity."""
supports_single_entity = False
__slots__ = (
"expr",
"mapper",
"column",
"_label_name",
"entity_zero_or_selectable",
"entity_zero",
"_extra_entities",
)
def __init__(
self,
compile_state,
column,
entities_collection,
parententity,
raw_column_index,
is_current_entities,
parent_bundle=None,
):
annotations = column._annotations
_entity = parententity
# an AliasedClass won't have proxy_key in the annotations for
# a column if it was acquired using the class' adapter directly,
# such as using AliasedInsp._adapt_element(). this occurs
# within internal loaders.
orm_key = annotations.get("proxy_key", None)
proxy_owner = annotations.get("proxy_owner", _entity)
if orm_key:
self.expr = getattr(proxy_owner.entity, orm_key)
self.translate_raw_column = False
else:
# if orm_key is not present, that means this is an ad-hoc
# SQL ColumnElement, like a CASE() or other expression.
# include this column position from the invoked statement
# in the ORM-level ResultSetMetaData on each execute, so that
# it can be targeted by identity after caching
self.expr = column
self.translate_raw_column = raw_column_index is not None
self.raw_column_index = raw_column_index
if is_current_entities:
if parent_bundle:
self._label_name = orm_key if orm_key else column._proxy_key
else:
self._label_name = compile_state._label_convention(
column, col_name=orm_key
)
else:
self._label_name = None
_entity._post_inspect
self.entity_zero = self.entity_zero_or_selectable = ezero = _entity
self.mapper = mapper = _entity.mapper
if parent_bundle:
parent_bundle._entities.append(self)
else:
entities_collection.append(self)
compile_state._has_orm_entities = True
self.column = column
self._fetch_column = self._row_processor = None
self._extra_entities = (self.expr, self.column)
if mapper._should_select_with_poly_adapter:
compile_state._create_with_polymorphic_adapter(
ezero, ezero.selectable
)
def corresponds_to(self, entity):
if _is_aliased_class(entity):
# TODO: polymorphic subclasses ?
return entity is self.entity_zero
else:
return not _is_aliased_class(
self.entity_zero
) and entity.common_parent(self.entity_zero)
def setup_dml_returning_compile_state(
self,
compile_state: ORMCompileState,
adapter: DMLReturningColFilter,
) -> None:
self._fetch_column = self.column
column = adapter(self.column, False)
if column is not None:
compile_state.dedupe_columns.add(column)
compile_state.primary_columns.append(column)
def setup_compile_state(self, compile_state):
current_adapter = compile_state._get_current_adapter()
if current_adapter:
column = current_adapter(self.column, False)
if column is None:
assert compile_state.is_dml_returning
self._fetch_column = self.column
return
else:
column = self.column
ezero = self.entity_zero
single_table_crit = self.mapper._single_table_criterion
if (
single_table_crit is not None
or ("additional_entity_criteria", self.mapper)
in compile_state.global_attributes
):
compile_state.extra_criteria_entities[ezero] = (
ezero,
ezero._adapter if ezero.is_aliased_class else None,
)
if column._annotations and not column._expression_label:
# annotated columns perform more slowly in compiler and
# result due to the __eq__() method, so use deannotated
column = column._deannotate()
# use entity_zero as the from if we have it. this is necessary
# for polymorphic scenarios where our FROM is based on ORM entity,
# not the FROM of the column. but also, don't use it if our column
# doesn't actually have any FROMs that line up, such as when its
# a scalar subquery.
if set(self.column._from_objects).intersection(
ezero.selectable._from_objects
):
compile_state._fallback_from_clauses.append(ezero.selectable)
compile_state.dedupe_columns.add(column)
compile_state.primary_columns.append(column)
self._fetch_column = column
class _IdentityTokenEntity(_ORMColumnEntity):
translate_raw_column = False
def setup_compile_state(self, compile_state):
pass
def row_processor(self, context, result):
def getter(row):
return context.load_options._identity_token
return getter, self._label_name, self._extra_entities