deprecated relation(class, table)

changed unit tests/examples to not do it

diff --git a/examples/adjacencytree/byroot_tree.py b/examples/adjacencytree/byroot_tree.py
index a66f11378ea89413f91636db15734c986d0dff38..f564b1f9ef4212ba98dee5c3ddabb0cd167c6c0c 100644 (file)
--- 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 fcfa17fe0007e6ddd5d8534a8c20776028f44ce3..b9b9ee5a1019909524631c497bb133d67d8a19cb 100644 (file)
--- 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 e79558cb97b92e1afbb5b34e6773161efb900744..5ef48b49439a84910b6f634778ff9d37e576c0b3 100644 (file)
--- 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 4e0721b9719a80bce63b372d70060a3bc7497988..e979879b2675b3e5e975787154b28565e46842c1 100644 (file)
--- 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'},