From 3227aefc7127902cc491a124a0a69c915d3d3af8 Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Thu, 2 Feb 2006 23:28:23 +0000 Subject: [PATCH] deprecated relation(class, table) changed unit tests/examples to not do it --- examples/adjacencytree/byroot_tree.py | 2 +- lib/sqlalchemy/mapping/__init__.py | 23 ++------ test/mapper.py | 80 +++++++++++++-------------- test/objectstore.py | 33 +++++------ 4 files changed, 62 insertions(+), 76 deletions(-) diff --git a/examples/adjacencytree/byroot_tree.py b/examples/adjacencytree/byroot_tree.py index a66f11378e..f564b1f9ef 100644 --- a/examples/adjacencytree/byroot_tree.py +++ b/examples/adjacencytree/byroot_tree.py @@ -138,7 +138,7 @@ assign_mapper(TreeNode, trees, properties=dict( root_id=trees.c.root_node_id, root=relation(TreeNode, primaryjoin=trees.c.root_node_id==trees.c.node_id, foreignkey=trees.c.node_id, lazy=None, uselist=False), children=relation(TreeNode, primaryjoin=trees.c.parent_node_id==trees.c.node_id, lazy=None, uselist=True, private=True), - data=relation(TreeData, treedata, properties=dict(id=treedata.c.data_id), private=True, lazy=False) + data=relation(mapper(TreeData, treedata, properties=dict(id=treedata.c.data_id)), private=True, lazy=False) ), extension = TreeLoader()) TreeNode.mapper diff --git a/lib/sqlalchemy/mapping/__init__.py b/lib/sqlalchemy/mapping/__init__.py index fcfa17fe00..b9b9ee5a10 100644 --- a/lib/sqlalchemy/mapping/__init__.py +++ b/lib/sqlalchemy/mapping/__init__.py @@ -24,15 +24,12 @@ __all__ = ['relation', 'eagerload', 'lazyload', 'noload', 'deferred', 'column', 'assign_mapper' ] -def relation(*args, **params): +def relation(*args, **kwargs): """provides a relationship of a primary Mapper to a secondary Mapper, which corresponds to a parent-child or associative table relationship.""" - if isinstance(args[0], type) and len(args) == 1: - return _relation_loader(*args, **params) - elif isinstance(args[0], Mapper): - return _relation_loader(*args, **params) - else: - return _relation_mapper(*args, **params) + if len(args) > 1 and isinstance(args[0], type): + raise ValueError("relation(class, table, **kwargs) is deprecated. Please use relation(class, **kwargs) or relation(mapper, **kwargs).") + return _relation_loader(*args, **kwargs) def _relation_loader(mapper, secondary=None, primaryjoin=None, secondaryjoin=None, lazy=True, **kwargs): if lazy: @@ -42,18 +39,6 @@ def _relation_loader(mapper, secondary=None, primaryjoin=None, secondaryjoin=Non else: return EagerLoader(mapper, secondary, primaryjoin, secondaryjoin, **kwargs) -def _relation_mapper(class_, table=None, secondary=None, - primaryjoin=None, secondaryjoin=None, - foreignkey=None, uselist=None, private=False, - live=False, association=None, lazy=True, - selectalias=None, order_by=None, attributeext=None, **kwargs): - - return _relation_loader(mapper(class_, table, **kwargs), - secondary, primaryjoin, secondaryjoin, - foreignkey=foreignkey, uselist=uselist, private=private, - live=live, association=association, lazy=lazy, - selectalias=selectalias, order_by=order_by, attributeext=attributeext) - def column(*columns, **kwargs): return ColumnProperty(*columns, **kwargs) diff --git a/test/mapper.py b/test/mapper.py index e79558cb97..5ef48b4943 100644 --- a/test/mapper.py +++ b/test/mapper.py @@ -85,7 +85,7 @@ class MapperTest(MapperSuperTest): def testmagic(self): m = mapper(User, users, properties = { - 'addresses' : relation(Address, addresses) + 'addresses' : relation(mapper(Address, addresses)) }) l = m.select_by(user_name='fred') self.assert_result(l, User, *[{'user_id':9}]) @@ -155,19 +155,19 @@ class MapperTest(MapperSuperTest): # assert that allow_column_override cancels the error m = mapper(User, users, properties = { - 'user_name' : relation(Address, addresses) + 'user_name' : relation(mapper(Address, addresses)) }, allow_column_override=True) # assert that the column being named else where also cancels the error m = mapper(User, users, properties = { - 'user_name' : relation(Address, addresses), + 'user_name' : relation(mapper(Address, addresses)), 'foo' : users.c.user_name, }) def testeageroptions(self): """tests that a lazy relation can be upgraded to an eager relation via the options method""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True) + addresses = relation(mapper(Address, addresses), lazy = True) )) l = m.options(eagerload('addresses')).select() @@ -178,7 +178,7 @@ class MapperTest(MapperSuperTest): def testlazyoptions(self): """tests that an eager relation can be upgraded to a lazy relation via the options method""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False) + addresses = relation(mapper(Address, addresses), lazy = False) )) l = m.options(lazyload('addresses')).select() def go(): @@ -188,11 +188,11 @@ class MapperTest(MapperSuperTest): def testdeepoptions(self): m = mapper(User, users, properties = { - 'orders': relation(Order, orders, properties = { - 'items' : relation(Item, orderitems, properties = { - 'keywords' : relation(Keyword, keywords, itemkeywords) - }) - }) + 'orders': relation(mapper(Order, orders, properties = { + 'items' : relation(mapper(Item, orderitems, properties = { + 'keywords' : relation(mapper(Keyword, keywords), itemkeywords) + })) + })) }) m2 = m.options(eagerload('orders.items.keywords')) @@ -319,11 +319,11 @@ class DeferredTest(MapperSuperTest): def testdeepoptions(self): m = mapper(User, users, properties={ - 'orders':relation(Order, orders, properties={ - 'items':relation(Item, orderitems, properties={ + 'orders':relation(mapper(Order, orders, properties={ + 'items':relation(mapper(Item, orderitems, properties={ 'item_name':deferred(orderitems.c.item_name) - }) - }) + })) + })) }) l = m.select() item = l[0].orders[1].items[1] @@ -346,7 +346,7 @@ class LazyTest(MapperSuperTest): def testbasic(self): """tests a basic one-to-many lazy load""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True) + addresses = relation(mapper(Address, addresses), lazy = True) )) l = m.select(users.c.user_id == 7) self.assert_result(l, User, @@ -383,11 +383,11 @@ class LazyTest(MapperSuperTest): def testlimit(self): ordermapper = mapper(Order, orders, properties = dict( - items = relation(Item, orderitems, lazy = True) + items = relation(mapper(Item, orderitems), lazy = True) )) m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True), + addresses = relation(mapper(Address, addresses), lazy = True), orders = relation(ordermapper, primaryjoin = users.c.user_id==orders.c.user_id, lazy = True), )) l = m.select(limit=2, offset=1) @@ -401,14 +401,14 @@ class LazyTest(MapperSuperTest): objectstore.clear() m = mapper(Item, orderitems, is_primary=True, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy = True), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = True), )) l = m.select((Item.c.item_name=='item 2') | (Item.c.item_name=='item 5') | (Item.c.item_name=='item 3'), order_by=[Item.c.item_id], limit=2) self.assert_result(l, Item, *[item_keyword_result[1], item_keyword_result[2]]) def testonetoone(self): m = mapper(User, users, properties = dict( - address = relation(Address, addresses, lazy = True, uselist = False) + address = relation(mapper(Address, addresses), lazy = True, uselist = False) )) l = m.select(users.c.user_id == 7) self.echo(repr(l)) @@ -416,7 +416,7 @@ class LazyTest(MapperSuperTest): def testbackwardsonetoone(self): m = mapper(Address, addresses, properties = dict( - user = relation(User, users, properties = {'id':users.c.user_id}, lazy = True) + user = relation(mapper(User, users, properties = {'id':users.c.user_id}), lazy = True) )) l = m.select(addresses.c.address_id == 1) self.echo(repr(l)) @@ -430,9 +430,9 @@ class LazyTest(MapperSuperTest): openorders = alias(orders, 'openorders') closedorders = alias(orders, 'closedorders') m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False), - open_orders = relation(Order, openorders, primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = True), - closed_orders = relation(Order, closedorders, primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = True) + addresses = relation(mapper(Address, addresses), lazy = False), + open_orders = relation(mapper(Order, openorders), primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = True), + closed_orders = relation(mapper(Order, closedorders), primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = True) )) l = m.select() self.assert_result(l, User, @@ -456,7 +456,7 @@ class LazyTest(MapperSuperTest): def testmanytomany(self): """tests a many-to-many lazy load""" assign_mapper(Item, orderitems, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy = True), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = True), )) l = Item.mapper.select() self.assert_result(l, Item, @@ -513,11 +513,11 @@ class EagerTest(MapperSuperTest): def testlimit(self): ordermapper = mapper(Order, orders, properties = dict( - items = relation(Item, orderitems, lazy = False) + items = relation(mapper(Item, orderitems), lazy = False) )) m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False), + addresses = relation(mapper(Address, addresses), lazy = False), orders = relation(ordermapper, primaryjoin = users.c.user_id==orders.c.user_id, lazy = False), )) l = m.select(limit=2, offset=1) @@ -531,7 +531,7 @@ class EagerTest(MapperSuperTest): self.assert_result(l, User, *user_all_result) objectstore.clear() m = mapper(Item, orderitems, is_primary=True, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy = False), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False), )) l = m.select((Item.c.item_name=='item 2') | (Item.c.item_name=='item 5') | (Item.c.item_name=='item 3'), order_by=[Item.c.item_id], limit=2) self.assert_result(l, Item, *[item_keyword_result[1], item_keyword_result[2]]) @@ -540,7 +540,7 @@ class EagerTest(MapperSuperTest): def testonetoone(self): m = mapper(User, users, properties = dict( - address = relation(Address, addresses, lazy = False, uselist = False) + address = relation(mapper(Address, addresses), lazy = False, uselist = False) )) l = m.select(users.c.user_id == 7) self.assert_result(l, User, @@ -549,7 +549,7 @@ class EagerTest(MapperSuperTest): def testbackwardsonetoone(self): m = mapper(Address, addresses, properties = dict( - user = relation(User, users, lazy = False) + user = relation(mapper(User, users), lazy = False) )) self.echo(repr(m.props['user'].uselist)) l = m.select(addresses.c.address_id == 1) @@ -564,7 +564,7 @@ class EagerTest(MapperSuperTest): criterion is using the same tables that are used within the eager load. the mapper must insure that the criterion doesnt interfere with the eager load criterion.""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, primaryjoin = users.c.user_id==addresses.c.user_id, lazy = False) + addresses = relation(mapper(Address, addresses), primaryjoin = users.c.user_id==addresses.c.user_id, lazy = False) )) l = m.select(and_(addresses.c.email_address == 'ed@lala.com', addresses.c.user_id==users.c.user_id)) self.assert_result(l, User, @@ -575,7 +575,7 @@ class EagerTest(MapperSuperTest): def testcompile(self): """tests deferred operation of a pre-compiled mapper statement""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False) + addresses = relation(mapper(Address, addresses), lazy = False) )) s = m.compile(and_(addresses.c.email_address == bindparam('emailad'), addresses.c.user_id==users.c.user_id)) c = s.compile() @@ -587,8 +587,8 @@ class EagerTest(MapperSuperTest): def testmulti(self): """tests eager loading with two relations simultaneously""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, primaryjoin = users.c.user_id==addresses.c.user_id, lazy = False), - orders = relation(Order, orders, lazy = False), + addresses = relation(mapper(Address, addresses), primaryjoin = users.c.user_id==addresses.c.user_id, lazy = False), + orders = relation(mapper(Order, orders), lazy = False), )) l = m.select() self.assert_result(l, User, @@ -611,9 +611,9 @@ class EagerTest(MapperSuperTest): openorders = alias(orders, 'openorders') closedorders = alias(orders, 'closedorders') m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False), - open_orders = relation(Order, openorders, primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = False), - closed_orders = relation(Order, closedorders, primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = False) + addresses = relation(mapper(Address, addresses), lazy = False), + open_orders = relation(mapper(Order, openorders), primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = False), + closed_orders = relation(mapper(Order, closedorders), primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = False) )) l = m.select() self.assert_result(l, User, @@ -638,11 +638,11 @@ class EagerTest(MapperSuperTest): """tests eager loading of a parent item with two types of child items, where one of those child items eager loads its own child items.""" ordermapper = mapper(Order, orders, properties = dict( - items = relation(Item, orderitems, lazy = False) + items = relation(mapper(Item, orderitems), lazy = False) )) m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = False), + addresses = relation(mapper(Address, addresses), lazy = False), orders = relation(ordermapper, primaryjoin = users.c.user_id==orders.c.user_id, lazy = False), )) l = m.select() @@ -652,7 +652,7 @@ class EagerTest(MapperSuperTest): items = orderitems m = mapper(Item, items, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy=False), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy=False), )) l = m.select() self.assert_result(l, Item, *item_keyword_result) @@ -671,7 +671,7 @@ class EagerTest(MapperSuperTest): m = mapper(Item, items, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy = False), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False), )) m = mapper(Order, orders, properties = dict( diff --git a/test/objectstore.py b/test/objectstore.py index 4e0721b971..e979879b26 100644 --- a/test/objectstore.py +++ b/test/objectstore.py @@ -28,7 +28,7 @@ class HistoryTest(AssertMixin): should be tested mostly in attributes.py which tests independently of the ORM objects, but I think here we are going for the Mapper not interfering with it.""" - m = mapper(User, users, properties = dict(addresses = relation(Address, addresses))) + m = mapper(User, users, properties = dict(addresses = relation(mapper(Address, addresses)))) u = User() u.user_id = 7 u.user_name = 'afdas' @@ -238,7 +238,7 @@ class SaveTest(AssertMixin): def testonetoone(self): m = mapper(User, users, properties = dict( - address = relation(Address, addresses, lazy = True, uselist = False) + address = relation(mapper(Address, addresses), lazy = True, uselist = False) )) u = User() u.user_name = 'one2onetester' @@ -252,7 +252,7 @@ class SaveTest(AssertMixin): def testdelete(self): m = mapper(User, users, properties = dict( - address = relation(Address, addresses, lazy = True, uselist = False, private = False) + address = relation(mapper(Address, addresses), lazy = True, uselist = False, private = False) )) u = User() a = Address() @@ -267,10 +267,10 @@ class SaveTest(AssertMixin): def testcascadingdelete(self): m = mapper(User, users, properties = dict( - address = relation(Address, addresses, lazy = False, uselist = False, private = True), + address = relation(mapper(Address, addresses), lazy = False, uselist = False, private = True), orders = relation( mapper(Order, orders, properties = dict ( - items = relation(Item, orderitems, lazy = False, uselist =True, private = True) + items = relation(mapper(Item, orderitems), lazy = False, uselist =True, private = True) )), lazy = True, uselist = True, private = True) )) @@ -350,7 +350,7 @@ class SaveTest(AssertMixin): # )) # TODO: put assertion in here !!! m = mapper(Address, addresses, properties = dict( - user = relation(User, users, lazy = True, uselist = False) + user = relation(mapper(User, users), lazy = True, uselist = False) )) data = [ {'user_name' : 'thesub' , 'email_address' : 'bar@foo.com'}, @@ -409,7 +409,7 @@ class SaveTest(AssertMixin): def testonetomany(self): """test basic save of one to many.""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True) + addresses = relation(mapper(Address, addresses), lazy = True) )) u = User() u.user_name = 'one2manytester' @@ -457,7 +457,7 @@ class SaveTest(AssertMixin): oldmapper = User.mapper # now a mapper with the users table plus a relation to the addresses assign_mapper(User, users, is_primary=True, properties = dict( - addresses = relation(Address, addresses, lazy = False) + addresses = relation(mapper(Address, addresses), lazy = False) )) self.assert_(oldmapper is not User.mapper) u = User.mapper.select() @@ -484,7 +484,7 @@ class SaveTest(AssertMixin): """digs deeper into modifying the child items of an object to insure the correct updates take place""" m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True) + addresses = relation(mapper(Address, addresses), lazy = True) )) u1 = User() u1.user_name = 'user1' @@ -528,7 +528,7 @@ class SaveTest(AssertMixin): def testbackwardsmanipulations(self): m = mapper(Address, addresses, properties = dict( - user = relation(User, users, lazy = True, uselist = False) + user = relation(mapper(User, users), lazy = True, uselist = False) )) a1 = Address() a1.email_address = 'emailaddress1' @@ -557,7 +557,7 @@ class SaveTest(AssertMixin): def _testremove(self): m = mapper(User, users, properties = dict( - addresses = relation(Address, addresses, lazy = True) + addresses = relation(mapper(Address, addresses), lazy = True) )) u = User() u.user_name = 'one2manytester' @@ -585,7 +585,7 @@ class SaveTest(AssertMixin): items.select().execute() m = mapper(Item, items, properties = dict( - keywords = relation(Keyword, keywords, itemkeywords, lazy = False), + keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False), )) keywordmapper = mapper(Keyword, keywords) @@ -682,9 +682,10 @@ class SaveTest(AssertMixin): keywordmapper = mapper(Keyword, keywords) m = mapper(Item, items, properties = dict( - keywords = relation(IKAssociation, itemkeywords, lazy = False, properties = dict( - keyword = relation(Keyword, keywords, lazy = False, uselist = False) - ), primary_key = [itemkeywords.c.item_id, itemkeywords.c.keyword_id]) + keywords = relation(mapper(IKAssociation, itemkeywords, properties = dict( + keyword = relation(mapper(Keyword, keywords), lazy = False, uselist = False) + ), primary_key = [itemkeywords.c.item_id, itemkeywords.c.keyword_id]), + lazy = False) )) data = [Item, @@ -794,7 +795,7 @@ class SaveTest2(AssertMixin): def testbackwardsnonmatch(self): m = mapper(Address, self.addresses, properties = dict( - user = relation(User, self.users, lazy = True, uselist = False) + user = relation(mapper(User, self.users), lazy = True, uselist = False) )) data = [ {'user_name' : 'thesub' , 'email_address' : 'bar@foo.com'}, -- 2.47.2