from .session import Session, sessionmaker
from .scoping import scoped_session
from .attributes import QueryableAttribute
-from . import mapper as mapperfunc
class InstrumentationEvents(event.Events):
"""Events related to class instrumentation events.
if util.py2k:
return dict.values(self)
else:
- return list(dict.values(self))
+ return list(dict.values(self))
def discard(self, state):
st = dict.get(self, state.key, None)
from . import exc, collections, interfaces, state
-from .. import event, util
+from .. import util
from . import base
class ClassManager(dict):
"""
return [
{
- 'name':ent._label_name,
- 'type':ent.type,
- 'aliased':getattr(ent, 'is_aliased_class', False),
- 'expr':ent.expr
+ 'name': ent._label_name,
+ 'type': ent.type,
+ 'aliased': getattr(ent, 'is_aliased_class', False),
+ 'expr': ent.expr
}
for ent in self._entities
]
return entity.common_parent(self.entity_zero)
- #_adapted_selectable = None
def adapt_to_selectable(self, query, sel):
query._entities.append(self)
- # self._adapted_selectable = sel
def _get_entity_clauses(self, query, context):
import weakref
-from .. import util, sql, engine, exc as sa_exc, event
+from .. import util, sql, engine, exc as sa_exc
from ..sql import util as sql_util, expression
from . import (
SessionExtension, attributes, exc, query,
_none_set, state_str, instance_str
)
from .unitofwork import UOWTransaction
-#from .events import SessionEvents
from . import state as statelib
import sys
collections = path.get(context.attributes, "collections")
if collections is None:
collections = dict(
- (k, [v[0] for v in v])
+ (k, [vv[0] for vv in v])
for k, v in itertools.groupby(
subq,
lambda x: x[1:]
self.lazy = lazy
self.chained = chained
self.propagate_to_loaders = propagate_to_loaders
- #self.strategy_cls = properties.RelationshipProperty._strategy_lookup(lazy=lazy)
- self.strategy_cls = factory(lazy)
+ self.strategy_cls = properties.RelationshipProperty._strategy_lookup(lazy=lazy)
def get_strategy_class(self):
return self.strategy_cls
-_factory = {
- False: JoinedLoader,
- "joined": JoinedLoader,
- None: NoLoader,
- "noload": NoLoader,
- "select": LazyLoader,
- True: LazyLoader,
- "subquery": SubqueryLoader,
- "immediate": ImmediateLoader
-}
-
-
-def factory(identifier):
- return _factory.get(identifier, LazyLoader)
-
class EagerJoinOption(PropertyOption):
state_attribute_str, object_mapper, object_state, _none_set
from .base import class_mapper, _class_to_mapper
from .base import _InspectionAttr
+from .path_registry import PathRegistry
all_cascades = frozenset(("delete", "delete-orphan", "all", "merge",
"expunge", "save-update", "refresh-expire",
else:
return None
-from .path_registry import _unreduce_path, PathRegistry, RootRegistry, TokenRegistry, PropRegistry, EntityRegistry
-
class AliasedClass(object):
"""Represents an "aliased" form of a mapped class for usage with Query.
"""Collection classes and helpers."""
-import itertools
import weakref
import operator
from .compat import threading, itertools_filterfalse
self.impls[name] = impl.load
return impl.load()
- from sqlalchemy import exc
raise exc.ArgumentError(
"Can't load plugin: %s:%s" %
(self.group, name))
try:
+ # TODO: who doesn't have this constant?
from inspect import CO_VARKEYWORDS
def inspect_func_args(fn):
from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy.testing import eq_, is_
-from sqlalchemy.orm.util import PathRegistry
+from sqlalchemy.orm.path_registry import PathRegistry, RootRegistry
from sqlalchemy import inspect
class AliasedClassTest(fixtures.TestBase):
def test_root_registry(self):
umapper = inspect(self.classes.User)
is_(
- orm_util.RootRegistry()[umapper],
+ RootRegistry()[umapper],
umapper._path_registry
)
eq_(
- orm_util.RootRegistry()[umapper],
- orm_util.PathRegistry.coerce((umapper,))
+ RootRegistry()[umapper],
+ PathRegistry.coerce((umapper,))
)
def test_expand(self):