added test for testing against "outerjoin"

diff --git a/examples/polymorph/polymorph.py b/examples/polymorph/polymorph.py
index 00214f919d3b7a2b407e296b38642d491701a071..b1f3e75158f8c9f1e3e62c7f3c24511238ea4cb4 100644 (file)
--- a/examples/polymorph/polymorph.py
+++ b/examples/polymorph/polymorph.py
@@ -1,15 +1,10 @@
 from sqlalchemy import *
+from sqlalchemy.orm import *
 import sets
 
-import logging
-logging.basicConfig()
-logging.getLogger('sqlalchemy.orm').setLevel(logging.DEBUG)
-logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
+# this example illustrates a polymorphic load of two classes
 
-# this example illustrates a polymorphic load of two classes, where each class has a  
-# different set of properties
-
-metadata = BoundMetaData('sqlite://')
+metadata = BoundMetaData('sqlite://', echo='True')
 
 # a table to store companies
 companies = Table('companies', metadata, 
@@ -60,16 +55,9 @@ class Company(object):
         return "Company %s" % self.name
 
 
-# create a union that represents both types of joins.  
-person_join = polymorphic_union(
-    {
-        'engineer':people.join(engineers),
-        'manager':people.join(managers),
-        'person':people.select(people.c.type=='person'),
-    }, None, 'pjoin')
+person_join = people.outerjoin(engineers).outerjoin(managers)
 
-#person_mapper = mapper(Person, people, select_table=person_join,polymorphic_on=person_join.c.type, polymorphic_identity='person')
-person_mapper = mapper(Person, people, polymorphic_on=people.c.type, polymorphic_identity='person')
+person_mapper = mapper(Person, people, select_table=person_join,polymorphic_on=people.c.type, polymorphic_identity='person')
 mapper(Engineer, engineers, inherits=person_mapper, polymorphic_identity='engineer')
 mapper(Manager, managers, inherits=person_mapper, polymorphic_identity='manager')
 

diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index 14178c1d85590ae4be9ea94c091ce9bbf0b610db..8de2d00e5f3411c8eb253b3d1ec942cc72a2ffa5 100644 (file)
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -674,7 +674,7 @@ class EagerLoader(AbstractRelationLoader):
                         result_list = selectcontext.attributes[(instance, self.key)]
                         if self._should_log_debug:
                             self.logger.debug("eagerload list instance on %s" % mapperutil.attribute_str(instance, self.key))
-                        self.mapper._instance(selectcontext, decorated_row, result_list)
+                        self.select_mapper._instance(selectcontext, decorated_row, result_list)
                 finally:
                     selectcontext.recursion_stack.remove(self)
             return (execute, None)

diff --git a/test/orm/inheritance/magazine.py b/test/orm/inheritance/magazine.py
index 20270d59cb5a560dab718383ab11aa74524c7f1f..880ede591876734e1ac1c3d2e093f3d1adeb913e 100644 (file)
--- a/test/orm/inheritance/magazine.py
+++ b/test/orm/inheritance/magazine.py
@@ -118,7 +118,7 @@ class MagazineTest(testbase.ORMTest):
             Column('name', String(45), default=''),
         )
 
-def generate_round_trip_test(use_unions=False):
+def generate_round_trip_test(use_unions=False, use_joins=False):
     def test_roundtrip(self):
         publication_mapper = mapper(Publication, publication_table)
 
@@ -150,6 +150,9 @@ def generate_round_trip_test(use_unions=False):
                     'p': page_table.select(page_table.c.type=='p'),
                 }, None, 'page_join')
             page_mapper = mapper(Page, page_table, select_table=page_join, polymorphic_on=page_join.c.type, polymorphic_identity='p')
+        elif use_joins:
+            page_join = page_table.outerjoin(magazine_page_table).outerjoin(classified_page_table)
+            page_mapper = mapper(Page, page_table, select_table=page_join, polymorphic_on=page_table.c.type, polymorphic_identity='p')
         else:
             page_mapper = mapper(Page, page_table, polymorphic_on=page_table.c.type, polymorphic_identity='p')
 
@@ -162,15 +165,20 @@ def generate_round_trip_test(use_unions=False):
             magazine_page_mapper = mapper(MagazinePage, magazine_page_table, select_table=magazine_join, inherits=page_mapper, polymorphic_identity='m', properties={
                 'magazine': relation(Magazine, backref=backref('pages', order_by=magazine_join.c.page_no))
             })
+        elif use_joins:
+            magazine_join = page_table.join(magazine_page_table).outerjoin(classified_page_table)
+            magazine_page_mapper = mapper(MagazinePage, magazine_page_table, select_table=magazine_join, inherits=page_mapper, polymorphic_identity='m', properties={
+                'magazine': relation(Magazine, backref=backref('pages', order_by=page_table.c.page_no))
+            })
         else:
             magazine_page_mapper = mapper(MagazinePage, magazine_page_table, inherits=page_mapper, polymorphic_identity='m', properties={
                 'magazine': relation(Magazine, backref=backref('pages', order_by=page_table.c.page_no))
             })
 
         classified_page_mapper = mapper(ClassifiedPage, classified_page_table, inherits=magazine_page_mapper, polymorphic_identity='c', primary_key=[page_table.c.id])
-        compile_mappers()
-        print [str(s) for s in classified_page_mapper.primary_key]
-        print classified_page_mapper.columntoproperty[page_table.c.id]
+        #compile_mappers()
+        #print [str(s) for s in classified_page_mapper.primary_key]
+        #print classified_page_mapper.columntoproperty[page_table.c.id]
 
 
         session = create_session()
@@ -198,13 +206,13 @@ def generate_round_trip_test(use_unions=False):
 
         print p.issues[0].locations[0].magazine.pages
         print [page, page2, page3]
-        assert repr(p.issues[0].locations[0].magazine.pages) == repr([page, page2, page3])
+        assert repr(p.issues[0].locations[0].magazine.pages) == repr([page, page2, page3]), repr(p.issues[0].locations[0].magazine.pages)
     
-    test_roundtrip.__name__ = "test_%s" % (not use_union and "Nounion" or "Unions")
+    test_roundtrip.__name__ = "test_%s" % (not use_union and (use_joins and "joins" or "select") or "unions")
     setattr(MagazineTest, test_roundtrip.__name__, test_roundtrip)
     
-for use_union in [True, False]:
-    generate_round_trip_test(use_union)
+for (use_union, use_join) in [(True, False), (False, True), (False, False)]:
+    generate_round_trip_test(use_union, use_join)
 
         
 if __name__ == '__main__':