def test_load_many_to_one_self_refencing(self):
User = self.classes.User
session = fixture_session()
users = (
session.query(User)
.filter(self.tables.users.c.id.in_([8, 9, 10]))
.order_by(self.tables.users.c.id.asc())
.all()
)
self.queries = []
# make sure no relations are loaded
for user in users:
model_dict = attributes.instance_dict(user)
assert "parent" not in model_dict
# trigger a lazy load on the first user
users[0].parent
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
user1_dict = attributes.instance_dict(users[0])
user2_dict = attributes.instance_dict(users[1])
user3_dict = attributes.instance_dict(users[2])
assert User(id=7, name="jack", parent_id=None) == user1_dict["parent"]
assert User(id=7, name="jack", parent_id=None) == user2_dict["parent"]
assert User(id=8, name="jack jr", parent_id=7) == user3_dict["parent"]
# no new queries should have been generated
assert len(self.queries) == 0
def test_deferred(self):
for base in (object, MyBaseClass, MyClass):
class Foo(base):
pass
data = {'a': 'this is a', 'b': 12}
def loader(state, keys):
for k in keys:
state.dict[k] = data[k]
return attributes.ATTR_WAS_SET
manager = register_class(Foo)
manager.deferred_scalar_loader = loader
attributes.register_attribute(Foo,
'a',
uselist=False,
useobject=False)
attributes.register_attribute(Foo,
'b',
uselist=False,
useobject=False)
if base is object:
assert Foo not in instrumentation._instrumentation_factory._state_finders
else:
assert Foo in instrumentation._instrumentation_factory._state_finders
f = Foo()
attributes.instance_state(f)._expire(attributes.instance_dict(f),
set())
eq_(f.a, "this is a")
eq_(f.b, 12)
f.a = "this is some new a"
attributes.instance_state(f)._expire(attributes.instance_dict(f),
set())
eq_(f.a, "this is a")
eq_(f.b, 12)
attributes.instance_state(f)._expire(attributes.instance_dict(f),
set())
f.a = "this is another new a"
eq_(f.a, "this is another new a")
eq_(f.b, 12)
attributes.instance_state(f)._expire(attributes.instance_dict(f),
set())
eq_(f.a, "this is a")
eq_(f.b, 12)
del f.a
eq_(f.a, None)
eq_(f.b, 12)
attributes.instance_state(f)._commit_all(
attributes.instance_dict(f))
eq_(f.a, None)
eq_(f.b, 12)
def test_deferred(self):
for base in (object, MyBaseClass, MyClass):
class Foo(base):
pass
data = {'a': 'this is a', 'b': 12}
def loader(state, keys):
for k in keys:
state.dict[k] = data[k]
return attributes.ATTR_WAS_SET
manager = register_class(Foo)
manager.deferred_scalar_loader = loader
attributes.register_attribute(
Foo, 'a', uselist=False, useobject=False)
attributes.register_attribute(
Foo, 'b', uselist=False, useobject=False)
if base is object:
assert Foo not in \
instrumentation._instrumentation_factory._state_finders
else:
assert Foo in \
instrumentation._instrumentation_factory._state_finders
f = Foo()
attributes.instance_state(f)._expire(
attributes.instance_dict(f), set())
eq_(f.a, "this is a")
eq_(f.b, 12)
f.a = "this is some new a"
attributes.instance_state(f)._expire(
attributes.instance_dict(f), set())
eq_(f.a, "this is a")
eq_(f.b, 12)
attributes.instance_state(f)._expire(
attributes.instance_dict(f), set())
f.a = "this is another new a"
eq_(f.a, "this is another new a")
eq_(f.b, 12)
attributes.instance_state(f)._expire(
attributes.instance_dict(f), set())
eq_(f.a, "this is a")
eq_(f.b, 12)
del f.a
eq_(f.a, None)
eq_(f.b, 12)
attributes.instance_state(f)._commit_all(
attributes.instance_dict(f))
eq_(f.a, None)
eq_(f.b, 12)
def _get_similar_unpopulated_models(self, model, session):
"""
This finds all other models of this class in the session that also need to have this relationship lazyloaded
"""
model_class = model.__class__
dict_ = attributes.instance_dict(model)
similar_models = []
for possible_model in session.identity_map.values():
is_same_class = isinstance(possible_model, model_class)
is_not_new = possible_model not in session.new
if is_same_class and is_not_new and self.key not in attributes.instance_dict(
possible_model):
similar_models.append(possible_model)
return similar_models
def test_load_one_to_many(self):
User = self.classes.User
Address = self.classes.Address
session = fixture_session()
users = session.query(User).order_by(self.tables.users.c.id.asc()).all()
self.queries = []
# make sure no relations are loaded
for user in users:
model_dict = attributes.instance_dict(user)
assert "addresses" not in model_dict
# trigger a lazy load on the first user
users[0].addresses
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
user1_dict = attributes.instance_dict(users[0])
user2_dict = attributes.instance_dict(users[1])
user3_dict = attributes.instance_dict(users[2])
user4_dict = attributes.instance_dict(users[3])
assert [
Address(id=1, email_address="*****@*****.**", user_id=7),
] == user1_dict["addresses"]
assert [ # order is by email_address DESC
Address(id=2, email_address="*****@*****.**", user_id=8),
Address(id=4, email_address="*****@*****.**", user_id=8),
Address(id=3, email_address="*****@*****.**", user_id=8),
] == user2_dict["addresses"]
assert [
Address(id=5, email_address="*****@*****.**", user_id=9),
] == user3_dict["addresses"]
assert [] == user4_dict["addresses"]
# backrefs should also not trigger loading
for address in users[0].addresses:
assert address.user == users[0]
for address in users[1].addresses:
assert address.user == users[1]
for address in users[2].addresses:
assert address.user == users[2]
# no new queries should have been generated
assert len(self.queries) == 0
def test_basic(self):
for base in (object, MyBaseClass, MyClass):
class User(base):
pass
register_class(User)
attributes.register_attribute(
User, 'user_id', uselist=False, useobject=False)
attributes.register_attribute(
User, 'user_name', uselist=False, useobject=False)
attributes.register_attribute(
User, 'email_address', uselist=False, useobject=False)
u = User()
u.user_id = 7
u.user_name = 'john'
u.email_address = '*****@*****.**'
eq_(u.user_id, 7)
eq_(u.user_name, "john")
eq_(u.email_address, "*****@*****.**")
attributes.instance_state(u)._commit_all(
attributes.instance_dict(u))
eq_(u.user_id, 7)
eq_(u.user_name, "john")
eq_(u.email_address, "*****@*****.**")
u.user_name = 'heythere'
u.email_address = '*****@*****.**'
eq_(u.user_id, 7)
eq_(u.user_name, "heythere")
eq_(u.email_address, "*****@*****.**")
def test_get_populated_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get(attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_RETURN_NEVER_SET),
User(name='ed'))
def replicate_relation(source, target, attr, target_attr, cache=None):
if attr.property.cascade.delete_orphan:
process_scalar = replicate_no_merge
process_list = replicate_filter
else:
process_scalar = reflect
process_list = reflect_filter
value = getattr(source, attr.key)
target_attr_model = target_attr.property.mapper.class_
if attr.property.uselist:
adapter = collection_adapter(value)
if adapter:
# Convert any collection to flat iterable
value = adapter.adapt_like_to_iterable(value)
reflection = process_list(value, target_attr_model, cache=cache)
impl = instance_state(target).get_impl(attr.key)
# Set any collection value from flat list
impl._set_iterable(instance_state(target),
instance_dict(target),
reflection)
else:
reflection = process_scalar(value, target_attr_model, cache=cache)
setattr(target, attr.key, reflection)
if (reflection is None and
attr.property.direction is MANYTOONE and
any(col.primary_key and not col.nullable
for col in attr.property.local_columns)):
raise _PrimaryKeyIsNull()
def replicate_relation(source, target, attr, target_attr, cache=None):
if attr.property.cascade.delete_orphan:
process_scalar = replicate_no_merge
process_list = replicate_filter
else:
process_scalar = reflect
process_list = reflect_filter
value = getattr(source, attr.key)
target_attr_model = target_attr.property.mapper.class_
if attr.property.uselist:
adapter = collection_adapter(value)
if adapter:
# XXX The magic passes below are adapted from logic in
# CollectionAttributeImpl.set() method without proper
# understanding. The `elif` branch isn't even coverered by tests.
if hasattr(value, '_sa_iterator'):
value = value._sa_iterator()
elif duck_type_collection(value) is dict:
value = value.values()
reflection = process_list(value, target_attr_model, cache=cache)
impl = instance_state(target).get_impl(attr.key)
impl.set(instance_state(target), instance_dict(target), reflection,
# XXX We either have to convert reflection back to original
# collection type or use this private parameter.
_adapt=False)
else:
reflection = process_scalar(value, target_attr_model, cache=cache)
setattr(target, attr.key, reflection)
if (reflection is None and
attr.property.direction is MANYTOONE and
any(col.primary_key and not col.nullable
for col in attr.property.local_columns)):
raise _PrimaryKeyIsNull()
def replicate_relation(source, target, attr, target_attr, cache=None):
if attr.property.cascade.delete_orphan:
process_scalar = replicate_no_merge
process_list = replicate_filter
else:
process_scalar = reflect
process_list = reflect_filter
value = getattr(source, attr.key)
target_attr_model = target_attr.property.mapper.class_
if attr.property.uselist:
adapter = collection_adapter(value)
if adapter:
# XXX The magic passes below are adapted from logic in
# CollectionAttributeImpl.set() method without proper
# understanding. The `elif` branch isn't even coverered by tests.
if hasattr(value, '_sa_iterator'):
value = value._sa_iterator()
elif duck_type_collection(value) is dict:
value = value.values()
reflection = process_list(value, target_attr_model, cache=cache)
impl = instance_state(target).get_impl(attr.key)
impl.set(
instance_state(target),
instance_dict(target),
reflection,
# XXX We either have to convert reflection back to original
# collection type or use this private parameter.
_adapt=False)
else:
reflection = process_scalar(value, target_attr_model, cache=cache)
setattr(target, attr.key, reflection)
if (reflection is None and attr.property.direction is MANYTOONE
and any(col.primary_key and not col.nullable
for col in attr.property.local_columns)):
raise _PrimaryKeyIsNull()
def getMessageByHash(self, message_hash):
"""Get a message for a given hash."""
try:
result = self.session.query(Messages).filter(Messages.message_hash == message_hash).one()
return instance_dict(result)
except NoResultFound, e:
return None
def lazy_clause(self,
state,
reverse_direction=False,
alias_secondary=False,
adapt_source=None,
detect_transient_pending=False):
if state is None:
return self._lazy_none_clause(reverse_direction,
adapt_source=adapt_source)
if not reverse_direction:
criterion, bind_to_col, rev = \
self.__lazywhere, \
self.__bind_to_col, \
self._equated_columns
else:
criterion, bind_to_col, rev = \
LazyLoader._create_lazy_clause(
self.parent_property,
reverse_direction=reverse_direction)
if reverse_direction:
mapper = self.parent_property.mapper
else:
mapper = self.parent_property.parent
o = state.obj() # strong ref
dict_ = attributes.instance_dict(o)
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
# using a flag to enable "detect transient pending" so that
# the slightly different usage paradigm of "dynamic" loaders
# continue to work as expected, i.e. that all pending objects
# should use the "post flush" attributes, and to limit this
# newer behavior to the query.with_parent() method.
# It would be nice to do away with this flag.
if detect_transient_pending and \
(not state.key or not state.session_id):
bindparam.value = mapper._get_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
else:
# send value as a lambda so that the value is
# acquired after any autoflush occurs.
bindparam.value = \
lambda: mapper._get_committed_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
if self.parent_property.secondary is not None and alias_secondary:
criterion = sql_util.ClauseAdapter(
self.parent_property.secondary.alias()).\
traverse(criterion)
criterion = visitors.cloned_traverse(criterion, {},
{'bindparam': visit_bindparam})
if adapt_source:
criterion = adapt_source(criterion)
return criterion
def fdel(instance):
state = attributes.instance_state(instance)
dict_ = attributes.instance_dict(instance)
previous = dict_.pop(self.key, attributes.NO_VALUE)
attr = state.manager[self.key]
attr.dispatch.remove(state, previous, attr.impl)
for key in self._attribute_keys:
setattr(instance, key, None)
def test_history_populated_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1), attributes.instance_dict(a1), passive=attributes.PASSIVE_RETURN_NEVER_SET
),
((), [User(name="ed")], ()),
)
def fdel(instance):
state = attributes.instance_state(instance)
dict_ = attributes.instance_dict(instance)
previous = dict_.pop(self.key, attributes.NO_VALUE)
attr = state.manager[self.key]
attr.dispatch.remove(state, previous, attr.impl)
for key in self._attribute_keys:
setattr(instance, key, None)
def cache_detail_key(self, data=None):
if not hasattr(self._meta, 'cache_detail_keys'):
raise Exception('Class meta has no cache_detail_keys')
if not has_identity(self):
raise Exception('Cannot generate detail cache key for instance ' \
'with no identity')
data = data or instance_dict(self)
raw_key, attrs = self._meta.cache_detail_keys[0]
return self.format_key(raw_key % data)
def cache_list_version_key(self, data=None):
if not self._meta.cache_list_keys:
raise Exception('Class._meta has no cache_list_keys')
if not has_identity(self):
raise Exception('Cannot generate list cache key for instance ' \
'with no identity')
data = data or instance_dict(self)
raw_key, attrs = self._meta.cache_list_keys[0]
return raw_key % data
def test_history_empty_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_RETURN_NEVER_SET), ((), (), ()))
assert 'user_id' not in a1.__dict__
assert 'user' not in a1.__dict__
def test_get_populated_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get(attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_NO_INITIALIZE),
attributes.PASSIVE_NO_RESULT)
assert 'user_id' not in a1.__dict__
assert 'user' not in a1.__dict__
def lazy_clause(self,
state,
reverse_direction=False,
alias_secondary=False,
adapt_source=None):
if state is None:
return self._lazy_none_clause(reverse_direction,
adapt_source=adapt_source)
if not reverse_direction:
criterion, bind_to_col, rev = \
self.__lazywhere, \
self.__bind_to_col, \
self._equated_columns
else:
criterion, bind_to_col, rev = \
LazyLoader._create_lazy_clause(
self.parent_property,
reverse_direction=reverse_direction)
if reverse_direction:
mapper = self.parent_property.mapper
else:
mapper = self.parent_property.parent
o = state.obj() # strong ref
dict_ = attributes.instance_dict(o)
# use the "committed state" only if we're in a flush
# for this state.
sess = sessionlib._state_session(state)
if sess is not None and sess._flushing:
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
bindparam.callable = \
lambda: mapper._get_committed_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
else:
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
bindparam.callable = lambda: mapper._get_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
if self.parent_property.secondary is not None and alias_secondary:
criterion = sql_util.ClauseAdapter(
self.parent_property.secondary.alias()).\
traverse(criterion)
criterion = visitors.cloned_traverse(criterion, {},
{'bindparam': visit_bindparam})
if adapt_source:
criterion = adapt_source(criterion)
return criterion
def test_load_one_to_many_self_refencing(self):
User = self.classes.User
session = fixture_session()
users = (
session.query(User)
.filter(self.tables.users.c.id.in_([7, 8]))
.order_by(self.tables.users.c.id.asc())
.all()
)
self.queries = []
# make sure no relations are loaded
for user in users:
model_dict = attributes.instance_dict(user)
assert "children" not in model_dict
# trigger a lazy load on the first user
users[0].children
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
user1_dict = attributes.instance_dict(users[0])
user2_dict = attributes.instance_dict(users[1])
assert [
User(id=8, name="jack jr", parent_id=7),
User(id=9, name="fred", parent_id=7),
] == user1_dict["children"]
assert [
User(id=10, name="jack jr jr", parent_id=8),
] == user2_dict["children"]
# backrefs should also not trigger loading
for child in users[0].children:
assert child.parent == users[0]
for child in users[1].children:
assert child.parent == users[1]
# no new queries should have been generated
assert len(self.queries) == 0
def cache_pointers(self, data=None, columns=[]):
if not hasattr(self._meta, 'cache_pointers'):
return {}
data = data or instance_dict(self)
keys = {}
for raw_key, attrs, name in self._meta.cache_pointers:
if columns and not any(c in attrs for c in columns):
continue
keys[name] = raw_key % data
return keys
def cache_pointers(self, data=None, columns=[]):
if not hasattr(self._meta, 'cache_pointers'):
return {}
data = data or instance_dict(self)
keys = {}
for raw_key, attrs, name in self._meta.cache_pointers:
if columns and not any(c in attrs for c in columns):
continue
keys[name] = raw_key % data
return keys
def test_get_populated_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_RETURN_NO_VALUE,
),
User(name="ed"),
)
def test_history_empty_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_NO_INITIALIZE),
attributes.HISTORY_BLANK)
assert 'user_id' not in a1.__dict__
assert 'user' not in a1.__dict__
def test_get_empty_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get(
attributes.instance_state(a1), attributes.instance_dict(a1), passive=attributes.PASSIVE_NO_INITIALIZE
),
attributes.PASSIVE_NO_RESULT,
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def test_history_populated_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1), attributes.instance_dict(a1), passive=attributes.PASSIVE_NO_INITIALIZE
),
attributes.HISTORY_BLANK,
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def test_history_populated_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_RETURN_NO_VALUE,
),
((), [User(name="ed")], ()),
)
def test_history_empty_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1), attributes.instance_dict(a1), passive=attributes.PASSIVE_RETURN_NEVER_SET
),
((), (), ()),
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def lazy_clause(self, state, reverse_direction=False,
alias_secondary=False,
adapt_source=None):
if state is None:
return self._lazy_none_clause(
reverse_direction,
adapt_source=adapt_source)
if not reverse_direction:
criterion, bind_to_col, rev = \
self.__lazywhere, \
self.__bind_to_col, \
self._equated_columns
else:
criterion, bind_to_col, rev = \
LazyLoader._create_lazy_clause(
self.parent_property,
reverse_direction=reverse_direction)
if reverse_direction:
mapper = self.parent_property.mapper
else:
mapper = self.parent_property.parent
o = state.obj() # strong ref
dict_ = attributes.instance_dict(o)
# use the "committed state" only if we're in a flush
# for this state.
sess = sessionlib._state_session(state)
if sess is not None and sess._flushing:
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
bindparam.callable = \
lambda: mapper._get_committed_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
else:
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
bindparam.callable = lambda: mapper._get_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key])
if self.parent_property.secondary is not None and alias_secondary:
criterion = sql_util.ClauseAdapter(
self.parent_property.secondary.alias()).\
traverse(criterion)
criterion = visitors.cloned_traverse(
criterion, {}, {'bindparam':visit_bindparam})
if adapt_source:
criterion = adapt_source(criterion)
return criterion
def test_load_one_to_one(self):
User = self.classes.User
UserInfo = self.classes.UserInfo
session = fixture_session()
users = session.query(User).order_by(self.tables.users.c.id.asc()).all()
self.queries = []
# make sure no relations are loaded
for user in users:
model_dict = attributes.instance_dict(user)
assert "user_info" not in model_dict
# trigger a lazy load on the first user
users[0].user_info
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
user1_dict = attributes.instance_dict(users[0])
user2_dict = attributes.instance_dict(users[1])
user3_dict = attributes.instance_dict(users[2])
user4_dict = attributes.instance_dict(users[3])
assert UserInfo(id=1, details="is cool", user_id=7) == user1_dict["user_info"]
assert (
UserInfo(id=2, details="is not cool", user_id=8) == user2_dict["user_info"]
)
assert user3_dict["user_info"] is None
assert (
UserInfo(id=3, details="is moderately cool", user_id=10)
== user4_dict["user_info"]
)
# backrefs should also not trigger loading
assert users[0].user_info.user == users[0]
assert users[1].user_info.user == users[1]
assert users[3].user_info.user == users[3]
# no new queries should have been generated
assert len(self.queries) == 0
def test_get_populated_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_NO_INITIALIZE),
attributes.PASSIVE_NO_RESULT
)
assert 'user_id' not in a1.__dict__
assert 'user' not in a1.__dict__
def test_load_many_to_many(self):
User = self.classes.User
Thing = self.classes.Thing
session = fixture_session()
users = session.query(User).order_by(self.tables.users.c.id.asc()).all()
self.queries = []
# make sure no relations are loaded
for user in users:
model_dict = attributes.instance_dict(user)
assert "things" not in model_dict
# trigger a lazy load on the first user
users[0].things
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
user1_dict = attributes.instance_dict(users[0])
user2_dict = attributes.instance_dict(users[1])
user3_dict = attributes.instance_dict(users[2])
user4_dict = attributes.instance_dict(users[3])
assert [
Thing(id=1, name="dog"),
] == user1_dict["things"]
assert [
Thing(id=1, name="dog"),
] == user2_dict["things"]
assert [
Thing(id=2, name="lamp"),
] == user3_dict["things"]
assert [
Thing(id=2, name="lamp"),
Thing(id=3, name="chair"),
] == user4_dict["things"]
# no new queries should have been generated
assert len(self.queries) == 0
def test_get_empty_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_NO_INITIALIZE,
),
attributes.PASSIVE_NO_RESULT,
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def test_history_populated_passive_no_initialize(self):
User, Address, sess, a1 = self._u_ad_fixture(True)
eq_(
Address.user.impl.get_history(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_NO_INITIALIZE,
),
attributes.HISTORY_BLANK,
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def test_get_empty_passive_return_never_set(self):
User, Address, sess, a1 = self._u_ad_fixture(False)
eq_(
Address.user.impl.get(
attributes.instance_state(a1),
attributes.instance_dict(a1),
passive=attributes.PASSIVE_RETURN_NO_VALUE,
),
attributes.NO_VALUE,
)
assert "user_id" not in a1.__dict__
assert "user" not in a1.__dict__
def blacklist(self, limit = None):
"""Return blacklisted items in the database, with optional limit."""
if (limit is not None):
rows = self.session.query(Messages).filter(Messages.message_blacklist == True).order_by(desc(Messages.message_priority)).order_by(desc(Messages.message_received_timestamp)).all()[0:limit]
else:
rows = self.session.query(Messages).filter(Messages.message_blacklist == True).order_by(desc(Messages.message_priority)).order_by(desc(Messages.message_received_timestamp)).all()
results = []
for row in rows:
results.append(instance_dict(row))
return results
def test_load_many_to_one(self):
User = self.classes.User
Address = self.classes.Address
session = create_session()
addresses = session.query(Address).order_by(self.tables.addresses.c.id.asc()).all()
self.queries = []
# make sure no relations are loaded
for address in addresses:
model_dict = attributes.instance_dict(address)
assert 'user' not in model_dict
# trigger a lazy load on the first user
addresses[0].user
# only 1 query should have been generated to load all the child relationships
assert len(self.queries) == 1
self.queries = []
address1_dict = attributes.instance_dict(addresses[0])
address2_dict = attributes.instance_dict(addresses[1])
address3_dict = attributes.instance_dict(addresses[2])
address4_dict = attributes.instance_dict(addresses[3])
address5_dict = attributes.instance_dict(addresses[4])
assert User(id=7, name='jack', parent_id=None) == address1_dict['user']
assert User(id=8, name='jack jr', parent_id=7) == address2_dict['user']
assert User(id=8, name='jack jr', parent_id=7) == address3_dict['user']
assert User(id=8, name='jack jr', parent_id=7) == address4_dict['user']
assert User(id=9, name='fred', parent_id=7) == address5_dict['user']
# no new queries should have been generated
assert len(self.queries) == 0
def _get_model_value(self, model, mapper, col, passive):
state = inspect(model)
dict_ = attributes.instance_dict(model)
# not sure what this means, taken from LazyLoader#_generate_lazy_clause
if passive & attributes.INIT_OK:
passive ^= attributes.INIT_OK
# adapted from LazyLoader#_generate_lazy_clause
if passive and passive & attributes.LOAD_AGAINST_COMMITTED:
return mapper._get_committed_state_attr_by_column(
state, dict_, col, passive)
return mapper._get_state_attr_by_column(state, dict_, col, passive)
def test_history(self):
for base in (object, MyBaseClass, MyClass):
class Foo(base):
pass
class Bar(base):
pass
attributes.register_class(Foo)
attributes.register_class(Bar)
attributes.register_attribute(Foo, "name", uselist=False, useobject=False)
attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True)
attributes.register_attribute(Bar, "name", uselist=False, useobject=False)
f1 = Foo()
f1.name = 'f1'
eq_(attributes.get_history(attributes.instance_state(f1), 'name'), (['f1'], (), ()))
b1 = Bar()
b1.name = 'b1'
f1.bars.append(b1)
eq_(attributes.get_history(attributes.instance_state(f1), 'bars'), ([b1], [], []))
attributes.instance_state(f1).commit_all(attributes.instance_dict(f1))
attributes.instance_state(b1).commit_all(attributes.instance_dict(b1))
eq_(attributes.get_history(attributes.instance_state(f1), 'name'), ((), ['f1'], ()))
eq_(attributes.get_history(attributes.instance_state(f1), 'bars'), ((), [b1], ()))
f1.name = 'f1mod'
b2 = Bar()
b2.name = 'b2'
f1.bars.append(b2)
eq_(attributes.get_history(attributes.instance_state(f1), 'name'), (['f1mod'], (), ['f1']))
eq_(attributes.get_history(attributes.instance_state(f1), 'bars'), ([b2], [b1], []))
f1.bars.remove(b1)
eq_(attributes.get_history(attributes.instance_state(f1), 'bars'), ([b2], [], [b1]))
def test_history(self):
for base in (object, MyBaseClass, MyClass):
class Foo(base):
pass
class Bar(base):
pass
attributes.register_class(Foo)
attributes.register_class(Bar)
attributes.register_attribute(Foo, "name", uselist=False, useobject=False)
attributes.register_attribute(Foo, "bars", uselist=True, trackparent=True, useobject=True)
attributes.register_attribute(Bar, "name", uselist=False, useobject=False)
f1 = Foo()
f1.name = 'f1'
eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), (['f1'], (), ()))
b1 = Bar()
b1.name = 'b1'
f1.bars.append(b1)
eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b1], [], []))
attributes.instance_state(f1).commit_all(attributes.instance_dict(f1))
attributes.instance_state(b1).commit_all(attributes.instance_dict(b1))
eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), ((), ['f1'], ()))
eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ((), [b1], ()))
f1.name = 'f1mod'
b2 = Bar()
b2.name = 'b2'
f1.bars.append(b2)
eq_(attributes.get_state_history(attributes.instance_state(f1), 'name'), (['f1mod'], (), ['f1']))
eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b2], [b1], []))
f1.bars.remove(b1)
eq_(attributes.get_state_history(attributes.instance_state(f1), 'bars'), ([b2], [], [b1]))
def fset(instance, value):
dict_ = attributes.instance_dict(instance)
state = attributes.instance_state(instance)
attr = state.manager[self.key]
previous = dict_.get(self.key, attributes.NO_VALUE)
for fn in attr.dispatch.set:
value = fn(state, value, previous, attr.impl)
dict_[self.key] = value
if value is None:
for key in self._attribute_keys:
setattr(instance, key, None)
else:
for key, value in zip(self._attribute_keys,
value.__composite_values__()):
setattr(instance, key, value)
def fset(instance, value):
dict_ = attributes.instance_dict(instance)
state = attributes.instance_state(instance)
attr = state.manager[self.key]
previous = dict_.get(self.key, attributes.NO_VALUE)
for fn in attr.dispatch.set:
value = fn(state, value, previous, attr.impl)
dict_[self.key] = value
if value is None:
for key in self._attribute_keys:
setattr(instance, key, None)
else:
for key, value in zip(
self._attribute_keys,
value.__composite_values__()):
setattr(instance, key, value)
def fget(instance):
dict_ = attributes.instance_dict(instance)
if self.key not in dict_:
# key not present. Iterate through related
# attributes, retrieve their values. This
# ensures they all load.
values = [getattr(instance, key) for key in self._attribute_keys]
# usually, the load() event will have loaded our key
# at this point, unless we only loaded relationship()
# attributes above. Populate here if that's the case.
if self.key not in dict_ and not _none_set.issuperset(values):
dict_[self.key] = self.composite_class(*values)
return dict_.get(self.key, None)
def lazy_clause(
self, state, reverse_direction=False, alias_secondary=False, adapt_source=None, detect_transient_pending=False
):
if state is None:
return self._lazy_none_clause(reverse_direction, adapt_source=adapt_source)
if not reverse_direction:
criterion, bind_to_col, rev = self.__lazywhere, self.__bind_to_col, self._equated_columns
else:
criterion, bind_to_col, rev = LazyLoader._create_lazy_clause(
self.parent_property, reverse_direction=reverse_direction
)
if reverse_direction:
mapper = self.parent_property.mapper
else:
mapper = self.parent_property.parent
o = state.obj() # strong ref
dict_ = attributes.instance_dict(o)
def visit_bindparam(bindparam):
if bindparam.key in bind_to_col:
# using a flag to enable "detect transient pending" so that
# the slightly different usage paradigm of "dynamic" loaders
# continue to work as expected, i.e. that all pending objects
# should use the "post flush" attributes, and to limit this
# newer behavior to the query.with_parent() method.
# It would be nice to do away with this flag.
if detect_transient_pending and (not state.key or not state.session_id):
bindparam.value = mapper._get_state_attr_by_column(state, dict_, bind_to_col[bindparam.key])
else:
# send value as a lambda so that the value is
# acquired after any autoflush occurs.
bindparam.value = lambda: mapper._get_committed_state_attr_by_column(
state, dict_, bind_to_col[bindparam.key]
)
if self.parent_property.secondary is not None and alias_secondary:
criterion = sql_util.ClauseAdapter(self.parent_property.secondary.alias()).traverse(criterion)
criterion = visitors.cloned_traverse(criterion, {}, {"bindparam": visit_bindparam})
if adapt_source:
criterion = adapt_source(criterion)
return criterion
def highPriority(self, limit = None, includeBlacklist = False):
"""Return all of the items in the database, with optional limit."""
if (limit is not None):
if (includeBlacklist):
rows = self.session.query(Messages).filter(Messages.message_priority == 1).order_by(desc(Messages.message_received_timestamp)).all()[0:limit]
else:
rows = self.session.query(Messages).filter(Messages.message_priority == 1).filter(Messages.message_blacklist == False).order_by(desc(Messages.message_received_timestamp)).all()[0:limit]
else:
if (includeBlacklist):
rows = self.session.query(Messages).filter(Messages.message_priority == 1).order_by(desc(Messages.message_received_timestamp)).all()
else:
rows = self.session.query(Messages).filter(Messages.message_priority == 1).filter(Messages.message_blacklist == False).order_by(desc(Messages.message_received_timestamp)).all()
results = []
for row in rows:
results.append(instance_dict(row))
return results
def fget(instance):
dict_ = attributes.instance_dict(instance)
if self.key not in dict_:
# key not present. Iterate through related
# attributes, retrieve their values. This
# ensures they all load.
values = [
getattr(instance, key) for key in self._attribute_keys
]
# usually, the load() event will have loaded our key
# at this point, unless we only loaded relationship()
# attributes above. Populate here if that's the case.
if self.key not in dict_ and not _none_set.issuperset(values):
dict_[self.key] = self.composite_class(*values)
return dict_.get(self.key, None)
def test_basic(self):
for base in (object, MyBaseClass, MyClass):
class User(base):
pass
attributes.register_class(User)
attributes.register_attribute(User, 'user_id', uselist = False, useobject=False)
attributes.register_attribute(User, 'user_name', uselist = False, useobject=False)
attributes.register_attribute(User, 'email_address', uselist = False, useobject=False)
u = User()
u.user_id = 7
u.user_name = 'john'
u.email_address = '*****@*****.**'
self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**')
attributes.instance_state(u).commit_all(attributes.instance_dict(u))
self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**')
u.user_name = 'heythere'
u.email_address = '*****@*****.**'
self.assert_(u.user_id == 7 and u.user_name == 'heythere' and u.email_address == '*****@*****.**')
def test_basic(self):
for base in (object, MyBaseClass, MyClass):
class User(base):
pass
register_class(User)
attributes.register_attribute(User,
"user_id",
uselist=False,
useobject=False)
attributes.register_attribute(User,
"user_name",
uselist=False,
useobject=False)
attributes.register_attribute(User,
"email_address",
uselist=False,
useobject=False)
u = User()
u.user_id = 7
u.user_name = "john"
u.email_address = "*****@*****.**"
eq_(u.user_id, 7)
eq_(u.user_name, "john")
eq_(u.email_address, "*****@*****.**")
attributes.instance_state(u)._commit_all(
attributes.instance_dict(u))
eq_(u.user_id, 7)
eq_(u.user_name, "john")
eq_(u.email_address, "*****@*****.**")
u.user_name = "heythere"
u.email_address = "*****@*****.**"
eq_(u.user_id, 7)
eq_(u.user_name, "heythere")
eq_(u.email_address, "*****@*****.**")
def test_basic(self):
for base in (object, MyBaseClass, MyClass):
class User(base):
pass
attributes.register_class(User)
attributes.register_attribute(User, 'user_id', uselist = False, useobject=False)
attributes.register_attribute(User, 'user_name', uselist = False, useobject=False)
attributes.register_attribute(User, 'email_address', uselist = False, useobject=False)
u = User()
u.user_id = 7
u.user_name = 'john'
u.email_address = '*****@*****.**'
self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**')
attributes.instance_state(u).commit_all(attributes.instance_dict(u))
self.assert_(u.user_id == 7 and u.user_name == 'john' and u.email_address == '*****@*****.**')
u.user_name = 'heythere'
u.email_address = '*****@*****.**'
self.assert_(u.user_id == 7 and u.user_name == 'heythere' and u.email_address == '*****@*****.**')
def fget(instance):
dict_ = attributes.instance_dict(instance)
state = attributes.instance_state(instance)
if self.key not in dict_:
# key not present. Iterate through related
# attributes, retrieve their values. This
# ensures they all load.
values = [getattr(instance, key) for key in self._attribute_keys]
# current expected behavior here is that the composite is
# created on access if the object is persistent or if
# col attributes have non-None. This would be better
# if the composite were created unconditionally,
# but that would be a behavioral change.
if self.key not in dict_ and (
state.key is not None or
not _none_set.issuperset(values)
):
dict_[self.key] = self.composite_class(*values)
state.manager.dispatch.refresh(state, None, [self.key])
return dict_.get(self.key, None)
def test_history(self):
for base in (object, MyBaseClass, MyClass):
class Foo(base):
pass
class Bar(base):
pass
register_class(Foo)
register_class(Bar)
attributes.register_attribute(
Foo, "name", uselist=False, useobject=False
)
attributes.register_attribute(
Foo, "bars", uselist=True, trackparent=True, useobject=True
)
attributes.register_attribute(
Bar, "name", uselist=False, useobject=False
)
f1 = Foo()
f1.name = "f1"
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "name"
),
(["f1"], (), ()),
)
b1 = Bar()
b1.name = "b1"
f1.bars.append(b1)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "bars"
),
([b1], [], []),
)
attributes.instance_state(f1)._commit_all(
attributes.instance_dict(f1)
)
attributes.instance_state(b1)._commit_all(
attributes.instance_dict(b1)
)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "name"
),
((), ["f1"], ()),
)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "bars"
),
((), [b1], ()),
)
f1.name = "f1mod"
b2 = Bar()
b2.name = "b2"
f1.bars.append(b2)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "name"
),
(["f1mod"], (), ["f1"]),
)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "bars"
),
([b2], [b1], []),
)
f1.bars.remove(b1)
eq_(
attributes.get_state_history(
attributes.instance_state(f1), "bars"
),
([b2], [], [b1]),
)
def as_dict(self):
return instance_dict(self)
def flag_modified(instance, key):
state, dict_ = instance_state(instance), instance_dict(instance)
impl = state.manager[key].impl
state.modified_event(dict_, impl, True, NO_VALUE)
def remove(self, item):
self.attr.remove(
attributes.instance_state(self.instance),
attributes.instance_dict(self.instance), item, None)
def append(self, item):
self.attr.append(
attributes.instance_state(self.instance),
attributes.instance_dict(self.instance), item, None)
def dict(self):
o = self.obj()
if o is not None:
return attributes.instance_dict(o)
else:
return {}
