[Sqlalchemy-commits] [1010] sqlalchemy/trunk/test: merged eager loading overhaul rev 1001:1009
Brought to you by:
zzzeek
Menu
▾
▴
[Sqlalchemy-commits] [1010] sqlalchemy/trunk/test: merged eager loading overhaul rev 1001:1009
|
From: <co...@sq...> - 2006-02-22 07:46:28
|
<!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>[1010] sqlalchemy/trunk/test: merged eager loading overhaul rev 1001:1009</title> </head> <body> <div id="msg"> <dl> <dt>Revision</dt> <dd>1010</dd> <dt>Author</dt> <dd>zzzeek</dd> <dt>Date</dt> <dd>2006-02-20 13:45:08 -0600 (Mon, 20 Feb 2006)</dd> </dl> <h3>Log Message</h3> <pre>merged eager loading overhaul rev 1001:1009 this includes: sql.Alias object keeps track of the immediate thing it aliased as well as the ultimate non-aliased (usually a Table) object, so that proxied columns can have a "parent" attribute some cleanup to SelectBaseMixin.order_by_clause to allow easier access, needs more cleanup engine has been making two ResultProxies all this time, added "return_raw" quickie flag to disable that some cleanup to _get_col_by_original so that it also works for oid columns, new eager load stuff more aggressively aliaseses orderby's so this was needed EagerLoader now makes "chains" of unique aliased eager loaders in all cases. no need for use_alias/selectalias anymore since it aliases every time. properly detects recursive eager loads and terminates them with a lazyloader, instead of raising an exception. totally simplified setup() and init() is more straightforward and has a single codepath now instead of two or three.</pre> <h3>Modified Paths</h3> <ul> <li><a href="#sqlalchemytrunklibsqlalchemyansisqlpy">sqlalchemy/trunk/lib/sqlalchemy/ansisql.py</a></li> <li><a href="#sqlalchemytrunklibsqlalchemyenginepy">sqlalchemy/trunk/lib/sqlalchemy/engine.py</a></li> <li><a href="#sqlalchemytrunklibsqlalchemymappingpropertiespy">sqlalchemy/trunk/lib/sqlalchemy/mapping/properties.py</a></li> <li><a href="#sqlalchemytrunklibsqlalchemyschemapy">sqlalchemy/trunk/lib/sqlalchemy/schema.py</a></li> <li><a href="#sqlalchemytrunklibsqlalchemysqlpy">sqlalchemy/trunk/lib/sqlalchemy/sql.py</a></li> <li><a href="#sqlalchemytrunktestmapperpy">sqlalchemy/trunk/test/mapper.py</a></li> </ul> </div> <div id="patch"> <h3>Diff</h3> <a id="sqlalchemytrunklibsqlalchemyansisqlpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/lib/sqlalchemy/ansisql.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/lib/sqlalchemy/ansisql.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/lib/sqlalchemy/ansisql.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -239,8 +239,8 @@ </span><span class="cx"> return self.engine.bindtemplate % name </span><span class="cx"> </span><span class="cx"> def visit_alias(self, alias): </span><del>- self.froms[alias] = self.get_from_text(alias.selectable) + " AS " + alias.name - self.strings[alias] = self.get_str(alias.selectable) </del><ins>+ self.froms[alias] = self.get_from_text(alias.original) + " AS " + alias.name + self.strings[alias] = self.get_str(alias.original) </ins><span class="cx"> </span><span class="cx"> def visit_select(self, select): </span><span class="cx"> </span></span></pre></div> <a id="sqlalchemytrunklibsqlalchemyenginepy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/lib/sqlalchemy/engine.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/lib/sqlalchemy/engine.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/lib/sqlalchemy/engine.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -546,7 +546,7 @@ </span><span class="cx"> else: </span><span class="cx"> parameters = parameters.values() </span><span class="cx"> </span><del>- self.execute(statement, parameters, connection=connection, cursor=cursor) </del><ins>+ self.execute(statement, parameters, connection=connection, cursor=cursor, return_raw=True) </ins><span class="cx"> return cursor </span><span class="cx"> </span><span class="cx"> self.pre_exec(proxy, compiled, parameters, **kwargs) </span><span class="lines">@@ -555,7 +555,7 @@ </span><span class="cx"> self.post_exec(proxy, compiled, parameters, **kwargs) </span><span class="cx"> return ResultProxy(cursor, self, typemap=compiled.typemap) </span><span class="cx"> </span><del>- def execute(self, statement, parameters, connection=None, cursor=None, echo=None, typemap=None, commit=False, **kwargs): </del><ins>+ def execute(self, statement, parameters, connection=None, cursor=None, echo=None, typemap=None, commit=False, return_raw=False, **kwargs): </ins><span class="cx"> """executes the given string-based SQL statement with the given parameters. </span><span class="cx"> </span><span class="cx"> The parameters can be a dictionary or a list, or a list of dictionaries or lists, depending </span><span class="lines">@@ -606,7 +606,10 @@ </span><span class="cx"> except: </span><span class="cx"> self.do_rollback(connection) </span><span class="cx"> raise </span><del>- return ResultProxy(cursor, self, typemap=typemap) </del><ins>+ if return_raw: + return cursor + else: + return ResultProxy(cursor, self, typemap=typemap) </ins><span class="cx"> </span><span class="cx"> def _execute(self, c, statement, parameters): </span><span class="cx"> try: </span></span></pre></div> <a id="sqlalchemytrunklibsqlalchemymappingpropertiespy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/lib/sqlalchemy/mapping/properties.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/lib/sqlalchemy/mapping/properties.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/lib/sqlalchemy/mapping/properties.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -107,7 +107,7 @@ </span><span class="cx"> </span><span class="cx"> """describes an object property that holds a single item or list of items that correspond </span><span class="cx"> to a related database table.""" </span><del>- def __init__(self, argument, secondary, primaryjoin, secondaryjoin, foreignkey=None, uselist=None, private=False, association=None, use_alias=False, selectalias=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False): </del><ins>+ def __init__(self, argument, secondary, primaryjoin, secondaryjoin, foreignkey=None, uselist=None, private=False, association=None, use_alias=None, selectalias=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False): </ins><span class="cx"> self.uselist = uselist </span><span class="cx"> self.argument = argument </span><span class="cx"> self.secondary = secondary </span><span class="lines">@@ -127,11 +127,10 @@ </span><span class="cx"> </span><span class="cx"> self.private = private </span><span class="cx"> self.association = association </span><del>- if isinstance(selectalias, str): - print "'selectalias' argument to property is deprecated. please use 'use_alias=True'" - self.use_alias = True - else: - self.use_alias = use_alias </del><ins>+ if selectalias is not None: + print "'selectalias' argument to relation() is deprecated. eager loads automatically alias-ize tables now." + if use_alias is not None: + print "'use_alias' argument to relation() is deprecated. eager loads automatically alias-ize tables now." </ins><span class="cx"> self.order_by = order_by </span><span class="cx"> self.attributeext=attributeext </span><span class="cx"> self.backref = backref </span><span class="lines">@@ -289,7 +288,6 @@ </span><span class="cx"> elif self.association is not None: </span><span class="cx"> c = self.mapper._get_criterion(key, value) & self.primaryjoin </span><span class="cx"> return c.copy_container() </span><del>- </del><span class="cx"> return None </span><span class="cx"> </span><span class="cx"> def register_deleted(self, obj, uow): </span><span class="lines">@@ -743,107 +741,81 @@ </span><span class="cx"> </span><span class="cx"> if recursion_stack is None: </span><span class="cx"> recursion_stack = {} </span><del>- - if self.use_alias: - pass - - # figure out tables in the various join clauses we have, because user-defined - # whereclauses that reference the same tables will be converted to use - # aliases of those tables - self.to_alias = util.HashSet() - [self.to_alias.append(f) for f in self.primaryjoin._get_from_objects()] - if self.secondaryjoin is not None: - [self.to_alias.append(f) for f in self.secondaryjoin._get_from_objects()] - try: - del self.to_alias[parent.table] - except KeyError: - pass </del><span class="cx"> </span><del>- # if this eagermapper is to select using an "alias" to isolate it from other - # eager mappers against the same table, we have to redefine our secondary - # or primary join condition to reference the aliased table (and the order_by). - # else we set up the target clause objects as what they are defined in the - # superclass. - if self.use_alias: - self.eagertarget = self.target.alias() - aliasizer = Aliasizer(self.target, aliases={self.target:self.eagertarget}) - if self.secondaryjoin is not None: - self.eagersecondary = self.secondaryjoin.copy_container() - self.eagersecondary.accept_visitor(aliasizer) - self.eagerprimary = self.primaryjoin.copy_container() - self.eagerprimary.accept_visitor(aliasizer) - else: - self.eagerprimary = self.primaryjoin.copy_container() - self.eagerprimary.accept_visitor(aliasizer) - if self.order_by: - self.eager_order_by = [o.copy_container() for o in util.to_list(self.order_by)] - for i in range(0, len(self.eager_order_by)): - if isinstance(self.eager_order_by[i], schema.Column): - self.eager_order_by[i] = self.eagertarget._get_col_by_original(self.eager_order_by[i]) - else: - self.eager_order_by[i].accept_visitor(aliasizer) - else: - self.eager_order_by = self.order_by </del><ins>+ self.eagertarget = self.target.alias() + if self.secondary: + self.eagersecondary = self.secondary.alias() + self.aliasizer = Aliasizer(self.target, self.secondary, aliases={ + self.target:self.eagertarget, + self.secondary:self.eagersecondary + }) + self.eagersecondaryjoin = self.secondaryjoin.copy_container() + self.eagersecondaryjoin.accept_visitor(self.aliasizer) + self.eagerprimary = self.primaryjoin.copy_container() + self.eagerprimary.accept_visitor(self.aliasizer) + else: + self.aliasizer = Aliasizer(self.target, aliases={self.target:self.eagertarget}) + self.eagerprimary = self.primaryjoin.copy_container() + self.eagerprimary.accept_visitor(self.aliasizer) + + if self.order_by: + self.eager_order_by = self._aliasize_orderby(self.order_by) + else: + self.eager_order_by = None </ins><span class="cx"> </span><del>- # we have to propigate the "use_alias" fact into - # any sub-mappers that are also eagerloading so that they create a unique tablename - # as well. this copies our child mapper and replaces any eager properties on the - # new mapper with an equivalent eager property, just containing use_alias=True - eagerprops = [] - for key, prop in self.mapper.props.iteritems(): - if isinstance(prop, EagerLoader) and not prop.use_alias: - eagerprops.append(prop) - if len(eagerprops): - recursion_stack[self] = True - self.mapper = self.mapper.copy() - try: - for prop in eagerprops: - p = prop.copy() - p.use_alias=True - - self.mapper.props[prop.key] = p - - if recursion_stack.has_key(prop): - raise ArgumentError("Circular eager load relationship detected on " + str(self.mapper) + " " + key + repr(self.mapper.props)) - - p.do_init_subclass(prop.key, prop.parent, recursion_stack) - - p.eagerprimary = p.eagerprimary.copy_container() - aliasizer = Aliasizer(p.parent.table, aliases={p.parent.table:self.eagertarget}) - p.eagerprimary.accept_visitor(aliasizer) - finally: - del recursion_stack[self] - </del><ins>+ eagerprops = [] + # create a new "eager chain", starting from this eager loader and descending downwards + # through all sub-eagerloaders. this will copy all those eagerloaders and have them set up + # aliases distinct to this eager chain. if a recursive relationship to any of the tables is detected, + # the chain will terminate by copying that eager loader into a lazy loader. + for key, prop in self.mapper.props.iteritems(): + if isinstance(prop, EagerLoader): + eagerprops.append(prop) + if len(eagerprops): + recursion_stack[self.parent.table] = True + self.mapper = self.mapper.copy() + try: + for prop in eagerprops: + if recursion_stack.has_key(prop.target): + # recursion - set the relationship as a LazyLoader + p = EagerLazyOption(None, False).create_prop(self.mapper, prop.key) + continue + p = prop.copy() + self.mapper.props[prop.key] = p + #print "we are:", id(self), self.target.name, (self.secondary and self.secondary.name or "None"), self.parent.table.name + #print "prop is",id(prop), prop.target.name, (prop.secondary and prop.secondary.name or "None"), prop.parent.table.name + p.do_init_subclass(prop.key, prop.parent, recursion_stack) + p.eagerprimary = p.eagerprimary.copy_container() + aliasizer = Aliasizer(p.parent.table, aliases={p.parent.table:self.eagertarget}) + p.eagerprimary.accept_visitor(aliasizer) + #print "new eagertqarget", p.eagertarget.name, (p.secondary and p.secondary.name or "none"), p.parent.table.name + finally: + del recursion_stack[self.parent.table] + + def _aliasize_orderby(self, orderby, copy=True): + if copy: + orderby = [o.copy_container() for o in util.to_list(orderby)] </ins><span class="cx"> else: </span><del>- self.eagertarget = self.target - self.eagerprimary = self.primaryjoin - self.eagersecondary = self.secondaryjoin - self.eager_order_by = self.order_by - - def setup(self, key, statement, recursion_stack = None, eagertable=None, **options): </del><ins>+ orderby = util.to_list(orderby) + for i in range(0, len(orderby)): + if isinstance(orderby[i], schema.Column): + orderby[i] = self.eagertarget._get_col_by_original(orderby[i]) + else: + orderby[i].accept_visitor(self.aliasizer) + return orderby + + def setup(self, key, statement, eagertable=None, **options): </ins><span class="cx"> """add a left outer join to the statement thats being constructed""" </span><span class="cx"> </span><del>- if recursion_stack is None: - recursion_stack = {} - - if statement.whereclause is not None: - # "aliasize" the tables referenced in the user-defined whereclause to not - # collide with the tables used by the eager load - # note that we arent affecting the mapper's table, nor our own primary or secondary joins - aliasizer = Aliasizer(*self.to_alias) - statement.whereclause.accept_visitor(aliasizer) - for alias in aliasizer.aliases.values(): - statement.append_from(alias) - </del><span class="cx"> if hasattr(statement, '_outerjoin'): </span><span class="cx"> towrap = statement._outerjoin </span><span class="cx"> else: </span><span class="cx"> towrap = self.parent.table </span><span class="cx"> </span><span class="cx"> if self.secondaryjoin is not None: </span><del>- statement._outerjoin = sql.outerjoin(towrap, self.secondary, self.eagerprimary).outerjoin(self.eagertarget, self.eagersecondary) </del><ins>+ statement._outerjoin = sql.outerjoin(towrap, self.eagersecondary, self.eagerprimary).outerjoin(self.eagertarget, self.eagersecondaryjoin) </ins><span class="cx"> if self.order_by is False and self.secondary.default_order_by() is not None: </span><del>- statement.order_by(*self.secondary.default_order_by()) </del><ins>+ statement.order_by(*self.eagersecondary.default_order_by()) </ins><span class="cx"> else: </span><span class="cx"> statement._outerjoin = towrap.outerjoin(self.eagertarget, self.eagerprimary) </span><span class="cx"> if self.order_by is False and self.eagertarget.default_order_by() is not None: </span><span class="lines">@@ -851,16 +823,12 @@ </span><span class="cx"> </span><span class="cx"> if self.eager_order_by: </span><span class="cx"> statement.order_by(*util.to_list(self.eager_order_by)) </span><del>- </del><ins>+ elif getattr(statement, 'order_by_clause', None): + self._aliasize_orderby(statement.order_by_clause, False) + </ins><span class="cx"> statement.append_from(statement._outerjoin) </span><del>- recursion_stack[self] = True - try: - for key, value in self.mapper.props.iteritems(): - if recursion_stack.has_key(value): - raise InvalidRequestError("Circular eager load relationship detected on " + str(self.mapper) + " " + key + repr(self.mapper.props)) - value.setup(key, statement, recursion_stack=recursion_stack, eagertable=self.eagertarget) - finally: - del recursion_stack[self] </del><ins>+ for key, value in self.mapper.props.iteritems(): + value.setup(key, statement, eagertable=self.eagertarget) </ins><span class="cx"> </span><span class="cx"> def execute(self, instance, row, identitykey, imap, isnew): </span><span class="cx"> """receive a row. tell our mapper to look for a new object instance in the row, and attach </span><span class="lines">@@ -884,16 +852,10 @@ </span><span class="cx"> </span><span class="cx"> def _instance(self, row, imap, result_list=None): </span><span class="cx"> """gets an instance from a row, via this EagerLoader's mapper.""" </span><del>- # if we have an alias for our mapper's table via the use_alias - # parameter, we need to translate the - # aliased columns from the incoming row into a new row that maps - # the values against the columns of the mapper's original non-aliased table. - if self.use_alias: - fakerow = {} - fakerow = util.DictDecorator(row) - for c in self.eagertarget.c: - fakerow[c.original] = row[c] - row = fakerow </del><ins>+ fakerow = util.DictDecorator(row) + for c in self.eagertarget.c: + fakerow[c.parent] = row[c] + row = fakerow </ins><span class="cx"> return self.mapper._instance(row, imap, result_list) </span><span class="cx"> </span><span class="cx"> class GenericOption(MapperOption): </span><span class="lines">@@ -918,6 +880,7 @@ </span><span class="cx"> def create_prop(self, mapper, key): </span><span class="cx"> kwargs = util.constructor_args(oldprop) </span><span class="cx"> mapper.set_property(key, class_(**kwargs )) </span><ins>+ </ins><span class="cx"> </span><span class="cx"> class EagerLazyOption(GenericOption): </span><span class="cx"> """an option that switches a PropertyLoader to be an EagerLoader or LazyLoader""" </span><span class="lines">@@ -941,10 +904,6 @@ </span><span class="cx"> newprop = class_.__new__(class_) </span><span class="cx"> newprop.__dict__.update(oldprop.__dict__) </span><span class="cx"> newprop.do_init_subclass(key, mapper) </span><del>- if self.kwargs.get('selectalias', None): - newprop.use_alias = True - elif self.kwargs.get('use_alias', None) is not None: - newprop.use_alias = self.kwargs['use_alias'] </del><span class="cx"> mapper.set_property(key, newprop) </span><span class="cx"> </span><span class="cx"> class DeferredOption(GenericOption): </span><span class="lines">@@ -969,28 +928,26 @@ </span><span class="cx"> for t in tables: </span><span class="cx"> self.tables[t] = t </span><span class="cx"> self.binary = None </span><del>- self.match = False </del><span class="cx"> self.aliases = kwargs.get('aliases', {}) </span><del>- </del><span class="cx"> def get_alias(self, table): </span><span class="cx"> try: </span><span class="cx"> return self.aliases[table] </span><span class="cx"> except: </span><span class="cx"> return self.aliases.setdefault(table, sql.alias(table)) </span><del>- </del><span class="cx"> def visit_compound(self, compound): </span><del>- for i in range(0, len(compound.clauses)): - if isinstance(compound.clauses[i], schema.Column) and self.tables.has_key(compound.clauses[i].table): - compound.clauses[i] = self.get_alias(compound.clauses[i].table)._get_col_by_original(compound.clauses[i]) - self.match = True - </del><ins>+ self.visit_clauselist(compound) + def visit_clauselist(self, clist): + for i in range(0, len(clist.clauses)): + if isinstance(clist.clauses[i], schema.Column) and self.tables.has_key(clist.clauses[i].table): + orig = clist.clauses[i] + clist.clauses[i] = self.get_alias(clist.clauses[i].table)._get_col_by_original(clist.clauses[i]) + if clist.clauses[i] is None: + raise "cant get orig for " + str(orig) + " against table " + orig.table.name + " " + self.get_alias(orig.table).name </ins><span class="cx"> def visit_binary(self, binary): </span><span class="cx"> if isinstance(binary.left, schema.Column) and self.tables.has_key(binary.left.table): </span><span class="cx"> binary.left = self.get_alias(binary.left.table)._get_col_by_original(binary.left) </span><del>- self.match = True </del><span class="cx"> if isinstance(binary.right, schema.Column) and self.tables.has_key(binary.right.table): </span><span class="cx"> binary.right = self.get_alias(binary.right.table)._get_col_by_original(binary.right) </span><del>- self.match = True </del><span class="cx"> </span><span class="cx"> class BinaryVisitor(sql.ClauseVisitor): </span><span class="cx"> def __init__(self, func): </span></span></pre></div> <a id="sqlalchemytrunklibsqlalchemyschemapy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/lib/sqlalchemy/schema.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/lib/sqlalchemy/schema.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/lib/sqlalchemy/schema.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -248,10 +248,12 @@ </span><span class="cx"> self.default = kwargs.pop('default', None) </span><span class="cx"> self.foreign_key = None </span><span class="cx"> self._orig = None </span><ins>+ self._parent = None </ins><span class="cx"> if len(kwargs): </span><span class="cx"> raise ArgumentError("Unknown arguments passed to Column: " + repr(kwargs.keys())) </span><span class="cx"> </span><span class="cx"> original = property(lambda s: s._orig or s) </span><ins>+ parent = property(lambda s:s._parent or s) </ins><span class="cx"> engine = property(lambda s: s.table.engine) </span><span class="cx"> </span><span class="cx"> def __repr__(self): </span><span class="lines">@@ -307,6 +309,7 @@ </span><span class="cx"> c = Column(name or self.name, self.type, fk, self.default, key = name or self.key, primary_key = self.primary_key, nullable = self.nullable, hidden = self.hidden) </span><span class="cx"> c.table = selectable </span><span class="cx"> c._orig = self.original </span><ins>+ c._parent = self </ins><span class="cx"> if not c.hidden: </span><span class="cx"> selectable.columns[c.key] = c </span><span class="cx"> if self.primary_key: </span><span class="lines">@@ -369,7 +372,7 @@ </span><span class="cx"> </span><span class="cx"> def references(self, table): </span><span class="cx"> """returns True if the given table is referenced by this ForeignKey.""" </span><del>- return table._get_col_by_original(self.column) is not None </del><ins>+ return table._get_col_by_original(self.column, False) is not None </ins><span class="cx"> </span><span class="cx"> def _init_column(self): </span><span class="cx"> # ForeignKey inits its remote column as late as possible, so tables can </span></span></pre></div> <a id="sqlalchemytrunklibsqlalchemysqlpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/lib/sqlalchemy/sql.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/lib/sqlalchemy/sql.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/lib/sqlalchemy/sql.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -522,6 +522,7 @@ </span><span class="cx"> primary_key = property(lambda self:getattr(self, '_primary_key', False)) </span><span class="cx"> foreign_key = property(lambda self:getattr(self, '_foreign_key', False)) </span><span class="cx"> original = property(lambda self:getattr(self, '_original', self)) </span><ins>+ parent = property(lambda self:getattr(self, '_parent', self)) </ins><span class="cx"> columns = property(lambda self:[self]) </span><span class="cx"> def _make_proxy(self, selectable, name=None): </span><span class="cx"> """creates a new ColumnElement representing this ColumnElement as it appears in the select list </span><span class="lines">@@ -563,12 +564,19 @@ </span><span class="cx"> return Join(self, right, isouter = True, *args, **kwargs) </span><span class="cx"> def alias(self, name=None): </span><span class="cx"> return Alias(self, name) </span><del>- def _get_col_by_original(self, column): </del><ins>+ def _get_col_by_original(self, column, raiseerr=True): </ins><span class="cx"> """given a column which is a schema.Column object attached to a schema.Table object </span><span class="cx"> (i.e. an "original" column), return the Column object from this </span><span class="cx"> Selectable which corresponds to that original Column, or None if this Selectable </span><span class="cx"> does not contain the column.""" </span><del>- return self.original_columns.get(column.original, None) </del><ins>+ try: + return self.original_columns[column.original] + except KeyError: + if not raiseerr: + return None + else: + raise InvalidRequestError("cant get orig for " + str(column) + " with table " + column.table.id + " from table " + self.id) + </ins><span class="cx"> def _get_exported_attribute(self, name): </span><span class="cx"> try: </span><span class="cx"> return getattr(self, name) </span><span class="lines">@@ -595,6 +603,8 @@ </span><span class="cx"> for co in column.columns: </span><span class="cx"> cp = self._proxy_column(co) </span><span class="cx"> self._orig_cols[co.original] = cp </span><ins>+ if getattr(self, 'oid_column', None): + self._orig_cols[self.oid_column.original] = self.oid_column </ins><span class="cx"> def _exportable_columns(self): </span><span class="cx"> return [] </span><span class="cx"> def _proxy_column(self, column): </span><span class="lines">@@ -699,6 +709,8 @@ </span><span class="cx"> self.clauses.append(clause) </span><span class="cx"> def accept_visitor(self, visitor): </span><span class="cx"> for c in self.clauses: </span><ins>+ if c is None: + raise "oh weird" + repr(self.clauses) </ins><span class="cx"> c.accept_visitor(visitor) </span><span class="cx"> visitor.visit_clauselist(self) </span><span class="cx"> def _get_from_objects(self): </span><span class="lines">@@ -904,13 +916,17 @@ </span><span class="cx"> </span><span class="cx"> class Alias(FromClause): </span><span class="cx"> def __init__(self, selectable, alias = None): </span><del>- while isinstance(selectable, Alias): - selectable = selectable.selectable </del><ins>+ baseselectable = selectable + while isinstance(baseselectable, Alias): + baseselectable = baseselectable.selectable + self.original = baseselectable </ins><span class="cx"> self.selectable = selectable </span><span class="cx"> if alias is None: </span><del>- n = getattr(selectable, 'name') </del><ins>+ n = getattr(self.original, 'name') </ins><span class="cx"> if n is None: </span><span class="cx"> n = 'anon' </span><ins>+ elif len(n) > 15: + n = n[0:15] </ins><span class="cx"> alias = n + "_" + hex(random.randint(0, 65535))[2:] </span><span class="cx"> self.name = alias </span><span class="cx"> self.id = self.name </span><span class="lines">@@ -949,6 +965,7 @@ </span><span class="cx"> key = property(lambda s: s.name) </span><span class="cx"> _label = property(lambda s: s.name) </span><span class="cx"> original = property(lambda s:s.obj.original) </span><ins>+ parent = property(lambda s:s.obj.parent) </ins><span class="cx"> def accept_visitor(self, visitor): </span><span class="cx"> self.obj.accept_visitor(visitor) </span><span class="cx"> visitor.visit_label(self) </span><span class="lines">@@ -1009,7 +1026,8 @@ </span><span class="cx"> </span><span class="cx"> engine = property(lambda s: s.column.engine) </span><span class="cx"> default_label = property(lambda s:s._label) </span><del>- original = property(lambda self:self.column) </del><ins>+ original = property(lambda self:self.column.original) + parent = property(lambda self:self.column.parent) </ins><span class="cx"> columns = property(lambda self:[self.column]) </span><span class="cx"> </span><span class="cx"> def label(self, name): </span><span class="lines">@@ -1073,6 +1091,9 @@ </span><span class="cx"> self._orig_cols= {} </span><span class="cx"> for c in self.columns: </span><span class="cx"> self._orig_cols[c.original] = c </span><ins>+ oid = self.oid_column + if oid is not None: + self._orig_cols[oid.original] = oid </ins><span class="cx"> return self._orig_cols </span><span class="cx"> </span><span class="cx"> oid_column = property(_oid_col) </span><span class="lines">@@ -1132,13 +1153,18 @@ </span><span class="cx"> if not hasattr(self, attribute): </span><span class="cx"> l = ClauseList(*clauses) </span><span class="cx"> setattr(self, attribute, l) </span><del>- self.append_clause(prefix, l) </del><span class="cx"> else: </span><span class="cx"> getattr(self, attribute).clauses += clauses </span><del>- def append_clause(self, keyword, clause): - if type(clause) == str: - clause = TextClause(clause) - self.clauses.append((keyword, clause)) </del><ins>+ def _get_clauses(self): + # TODO: this is a little stupid. make ORDER BY/GROUP BY keywords handled by + # the compiler, make group_by_clause/order_by_clause regular attributes + x =[] + if getattr(self, 'group_by_clause', None): + x.append(("GROUP BY", self.group_by_clause)) + if getattr(self, 'order_by_clause', None): + x.append(("ORDER BY", self.order_by_clause)) + return x + clauses = property(_get_clauses) </ins><span class="cx"> def select(self, whereclauses = None, **params): </span><span class="cx"> return select([self], whereclauses, **params) </span><span class="cx"> def _get_from_objects(self): </span><span class="lines">@@ -1157,7 +1183,6 @@ </span><span class="cx"> for s in self.selects: </span><span class="cx"> s.group_by(None) </span><span class="cx"> s.order_by(None) </span><del>- self.clauses = [] </del><span class="cx"> group_by = kwargs.get('group_by', None) </span><span class="cx"> if group_by: </span><span class="cx"> self.group_by(*group_by) </span><span class="lines">@@ -1211,7 +1236,6 @@ </span><span class="cx"> # indicates if this select statement is a subquery as a criterion </span><span class="cx"> # inside of a WHERE clause </span><span class="cx"> self.is_where = False </span><del>- self.clauses = [] </del><span class="cx"> </span><span class="cx"> self.distinct = distinct </span><span class="cx"> self._text = None </span></span></pre></div> <a id="sqlalchemytrunktestmapperpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/trunk/test/mapper.py (1009 => 1010)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/trunk/test/mapper.py 2006-02-20 19:31:49 UTC (rev 1009) +++ sqlalchemy/trunk/test/mapper.py 2006-02-20 19:45:08 UTC (rev 1010) </span><span class="lines">@@ -538,7 +538,7 @@ </span><span class="cx"> self.assert_result(l, User, *user_all_result) </span><span class="cx"> objectstore.clear() </span><span class="cx"> m = mapper(Item, orderitems, is_primary=True, properties = dict( </span><del>- keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False), </del><ins>+ keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False, order_by=[keywords.c.keyword_id]), </ins><span class="cx"> )) </span><span class="cx"> 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) </span><span class="cx"> self.assert_result(l, Item, *[item_keyword_result[1], item_keyword_result[2]]) </span><span class="lines">@@ -617,6 +617,7 @@ </span><span class="cx"> """tests eager loading with two relations simulatneously, from the same table. """ </span><span class="cx"> openorders = alias(orders, 'openorders') </span><span class="cx"> closedorders = alias(orders, 'closedorders') </span><ins>+ ordermapper = mapper(Order, orders) </ins><span class="cx"> m = mapper(User, users, properties = dict( </span><span class="cx"> addresses = relation(mapper(Address, addresses), lazy = False), </span><span class="cx"> open_orders = relation(mapper(Order, openorders), primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = False), </span><span class="lines">@@ -659,7 +660,7 @@ </span><span class="cx"> items = orderitems </span><span class="cx"> </span><span class="cx"> m = mapper(Item, items, properties = dict( </span><del>- keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy=False), </del><ins>+ keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy=False, order_by=[keywords.c.keyword_id]), </ins><span class="cx"> )) </span><span class="cx"> l = m.select() </span><span class="cx"> self.assert_result(l, Item, *item_keyword_result) </span><span class="lines">@@ -678,7 +679,7 @@ </span><span class="cx"> </span><span class="cx"> m = mapper(Item, items, </span><span class="cx"> properties = dict( </span><del>- keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False), </del><ins>+ keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = False, order_by=[keywords.c.keyword_id]), </ins><span class="cx"> )) </span><span class="cx"> </span><span class="cx"> m = mapper(Order, orders, properties = dict( </span></span></pre> </div> </div> </body> </html> |
