[Sqlalchemy-commits] [1032] sqlalchemy/branches/sql_rearrangement/test: w00p
Brought to you by:
zzzeek
Menu
▾
▴
[Sqlalchemy-commits] [1032] sqlalchemy/branches/sql_rearrangement/test: w00p
|
From: <co...@sq...> - 2006-02-25 05:18:02
|
<!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>[1032] sqlalchemy/branches/sql_rearrangement/test: w00p</title> </head> <body> <div id="msg"> <dl> <dt>Revision</dt> <dd>1032</dd> <dt>Author</dt> <dd>zzzeek</dd> <dt>Date</dt> <dd>2006-02-24 23:17:47 -0600 (Fri, 24 Feb 2006)</dd> </dl> <h3>Log Message</h3> <pre>w00p</pre> <h3>Modified Paths</h3> <ul> <li><a href="#sqlalchemybranchessql_rearrangementlibsqlalchemyansisqlpy">sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/ansisql.py</a></li> <li><a href="#sqlalchemybranchessql_rearrangementlibsqlalchemyschemapy">sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/schema.py</a></li> <li><a href="#sqlalchemybranchessql_rearrangementlibsqlalchemysqlpy">sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/sql.py</a></li> <li><a href="#sqlalchemybranchessql_rearrangementlibsqlalchemyutilpy">sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/util.py</a></li> <li><a href="#sqlalchemybranchessql_rearrangementtestselectpy">sqlalchemy/branches/sql_rearrangement/test/select.py</a></li> </ul> </div> <div id="patch"> <h3>Diff</h3> <a id="sqlalchemybranchessql_rearrangementlibsqlalchemyansisqlpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/ansisql.py (1031 => 1032)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/ansisql.py 2006-02-25 03:25:29 UTC (rev 1031) +++ sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/ansisql.py 2006-02-25 05:17:47 UTC (rev 1032) </span><span class="lines">@@ -257,10 +257,13 @@ </span><span class="cx"> l = co.label(co._label) </span><span class="cx"> l.accept_visitor(self) </span><span class="cx"> inner_columns[co._label] = l </span><del>- elif select.issubquery and isinstance(co, sql.ColumnClause) and co.table is not None: </del><ins>+ # TODO: figure this out, a ColumnClause with a select as a parent + # is different from any other kind of parent + elif select.issubquery and isinstance(co, sql.ColumnClause) and co.table is not None and not isinstance(co.table, sql.Select): </ins><span class="cx"> # SQLite doesnt like selecting from a subquery where the column </span><span class="cx"> # names look like table.colname, so add a label synonomous with </span><span class="cx"> # the column name </span><ins>+ print "ALALA", co.text, repr(co.table) </ins><span class="cx"> l = co.label(co.text) </span><span class="cx"> l.accept_visitor(self) </span><span class="cx"> inner_columns[self.get_str(l.obj)] = l </span><span class="lines">@@ -357,7 +360,6 @@ </span><span class="cx"> self.strings[table] = "" </span><span class="cx"> </span><span class="cx"> def visit_tableclause(self, table): </span><del>- print "HI" </del><span class="cx"> self.froms[table] = table.name </span><span class="cx"> self.strings[table] = "" </span><span class="cx"> </span><span class="lines">@@ -384,7 +386,7 @@ </span><span class="cx"> contains a Sequence object.""" </span><span class="cx"> pass </span><span class="cx"> </span><del>- def visit_insert_column(selef, column): </del><ins>+ def visit_insert_column(self, column): </ins><span class="cx"> """called when visiting an Insert statement, for each column in the table </span><span class="cx"> that is a NULL insert into the table""" </span><span class="cx"> pass </span><span class="lines">@@ -392,6 +394,8 @@ </span><span class="cx"> def visit_insert(self, insert_stmt): </span><span class="cx"> # set up a call for the defaults and sequences inside the table </span><span class="cx"> class DefaultVisitor(schema.SchemaVisitor): </span><ins>+ def visit_columnclause(s, c): + self.visit_insert_column(c) </ins><span class="cx"> def visit_column(s, c): </span><span class="cx"> self.visit_insert_column(c) </span><span class="cx"> def visit_column_default(s, cd): </span><span class="lines">@@ -424,7 +428,7 @@ </span><span class="cx"> return self.bindparam_string(p.key) </span><span class="cx"> else: </span><span class="cx"> p.accept_visitor(self) </span><del>- if isinstance(p, sql.ClauseElement): </del><ins>+ if isinstance(p, sql.ClauseElement) and not isinstance(p, sql.ColumnClause): </ins><span class="cx"> return "(" + self.get_str(p) + ")" </span><span class="cx"> else: </span><span class="cx"> return self.get_str(p) </span><span class="lines">@@ -464,14 +468,17 @@ </span><span class="cx"> else: </span><span class="cx"> parameters = self.parameters.copy() </span><span class="cx"> </span><ins>+ print "stmt", repr(stmt) </ins><span class="cx"> if stmt.parameters is not None: </span><span class="cx"> for k, v in stmt.parameters.iteritems(): </span><ins>+ print "k", k, "v", repr(v) </ins><span class="cx"> parameters.setdefault(k, v) </span><span class="cx"> </span><span class="cx"> # now go thru compiled params, get the Column object for each key </span><span class="cx"> d = {} </span><span class="cx"> for key, value in parameters.iteritems(): </span><del>- if isinstance(key, schema.Column): </del><ins>+ print "key", key, "value", repr(value) + if isinstance(key, sql.ColumnClause): </ins><span class="cx"> d[key] = value </span><span class="cx"> else: </span><span class="cx"> try: </span></span></pre></div> <a id="sqlalchemybranchessql_rearrangementlibsqlalchemyschemapy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/schema.py (1031 => 1032)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/schema.py 2006-02-25 03:25:29 UTC (rev 1031) +++ sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/schema.py 2006-02-25 05:17:47 UTC (rev 1032) </span><span class="lines">@@ -117,7 +117,7 @@ </span><span class="cx"> </span><span class="cx"> """ </span><span class="cx"> super(Table, self).__init__(name) </span><del>- self.engine = engine </del><ins>+ self._engine = engine </ins><span class="cx"> self.schema = kwargs.pop('schema', None) </span><span class="cx"> if self.schema is not None: </span><span class="cx"> self.fullname = "%s.%s" % (self.schema, self.name) </span><span class="lines">@@ -153,7 +153,7 @@ </span><span class="cx"> </span><span class="cx"> def append_column(self, column): </span><span class="cx"> if not column.hidden: </span><del>- self._columns[column.key] = self </del><ins>+ self._columns[column.key] = column </ins><span class="cx"> if column.primary_key: </span><span class="cx"> self.primary_key.append(column) </span><span class="cx"> column.table = self </span><span class="lines">@@ -227,11 +227,11 @@ </span><span class="cx"> super(Column, self).__init__(name, None) </span><span class="cx"> self.args = args </span><span class="cx"> self.key = kwargs.pop('key', name) </span><del>- self.primary_key = kwargs.pop('primary_key', False) </del><ins>+ self._primary_key = kwargs.pop('primary_key', False) </ins><span class="cx"> self.nullable = kwargs.pop('nullable', not self.primary_key) </span><span class="cx"> self.hidden = kwargs.pop('hidden', False) </span><span class="cx"> self.default = kwargs.pop('default', None) </span><del>- self.foreign_key = None </del><ins>+ self._foreign_key = None </ins><span class="cx"> self._orig = None </span><span class="cx"> self._parent = None </span><span class="cx"> if len(kwargs): </span><span class="lines">@@ -242,11 +242,13 @@ </span><span class="cx"> self.default._set_parent(self) </span><span class="cx"> </span><span class="cx"> self._init_items(*self.args) </span><del>- </del><ins>+ + primary_key = AttrProp('_primary_key') + foreign_key = AttrProp('_foreign_key') </ins><span class="cx"> original = property(lambda s: s._orig or s) </span><span class="cx"> parent = property(lambda s:s._parent or s) </span><span class="cx"> engine = property(lambda s: s.table.engine) </span><del>- columns = property(lambda self:[self.column]) </del><ins>+ columns = property(lambda self:[self]) </ins><span class="cx"> </span><span class="cx"> def __repr__(self): </span><span class="cx"> return "Column(%s)" % string.join( </span></span></pre></div> <a id="sqlalchemybranchessql_rearrangementlibsqlalchemysqlpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/sql.py (1031 => 1032)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/sql.py 2006-02-25 03:25:29 UTC (rev 1031) +++ sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/sql.py 2006-02-25 05:17:47 UTC (rev 1032) </span><span class="lines">@@ -174,7 +174,7 @@ </span><span class="cx"> An optional default value can be specified by the value parameter, and the optional type parameter </span><span class="cx"> is a sqlalchemy.types.TypeEngine object which indicates bind-parameter and result-set translation for </span><span class="cx"> this bind parameter.""" </span><del>- if isinstance(key, schema.Column): </del><ins>+ if isinstance(key, ColumnClause): </ins><span class="cx"> return BindParamClause(key.name, value, type=key.type) </span><span class="cx"> else: </span><span class="cx"> return BindParamClause(key, value, type=type) </span><span class="lines">@@ -953,7 +953,7 @@ </span><span class="cx"> in two modes, one where its just any text that will be placed into the select statement, </span><span class="cx"> and "column" mode, where it represents a column attached to a table.""" </span><span class="cx"> def __init__(self, text, selectable=None): </span><del>- self.text = text </del><ins>+ self.key = self.name = self.text = text </ins><span class="cx"> self.table = selectable </span><span class="cx"> self.type = sqltypes.NullTypeEngine() </span><span class="cx"> def _get_label(self): </span><span class="lines">@@ -961,8 +961,6 @@ </span><span class="cx"> return self.table.name + "_" + self.text </span><span class="cx"> else: </span><span class="cx"> return self.text </span><del>- name = property(lambda self:self.text) - key = property(lambda self:self.text) </del><span class="cx"> _label = property(_get_label) </span><span class="cx"> default_label = property(lambda s:s._label) </span><span class="cx"> def accept_visitor(self, visitor): </span><span class="lines">@@ -981,11 +979,15 @@ </span><span class="cx"> c = ColumnClause(name or self.text, selectable) </span><span class="cx"> selectable.columns[c.key] = c </span><span class="cx"> return c </span><ins>+ def _compare_type(self, obj): + return self.type + def _group_parenthesized(self): + return False </ins><span class="cx"> </span><span class="cx"> class TableClause(FromClause): </span><span class="cx"> def __init__(self, name, *columns): </span><span class="cx"> super(TableClause, self).__init__(name) </span><del>- self.name = self.id = name </del><ins>+ self.name = self.id = self.fullname = name </ins><span class="cx"> self._columns = util.OrderedProperties() </span><span class="cx"> self._foreign_keys = [] </span><span class="cx"> self._primary_key = [] </span><span class="lines">@@ -1181,6 +1183,9 @@ </span><span class="cx"> self.is_where = is_where </span><span class="cx"> def visit_compound_select(self, cs): </span><span class="cx"> self.visit_select(cs) </span><ins>+ # TODO: visit_column, visit_table arent from this module + def visit_column(self, c):pass + def visit_table(self, c):pass </ins><span class="cx"> def visit_select(self, select): </span><span class="cx"> if select is self.select: </span><span class="cx"> return </span><span class="lines">@@ -1300,6 +1305,7 @@ </span><span class="cx"> elif _is_literal(value): </span><span class="cx"> if _is_literal(key): </span><span class="cx"> col = self.table.c[key] </span><ins>+ print "COL", col </ins><span class="cx"> else: </span><span class="cx"> col = key </span><span class="cx"> try: </span><span class="lines">@@ -1307,6 +1313,9 @@ </span><span class="cx"> except KeyError: </span><span class="cx"> del parameters[key] </span><span class="cx"> return parameters </span><ins>+ + def _find_engine(self): + return self._engine </ins><span class="cx"> </span><span class="cx"> </span><span class="cx"> class Insert(UpdateBase): </span></span></pre></div> <a id="sqlalchemybranchessql_rearrangementlibsqlalchemyutilpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/util.py (1031 => 1032)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/util.py 2006-02-25 03:25:29 UTC (rev 1031) +++ sqlalchemy/branches/sql_rearrangement/lib/sqlalchemy/util.py 2006-02-25 05:17:47 UTC (rev 1032) </span><span class="lines">@@ -4,7 +4,7 @@ </span><span class="cx"> # This module is part of SQLAlchemy and is released under </span><span class="cx"> # the MIT License: http://www.opensource.org/licenses/mit-license.php </span><span class="cx"> </span><del>-__all__ = ['OrderedProperties', 'OrderedDict', 'generic_repr', 'HashSet'] </del><ins>+__all__ = ['OrderedProperties', 'OrderedDict', 'generic_repr', 'HashSet', 'AttrProp'] </ins><span class="cx"> import thread, weakref, UserList,string, inspect </span><span class="cx"> from exceptions import * </span><span class="cx"> </span><span class="lines">@@ -23,7 +23,21 @@ </span><span class="cx"> return HashSet(to_list(x)) </span><span class="cx"> else: </span><span class="cx"> return x </span><del>- </del><ins>+ +class AttrProp(object): + """a quick way to stick a property accessor on an object""" + def __init__(self, key): + self.key = key + def __set__(self, obj, value): + setattr(obj, self.key, value) + def __delete__(self, obj): + delattr(obj, self.key) + def __get__(self, obj, owner): + if obj is None: + return self + else: + return getattr(obj, self.key) + </ins><span class="cx"> def generic_repr(obj, exclude=None): </span><span class="cx"> L = ['%s=%s' % (a, repr(getattr(obj, a))) for a in dir(obj) if not callable(getattr(obj, a)) and not a.startswith('_') and (exclude is None or not exclude.has_key(a))] </span><span class="cx"> return '%s(%s)' % (obj.__class__.__name__, ','.join(L)) </span></span></pre></div> <a id="sqlalchemybranchessql_rearrangementtestselectpy"></a> <div class="modfile"><h4>Modified: sqlalchemy/branches/sql_rearrangement/test/select.py (1031 => 1032)</h4> <pre class="diff"><span> <span class="info">--- sqlalchemy/branches/sql_rearrangement/test/select.py 2006-02-25 03:25:29 UTC (rev 1031) +++ sqlalchemy/branches/sql_rearrangement/test/select.py 2006-02-25 05:17:47 UTC (rev 1032) </span><span class="lines">@@ -28,12 +28,12 @@ </span><span class="cx"> column('otherstuff'), </span><span class="cx"> ) </span><span class="cx"> </span><del>-table4 = table( - 'remotetable', - column('rem_id'), - column('datatype_id'), - column('value'), -# schema = 'remote_owner' </del><ins>+table4 = Table( + 'remotetable', db, + Column('rem_id', Integer, primary_key=True), + Column('datatype_id', Integer), + Column('value', String(20)), + schema = 'remote_owner' </ins><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> users = table('users', </span><span class="lines">@@ -303,31 +303,31 @@ </span><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> self.runtest( </span><del>- join(users, addresses).select(), </del><ins>+ join(users, addresses, users.c.user_id==addresses.c.user_id).select(), </ins><span class="cx"> "SELECT users.user_id, users.user_name, users.password, addresses.address_id, addresses.user_id, addresses.street, addresses.city, addresses.state, addresses.zip FROM users JOIN addresses ON users.user_id = addresses.user_id" </span><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> def testmultijoin(self): </span><span class="cx"> self.runtest( </span><del>- select([table, table2, table3], </del><ins>+ select([table1, table2, table3], </ins><span class="cx"> </span><del>- from_obj = [join(table, table2, table1.c.myid == table2.c.otherid).outerjoin(table3, table1.c.myid==table3.c.userid)] </del><ins>+ from_obj = [join(table1, table2, table1.c.myid == table2.c.otherid).outerjoin(table3, table1.c.myid==table3.c.userid)] </ins><span class="cx"> </span><span class="cx"> #from_obj = [outerjoin(join(table, table2, table1.c.myid == table2.c.otherid), table3, table1.c.myid==table3.c.userid)] </span><span class="cx"> ) </span><del>- ,"SELECT mytable.myid, mytable.name, mytable.description, myothertable.otherid, myothertable.othername, thirdtable1.userid, thirdtable1.otherstuff FROM mytable JOIN myothertable ON mytable.myid = myothertable.otherid LEFT OUTER JOIN thirdtable ON mytable.myid = thirdtable1.userid" </del><ins>+ ,"SELECT mytable.myid, mytable.name, mytable.description, myothertable.otherid, myothertable.othername, thirdtable.userid, thirdtable.otherstuff FROM mytable JOIN myothertable ON mytable.myid = myothertable.otherid LEFT OUTER JOIN thirdtable ON mytable.myid = thirdtable.userid" </ins><span class="cx"> ) </span><span class="cx"> self.runtest( </span><del>- select([table, table2, table3], - from_obj = [outerjoin(table, join(table2, table3, table2.c.otherid == table3.c.userid), table1.c.myid==table2.c.otherid)] </del><ins>+ select([table1, table2, table3], + from_obj = [outerjoin(table1, join(table2, table3, table2.c.otherid == table3.c.userid), table1.c.myid==table2.c.otherid)] </ins><span class="cx"> ) </span><del>- ,"SELECT mytable.myid, mytable.name, mytable.description, myothertable.otherid, myothertable.othername, thirdtable1.userid, thirdtable1.otherstuff FROM mytable LEFT OUTER JOIN (myothertable JOIN thirdtable ON myothertable.otherid = thirdtable1.userid) ON mytable.myid = myothertable.otherid" </del><ins>+ ,"SELECT mytable.myid, mytable.name, mytable.description, myothertable.otherid, myothertable.othername, thirdtable.userid, thirdtable.otherstuff FROM mytable LEFT OUTER JOIN (myothertable JOIN thirdtable ON myothertable.otherid = thirdtable.userid) ON mytable.myid = myothertable.otherid" </ins><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> def testunion(self): </span><span class="cx"> x = union( </span><del>- select([table], table1.c.myid == 5), - select([table], table1.c.myid == 12), </del><ins>+ select([table1], table1.c.myid == 5), + select([table1], table1.c.myid == 12), </ins><span class="cx"> order_by = [table1.c.myid], </span><span class="cx"> ) </span><span class="cx"> </span><span class="lines">@@ -338,14 +338,14 @@ </span><span class="cx"> </span><span class="cx"> self.runtest( </span><span class="cx"> union( </span><del>- select([table]), </del><ins>+ select([table1]), </ins><span class="cx"> select([table2]), </span><span class="cx"> select([table3]) </span><span class="cx"> ) </span><span class="cx"> , </span><span class="cx"> "SELECT mytable.myid, mytable.name, mytable.description \ </span><span class="cx"> FROM mytable UNION SELECT myothertable.otherid, myothertable.othername \ </span><del>-FROM myothertable UNION SELECT thirdtable1.userid, thirdtable1.otherstuff FROM thirdtable") </del><ins>+FROM myothertable UNION SELECT thirdtable.userid, thirdtable.otherstuff FROM thirdtable") </ins><span class="cx"> </span><span class="cx"> </span><span class="cx"> def testouterjoin(self): </span><span class="lines">@@ -355,14 +355,14 @@ </span><span class="cx"> # parameters. </span><span class="cx"> </span><span class="cx"> query = select( </span><del>- [table, table2], </del><ins>+ [table1, table2], </ins><span class="cx"> and_( </span><span class="cx"> table1.c.name == 'fred', </span><span class="cx"> table1.c.myid == 10, </span><span class="cx"> table2.c.othername != 'jack', </span><span class="cx"> "EXISTS (select yay from foo where boo = lar)" </span><span class="cx"> ), </span><del>- from_obj = [ outerjoin(table, table2, table1.c.myid == table2.c.otherid) ] </del><ins>+ from_obj = [ outerjoin(table1, table2, table1.c.myid == table2.c.otherid) ] </ins><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> self.runtest(query, </span><span class="lines">@@ -383,7 +383,7 @@ </span><span class="cx"> </span><span class="cx"> def testbindparam(self): </span><span class="cx"> self.runtest(select( </span><del>- [table, table2], </del><ins>+ [table1, table2], </ins><span class="cx"> and_(table1.c.myid == table2.c.otherid, </span><span class="cx"> table1.c.name == bindparam('mytablename'), </span><span class="cx"> ) </span><span class="lines">@@ -394,14 +394,14 @@ </span><span class="cx"> </span><span class="cx"> # check that the bind params sent along with a compile() call </span><span class="cx"> # get preserved when the params are retreived later </span><del>- s = select([table], table1.c.myid == bindparam('test')) - c = s.compile(parameters = {'test' : 7}) </del><ins>+ s = select([table1], table1.c.myid == bindparam('test')) + c = s.compile(parameters = {'test' : 7}, engine=db) </ins><span class="cx"> self.assert_(c.get_params() == {'test' : 7}) </span><span class="cx"> </span><span class="cx"> def testcorrelatedsubquery(self): </span><span class="cx"> self.runtest( </span><span class="cx"> table1.select(table1.c.myid == select([table2.c.otherid], table1.c.name == table2.c.othername)), </span><del>- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = (SELECT myothertable.otherid AS id FROM myothertable WHERE mytable.name = myothertable.othername)" </del><ins>+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = (SELECT myothertable.otherid AS otherid FROM myothertable WHERE mytable.name = myothertable.othername)" </ins><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> self.runtest( </span><span class="lines">@@ -410,10 +410,10 @@ </span><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> talias = table1.alias('ta') </span><del>- s = subquery('sq2', [talias], exists([1], table2.c.otherid == talias.c.id)) </del><ins>+ s = subquery('sq2', [talias], exists([1], table2.c.otherid == talias.c.myid)) </ins><span class="cx"> self.runtest( </span><del>- select([s, table]) - ,"SELECT sq2.id, sq2.name, sq2.description, mytable.myid, mytable.name, mytable.description FROM (SELECT ta.myid AS id, ta.name AS name, ta.description AS description FROM mytable AS ta WHERE EXISTS (SELECT 1 FROM myothertable WHERE myothertable.otherid = ta.myid)) AS sq2, mytable") </del><ins>+ select([s, table1]) + ,"SELECT sq2.myid, sq2.name, sq2.description, mytable.myid, mytable.name, mytable.description FROM (SELECT ta.myid AS myid, ta.name AS name, ta.description AS description FROM mytable AS ta WHERE EXISTS (SELECT 1 FROM myothertable WHERE myothertable.otherid = ta.myid)) AS sq2, mytable") </ins><span class="cx"> </span><span class="cx"> s = select([addresses.c.street], addresses.c.user_id==users.c.user_id).alias('s') </span><span class="cx"> self.runtest( </span><span class="lines">@@ -421,62 +421,61 @@ </span><span class="cx"> """SELECT users.user_id, users.user_name, users.password, s.street FROM users, (SELECT addresses.street AS street FROM addresses WHERE addresses.user_id = users.user_id) AS s""") </span><span class="cx"> </span><span class="cx"> def testin(self): </span><del>- self.runtest(select([table], table1.c.myid.in_(1, 2, 3)), </del><ins>+ self.runtest(select([table1], table1.c.myid.in_(1, 2, 3)), </ins><span class="cx"> "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :mytable_myid_1, :mytable_myid_2)") </span><span class="cx"> </span><del>- self.runtest(select([table], table1.c.myid.in_(select([table2.c.otherid]))), - "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (SELECT myothertable.otherid AS id FROM myothertable)") </del><ins>+ self.runtest(select([table1], table1.c.myid.in_(select([table2.c.otherid]))), + "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (SELECT myothertable.otherid AS otherid FROM myothertable)") </ins><span class="cx"> </span><span class="cx"> def testlateargs(self): </span><span class="cx"> """tests that a SELECT clause will have extra "WHERE" clauses added to it at compile time if extra arguments </span><span class="cx"> are sent""" </span><span class="cx"> </span><del>- self.runtest(table1.select(), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.name = :mytable_name AND mytable.myid = :mytable_myid", params={'id':'3', 'name':'jack'}) </del><ins>+ self.runtest(table1.select(), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.name = :mytable_name AND mytable.myid = :mytable_myid", params={'myid':'3', 'name':'jack'}) </ins><span class="cx"> </span><del>- self.runtest(table1.select(table1.c.name=='jack'), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :mytable_myid AND mytable.name = :mytable_name", params={'id':'3'}) </del><ins>+ self.runtest(table1.select(table1.c.name=='jack'), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :mytable_myid AND mytable.name = :mytable_name", params={'myid':'3'}) </ins><span class="cx"> </span><del>- self.runtest(table1.select(table1.c.name=='jack'), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :mytable_myid AND mytable.name = :mytable_name", params={'id':'3', 'name':'fred'}) </del><ins>+ self.runtest(table1.select(table1.c.name=='jack'), "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :mytable_myid AND mytable.name = :mytable_name", params={'myid':'3', 'name':'fred'}) </ins><span class="cx"> </span><span class="cx"> class CRUDTest(SQLTest): </span><span class="cx"> def testinsert(self): </span><span class="cx"> # generic insert, will create bind params for all columns </span><del>- self.runtest(insert(table), "INSERT INTO mytable (myid, name, description) VALUES (:myid, :name, :description)") </del><ins>+ self.runtest(insert(table1), "INSERT INTO mytable (myid, name, description) VALUES (:myid, :name, :description)") </ins><span class="cx"> </span><span class="cx"> # insert with user-supplied bind params for specific columns, </span><span class="cx"> # cols provided literally </span><span class="cx"> self.runtest( </span><del>- insert(table, {table1.c.myid : bindparam('userid'), table1.c.name : bindparam('username')}), </del><ins>+ insert(table1, {table1.c.myid : bindparam('userid'), table1.c.name : bindparam('username')}), </ins><span class="cx"> "INSERT INTO mytable (myid, name) VALUES (:userid, :username)") </span><span class="cx"> </span><span class="cx"> # insert with user-supplied bind params for specific columns, cols </span><span class="cx"> # provided as strings </span><span class="cx"> self.runtest( </span><del>- insert(table, dict(id = 3, name = 'jack')), </del><ins>+ insert(table1, dict(myid = 3, name = 'jack')), </ins><span class="cx"> "INSERT INTO mytable (myid, name) VALUES (:myid, :name)" </span><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> # test with a tuple of params instead of named </span><span class="cx"> self.runtest( </span><del>- insert(table, (3, 'jack', 'mydescription')), </del><ins>+ insert(table1, (3, 'jack', 'mydescription')), </ins><span class="cx"> "INSERT INTO mytable (myid, name, description) VALUES (:myid, :name, :description)", </span><span class="cx"> checkparams = {'myid':3, 'name':'jack', 'description':'mydescription'} </span><span class="cx"> ) </span><span class="cx"> </span><span class="cx"> def testupdate(self): </span><del>- self.runtest(update(table, table1.c.myid == 7), "UPDATE mytable SET name=:name WHERE mytable.myid = :mytable_myid", params = {table1.c.name:'fred'}) - self.runtest(update(table, table1.c.myid == 7), "UPDATE mytable SET name=:name WHERE mytable.myid = :mytable_myid", params = {'name':'fred'}) - self.runtest(update(table, values = {table1.c.name : table1.c.myid}), "UPDATE mytable SET name=mytable.myid") - self.runtest(update(table, whereclause = table1.c.name == bindparam('crit'), values = {table1.c.name : 'hi'}), "UPDATE mytable SET name=:name WHERE mytable.name = :crit", params = {'crit' : 'notthere'}) - self.runtest(update(table, table1.c.myid == 12, values = {table1.c.name : table1.c.myid}), "UPDATE mytable SET name=mytable.myid, description=:description WHERE mytable.myid = :mytable_myid", params = {'description':'test'}) - self.runtest(update(table, table1.c.myid == 12, values = {table1.c.myid : 9}), "UPDATE mytable SET myid=:myid, description=:description WHERE mytable.myid = :mytable_myid", params = {'mytable_myid': 12, 'myid': 9, 'description': 'test'}) </del><ins>+ self.runtest(update(table1, table1.c.myid == 7), "UPDATE mytable SET name=:name WHERE mytable.myid = :mytable_myid", params = {table1.c.name:'fred'}) + self.runtest(update(table1, table1.c.myid == 7), "UPDATE mytable SET name=:name WHERE mytable.myid = :mytable_myid", params = {'name':'fred'}) + self.runtest(update(table1, values = {table1.c.name : table1.c.myid}), "UPDATE mytable SET name=mytable.myid") + self.runtest(update(table1, whereclause = table1.c.name == bindparam('crit'), values = {table1.c.name : 'hi'}), "UPDATE mytable SET name=:name WHERE mytable.name = :crit", params = {'crit' : 'notthere'}) + self.runtest(update(table1, table1.c.myid == 12, values = {table1.c.name : table1.c.myid}), "UPDATE mytable SET name=mytable.myid, description=:description WHERE mytable.myid = :mytable_myid", params = {'description':'test'}) + self.runtest(update(table1, table1.c.myid == 12, values = {table1.c.myid : 9}), "UPDATE mytable SET myid=:myid, description=:description WHERE mytable.myid = :mytable_myid", params = {'mytable_myid': 12, 'myid': 9, 'description': 'test'}) </ins><span class="cx"> s = table1.update(table1.c.myid == 12, values = {table1.c.name : 'lala'}) </span><del>- print str(s) - c = s.compile(parameters = {'mytable_id':9,'name':'h0h0'}) </del><ins>+ c = s.compile(parameters = {'mytable_id':9,'name':'h0h0'}, engine=db) </ins><span class="cx"> print str(c) </span><span class="cx"> self.assert_(str(s) == str(c)) </span><span class="cx"> </span><span class="cx"> def testupdateexpression(self): </span><del>- self.runtest(update(table, </del><ins>+ self.runtest(update(table1, </ins><span class="cx"> (table1.c.myid == func.hoho(4)) & </span><span class="cx"> (table1.c.name == literal('foo') + table1.c.name + literal('lala')), </span><span class="cx"> values = { </span><span class="lines">@@ -486,16 +485,16 @@ </span><span class="cx"> </span><span class="cx"> def testcorrelatedupdate(self): </span><span class="cx"> # test against a straight text subquery </span><del>- u = update(table, values = {table1.c.name : text("select name from mytable where id=mytable.id")}) </del><ins>+ u = update(table1, values = {table1.c.name : text("select name from mytable where id=mytable.id")}) </ins><span class="cx"> self.runtest(u, "UPDATE mytable SET name=(select name from mytable where id=mytable.id)") </span><span class="cx"> </span><span class="cx"> # test against a regular constructed subquery </span><span class="cx"> s = select([table2], table2.c.otherid == table1.c.myid) </span><del>- u = update(table, table1.c.name == 'jack', values = {table1.c.name : s}) </del><ins>+ u = update(table1, table1.c.name == 'jack', values = {table1.c.name : s}) </ins><span class="cx"> self.runtest(u, "UPDATE mytable SET name=(SELECT myothertable.otherid, myothertable.othername FROM myothertable WHERE myothertable.otherid = mytable.myid) WHERE mytable.name = :mytable_name") </span><span class="cx"> </span><span class="cx"> def testdelete(self): </span><del>- self.runtest(delete(table, table1.c.myid == 7), "DELETE FROM mytable WHERE mytable.myid = :mytable_myid") </del><ins>+ self.runtest(delete(table1, table1.c.myid == 7), "DELETE FROM mytable WHERE mytable.myid = :mytable_myid") </ins><span class="cx"> </span><span class="cx"> class SchemaTest(SQLTest): </span><span class="cx"> def testselect(self): </span><span class="lines">@@ -508,7 +507,7 @@ </span><span class="cx"> </span><span class="cx"> def testalias(self): </span><span class="cx"> a = alias(table4, 'remtable') </span><del>- self.runtest(a.select(a.c.datatype_id==7), "SELECT remtable1.rem_id, remtable1.datatype_id, remtable1.value FROM remote_owner.remotetable AS remtable WHERE remtable1.datatype_id = :remtable_datatype_id") </del><ins>+ self.runtest(a.select(a.c.datatype_id==7), "SELECT remtable.rem_id, remtable.datatype_id, remtable.value FROM remote_owner.remotetable AS remtable WHERE remtable.datatype_id = :remtable_datatype_id") </ins><span class="cx"> </span><span class="cx"> def testupdate(self): </span><span class="cx"> self.runtest(table4.update(table4.c.value=='test', values={table4.c.datatype_id:12}), "UPDATE remote_owner.remotetable SET datatype_id=:datatype_id WHERE remotetable.value = :remotetable_value") </span></span></pre> </div> </div> </body> </html> |
