[Sqlalchemy-commits] [2265] sqlalchemy/branches/polymorphic_relations/test/sql: its good
Brought to you by:
zzzeek
Menu
▾
▴
[Sqlalchemy-commits] [2265] sqlalchemy/branches/polymorphic_relations/test/sql: its good
|
From: <co...@sq...> - 2007-01-28 19:31:26
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head><style type="text/css"><!-- #msg dl { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; } #msg dt { float: left; width: 6em; font-weight: bold; } #msg dt:after { content:':';} #msg dl, #msg dt, #msg ul, #msg li { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; } #msg dl a { font-weight: bold} #msg dl a:link { color:#fc3; } #msg dl a:active { color:#ff0; } #msg dl a:visited { color:#cc6; } h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; } #msg pre { overflow: auto; background: #ffc; border: 1px #fc0 solid; padding: 6px; } #msg ul, pre { overflow: auto; } #patch { width: 100%; } #patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;} #patch .propset h4, #patch .binary h4 {margin:0;} #patch pre {padding:0;line-height:1.2em;margin:0;} #patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;} #patch .propset .diff, #patch .binary .diff {padding:10px 0;} #patch span {display:block;padding:0 10px;} #patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;} #patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;} #patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;} #patch .lines, .info {color:#888;background:#fff;} --></style> <title>[2265] sqlalchemy/branches/polymorphic_relations/test/sql: its good</title> </head> <body> <div id="msg"> <dl> <dt>Revision</dt> <dd>2265</dd> <dt>Author</dt> <dd>zzzeek</dd> <dt>Date</dt> <dd>2007-01-28 15:33:00 -0600 (Sun, 28 Jan 2007)</dd> </dl> <h3>Log Message</h3> <pre>its good</pre> <h3>Modified Paths</h3> <ul> <li><a href="#sqlalchemybranchespolymorphic_relationslibsqlalchemyormmapperpy">sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/mapper.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationslibsqlalchemyormpropertiespy">sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/properties.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationslibsqlalchemyormstrategiespy">sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/strategies.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationslibsqlalchemysqlpy">sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/sql.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationstestorminheritance5py">sqlalchemy/branches/polymorphic_relations/test/orm/inheritance5.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationstestormrelationshipspy">sqlalchemy/branches/polymorphic_relations/test/orm/relationships.py</a></li> <li><a href="#sqlalchemybranchespolymorphic_relationstestsqlselectablepy">sqlalchemy/branches/polymorphic_relations/test/sql/selectable.py</a></li> </ul> </div> <div id="patch"> <h3>Diff</h3> <a id="sqlalchemybranchespolymorphic_relationslibsqlalchemyormmapperpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/mapper.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/mapper.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/mapper.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -458,6 +458,7 @@ </span><span class="cx"> # load custom properties </span><span class="cx"> if self.properties is not None: </span><span class="cx"> for key, prop in self.properties.iteritems(): </span><ins>+ print "COMPILING PROPERTY", key, type(prop), "WE ARE", str(self) </ins><span class="cx"> self._compile_property(key, prop, False) </span><span class="cx"> </span><span class="cx"> if self.inherits is not None: </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationslibsqlalchemyormpropertiespy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/properties.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/properties.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/properties.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -254,9 +254,19 @@ </span><span class="cx"> #print "DIRECTION IS ", self.direction, sync.ONETOMANY, sync.MANYTOONE </span><span class="cx"> #print "FKEY IS", self.foreignkey </span><span class="cx"> </span><ins>+ # get ready to create "polymorphic" primary/secondary join clauses. + # these clauses represent the same join between parent/child tables that the primary + # and secondary join clauses represent, except they reference ColumnElements that are specifically + # in the "polymorphic" selectables. these are used to construct joins for both Query as well as + # eager loading, and also are used to calculate "lazy loading" clauses. + + # as we will be using the polymorphic selectables (i.e. select_table argument to Mapper) to figure this out, + # first create maps of all the "equivalent" columns, since polymorphic selectables will often munge + # several "equivalent" columns (such as parent/child fk cols) into just one column. </ins><span class="cx"> parent_equivalents = self.parent._get_inherited_column_equivalents() </span><span class="cx"> target_equivalents = self.mapper._get_inherited_column_equivalents() </span><del>- print "EQUIVALENTS:", parent_equivalents, target_equivalents </del><ins>+ + # if the target mapper loads polymorphically, adapt the clauses to the target's selectable </ins><span class="cx"> if self.loads_polymorphic: </span><span class="cx"> if self.secondaryjoin: </span><span class="cx"> self.polymorphic_secondaryjoin = self.secondaryjoin.copy_container() </span><span class="lines">@@ -274,6 +284,7 @@ </span><span class="cx"> self.polymorphic_primaryjoin = self.primaryjoin.copy_container() </span><span class="cx"> self.polymorphic_secondaryjoin = self.secondaryjoin and self.secondaryjoin.copy_container() or None </span><span class="cx"> </span><ins>+ # if the parent mapper loads polymorphically, adapt the clauses to the parent's selectable </ins><span class="cx"> if self.parent.select_table is not self.parent.mapped_table: </span><span class="cx"> if self.direction is sync.ONETOMANY: </span><span class="cx"> self.polymorphic_primaryjoin.accept_visitor(sql_util.ClauseAdapter(self.parent.select_table, exclude=self.foreignkey, equivalents=parent_equivalents)) </span><span class="lines">@@ -282,6 +293,7 @@ </span><span class="cx"> elif self.secondaryjoin: </span><span class="cx"> self.polymorphic_primaryjoin.accept_visitor(sql_util.ClauseAdapter(self.parent.select_table, exclude=self.foreignkey, equivalents=parent_equivalents)) </span><span class="cx"> </span><ins>+ print "KEY", self.key, "PARENT", str(self.parent) </ins><span class="cx"> print "KEY", self.key, "REG PRIMARY JOIN", str(self.primaryjoin) </span><span class="cx"> print "KEY", self.key, "POLY PRIMARY JOIN", str(self.polymorphic_primaryjoin) </span><span class="cx"> </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationslibsqlalchemyormstrategiespy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/strategies.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/strategies.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/orm/strategies.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -151,7 +151,13 @@ </span><span class="cx"> class LazyLoader(AbstractRelationLoader): </span><span class="cx"> def init(self): </span><span class="cx"> super(LazyLoader, self).init() </span><del>- (self.lazywhere, self.lazybinds, self.lazyreverse) = self._create_lazy_clause(self.parent.unjoined_table, self.polymorphic_primaryjoin, self.polymorphic_secondaryjoin, self.foreignkey, self.remote_side, self.mapper.select_table) </del><ins>+ (self.lazywhere, self.lazybinds, self.lazyreverse) = self._create_lazy_clause( + self.parent.select_table, + self.mapper.select_table, + self.polymorphic_primaryjoin, + self.polymorphic_secondaryjoin, + self.foreignkey, + self.remote_side) </ins><span class="cx"> </span><span class="cx"> # determine if our "lazywhere" clause is the same as the mapper's </span><span class="cx"> # get() clause. then we can just use mapper.get() </span><span class="lines">@@ -236,12 +242,51 @@ </span><span class="cx"> # to load data into it. </span><span class="cx"> sessionlib.attribute_manager.reset_instance_attribute(instance, self.key) </span><span class="cx"> </span><del>- def _create_lazy_clause(self, table, primaryjoin, secondaryjoin, foreignkey, remote_side, select_table): </del><ins>+ def _create_lazy_clause(self, parenttable, targettable, primaryjoin, secondaryjoin, foreignkey, remote_side): </ins><span class="cx"> binds = {} </span><span class="cx"> reverse = {} </span><del>- def column_in_table(table, column): - return table.corresponding_column(column, raiseerr=False, keys_ok=False) is not None </del><span class="cx"> </span><ins>+ print "PARENTTABLE", parenttable, "TARGETTABLE", targettable + + + def should_bind(targetcol, othercol): + # determine if the given target column is part of the parent table + # portion of the join condition, in which case it gets converted + # to a bind param. + + # contains_column will return if this column is exactly in the table, with no + # proxying relationships. the table can be either the column's actual parent table, + # or a Join object containing the table. for a Select, Alias, or Union, the column + # needs to be the actual ColumnElement exported by that selectable, not the "originating" column. + inparent = parenttable.c.contains_column(targetcol) + + # check if its also in the target table. if this is a many-to-many relationship, + # then we dont care about target table presence + intarget = secondaryjoin is None and targettable.c.contains_column(targetcol) + + if inparent and not intarget: + # its in the parent and not the target, return true. + return True + elif inparent and intarget: + # its in both. hmm. + if parenttable is not targettable: + print "IN BOTH:", targetcol + # the column is in both tables, but the two tables are different. + # this corresponds to a table relating to a Join which also contains that table. + # such as tableA.c.col1 == tableB.c.col2, tables are tableA and tableA.join(tableB) + # in which case we only accept that the parenttable is the "base" table, not the "joined" table + return targetcol.table is parenttable + else: + # parent/target are the same table, i.e. circular reference. + # we have to rely on the "remote_side" argument + # and/or foreignkey collection. + # technically we can use this for the non-circular refs as well except that "remote_side" is usually + # only calculated for self-referential relationships at the moment. + # TODO: have PropertyLoader calculate remote_side completely ? + if col_in_collection(othercol, remote_side): + return True + return False + </ins><span class="cx"> if remote_side is None or len(remote_side) == 0: </span><span class="cx"> remote_side = foreignkey </span><span class="cx"> </span><span class="lines">@@ -269,14 +314,15 @@ </span><span class="cx"> rightcol = find_column_in_expr(binary.right) </span><span class="cx"> if leftcol is None or rightcol is None: </span><span class="cx"> return </span><del>- circular = leftcol.table is rightcol.table - if ((not circular and column_in_table(table, leftcol)) or (circular and col_in_collection(rightcol, remote_side))): </del><ins>+ if should_bind(leftcol, rightcol): </ins><span class="cx"> col = leftcol </span><span class="cx"> binary.left = binds.setdefault(leftcol, </span><span class="cx"> sql.bindparam(bind_label(), None, shortname=leftcol.name, type=binary.right.type)) </span><span class="cx"> reverse[rightcol] = binds[col] </span><span class="cx"> </span><del>- if (leftcol is not rightcol) and ((not circular and column_in_table(table, rightcol)) or (circular and col_in_collection(leftcol, remote_side))): </del><ins>+ # the "left is not right" compare is to handle part of a join clause that is "table.c.col1==table.c.col1", + # which can happen in rare cases + if leftcol is not rightcol and should_bind(rightcol, leftcol): </ins><span class="cx"> col = rightcol </span><span class="cx"> binary.right = binds.setdefault(rightcol, </span><span class="cx"> sql.bindparam(bind_label(), None, shortname=rightcol.name, type=binary.left.type)) </span><span class="lines">@@ -290,6 +336,7 @@ </span><span class="cx"> secondaryjoin = secondaryjoin.copy_container() </span><span class="cx"> lazywhere = sql.and_(lazywhere, secondaryjoin) </span><span class="cx"> </span><ins>+ print "LAZYCLAUSE", str(lazywhere) </ins><span class="cx"> LazyLoader.logger.info("create_lazy_clause " + str(lazywhere)) </span><span class="cx"> return (lazywhere, binds, reverse) </span><span class="cx"> </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationslibsqlalchemysqlpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/sql.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/sql.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/lib/sqlalchemy/sql.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -694,7 +694,12 @@ </span><span class="cx"> if c.shares_lineage(local): </span><span class="cx"> l.append(c==local) </span><span class="cx"> return and_(*l) </span><del>- </del><ins>+ def contains_column(self, col): + # have to use a Set here, because it will compare the identity + # of the column, not just using "==" for comparison which will always return a + # "True" value (i.e. a BinaryClause...) + return col in util.Set(self) + </ins><span class="cx"> class FromClause(Selectable): </span><span class="cx"> """represents an element that can be used within the FROM clause of a SELECT statement.""" </span><span class="cx"> def __init__(self, name=None): </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationstestorminheritance5py"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/test/orm/inheritance5.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/test/orm/inheritance5.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/test/orm/inheritance5.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -26,7 +26,11 @@ </span><span class="cx"> Column('manager_name', String(50)) </span><span class="cx"> ) </span><span class="cx"> </span><del>- def testbasic(self): </del><ins>+ def tearDown(self): + people.update(values={people.c.manager_id:None}).execute() + super(RelationTest1, self).tearDown() + + def testparentrefsdescendant(self): </ins><span class="cx"> class Person(AttrSettable): </span><span class="cx"> pass </span><span class="cx"> class Manager(Person): </span><span class="lines">@@ -60,11 +64,35 @@ </span><span class="cx"> m = session.query(Manager).get(m.person_id) </span><span class="cx"> print p, m, p.manager </span><span class="cx"> assert p.manager is m </span><ins>+ + def testdescendantrefsparent(self): + class Person(AttrSettable): + pass + class Manager(Person): + pass + + mapper(Person, people) + mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, properties={ + 'employee':relation(Person, primaryjoin=people.c.manager_id==managers.c.person_id, foreignkey=people.c.manager_id, uselist=False, post_update=True) + }) + + session = create_session() + p = Person(name='some person') + m = Manager(name='some manager') + m.employee = p + session.save(m) + session.flush() + session.clear() + + p = session.query(Person).get(p.person_id) + m = session.query(Manager).get(m.person_id) + print p, m, m.employee + assert m.employee is p </ins><span class="cx"> </span><span class="cx"> class RelationTest2(testbase.ORMTest): </span><span class="cx"> """test self-referential relationships on polymorphic mappers""" </span><span class="cx"> def define_tables(self, metadata): </span><del>- global people, managers </del><ins>+ global people, managers, data </ins><span class="cx"> people = Table('people', metadata, </span><span class="cx"> Column('person_id', Integer, Sequence('person_id_seq', optional=True), primary_key=True), </span><span class="cx"> Column('name', String(50)), </span><span class="lines">@@ -75,28 +103,66 @@ </span><span class="cx"> Column('manager_id', Integer, ForeignKey('people.person_id')), </span><span class="cx"> Column('status', String(30)), </span><span class="cx"> ) </span><del>- - def testrelationonsubclass(self): </del><ins>+ + data = Table('data', metadata, + Column('person_id', Integer, ForeignKey('managers.person_id'), primary_key=True), + Column('data', String(30)) + ) + + def testrelationonsubclass_j1_nodata(self): + self.do_test("join1", False) + def testrelationonsubclass_j2_nodata(self): + self.do_test("join2", False) + def testrelationonsubclass_j1_data(self): + self.do_test("join1", True) + def testrelationonsubclass_j2_data(self): + self.do_test("join2", True) + + def do_test(self, jointype="join1", usedata=False): </ins><span class="cx"> class Person(AttrSettable): </span><span class="cx"> pass </span><span class="cx"> class Manager(Person): </span><span class="cx"> pass </span><span class="cx"> </span><del>- poly_union = polymorphic_union({ - 'person':people.select(people.c.type=='person'), - 'manager':managers.join(people, people.c.person_id==managers.c.person_id) - }, None) </del><ins>+ if jointype == "join1": + poly_union = polymorphic_union({ + 'person':people.select(people.c.type=='person'), + 'manager':join(people, managers, people.c.person_id==managers.c.person_id) + }, None) + elif jointype == "join2": + poly_union = polymorphic_union({ + 'person':people.select(people.c.type=='person'), + 'manager':managers.join(people, people.c.person_id==managers.c.person_id) + }, None) </ins><span class="cx"> </span><del>- mapper(Person, people, select_table=poly_union, polymorphic_identity='person', polymorphic_on=people.c.type) - mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager', - properties={ - 'colleague':relation(Person, primaryjoin=managers.c.manager_id==people.c.person_id, uselist=False) - }) - class_mapper(Person).compile() </del><ins>+ if usedata: + class Data(object): + def __init__(self, data): + self.data = data + mapper(Data, data) + + mapper(Person, people, select_table=poly_union, polymorphic_identity='person', polymorphic_on=poly_union.c.type) + + if usedata: + mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager', + properties={ + 'colleague':relation(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy=True, uselist=False), + 'data':relation(Data, uselist=False) + } + ) + else: + mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager', + properties={ + 'colleague':relation(Person, primaryjoin=managers.c.manager_id==people.c.person_id, lazy=True, uselist=False) + } + ) + </ins><span class="cx"> sess = create_session() </span><span class="cx"> p = Person(name='person1') </span><span class="cx"> m = Manager(name='manager1') </span><span class="cx"> m.colleague = p </span><ins>+ if usedata: + m.data = Data('ms data') </ins><span class="cx"> sess.save(m) </span><span class="cx"> sess.flush() </span><span class="cx"> </span><span class="lines">@@ -106,11 +172,13 @@ </span><span class="cx"> print p </span><span class="cx"> print m </span><span class="cx"> assert m.colleague is p </span><ins>+ if usedata: + assert m.data.data == 'ms data' </ins><span class="cx"> </span><span class="cx"> class RelationTest3(testbase.ORMTest): </span><span class="cx"> """test self-referential relationships on polymorphic mappers""" </span><span class="cx"> def define_tables(self, metadata): </span><del>- global people, managers </del><ins>+ global people, managers, data </ins><span class="cx"> people = Table('people', metadata, </span><span class="cx"> Column('person_id', Integer, Sequence('person_id_seq', optional=True), primary_key=True), </span><span class="cx"> Column('colleague_id', Integer, ForeignKey('people.person_id')), </span><span class="lines">@@ -122,25 +190,60 @@ </span><span class="cx"> Column('status', String(30)), </span><span class="cx"> ) </span><span class="cx"> </span><del>- def testrelationonbaseclass(self): </del><ins>+ data = Table('data', metadata, + Column('person_id', Integer, ForeignKey('people.person_id'), primary_key=True), + Column('data', String(30)) + ) + + def testrelationonbaseclass_j1_nodata(self): + self.do_test("join1", False) + def testrelationonbaseclass_j2_nodata(self): + self.do_test("join2", False) + def testrelationonbaseclass_j1_data(self): + self.do_test("join1", True) + def testrelationonbaseclass_j2_data(self): + self.do_test("join2", True) + + def do_test(self, jointype="join1", usedata=False): </ins><span class="cx"> class Person(AttrSettable): </span><span class="cx"> pass </span><span class="cx"> class Manager(Person): </span><span class="cx"> pass </span><span class="cx"> </span><del>- poly_union = polymorphic_union({ - 'manager':managers.join(people, people.c.person_id==managers.c.person_id), - 'person':people.select(people.c.type=='person') - }, None) </del><ins>+ if usedata: + class Data(object): + def __init__(self, data): + self.data = data </ins><span class="cx"> </span><del>- mapper(Person, people, select_table=poly_union, polymorphic_identity='person', polymorphic_on=people.c.type, - properties={ - 'colleagues':relation(Person, primaryjoin=people.c.colleague_id==people.c.person_id, - remote_side=people.c.colleague_id, - uselist=True) - } - ) </del><ins>+ if jointype == "join1": + poly_union = polymorphic_union({ + 'manager':managers.join(people, people.c.person_id==managers.c.person_id), + 'person':people.select(people.c.type=='person') + }, None) + elif jointype =="join2": + poly_union = polymorphic_union({ + 'manager':join(people, managers, people.c.person_id==managers.c.person_id), + 'person':people.select(people.c.type=='person') + }, None) + + if usedata: + mapper(Data, data) + </ins><span class="cx"> mapper(Manager, managers, inherits=Person, inherit_condition=people.c.person_id==managers.c.person_id, polymorphic_identity='manager') </span><ins>+ if usedata: + mapper(Person, people, select_table=poly_union, polymorphic_identity='person', polymorphic_on=people.c.type, + properties={ + 'colleagues':relation(Person, primaryjoin=people.c.colleague_id==people.c.person_id, remote_side=people.c.colleague_id, uselist=True), + 'data':relation(Data, uselist=False) + } + ) + else: + mapper(Person, people, select_table=poly_union, polymorphic_identity='person', polymorphic_on=people.c.type, + properties={ + 'colleagues':relation(Person, primaryjoin=people.c.colleague_id==people.c.person_id, + remote_side=people.c.colleague_id, uselist=True) + } + ) </ins><span class="cx"> </span><span class="cx"> sess = create_session() </span><span class="cx"> p = Person(name='person1') </span><span class="lines">@@ -148,6 +251,10 @@ </span><span class="cx"> m = Manager(name='manager1') </span><span class="cx"> p.colleagues.append(p2) </span><span class="cx"> m.colleagues.append(p2) </span><ins>+ if usedata: + p.data = Data('ps data') + m.data = Data('ms data') + </ins><span class="cx"> sess.save(m) </span><span class="cx"> sess.save(p) </span><span class="cx"> sess.flush() </span><span class="lines">@@ -158,7 +265,11 @@ </span><span class="cx"> print p, p2, p.colleagues </span><span class="cx"> assert len(p.colleagues) == 1 </span><span class="cx"> assert p.colleagues == [p2] </span><ins>+ if usedata: + assert p.data.data == 'ps data' + assert m.data.data == 'ms data' </ins><span class="cx"> </span><ins>+ </ins><span class="cx"> class RelationTest4(testbase.ORMTest): </span><span class="cx"> def define_tables(self, metadata): </span><span class="cx"> global people, engineers, managers, cars </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationstestormrelationshipspy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/test/orm/relationships.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/test/orm/relationships.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/test/orm/relationships.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -173,7 +173,7 @@ </span><span class="cx"> assert sess.query(Employee).get([c1.company_id, 3]).reports_to.name == 'emp1' </span><span class="cx"> assert sess.query(Employee).get([c2.company_id, 3]).reports_to.name == 'emp5' </span><span class="cx"> </span><del>- def testimplict(self): </del><ins>+ def testimplicit(self): </ins><span class="cx"> """test with mappers that have the most minimal arguments""" </span><span class="cx"> class Company(object): </span><span class="cx"> pass </span></span></pre></div> <a id="sqlalchemybranchespolymorphic_relationstestsqlselectablepy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/polymorphic_relations/test/sql/selectable.py (2264 => 2265)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/polymorphic_relations/test/sql/selectable.py 2007-01-28 03:30:27 UTC (rev 2264) +++ sqlalchemy/branches/polymorphic_relations/test/sql/selectable.py 2007-01-28 21:33:00 UTC (rev 2265) </span><span class="lines">@@ -63,6 +63,21 @@ </span><span class="cx"> assert u.corresponding_column(s2.c.table2_coly) is u.c.coly </span><span class="cx"> assert s2.corresponding_column(u.c.coly) is s2.c.table2_coly </span><span class="cx"> </span><ins>+ def testfoo(self): + j1 = table.join(table2) + j2 = join(table, table2) + u1 = union( + table.select(table.c.col3==7), + select([j1]) + ) + u2 = union( + table.select(table.c.col3==7), + select([j2]) + ) + + assert table2.corresponding_column(u1.c.col1, raiseerr=False) is None + assert table2.corresponding_column(u2.c.col1, raiseerr=False) is None + </ins><span class="cx"> def testselectunion(self): </span><span class="cx"> # like testaliasunion, but off a Select off the union. </span><span class="cx"> u = select([table.c.col1, table.c.col2, table.c.col3, table.c.colx, null().label('coly')]).union( </span></span></pre> </div> </div> </body> </html> |