From: Mike Bayer Date: Fri, 29 Jun 2007 20:46:54 +0000 (+0000) Subject: all of LazyTest moved to updated lazy_relations module X-Git-Tag: rel_0_4_6~158 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=742f2583093e685d541b3a9901a818193fb49206;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git all of LazyTest moved to updated lazy_relations module --- diff --git a/test/orm/lazy_relations.py b/test/orm/lazy_relations.py index e0a6ceeed4..5090ef4ac7 100644 --- a/test/orm/lazy_relations.py +++ b/test/orm/lazy_relations.py @@ -1,3 +1,5 @@ +"""basic tests of lazy loaded attributes""" + from sqlalchemy import * from sqlalchemy.orm import * import testbase @@ -170,7 +172,7 @@ class LazyTest(QueryTest): l = q.filter(s.c.u2_id==User.c.id).distinct().all() assert self.user_all_result == l - def test_onetoone(self): + def test_one_to_many_scalar(self): mapper(User, users, properties = dict( address = relation(mapper(Address, addresses), lazy=True, uselist=False) )) @@ -178,5 +180,97 @@ class LazyTest(QueryTest): l = q.filter(users.c.id == 7).all() assert [User(id=7, address=Address(id=1))] == l + def test_double(self): + """tests lazy loading with two relations simulatneously, from the same table, using aliases. """ + openorders = alias(orders, 'openorders') + closedorders = alias(orders, 'closedorders') + + mapper(Address, addresses) + + mapper(User, users, properties = dict( + addresses = relation(Address, lazy = True), + open_orders = relation(mapper(Order, openorders, entity_name='open'), primaryjoin = and_(openorders.c.isopen == 1, users.c.id==openorders.c.user_id), lazy=True), + closed_orders = relation(mapper(Order, closedorders,entity_name='closed'), primaryjoin = and_(closedorders.c.isopen == 0, users.c.id==closedorders.c.user_id), lazy=True) + )) + q = create_session().query(User) + + assert [ + User( + id=7, + addresses=[Address(id=1)], + open_orders = [Order(id=3)], + closed_orders = [Order(id=1), Order(id=5)] + ), + User( + id=8, + addresses=[Address(id=2), Address(id=3), Address(id=4)], + open_orders = [], + closed_orders = [] + ), + User( + id=9, + addresses=[Address(id=5)], + open_orders = [Order(id=4)], + closed_orders = [Order(id=2)] + ), + User(id=10) + + ] == q.all() + + def test_many_to_many(self): + + mapper(Keyword, keywords) + mapper(Item, items, properties = dict( + keywords = relation(Keyword, secondary=item_keywords, lazy=True), + )) + + q = create_session().query(Item) + assert [ + Item(id=1, keywords=[Keyword(name='red'), Keyword(name='big'), Keyword(name='round')]), + Item(id=2, keywords=[Keyword(name='red'), Keyword(name='small'), Keyword(name='square')]), + Item(id=3, keywords=[Keyword(name='green'), Keyword(name='big'), Keyword(name='round')]), + Item(id=4, keywords=[]), + Item(id=5, keywords=[]), + ] == q.all() + + assert [ + Item(id=1, keywords=[Keyword(name='red'), Keyword(name='big'), Keyword(name='round')]), + Item(id=2, keywords=[Keyword(name='red'), Keyword(name='small'), Keyword(name='square')]), + ] == q.join('keywords').filter(keywords.c.name == 'red').all() + + def test_uses_get(self): + """test that a simple many-to-one lazyload optimizes to use query.get().""" + + mapper(Address, addresses, properties = dict( + user = relation(mapper(User, users), lazy=True) + )) + + sess = create_session() + + # load address + a1 = sess.query(Address).filter_by(email_address="ed@wood.com").one() + + # load user that is attached to the address + u1 = sess.query(User).get(8) + + def go(): + # lazy load of a1.user should get it from the session + assert a1.user is u1 + self.assert_sql_count(testbase.db, go, 0) + + def test_many_to_one(self): + mapper(Address, addresses, properties = dict( + user = relation(mapper(User, users), lazy=True) + )) + sess = create_session() + q = sess.query(Address) + a = q.filter(addresses.c.id==1).one() + + assert a.user is not None + + u1 = sess.query(User).get(7) + + assert a.user is u1 + if __name__ == '__main__': testbase.main() diff --git a/test/orm/mapper.py b/test/orm/mapper.py index ab53e36c45..370027a880 100644 --- a/test/orm/mapper.py +++ b/test/orm/mapper.py @@ -868,88 +868,6 @@ class MapperExtensionTest(MapperSuperTest): l = q.select(); self.assert_result(l, User, *user_address_result) -class LazyTest(MapperSuperTest): - - - def testbackwardsonetoone(self): - m = mapper(Address, addresses, properties = dict( - user = relation(mapper(User, users), lazy = True) - )) - q = create_session().query(m) - l = q.select(addresses.c.address_id == 1) - self.echo(repr(l)) - print repr(l[0].__dict__) - self.echo(repr(l[0].user)) - self.assert_(l[0].user is not None) - - def testuseget(self): - """test that a simple many-to-one lazyload optimizes to use query.get(). - - this is done currently by comparing the 'get' SQL clause of the query - to the 'lazy' SQL clause of the lazy loader, so it relies heavily on - ClauseElement.compare()""" - - m = mapper(Address, addresses, properties = dict( - user = relation(mapper(User, users), lazy = True) - )) - sess = create_session() - a1 = sess.query(Address).get_by(email_address = "ed@wood.com") - u1 = sess.query(User).get(8) - def go(): - assert a1.user is u1 - self.assert_sql_count(db, go, 0) - - def testdouble(self): - """tests lazy loading with two relations simulatneously, from the same table, using aliases. """ - openorders = alias(orders, 'openorders') - closedorders = alias(orders, 'closedorders') - m = mapper(User, users, properties = dict( - addresses = relation(mapper(Address, addresses), lazy = True), - open_orders = relation(mapper(Order, openorders, entity_name='open'), primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = True), - closed_orders = relation(mapper(Order, closedorders,entity_name='closed'), primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = True) - )) - q = create_session().query(m) - l = q.select() - self.assert_result(l, User, - {'user_id' : 7, - 'addresses' : (Address, [{'address_id' : 1}]), - 'open_orders' : (Order, [{'order_id' : 3}]), - 'closed_orders' : (Order, [{'order_id' : 1},{'order_id' : 5},]) - }, - {'user_id' : 8, - 'addresses' : (Address, [{'address_id' : 2}, {'address_id' : 3}, {'address_id' : 4}]), - 'open_orders' : (Order, []), - 'closed_orders' : (Order, []) - }, - {'user_id' : 9, - 'addresses' : (Address, []), - 'open_orders' : (Order, [{'order_id' : 4}]), - 'closed_orders' : (Order, [{'order_id' : 2}]) - } - ) - - def testmanytomany(self): - """tests a many-to-many lazy load""" - mapper(Item, orderitems, properties = dict( - keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = True), - )) - q = create_session().query(Item) - l = q.select() - self.assert_result(l, Item, - {'item_id' : 1, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 4}, {'keyword_id' : 6}])}, - {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])}, - {'item_id' : 3, 'keywords' : (Keyword, [{'keyword_id' : 3}, {'keyword_id' : 4}, {'keyword_id' : 6}])}, - {'item_id' : 4, 'keywords' : (Keyword, [])}, - {'item_id' : 5, 'keywords' : (Keyword, [])} - ) - l = q.select(and_(keywords.c.name == 'red', keywords.c.keyword_id == itemkeywords.c.keyword_id, Item.c.item_id==itemkeywords.c.item_id)) - self.assert_result(l, Item, - {'item_id' : 1, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 4}, {'keyword_id' : 6}])}, - {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])}, - ) - - - class EagerTest(MapperSuperTest): def testbasic(self): """tests a basic one-to-many eager load"""