def test_composite_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
[addresses.c.id, addresses.c.email_address]
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
(1, "email1"): Address(id=1, email_address="email1"),
(2, "email2"): Address(id=2, email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(
repickled.addresses[(1, "email1")],
Address(id=1, email_address="email1"),
)
def test_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
addresses.c.email_address
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
"email1": Address(email_address="email1"),
"email2": Address(email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
addresses.c.email_address
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
"email1": Address(email_address="email1"),
"email2": Address(email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_pickle_anon_label(self):
q1 = _anonymous_label(quoted_name("x", True))
for loads, dumps in picklers():
q2 = loads(dumps(q1))
assert isinstance(q2, _anonymous_label)
eq_(str(q1), str(q2))
eq_(q1.quote, q2.quote)
def test_serialize_cy_py_cy(self):
from sqlalchemy.engine._py_row import BaseRow as _PyRow
from sqlalchemy.cyextension.resultproxy import BaseRow as _CyRow
global Row
p = result.SimpleResultMetaData(["a", None, "b"])
for loads, dumps in picklers():
class Row(_CyRow):
pass
row = Row(p, p._processors, p._keymap, 0, (1, 2, 3))
state = dumps(row)
class Row(_PyRow):
pass
row2 = loads(state)
is_true(isinstance(row2, _PyRow))
state2 = dumps(row2)
class Row(_CyRow):
pass
row3 = loads(state2)
is_true(isinstance(row3, _CyRow))
def test_composite_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
[addresses.c.id, addresses.c.email_address]
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
(1, "email1"): Address(id=1, email_address="email1"),
(2, "email2"): Address(id=2, email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(
repickled.addresses[(1, "email1")],
Address(id=1, email_address="email1"),
)
def test_pickle_anon_label(self):
q1 = _anonymous_label(quoted_name("x", True))
for loads, dumps in picklers():
q2 = loads(dumps(q1))
assert isinstance(q2, _anonymous_label)
eq_(str(q1), str(q2))
eq_(q1.quote, q2.quote)
def test_picklability(self):
from sqlalchemy.ext.orderinglist import OrderingList
olist = OrderingList("order", reorder_on_append=True)
olist.append(DummyItem())
for loads, dumps in picklers():
pck = dumps(olist)
copy = loads(pck)
self.assert_(copy == olist)
self.assert_(copy.__dict__ == olist.__dict__)
def test_picklability(self):
from sqlalchemy.ext.orderinglist import OrderingList
olist = OrderingList("order", reorder_on_append=True)
olist.append(DummyItem())
for loads, dumps in picklers():
pck = dumps(olist)
copy = loads(pck)
self.assert_(copy == olist)
self.assert_(copy.__dict__ == olist.__dict__)
def test_serialize(self):
keyed_tuple = self._fixture([1, 2, 3], ["a", None, "b"])
for loads, dumps in picklers():
kt = loads(dumps(keyed_tuple))
eq_(str(kt), "(1, 2, 3)")
eq_(list(kt._mapping.keys()), ["a", "b"])
eq_(kt._fields, ("a", "b"))
eq_(kt._asdict(), {"a": 1, "b": 3})
def test_exceptions(self):
class Foo(object):
pass
users = self.tables.users
mapper(User, users)
for sa_exc in (
orm_exc.UnmappedInstanceError(Foo()),
orm_exc.UnmappedClassError(Foo),
orm_exc.ObjectDeletedError(attributes.instance_state(User())),
):
for loads, dumps in picklers():
repickled = loads(dumps(sa_exc))
eq_(repickled.args[0], sa_exc.args[0])
def test_exceptions(self):
class Foo(object):
pass
users = self.tables.users
mapper(User, users)
for sa_exc in (
orm_exc.UnmappedInstanceError(Foo()),
orm_exc.UnmappedClassError(Foo),
orm_exc.ObjectDeletedError(attributes.instance_state(User())),
):
for loads, dumps in picklers():
repickled = loads(dumps(sa_exc))
eq_(repickled.args[0], sa_exc.args[0])
def test_pickle_parent(self):
sess = Session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data["a"] = "c"
assert f2 in sess.dirty
def test_pickle_parent(self):
sess = Session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.add(3)
assert f2 in sess.dirty
def test_pickle_parent(self):
sess = Session()
f1 = Foo(data={'a': 'b'})
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data['a'] = 'c'
assert f2 in sess.dirty
def test_pickle_parent(self):
sess = Session()
f1 = Foo(data={'a': 'b'})
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data['a'] = 'c'
assert f2 in sess.dirty
def test_pickle_parent(self):
sess = fixture_session()
f1 = Foo(data={"a": "b"})
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data["a"] = "c"
assert f2 in sess.dirty
def test_pickle_parent(self):
sess = fixture_session()
f1 = Foo(data=set([1, 2]))
sess.add(f1)
sess.commit()
f1.data
sess.close()
for loads, dumps in picklers():
sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.add(3)
assert f2 in sess.dirty
def test_pickle_parent_multi_attrs(self, registry, connection, pickleit):
"""test #8133"""
local_foo = Table(
"lf",
registry.metadata,
Column("id", Integer, primary_key=True),
Column("j1", MutableDict.as_mutable(PickleType)),
Column("j2", MutableDict.as_mutable(PickleType)),
Column("j3", MutableDict.as_mutable(PickleType)),
Column("j4", MutableDict.as_mutable(PickleType)),
)
registry.map_imperatively(Foo2, local_foo)
registry.metadata.create_all(connection)
with Session(connection) as sess:
data = dict(
j1={"a": 1},
j2={"b": 2},
j3={"c": 3},
j4={"d": 4},
)
lf = Foo2(**data)
sess.add(lf)
sess.commit()
all_attrs = {"j1", "j2", "j3", "j4"}
for attr in all_attrs:
for loads, dumps in picklers():
with Session(connection) as sess:
f1 = sess.scalars(select(Foo2)).first()
if pickleit:
f2 = loads(dumps(f1))
else:
f2 = f1
existing_dict = getattr(f2, attr)
existing_dict["q"] = "c"
eq_(
inspect(f2).attrs[attr].history,
([existing_dict], (), ()),
)
for other_attr in all_attrs.difference([attr]):
a = inspect(f2).attrs[other_attr].history
b = ((), [data[other_attr]], ())
eq_(a, b)
def test_pickle_of_parent(self):
sess = fixture_session()
d = Point(3, 4)
f1 = Foo(data=d)
sess.add(f1)
sess.commit()
f1.data
assert "data" in f1.__dict__
sess.close()
for loads, dumps in picklers():
sess = fixture_session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.y = 12
assert f2 in sess.dirty
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(User, users, properties={
'addresses': relationship(
Address,
collection_class=attribute_mapped_collection('email_address')
)
})
mapper(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses['email1'],
Address(email_address="email1"))
def test_pickle_of_parent_subclass(self):
sess = Session()
d = Point(3, 4)
f1 = SubFoo(data=d)
sess.add(f1)
sess.commit()
f1.data
assert 'data' in f1.__dict__
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.y = 12
assert f2 in sess.dirty
def test_pickle_of_parent_subclass(self):
sess = Session()
d = Point(3, 4)
f1 = SubFoo(data=d)
sess.add(f1)
sess.commit()
f1.data
assert 'data' in f1.__dict__
sess.close()
for loads, dumps in picklers():
sess = Session()
f2 = loads(dumps(f1))
sess.add(f2)
f2.data.y = 12
assert f2 in sess.dirty
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(User,
users,
properties={
'addresses':
relationship(Address,
collection_class=attribute_mapped_collection(
'email_address'))
})
mapper(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses['email1'], Address(email_address="email1"))
def test_pickle_protocols(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(User, users, properties={
'addresses': relationship(Address, backref="user")
})
mapper(Address, addresses)
sess = sessionmaker()()
u1 = User(name='ed')
u1.addresses.append(Address(email_address='*****@*****.**'))
sess.add(u1)
sess.commit()
u1 = sess.query(User).first()
u1.addresses
for loads, dumps in picklers():
u2 = loads(dumps(u1))
eq_(u1, u2)
def test_pickle_protocols(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(User,
users,
properties={'addresses': relationship(Address, backref="user")})
mapper(Address, addresses)
sess = sessionmaker()()
u1 = User(name='ed')
u1.addresses.append(Address(email_address='*****@*****.**'))
sess.add(u1)
sess.commit()
u1 = sess.query(User).first()
u1.addresses
for loads, dumps in picklers():
u2 = loads(dumps(u1))
eq_(u1, u2)
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses":
relationship(
Address,
collection_class=attribute_mapped_collection(
"email_address"),
)
},
)
self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_pickle_protocols(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
mapper(Address, addresses)
sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="*****@*****.**"))
sess.add(u1)
sess.commit()
u1 = sess.query(User).first()
u1.addresses
for loads, dumps in picklers():
u2 = loads(dumps(u1))
eq_(u1, u2)
def test_serialize(self):
d = util.immutabledict({1: 2, 3: 4})
for loads, dumps in picklers():
print(loads(dumps(d)))
def test_unpickle_modified_eq(self):
u1 = FooWithEq(data=self.Point(3, 5))
for loads, dumps in picklers():
loads(dumps(u1))
def test_unpickle_modified_eq(self):
u1 = FooWithEq(data=self.Point(3, 5))
for loads, dumps in picklers():
loads(dumps(u1))
def test_serialize(self):
d = util.immutabledict({1: 2, 3: 4})
for loads, dumps in picklers():
print(loads(dumps(d)))
def test_pickle_quote(self):
q1 = quoted_name("x", True)
for loads, dumps in picklers():
q2 = loads(dumps(q1))
eq_(str(q1), str(q2))
eq_(q1.quote, q2.quote)
def test_pickle_quote(self):
q1 = quoted_name("x", True)
for loads, dumps in picklers():
q2 = loads(dumps(q1))
eq_(str(q1), str(q2))
eq_(q1.quote, q2.quote)
