diff options
| -rw-r--r-- | test/sql/test_case_statement.py | 4 | ||||
| -rw-r--r-- | test/sql/test_compiler.py | 1831 | ||||
| -rw-r--r-- | test/sql/test_constraints.py | 416 | ||||
| -rw-r--r-- | test/sql/test_cte.py | 352 | ||||
| -rw-r--r-- | test/sql/test_ddlemit.py | 133 | ||||
| -rw-r--r-- | test/sql/test_defaults.py | 8 | ||||
| -rw-r--r-- | test/sql/test_delete.py | 41 | ||||
| -rw-r--r-- | test/sql/test_functions.py | 149 | ||||
| -rw-r--r-- | test/sql/test_generative.py | 520 | ||||
| -rw-r--r-- | test/sql/test_insert.py | 180 | ||||
| -rw-r--r-- | test/sql/test_inspect.py | 11 | ||||
| -rw-r--r-- | test/sql/test_join_rewriting.py | 405 | ||||
| -rw-r--r-- | test/sql/test_labels.py | 353 | ||||
| -rw-r--r-- | test/sql/test_metadata.py | 944 | ||||
| -rw-r--r-- | test/sql/test_operators.py | 575 | ||||
| -rw-r--r-- | test/sql/test_query.py | 9 | ||||
| -rw-r--r-- | test/sql/test_quote.py | 463 | ||||
| -rw-r--r-- | test/sql/test_returning.py | 180 | ||||
| -rw-r--r-- | test/sql/test_rowcount.py | 42 | ||||
| -rw-r--r-- | test/sql/test_selectable.py | 624 | ||||
| -rw-r--r-- | test/sql/test_text.py | 192 | ||||
| -rw-r--r-- | test/sql/test_type_expressions.py | 80 | ||||
| -rw-r--r-- | test/sql/test_types.py | 34 | ||||
| -rw-r--r-- | test/sql/test_unicode.py | 66 | ||||
| -rw-r--r-- | test/sql/test_update.py | 195 | ||||
| -rw-r--r-- | tox.ini | 2 |
26 files changed, 4238 insertions, 3571 deletions
diff --git a/test/sql/test_case_statement.py b/test/sql/test_case_statement.py index 977bb00a4..f7025b360 100644 --- a/test/sql/test_case_statement.py +++ b/test/sql/test_case_statement.py @@ -143,12 +143,12 @@ class CaseTest(fixtures.TestBase, AssertsCompiledSQL): eq_(s.execute().fetchall(), [ ('no ', ), ('no ', ), ('no ', ), ('yes', ), ('no ', ), ('no ', ), - ]) + ]) else: eq_(s.execute().fetchall(), [ ('no', ), ('no', ), ('no', ), ('yes', ), ('no', ), ('no', ), - ]) + ]) @testing.fails_on('firebird', 'FIXME: unknown') def testcase_with_dict(self): diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py index 301cf149c..2b2083bf7 100644 --- a/test/sql/test_compiler.py +++ b/test/sql/test_compiler.py @@ -16,7 +16,7 @@ from sqlalchemy.testing import fixtures, AssertsCompiledSQL from sqlalchemy import Integer, String, MetaData, Table, Column, select, \ func, not_, cast, text, tuple_, exists, update, bindparam,\ literal, and_, null, type_coerce, alias, or_, literal_column,\ - Float, TIMESTAMP, Numeric, Date, Text, collate, union, except_,\ + Float, TIMESTAMP, Numeric, Date, Text, union, except_,\ intersect, union_all, Boolean, distinct, join, outerjoin, asc, desc,\ over, subquery, case, true import decimal @@ -26,15 +26,15 @@ from sqlalchemy.sql import table, column, label from sqlalchemy.sql.expression import ClauseList, _literal_as_text, HasPrefixes from sqlalchemy.engine import default from sqlalchemy.dialects import mysql, mssql, postgresql, oracle, \ - sqlite, sybase + sqlite, sybase from sqlalchemy.ext.compiler import compiles from sqlalchemy.sql import compiler table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), -) + column('myid', Integer), + column('name', String), + column('description', String), + ) table2 = table( 'myothertable', @@ -69,25 +69,25 @@ table5 = Table( ) users = table('users', - column('user_id'), - column('user_name'), - column('password'), -) + column('user_id'), + column('user_name'), + column('password'), + ) addresses = table('addresses', - column('address_id'), - column('user_id'), - column('street'), - column('city'), - column('state'), - column('zip') -) + column('address_id'), + column('user_id'), + column('street'), + column('city'), + column('state'), + column('zip') + ) keyed = Table('keyed', metadata, - Column('x', Integer, key='colx'), - Column('y', Integer, key='coly'), - Column('z', Integer), -) + Column('x', Integer, key='colx'), + Column('y', Integer, key='coly'), + Column('z', Integer), + ) class SelectTest(fixtures.TestBase, AssertsCompiledSQL): @@ -111,39 +111,44 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'columns; use this object directly within a ' 'column-level expression.', lambda: hasattr( - select([table1.c.myid]).as_scalar().self_group(), - 'columns')) + select([table1.c.myid]).as_scalar().self_group(), + 'columns')) assert_raises_message( exc.InvalidRequestError, 'Scalar Select expression has no ' 'columns; use this object directly within a ' 'column-level expression.', lambda: hasattr(select([table1.c.myid]).as_scalar(), - 'columns')) + 'columns')) else: assert not hasattr( - select([table1.c.myid]).as_scalar().self_group(), - 'columns') + select([table1.c.myid]).as_scalar().self_group(), + 'columns') assert not hasattr(select([table1.c.myid]).as_scalar(), 'columns') def test_prefix_constructor(self): class Pref(HasPrefixes): + def _generate(self): return self assert_raises(exc.ArgumentError, - Pref().prefix_with, - "some prefix", not_a_dialect=True - ) + Pref().prefix_with, + "some prefix", not_a_dialect=True + ) def test_table_select(self): self.assert_compile(table1.select(), "SELECT mytable.myid, mytable.name, " "mytable.description FROM mytable") - self.assert_compile(select([table1, table2]), - "SELECT mytable.myid, mytable.name, mytable.description, " - "myothertable.otherid, myothertable.othername FROM mytable, " - "myothertable") + self.assert_compile( + select( + [ + table1, + table2]), + "SELECT mytable.myid, mytable.name, mytable.description, " + "myothertable.otherid, myothertable.othername FROM mytable, " + "myothertable") def test_invalid_col_argument(self): assert_raises(exc.ArgumentError, select, table1) @@ -221,11 +226,11 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_limit_offset(self): for lim, offset, exp, params in [ (5, 10, "LIMIT :param_1 OFFSET :param_2", - {'param_1':5, 'param_2':10}), - (None, 10, "LIMIT -1 OFFSET :param_1", {'param_1':10}), - (5, None, "LIMIT :param_1", {'param_1':5}), + {'param_1': 5, 'param_2': 10}), + (None, 10, "LIMIT -1 OFFSET :param_1", {'param_1': 10}), + (5, None, "LIMIT :param_1", {'param_1': 5}), (0, 0, "LIMIT :param_1 OFFSET :param_2", - {'param_1':0, 'param_2':0}), + {'param_1': 0, 'param_2': 0}), ]: self.assert_compile( select([1]).limit(lim).offset(offset), @@ -233,19 +238,22 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): checkparams=params ) - - def test_select_precol_compile_ordering(self): s1 = select([column('x')]).select_from('a').limit(5).as_scalar() s2 = select([s1]).limit(10) class MyCompiler(compiler.SQLCompiler): + def get_select_precolumns(self, select): result = "" if select._limit: - result += "FIRST %s " % self.process(literal(select._limit)) + result += "FIRST %s " % self.process( + literal( + select._limit)) if select._offset: - result += "SKIP %s " % self.process(literal(select._offset)) + result += "SKIP %s " % self.process( + literal( + select._offset)) return result def limit_clause(self, select): @@ -262,7 +270,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): dialect=dialect ) - def test_from_subquery(self): """tests placing select statements in the column clause of another select, for the @@ -272,12 +279,12 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select( [s], - s.c.myid == 7 - ), - "SELECT myid, name, description FROM (SELECT mytable.myid AS myid, " - "mytable.name AS name, mytable.description AS description " - "FROM mytable " - "WHERE mytable.name = :name_1) WHERE myid = :myid_1") + s.c.myid == 7), + "SELECT myid, name, description FROM " + "(SELECT mytable.myid AS myid, " + "mytable.name AS name, mytable.description AS description " + "FROM mytable " + "WHERE mytable.name = :name_1) WHERE myid = :myid_1") sq = select([table1]) self.assert_compile( @@ -307,17 +314,17 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ).alias('sq') sqstring = "SELECT mytable.myid AS mytable_myid, mytable.name AS "\ - "mytable_name, mytable.description AS mytable_description, "\ - "myothertable.otherid AS myothertable_otherid, "\ - "myothertable.othername AS myothertable_othername FROM "\ - "mytable, myothertable WHERE mytable.myid = :myid_1 AND "\ - "myothertable.otherid = mytable.myid" + "mytable_name, mytable.description AS mytable_description, "\ + "myothertable.otherid AS myothertable_otherid, "\ + "myothertable.othername AS myothertable_othername FROM "\ + "mytable, myothertable WHERE mytable.myid = :myid_1 AND "\ + "myothertable.otherid = mytable.myid" self.assert_compile( - sq.select(), - "SELECT sq.mytable_myid, sq.mytable_name, " - "sq.mytable_description, sq.myothertable_otherid, " - "sq.myothertable_othername FROM (%s) AS sq" % sqstring) + sq.select(), + "SELECT sq.mytable_myid, sq.mytable_name, " + "sq.mytable_description, sq.myothertable_otherid, " + "sq.myothertable_othername FROM (%s) AS sq" % sqstring) sq2 = select( [sq], @@ -325,21 +332,21 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ).alias('sq2') self.assert_compile( - sq2.select(), - "SELECT sq2.sq_mytable_myid, sq2.sq_mytable_name, " - "sq2.sq_mytable_description, sq2.sq_myothertable_otherid, " - "sq2.sq_myothertable_othername FROM " - "(SELECT sq.mytable_myid AS " - "sq_mytable_myid, sq.mytable_name AS sq_mytable_name, " - "sq.mytable_description AS sq_mytable_description, " - "sq.myothertable_otherid AS sq_myothertable_otherid, " - "sq.myothertable_othername AS sq_myothertable_othername " - "FROM (%s) AS sq) AS sq2" % sqstring) + sq2.select(), + "SELECT sq2.sq_mytable_myid, sq2.sq_mytable_name, " + "sq2.sq_mytable_description, sq2.sq_myothertable_otherid, " + "sq2.sq_myothertable_othername FROM " + "(SELECT sq.mytable_myid AS " + "sq_mytable_myid, sq.mytable_name AS sq_mytable_name, " + "sq.mytable_description AS sq_mytable_description, " + "sq.myothertable_otherid AS sq_myothertable_otherid, " + "sq.myothertable_othername AS sq_myothertable_othername " + "FROM (%s) AS sq) AS sq2" % sqstring) def test_select_from_clauselist(self): self.assert_compile( select([ClauseList(column('a'), column('b'))] - ).select_from('sometable'), + ).select_from('sometable'), 'SELECT a, b FROM sometable' ) @@ -435,8 +442,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # using alternate keys. a, b, c = Column('a', Integer, key='b'), \ - Column('b', Integer), \ - Column('c', Integer, key='a') + Column('b', Integer), \ + Column('c', Integer, key='a') self.assert_compile( select([a, b, c, a, b, c]), "SELECT a, b, c", dialect=default.DefaultDialect() @@ -445,13 +452,13 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([bindparam('a'), bindparam('b'), bindparam('c')]), "SELECT :a AS anon_1, :b AS anon_2, :c AS anon_3", - dialect=default.DefaultDialect(paramstyle='named') + dialect=default.DefaultDialect(paramstyle='named') ) self.assert_compile( select([bindparam('a'), bindparam('b'), bindparam('c')]), "SELECT ? AS anon_1, ? AS anon_2, ? AS anon_3", - dialect=default.DefaultDialect(paramstyle='qmark'), + dialect=default.DefaultDialect(paramstyle='qmark'), ) self.assert_compile( @@ -490,90 +497,103 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): s2 = s1.alias() s3 = select([s2], use_labels=True) self.assert_compile(s3, - "SELECT anon_1.x AS anon_1_x, " - "anon_1.y AS anon_1_y, " - "anon_1.z AS anon_1_z FROM " - "(SELECT keyed.x AS x, keyed.y " - "AS y, keyed.z AS z FROM keyed) AS anon_1") + "SELECT anon_1.x AS anon_1_x, " + "anon_1.y AS anon_1_y, " + "anon_1.z AS anon_1_z FROM " + "(SELECT keyed.x AS x, keyed.y " + "AS y, keyed.z AS z FROM keyed) AS anon_1") s4 = s3.alias() s5 = select([s4], use_labels=True) self.assert_compile(s5, - "SELECT anon_1.anon_2_x AS anon_1_anon_2_x, " - "anon_1.anon_2_y AS anon_1_anon_2_y, " - "anon_1.anon_2_z AS anon_1_anon_2_z " - "FROM (SELECT anon_2.x AS anon_2_x, " - "anon_2.y AS anon_2_y, " - "anon_2.z AS anon_2_z FROM " - "(SELECT keyed.x AS x, keyed.y AS y, keyed.z " - "AS z FROM keyed) AS anon_2) AS anon_1" - ) + "SELECT anon_1.anon_2_x AS anon_1_anon_2_x, " + "anon_1.anon_2_y AS anon_1_anon_2_y, " + "anon_1.anon_2_z AS anon_1_anon_2_z " + "FROM (SELECT anon_2.x AS anon_2_x, " + "anon_2.y AS anon_2_y, " + "anon_2.z AS anon_2_z FROM " + "(SELECT keyed.x AS x, keyed.y AS y, keyed.z " + "AS z FROM keyed) AS anon_2) AS anon_1" + ) def test_exists(self): s = select([table1.c.myid]).where(table1.c.myid == 5) self.assert_compile(exists(s), - "EXISTS (SELECT mytable.myid FROM mytable " - "WHERE mytable.myid = :myid_1)" - ) + "EXISTS (SELECT mytable.myid FROM mytable " + "WHERE mytable.myid = :myid_1)" + ) self.assert_compile(exists(s.as_scalar()), - "EXISTS (SELECT mytable.myid FROM mytable " - "WHERE mytable.myid = :myid_1)" - ) + "EXISTS (SELECT mytable.myid FROM mytable " + "WHERE mytable.myid = :myid_1)" + ) self.assert_compile(exists([table1.c.myid], table1.c.myid - == 5).select(), + == 5).select(), 'SELECT EXISTS (SELECT mytable.myid FROM ' 'mytable WHERE mytable.myid = :myid_1)', params={'mytable_myid': 5}) self.assert_compile(select([table1, exists([1], - from_obj=table2)]), + from_obj=table2)]), 'SELECT mytable.myid, mytable.name, ' 'mytable.description, EXISTS (SELECT 1 ' 'FROM myothertable) FROM mytable', params={}) - self.assert_compile(select([table1, exists([1], - from_obj=table2).label('foo')]), + self.assert_compile(select([table1, + exists([1], + from_obj=table2).label('foo')]), 'SELECT mytable.myid, mytable.name, ' 'mytable.description, EXISTS (SELECT 1 ' 'FROM myothertable) AS foo FROM mytable', params={}) - self.assert_compile(table1.select(exists().where(table2.c.otherid - == table1.c.myid).correlate(table1)), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'EXISTS (SELECT * FROM myothertable WHERE ' - 'myothertable.otherid = mytable.myid)') - self.assert_compile(table1.select(exists().where(table2.c.otherid - == table1.c.myid).correlate(table1)), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'EXISTS (SELECT * FROM myothertable WHERE ' - 'myothertable.otherid = mytable.myid)') - self.assert_compile(table1.select(exists().where(table2.c.otherid - == table1.c.myid).correlate(table1) - ).replace_selectable(table2, - table2.alias()), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'EXISTS (SELECT * FROM myothertable AS ' - 'myothertable_1 WHERE myothertable_1.otheri' - 'd = mytable.myid)') - self.assert_compile(table1.select(exists().where(table2.c.otherid - == table1.c.myid).correlate(table1)).select_from( - table1.join(table2, - table1.c.myid - == table2.c.otherid)).replace_selectable(table2, - table2.alias()), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable JOIN ' - 'myothertable AS myothertable_1 ON ' - 'mytable.myid = myothertable_1.otherid ' - 'WHERE EXISTS (SELECT * FROM myothertable ' - 'AS myothertable_1 WHERE ' - 'myothertable_1.otherid = mytable.myid)') + self.assert_compile( + table1.select( + exists().where( + table2.c.otherid == table1.c.myid).correlate(table1)), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable WHERE ' + 'EXISTS (SELECT * FROM myothertable WHERE ' + 'myothertable.otherid = mytable.myid)') + self.assert_compile( + table1.select( + exists().where( + table2.c.otherid == table1.c.myid).correlate(table1)), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable WHERE ' + 'EXISTS (SELECT * FROM myothertable WHERE ' + 'myothertable.otherid = mytable.myid)') + self.assert_compile( + table1.select( + exists().where( + table2.c.otherid == table1.c.myid).correlate(table1) + ).replace_selectable( + table2, + table2.alias()), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable WHERE ' + 'EXISTS (SELECT * FROM myothertable AS ' + 'myothertable_1 WHERE myothertable_1.otheri' + 'd = mytable.myid)') + self.assert_compile( + table1.select( + exists().where( + table2.c.otherid == table1.c.myid).correlate(table1)). + select_from( + table1.join( + table2, + table1.c.myid == table2.c.otherid)). + replace_selectable( + table2, + table2.alias()), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable JOIN ' + 'myothertable AS myothertable_1 ON ' + 'mytable.myid = myothertable_1.otherid ' + 'WHERE EXISTS (SELECT * FROM myothertable ' + 'AS myothertable_1 WHERE ' + 'myothertable_1.otherid = mytable.myid)') self.assert_compile( select([ @@ -588,7 +608,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "myothertable.otherid = :otherid_2)) AS anon_1" ) - def test_where_subquery(self): s = select([addresses.c.street], addresses.c.user_id == users.c.user_id, correlate=True).alias('s') @@ -600,31 +619,36 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "(SELECT addresses.street AS street FROM " "addresses, users WHERE addresses.user_id = " "users.user_id) AS s") - self.assert_compile(table1.select(table1.c.myid - == select([table1.c.myid], table1.c.name - == 'jack')), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'mytable.myid = (SELECT mytable.myid FROM ' - 'mytable WHERE mytable.name = :name_1)') - self.assert_compile(table1.select(table1.c.myid - == select([table2.c.otherid], table1.c.name - == table2.c.othername)), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'mytable.myid = (SELECT ' - 'myothertable.otherid FROM myothertable ' - 'WHERE mytable.name = myothertable.othernam' - 'e)') + self.assert_compile(table1.select( + table1.c.myid == select( + [table1.c.myid], + table1.c.name == 'jack')), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable WHERE ' + 'mytable.myid = (SELECT mytable.myid FROM ' + 'mytable WHERE mytable.name = :name_1)') + self.assert_compile( + table1.select( + table1.c.myid == select( + [table2.c.otherid], + table1.c.name == table2.c.othername + ) + ), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable WHERE ' + 'mytable.myid = (SELECT ' + 'myothertable.otherid FROM myothertable ' + 'WHERE mytable.name = myothertable.othernam' + 'e)') self.assert_compile(table1.select(exists([1], table2.c.otherid - == table1.c.myid)), + == table1.c.myid)), 'SELECT mytable.myid, mytable.name, ' 'mytable.description FROM mytable WHERE ' 'EXISTS (SELECT 1 FROM myothertable WHERE ' 'myothertable.otherid = mytable.myid)') talias = table1.alias('ta') s = subquery('sq2', [talias], exists([1], table2.c.otherid - == talias.c.myid)) + == talias.c.myid)) self.assert_compile(select([s, table1]), 'SELECT sq2.myid, sq2.name, ' 'sq2.description, mytable.myid, ' @@ -635,7 +659,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'myothertable WHERE myothertable.otherid = ' 'ta.myid)) AS sq2, mytable') - # test constructing the outer query via append_column(), which # occurs in the ORM's Query object @@ -648,18 +671,22 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'EXISTS (SELECT 1 FROM myothertable WHERE ' 'myothertable.otherid = mytable.myid)') - def test_orderby_subquery(self): - self.assert_compile(table1.select(order_by=[select([table2.c.otherid], - table1.c.myid == table2.c.otherid)]), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable ORDER BY ' - '(SELECT myothertable.otherid FROM ' - 'myothertable WHERE mytable.myid = ' - 'myothertable.otherid)') + self.assert_compile( + table1.select( + order_by=[ + select( + [ + table2.c.otherid], + table1.c.myid == table2.c.otherid)]), + 'SELECT mytable.myid, mytable.name, ' + 'mytable.description FROM mytable ORDER BY ' + '(SELECT myothertable.otherid FROM ' + 'myothertable WHERE mytable.myid = ' + 'myothertable.otherid)') self.assert_compile(table1.select(order_by=[ desc(select([table2.c.otherid], - table1.c.myid == table2.c.otherid))]), + table1.c.myid == table2.c.otherid))]), 'SELECT mytable.myid, mytable.name, ' 'mytable.description FROM mytable ORDER BY ' '(SELECT myothertable.otherid FROM ' @@ -706,12 +733,12 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): s = select([table1.c.myid]).alias() self.assert_compile(select([table1.c.myid]).where(table1.c.myid - == s), + == s), 'SELECT mytable.myid FROM mytable WHERE ' 'mytable.myid = (SELECT mytable.myid FROM ' 'mytable)') self.assert_compile(select([table1.c.myid]).where(s - > table1.c.myid), + > table1.c.myid), 'SELECT mytable.myid FROM mytable WHERE ' 'mytable.myid < (SELECT mytable.myid FROM ' 'mytable)') @@ -728,14 +755,14 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'SELECT (SELECT mytable.myid FROM mytable) ' '- :param_1 AS anon_1') self.assert_compile(select([select([table1.c.name]).as_scalar() - + literal('x')]), + + literal('x')]), 'SELECT (SELECT mytable.name FROM mytable) ' '|| :param_1 AS anon_1') self.assert_compile(select([s > literal(8)]), 'SELECT (SELECT mytable.myid FROM mytable) ' '> :param_1 AS anon_1') self.assert_compile(select([select([table1.c.name]).label('foo' - )]), + )]), 'SELECT (SELECT mytable.name FROM mytable) ' 'AS foo') @@ -757,25 +784,25 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'object directly within a column-level expression.' zips = table('zips', - column('zipcode'), - column('latitude'), - column('longitude'), - ) + column('zipcode'), + column('latitude'), + column('longitude'), + ) places = table('places', - column('id'), - column('nm') - ) + column('id'), + column('nm') + ) zip = '12345' qlat = select([zips.c.latitude], zips.c.zipcode == zip).\ - correlate(None).as_scalar() + correlate(None).as_scalar() qlng = select([zips.c.longitude], zips.c.zipcode == zip).\ - correlate(None).as_scalar() + correlate(None).as_scalar() q = select([places.c.id, places.c.nm, zips.c.zipcode, - func.latlondist(qlat, qlng).label('dist')], - zips.c.zipcode == zip, - order_by=['dist', places.c.nm] - ) + func.latlondist(qlat, qlng).label('dist')], + zips.c.zipcode == zip, + order_by=['dist', places.c.nm] + ) self.assert_compile(q, 'SELECT places.id, places.nm, ' @@ -789,11 +816,11 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): zalias = zips.alias('main_zip') qlat = select([zips.c.latitude], zips.c.zipcode == zalias.c.zipcode).\ - as_scalar() + as_scalar() qlng = select([zips.c.longitude], zips.c.zipcode == zalias.c.zipcode).\ - as_scalar() + as_scalar() q = select([places.c.id, places.c.nm, zalias.c.zipcode, - func.latlondist(qlat, qlng).label('dist')], + func.latlondist(qlat, qlng).label('dist')], order_by=['dist', places.c.nm]) self.assert_compile(q, 'SELECT places.id, places.nm, ' @@ -827,9 +854,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_label_comparison_two(self): self.assert_compile( - label('bar', column('foo', type_=String)) + 'foo', - 'foo || :param_1') - + label('bar', column('foo', type_=String)) + 'foo', + 'foo || :param_1') def test_order_by_labels_enabled(self): lab1 = (table1.c.myid + 12).label('foo') @@ -837,11 +863,11 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): dialect = default.DefaultDialect() self.assert_compile(select([lab1, lab2]).order_by(lab1, desc(lab2)), - "SELECT mytable.myid + :myid_1 AS foo, " - "somefunc(mytable.name) AS bar FROM mytable " - "ORDER BY foo, bar DESC", - dialect=dialect - ) + "SELECT mytable.myid + :myid_1 AS foo, " + "somefunc(mytable.name) AS bar FROM mytable " + "ORDER BY foo, bar DESC", + dialect=dialect + ) # the function embedded label renders as the function self.assert_compile( @@ -854,11 +880,11 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # binary expressions render as the expression without labels self.assert_compile(select([lab1, lab2]).order_by(lab1 + "test"), - "SELECT mytable.myid + :myid_1 AS foo, " - "somefunc(mytable.name) AS bar FROM mytable " - "ORDER BY mytable.myid + :myid_1 + :param_1", - dialect=dialect - ) + "SELECT mytable.myid + :myid_1 AS foo, " + "somefunc(mytable.name) AS bar FROM mytable " + "ORDER BY mytable.myid + :myid_1 + :param_1", + dialect=dialect + ) # labels within functions in the columns clause render # with the expression @@ -868,8 +894,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "foo(mytable.myid + :myid_1) AS foo_1 FROM mytable " "ORDER BY foo, foo(mytable.myid + :myid_1)", dialect=dialect - ) - + ) lx = (table1.c.myid + table1.c.myid).label('lx') ly = (func.lower(table1.c.name) + table1.c.description).label('ly') @@ -880,19 +905,24 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "lower(mytable.name) || mytable.description AS ly " "FROM mytable ORDER BY lx, ly DESC", dialect=dialect - ) + ) def test_order_by_labels_disabled(self): lab1 = (table1.c.myid + 12).label('foo') lab2 = func.somefunc(table1.c.name).label('bar') dialect = default.DefaultDialect() dialect.supports_simple_order_by_label = False - self.assert_compile(select([lab1, lab2]).order_by(lab1, desc(lab2)), + self.assert_compile( + select( + [ + lab1, + lab2]).order_by( + lab1, + desc(lab2)), "SELECT mytable.myid + :myid_1 AS foo, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY mytable.myid + :myid_1, somefunc(mytable.name) DESC", - dialect=dialect - ) + dialect=dialect) self.assert_compile( select([lab1, lab2]).order_by(func.hoho(lab1), desc(lab2)), "SELECT mytable.myid + :myid_1 AS foo, " @@ -905,7 +935,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_conjunctions(self): a, b, c = 'a', 'b', 'c' x = and_(a, b, c) - assert isinstance(x.type, Boolean) + assert isinstance(x.type, Boolean) assert str(x) == 'a AND b AND c' self.assert_compile( select([x.label('foo')]), @@ -914,8 +944,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( and_(table1.c.myid == 12, table1.c.name == 'asdf', - table2.c.othername == 'foo', "sysdate() = today()"), - "mytable.myid = :myid_1 AND mytable.name = :name_1 "\ + table2.c.othername == 'foo', "sysdate() = today()"), + "mytable.myid = :myid_1 AND mytable.name = :name_1 " "AND myothertable.othername = " ":othername_1 AND sysdate() = today()" ) @@ -928,11 +958,11 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "sysdate() = today()", ), 'mytable.myid = :myid_1 AND (myothertable.othername = ' - ':othername_1 OR myothertable.othername = :othername_2 OR ' - 'myothertable.otherid = :otherid_1) AND sysdate() = ' - 'today()', + ':othername_1 OR myothertable.othername = :othername_2 OR ' + 'myothertable.otherid = :otherid_1) AND sysdate() = ' + 'today()', checkparams={'othername_1': 'asdf', 'othername_2': 'foo', - 'otherid_1': 9, 'myid_1': 12} + 'otherid_1': 9, 'myid_1': 12} ) # test a generator @@ -954,17 +984,28 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([t]).where(and_(t.c.x == 5, - or_(and_(or_(t.c.x == 7))))), + or_(and_(or_(t.c.x == 7))))), "SELECT t.x FROM t WHERE t.x = :x_1 AND t.x = :x_2" ) self.assert_compile( select([t]).where(and_(or_(t.c.x == 12, - and_(or_(t.c.x == 8))))), + and_(or_(t.c.x == 8))))), "SELECT t.x FROM t WHERE t.x = :x_1 OR t.x = :x_2" ) self.assert_compile( - select([t]).where(and_(or_(or_(t.c.x == 12), - and_(or_(), or_(and_(t.c.x == 8)), and_())))), + select([t]). + where( + and_( + or_( + or_(t.c.x == 12), + and_( + or_(), + or_(and_(t.c.x == 8)), + and_() + ) + ) + ) + ), "SELECT t.x FROM t WHERE t.x = :x_1 OR t.x = :x_2" ) @@ -1014,7 +1055,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT count(DISTINCT mytable.myid) AS count_1 FROM mytable" ) - def test_where_empty(self): self.assert_compile( select([table1.c.myid]).where(and_()), @@ -1028,7 +1068,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_multiple_col_binds(self): self.assert_compile( select(["*"], or_(table1.c.myid == 12, table1.c.myid == 'asdf', - table1.c.myid == 'foo')), + table1.c.myid == 'foo')), "SELECT * FROM mytable WHERE mytable.myid = :myid_1 " "OR mytable.myid = :myid_2 OR mytable.myid = :myid_3" ) @@ -1044,7 +1084,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table2.select(order_by=[ - table2.c.otherid, table2.c.othername.desc().nullslast()]), + table2.c.otherid, table2.c.othername.desc().nullslast()]), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " "myothertable.othername DESC NULLS LAST" @@ -1052,8 +1092,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table2.select(order_by=[ - table2.c.otherid.nullslast(), - table2.c.othername.desc().nullsfirst()]), + table2.c.otherid.nullslast(), + table2.c.othername.desc().nullsfirst()]), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid NULLS LAST, " "myothertable.othername DESC NULLS FIRST" @@ -1061,7 +1101,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table2.select(order_by=[table2.c.otherid.nullsfirst(), - table2.c.othername.desc()]), + table2.c.othername.desc()]), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid NULLS FIRST, " "myothertable.othername DESC" @@ -1069,7 +1109,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table2.select(order_by=[table2.c.otherid.nullsfirst(), - table2.c.othername.desc().nullslast()]), + table2.c.othername.desc().nullslast()]), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid NULLS FIRST, " "myothertable.othername DESC NULLS LAST" @@ -1078,7 +1118,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_orderby_groupby(self): self.assert_compile( table2.select(order_by=[table2.c.otherid, - asc(table2.c.othername)]), + asc(table2.c.othername)]), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " "myothertable.othername ASC" @@ -1094,8 +1134,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # generative order_by self.assert_compile( - table2.select().order_by(table2.c.otherid).\ - order_by(table2.c.othername.desc()), + table2.select().order_by(table2.c.otherid). + order_by(table2.c.othername.desc()), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " "myothertable.othername DESC" @@ -1103,16 +1143,16 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table2.select().order_by(table2.c.otherid). - order_by(table2.c.othername.desc() - ).order_by(None), + order_by(table2.c.othername.desc() + ).order_by(None), "SELECT myothertable.otherid, myothertable.othername " "FROM myothertable" ) self.assert_compile( select( - [table2.c.othername, func.count(table2.c.otherid)], - group_by=[table2.c.othername]), + [table2.c.othername, func.count(table2.c.otherid)], + group_by=[table2.c.othername]), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " "FROM myothertable GROUP BY myothertable.othername" @@ -1121,7 +1161,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # generative group by self.assert_compile( select([table2.c.othername, func.count(table2.c.otherid)]). - group_by(table2.c.othername), + group_by(table2.c.othername), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " "FROM myothertable GROUP BY myothertable.othername" @@ -1129,7 +1169,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table2.c.othername, func.count(table2.c.otherid)]). - group_by(table2.c.othername).group_by(None), + group_by(table2.c.othername).group_by(None), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " "FROM myothertable" @@ -1137,8 +1177,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table2.c.othername, func.count(table2.c.otherid)], - group_by=[table2.c.othername], - order_by=[table2.c.othername]), + group_by=[table2.c.othername], + order_by=[table2.c.othername]), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " "FROM myothertable " @@ -1163,7 +1203,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): table1.select, table1.c.myid == 7, for_update='unknown_mode' ) - def test_alias(self): # test the alias for a table1. column names stay the same, # table name "changes" to "foo". @@ -1188,9 +1227,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # also, only use one column from the second table and all columns # from the first table1. q = select( - [table1, table2.c.otherid], - table1.c.myid == table2.c.otherid, use_labels=True - ) + [table1, table2.c.otherid], + table1.c.myid == table2.c.otherid, use_labels=True + ) # make an alias of the "selectable". column names # stay the same (i.e. the labels), table name "changes" to "t2view". @@ -1207,20 +1246,19 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "t2view.mytable_description AS t2view_mytable_description, " "t2view.myothertable_otherid AS t2view_myothertable_otherid FROM " "(SELECT mytable.myid AS mytable_myid, " - "mytable.name AS mytable_name, " + "mytable.name AS mytable_name, " "mytable.description AS mytable_description, " - "myothertable.otherid AS " + "myothertable.otherid AS " "myothertable_otherid FROM mytable, myothertable " - "WHERE mytable.myid = " + "WHERE mytable.myid = " "myothertable.otherid) AS t2view " - "WHERE t2view.mytable_myid = :mytable_myid_1" + "WHERE t2view.mytable_myid = :mytable_myid_1" ) - def test_prefix(self): self.assert_compile( - table1.select().prefix_with("SQL_CALC_FOUND_ROWS").\ - prefix_with("SQL_SOME_WEIRD_MYSQL_THING"), + table1.select().prefix_with("SQL_CALC_FOUND_ROWS"). + prefix_with("SQL_SOME_WEIRD_MYSQL_THING"), "SELECT SQL_CALC_FOUND_ROWS SQL_SOME_WEIRD_MYSQL_THING " "mytable.myid, mytable.name, mytable.description FROM mytable" ) @@ -1228,9 +1266,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_prefix_dialect_specific(self): self.assert_compile( table1.select().prefix_with("SQL_CALC_FOUND_ROWS", - dialect='sqlite').\ - prefix_with("SQL_SOME_WEIRD_MYSQL_THING", - dialect='mysql'), + dialect='sqlite'). + prefix_with("SQL_SOME_WEIRD_MYSQL_THING", + dialect='mysql'), "SELECT SQL_SOME_WEIRD_MYSQL_THING " "mytable.myid, mytable.name, mytable.description FROM mytable", dialect=mysql.dialect() @@ -1242,6 +1280,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): SQL in the columns clause.""" dialect = default.DefaultDialect() + class Compiler(dialect.statement_compiler): ansi_bind_rules = True dialect.statement_compiler = Compiler @@ -1291,67 +1330,73 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.CompileError, - "Bind parameter 'foo' without a renderable value not allowed here.", - bindparam("foo").in_([]).compile, dialect=dialect - ) - + "Bind parameter 'foo' without a " + "renderable value not allowed here.", + bindparam("foo").in_( + []).compile, + dialect=dialect) def test_literal(self): self.assert_compile(select([literal('foo')]), - "SELECT :param_1 AS anon_1") + "SELECT :param_1 AS anon_1") - self.assert_compile(select([literal("foo") + literal("bar")], - from_obj=[table1]), + self.assert_compile( + select( + [ + literal("foo") + + literal("bar")], + from_obj=[table1]), "SELECT :param_1 || :param_2 AS anon_1 FROM mytable") def test_calculated_columns(self): value_tbl = table('values', - column('id', Integer), - column('val1', Float), - column('val2', Float), - ) + column('id', Integer), + column('val1', Float), + column('val2', Float), + ) self.assert_compile( - select([value_tbl.c.id, (value_tbl.c.val2 - - value_tbl.c.val1) / value_tbl.c.val1]), - "SELECT values.id, (values.val2 - values.val1) " - "/ values.val1 AS anon_1 FROM values" - ) + select([value_tbl.c.id, (value_tbl.c.val2 - + value_tbl.c.val1) / value_tbl.c.val1]), + "SELECT values.id, (values.val2 - values.val1) " + "/ values.val1 AS anon_1 FROM values" + ) self.assert_compile( - select([value_tbl.c.id], (value_tbl.c.val2 - - value_tbl.c.val1) / value_tbl.c.val1 > 2.0), - "SELECT values.id FROM values WHERE " - "(values.val2 - values.val1) / values.val1 > :param_1" - ) + select([ + value_tbl.c.id], + (value_tbl.c.val2 - value_tbl.c.val1) / + value_tbl.c.val1 > 2.0), + "SELECT values.id FROM values WHERE " + "(values.val2 - values.val1) / values.val1 > :param_1" + ) self.assert_compile( - select([value_tbl.c.id], value_tbl.c.val1 / - (value_tbl.c.val2 - value_tbl.c.val1) / - value_tbl.c.val1 > 2.0), - "SELECT values.id FROM values WHERE " - "(values.val1 / (values.val2 - values.val1)) " - "/ values.val1 > :param_1" - ) + select([value_tbl.c.id], value_tbl.c.val1 / + (value_tbl.c.val2 - value_tbl.c.val1) / + value_tbl.c.val1 > 2.0), + "SELECT values.id FROM values WHERE " + "(values.val1 / (values.val2 - values.val1)) " + "/ values.val1 > :param_1" + ) def test_percent_chars(self): t = table("table%name", - column("percent%"), - column("%(oneofthese)s"), - column("spaces % more spaces"), - ) + column("percent%"), + column("%(oneofthese)s"), + column("spaces % more spaces"), + ) self.assert_compile( t.select(use_labels=True), - '''SELECT "table%name"."percent%" AS "table%name_percent%", '''\ - '''"table%name"."%(oneofthese)s" AS '''\ - '''"table%name_%(oneofthese)s", '''\ - '''"table%name"."spaces % more spaces" AS '''\ - '''"table%name_spaces % '''\ + '''SELECT "table%name"."percent%" AS "table%name_percent%", ''' + '''"table%name"."%(oneofthese)s" AS ''' + '''"table%name_%(oneofthese)s", ''' + '''"table%name"."spaces % more spaces" AS ''' + '''"table%name_spaces % ''' '''more spaces" FROM "table%name"''' ) - def test_joins(self): self.assert_compile( join(table2, table1, table1.c.myid == table2.c.otherid).select(), @@ -1362,17 +1407,17 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select( - [table1], + [table1], from_obj=[join(table1, table2, table1.c.myid - == table2.c.otherid)] + == table2.c.otherid)] ), - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable JOIN myothertable ON mytable.myid = myothertable.otherid") + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable JOIN myothertable ON mytable.myid = myothertable.otherid") self.assert_compile( select( [join(join(table1, table2, table1.c.myid == table2.c.otherid), - table3, table1.c.myid == table3.c.userid)] + table3, table1.c.myid == table3.c.userid)] ), "SELECT mytable.myid, mytable.name, mytable.description, " "myothertable.otherid, myothertable.othername, " @@ -1385,7 +1430,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( join(users, addresses, users.c.user_id == - addresses.c.user_id).select(), + addresses.c.user_id).select(), "SELECT users.user_id, users.user_name, users.password, " "addresses.address_id, addresses.user_id, addresses.street, " "addresses.city, addresses.state, addresses.zip " @@ -1394,58 +1439,57 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ) self.assert_compile( - select([table1, table2, table3], + select([table1, table2, table3], - from_obj=[join(table1, table2, - table1.c.myid == table2.c.otherid). - outerjoin(table3, - table1.c.myid == table3.c.userid)] - ), - "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" - ) + from_obj=[join(table1, table2, + table1.c.myid == table2.c.otherid). + outerjoin(table3, + table1.c.myid == table3.c.userid)] + ), + "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" + ) self.assert_compile( - select([table1, table2, table3], - from_obj=[outerjoin(table1, - join(table2, table3, table2.c.otherid - == table3.c.userid), - table1.c.myid == table2.c.otherid)] - ), - "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" - ) + select([table1, table2, table3], + from_obj=[outerjoin(table1, + join(table2, table3, table2.c.otherid + == table3.c.userid), + table1.c.myid == table2.c.otherid)] + ), + "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" + ) query = select( - [table1, table2], - or_( - table1.c.name == 'fred', - table1.c.myid == 10, - table2.c.othername != 'jack', - "EXISTS (select yay from foo where boo = lar)" - ), - from_obj=[outerjoin(table1, table2, + [table1, table2], + or_( + table1.c.name == 'fred', + table1.c.myid == 10, + table2.c.othername != 'jack', + "EXISTS (select yay from foo where boo = lar)" + ), + from_obj=[outerjoin(table1, table2, table1.c.myid == table2.c.otherid)] - ) - self.assert_compile(query, - "SELECT mytable.myid, mytable.name, mytable.description, " + ) + self.assert_compile( + query, "SELECT mytable.myid, mytable.name, mytable.description, " "myothertable.otherid, myothertable.othername " "FROM mytable LEFT OUTER JOIN myothertable ON mytable.myid = " "myothertable.otherid WHERE mytable.name = :name_1 OR " "mytable.myid = :myid_1 OR myothertable.othername != :othername_1 " - "OR EXISTS (select yay from foo where boo = lar)", - ) + "OR EXISTS (select yay from foo where boo = lar)", ) def test_compound_selects(self): assert_raises_message( @@ -1457,42 +1501,42 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ) x = union( - select([table1], table1.c.myid == 5), - select([table1], table1.c.myid == 12), - order_by=[table1.c.myid], + select([table1], table1.c.myid == 5), + select([table1], table1.c.myid == 12), + order_by=[table1.c.myid], ) - self.assert_compile(x, - "SELECT mytable.myid, mytable.name, " - "mytable.description " - "FROM mytable WHERE " - "mytable.myid = :myid_1 UNION " - "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable WHERE mytable.myid = :myid_2 " - "ORDER BY mytable.myid") + self.assert_compile( + x, "SELECT mytable.myid, mytable.name, " + "mytable.description " + "FROM mytable WHERE " + "mytable.myid = :myid_1 UNION " + "SELECT mytable.myid, mytable.name, mytable.description " + "FROM mytable WHERE mytable.myid = :myid_2 " + "ORDER BY mytable.myid") x = union( - select([table1]), - select([table1]) + select([table1]), + select([table1]) ) x = union(x, select([table1])) - self.assert_compile(x, - "(SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable UNION SELECT mytable.myid, mytable.name, " - "mytable.description FROM mytable) UNION SELECT mytable.myid," - " mytable.name, mytable.description FROM mytable") + self.assert_compile( + x, "(SELECT mytable.myid, mytable.name, mytable.description " + "FROM mytable UNION SELECT mytable.myid, mytable.name, " + "mytable.description FROM mytable) UNION SELECT mytable.myid," + " mytable.name, mytable.description FROM mytable") u1 = union( select([table1.c.myid, table1.c.name]), select([table2]), select([table3]) ) - self.assert_compile(u1, - "SELECT mytable.myid, mytable.name " - "FROM mytable UNION SELECT myothertable.otherid, " - "myothertable.othername FROM myothertable " - "UNION SELECT thirdtable.userid, thirdtable.otherstuff " - "FROM thirdtable") + self.assert_compile( + u1, "SELECT mytable.myid, mytable.name " + "FROM mytable UNION SELECT myothertable.otherid, " + "myothertable.othername FROM myothertable " + "UNION SELECT thirdtable.userid, thirdtable.otherstuff " + "FROM thirdtable") assert u1.corresponding_column(table2.c.otherid) is u1.c.myid @@ -1514,9 +1558,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( union( select([table1.c.myid, table1.c.name, - func.max(table1.c.description)], - table1.c.name == 'name2', - group_by=[table1.c.myid, table1.c.name]), + func.max(table1.c.description)], + table1.c.name == 'name2', + group_by=[table1.c.myid, table1.c.name]), table1.select(table1.c.name == 'name1') ), "SELECT mytable.myid, mytable.name, " @@ -1532,8 +1576,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): union( select([literal(100).label('value')]), select([literal(200).label('value')]) - ), - "SELECT :param_1 AS value UNION SELECT :param_2 AS value" + ), + "SELECT :param_1 AS value UNION SELECT :param_2 AS value" ) self.assert_compile( @@ -1550,20 +1594,21 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT thirdtable.userid FROM thirdtable)" ) - s = select([column('foo'), column('bar')]) # ORDER BY's even though not supported by # all DB's, are rendered if requested - self.assert_compile(union(s.order_by("foo"), s.order_by("bar")), - "SELECT foo, bar ORDER BY foo UNION SELECT foo, bar ORDER BY bar" - ) + self.assert_compile( + union( + s.order_by("foo"), + s.order_by("bar")), + "SELECT foo, bar ORDER BY foo UNION SELECT foo, bar ORDER BY bar") # self_group() is honored self.assert_compile( union(s.order_by("foo").self_group(), - s.order_by("bar").limit(10).self_group()), + s.order_by("bar").limit(10).self_group()), "(SELECT foo, bar ORDER BY foo) UNION (SELECT foo, " - "bar ORDER BY bar LIMIT :param_1)", + "bar ORDER BY bar LIMIT :param_1)", {'param_1': 10} ) @@ -1588,7 +1633,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): union(s, union(s, union(s, s))), "SELECT foo, bar FROM bat UNION (SELECT foo, bar FROM bat " "UNION (SELECT foo, bar FROM bat " - "UNION SELECT foo, bar FROM bat))" + "UNION SELECT foo, bar FROM bat))" ) self.assert_compile( @@ -1601,14 +1646,14 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): select([union(s, s).alias()]), 'SELECT anon_1.foo, anon_1.bar FROM ' '(SELECT foo, bar FROM bat UNION ' - 'SELECT foo, bar FROM bat) AS anon_1' + 'SELECT foo, bar FROM bat) AS anon_1' ) self.assert_compile( select([except_(s, s).alias()]), 'SELECT anon_1.foo, anon_1.bar FROM ' '(SELECT foo, bar FROM bat EXCEPT ' - 'SELECT foo, bar FROM bat) AS anon_1' + 'SELECT foo, bar FROM bat) AS anon_1' ) # this query sqlite specifically chokes on @@ -1638,7 +1683,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ), "SELECT anon_1.foo, anon_1.bar FROM " "(SELECT foo, bar FROM bat EXCEPT " - "SELECT foo, bar FROM bat) AS anon_1 " + "SELECT foo, bar FROM bat) AS anon_1 " "UNION SELECT foo, bar FROM bat" ) @@ -1657,7 +1702,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "UNION (SELECT foo, bar FROM bat " "UNION SELECT foo, bar FROM bat)") - self.assert_compile( union( intersect(s, s), @@ -1665,137 +1709,141 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ), "(SELECT foo, bar FROM bat INTERSECT SELECT foo, bar FROM bat) " "UNION (SELECT foo, bar FROM bat INTERSECT " - "SELECT foo, bar FROM bat)" + "SELECT foo, bar FROM bat)" ) def test_binds(self): for ( - stmt, - expected_named_stmt, - expected_positional_stmt, - expected_default_params_dict, - expected_default_params_list, - test_param_dict, - expected_test_params_dict, - expected_test_params_list - ) in [ - ( - select( - [table1, table2], - and_( - table1.c.myid == table2.c.otherid, - table1.c.name == bindparam('mytablename') - )), - "SELECT mytable.myid, mytable.name, mytable.description, " - "myothertable.otherid, myothertable.othername FROM mytable, " - "myothertable WHERE mytable.myid = myothertable.otherid " - "AND mytable.name = :mytablename", - "SELECT mytable.myid, mytable.name, mytable.description, " - "myothertable.otherid, myothertable.othername FROM mytable, " - "myothertable WHERE mytable.myid = myothertable.otherid AND " - "mytable.name = ?", - {'mytablename':None}, [None], - {'mytablename':5}, {'mytablename':5}, [5] - ), - ( - select([table1], or_(table1.c.myid == bindparam('myid'), - table2.c.otherid == bindparam('myid'))), - "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable, myothertable WHERE mytable.myid = :myid " - "OR myothertable.otherid = :myid", - "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable, myothertable WHERE mytable.myid = ? " - "OR myothertable.otherid = ?", - {'myid': None}, [None, None], - {'myid': 5}, {'myid': 5}, [5, 5] - ), - ( - text("SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = :myid OR " - "myothertable.otherid = :myid"), - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = :myid OR " - "myothertable.otherid = :myid", - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = ? OR " - "myothertable.otherid = ?", - {'myid':None}, [None, None], - {'myid': 5}, {'myid': 5}, [5, 5] - ), - ( - select([table1], or_(table1.c.myid == - bindparam('myid', unique=True), - table2.c.otherid == - bindparam('myid', unique=True))), - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = " - ":myid_1 OR myothertable.otherid = :myid_2", - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = ? " - "OR myothertable.otherid = ?", - {'myid_1':None, 'myid_2':None}, [None, None], - {'myid_1': 5, 'myid_2': 6}, {'myid_1': 5, 'myid_2': 6}, [5, 6] - ), - ( + stmt, + expected_named_stmt, + expected_positional_stmt, + expected_default_params_dict, + expected_default_params_list, + test_param_dict, + expected_test_params_dict, + expected_test_params_list + ) in [ + ( + select( + [table1, table2], + and_( + table1.c.myid == table2.c.otherid, + table1.c.name == bindparam('mytablename') + )), + "SELECT mytable.myid, mytable.name, mytable.description, " + "myothertable.otherid, myothertable.othername FROM mytable, " + "myothertable WHERE mytable.myid = myothertable.otherid " + "AND mytable.name = :mytablename", + "SELECT mytable.myid, mytable.name, mytable.description, " + "myothertable.otherid, myothertable.othername FROM mytable, " + "myothertable WHERE mytable.myid = myothertable.otherid AND " + "mytable.name = ?", + {'mytablename': None}, [None], + {'mytablename': 5}, {'mytablename': 5}, [5] + ), + ( + select([table1], or_(table1.c.myid == bindparam('myid'), + table2.c.otherid == bindparam('myid'))), + "SELECT mytable.myid, mytable.name, mytable.description " + "FROM mytable, myothertable WHERE mytable.myid = :myid " + "OR myothertable.otherid = :myid", + "SELECT mytable.myid, mytable.name, mytable.description " + "FROM mytable, myothertable WHERE mytable.myid = ? " + "OR myothertable.otherid = ?", + {'myid': None}, [None, None], + {'myid': 5}, {'myid': 5}, [5, 5] + ), + ( + text("SELECT mytable.myid, mytable.name, " + "mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = :myid OR " + "myothertable.otherid = :myid"), + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = :myid OR " + "myothertable.otherid = :myid", + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = ? OR " + "myothertable.otherid = ?", + {'myid': None}, [None, None], + {'myid': 5}, {'myid': 5}, [5, 5] + ), + ( + select([table1], or_(table1.c.myid == + bindparam('myid', unique=True), + table2.c.otherid == + bindparam('myid', unique=True))), + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = " + ":myid_1 OR myothertable.otherid = :myid_2", + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = ? " + "OR myothertable.otherid = ?", + {'myid_1': None, 'myid_2': None}, [None, None], + {'myid_1': 5, 'myid_2': 6}, {'myid_1': 5, 'myid_2': 6}, [5, 6] + ), + ( bindparam('test', type_=String, required=False) + text("'hi'"), ":test || 'hi'", "? || 'hi'", - {'test':None}, [None], - {}, {'test':None}, [None] - ), - ( + {'test': None}, [None], + {}, {'test': None}, [None] + ), + ( # testing select.params() here - bindparam() objects # must get required flag set to False - select([table1], or_(table1.c.myid == bindparam('myid'), - table2.c.otherid == bindparam('myotherid'))).\ - params({'myid':8, 'myotherid':7}), - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = " - ":myid OR myothertable.otherid = :myotherid", - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = " - "? OR myothertable.otherid = ?", - {'myid': 8, 'myotherid': 7}, [8, 7], - {'myid': 5}, {'myid': 5, 'myotherid': 7}, [5, 7] - ), - ( - select([table1], or_(table1.c.myid == - bindparam('myid', value=7, unique=True), - table2.c.otherid == - bindparam('myid', value=8, unique=True))), - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = " - ":myid_1 OR myothertable.otherid = :myid_2", - "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable, myothertable WHERE mytable.myid = " - "? OR myothertable.otherid = ?", - {'myid_1': 7, 'myid_2': 8}, [7, 8], - {'myid_1': 5, 'myid_2': 6}, {'myid_1': 5, 'myid_2': 6}, [5, 6] - ), - ]: - - self.assert_compile(stmt, expected_named_stmt, - params=expected_default_params_dict) - self.assert_compile(stmt, expected_positional_stmt, - dialect=sqlite.dialect()) - nonpositional = stmt.compile() - positional = stmt.compile(dialect=sqlite.dialect()) - pp = positional.params - eq_([pp[k] for k in positional.positiontup], - expected_default_params_list) - - eq_(nonpositional.construct_params(test_param_dict), - expected_test_params_dict) - pp = positional.construct_params(test_param_dict) - eq_( - [pp[k] for k in positional.positiontup], - expected_test_params_list - ) + select( + [table1], + or_( + table1.c.myid == bindparam('myid'), + table2.c.otherid == bindparam('myotherid') + )).params({'myid': 8, 'myotherid': 7}), + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = " + ":myid OR myothertable.otherid = :myotherid", + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = " + "? OR myothertable.otherid = ?", + {'myid': 8, 'myotherid': 7}, [8, 7], + {'myid': 5}, {'myid': 5, 'myotherid': 7}, [5, 7] + ), + ( + select([table1], or_(table1.c.myid == + bindparam('myid', value=7, unique=True), + table2.c.otherid == + bindparam('myid', value=8, unique=True))), + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = " + ":myid_1 OR myothertable.otherid = :myid_2", + "SELECT mytable.myid, mytable.name, mytable.description FROM " + "mytable, myothertable WHERE mytable.myid = " + "? OR myothertable.otherid = ?", + {'myid_1': 7, 'myid_2': 8}, [7, 8], + {'myid_1': 5, 'myid_2': 6}, {'myid_1': 5, 'myid_2': 6}, [5, 6] + ), + ]: + + self.assert_compile(stmt, expected_named_stmt, + params=expected_default_params_dict) + self.assert_compile(stmt, expected_positional_stmt, + dialect=sqlite.dialect()) + nonpositional = stmt.compile() + positional = stmt.compile(dialect=sqlite.dialect()) + pp = positional.params + eq_([pp[k] for k in positional.positiontup], + expected_default_params_list) + + eq_(nonpositional.construct_params(test_param_dict), + expected_test_params_dict) + pp = positional.construct_params(test_param_dict) + eq_( + [pp[k] for k in positional.positiontup], + expected_test_params_list + ) # check that params() doesn't modify original statement s = select([table1], or_(table1.c.myid == bindparam('myid'), - table2.c.otherid == - bindparam('myotherid'))) + table2.c.otherid == + bindparam('myotherid'))) s2 = s.params({'myid': 8, 'myotherid': 7}) s3 = s2.params({'myid': 9}) assert s.compile().params == {'myid': None, 'myotherid': None} @@ -1805,9 +1853,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # test using same 'unique' param object twice in one compile s = select([table1.c.myid]).where(table1.c.myid == 12).as_scalar() s2 = select([table1, s], table1.c.myid == s) - self.assert_compile(s2, - "SELECT mytable.myid, mytable.name, mytable.description, " - "(SELECT mytable.myid FROM mytable WHERE mytable.myid = "\ + self.assert_compile( + s2, "SELECT mytable.myid, mytable.name, mytable.description, " + "(SELECT mytable.myid FROM mytable WHERE mytable.myid = " ":myid_1) AS anon_1 FROM mytable WHERE mytable.myid = " "(SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1)") positional = s2.compile(dialect=sqlite.dialect()) @@ -1817,18 +1865,18 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # check that conflicts with "unique" params are caught s = select([table1], or_(table1.c.myid == 7, - table1.c.myid == bindparam('myid_1'))) + table1.c.myid == bindparam('myid_1'))) assert_raises_message(exc.CompileError, - "conflicts with unique bind parameter " - "of the same name", - str, s) + "conflicts with unique bind parameter " + "of the same name", + str, s) s = select([table1], or_(table1.c.myid == 7, table1.c.myid == 8, - table1.c.myid == bindparam('myid_1'))) + table1.c.myid == bindparam('myid_1'))) assert_raises_message(exc.CompileError, - "conflicts with unique bind parameter " - "of the same name", - str, s) + "conflicts with unique bind parameter " + "of the same name", + str, s) def _test_binds_no_hash_collision(self): """test that construct_params doesn't corrupt dict @@ -1845,7 +1893,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): eq_(len(set(pp)), total_params, '%s %s' % (len(set(pp)), len(pp))) eq_(len(set(pp.values())), total_params) - def test_bind_as_col(self): t = table('foo', column('id')) @@ -1863,74 +1910,76 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ) def test_bind_params_missing(self): - assert_raises_message(exc.InvalidRequestError, + assert_raises_message( + exc.InvalidRequestError, r"A value is required for bind parameter 'x'", - select([table1]).where( - and_( - table1.c.myid == bindparam("x", required=True), - table1.c.name == bindparam("y", required=True) - ) - ).compile().construct_params, + select( + [table1]).where( + and_( + table1.c.myid == bindparam("x", required=True), + table1.c.name == bindparam("y", required=True) + ) + ).compile().construct_params, params=dict(y=5) ) - assert_raises_message(exc.InvalidRequestError, + assert_raises_message( + exc.InvalidRequestError, r"A value is required for bind parameter 'x'", - select([table1]).where( - table1.c.myid == bindparam("x", required=True) - ).compile().construct_params - ) + select( + [table1]).where( + table1.c.myid == bindparam( + "x", + required=True)).compile().construct_params) - assert_raises_message(exc.InvalidRequestError, + assert_raises_message( + exc.InvalidRequestError, r"A value is required for bind parameter 'x', " - "in parameter group 2", - select([table1]).where( - and_( - table1.c.myid == bindparam("x", required=True), - table1.c.name == bindparam("y", required=True) - ) - ).compile().construct_params, - params=dict(y=5), - _group_number=2 - ) + "in parameter group 2", + select( + [table1]).where( + and_( + table1.c.myid == bindparam("x", required=True), + table1.c.name == bindparam("y", required=True) + ) + ).compile().construct_params, + params=dict(y=5), _group_number=2) - assert_raises_message(exc.InvalidRequestError, + assert_raises_message( + exc.InvalidRequestError, r"A value is required for bind parameter 'x', " - "in parameter group 2", - select([table1]).where( - table1.c.myid == bindparam("x", required=True) - ).compile().construct_params, - _group_number=2 - ) - - - + "in parameter group 2", + select( + [table1]).where( + table1.c.myid == bindparam( + "x", + required=True)).compile().construct_params, + _group_number=2) def test_tuple(self): self.assert_compile( tuple_(table1.c.myid, table1.c.name).in_( - [(1, 'foo'), (5, 'bar')]), + [(1, 'foo'), (5, 'bar')]), "(mytable.myid, mytable.name) IN " "((:param_1, :param_2), (:param_3, :param_4))" ) self.assert_compile( tuple_(table1.c.myid, table1.c.name).in_( - [tuple_(table2.c.otherid, table2.c.othername)] - ), + [tuple_(table2.c.otherid, table2.c.othername)] + ), "(mytable.myid, mytable.name) IN " "((myothertable.otherid, myothertable.othername))" ) self.assert_compile( tuple_(table1.c.myid, table1.c.name).in_( - select([table2.c.otherid, table2.c.othername]) - ), + select([table2.c.otherid, table2.c.othername]) + ), "(mytable.myid, mytable.name) IN (SELECT " "myothertable.otherid, myothertable.othername FROM myothertable)" ) - def test_cast(self): tbl = table('casttest', column('id', Integer), @@ -1941,47 +1990,54 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def check_results(dialect, expected_results, literal): eq_(len(expected_results), 5, - 'Incorrect number of expected results') + 'Incorrect number of expected results') eq_(str(cast(tbl.c.v1, Numeric).compile(dialect=dialect)), - 'CAST(casttest.v1 AS %s)' % expected_results[0]) + 'CAST(casttest.v1 AS %s)' % expected_results[0]) eq_(str(cast(tbl.c.v1, Numeric(12, 9)).compile(dialect=dialect)), - 'CAST(casttest.v1 AS %s)' % expected_results[1]) + 'CAST(casttest.v1 AS %s)' % expected_results[1]) eq_(str(cast(tbl.c.ts, Date).compile(dialect=dialect)), - 'CAST(casttest.ts AS %s)' % expected_results[2]) + 'CAST(casttest.ts AS %s)' % expected_results[2]) eq_(str(cast(1234, Text).compile(dialect=dialect)), - 'CAST(%s AS %s)' % (literal, expected_results[3])) + 'CAST(%s AS %s)' % (literal, expected_results[3])) eq_(str(cast('test', String(20)).compile(dialect=dialect)), - 'CAST(%s AS %s)' % (literal, expected_results[4])) + 'CAST(%s AS %s)' % (literal, expected_results[4])) # fixme: shoving all of this dialect-specific stuff in one test # is now officialy completely ridiculous AND non-obviously omits # coverage on other dialects. - sel = select([tbl, cast(tbl.c.v1, Numeric)]).compile(dialect=dialect) + sel = select([tbl, cast(tbl.c.v1, Numeric)]).compile( + dialect=dialect) if isinstance(dialect, type(mysql.dialect())): eq_(str(sel), - "SELECT casttest.id, casttest.v1, casttest.v2, casttest.ts, " - "CAST(casttest.v1 AS DECIMAL) AS anon_1 \nFROM casttest") + "SELECT casttest.id, casttest.v1, casttest.v2, " + "casttest.ts, " + "CAST(casttest.v1 AS DECIMAL) AS anon_1 \nFROM casttest") else: eq_(str(sel), - "SELECT casttest.id, casttest.v1, casttest.v2, " - "casttest.ts, CAST(casttest.v1 AS NUMERIC) AS " - "anon_1 \nFROM casttest") + "SELECT casttest.id, casttest.v1, casttest.v2, " + "casttest.ts, CAST(casttest.v1 AS NUMERIC) AS " + "anon_1 \nFROM casttest") # first test with PostgreSQL engine - check_results(postgresql.dialect(), ['NUMERIC', 'NUMERIC(12, 9)', - 'DATE', 'TEXT', 'VARCHAR(20)'], '%(param_1)s') + check_results( + postgresql.dialect(), [ + 'NUMERIC', 'NUMERIC(12, 9)', 'DATE', 'TEXT', 'VARCHAR(20)'], + '%(param_1)s') # then the Oracle engine - check_results(oracle.dialect(), ['NUMERIC', 'NUMERIC(12, 9)', - 'DATE', 'CLOB', 'VARCHAR2(20 CHAR)'], ':param_1') + check_results( + oracle.dialect(), [ + 'NUMERIC', 'NUMERIC(12, 9)', 'DATE', + 'CLOB', 'VARCHAR2(20 CHAR)'], + ':param_1') # then the sqlite engine check_results(sqlite.dialect(), ['NUMERIC', 'NUMERIC(12, 9)', - 'DATE', 'TEXT', 'VARCHAR(20)'], '?') + 'DATE', 'TEXT', 'VARCHAR(20)'], '?') # then the MySQL engine check_results(mysql.dialect(), ['DECIMAL', 'DECIMAL(12, 9)', - 'DATE', 'CHAR', 'CHAR(20)'], '%s') + 'DATE', 'CHAR', 'CHAR(20)'], '%s') self.assert_compile(cast(text('NULL'), Integer), 'CAST(NULL AS INTEGER)', @@ -2108,25 +2164,23 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT x + foo() OVER () AS anon_1" ) - def test_date_between(self): import datetime table = Table('dt', metadata, - Column('date', Date)) + Column('date', Date)) self.assert_compile( table.select(table.c.date.between(datetime.date(2006, 6, 1), - datetime.date(2006, 6, 5))), + datetime.date(2006, 6, 5))), "SELECT dt.date FROM dt WHERE dt.date BETWEEN :date_1 AND :date_2", checkparams={'date_1': datetime.date(2006, 6, 1), - 'date_2': datetime.date(2006, 6, 5)}) + 'date_2': datetime.date(2006, 6, 5)}) self.assert_compile( table.select(sql.between(table.c.date, datetime.date(2006, 6, 1), - datetime.date(2006, 6, 5))), + datetime.date(2006, 6, 5))), "SELECT dt.date FROM dt WHERE dt.date BETWEEN :date_1 AND :date_2", checkparams={'date_1': datetime.date(2006, 6, 1), - 'date_2': datetime.date(2006, 6, 5)}) - + 'date_2': datetime.date(2006, 6, 5)}) def test_delayed_col_naming(self): my_str = Column(String) @@ -2179,8 +2233,8 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): f1 = func.hoho(table1.c.name) s1 = select([table1.c.myid, table1.c.myid.label('foobar'), - f1, - func.lala(table1.c.name).label('gg')]) + f1, + func.lala(table1.c.name).label('gg')]) eq_( list(s1.c.keys()), @@ -2196,12 +2250,12 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): cast(table1.c.name, Numeric), literal('x'), ) - for col, key, expr, label in ( + for col, key, expr, lbl in ( (table1.c.name, 'name', 'mytable.name', None), (exprs[0], str(exprs[0]), 'mytable.myid = :myid_1', 'anon_1'), (exprs[1], str(exprs[1]), 'hoho(mytable.myid)', 'hoho_1'), (exprs[2], str(exprs[2]), - 'CAST(mytable.name AS NUMERIC)', 'anon_1'), + 'CAST(mytable.name AS NUMERIC)', 'anon_1'), (t1.c.col1, 'col1', 'mytable.col1', None), (column('some wacky thing'), 'some wacky thing', '"some wacky thing"', ''), @@ -2215,26 +2269,27 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): s1 = select([col], from_obj=t) assert list(s1.c.keys()) == [key], list(s1.c.keys()) - if label: - self.assert_compile(s1, - "SELECT %s AS %s FROM mytable" % (expr, label)) + if lbl: + self.assert_compile( + s1, "SELECT %s AS %s FROM mytable" % + (expr, lbl)) else: self.assert_compile(s1, "SELECT %s FROM mytable" % (expr,)) s1 = select([s1]) - if label: - self.assert_compile(s1, - "SELECT %s FROM (SELECT %s AS %s FROM mytable)" % - (label, expr, label)) + if lbl: + self.assert_compile( + s1, "SELECT %s FROM (SELECT %s AS %s FROM mytable)" % + (lbl, expr, lbl)) elif col.table is not None: # sqlite rule labels subquery columns - self.assert_compile(s1, - "SELECT %s FROM (SELECT %s AS %s FROM mytable)" % - (key, expr, key)) + self.assert_compile( + s1, "SELECT %s FROM (SELECT %s AS %s FROM mytable)" % + (key, expr, key)) else: self.assert_compile(s1, - "SELECT %s FROM (SELECT %s FROM mytable)" % - (expr, expr)) + "SELECT %s FROM (SELECT %s FROM mytable)" % + (expr, expr)) def test_hints(self): s = select([table1.c.myid]).with_hint(table1, "test hint %(name)s") @@ -2248,88 +2303,90 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): subs4 = select([ table1, table2 - ]).select_from(table1.join(table2, table1.c.myid == table2.c.otherid)).\ + ]).select_from( + table1.join(table2, table1.c.myid == table2.c.otherid)).\ with_hint(table1, 'hint1') s4 = select([table3]).select_from( - table3.join( - subs4, - subs4.c.othername == table3.c.otherstuff - ) - ).\ - with_hint(table3, 'hint3') - + table3.join( + subs4, + subs4.c.othername == table3.c.otherstuff + ) + ).\ + with_hint(table3, 'hint3') t1 = table('QuotedName', column('col1')) s6 = select([t1.c.col1]).where(t1.c.col1 > 10).\ - with_hint(t1, '%(name)s idx1') + with_hint(t1, '%(name)s idx1') a2 = t1.alias('SomeName') s7 = select([a2.c.col1]).where(a2.c.col1 > 10).\ - with_hint(a2, '%(name)s idx1') + with_hint(a2, '%(name)s idx1') mysql_d, oracle_d, sybase_d = \ - mysql.dialect(), \ - oracle.dialect(), \ - sybase.dialect() + mysql.dialect(), \ + oracle.dialect(), \ + sybase.dialect() for stmt, dialect, expected in [ - (s, mysql_d, - "SELECT mytable.myid FROM mytable test hint mytable"), - (s, oracle_d, - "SELECT /*+ test hint mytable */ mytable.myid FROM mytable"), - (s, sybase_d, - "SELECT mytable.myid FROM mytable test hint mytable"), - (s2, mysql_d, - "SELECT mytable.myid FROM mytable"), - (s2, oracle_d, - "SELECT /*+ index(mytable idx) */ mytable.myid FROM mytable"), - (s2, sybase_d, - "SELECT mytable.myid FROM mytable WITH HINT INDEX idx"), - (s3, mysql_d, - "SELECT mytable_1.myid FROM mytable AS mytable_1 " - "index(mytable_1 hint)"), - (s3, oracle_d, - "SELECT /*+ index(mytable_1 hint) */ mytable_1.myid FROM " - "mytable mytable_1"), - (s3, sybase_d, - "SELECT mytable_1.myid FROM mytable AS mytable_1 " - "index(mytable_1 hint)"), - (s4, mysql_d, - "SELECT thirdtable.userid, thirdtable.otherstuff FROM thirdtable " - "hint3 INNER JOIN (SELECT mytable.myid, mytable.name, " - "mytable.description, myothertable.otherid, " - "myothertable.othername FROM mytable hint1 INNER " - "JOIN myothertable ON mytable.myid = myothertable.otherid) " - "ON othername = thirdtable.otherstuff"), - (s4, sybase_d, - "SELECT thirdtable.userid, thirdtable.otherstuff FROM thirdtable " - "hint3 JOIN (SELECT mytable.myid, mytable.name, " - "mytable.description, myothertable.otherid, " - "myothertable.othername FROM mytable hint1 " - "JOIN myothertable ON mytable.myid = myothertable.otherid) " - "ON othername = thirdtable.otherstuff"), - (s4, oracle_d, - "SELECT /*+ hint3 */ thirdtable.userid, thirdtable.otherstuff " - "FROM thirdtable JOIN (SELECT /*+ hint1 */ mytable.myid," - " mytable.name, mytable.description, myothertable.otherid," - " myothertable.othername FROM mytable JOIN myothertable ON" - " mytable.myid = myothertable.otherid) ON othername =" - " thirdtable.otherstuff"), -# TODO: figure out dictionary ordering solution here -# (s5, oracle_d, -# "SELECT /*+ hint3 */ /*+ hint1 */ thirdtable.userid, " -# "thirdtable.otherstuff " -# "FROM thirdtable JOIN (SELECT mytable.myid," -# " mytable.name, mytable.description, myothertable.otherid," -# " myothertable.othername FROM mytable JOIN myothertable ON" -# " mytable.myid = myothertable.otherid) ON othername =" -# " thirdtable.otherstuff"), - (s6, oracle_d, + (s, mysql_d, + "SELECT mytable.myid FROM mytable test hint mytable"), + (s, oracle_d, + "SELECT /*+ test hint mytable */ mytable.myid FROM mytable"), + (s, sybase_d, + "SELECT mytable.myid FROM mytable test hint mytable"), + (s2, mysql_d, + "SELECT mytable.myid FROM mytable"), + (s2, oracle_d, + "SELECT /*+ index(mytable idx) */ mytable.myid FROM mytable"), + (s2, sybase_d, + "SELECT mytable.myid FROM mytable WITH HINT INDEX idx"), + (s3, mysql_d, + "SELECT mytable_1.myid FROM mytable AS mytable_1 " + "index(mytable_1 hint)"), + (s3, oracle_d, + "SELECT /*+ index(mytable_1 hint) */ mytable_1.myid FROM " + "mytable mytable_1"), + (s3, sybase_d, + "SELECT mytable_1.myid FROM mytable AS mytable_1 " + "index(mytable_1 hint)"), + (s4, mysql_d, + "SELECT thirdtable.userid, thirdtable.otherstuff " + "FROM thirdtable " + "hint3 INNER JOIN (SELECT mytable.myid, mytable.name, " + "mytable.description, myothertable.otherid, " + "myothertable.othername FROM mytable hint1 INNER " + "JOIN myothertable ON mytable.myid = myothertable.otherid) " + "ON othername = thirdtable.otherstuff"), + (s4, sybase_d, + "SELECT thirdtable.userid, thirdtable.otherstuff " + "FROM thirdtable " + "hint3 JOIN (SELECT mytable.myid, mytable.name, " + "mytable.description, myothertable.otherid, " + "myothertable.othername FROM mytable hint1 " + "JOIN myothertable ON mytable.myid = myothertable.otherid) " + "ON othername = thirdtable.otherstuff"), + (s4, oracle_d, + "SELECT /*+ hint3 */ thirdtable.userid, thirdtable.otherstuff " + "FROM thirdtable JOIN (SELECT /*+ hint1 */ mytable.myid," + " mytable.name, mytable.description, myothertable.otherid," + " myothertable.othername FROM mytable JOIN myothertable ON" + " mytable.myid = myothertable.otherid) ON othername =" + " thirdtable.otherstuff"), + # TODO: figure out dictionary ordering solution here + # (s5, oracle_d, + # "SELECT /*+ hint3 */ /*+ hint1 */ thirdtable.userid, " + # "thirdtable.otherstuff " + # "FROM thirdtable JOIN (SELECT mytable.myid," + # " mytable.name, mytable.description, myothertable.otherid," + # " myothertable.othername FROM mytable JOIN myothertable ON" + # " mytable.myid = myothertable.otherid) ON othername =" + # " thirdtable.otherstuff"), + (s6, oracle_d, """SELECT /*+ "QuotedName" idx1 */ "QuotedName".col1 """ """FROM "QuotedName" WHERE "QuotedName".col1 > :col1_1"""), - (s7, oracle_d, - """SELECT /*+ SomeName idx1 */ "SomeName".col1 FROM """ - """"QuotedName" "SomeName" WHERE "SomeName".col1 > :col1_1"""), + (s7, oracle_d, + """SELECT /*+ SomeName idx1 */ "SomeName".col1 FROM """ + """"QuotedName" "SomeName" WHERE "SomeName".col1 > :col1_1"""), ]: self.assert_compile( stmt, @@ -2345,13 +2402,15 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def test_literal_as_text_nonstring_raise(self): assert_raises(exc.ArgumentError, - and_, ("a",), ("b",) - ) + and_, ("a",), ("b",) + ) class UnsupportedTest(fixtures.TestBase): + def test_unsupported_element_str_visit_name(self): from sqlalchemy.sql.expression import ClauseElement + class SomeElement(ClauseElement): __visit_name__ = 'some_element' @@ -2364,7 +2423,9 @@ class UnsupportedTest(fixtures.TestBase): def test_unsupported_element_meth_visit_name(self): from sqlalchemy.sql.expression import ClauseElement + class SomeElement(ClauseElement): + @classmethod def __visit_name__(cls): return "some_element" @@ -2378,6 +2439,7 @@ class UnsupportedTest(fixtures.TestBase): def test_unsupported_operator(self): from sqlalchemy.sql.expression import BinaryExpression + def myop(x, y): pass binary = BinaryExpression(column("foo"), column("bar"), myop) @@ -2394,6 +2456,7 @@ class KwargPropagationTest(fixtures.TestBase): @classmethod def setup_class(cls): from sqlalchemy.sql.expression import ColumnClause, TableClause + class CatchCol(ColumnClause): pass @@ -2417,15 +2480,15 @@ class KwargPropagationTest(fixtures.TestBase): def _do_test(self, element): d = default.DefaultDialect() d.statement_compiler(d, element, - compile_kwargs={"canary": True}) + compile_kwargs={"canary": True}) def test_binary(self): self._do_test(self.column == 5) def test_select(self): s = select([self.column]).select_from(self.table).\ - where(self.column == self.criterion).\ - order_by(self.column) + where(self.column == self.criterion).\ + order_by(self.column) self._do_test(s) def test_case(self): @@ -2440,77 +2503,81 @@ class KwargPropagationTest(fixtures.TestBase): class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' - def test_correlated_update(self): # test against a straight text subquery - u = update(table1, values={ - table1.c.name: - text("(select name from mytable where id=mytable.id)")}) - self.assert_compile(u, - "UPDATE mytable SET name=(select name from mytable " - "where id=mytable.id)") + u = update( + table1, + values={ + table1.c.name: + text("(select name from mytable where id=mytable.id)") + } + ) + self.assert_compile( + u, + "UPDATE mytable SET name=(select name from mytable " + "where id=mytable.id)") mt = table1.alias() u = update(table1, values={ - table1.c.name: - select([mt.c.name], mt.c.myid == table1.c.myid) - }) - self.assert_compile(u, - "UPDATE mytable SET name=(SELECT mytable_1.name FROM " - "mytable AS mytable_1 WHERE " - "mytable_1.myid = mytable.myid)") + table1.c.name: + select([mt.c.name], mt.c.myid == table1.c.myid) + }) + self.assert_compile( + u, "UPDATE mytable SET name=(SELECT mytable_1.name FROM " + "mytable AS mytable_1 WHERE " + "mytable_1.myid = mytable.myid)") # test against a regular constructed subquery s = select([table2], table2.c.otherid == table1.c.myid) u = update(table1, table1.c.name == 'jack', values={table1.c.name: s}) - self.assert_compile(u, - "UPDATE mytable SET name=(SELECT myothertable.otherid, " - "myothertable.othername FROM myothertable WHERE " - "myothertable.otherid = mytable.myid) " - "WHERE mytable.name = :name_1") + self.assert_compile( + u, "UPDATE mytable SET name=(SELECT myothertable.otherid, " + "myothertable.othername FROM myothertable WHERE " + "myothertable.otherid = mytable.myid) " + "WHERE mytable.name = :name_1") # test a non-correlated WHERE clause s = select([table2.c.othername], table2.c.otherid == 7) u = update(table1, table1.c.name == s) self.assert_compile(u, - "UPDATE mytable SET myid=:myid, name=:name, " - "description=:description WHERE mytable.name = " - "(SELECT myothertable.othername FROM myothertable " - "WHERE myothertable.otherid = :otherid_1)") + "UPDATE mytable SET myid=:myid, name=:name, " + "description=:description WHERE mytable.name = " + "(SELECT myothertable.othername FROM myothertable " + "WHERE myothertable.otherid = :otherid_1)") # test one that is actually correlated... s = select([table2.c.othername], table2.c.otherid == table1.c.myid) u = table1.update(table1.c.name == s) self.assert_compile(u, - "UPDATE mytable SET myid=:myid, name=:name, " - "description=:description WHERE mytable.name = " - "(SELECT myothertable.othername FROM myothertable " - "WHERE myothertable.otherid = mytable.myid)") + "UPDATE mytable SET myid=:myid, name=:name, " + "description=:description WHERE mytable.name = " + "(SELECT myothertable.othername FROM myothertable " + "WHERE myothertable.otherid = mytable.myid)") # test correlated FROM implicit in WHERE and SET clauses u = table1.update().values(name=table2.c.othername)\ .where(table2.c.otherid == table1.c.myid) - self.assert_compile(u, - "UPDATE mytable SET name=myothertable.othername " - "FROM myothertable WHERE myothertable.otherid = mytable.myid") + self.assert_compile( + u, "UPDATE mytable SET name=myothertable.othername " + "FROM myothertable WHERE myothertable.otherid = mytable.myid") u = table1.update().values(name='foo')\ .where(table2.c.otherid == table1.c.myid) - self.assert_compile(u, - "UPDATE mytable SET name=:name " - "FROM myothertable WHERE myothertable.otherid = mytable.myid") + self.assert_compile( + u, "UPDATE mytable SET name=:name " + "FROM myothertable WHERE myothertable.otherid = mytable.myid") self.assert_compile(u, - "UPDATE mytable SET name=:name " - "FROM mytable, myothertable WHERE " - "myothertable.otherid = mytable.myid", - dialect=mssql.dialect()) + "UPDATE mytable SET name=:name " + "FROM mytable, myothertable WHERE " + "myothertable.otherid = mytable.myid", + dialect=mssql.dialect()) self.assert_compile(u.where(table2.c.othername == mt.c.name), - "UPDATE mytable SET name=:name " - "FROM mytable, myothertable, mytable AS mytable_1 " - "WHERE myothertable.otherid = mytable.myid " - "AND myothertable.othername = mytable_1.name", - dialect=mssql.dialect()) + "UPDATE mytable SET name=:name " + "FROM mytable, myothertable, mytable AS mytable_1 " + "WHERE myothertable.otherid = mytable.myid " + "AND myothertable.othername = mytable_1.name", + dialect=mssql.dialect()) def test_binds_that_match_columns(self): """test bind params named after column names @@ -2527,29 +2594,44 @@ class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises(exc.CompileError, u.values(x=7).compile) self.assert_compile(u.values(y=7), - "UPDATE foo SET y=:y WHERE foo.x = :x") + "UPDATE foo SET y=:y WHERE foo.x = :x") assert_raises(exc.CompileError, - u.values(x=7).compile, column_keys=['x', 'y']) + u.values(x=7).compile, column_keys=['x', 'y']) assert_raises(exc.CompileError, u.compile, column_keys=['x', 'y']) - self.assert_compile(u.values(x=3 + bindparam('x')), - "UPDATE foo SET x=(:param_1 + :x) WHERE foo.x = :x") + self.assert_compile( + u.values( + x=3 + + bindparam('x')), + "UPDATE foo SET x=(:param_1 + :x) WHERE foo.x = :x") - self.assert_compile(u.values(x=3 + bindparam('x')), - "UPDATE foo SET x=(:param_1 + :x) WHERE foo.x = :x", - params={'x': 1}) + self.assert_compile( + u.values( + x=3 + + bindparam('x')), + "UPDATE foo SET x=(:param_1 + :x) WHERE foo.x = :x", + params={ + 'x': 1}) - self.assert_compile(u.values(x=3 + bindparam('x')), - "UPDATE foo SET x=(:param_1 + :x), y=:y WHERE foo.x = :x", - params={'x': 1, 'y': 2}) + self.assert_compile( + u.values( + x=3 + + bindparam('x')), + "UPDATE foo SET x=(:param_1 + :x), y=:y WHERE foo.x = :x", + params={ + 'x': 1, + 'y': 2}) i = t.insert().values(x=3 + bindparam('x')) self.assert_compile(i, - "INSERT INTO foo (x) VALUES ((:param_1 + :x))") - self.assert_compile(i, - "INSERT INTO foo (x, y) VALUES ((:param_1 + :x), :y)", - params={'x': 1, 'y': 2}) + "INSERT INTO foo (x) VALUES ((:param_1 + :x))") + self.assert_compile( + i, + "INSERT INTO foo (x, y) VALUES ((:param_1 + :x), :y)", + params={ + 'x': 1, + 'y': 2}) i = t.insert().values(x=bindparam('y')) self.assert_compile(i, "INSERT INTO foo (x) VALUES (:y)") @@ -2562,15 +2644,23 @@ class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): i = t.insert().values(x=3 + bindparam('x2')) self.assert_compile(i, - "INSERT INTO foo (x) VALUES ((:param_1 + :x2))") - self.assert_compile(i, - "INSERT INTO foo (x) VALUES ((:param_1 + :x2))", params={}) - self.assert_compile(i, - "INSERT INTO foo (x, y) VALUES ((:param_1 + :x2), :y)", - params={'x': 1, 'y': 2}) - self.assert_compile(i, - "INSERT INTO foo (x, y) VALUES ((:param_1 + :x2), :y)", - params={'x2': 1, 'y': 2}) + "INSERT INTO foo (x) VALUES ((:param_1 + :x2))") + self.assert_compile( + i, + "INSERT INTO foo (x) VALUES ((:param_1 + :x2))", + params={}) + self.assert_compile( + i, + "INSERT INTO foo (x, y) VALUES ((:param_1 + :x2), :y)", + params={ + 'x': 1, + 'y': 2}) + self.assert_compile( + i, + "INSERT INTO foo (x, y) VALUES ((:param_1 + :x2), :y)", + params={ + 'x2': 1, + 'y': 2}) def test_unconsumed_names(self): t = table("t", column("x"), column("y")) @@ -2590,7 +2680,7 @@ class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): exc.CompileError, "Unconsumed column names: j", t.update().values(x=5, j=7).values({t2.c.z: 5}). - where(t.c.x == t2.c.q).compile, + where(t.c.x == t2.c.q).compile, ) # bindparam names don't get counted @@ -2615,7 +2705,6 @@ class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): column_keys=['j'] ) - def test_labels_no_collision(self): t = table('foo', column('id'), column('foo_id')) @@ -2630,12 +2719,14 @@ class CRUDTest(fixtures.TestBase, AssertsCompiledSQL): "UPDATE foo SET id=:id, foo_id=:foo_id WHERE foo.id = :foo_id_1" ) + class DDLTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' def _illegal_type_fixture(self): class MyType(types.TypeEngine): pass + @compiles(MyType) def compile(element, compiler, **kw): raise exc.CompileError("Couldn't compile type") @@ -2644,8 +2735,8 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL): def test_reraise_of_column_spec_issue(self): MyType = self._illegal_type_fixture() t1 = Table('t', MetaData(), - Column('x', MyType()) - ) + Column('x', MyType()) + ) assert_raises_message( exc.CompileError, r"\(in table 't', column 'x'\): Couldn't compile type", @@ -2655,8 +2746,8 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL): def test_reraise_of_column_spec_issue_unicode(self): MyType = self._illegal_type_fixture() t1 = Table('t', MetaData(), - Column(u('méil'), MyType()) - ) + Column(u('méil'), MyType()) + ) assert_raises_message( exc.CompileError, u(r"\(in table 't', column 'méil'\): Couldn't compile type"), @@ -2666,8 +2757,8 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL): def test_system_flag(self): m = MetaData() t = Table('t', m, Column('x', Integer), - Column('y', Integer, system=True), - Column('z', Integer)) + Column('y', Integer, system=True), + Column('z', Integer)) self.assert_compile( schema.CreateTable(t), "CREATE TABLE t (x INTEGER, z INTEGER)" @@ -2686,58 +2777,65 @@ class InlineDefaultTest(fixtures.TestBase, AssertsCompiledSQL): def test_insert(self): m = MetaData() foo = Table('foo', m, - Column('id', Integer)) + Column('id', Integer)) t = Table('test', m, - Column('col1', Integer, default=func.foo(1)), - Column('col2', Integer, default=select( - [func.coalesce(func.max(foo.c.id))])), - ) + Column('col1', Integer, default=func.foo(1)), + Column('col2', Integer, default=select( + [func.coalesce(func.max(foo.c.id))])), + ) - self.assert_compile(t.insert(inline=True, values={}), - "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " - "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " - "foo))") + self.assert_compile( + t.insert( + inline=True, values={}), + "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " + "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " + "foo))") def test_update(self): m = MetaData() foo = Table('foo', m, - Column('id', Integer)) + Column('id', Integer)) t = Table('test', m, - Column('col1', Integer, onupdate=func.foo(1)), - Column('col2', Integer, onupdate=select( - [func.coalesce(func.max(foo.c.id))])), - Column('col3', String(30)) - ) + Column('col1', Integer, onupdate=func.foo(1)), + Column('col2', Integer, onupdate=select( + [func.coalesce(func.max(foo.c.id))])), + Column('col3', String(30)) + ) self.assert_compile(t.update(inline=True, values={'col3': 'foo'}), - "UPDATE test SET col1=foo(:foo_1), col2=(SELECT " - "coalesce(max(foo.id)) AS coalesce_1 FROM foo), " - "col3=:col3") + "UPDATE test SET col1=foo(:foo_1), col2=(SELECT " + "coalesce(max(foo.id)) AS coalesce_1 FROM foo), " + "col3=:col3") + class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' def test_select(self): self.assert_compile(table4.select(), - "SELECT remote_owner.remotetable.rem_id, " - "remote_owner.remotetable.datatype_id," - " remote_owner.remotetable.value " - "FROM remote_owner.remotetable") - - self.assert_compile(table4.select(and_(table4.c.datatype_id == 7, - table4.c.value == 'hi')), - "SELECT remote_owner.remotetable.rem_id, " - "remote_owner.remotetable.datatype_id," - " remote_owner.remotetable.value " - "FROM remote_owner.remotetable WHERE " - "remote_owner.remotetable.datatype_id = :datatype_id_1 AND" - " remote_owner.remotetable.value = :value_1") + "SELECT remote_owner.remotetable.rem_id, " + "remote_owner.remotetable.datatype_id," + " remote_owner.remotetable.value " + "FROM remote_owner.remotetable") + + self.assert_compile( + table4.select( + and_( + table4.c.datatype_id == 7, + table4.c.value == 'hi')), + "SELECT remote_owner.remotetable.rem_id, " + "remote_owner.remotetable.datatype_id," + " remote_owner.remotetable.value " + "FROM remote_owner.remotetable WHERE " + "remote_owner.remotetable.datatype_id = :datatype_id_1 AND" + " remote_owner.remotetable.value = :value_1") s = table4.select(and_(table4.c.datatype_id == 7, - table4.c.value == 'hi'), use_labels=True) - self.assert_compile(s, "SELECT remote_owner.remotetable.rem_id AS" + table4.c.value == 'hi'), use_labels=True) + self.assert_compile( + s, "SELECT remote_owner.remotetable.rem_id AS" " remote_owner_remotetable_rem_id, " "remote_owner.remotetable.datatype_id AS" " remote_owner_remotetable_datatype_id, " @@ -2749,22 +2847,22 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): # multi-part schema name self.assert_compile(table5.select(), - 'SELECT "dbo.remote_owner".remotetable.rem_id, ' - '"dbo.remote_owner".remotetable.datatype_id, ' - '"dbo.remote_owner".remotetable.value ' - 'FROM "dbo.remote_owner".remotetable' - ) + 'SELECT "dbo.remote_owner".remotetable.rem_id, ' + '"dbo.remote_owner".remotetable.datatype_id, ' + '"dbo.remote_owner".remotetable.value ' + 'FROM "dbo.remote_owner".remotetable' + ) # multi-part schema name labels - convert '.' to '_' self.assert_compile(table5.select(use_labels=True), - 'SELECT "dbo.remote_owner".remotetable.rem_id AS' - ' dbo_remote_owner_remotetable_rem_id, ' - '"dbo.remote_owner".remotetable.datatype_id' - ' AS dbo_remote_owner_remotetable_datatype_id,' - ' "dbo.remote_owner".remotetable.value AS ' - 'dbo_remote_owner_remotetable_value FROM' - ' "dbo.remote_owner".remotetable' - ) + 'SELECT "dbo.remote_owner".remotetable.rem_id AS' + ' dbo_remote_owner_remotetable_rem_id, ' + '"dbo.remote_owner".remotetable.datatype_id' + ' AS dbo_remote_owner_remotetable_datatype_id,' + ' "dbo.remote_owner".remotetable.value AS ' + 'dbo_remote_owner_remotetable_value FROM' + ' "dbo.remote_owner".remotetable' + ) def test_alias(self): a = alias(table4, 'remtable') @@ -2776,17 +2874,16 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): def test_update(self): self.assert_compile( - table4.update(table4.c.value == 'test', - values={table4.c.datatype_id: 12}), - "UPDATE remote_owner.remotetable SET datatype_id=:datatype_id " - "WHERE remote_owner.remotetable.value = :value_1") + table4.update(table4.c.value == 'test', + values={table4.c.datatype_id: 12}), + "UPDATE remote_owner.remotetable SET datatype_id=:datatype_id " + "WHERE remote_owner.remotetable.value = :value_1") def test_insert(self): self.assert_compile(table4.insert(values=(2, 5, 'test')), - "INSERT INTO remote_owner.remotetable " - "(rem_id, datatype_id, value) VALUES " - "(:rem_id, :datatype_id, :value)") - + "INSERT INTO remote_owner.remotetable " + "(rem_id, datatype_id, value) VALUES " + "(:rem_id, :datatype_id, :value)") class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): @@ -2794,7 +2891,7 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): def test_dont_overcorrelate(self): self.assert_compile(select([table1], from_obj=[table1, - table1.select()]), + table1.select()]), "SELECT mytable.myid, mytable.name, " "mytable.description FROM mytable, (SELECT " "mytable.myid AS myid, mytable.name AS " @@ -2808,188 +2905,191 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): def _assert_where_correlated(self, stmt): self.assert_compile( - stmt, - "SELECT t2.a FROM t2 WHERE t2.a = " - "(SELECT t1.a FROM t1 WHERE t1.a = t2.a)") + stmt, + "SELECT t2.a FROM t2 WHERE t2.a = " + "(SELECT t1.a FROM t1 WHERE t1.a = t2.a)") def _assert_where_all_correlated(self, stmt): self.assert_compile( - stmt, - "SELECT t1.a, t2.a FROM t1, t2 WHERE t2.a = " - "(SELECT t1.a WHERE t1.a = t2.a)") + stmt, + "SELECT t1.a, t2.a FROM t1, t2 WHERE t2.a = " + "(SELECT t1.a WHERE t1.a = t2.a)") # note there's no more "backwards" correlation after # we've done #2746 - #def _assert_where_backwards_correlated(self, stmt): + # def _assert_where_backwards_correlated(self, stmt): # self.assert_compile( # stmt, # "SELECT t2.a FROM t2 WHERE t2.a = " # "(SELECT t1.a FROM t2 WHERE t1.a = t2.a)") - #def _assert_column_backwards_correlated(self, stmt): + # def _assert_column_backwards_correlated(self, stmt): # self.assert_compile(stmt, # "SELECT t2.a, (SELECT t1.a FROM t2 WHERE t1.a = t2.a) " # "AS anon_1 FROM t2") def _assert_column_correlated(self, stmt): - self.assert_compile(stmt, - "SELECT t2.a, (SELECT t1.a FROM t1 WHERE t1.a = t2.a) " - "AS anon_1 FROM t2") + self.assert_compile( + stmt, + "SELECT t2.a, (SELECT t1.a FROM t1 WHERE t1.a = t2.a) " + "AS anon_1 FROM t2") def _assert_column_all_correlated(self, stmt): - self.assert_compile(stmt, - "SELECT t1.a, t2.a, " - "(SELECT t1.a WHERE t1.a = t2.a) AS anon_1 FROM t1, t2") - + self.assert_compile( + stmt, + "SELECT t1.a, t2.a, " + "(SELECT t1.a WHERE t1.a = t2.a) AS anon_1 FROM t1, t2") def _assert_having_correlated(self, stmt): self.assert_compile(stmt, - "SELECT t2.a FROM t2 HAVING t2.a = " - "(SELECT t1.a FROM t1 WHERE t1.a = t2.a)") + "SELECT t2.a FROM t2 HAVING t2.a = " + "(SELECT t1.a FROM t1 WHERE t1.a = t2.a)") def _assert_from_uncorrelated(self, stmt): - self.assert_compile(stmt, - "SELECT t2.a, anon_1.a FROM t2, " - "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a) AS anon_1") + self.assert_compile( + stmt, + "SELECT t2.a, anon_1.a FROM t2, " + "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a) AS anon_1") def _assert_from_all_uncorrelated(self, stmt): - self.assert_compile(stmt, - "SELECT t1.a, t2.a, anon_1.a FROM t1, t2, " - "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a) AS anon_1") + self.assert_compile( + stmt, + "SELECT t1.a, t2.a, anon_1.a FROM t1, t2, " + "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a) AS anon_1") def _assert_where_uncorrelated(self, stmt): self.assert_compile(stmt, - "SELECT t2.a FROM t2 WHERE t2.a = " - "(SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a)") + "SELECT t2.a FROM t2 WHERE t2.a = " + "(SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a)") def _assert_column_uncorrelated(self, stmt): self.assert_compile(stmt, - "SELECT t2.a, (SELECT t1.a FROM t1, t2 " - "WHERE t1.a = t2.a) AS anon_1 FROM t2") + "SELECT t2.a, (SELECT t1.a FROM t1, t2 " + "WHERE t1.a = t2.a) AS anon_1 FROM t2") def _assert_having_uncorrelated(self, stmt): self.assert_compile(stmt, - "SELECT t2.a FROM t2 HAVING t2.a = " - "(SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a)") + "SELECT t2.a FROM t2 HAVING t2.a = " + "(SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a)") def _assert_where_single_full_correlated(self, stmt): self.assert_compile(stmt, - "SELECT t1.a FROM t1 WHERE t1.a = (SELECT t1.a)") + "SELECT t1.a FROM t1 WHERE t1.a = (SELECT t1.a)") def test_correlate_semiauto_where(self): t1, t2, s1 = self._fixture() self._assert_where_correlated( - select([t2]).where(t2.c.a == s1.correlate(t2))) + select([t2]).where(t2.c.a == s1.correlate(t2))) def test_correlate_semiauto_column(self): t1, t2, s1 = self._fixture() self._assert_column_correlated( - select([t2, s1.correlate(t2).as_scalar()])) + select([t2, s1.correlate(t2).as_scalar()])) def test_correlate_semiauto_from(self): t1, t2, s1 = self._fixture() self._assert_from_uncorrelated( - select([t2, s1.correlate(t2).alias()])) + select([t2, s1.correlate(t2).alias()])) def test_correlate_semiauto_having(self): t1, t2, s1 = self._fixture() self._assert_having_correlated( - select([t2]).having(t2.c.a == s1.correlate(t2))) + select([t2]).having(t2.c.a == s1.correlate(t2))) def test_correlate_except_inclusion_where(self): t1, t2, s1 = self._fixture() self._assert_where_correlated( - select([t2]).where(t2.c.a == s1.correlate_except(t1))) + select([t2]).where(t2.c.a == s1.correlate_except(t1))) def test_correlate_except_exclusion_where(self): t1, t2, s1 = self._fixture() self._assert_where_uncorrelated( - select([t2]).where(t2.c.a == s1.correlate_except(t2))) + select([t2]).where(t2.c.a == s1.correlate_except(t2))) def test_correlate_except_inclusion_column(self): t1, t2, s1 = self._fixture() self._assert_column_correlated( - select([t2, s1.correlate_except(t1).as_scalar()])) + select([t2, s1.correlate_except(t1).as_scalar()])) def test_correlate_except_exclusion_column(self): t1, t2, s1 = self._fixture() self._assert_column_uncorrelated( - select([t2, s1.correlate_except(t2).as_scalar()])) + select([t2, s1.correlate_except(t2).as_scalar()])) def test_correlate_except_inclusion_from(self): t1, t2, s1 = self._fixture() self._assert_from_uncorrelated( - select([t2, s1.correlate_except(t1).alias()])) + select([t2, s1.correlate_except(t1).alias()])) def test_correlate_except_exclusion_from(self): t1, t2, s1 = self._fixture() self._assert_from_uncorrelated( - select([t2, s1.correlate_except(t2).alias()])) + select([t2, s1.correlate_except(t2).alias()])) def test_correlate_except_none(self): t1, t2, s1 = self._fixture() self._assert_where_all_correlated( - select([t1, t2]).where(t2.c.a == s1.correlate_except(None))) + select([t1, t2]).where(t2.c.a == s1.correlate_except(None))) def test_correlate_except_having(self): t1, t2, s1 = self._fixture() self._assert_having_correlated( - select([t2]).having(t2.c.a == s1.correlate_except(t1))) + select([t2]).having(t2.c.a == s1.correlate_except(t1))) def test_correlate_auto_where(self): t1, t2, s1 = self._fixture() self._assert_where_correlated( - select([t2]).where(t2.c.a == s1)) + select([t2]).where(t2.c.a == s1)) def test_correlate_auto_column(self): t1, t2, s1 = self._fixture() self._assert_column_correlated( - select([t2, s1.as_scalar()])) + select([t2, s1.as_scalar()])) def test_correlate_auto_from(self): t1, t2, s1 = self._fixture() self._assert_from_uncorrelated( - select([t2, s1.alias()])) + select([t2, s1.alias()])) def test_correlate_auto_having(self): t1, t2, s1 = self._fixture() self._assert_having_correlated( - select([t2]).having(t2.c.a == s1)) + select([t2]).having(t2.c.a == s1)) def test_correlate_disabled_where(self): t1, t2, s1 = self._fixture() self._assert_where_uncorrelated( - select([t2]).where(t2.c.a == s1.correlate(None))) + select([t2]).where(t2.c.a == s1.correlate(None))) def test_correlate_disabled_column(self): t1, t2, s1 = self._fixture() self._assert_column_uncorrelated( - select([t2, s1.correlate(None).as_scalar()])) + select([t2, s1.correlate(None).as_scalar()])) def test_correlate_disabled_from(self): t1, t2, s1 = self._fixture() self._assert_from_uncorrelated( - select([t2, s1.correlate(None).alias()])) + select([t2, s1.correlate(None).alias()])) def test_correlate_disabled_having(self): t1, t2, s1 = self._fixture() self._assert_having_uncorrelated( - select([t2]).having(t2.c.a == s1.correlate(None))) + select([t2]).having(t2.c.a == s1.correlate(None))) def test_correlate_all_where(self): t1, t2, s1 = self._fixture() self._assert_where_all_correlated( - select([t1, t2]).where(t2.c.a == s1.correlate(t1, t2))) + select([t1, t2]).where(t2.c.a == s1.correlate(t1, t2))) def test_correlate_all_column(self): t1, t2, s1 = self._fixture() self._assert_column_all_correlated( - select([t1, t2, s1.correlate(t1, t2).as_scalar()])) + select([t1, t2, s1.correlate(t1, t2).as_scalar()])) def test_correlate_all_from(self): t1, t2, s1 = self._fixture() self._assert_from_all_uncorrelated( - select([t1, t2, s1.correlate(t1, t2).alias()])) + select([t1, t2, s1.correlate(t1, t2).alias()])) def test_correlate_where_all_unintentional(self): t1, t2, s1 = self._fixture() @@ -3012,8 +3112,8 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): s = select([t1.c.a]) s2 = select([t1]).where(t1.c.a == s) self.assert_compile(s2, - "SELECT t1.a FROM t1 WHERE t1.a = " - "(SELECT t1.a FROM t1)") + "SELECT t1.a FROM t1 WHERE t1.a = " + "(SELECT t1.a FROM t1)") def test_correlate_semiauto_where_singlefrom(self): t1, t2, s1 = self._fixture() @@ -3035,7 +3135,7 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): # new as of #2668 t1, t2, s1 = self._fixture() self.assert_compile(s1.correlate(t1, t2), - "SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a") + "SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a") def test_correlate_except_froms(self): # new as of #2748 @@ -3047,23 +3147,24 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): s2 = select([func.foo(s.c.b)]).as_scalar() s3 = select([t1], order_by=s2) - self.assert_compile(s3, - "SELECT t1.a FROM t1 ORDER BY " + self.assert_compile( + s3, "SELECT t1.a FROM t1 ORDER BY " "(SELECT foo(s.b) AS foo_1 FROM " - "(SELECT t2.b AS b FROM t2 WHERE t1.a = t2.a) AS s)" - ) + "(SELECT t2.b AS b FROM t2 WHERE t1.a = t2.a) AS s)") def test_multilevel_froms_correlation(self): # new as of #2748 p = table('parent', column('id')) c = table('child', column('id'), column('parent_id'), column('pos')) - s = c.select().where(c.c.parent_id == p.c.id).order_by(c.c.pos).limit(1) + s = c.select().where( + c.c.parent_id == p.c.id).order_by( + c.c.pos).limit(1) s = s.correlate(p) s = exists().select_from(s).where(s.c.id == 1) s = select([p]).where(s) - self.assert_compile(s, - "SELECT parent.id FROM parent WHERE EXISTS (SELECT * " + self.assert_compile( + s, "SELECT parent.id FROM parent WHERE EXISTS (SELECT * " "FROM (SELECT child.id AS id, child.parent_id AS parent_id, " "child.pos AS pos FROM child WHERE child.parent_id = parent.id " "ORDER BY child.pos LIMIT :param_1) WHERE id = :id_1)") @@ -3077,7 +3178,8 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): s = select([t1]).where(t1.c.x == t2.c.y).\ where(t2.c.y == t3.c.z).correlate_except(t1) - self.assert_compile(s, + self.assert_compile( + s, "SELECT t1.x FROM t1, t2, t3 WHERE t1.x = t2.y AND t2.y = t3.z") def test_multilevel_implicit_correlation_disabled(self): @@ -3092,13 +3194,13 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): s3 = select([t1]).where(t1.c.x == s2.as_scalar()) self.assert_compile(s3, - "SELECT t1.x FROM t1 " - "WHERE t1.x = (SELECT t3.z " - "FROM t3 " - "WHERE t3.z = (SELECT t1.x " - "FROM t1, t2 " - "WHERE t1.x = t2.y))" - ) + "SELECT t1.x FROM t1 " + "WHERE t1.x = (SELECT t3.z " + "FROM t3 " + "WHERE t3.z = (SELECT t1.x " + "FROM t1, t2 " + "WHERE t1.x = t2.y))" + ) def test_from_implicit_correlation_disabled(self): # test that implicit correlation with immediate and @@ -3112,10 +3214,11 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): s3 = select([t1, s2]) self.assert_compile(s3, - "SELECT t1.x, y, x FROM t1, " - "(SELECT t2.y AS y, x FROM t2, " - "(SELECT t1.x AS x FROM t1, t2 WHERE t1.x = t2.y))" - ) + "SELECT t1.x, y, x FROM t1, " + "(SELECT t2.y AS y, x FROM t2, " + "(SELECT t1.x AS x FROM t1, t2 WHERE t1.x = t2.y))" + ) + class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = default.DefaultDialect(supports_native_boolean=True) @@ -3123,7 +3226,7 @@ class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): def _fixture(self): m = MetaData() return Table('foo', m, - Column('id', Integer)) + Column('id', Integer)) bool_table = table('t', column('x', Boolean)) @@ -3194,17 +3297,19 @@ class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): class ResultMapTest(fixtures.TestBase): + """test the behavior of the 'entry stack' and the determination when the result_map needs to be populated. """ + def test_compound_populates(self): t = Table('t', MetaData(), Column('a', Integer), Column('b', Integer)) stmt = select([t]).union(select([t])) comp = stmt.compile() eq_( comp.result_map, - {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type), + {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type), 'b': ('b', (t.c.b, 'b', 'b'), t.c.b.type)} ) @@ -3215,7 +3320,7 @@ class ResultMapTest(fixtures.TestBase): comp = stmt.compile() eq_( comp.result_map, - {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type)} + {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type)} ) def test_compound_only_top_populates(self): @@ -3224,7 +3329,7 @@ class ResultMapTest(fixtures.TestBase): comp = stmt.compile() eq_( comp.result_map, - {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type)}, + {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type)}, ) def test_label_plus_element(self): @@ -3236,22 +3341,22 @@ class ResultMapTest(fixtures.TestBase): tc_anon_label = comp.result_map['a_1'][1][0] eq_( comp.result_map, - { + { 'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type), 'bar': ('bar', (l1, 'bar'), l1.type), 'a_1': ('%%(%d a)s' % id(tc), (tc_anon_label, 'a_1'), tc.type), - }, + }, ) def test_label_conflict_union(self): t1 = Table('t1', MetaData(), Column('a', Integer), - Column('b', Integer)) + Column('b', Integer)) t2 = Table('t2', MetaData(), Column('t1_a', Integer)) union = select([t2]).union(select([t2])).alias() t1_alias = t1.alias() stmt = select([t1, t1_alias]).select_from( - t1.join(union, t1.c.a == union.c.t1_a)).apply_labels() + t1.join(union, t1.c.a == union.c.t1_a)).apply_labels() comp = stmt.compile() eq_( set(comp.result_map), diff --git a/test/sql/test_constraints.py b/test/sql/test_constraints.py index 992289d3e..2f054dac1 100644 --- a/test/sql/test_constraints.py +++ b/test/sql/test_constraints.py @@ -4,7 +4,7 @@ from sqlalchemy import Table, Integer, String, Column, PrimaryKeyConstraint,\ CheckConstraint, func, text from sqlalchemy import exc, schema from sqlalchemy.testing import fixtures, AssertsExecutionResults, \ - AssertsCompiledSQL + AssertsCompiledSQL from sqlalchemy import testing from sqlalchemy.engine import default from sqlalchemy.testing import engines @@ -12,67 +12,66 @@ from sqlalchemy.testing import eq_ from sqlalchemy.testing.assertsql import AllOf, RegexSQL, ExactSQL, CompiledSQL from sqlalchemy.sql import table, column + class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): __dialect__ = 'default' __backend__ = True - @testing.provide_metadata def test_pk_fk_constraint_create(self): metadata = self.metadata Table('employees', metadata, - Column('id', Integer), - Column('soc', String(40)), - Column('name', String(30)), - PrimaryKeyConstraint('id', 'soc') - ) + Column('id', Integer), + Column('soc', String(40)), + Column('name', String(30)), + PrimaryKeyConstraint('id', 'soc') + ) Table('elements', metadata, - Column('id', Integer), - Column('stuff', String(30)), - Column('emp_id', Integer), - Column('emp_soc', String(40)), - PrimaryKeyConstraint('id', name='elements_primkey'), - ForeignKeyConstraint(['emp_id', 'emp_soc'], - ['employees.id', 'employees.soc']) - ) + Column('id', Integer), + Column('stuff', String(30)), + Column('emp_id', Integer), + Column('emp_soc', String(40)), + PrimaryKeyConstraint('id', name='elements_primkey'), + ForeignKeyConstraint(['emp_id', 'emp_soc'], + ['employees.id', 'employees.soc']) + ) self.assert_sql_execution( testing.db, lambda: metadata.create_all(checkfirst=False), CompiledSQL('CREATE TABLE employees (' - 'id INTEGER NOT NULL, ' - 'soc VARCHAR(40) NOT NULL, ' - 'name VARCHAR(30), ' - 'PRIMARY KEY (id, soc)' - ')' - ), + 'id INTEGER NOT NULL, ' + 'soc VARCHAR(40) NOT NULL, ' + 'name VARCHAR(30), ' + 'PRIMARY KEY (id, soc)' + ')' + ), CompiledSQL('CREATE TABLE elements (' - 'id INTEGER NOT NULL, ' - 'stuff VARCHAR(30), ' - 'emp_id INTEGER, ' - 'emp_soc VARCHAR(40), ' - 'CONSTRAINT elements_primkey PRIMARY KEY (id), ' - 'FOREIGN KEY(emp_id, emp_soc) ' - 'REFERENCES employees (id, soc)' - ')' - ) + 'id INTEGER NOT NULL, ' + 'stuff VARCHAR(30), ' + 'emp_id INTEGER, ' + 'emp_soc VARCHAR(40), ' + 'CONSTRAINT elements_primkey PRIMARY KEY (id), ' + 'FOREIGN KEY(emp_id, emp_soc) ' + 'REFERENCES employees (id, soc)' + ')' + ) ) - @testing.provide_metadata def test_cyclic_fk_table_constraint_create(self): metadata = self.metadata Table("a", metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer), - ForeignKeyConstraint(["bid"], ["b.id"]) - ) - Table("b", metadata, - Column('id', Integer, primary_key=True), - Column("aid", Integer), - ForeignKeyConstraint(["aid"], ["a.id"], use_alter=True, name="bfk") - ) + Column('id', Integer, primary_key=True), + Column('bid', Integer), + ForeignKeyConstraint(["bid"], ["b.id"]) + ) + Table( + "b", metadata, Column( + 'id', Integer, primary_key=True), Column( + "aid", Integer), ForeignKeyConstraint( + ["aid"], ["a.id"], use_alter=True, name="bfk")) self._assert_cyclic_constraint(metadata) @testing.provide_metadata @@ -80,37 +79,37 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata Table("a", metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer, ForeignKey("b.id")), - ) + Column('id', Integer, primary_key=True), + Column('bid', Integer, ForeignKey("b.id")), + ) Table("b", metadata, - Column('id', Integer, primary_key=True), - Column("aid", Integer, - ForeignKey("a.id", use_alter=True, name="bfk") - ), - ) + Column('id', Integer, primary_key=True), + Column("aid", Integer, + ForeignKey("a.id", use_alter=True, name="bfk") + ), + ) self._assert_cyclic_constraint(metadata) def _assert_cyclic_constraint(self, metadata): assertions = [ CompiledSQL('CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ), + 'id INTEGER NOT NULL, ' + 'aid INTEGER, ' + 'PRIMARY KEY (id)' + ')' + ), CompiledSQL('CREATE TABLE a (' - 'id INTEGER NOT NULL, ' - 'bid INTEGER, ' - 'PRIMARY KEY (id), ' - 'FOREIGN KEY(bid) REFERENCES b (id)' - ')' - ), + 'id INTEGER NOT NULL, ' + 'bid INTEGER, ' + 'PRIMARY KEY (id), ' + 'FOREIGN KEY(bid) REFERENCES b (id)' + ')' + ), ] if testing.db.dialect.supports_alter: assertions.append( CompiledSQL('ALTER TABLE b ADD CONSTRAINT bfk ' - 'FOREIGN KEY(aid) REFERENCES a (id)') + 'FOREIGN KEY(aid) REFERENCES a (id)') ) self.assert_sql_execution( testing.db, @@ -124,7 +123,7 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): assertions.extend([ CompiledSQL("DROP TABLE a"), CompiledSQL("DROP TABLE b"), - ]) + ]) self.assert_sql_execution( testing.db, lambda: metadata.drop_all(checkfirst=False), @@ -136,35 +135,35 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata Table('foo', metadata, - Column('id', Integer, primary_key=True), - Column('x', Integer), - Column('y', Integer), - CheckConstraint('x>y')) + Column('id', Integer, primary_key=True), + Column('x', Integer), + Column('y', Integer), + CheckConstraint('x>y')) Table('bar', metadata, - Column('id', Integer, primary_key=True), - Column('x', Integer, CheckConstraint('x>7')), - Column('z', Integer) - ) + Column('id', Integer, primary_key=True), + Column('x', Integer, CheckConstraint('x>7')), + Column('z', Integer) + ) self.assert_sql_execution( testing.db, lambda: metadata.create_all(checkfirst=False), AllOf( CompiledSQL('CREATE TABLE foo (' - 'id INTEGER NOT NULL, ' - 'x INTEGER, ' - 'y INTEGER, ' - 'PRIMARY KEY (id), ' - 'CHECK (x>y)' - ')' - ), + 'id INTEGER NOT NULL, ' + 'x INTEGER, ' + 'y INTEGER, ' + 'PRIMARY KEY (id), ' + 'CHECK (x>y)' + ')' + ), CompiledSQL('CREATE TABLE bar (' - 'id INTEGER NOT NULL, ' - 'x INTEGER CHECK (x>7), ' - 'z INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ) + 'id INTEGER NOT NULL, ' + 'x INTEGER CHECK (x>7), ' + 'z INTEGER, ' + 'PRIMARY KEY (id)' + ')' + ) ) ) @@ -173,32 +172,32 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata Table('foo', metadata, - Column('id', Integer, primary_key=True), - Column('value', String(30), unique=True)) + Column('id', Integer, primary_key=True), + Column('value', String(30), unique=True)) Table('bar', metadata, - Column('id', Integer, primary_key=True), - Column('value', String(30)), - Column('value2', String(30)), - UniqueConstraint('value', 'value2', name='uix1') - ) + Column('id', Integer, primary_key=True), + Column('value', String(30)), + Column('value2', String(30)), + UniqueConstraint('value', 'value2', name='uix1') + ) self.assert_sql_execution( testing.db, lambda: metadata.create_all(checkfirst=False), AllOf( CompiledSQL('CREATE TABLE foo (' - 'id INTEGER NOT NULL, ' - 'value VARCHAR(30), ' - 'PRIMARY KEY (id), ' - 'UNIQUE (value)' - ')'), + 'id INTEGER NOT NULL, ' + 'value VARCHAR(30), ' + 'PRIMARY KEY (id), ' + 'UNIQUE (value)' + ')'), CompiledSQL('CREATE TABLE bar (' - 'id INTEGER NOT NULL, ' - 'value VARCHAR(30), ' - 'value2 VARCHAR(30), ' - 'PRIMARY KEY (id), ' - 'CONSTRAINT uix1 UNIQUE (value, value2)' - ')') + 'id INTEGER NOT NULL, ' + 'value VARCHAR(30), ' + 'value2 VARCHAR(30), ' + 'PRIMARY KEY (id), ' + 'CONSTRAINT uix1 UNIQUE (value, value2)' + ')') ) ) @@ -226,9 +225,9 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): RegexSQL("^CREATE TABLE"), AllOf( CompiledSQL('CREATE INDEX employee_name_index ON ' - 'employees (last_name, first_name)', []), + 'employees (last_name, first_name)', []), CompiledSQL('CREATE UNIQUE INDEX employee_email_index ON ' - 'employees (email_address)', []) + 'employees (email_address)', []) ) ) @@ -244,25 +243,21 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): Column('lastName', String(30)), Column('emailAddress', String(30))) - - Index('employeeNameIndex', - employees.c.lastName, employees.c.firstName) + employees.c.lastName, employees.c.firstName) Index('employeeEmailIndex', - employees.c.emailAddress, unique=True) + employees.c.emailAddress, unique=True) self.assert_sql_execution( - testing.db, - lambda: metadata.create_all(checkfirst=False), - RegexSQL("^CREATE TABLE"), - AllOf( - CompiledSQL('CREATE INDEX "employeeNameIndex" ON ' - '"companyEmployees" ("lastName", "firstName")', []), - CompiledSQL('CREATE UNIQUE INDEX "employeeEmailIndex" ON ' - '"companyEmployees" ("emailAddress")', []) - ) - ) + testing.db, lambda: metadata.create_all( + checkfirst=False), RegexSQL("^CREATE TABLE"), AllOf( + CompiledSQL( + 'CREATE INDEX "employeeNameIndex" ON ' + '"companyEmployees" ("lastName", "firstName")', []), + CompiledSQL( + 'CREATE UNIQUE INDEX "employeeEmailIndex" ON ' + '"companyEmployees" ("emailAddress")', []))) @testing.provide_metadata def test_index_create_inline(self): @@ -279,13 +274,13 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): Column('winner', String(30))) Index('sport_announcer', events.c.sport, events.c.announcer, - unique=True) + unique=True) Index('idx_winners', events.c.winner) eq_( set(ix.name for ix in events.indexes), set(['ix_events_name', 'ix_events_location', - 'sport_announcer', 'idx_winners']) + 'sport_announcer', 'idx_winners']) ) self.assert_sql_execution( @@ -294,11 +289,11 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): RegexSQL("^CREATE TABLE events"), AllOf( ExactSQL('CREATE UNIQUE INDEX ix_events_name ON events ' - '(name)'), + '(name)'), ExactSQL('CREATE INDEX ix_events_location ON events ' - '(location)'), + '(location)'), ExactSQL('CREATE UNIQUE INDEX sport_announcer ON events ' - '(sport, announcer)'), + '(sport, announcer)'), ExactSQL('CREATE INDEX idx_winners ON events (winner)') ) ) @@ -308,18 +303,19 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata t = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String(50)) - ) + Column('id', Integer, primary_key=True), + Column('data', String(50)) + ) Index('myindex', t.c.data.desc()) self.assert_sql_execution( testing.db, lambda: t.create(testing.db), CompiledSQL('CREATE TABLE sometable (id INTEGER NOT NULL, ' - 'data VARCHAR(50), PRIMARY KEY (id))'), + 'data VARCHAR(50), PRIMARY KEY (id))'), ExactSQL('CREATE INDEX myindex ON sometable (data DESC)') ) + class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -359,7 +355,6 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): "DROP INDEX foo.xyz" ) - def test_too_long_index_name(self): dialect = testing.db.dialect.__class__() @@ -373,8 +368,8 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): ]: t1 = Table(tname, MetaData(), - Column(cname, Integer, index=True), - ) + Column(cname, Integer, index=True), + ) ix1 = list(t1.indexes)[0] self.assert_compile( @@ -391,16 +386,16 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises( exc.IdentifierError, schema.CreateIndex(Index( - "this_other_name_is_too_long_for_what_were_doing", - t1.c.c)).compile, + "this_other_name_is_too_long_for_what_were_doing", + t1.c.c)).compile, dialect=dialect ) def test_functional_index(self): metadata = MetaData() x = Table('x', metadata, - Column('q', String(50)) - ) + Column('q', String(50)) + ) idx = Index('y', func.lower(x.c.q)) self.assert_compile( @@ -418,8 +413,8 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): metadata = MetaData() idx = Index('y', text("some_function(q)")) t = Table('x', metadata, - Column('q', String(50)) - ) + Column('q', String(50)) + ) t.append_constraint(idx) self.assert_compile( schema.CreateIndex(idx), @@ -430,24 +425,23 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): metadata = MetaData() idx = Index('y', text("some_function(q)")) x = Table('x', metadata, - Column('q', String(50)), - idx - ) + Column('q', String(50)), + idx + ) self.assert_compile( schema.CreateIndex(idx), "CREATE INDEX y ON x (some_function(q))" ) - def test_index_declaration_inline(self): metadata = MetaData() t1 = Table('t1', metadata, - Column('x', Integer), - Column('y', Integer), - Index('foo', 'x', 'y') - ) + Column('x', Integer), + Column('y', Integer), + Index('foo', 'x', 'y') + ) self.assert_compile( schema.CreateIndex(list(t1.indexes)[0]), "CREATE INDEX foo ON t1 (x, y)" @@ -473,7 +467,6 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): sql = str(schema.CreateTable(t).compile(dialect=dialect)) assert 'NOT DEFERRABLE' in sql - t = Table('tbl', MetaData(), Column('a', Integer), Column('b', Integer), @@ -492,15 +485,21 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): assert 'INITIALLY DEFERRED' in sql def test_column_level_ck_name(self): - t = Table('tbl', MetaData(), - Column('a', Integer, CheckConstraint("a > 5", - name="ck_a_greater_five")) - ) + t = Table( + 'tbl', + MetaData(), + Column( + 'a', + Integer, + CheckConstraint( + "a > 5", + name="ck_a_greater_five"))) self.assert_compile( schema.CreateTable(t), "CREATE TABLE tbl (a INTEGER CONSTRAINT " "ck_a_greater_five CHECK (a > 5))" ) + def test_deferrable_pk(self): factory = lambda **kw: PrimaryKeyConstraint('a', **kw) self._test_deferrable(factory) @@ -553,23 +552,23 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): def test_multiple(self): m = MetaData() Table("foo", m, - Column('id', Integer, primary_key=True), - Column('bar', Integer, primary_key=True) - ) + Column('id', Integer, primary_key=True), + Column('bar', Integer, primary_key=True) + ) tb = Table("some_table", m, - Column('id', Integer, primary_key=True), - Column('foo_id', Integer, ForeignKey('foo.id')), - Column('foo_bar', Integer, ForeignKey('foo.bar')), - ) + Column('id', Integer, primary_key=True), + Column('foo_id', Integer, ForeignKey('foo.id')), + Column('foo_bar', Integer, ForeignKey('foo.bar')), + ) self.assert_compile( schema.CreateTable(tb), "CREATE TABLE some_table (" - "id INTEGER NOT NULL, " - "foo_id INTEGER, " - "foo_bar INTEGER, " - "PRIMARY KEY (id), " - "FOREIGN KEY(foo_id) REFERENCES foo (id), " - "FOREIGN KEY(foo_bar) REFERENCES foo (bar))" + "id INTEGER NOT NULL, " + "foo_id INTEGER, " + "foo_bar INTEGER, " + "PRIMARY KEY (id), " + "FOREIGN KEY(foo_id) REFERENCES foo (id), " + "FOREIGN KEY(foo_bar) REFERENCES foo (bar))" ) def test_empty_pkc(self): @@ -605,20 +604,20 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.CreateTable(t), "CREATE TABLE tbl (a INTEGER, b INTEGER CHECK (a < b) " - "DEFERRABLE INITIALLY DEFERRED)" + "DEFERRABLE INITIALLY DEFERRED)" ) def test_use_alter(self): m = MetaData() Table('t', m, - Column('a', Integer), - ) + Column('a', Integer), + ) Table('t2', m, - Column('a', Integer, ForeignKey('t.a', use_alter=True, - name='fk_ta')), - Column('b', Integer, ForeignKey('t.a', name='fk_tb')) - ) + Column('a', Integer, ForeignKey('t.a', use_alter=True, + name='fk_ta')), + Column('b', Integer, ForeignKey('t.a', name='fk_tb')) + ) e = engines.mock_engine(dialect_name='postgresql') m.create_all(e) @@ -627,9 +626,9 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): e.assert_sql([ 'CREATE TABLE t (a INTEGER)', 'CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb ' - 'FOREIGN KEY(b) REFERENCES t (a))', + 'FOREIGN KEY(b) REFERENCES t (a))', 'ALTER TABLE t2 ' - 'ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)', + 'ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)', 'ALTER TABLE t2 DROP CONSTRAINT fk_ta', 'DROP TABLE t2', 'DROP TABLE t' @@ -641,12 +640,12 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t = Table('tbl', m, Column('a', Integer), Column('b', Integer) - ) + ) t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + Column('a', Integer), + Column('b', Integer) + ) return t, t2 @@ -654,8 +653,8 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t, t2 = self._constraint_create_fixture() CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + deferrable=True, initially='DEFERRED', + table=t) # before we create an AddConstraint, # the CONSTRAINT comes out inline @@ -665,7 +664,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): "a INTEGER, " "b INTEGER, " "CONSTRAINT my_test_constraint CHECK (a < b) " - "DEFERRABLE INITIALLY DEFERRED" + "DEFERRABLE INITIALLY DEFERRED" ")" ) @@ -673,21 +672,21 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t, t2 = self._constraint_create_fixture() constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + deferrable=True, initially='DEFERRED', + table=t) self.assert_compile( schema.AddConstraint(constraint), "ALTER TABLE tbl ADD CONSTRAINT my_test_constraint " - "CHECK (a < b) DEFERRABLE INITIALLY DEFERRED" + "CHECK (a < b) DEFERRABLE INITIALLY DEFERRED" ) def test_external_ck_constraint_cancels_internal(self): t, t2 = self._constraint_create_fixture() constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + deferrable=True, initially='DEFERRED', + table=t) schema.AddConstraint(constraint) @@ -706,8 +705,8 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t, t2 = self._constraint_create_fixture() constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + deferrable=True, initially='DEFERRED', + table=t) self.assert_compile( schema.DropConstraint(constraint), @@ -718,8 +717,8 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t, t2 = self._constraint_create_fixture() constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + deferrable=True, initially='DEFERRED', + table=t) self.assert_compile( schema.DropConstraint(constraint, cascade=True), @@ -798,6 +797,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): class ConstraintAPITest(fixtures.TestBase): + def test_double_fk_usage_raises(self): f = ForeignKey('b.id') @@ -810,12 +810,12 @@ class ConstraintAPITest(fixtures.TestBase): t = Table('tbl', m, Column('a', Integer), Column('b', Integer) - ) + ) t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + Column('a', Integer), + Column('b', Integer) + ) for c in ( UniqueConstraint(t.c.a), @@ -848,12 +848,12 @@ class ConstraintAPITest(fixtures.TestBase): t = Table('tbl', m, Column('a', Integer), Column('b', Integer) - ) + ) t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + Column('a', Integer), + Column('b', Integer) + ) UniqueConstraint(t.c.a) CheckConstraint(t.c.a > 5) @@ -874,25 +874,24 @@ class ConstraintAPITest(fixtures.TestBase): t = Table('tbl', m, Column('a', Integer), Column('b', Integer) - ) + ) ck = CheckConstraint(t.c.a > 5) ck2 = ck.copy() assert ck in t.constraints assert ck2 not in t.constraints - def test_ambig_check_constraint_auto_append(self): m = MetaData() t = Table('tbl', m, Column('a', Integer), Column('b', Integer) - ) + ) t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + Column('a', Integer), + Column('b', Integer) + ) c = CheckConstraint(t.c.a > t2.c.b) assert c not in t.constraints assert c not in t2.constraints @@ -901,11 +900,11 @@ class ConstraintAPITest(fixtures.TestBase): metadata = MetaData() t1 = Table('t1', metadata, - Column('x', Integer) - ) + Column('x', Integer) + ) t2 = Table('t2', metadata, - Column('y', Integer) - ) + Column('y', Integer) + ) assert_raises_message( exc.ArgumentError, "Column 't2.y' is not part of table 't1'.", @@ -917,15 +916,15 @@ class ConstraintAPITest(fixtures.TestBase): metadata = MetaData() t1 = Table('t1', metadata, - Column('x', Integer) - ) + Column('x', Integer) + ) assert_raises_message( exc.ArgumentError, "Index 'bar' is against table 't1', and " "cannot be associated with table 't2'.", Table, 't2', metadata, - Column('y', Integer), - Index('bar', t1.c.x) + Column('y', Integer), + Index('bar', t1.c.x) ) def test_raise_index_nonexistent_name(self): @@ -957,7 +956,6 @@ class ConstraintAPITest(fixtures.TestBase): schema.CreateIndex(idx).compile ) - def test_no_warning_w_no_columns(self): idx = Index(name="foo") @@ -975,7 +973,9 @@ class ConstraintAPITest(fixtures.TestBase): def test_raise_clauseelement_not_a_column(self): m = MetaData() t2 = Table('t2', m, Column('x', Integer)) + class SomeClass(object): + def __clause_element__(self): return t2 assert_raises( diff --git a/test/sql/test_cte.py b/test/sql/test_cte.py index 18c85f9e6..7e83968da 100644 --- a/test/sql/test_cte.py +++ b/test/sql/test_cte.py @@ -5,39 +5,39 @@ from sqlalchemy.dialects import mssql from sqlalchemy.engine import default from sqlalchemy.exc import CompileError + class CTETest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' def test_nonrecursive(self): orders = table('orders', - column('region'), - column('amount'), - column('product'), - column('quantity') - ) + column('region'), + column('amount'), + column('product'), + column('quantity') + ) regional_sales = select([ - orders.c.region, - func.sum(orders.c.amount).label('total_sales') - ]).group_by(orders.c.region).cte("regional_sales") + orders.c.region, + func.sum(orders.c.amount).label('total_sales') + ]).group_by(orders.c.region).cte("regional_sales") top_regions = select([regional_sales.c.region]).\ - where( - regional_sales.c.total_sales > - select([ - func.sum(regional_sales.c.total_sales)/10 - ]) - ).cte("top_regions") + where( + regional_sales.c.total_sales > select([ + func.sum(regional_sales.c.total_sales) / 10 + ]) + ).cte("top_regions") s = select([ - orders.c.region, - orders.c.product, - func.sum(orders.c.quantity).label("product_units"), - func.sum(orders.c.amount).label("product_sales") - ]).where(orders.c.region.in_( - select([top_regions.c.region]) - )).group_by(orders.c.region, orders.c.product) + orders.c.region, + orders.c.product, + func.sum(orders.c.quantity).label("product_units"), + func.sum(orders.c.amount).label("product_sales") + ]).where(orders.c.region.in_( + select([top_regions.c.region]) + )).group_by(orders.c.region, orders.c.product) # needs to render regional_sales first as top_regions # refers to it @@ -61,17 +61,17 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): def test_recursive(self): parts = table('parts', - column('part'), - column('sub_part'), - column('quantity'), - ) + column('part'), + column('sub_part'), + column('quantity'), + ) included_parts = select([ - parts.c.sub_part, - parts.c.part, - parts.c.quantity]).\ - where(parts.c.part=='our part').\ - cte(recursive=True) + parts.c.sub_part, + parts.c.part, + parts.c.quantity]).\ + where(parts.c.part == 'our part').\ + cte(recursive=True) incl_alias = included_parts.alias() parts_alias = parts.alias() @@ -79,46 +79,45 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): select([ parts_alias.c.sub_part, parts_alias.c.part, - parts_alias.c.quantity]).\ - where(parts_alias.c.part==incl_alias.c.sub_part) - ) + parts_alias.c.quantity]). + where(parts_alias.c.part == incl_alias.c.sub_part) + ) s = select([ included_parts.c.sub_part, func.sum(included_parts.c.quantity).label('total_quantity')]).\ select_from(included_parts.join( - parts,included_parts.c.part==parts.c.part)).\ + parts, included_parts.c.part == parts.c.part)).\ group_by(included_parts.c.sub_part) - self.assert_compile(s, - "WITH RECURSIVE anon_1(sub_part, part, quantity) " - "AS (SELECT parts.sub_part AS sub_part, parts.part " - "AS part, parts.quantity AS quantity FROM parts " - "WHERE parts.part = :part_1 UNION SELECT parts_1.sub_part AS sub_part, " - "parts_1.part AS part, parts_1.quantity " - "AS quantity FROM parts AS parts_1, anon_1 AS anon_2 " - "WHERE parts_1.part = anon_2.sub_part) " - "SELECT anon_1.sub_part, " - "sum(anon_1.quantity) AS total_quantity FROM anon_1 " - "JOIN parts ON anon_1.part = parts.part " - "GROUP BY anon_1.sub_part" - ) + self.assert_compile( + s, "WITH RECURSIVE anon_1(sub_part, part, quantity) " + "AS (SELECT parts.sub_part AS sub_part, parts.part " + "AS part, parts.quantity AS quantity FROM parts " + "WHERE parts.part = :part_1 UNION " + "SELECT parts_1.sub_part AS sub_part, " + "parts_1.part AS part, parts_1.quantity " + "AS quantity FROM parts AS parts_1, anon_1 AS anon_2 " + "WHERE parts_1.part = anon_2.sub_part) " + "SELECT anon_1.sub_part, " + "sum(anon_1.quantity) AS total_quantity FROM anon_1 " + "JOIN parts ON anon_1.part = parts.part " + "GROUP BY anon_1.sub_part") # quick check that the "WITH RECURSIVE" varies per # dialect - self.assert_compile(s, - "WITH anon_1(sub_part, part, quantity) " - "AS (SELECT parts.sub_part AS sub_part, parts.part " - "AS part, parts.quantity AS quantity FROM parts " - "WHERE parts.part = :part_1 UNION SELECT parts_1.sub_part AS sub_part, " - "parts_1.part AS part, parts_1.quantity " - "AS quantity FROM parts AS parts_1, anon_1 AS anon_2 " - "WHERE parts_1.part = anon_2.sub_part) " - "SELECT anon_1.sub_part, " - "sum(anon_1.quantity) AS total_quantity FROM anon_1 " - "JOIN parts ON anon_1.part = parts.part " - "GROUP BY anon_1.sub_part", - dialect=mssql.dialect() - ) + self.assert_compile( + s, "WITH anon_1(sub_part, part, quantity) " + "AS (SELECT parts.sub_part AS sub_part, parts.part " + "AS part, parts.quantity AS quantity FROM parts " + "WHERE parts.part = :part_1 UNION " + "SELECT parts_1.sub_part AS sub_part, " + "parts_1.part AS part, parts_1.quantity " + "AS quantity FROM parts AS parts_1, anon_1 AS anon_2 " + "WHERE parts_1.part = anon_2.sub_part) " + "SELECT anon_1.sub_part, " + "sum(anon_1.quantity) AS total_quantity FROM anon_1 " + "JOIN parts ON anon_1.part = parts.part " + "GROUP BY anon_1.sub_part", dialect=mssql.dialect()) def test_recursive_union_no_alias_one(self): s1 = select([literal(0).label("x")]) @@ -128,13 +127,12 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): ) s2 = select([cte]) self.assert_compile(s2, - "WITH RECURSIVE cte(x) AS " - "(SELECT :param_1 AS x UNION ALL " - "SELECT cte.x + :x_1 AS anon_1 " - "FROM cte WHERE cte.x < :x_2) " - "SELECT cte.x FROM cte" - ) - + "WITH RECURSIVE cte(x) AS " + "(SELECT :param_1 AS x UNION ALL " + "SELECT cte.x + :x_1 AS anon_1 " + "FROM cte WHERE cte.x < :x_2) " + "SELECT cte.x FROM cte" + ) def test_recursive_union_no_alias_two(self): """ @@ -157,13 +155,13 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): t = t.union_all(select([t.c.n + 1]).where(t.c.n < 100)) s = select([func.sum(t.c.n)]) self.assert_compile(s, - "WITH RECURSIVE t(n) AS " - "(SELECT values(:values_1) AS n " - "UNION ALL SELECT t.n + :n_1 AS anon_1 " - "FROM t " - "WHERE t.n < :n_2) " - "SELECT sum(t.n) AS sum_1 FROM t" - ) + "WITH RECURSIVE t(n) AS " + "(SELECT values(:values_1) AS n " + "UNION ALL SELECT t.n + :n_1 AS anon_1 " + "FROM t " + "WHERE t.n < :n_2) " + "SELECT sum(t.n) AS sum_1 FROM t" + ) def test_recursive_union_no_alias_three(self): # like test one, but let's refer to the CTE @@ -181,14 +179,13 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): s2 = select([cte, bar]) self.assert_compile(s2, - "WITH RECURSIVE cte(x) AS " - "(SELECT :param_1 AS x UNION ALL " - "SELECT cte.x + :x_1 AS anon_1 " - "FROM cte WHERE cte.x < :x_2), " - "bar AS (SELECT cte.x AS x FROM cte) " - "SELECT cte.x, bar.x FROM cte, bar" - ) - + "WITH RECURSIVE cte(x) AS " + "(SELECT :param_1 AS x UNION ALL " + "SELECT cte.x + :x_1 AS anon_1 " + "FROM cte WHERE cte.x < :x_2), " + "bar AS (SELECT cte.x AS x FROM cte) " + "SELECT cte.x, bar.x FROM cte, bar" + ) def test_recursive_union_no_alias_four(self): # like test one and three, but let's refer @@ -208,109 +205,104 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): # includes "inner" cte s2 = select([cte, bar]) self.assert_compile(s2, - "WITH RECURSIVE cte(x) AS " - "(SELECT :param_1 AS x UNION ALL " - "SELECT cte.x + :x_1 AS anon_1 " - "FROM cte WHERE cte.x < :x_2), " - "bar AS (SELECT cte.x AS x FROM cte) " - "SELECT cte.x, bar.x FROM cte, bar" - ) + "WITH RECURSIVE cte(x) AS " + "(SELECT :param_1 AS x UNION ALL " + "SELECT cte.x + :x_1 AS anon_1 " + "FROM cte WHERE cte.x < :x_2), " + "bar AS (SELECT cte.x AS x FROM cte) " + "SELECT cte.x, bar.x FROM cte, bar" + ) # bar rendered, only includes "inner" cte, # "outer" cte isn't present s2 = select([bar]) self.assert_compile(s2, - "WITH RECURSIVE cte(x) AS " - "(SELECT :param_1 AS x), " - "bar AS (SELECT cte.x AS x FROM cte) " - "SELECT bar.x FROM bar" - ) + "WITH RECURSIVE cte(x) AS " + "(SELECT :param_1 AS x), " + "bar AS (SELECT cte.x AS x FROM cte) " + "SELECT bar.x FROM bar" + ) # bar rendered, but then the "outer" # cte is rendered. s2 = select([bar, cte]) - self.assert_compile(s2, - "WITH RECURSIVE bar AS (SELECT cte.x AS x FROM cte), " - "cte(x) AS " - "(SELECT :param_1 AS x UNION ALL " - "SELECT cte.x + :x_1 AS anon_1 " - "FROM cte WHERE cte.x < :x_2) " - - "SELECT bar.x, cte.x FROM bar, cte" - ) + self.assert_compile( + s2, "WITH RECURSIVE bar AS (SELECT cte.x AS x FROM cte), " + "cte(x) AS " + "(SELECT :param_1 AS x UNION ALL " + "SELECT cte.x + :x_1 AS anon_1 " + "FROM cte WHERE cte.x < :x_2) " + "SELECT bar.x, cte.x FROM bar, cte") def test_conflicting_names(self): """test a flat out name conflict.""" s1 = select([1]) - c1= s1.cte(name='cte1', recursive=True) + c1 = s1.cte(name='cte1', recursive=True) s2 = select([1]) c2 = s2.cte(name='cte1', recursive=True) s = select([c1, c2]) assert_raises_message( - CompileError, - "Multiple, unrelated CTEs found " - "with the same name: 'cte1'", - s.compile + CompileError, + "Multiple, unrelated CTEs found " + "with the same name: 'cte1'", + s.compile ) - - - def test_union(self): orders = table('orders', - column('region'), - column('amount'), - ) + column('region'), + column('amount'), + ) regional_sales = select([ - orders.c.region, - orders.c.amount - ]).cte("regional_sales") + orders.c.region, + orders.c.amount + ]).cte("regional_sales") - s = select([regional_sales.c.region]).\ - where( - regional_sales.c.amount > 500 - ) + s = select( + [regional_sales.c.region]).where( + regional_sales.c.amount > 500 + ) self.assert_compile(s, - "WITH regional_sales AS " - "(SELECT orders.region AS region, " - "orders.amount AS amount FROM orders) " - "SELECT regional_sales.region " - "FROM regional_sales WHERE " - "regional_sales.amount > :amount_1") + "WITH regional_sales AS " + "(SELECT orders.region AS region, " + "orders.amount AS amount FROM orders) " + "SELECT regional_sales.region " + "FROM regional_sales WHERE " + "regional_sales.amount > :amount_1") s = s.union_all( - select([regional_sales.c.region]).\ - where( - regional_sales.c.amount < 300 - ) + select([regional_sales.c.region]). + where( + regional_sales.c.amount < 300 + ) ) self.assert_compile(s, - "WITH regional_sales AS " - "(SELECT orders.region AS region, " - "orders.amount AS amount FROM orders) " - "SELECT regional_sales.region FROM regional_sales " - "WHERE regional_sales.amount > :amount_1 " - "UNION ALL SELECT regional_sales.region " - "FROM regional_sales WHERE " - "regional_sales.amount < :amount_2") + "WITH regional_sales AS " + "(SELECT orders.region AS region, " + "orders.amount AS amount FROM orders) " + "SELECT regional_sales.region FROM regional_sales " + "WHERE regional_sales.amount > :amount_1 " + "UNION ALL SELECT regional_sales.region " + "FROM regional_sales WHERE " + "regional_sales.amount < :amount_2") def test_reserved_quote(self): orders = table('orders', - column('order'), - ) + column('order'), + ) s = select([orders.c.order]).cte("regional_sales", recursive=True) s = select([s.c.order]) self.assert_compile(s, - 'WITH RECURSIVE regional_sales("order") AS ' - '(SELECT orders."order" AS "order" ' - "FROM orders)" - ' SELECT regional_sales."order" ' - "FROM regional_sales" - ) + 'WITH RECURSIVE regional_sales("order") AS ' + '(SELECT orders."order" AS "order" ' + "FROM orders)" + ' SELECT regional_sales."order" ' + "FROM regional_sales" + ) def test_multi_subq_quote(self): cte = select([literal(1).label("id")]).cte(name='CTE') @@ -327,65 +319,61 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): '(SELECT "CTE".id AS id FROM "CTE") AS anon_2' ) - def test_positional_binds(self): orders = table('orders', - column('order'), - ) + column('order'), + ) s = select([orders.c.order, literal("x")]).cte("regional_sales") s = select([s.c.order, literal("y")]) dialect = default.DefaultDialect() dialect.positional = True dialect.paramstyle = 'numeric' - self.assert_compile(s, + self.assert_compile( + s, 'WITH regional_sales AS (SELECT orders."order" ' 'AS "order", :1 AS anon_2 FROM orders) SELECT ' 'regional_sales."order", :2 AS anon_1 FROM regional_sales', - checkpositional=('x', 'y'), - dialect=dialect - ) + checkpositional=( + 'x', + 'y'), + dialect=dialect) - self.assert_compile(s.union(s), - 'WITH regional_sales AS (SELECT orders."order" ' + self.assert_compile( + s.union(s), 'WITH regional_sales AS (SELECT orders."order" ' 'AS "order", :1 AS anon_2 FROM orders) SELECT ' 'regional_sales."order", :2 AS anon_1 FROM regional_sales ' 'UNION SELECT regional_sales."order", :3 AS anon_1 ' - 'FROM regional_sales', - checkpositional=('x', 'y', 'y'), - dialect=dialect - ) + 'FROM regional_sales', checkpositional=( + 'x', 'y', 'y'), dialect=dialect) s = select([orders.c.order]).\ - where(orders.c.order=='x').cte("regional_sales") - s = select([s.c.order]).where(s.c.order=="y") - self.assert_compile(s, - 'WITH regional_sales AS (SELECT orders."order" AS ' + where(orders.c.order == 'x').cte("regional_sales") + s = select([s.c.order]).where(s.c.order == "y") + self.assert_compile( + s, 'WITH regional_sales AS (SELECT orders."order" AS ' '"order" FROM orders WHERE orders."order" = :1) ' 'SELECT regional_sales."order" FROM regional_sales ' - 'WHERE regional_sales."order" = :2', - checkpositional=('x', 'y'), - dialect=dialect - ) + 'WHERE regional_sales."order" = :2', checkpositional=( + 'x', 'y'), dialect=dialect) def test_positional_binds_2(self): orders = table('orders', - column('order'), - ) + column('order'), + ) s = select([orders.c.order, literal("x")]).cte("regional_sales") s = select([s.c.order, literal("y")]) dialect = default.DefaultDialect() dialect.positional = True dialect.paramstyle = 'numeric' s1 = select([orders.c.order]).where(orders.c.order == 'x').\ - cte("regional_sales_1") + cte("regional_sales_1") s1a = s1.alias() s2 = select([orders.c.order == 'y', s1a.c.order, - orders.c.order, s1.c.order]).\ - where(orders.c.order == 'z').\ - cte("regional_sales_2") - + orders.c.order, s1.c.order]).\ + where(orders.c.order == 'z').\ + cte("regional_sales_2") s3 = select([s2]) @@ -403,7 +391,6 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'regional_sales_2."order" FROM regional_sales_2', checkpositional=('x', 'y', 'z'), dialect=dialect) - def test_all_aliases(self): orders = table('order', column('order')) s = select([orders.c.order]).cte("regional_sales") @@ -422,7 +409,11 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'regional_sales AS anon_2 WHERE anon_1."order" > anon_2."order"' ) - s3 = select([orders]).select_from(orders.join(r1, r1.c.order == orders.c.order)) + s3 = select( + [orders]).select_from( + orders.join( + r1, + r1.c.order == orders.c.order)) self.assert_compile( s3, @@ -430,5 +421,6 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): '(SELECT "order"."order" AS "order" ' 'FROM "order")' ' SELECT "order"."order" ' - 'FROM "order" JOIN regional_sales AS anon_1 ON anon_1."order" = "order"."order"' - )
\ No newline at end of file + 'FROM "order" JOIN regional_sales AS anon_1 ' + 'ON anon_1."order" = "order"."order"' + ) diff --git a/test/sql/test_ddlemit.py b/test/sql/test_ddlemit.py index be75f63ec..825f8228b 100644 --- a/test/sql/test_ddlemit.py +++ b/test/sql/test_ddlemit.py @@ -1,11 +1,12 @@ from sqlalchemy.testing import fixtures from sqlalchemy.sql.ddl import SchemaGenerator, SchemaDropper -from sqlalchemy.engine import default from sqlalchemy import MetaData, Table, Column, Integer, Sequence from sqlalchemy import schema from sqlalchemy.testing.mock import Mock + class EmitDDLTest(fixtures.TestBase): + def _mock_connection(self, item_exists): def has_item(connection, name, schema): return item_exists(name) @@ -14,32 +15,32 @@ class EmitDDLTest(fixtures.TestBase): supports_sequences=True, has_table=Mock(side_effect=has_item), has_sequence=Mock(side_effect=has_item) - ) - ) + ) + ) def _mock_create_fixture(self, checkfirst, tables, - item_exists=lambda item: False): + item_exists=lambda item: False): connection = self._mock_connection(item_exists) return SchemaGenerator(connection.dialect, connection, - checkfirst=checkfirst, - tables=tables) + checkfirst=checkfirst, + tables=tables) def _mock_drop_fixture(self, checkfirst, tables, - item_exists=lambda item: True): + item_exists=lambda item: True): connection = self._mock_connection(item_exists) return SchemaDropper(connection.dialect, connection, - checkfirst=checkfirst, - tables=tables) + checkfirst=checkfirst, + tables=tables) def _table_fixture(self): m = MetaData() return (m, ) + tuple( - Table('t%d' % i, m, Column('x', Integer)) - for i in range(1, 6) - ) + Table('t%d' % i, m, Column('x', Integer)) + for i in range(1, 6) + ) def _table_seq_fixture(self): m = MetaData() @@ -51,101 +52,123 @@ class EmitDDLTest(fixtures.TestBase): return m, t1, t2, s1, s2 - def test_create_seq_checkfirst(self): m, t1, t2, s1, s2 = self._table_seq_fixture() - generator = self._mock_create_fixture(True, [t1, t2], - item_exists=lambda t: t not in ("t1", "s1") - ) + generator = self._mock_create_fixture( + True, [ + t1, t2], item_exists=lambda t: t not in ( + "t1", "s1")) self._assert_create([t1, s1], generator, m) - def test_drop_seq_checkfirst(self): m, t1, t2, s1, s2 = self._table_seq_fixture() - generator = self._mock_drop_fixture(True, [t1, t2], - item_exists=lambda t: t in ("t1", "s1") - ) + generator = self._mock_drop_fixture( + True, [ + t1, t2], item_exists=lambda t: t in ( + "t1", "s1")) self._assert_drop([t1, s1], generator, m) def test_create_collection_checkfirst(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_create_fixture(True, [t2, t3, t4], - item_exists=lambda t: t not in ("t2", "t4") - ) + generator = self._mock_create_fixture( + True, [ + t2, t3, t4], item_exists=lambda t: t not in ( + "t2", "t4")) self._assert_create_tables([t2, t4], generator, m) def test_drop_collection_checkfirst(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_drop_fixture(True, [t2, t3, t4], - item_exists=lambda t: t in ("t2", "t4") - ) + generator = self._mock_drop_fixture( + True, [ + t2, t3, t4], item_exists=lambda t: t in ( + "t2", "t4")) self._assert_drop_tables([t2, t4], generator, m) def test_create_collection_nocheck(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_create_fixture(False, [t2, t3, t4], - item_exists=lambda t: t not in ("t2", "t4") - ) + generator = self._mock_create_fixture( + False, [ + t2, t3, t4], item_exists=lambda t: t not in ( + "t2", "t4")) self._assert_create_tables([t2, t3, t4], generator, m) def test_create_empty_collection(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_create_fixture(True, [], - item_exists=lambda t: t not in ("t2", "t4") - ) + generator = self._mock_create_fixture( + True, + [], + item_exists=lambda t: t not in ( + "t2", + "t4")) self._assert_create_tables([], generator, m) def test_drop_empty_collection(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_drop_fixture(True, [], - item_exists=lambda t: t in ("t2", "t4") - ) + generator = self._mock_drop_fixture( + True, + [], + item_exists=lambda t: t in ( + "t2", + "t4")) self._assert_drop_tables([], generator, m) def test_drop_collection_nocheck(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_drop_fixture(False, [t2, t3, t4], - item_exists=lambda t: t in ("t2", "t4") - ) + generator = self._mock_drop_fixture( + False, [ + t2, t3, t4], item_exists=lambda t: t in ( + "t2", "t4")) self._assert_drop_tables([t2, t3, t4], generator, m) def test_create_metadata_checkfirst(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_create_fixture(True, None, - item_exists=lambda t: t not in ("t2", "t4") - ) + generator = self._mock_create_fixture( + True, + None, + item_exists=lambda t: t not in ( + "t2", + "t4")) self._assert_create_tables([t2, t4], generator, m) def test_drop_metadata_checkfirst(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_drop_fixture(True, None, - item_exists=lambda t: t in ("t2", "t4") - ) + generator = self._mock_drop_fixture( + True, + None, + item_exists=lambda t: t in ( + "t2", + "t4")) self._assert_drop_tables([t2, t4], generator, m) def test_create_metadata_nocheck(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_create_fixture(False, None, - item_exists=lambda t: t not in ("t2", "t4") - ) + generator = self._mock_create_fixture( + False, + None, + item_exists=lambda t: t not in ( + "t2", + "t4")) self._assert_create_tables([t1, t2, t3, t4, t5], generator, m) def test_drop_metadata_nocheck(self): m, t1, t2, t3, t4, t5 = self._table_fixture() - generator = self._mock_drop_fixture(False, None, - item_exists=lambda t: t in ("t2", "t4") - ) + generator = self._mock_drop_fixture( + False, + None, + item_exists=lambda t: t in ( + "t2", + "t4")) self._assert_drop_tables([t1, t2, t3, t4, t5], generator, m) @@ -157,13 +180,13 @@ class EmitDDLTest(fixtures.TestBase): def _assert_create(self, elements, generator, argument): self._assert_ddl( - (schema.CreateTable, schema.CreateSequence), - elements, generator, argument) + (schema.CreateTable, schema.CreateSequence), + elements, generator, argument) def _assert_drop(self, elements, generator, argument): self._assert_ddl( - (schema.DropTable, schema.DropSequence), - elements, generator, argument) + (schema.DropTable, schema.DropSequence), + elements, generator, argument) def _assert_ddl(self, ddl_cls, elements, generator, argument): generator.traverse_single(argument) @@ -171,6 +194,6 @@ class EmitDDLTest(fixtures.TestBase): c = call_[1][0] assert isinstance(c, ddl_cls) assert c.element in elements, "element %r was not expected"\ - % c.element + % c.element elements.remove(c.element) assert not elements, "elements remain in list: %r" % elements diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py index 2c144daf4..7688aba40 100644 --- a/test/sql/test_defaults.py +++ b/test/sql/test_defaults.py @@ -50,6 +50,7 @@ class DefaultTest(fixtures.TestBase): is_oracle = testing.against('oracle') class MyClass(object): + @classmethod def gen_default(cls, ctx): return "hi" @@ -166,10 +167,12 @@ class DefaultTest(fixtures.TestBase): pass class fn3(object): + def __init__(self, x, y): pass class FN4(object): + def __call__(self, x, y): pass fn4 = FN4() @@ -194,19 +197,23 @@ class DefaultTest(fixtures.TestBase): fn5 = list class fn6a(object): + def __init__(self, x): eq_(x, "context") class fn6b(object): + def __init__(self, x, y=3): eq_(x, "context") class FN7(object): + def __call__(self, x): eq_(x, "context") fn7 = FN7() class FN8(object): + def __call__(self, x, y=3): eq_(x, "context") fn8 = FN8() @@ -1023,6 +1030,7 @@ class TableBoundSequenceTest(fixtures.TestBase): class SpecialTypePKTest(fixtures.TestBase): + """test process_result_value in conjunction with primary key columns. Also tests that "autoincrement" checks are against diff --git a/test/sql/test_delete.py b/test/sql/test_delete.py index 64173bb00..904dcee3f 100644 --- a/test/sql/test_delete.py +++ b/test/sql/test_delete.py @@ -1,11 +1,13 @@ #! coding:utf-8 -from sqlalchemy import Column, Integer, String, Table, delete, select, and_, or_ +from sqlalchemy import Column, Integer, String, Table, delete, select, and_, \ + or_ from sqlalchemy.dialects import mysql from sqlalchemy.testing import AssertsCompiledSQL, fixtures class _DeleteTestBase(object): + @classmethod def define_tables(cls, metadata): Table('mytable', metadata, @@ -33,8 +35,8 @@ class DeleteTest(_DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( table1.delete(). - where(table1.c.myid == 7). - where(table1.c.name == 'somename'), + where(table1.c.myid == 7). + where(table1.c.name == 'somename'), 'DELETE FROM mytable ' 'WHERE mytable.myid = :myid_1 ' 'AND mytable.name = :name_1') @@ -59,11 +61,11 @@ class DeleteTest(_DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): prefix_with('C', 'D') self.assert_compile(stmt, - 'DELETE C D FROM mytable') + 'DELETE C D FROM mytable') self.assert_compile(stmt, - 'DELETE A B C D FROM mytable', - dialect=mysql.dialect()) + 'DELETE A B C D FROM mytable', + dialect=mysql.dialect()) def test_alias(self): table1 = self.tables.mytable @@ -71,7 +73,8 @@ class DeleteTest(_DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): talias1 = table1.alias('t1') stmt = delete(talias1).where(talias1.c.myid == 7) - self.assert_compile(stmt, + self.assert_compile( + stmt, 'DELETE FROM mytable AS t1 WHERE t1.myid = :myid_1') def test_correlated(self): @@ -80,19 +83,19 @@ class DeleteTest(_DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): # test a non-correlated WHERE clause s = select([table2.c.othername], table2.c.otherid == 7) self.assert_compile(delete(table1, table1.c.name == s), - 'DELETE FROM mytable ' - 'WHERE mytable.name = (' - 'SELECT myothertable.othername ' - 'FROM myothertable ' - 'WHERE myothertable.otherid = :otherid_1' - ')') + 'DELETE FROM mytable ' + 'WHERE mytable.name = (' + 'SELECT myothertable.othername ' + 'FROM myothertable ' + 'WHERE myothertable.otherid = :otherid_1' + ')') # test one that is actually correlated... s = select([table2.c.othername], table2.c.otherid == table1.c.myid) self.assert_compile(table1.delete(table1.c.name == s), - 'DELETE FROM mytable ' - 'WHERE mytable.name = (' - 'SELECT myothertable.othername ' - 'FROM myothertable ' - 'WHERE myothertable.otherid = mytable.myid' - ')') + 'DELETE FROM mytable ' + 'WHERE mytable.name = (' + 'SELECT myothertable.othername ' + 'FROM myothertable ' + 'WHERE myothertable.otherid = mytable.myid' + ')') diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py index 87c102a21..4d066be8a 100644 --- a/test/sql/test_functions.py +++ b/test/sql/test_functions.py @@ -1,6 +1,7 @@ from sqlalchemy.testing import eq_ import datetime -from sqlalchemy import * +from sqlalchemy import func, select, Integer, literal, DateTime, Table, \ + Column, Sequence, MetaData, extract, Date, String, bindparam from sqlalchemy.sql import table, column from sqlalchemy import sql, util from sqlalchemy.sql.compiler import BIND_TEMPLATES @@ -24,14 +25,14 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): for dialect in all_dialects(exclude=('sybase', )): bindtemplate = BIND_TEMPLATES[dialect.paramstyle] self.assert_compile(func.current_timestamp(), - "CURRENT_TIMESTAMP", dialect=dialect) + "CURRENT_TIMESTAMP", dialect=dialect) self.assert_compile(func.localtime(), "LOCALTIME", dialect=dialect) if dialect.name in ('firebird',): self.assert_compile(func.nosuchfunction(), - "nosuchfunction", dialect=dialect) + "nosuchfunction", dialect=dialect) else: self.assert_compile(func.nosuchfunction(), - "nosuchfunction()", dialect=dialect) + "nosuchfunction()", dialect=dialect) # test generic function compile class fake_func(GenericFunction): @@ -41,15 +42,16 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): GenericFunction.__init__(self, arg, **kwargs) self.assert_compile( - fake_func('foo'), - "fake_func(%s)" % - bindtemplate % {'name': 'param_1', 'position': 1}, - dialect=dialect) + fake_func('foo'), + "fake_func(%s)" % + bindtemplate % {'name': 'param_1', 'position': 1}, + dialect=dialect) def test_use_labels(self): self.assert_compile(select([func.foo()], use_labels=True), - "SELECT foo() AS foo_1" - ) + "SELECT foo() AS foo_1" + ) + def test_underscores(self): self.assert_compile(func.if_(), "if()") @@ -81,6 +83,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( fn, "coalesce(:param_1, :param_2)" ) + def test_custom_default_namespace(self): class myfunc(GenericFunction): pass @@ -204,26 +207,25 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): for fn in [func.coalesce, func.max, func.min, func.sum]: for args, type_ in [ - ((datetime.date(2007, 10, 5), - datetime.date(2005, 10, 15)), sqltypes.Date), - ((3, 5), sqltypes.Integer), - ((decimal.Decimal(3), decimal.Decimal(5)), - sqltypes.Numeric), - (("foo", "bar"), sqltypes.String), - ((datetime.datetime(2007, 10, 5, 8, 3, 34), - datetime.datetime(2005, 10, 15, 14, 45, 33)), - sqltypes.DateTime) - ]: + ((datetime.date(2007, 10, 5), + datetime.date(2005, 10, 15)), sqltypes.Date), + ((3, 5), sqltypes.Integer), + ((decimal.Decimal(3), decimal.Decimal(5)), + sqltypes.Numeric), + (("foo", "bar"), sqltypes.String), + ((datetime.datetime(2007, 10, 5, 8, 3, 34), + datetime.datetime(2005, 10, 15, 14, 45, 33)), + sqltypes.DateTime) + ]: assert isinstance(fn(*args).type, type_), \ - "%s / %r != %s" % (fn(), fn(*args).type, type_) + "%s / %r != %s" % (fn(), fn(*args).type, type_) assert isinstance(func.concat("foo", "bar").type, sqltypes.String) - def test_assorted(self): table1 = table('mytable', - column('myid', Integer), - ) + column('myid', Integer), + ) table2 = table( 'myothertable', @@ -232,35 +234,42 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): # test an expression with a function self.assert_compile(func.lala(3, 4, literal("five"), - table1.c.myid) * table2.c.otherid, - "lala(:lala_1, :lala_2, :param_1, mytable.myid) * " - "myothertable.otherid") + table1.c.myid) * table2.c.otherid, + "lala(:lala_1, :lala_2, :param_1, mytable.myid) * " + "myothertable.otherid") # test it in a SELECT - self.assert_compile(select([func.count(table1.c.myid)]), + self.assert_compile(select( + [func.count(table1.c.myid)]), "SELECT count(mytable.myid) AS count_1 FROM mytable") # test a "dotted" function name - self.assert_compile(select([func.foo.bar.lala(table1.c.myid)]), + self.assert_compile(select([func.foo.bar.lala( + table1.c.myid)]), "SELECT foo.bar.lala(mytable.myid) AS lala_1 FROM mytable") # test the bind parameter name with a "dotted" function name is # only the name (limits the length of the bind param name) self.assert_compile(select([func.foo.bar.lala(12)]), - "SELECT foo.bar.lala(:lala_2) AS lala_1") + "SELECT foo.bar.lala(:lala_2) AS lala_1") # test a dotted func off the engine itself self.assert_compile(func.lala.hoho(7), "lala.hoho(:hoho_1)") # test None becomes NULL - self.assert_compile(func.my_func(1, 2, None, 3), - "my_func(:my_func_1, :my_func_2, NULL, :my_func_3)") + self.assert_compile( + func.my_func( + 1, + 2, + None, + 3), + "my_func(:my_func_1, :my_func_2, NULL, :my_func_3)") # test pickling self.assert_compile( - util.pickle.loads(util.pickle.dumps( - func.my_func(1, 2, None, 3))), - "my_func(:my_func_1, :my_func_2, NULL, :my_func_3)") + util.pickle.loads(util.pickle.dumps( + func.my_func(1, 2, None, 3))), + "my_func(:my_func_1, :my_func_2, NULL, :my_func_3)") # assert func raises AttributeError for __bases__ attribute, since # its not a class fixes pydoc @@ -271,28 +280,34 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): assert True def test_functions_with_cols(self): - users = table('users', column('id'), column('name'), column('fullname')) - calculate = select([column('q'), column('z'), column('r')], - from_obj=[func.calculate(bindparam('x', None), bindparam('y', None))]) + users = table( + 'users', + column('id'), + column('name'), + column('fullname')) + calculate = select([column('q'), column('z'), column('r')], from_obj=[ + func.calculate( + bindparam('x', None), bindparam('y', None) + )]) self.assert_compile(select([users], users.c.id > calculate.c.z), - "SELECT users.id, users.name, users.fullname " - "FROM users, (SELECT q, z, r " - "FROM calculate(:x, :y)) " - "WHERE users.id > z" - ) + "SELECT users.id, users.name, users.fullname " + "FROM users, (SELECT q, z, r " + "FROM calculate(:x, :y)) " + "WHERE users.id > z" + ) s = select([users], users.c.id.between( calculate.alias('c1').unique_params(x=17, y=45).c.z, calculate.alias('c2').unique_params(x=5, y=12).c.z)) - self.assert_compile(s, - "SELECT users.id, users.name, users.fullname " + self.assert_compile( + s, "SELECT users.id, users.name, users.fullname " "FROM users, (SELECT q, z, r " "FROM calculate(:x_1, :y_1)) AS c1, (SELECT q, z, r " "FROM calculate(:x_2, :y_2)) AS c2 " - "WHERE users.id BETWEEN c1.z AND c2.z", - checkparams={'y_1': 45, 'x_1': 17, 'y_2': 12, 'x_2': 5}) + "WHERE users.id BETWEEN c1.z AND c2.z", checkparams={ + 'y_1': 45, 'x_1': 17, 'y_2': 12, 'x_2': 5}) def test_non_functions(self): expr = func.cast("foo", Integer) @@ -301,12 +316,13 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): expr = func.extract("year", datetime.date(2010, 12, 5)) self.assert_compile(expr, "EXTRACT(year FROM :param_1)") + class ExecuteTest(fixtures.TestBase): + @engines.close_first def tearDown(self): pass - def test_conn_execute(self): from sqlalchemy.sql.expression import FunctionElement from sqlalchemy.ext.compiler import compiles @@ -341,7 +357,6 @@ class ExecuteTest(fixtures.TestBase): eq_(ret.context.execution_options, {'foo': 'bar'}) ret.close() - @engines.close_first def test_update(self): """ @@ -352,16 +367,16 @@ class ExecuteTest(fixtures.TestBase): meta = MetaData(testing.db) t = Table('t1', meta, - Column('id', Integer, Sequence('t1idseq', optional=True), - primary_key=True), - Column('value', Integer) - ) + Column('id', Integer, Sequence('t1idseq', optional=True), + primary_key=True), + Column('value', Integer) + ) t2 = Table('t2', meta, - Column('id', Integer, Sequence('t2idseq', optional=True), - primary_key=True), - Column('value', Integer, default=7), - Column('stuff', String(20), onupdate="thisisstuff") - ) + Column('id', Integer, Sequence('t2idseq', optional=True), + primary_key=True), + Column('value', Integer, default=7), + Column('stuff', String(20), onupdate="thisisstuff") + ) meta.create_all() try: t.insert(values=dict(value=func.length("one"))).execute() @@ -374,20 +389,19 @@ class ExecuteTest(fixtures.TestBase): assert t.select(t.c.id == id).execute().first()['value'] == 9 t.update(values={t.c.value: func.length("asdf")}).execute() assert t.select().execute().first()['value'] == 4 - print("--------------------------") t2.insert().execute() t2.insert(values=dict(value=func.length("one"))).execute() t2.insert(values=dict(value=func.length("asfda") + -19)).\ - execute(stuff="hi") + execute(stuff="hi") res = exec_sorted(select([t2.c.value, t2.c.stuff])) eq_(res, [(-14, 'hi'), (3, None), (7, None)]) t2.update(values=dict(value=func.length("asdsafasd"))).\ - execute(stuff="some stuff") + execute(stuff="some stuff") assert select([t2.c.value, t2.c.stuff]).execute().fetchall() == \ - [(9, "some stuff"), (9, "some stuff"), - (9, "some stuff")] + [(9, "some stuff"), (9, "some stuff"), + (9, "some stuff")] t2.delete().execute() @@ -401,10 +415,10 @@ class ExecuteTest(fixtures.TestBase): ) t2.update(values={t2.c.value: func.length("asfdaasdf"), - t2.c.stuff: "foo"}).execute() + t2.c.stuff: "foo"}).execute() print("HI", select([t2.c.value, t2.c.stuff]).execute().first()) eq_(select([t2.c.value, t2.c.stuff]).execute().first(), - (9, "foo") + (9, "foo") ) finally: meta.drop_all() @@ -416,12 +430,12 @@ class ExecuteTest(fixtures.TestBase): y = func.current_date(bind=testing.db).select().execute().scalar() z = func.current_date(bind=testing.db).scalar() w = select(['*'], from_obj=[func.current_date(bind=testing.db)]).\ - scalar() + scalar() # construct a column-based FROM object out of a function, # like in [ticket:172] s = select([sql.column('date', type_=DateTime)], - from_obj=[func.current_date(bind=testing.db)]) + from_obj=[func.current_date(bind=testing.db)]) q = s.execute().first()[s.c.date] r = s.alias('datequery').select().scalar() @@ -470,4 +484,3 @@ def exec_sorted(statement, *args, **kw): return sorted([tuple(row) for row in statement.execute(*args, **kw).fetchall()]) - diff --git a/test/sql/test_generative.py b/test/sql/test_generative.py index 8a366f757..51a8a77cc 100644 --- a/test/sql/test_generative.py +++ b/test/sql/test_generative.py @@ -1,6 +1,8 @@ -from sqlalchemy import * from sqlalchemy.sql import table, column, ClauseElement, operators -from sqlalchemy.sql.expression import _clone, _from_objects +from sqlalchemy.sql.expression import _clone, _from_objects +from sqlalchemy import func, select, Integer, Table, \ + Column, MetaData, extract, String, bindparam, tuple_, and_, union, text,\ + case, ForeignKey from sqlalchemy.testing import fixtures, AssertsExecutionResults, \ AssertsCompiledSQL from sqlalchemy import testing @@ -10,7 +12,11 @@ from sqlalchemy import exc from sqlalchemy.sql import util as sql_util from sqlalchemy.testing import eq_, is_, assert_raises, assert_raises_message +A = B = t1 = t2 = t3 = table1 = table2 = table3 = table4 = None + + class TraversalTest(fixtures.TestBase, AssertsExecutionResults): + """test ClauseVisitor's traversal, particularly its ability to copy and modify a ClauseElement in place.""" @@ -83,7 +89,7 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): struct = B(a1, A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3")) struct2 = B(a1, A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3")) struct3 = B(a1, A("expr2"), B(A("expr1b"), - A("expr2bmodified")), A("expr3")) + A("expr2bmodified")), A("expr3")) assert a1.is_other(a1) assert struct.is_other(struct) @@ -94,11 +100,13 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): def test_clone(self): struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) + A("expr2b")), A("expr3")) class Vis(CloningVisitor): + def visit_a(self, a): pass + def visit_b(self, b): pass @@ -109,11 +117,13 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): def test_no_clone(self): struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) + A("expr2b")), A("expr3")) class Vis(ClauseVisitor): + def visit_a(self, a): pass + def visit_b(self, b): pass @@ -124,16 +134,18 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): def test_change_in_place(self): struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) + A("expr2b")), A("expr3")) struct2 = B(A("expr1"), A("expr2modified"), B(A("expr1b"), - A("expr2b")), A("expr3")) + A("expr2b")), A("expr3")) struct3 = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2bmodified")), A("expr3")) + A("expr2bmodified")), A("expr3")) class Vis(CloningVisitor): + def visit_a(self, a): if a.expr == "expr2": a.expr = "expr2modified" + def visit_b(self, b): pass @@ -144,9 +156,11 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): assert struct2 == s2 class Vis2(CloningVisitor): + def visit_a(self, a): if a.expr == "expr2b": a.expr = "expr2bmodified" + def visit_b(self, b): pass @@ -169,11 +183,14 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): set(ClauseVisitor().iterate(bin)) assert set(ClauseVisitor().iterate(bin)) == set([foo, bar, bin]) + class BinaryEndpointTraversalTest(fixtures.TestBase): + """test the special binary product visit""" def _assert_traversal(self, expr, expected): canary = [] + def visit(binary, l, r): canary.append((binary.operator, l, r)) print(binary.operator, l, r) @@ -206,8 +223,8 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): expr = tuple_( a, b, b1 == tuple_(b1a, b1b == d), c ) > tuple_( - func.go(e + f) - ) + func.go(e + f) + ) self._assert_traversal( expr, [ @@ -265,7 +282,9 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): ] ) + class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): + """test copy-in-place behavior of various ClauseElements.""" __dialect__ = 'default' @@ -274,19 +293,19 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): def setup_class(cls): global t1, t2, t3 t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) t3 = Table('table3', MetaData(), - Column('col1', Integer), - Column('col2', Integer) - ) + Column('col1', Integer), + Column('col2', Integer) + ) def test_binary(self): clause = t1.c.col2 == t2.c.col2 @@ -295,18 +314,19 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): def test_binary_anon_label_quirk(self): t = table('t1', column('col1')) - f = t.c.col1 * 5 self.assert_compile(select([f]), - "SELECT t1.col1 * :col1_1 AS anon_1 FROM t1") + "SELECT t1.col1 * :col1_1 AS anon_1 FROM t1") f.anon_label a = t.alias() f = sql_util.ClauseAdapter(a).traverse(f) - self.assert_compile(select([f]), - "SELECT t1_1.col1 * :col1_1 AS anon_1 FROM t1 AS t1_1") + self.assert_compile( + select( + [f]), + "SELECT t1_1.col1 * :col1_1 AS anon_1 FROM t1 AS t1_1") def test_join(self): clause = t1.join(t2, t1.c.col2 == t2.c.col2) @@ -314,6 +334,7 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): assert str(clause) == str(CloningVisitor().traverse(clause)) class Vis(CloningVisitor): + def visit_binary(self, binary): binary.right = t2.c.col3 @@ -422,10 +443,12 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): def test_text(self): clause = text( - "select * from table where foo=:bar", - bindparams=[bindparam('bar')]) + "select * from table where foo=:bar", + bindparams=[bindparam('bar')]) c1 = str(clause) + class Vis(CloningVisitor): + def visit_textclause(self, text): text.text = text.text + " SOME MODIFIER=:lala" text._bindparams['lala'] = bindparam('lala') @@ -440,7 +463,9 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s2 = select([t1]) s2_assert = str(s2) s3_assert = str(select([t1], t1.c.col2 == 7)) + class Vis(CloningVisitor): + def visit_select(self, select): select.append_whereclause(t1.c.col2 == 7) s3 = Vis().traverse(s2) @@ -448,14 +473,18 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): assert str(s2) == s2_assert print(str(s2)) print(str(s3)) + class Vis(ClauseVisitor): + def visit_select(self, select): select.append_whereclause(t1.c.col2 == 7) Vis().traverse(s2) assert str(s2) == s3_assert s4_assert = str(select([t1], and_(t1.c.col2 == 7, t1.c.col3 == 9))) + class Vis(CloningVisitor): + def visit_select(self, select): select.append_whereclause(t1.c.col3 == 9) s4 = Vis().traverse(s3) @@ -465,7 +494,9 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): assert str(s3) == s3_assert s5_assert = str(select([t1], and_(t1.c.col2 == 7, t1.c.col1 == 9))) + class Vis(CloningVisitor): + def visit_binary(self, binary): if binary.left is t1.c.col3: binary.left = t1.c.col1 @@ -495,8 +526,8 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): u2 = u.params(id_param=7) u3 = u.params(id_param=10) assert str(u) == str(u2) == str(u3) - assert u2.compile().params == {'id_param':7} - assert u3.compile().params == {'id_param':10} + assert u2.compile().params == {'id_param': 7} + assert u3.compile().params == {'id_param': 10} def test_in(self): expr = t1.c.col1.in_(['foo', 'bar']) @@ -510,9 +541,9 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): def test_adapt_union(self): u = union( - t1.select().where(t1.c.col1 == 4), - t1.select().where(t1.c.col1 == 5) - ).alias() + t1.select().where(t1.c.col1 == 4), + t1.select().where(t1.c.col1 == 5) + ).alias() assert sql_util.ClauseAdapter(u).traverse(t1) is u @@ -524,8 +555,8 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s2 = CloningVisitor().traverse(s).alias() s3 = select([s], s.c.col2 == s2.c.col2) - self.assert_compile(s3, - "SELECT anon_1.col1, anon_1.col2, anon_1.col3 FROM " + self.assert_compile( + s3, "SELECT anon_1.col1, anon_1.col2, anon_1.col3 FROM " "(SELECT table1.col1 AS col1, table1.col2 AS col2, " "table1.col3 AS col3 FROM table1 WHERE table1.col1 = :param_1) " "AS anon_1, " @@ -536,8 +567,8 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s = select([t1], t1.c.col1 == 4).alias() s2 = CloningVisitor().traverse(s).alias() s3 = select([s], s.c.col2 == s2.c.col2) - self.assert_compile(s3, - "SELECT anon_1.col1, anon_1.col2, anon_1.col3 FROM " + self.assert_compile( + s3, "SELECT anon_1.col1, anon_1.col2, anon_1.col3 FROM " "(SELECT table1.col1 AS col1, table1.col2 AS col2, " "table1.col3 AS col3 FROM table1 WHERE table1.col1 = :col1_1) " "AS anon_1, " @@ -547,25 +578,26 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): def test_extract(self): s = select([extract('foo', t1.c.col1).label('col1')]) - self.assert_compile(s, - "SELECT EXTRACT(foo FROM table1.col1) AS col1 FROM table1") + self.assert_compile( + s, + "SELECT EXTRACT(foo FROM table1.col1) AS col1 FROM table1") s2 = CloningVisitor().traverse(s).alias() s3 = select([s2.c.col1]) - self.assert_compile(s, - "SELECT EXTRACT(foo FROM table1.col1) AS col1 FROM table1") + self.assert_compile( + s, + "SELECT EXTRACT(foo FROM table1.col1) AS col1 FROM table1") self.assert_compile(s3, - "SELECT anon_1.col1 FROM (SELECT EXTRACT(foo FROM " - "table1.col1) AS col1 FROM table1) AS anon_1") - + "SELECT anon_1.col1 FROM (SELECT EXTRACT(foo FROM " + "table1.col1) AS col1 FROM table1) AS anon_1") @testing.emits_warning('.*replaced by another column with the same key') def test_alias(self): subq = t2.select().alias('subq') s = select([t1.c.col1, subq.c.col1], - from_obj=[t1, subq, - t1.join(subq, t1.c.col1 == subq.c.col2)] - ) + from_obj=[t1, subq, + t1.join(subq, t1.c.col1 == subq.c.col2)] + ) orig = str(s) s2 = CloningVisitor().traverse(s) assert orig == str(s) == str(s2) @@ -581,27 +613,28 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): subq = subq.alias('subq') s = select([t1.c.col1, subq.c.col1], - from_obj=[t1, subq, - t1.join(subq, t1.c.col1 == subq.c.col2)] - ) + from_obj=[t1, subq, + t1.join(subq, t1.c.col1 == subq.c.col2)] + ) s5 = CloningVisitor().traverse(s) assert orig == str(s) == str(s5) def test_correlated_select(self): s = select(['*'], t1.c.col1 == t2.c.col1, - from_obj=[t1, t2]).correlate(t2) + from_obj=[t1, t2]).correlate(t2) class Vis(CloningVisitor): + def visit_select(self, select): select.append_whereclause(t1.c.col2 == 7) self.assert_compile( - select([t2]).where(t2.c.col1 == Vis().traverse(s)), - "SELECT table2.col1, table2.col2, table2.col3 " - "FROM table2 WHERE table2.col1 = " - "(SELECT * FROM table1 WHERE table1.col1 = table2.col1 " - "AND table1.col2 = :col2_1)" - ) + select([t2]).where(t2.c.col1 == Vis().traverse(s)), + "SELECT table2.col1, table2.col2, table2.col3 " + "FROM table2 WHERE table2.col1 = " + "(SELECT * FROM table1 WHERE table1.col1 = table2.col1 " + "AND table1.col2 = :col2_1)" + ) def test_this_thing(self): s = select([t1]).where(t1.c.col1 == 'foo').alias() @@ -626,44 +659,42 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s = select([1], t1.c.col1 == t1a.c.col1, from_obj=t1a).correlate(t1a) s = select([t1]).where(t1.c.col1 == s) - self.assert_compile(s, - "SELECT table1.col1, table1.col2, table1.col3 FROM table1 " + self.assert_compile( + s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1 " "WHERE table1.col1 = " "(SELECT 1 FROM table1, table1 AS table1_1 " - "WHERE table1.col1 = table1_1.col1)" - ) + "WHERE table1.col1 = table1_1.col1)") s = CloningVisitor().traverse(s) - self.assert_compile(s, - "SELECT table1.col1, table1.col2, table1.col3 FROM table1 " + self.assert_compile( + s, "SELECT table1.col1, table1.col2, table1.col3 FROM table1 " "WHERE table1.col1 = " "(SELECT 1 FROM table1, table1 AS table1_1 " - "WHERE table1.col1 = table1_1.col1)") + "WHERE table1.col1 = table1_1.col1)") def test_select_fromtwice_two(self): s = select([t1]).where(t1.c.col1 == 'foo').alias() s2 = select([1], t1.c.col1 == s.c.col1, from_obj=s).correlate(t1) s3 = select([t1]).where(t1.c.col1 == s2) - self.assert_compile(s3, - "SELECT table1.col1, table1.col2, table1.col3 " - "FROM table1 WHERE table1.col1 = " - "(SELECT 1 FROM " - "(SELECT table1.col1 AS col1, table1.col2 AS col2, " - "table1.col3 AS col3 FROM table1 " - "WHERE table1.col1 = :col1_1) " - "AS anon_1 WHERE table1.col1 = anon_1.col1)" - ) + self.assert_compile( + s3, "SELECT table1.col1, table1.col2, table1.col3 " + "FROM table1 WHERE table1.col1 = " + "(SELECT 1 FROM " + "(SELECT table1.col1 AS col1, table1.col2 AS col2, " + "table1.col3 AS col3 FROM table1 " + "WHERE table1.col1 = :col1_1) " + "AS anon_1 WHERE table1.col1 = anon_1.col1)") s4 = ReplacingCloningVisitor().traverse(s3) - self.assert_compile(s4, - "SELECT table1.col1, table1.col2, table1.col3 " - "FROM table1 WHERE table1.col1 = " - "(SELECT 1 FROM " - "(SELECT table1.col1 AS col1, table1.col2 AS col2, " - "table1.col3 AS col3 FROM table1 " - "WHERE table1.col1 = :col1_1) " - "AS anon_1 WHERE table1.col1 = anon_1.col1)" - ) + self.assert_compile( + s4, "SELECT table1.col1, table1.col2, table1.col3 " + "FROM table1 WHERE table1.col1 = " + "(SELECT 1 FROM " + "(SELECT table1.col1 AS col1, table1.col2 AS col2, " + "table1.col3 AS col3 FROM table1 " + "WHERE table1.col1 = :col1_1) " + "AS anon_1 WHERE table1.col1 = anon_1.col1)") + class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -672,15 +703,15 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): def setup_class(cls): global t1, t2 t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) def test_correlation_on_clone(self): t1alias = t1.alias('t1alias') @@ -698,9 +729,9 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): s = vis.traverse(s) assert t2alias not in s._froms # not present because it's been - # cloned + # cloned assert t1alias in s._froms # present because the adapter placed - # it there + # it there # correlate list on "s" needs to take into account the full # _cloned_set for each element in _froms when correlating @@ -710,7 +741,7 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): 't2alias.col1 = (SELECT * FROM table1 AS ' 't1alias)') s = select(['*'], from_obj=[t1alias, - t2alias]).correlate(t2alias).as_scalar() + t2alias]).correlate(t2alias).as_scalar() self.assert_compile(select(['*'], t2alias.c.col1 == s), 'SELECT * FROM table2 AS t2alias WHERE ' 't2alias.col1 = (SELECT * FROM table1 AS ' @@ -806,63 +837,76 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) self.assert_compile(vis.traverse(select(['*'], t1.c.col1 - == t2.c.col2)), + == t2.c.col2)), 'SELECT * FROM table1 AS t1alias, table2 ' 'WHERE t1alias.col1 = table2.col2') def test_table_to_alias_5(self): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(vis.traverse(select(['*'], t1.c.col1 - == t2.c.col2, from_obj=[t1, t2])), - 'SELECT * FROM table1 AS t1alias, table2 ' - 'WHERE t1alias.col1 = table2.col2') + self.assert_compile( + vis.traverse( + select( + ['*'], + t1.c.col1 == t2.c.col2, + from_obj=[ + t1, + t2])), + 'SELECT * FROM table1 AS t1alias, table2 ' + 'WHERE t1alias.col1 = table2.col2') def test_table_to_alias_6(self): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( - select([t1alias, t2]).where(t1alias.c.col1 == - vis.traverse(select(['*'], - t1.c.col1 == t2.c.col2, - from_obj=[t1, t2]).correlate(t1))), - "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " - "table2.col1, table2.col2, table2.col3 " - "FROM table1 AS t1alias, table2 WHERE t1alias.col1 = " - "(SELECT * FROM table2 WHERE t1alias.col1 = table2.col2)" - ) + select([t1alias, t2]).where( + t1alias.c.col1 == vis.traverse( + select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2]). + correlate(t1) + ) + ), + "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " + "table2.col1, table2.col2, table2.col3 " + "FROM table1 AS t1alias, table2 WHERE t1alias.col1 = " + "(SELECT * FROM table2 WHERE t1alias.col1 = table2.col2)" + ) def test_table_to_alias_7(self): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( - select([t1alias, t2]).where(t1alias.c.col1 == - vis.traverse(select(['*'], - t1.c.col1 == t2.c.col2, - from_obj=[t1, t2]).correlate(t2))), - "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " - "table2.col1, table2.col2, table2.col3 " - "FROM table1 AS t1alias, table2 " - "WHERE t1alias.col1 = " - "(SELECT * FROM table1 AS t1alias " - "WHERE t1alias.col1 = table2.col2)") + select([t1alias, t2]). + where(t1alias.c.col1 == vis.traverse( + select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2]). + correlate(t2))), + "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " + "table2.col1, table2.col2, table2.col3 " + "FROM table1 AS t1alias, table2 " + "WHERE t1alias.col1 = " + "(SELECT * FROM table1 AS t1alias " + "WHERE t1alias.col1 = table2.col2)") def test_table_to_alias_8(self): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(vis.traverse(case([(t1.c.col1 == 5, - t1.c.col2)], else_=t1.c.col1)), - 'CASE WHEN (t1alias.col1 = :col1_1) THEN ' - 't1alias.col2 ELSE t1alias.col1 END') + self.assert_compile( + vis.traverse(case([(t1.c.col1 == 5, t1.c.col2)], else_=t1.c.col1)), + 'CASE WHEN (t1alias.col1 = :col1_1) THEN ' + 't1alias.col2 ELSE t1alias.col1 END') def test_table_to_alias_9(self): t1alias = t1.alias('t1alias') vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(vis.traverse(case([(5, t1.c.col2)], - value=t1.c.col1, else_=t1.c.col1)), - 'CASE t1alias.col1 WHEN :param_1 THEN ' - 't1alias.col2 ELSE t1alias.col1 END') - + self.assert_compile( + vis.traverse( + case( + [ + (5, + t1.c.col2)], + value=t1.c.col1, + else_=t1.c.col1)), + 'CASE t1alias.col1 WHEN :param_1 THEN ' + 't1alias.col2 ELSE t1alias.col1 END') def test_table_to_alias_10(self): s = select(['*'], from_obj=[t1]).alias('foo') @@ -893,7 +937,7 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): 'table1 AS t1alias') assert list(_from_objects(ff)) == [t1alias] - #def test_table_to_alias_2(self): + # def test_table_to_alias_2(self): # TODO: self.assert_compile(vis.traverse(select([func.count(t1.c # .col1).l abel('foo')]), clone=True), "SELECT # count(t1alias.col1) AS foo FROM table1 AS t1alias") @@ -904,7 +948,7 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): t2alias = t2.alias('t2alias') vis.chain(sql_util.ClauseAdapter(t2alias)) self.assert_compile(vis.traverse(select(['*'], t1.c.col1 - == t2.c.col2)), + == t2.c.col2)), 'SELECT * FROM table1 AS t1alias, table2 ' 'AS t2alias WHERE t1alias.col1 = ' 't2alias.col2') @@ -914,11 +958,17 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): vis = sql_util.ClauseAdapter(t1alias) t2alias = t2.alias('t2alias') vis.chain(sql_util.ClauseAdapter(t2alias)) - self.assert_compile(vis.traverse(select(['*'], t1.c.col1 - == t2.c.col2, from_obj=[t1, t2])), - 'SELECT * FROM table1 AS t1alias, table2 ' - 'AS t2alias WHERE t1alias.col1 = ' - 't2alias.col2') + self.assert_compile( + vis.traverse( + select( + ['*'], + t1.c.col1 == t2.c.col2, + from_obj=[ + t1, + t2])), + 'SELECT * FROM table1 AS t1alias, table2 ' + 'AS t2alias WHERE t1alias.col1 = ' + 't2alias.col2') def test_table_to_alias_16(self): t1alias = t1.alias('t1alias') @@ -927,18 +977,18 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): vis.chain(sql_util.ClauseAdapter(t2alias)) self.assert_compile( select([t1alias, t2alias]).where( - t1alias.c.col1 == - vis.traverse(select(['*'], - t1.c.col1 == t2.c.col2, - from_obj=[t1, t2]).correlate(t1)) - ), - "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " - "t2alias.col1, t2alias.col2, t2alias.col3 " - "FROM table1 AS t1alias, table2 AS t2alias " - "WHERE t1alias.col1 = " - "(SELECT * FROM table2 AS t2alias " - "WHERE t1alias.col1 = t2alias.col2)" - ) + t1alias.c.col1 == + vis.traverse(select(['*'], + t1.c.col1 == t2.c.col2, + from_obj=[t1, t2]).correlate(t1)) + ), + "SELECT t1alias.col1, t1alias.col2, t1alias.col3, " + "t2alias.col1, t2alias.col2, t2alias.col3 " + "FROM table1 AS t1alias, table2 AS t2alias " + "WHERE t1alias.col1 = " + "(SELECT * FROM table2 AS t2alias " + "WHERE t1alias.col1 = t2alias.col2)" + ) def test_table_to_alias_17(self): t1alias = t1.alias('t1alias') @@ -946,31 +996,35 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): t2alias = t2.alias('t2alias') vis.chain(sql_util.ClauseAdapter(t2alias)) self.assert_compile( - t2alias.select().where(t2alias.c.col2 == - vis.traverse(select(['*'], + t2alias.select().where( + t2alias.c.col2 == vis.traverse( + select( + ['*'], t1.c.col1 == t2.c.col2, - from_obj=[t1, t2]).correlate(t2))), - 'SELECT t2alias.col1, t2alias.col2, t2alias.col3 ' - 'FROM table2 AS t2alias WHERE t2alias.col2 = ' - '(SELECT * FROM table1 AS t1alias WHERE ' - 't1alias.col1 = t2alias.col2)') + from_obj=[ + t1, + t2]).correlate(t2))), + 'SELECT t2alias.col1, t2alias.col2, t2alias.col3 ' + 'FROM table2 AS t2alias WHERE t2alias.col2 = ' + '(SELECT * FROM table1 AS t1alias WHERE ' + 't1alias.col1 = t2alias.col2)') def test_include_exclude(self): m = MetaData() a = Table('a', m, - Column('id', Integer, primary_key=True), - Column('xxx_id', Integer, - ForeignKey('a.id', name='adf', use_alter=True) - ) - ) + Column('id', Integer, primary_key=True), + Column('xxx_id', Integer, + ForeignKey('a.id', name='adf', use_alter=True) + ) + ) e = (a.c.id == a.c.xxx_id) assert str(e) == "a.id = a.xxx_id" b = a.alias() - e = sql_util.ClauseAdapter( b, include= set([ a.c.id ]), - equivalents= { a.c.id: set([ a.c.id]) } - ).traverse( e) + e = sql_util.ClauseAdapter(b, include=set([a.c.id]), + equivalents={a.c.id: set([a.c.id])} + ).traverse(e) assert str(e) == "a_1.id = a.xxx_id" @@ -983,8 +1037,8 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # force a recursion overflow, by linking a.c.x<->c.c.x, and # asking for a nonexistent col. corresponding_column should prevent # endless depth. - adapt = sql_util.ClauseAdapter(b, - equivalents={a.c.x: set([c.c.x]), c.c.x: set([a.c.x])}) + adapt = sql_util.ClauseAdapter( + b, equivalents={a.c.x: set([c.c.x]), c.c.x: set([a.c.x])}) assert adapt._corresponding_column(a.c.x, False) is None def test_multilevel_equivalents(self): @@ -997,28 +1051,28 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # two levels of indirection from c.x->b.x->a.x, requires recursive # corresponding_column call - adapt = sql_util.ClauseAdapter(alias, - equivalents={b.c.x: set([a.c.x]), c.c.x: set([b.c.x])}) + adapt = sql_util.ClauseAdapter( + alias, equivalents={b.c.x: set([a.c.x]), c.c.x: set([b.c.x])}) assert adapt._corresponding_column(a.c.x, False) is alias.c.x assert adapt._corresponding_column(c.c.x, False) is alias.c.x def test_join_to_alias(self): metadata = MetaData() a = Table('a', metadata, - Column('id', Integer, primary_key=True)) + Column('id', Integer, primary_key=True)) b = Table('b', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + Column('id', Integer, primary_key=True), + Column('aid', Integer, ForeignKey('a.id')), + ) c = Table('c', metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer, ForeignKey('b.id')), - ) + Column('id', Integer, primary_key=True), + Column('bid', Integer, ForeignKey('b.id')), + ) d = Table('d', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + Column('id', Integer, primary_key=True), + Column('aid', Integer, ForeignKey('a.id')), + ) j1 = a.outerjoin(b) j2 = select([j1], use_labels=True) @@ -1054,7 +1108,6 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): assert not t1.is_derived_from(select([t1])) assert t1.alias().is_derived_from(t1) - s1 = select([t1, t2]).alias('foo') s2 = select([s1]).limit(5).offset(10).alias() assert s2.is_derived_from(s1) @@ -1108,13 +1161,13 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): 'LIMIT :param_1 OFFSET :param_2) AS anon_1 ' 'LEFT OUTER JOIN table1 AS bar ON ' 'anon_1.col1 = bar.col1', {'param_1': 5, - 'param_2': 10}) + 'param_2': 10}) def test_functions(self): self.assert_compile( - sql_util.ClauseAdapter(t1.alias()).\ - traverse(func.count(t1.c.col1)), - 'count(table1_1.col1)') + sql_util.ClauseAdapter(t1.alias()). + traverse(func.count(t1.c.col1)), + 'count(table1_1.col1)') s = select([func.count(t1.c.col1)]) self.assert_compile(sql_util.ClauseAdapter(t1.alias()).traverse(s), 'SELECT count(table1_1.col1) AS count_1 ' @@ -1123,20 +1176,20 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): def test_recursive(self): metadata = MetaData() a = Table('a', metadata, - Column('id', Integer, primary_key=True)) + Column('id', Integer, primary_key=True)) b = Table('b', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + Column('id', Integer, primary_key=True), + Column('aid', Integer, ForeignKey('a.id')), + ) c = Table('c', metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer, ForeignKey('b.id')), - ) + Column('id', Integer, primary_key=True), + Column('bid', Integer, ForeignKey('b.id')), + ) d = Table('d', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + Column('id', Integer, primary_key=True), + Column('aid', Integer, ForeignKey('a.id')), + ) u = union( a.join(b).select().apply_labels(), @@ -1144,9 +1197,9 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): ).alias() self.assert_compile( - sql_util.ClauseAdapter(u).\ - traverse(select([c.c.bid]).where(c.c.bid == u.c.b_aid)), - "SELECT c.bid "\ + sql_util.ClauseAdapter(u). + traverse(select([c.c.bid]).where(c.c.bid == u.c.b_aid)), + "SELECT c.bid " "FROM c, (SELECT a.id AS a_id, b.id AS b_id, b.aid AS b_aid " "FROM a JOIN b ON a.id = b.aid UNION SELECT a.id AS a_id, d.id " "AS d_id, d.aid AS d_aid " @@ -1154,6 +1207,7 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): "WHERE c.bid = anon_1.b_aid" ) + class SpliceJoinsTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -1165,13 +1219,19 @@ class SpliceJoinsTest(fixtures.TestBase, AssertsCompiledSQL): return table(name, column('col1'), column('col2'), column('col3')) - table1, table2, table3, table4 = [_table(name) for name in - ('table1', 'table2', 'table3', 'table4')] + table1, table2, table3, table4 = [ + _table(name) for name in ( + 'table1', 'table2', 'table3', 'table4')] def test_splice(self): t1, t2, t3, t4 = table1, table2, table1.alias(), table2.alias() - j = t1.join(t2, t1.c.col1 == t2.c.col1).join(t3, t2.c.col1 - == t3.c.col1).join(t4, t4.c.col1 == t1.c.col1) + j = t1.join( + t2, + t1.c.col1 == t2.c.col1).join( + t3, + t2.c.col1 == t3.c.col1).join( + t4, + t4.c.col1 == t1.c.col1) s = select([t1]).where(t1.c.col2 < 5).alias() self.assert_compile(sql_util.splice_joins(s, j), '(SELECT table1.col1 AS col1, table1.col2 ' @@ -1204,8 +1264,11 @@ class SpliceJoinsTest(fixtures.TestBase, AssertsCompiledSQL): def test_splice_2(self): t2a = table2.alias() t3a = table3.alias() - j1 = table1.join(t2a, table1.c.col1 == t2a.c.col1).join(t3a, - t2a.c.col2 == t3a.c.col2) + j1 = table1.join( + t2a, + table1.c.col1 == t2a.c.col1).join( + t3a, + t2a.c.col2 == t3a.c.col2) t2b = table4.alias() j2 = table1.join(t2b, table1.c.col3 == t2b.c.col3) self.assert_compile(sql_util.splice_joins(table1, j1), @@ -1216,16 +1279,21 @@ class SpliceJoinsTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile(sql_util.splice_joins(table1, j2), 'table1 JOIN table4 AS table4_1 ON ' 'table1.col3 = table4_1.col3') - self.assert_compile(sql_util.splice_joins(sql_util.splice_joins(table1, - j1), j2), - 'table1 JOIN table2 AS table2_1 ON ' - 'table1.col1 = table2_1.col1 JOIN table3 ' - 'AS table3_1 ON table2_1.col2 = ' - 'table3_1.col2 JOIN table4 AS table4_1 ON ' - 'table1.col3 = table4_1.col3') + self.assert_compile( + sql_util.splice_joins( + sql_util.splice_joins( + table1, + j1), + j2), + 'table1 JOIN table2 AS table2_1 ON ' + 'table1.col1 = table2_1.col1 JOIN table3 ' + 'AS table3_1 ON table2_1.col2 = ' + 'table3_1.col2 JOIN table4 AS table4_1 ON ' + 'table1.col3 = table4_1.col3') class SelectTest(fixtures.TestBase, AssertsCompiledSQL): + """tests the generative capability of Select""" __dialect__ = 'default' @@ -1234,16 +1302,15 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): def setup_class(cls): global t1, t2 t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) - + column("col1"), + column("col2"), + column("col3"), + ) def test_columns(self): s = t1.select() @@ -1275,7 +1342,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): 'SELECT table1.col1, table1.col2, ' 'table1.col3 FROM table1') - def test_prefixes(self): s = t1.select() self.assert_compile(s, @@ -1308,7 +1374,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises( exc.ArgumentError, select().execution_options, - isolation_level='READ_COMMITTED' + isolation_level='READ_COMMITTED' ) # this feature not available yet @@ -1325,7 +1391,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): s = text('select 42', execution_options=dict(foo='bar')) assert s._execution_options == dict(foo='bar') + class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): + """Tests the generative capability of Insert, Update""" __dialect__ = 'default' @@ -1336,15 +1404,15 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): def setup_class(cls): global t1, t2 t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + column("col1"), + column("col2"), + column("col3"), + ) def test_prefixes(self): i = t1.insert() @@ -1396,9 +1464,9 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): eq_(i.parameters, None) i = i.values([(5, 6, 7), (8, 9, 10)]) eq_(i.parameters, [ - {"col1": 5, "col2": 6, "col3": 7}, - {"col1": 8, "col2": 9, "col3": 10}, - ] + {"col1": 5, "col2": 6, "col3": 7}, + {"col1": 8, "col2": 9, "col3": 10}, + ] ) def test_inline_values_single(self): diff --git a/test/sql/test_insert.py b/test/sql/test_insert.py index 6ee38d6a2..d59d79d89 100644 --- a/test/sql/test_insert.py +++ b/test/sql/test_insert.py @@ -9,6 +9,7 @@ from sqlalchemy.testing import AssertsCompiledSQL,\ class _InsertTestBase(object): + @classmethod def define_tables(cls, metadata): Table('mytable', metadata, @@ -27,8 +28,8 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1 = self.tables.mytable self.assert_compile(insert(table1), - 'INSERT INTO mytable (myid, name, description) ' - 'VALUES (:myid, :name, :description)') + 'INSERT INTO mytable (myid, name, description) ' + 'VALUES (:myid, :name, :description)') def test_insert_with_values_dict(self): table1 = self.tables.mytable @@ -38,7 +39,12 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): 'name': 'jack' } - self.assert_compile(insert(table1, dict(myid=3, name='jack')), + self.assert_compile( + insert( + table1, + dict( + myid=3, + name='jack')), 'INSERT INTO mytable (myid, name) VALUES (:myid, :name)', checkparams=checkparams) @@ -52,15 +58,15 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): } self.assert_compile(insert(table1, (3, 'jack', 'mydescription')), - 'INSERT INTO mytable (myid, name, description) ' - 'VALUES (:myid, :name, :description)', - checkparams=checkparams) + 'INSERT INTO mytable (myid, name, description) ' + 'VALUES (:myid, :name, :description)', + checkparams=checkparams) def test_insert_with_values_func(self): table1 = self.tables.mytable self.assert_compile(insert(table1, values=dict(myid=func.lala())), - 'INSERT INTO mytable (myid) VALUES (lala())') + 'INSERT INTO mytable (myid) VALUES (lala())') def test_insert_with_user_supplied_bind_params(self): table1 = self.tables.mytable @@ -70,7 +76,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1.c.name: bindparam('username') } - self.assert_compile(insert(table1, values), + self.assert_compile( + insert( + table1, + values), 'INSERT INTO mytable (myid, name) VALUES (:userid, :username)') def test_insert_values(self): @@ -79,7 +88,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): values1 = {table1.c.myid: bindparam('userid')} values2 = {table1.c.name: bindparam('username')} - self.assert_compile(insert(table1, values=values1).values(values2), + self.assert_compile( + insert( + table1, + values=values1).values(values2), 'INSERT INTO mytable (myid, name) VALUES (:userid, :username)') def test_prefix_with(self): @@ -89,25 +101,31 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): prefix_with('A', 'B', dialect='mysql').\ prefix_with('C', 'D') - self.assert_compile(stmt, + self.assert_compile( + stmt, 'INSERT C D INTO mytable (myid, name, description) ' 'VALUES (:myid, :name, :description)') - self.assert_compile(stmt, + self.assert_compile( + stmt, 'INSERT A B C D INTO mytable (myid, name, description) ' - 'VALUES (%s, %s, %s)', dialect=mysql.dialect()) + 'VALUES (%s, %s, %s)', + dialect=mysql.dialect()) def test_inline_default(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=func.foobar())) + Column('id', Integer, primary_key=True), + Column('foo', Integer, default=func.foobar())) self.assert_compile(table.insert(values={}, inline=True), - 'INSERT INTO sometable (foo) VALUES (foobar())') + 'INSERT INTO sometable (foo) VALUES (foobar())') - self.assert_compile(table.insert(inline=True), - 'INSERT INTO sometable (foo) VALUES (foobar())', params={}) + self.assert_compile( + table.insert( + inline=True), + 'INSERT INTO sometable (foo) VALUES (foobar())', + params={}) def test_insert_returning_not_in_default(self): table1 = self.tables.mytable @@ -122,9 +140,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_from_select_select(self): table1 = self.tables.mytable - sel = select([table1.c.myid, table1.c.name]).where(table1.c.name == 'foo') + sel = select([table1.c.myid, table1.c.name]).where( + table1.c.name == 'foo') ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + from_select(("otherid", "othername"), sel) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " @@ -135,9 +154,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_from_select_select_alt_ordering(self): table1 = self.tables.mytable - sel = select([table1.c.name, table1.c.myid]).where(table1.c.name == 'foo') + sel = select([table1.c.name, table1.c.myid]).where( + table1.c.name == 'foo') ins = self.tables.myothertable.insert().\ - from_select(("othername", "otherid"), sel) + from_select(("othername", "otherid"), sel) self.assert_compile( ins, "INSERT INTO myothertable (othername, otherid) " @@ -149,12 +169,12 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_from_select_select_no_defaults(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=func.foobar())) + Column('id', Integer, primary_key=True), + Column('foo', Integer, default=func.foobar())) table1 = self.tables.mytable sel = select([table1.c.myid]).where(table1.c.name == 'foo') ins = table.insert().\ - from_select(["id"], sel) + from_select(["id"], sel) self.assert_compile( ins, "INSERT INTO sometable (id) SELECT mytable.myid " @@ -164,9 +184,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_mix_select_values_exception(self): table1 = self.tables.mytable - sel = select([table1.c.myid, table1.c.name]).where(table1.c.name == 'foo') + sel = select([table1.c.myid, table1.c.name]).where( + table1.c.name == 'foo') ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + from_select(("otherid", "othername"), sel) assert_raises_message( exc.InvalidRequestError, "This construct already inserts from a SELECT", @@ -175,7 +196,8 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_mix_values_select_exception(self): table1 = self.tables.mytable - sel = select([table1.c.myid, table1.c.name]).where(table1.c.name == 'foo') + sel = select([table1.c.myid, table1.c.name]).where( + table1.c.name == 'foo') ins = self.tables.myothertable.insert().values(othername="5") assert_raises_message( exc.InvalidRequestError, @@ -186,7 +208,7 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_insert_from_select_table(self): table1 = self.tables.mytable ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), table1) + from_select(("otherid", "othername"), table1) # note we aren't checking the number of columns right now self.assert_compile( ins, @@ -207,20 +229,22 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): select([name, description]) ) ins = mytable.insert().\ - from_select( - [mytable.c.name, mytable.c.description], sel) + from_select( + [mytable.c.name, mytable.c.description], sel) self.assert_compile( ins, "INSERT INTO mytable (name, description) " - "SELECT name, mytable.description FROM mytable " - "UNION SELECT name, desc" + "SELECT name, mytable.description FROM mytable " + "UNION SELECT name, desc" ) + def test_insert_from_select_col_values(self): table1 = self.tables.mytable table2 = self.tables.myothertable - sel = select([table1.c.myid, table1.c.name]).where(table1.c.name == 'foo') + sel = select([table1.c.myid, table1.c.name]).where( + table1.c.name == 'foo') ins = table2.insert().\ - from_select((table2.c.otherid, table2.c.othername), sel) + from_select((table2.c.otherid, table2.c.othername), sel) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " @@ -247,8 +271,8 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): stmt = table1.insert().values({}) # hide from 2to3 self.assert_compile(stmt, - 'INSERT INTO mytable DEFAULT VALUES', - dialect=dialect) + 'INSERT INTO mytable DEFAULT VALUES', + dialect=dialect) def test_supports_empty_insert_false(self): table1 = self.tables.mytable @@ -257,10 +281,12 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): dialect.supports_empty_insert = dialect.supports_default_values = False stmt = table1.insert().values({}) # hide from 2to3 - assert_raises_message(exc.CompileError, + assert_raises_message( + exc.CompileError, "The 'default' dialect with current database version " - "settings does not support empty inserts.", - stmt.compile, dialect=dialect) + "settings does not support empty inserts.", + stmt.compile, + dialect=dialect) def _test_insert_with_empty_collection_values(self, collection): table1 = self.tables.mytable @@ -268,13 +294,13 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): ins = table1.insert().values(collection) self.assert_compile(ins, - 'INSERT INTO mytable () VALUES ()', - checkparams={}) + 'INSERT INTO mytable () VALUES ()', + checkparams={}) # empty dict populates on next values call self.assert_compile(ins.values(myid=3), - 'INSERT INTO mytable (myid) VALUES (:myid)', - checkparams={'myid': 3}) + 'INSERT INTO mytable (myid) VALUES (:myid)', + checkparams={'myid': 3}) def test_insert_with_empty_list_values(self): self._test_insert_with_empty_collection_values([]) @@ -297,7 +323,7 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): assert_raises_message( exc.CompileError, "The 'default' dialect with current database version settings " - "does not support in-place multirow inserts.", + "does not support in-place multirow inserts.", stmt.compile, dialect=dialect) def test_named(self): @@ -324,12 +350,14 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): dialect = default.DefaultDialect() dialect.supports_multivalues_insert = True - self.assert_compile(table1.insert().values(values), + self.assert_compile( + table1.insert().values(values), 'INSERT INTO mytable (myid, name, description) VALUES ' - '(:myid_0, :name_0, :description_0), ' - '(:myid_1, :name_1, :description_1), ' - '(:myid_2, :name_2, :description_2)', - checkparams=checkparams, dialect=dialect) + '(:myid_0, :name_0, :description_0), ' + '(:myid_1, :name_1, :description_1), ' + '(:myid_2, :name_2, :description_2)', + checkparams=checkparams, + dialect=dialect) def test_positional(self): table1 = self.tables.mytable @@ -347,17 +375,19 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): dialect.paramstyle = 'format' dialect.positional = True - self.assert_compile(table1.insert().values(values), + self.assert_compile( + table1.insert().values(values), 'INSERT INTO mytable (myid, name, description) VALUES ' '(%s, %s, %s), (%s, %s, %s), (%s, %s, %s)', - checkpositional=checkpositional, dialect=dialect) + checkpositional=checkpositional, + dialect=dialect) def test_inline_default(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer, default=func.foobar())) + Column('id', Integer, primary_key=True), + Column('data', String), + Column('foo', Integer, default=func.foobar())) values = [ {'id': 1, 'data': 'data1'}, @@ -375,19 +405,21 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): 'foo_1': 'plainfoo', } - self.assert_compile(table.insert().values(values), + self.assert_compile( + table.insert().values(values), 'INSERT INTO sometable (id, data, foo) VALUES ' '(%(id_0)s, %(data_0)s, foobar()), ' '(%(id_1)s, %(data_1)s, %(foo_1)s), ' '(%(id_2)s, %(data_2)s, foobar())', - checkparams=checkparams, dialect=postgresql.dialect()) + checkparams=checkparams, + dialect=postgresql.dialect()) def test_sql_functions(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer)) + Column('id', Integer, primary_key=True), + Column('data', String), + Column('foo', Integer)) values = [ {"id": 1, "data": "foo", "foo": func.foob()}, @@ -414,21 +446,23 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): 'data_4': 'bar' } - self.assert_compile(table.insert().values(values), + self.assert_compile( + table.insert().values(values), "INSERT INTO sometable (id, data, foo) VALUES " "(%(id_0)s, %(data_0)s, foob()), " "(%(id_1)s, %(data_1)s, foob()), " "(%(id_2)s, %(data_2)s, bar()), " "(%(id_3)s, %(data_3)s, %(foo_3)s), " "(%(id_4)s, %(data_4)s, foob())", - checkparams=checkparams, dialect=postgresql.dialect()) + checkparams=checkparams, + dialect=postgresql.dialect()) def test_server_default(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer, server_default=func.foobar())) + Column('id', Integer, primary_key=True), + Column('data', String), + Column('foo', Integer, server_default=func.foobar())) values = [ {'id': 1, 'data': 'data1'}, @@ -445,19 +479,21 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): 'data_2': 'data3', } - self.assert_compile(table.insert().values(values), + self.assert_compile( + table.insert().values(values), 'INSERT INTO sometable (id, data) VALUES ' '(%(id_0)s, %(data_0)s), ' '(%(id_1)s, %(data_1)s), ' '(%(id_2)s, %(data_2)s)', - checkparams=checkparams, dialect=postgresql.dialect()) + checkparams=checkparams, + dialect=postgresql.dialect()) def test_server_default_absent_value(self): metadata = MetaData() table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer, server_default=func.foobar())) + Column('id', Integer, primary_key=True), + Column('data', String), + Column('foo', Integer, server_default=func.foobar())) values = [ {'id': 1, 'data': 'data1', 'foo': 'plainfoo'}, @@ -478,9 +514,11 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): # note the effect here is that the first set of params # takes effect for the rest of them, when one is absent - self.assert_compile(table.insert().values(values), + self.assert_compile( + table.insert().values(values), 'INSERT INTO sometable (id, data, foo) VALUES ' '(%(id_0)s, %(data_0)s, %(foo_0)s), ' '(%(id_1)s, %(data_1)s, %(foo_0)s), ' '(%(id_2)s, %(data_2)s, %(foo_2)s)', - checkparams=checkparams, dialect=postgresql.dialect()) + checkparams=checkparams, + dialect=postgresql.dialect()) diff --git a/test/sql/test_inspect.py b/test/sql/test_inspect.py index 8a0251498..d5a9a71ae 100644 --- a/test/sql/test_inspect.py +++ b/test/sql/test_inspect.py @@ -5,12 +5,13 @@ from sqlalchemy import Table, Column, Integer, MetaData from sqlalchemy.testing import fixtures from sqlalchemy.testing import is_ + class TestCoreInspection(fixtures.TestBase): def test_table(self): t = Table('t', MetaData(), - Column('x', Integer) - ) + Column('x', Integer) + ) is_(inspect(t), t) assert t.is_selectable @@ -18,8 +19,8 @@ class TestCoreInspection(fixtures.TestBase): def test_select(self): t = Table('t', MetaData(), - Column('x', Integer) - ) + Column('x', Integer) + ) s = t.select() is_(inspect(s), s) @@ -30,4 +31,4 @@ class TestCoreInspection(fixtures.TestBase): c = Column('x', Integer) is_(inspect(c), c) assert not c.is_selectable - assert not hasattr(c, 'selectable')
\ No newline at end of file + assert not hasattr(c, 'selectable') diff --git a/test/sql/test_join_rewriting.py b/test/sql/test_join_rewriting.py index 7400792ca..035f60d60 100644 --- a/test/sql/test_join_rewriting.py +++ b/test/sql/test_join_rewriting.py @@ -1,5 +1,6 @@ -from sqlalchemy import Table, Column, Integer, MetaData, ForeignKey, select, exists, union -from sqlalchemy.testing import fixtures, AssertsCompiledSQL, eq_ +from sqlalchemy import Table, Column, Integer, MetaData, ForeignKey, \ + select, exists, union +from sqlalchemy.testing import fixtures, AssertsCompiledSQL from sqlalchemy import util from sqlalchemy.engine import default from sqlalchemy import testing @@ -9,62 +10,64 @@ m = MetaData() a = Table('a', m, - Column('id', Integer, primary_key=True) - ) + Column('id', Integer, primary_key=True) + ) b = Table('b', m, - Column('id', Integer, primary_key=True), - Column('a_id', Integer, ForeignKey('a.id')) - ) + Column('id', Integer, primary_key=True), + Column('a_id', Integer, ForeignKey('a.id')) + ) b_a = Table('b_a', m, - Column('id', Integer, primary_key=True), - ) + Column('id', Integer, primary_key=True), + ) b1 = Table('b1', m, - Column('id', Integer, primary_key=True), - Column('a_id', Integer, ForeignKey('a.id')) - ) + Column('id', Integer, primary_key=True), + Column('a_id', Integer, ForeignKey('a.id')) + ) b2 = Table('b2', m, - Column('id', Integer, primary_key=True), - Column('a_id', Integer, ForeignKey('a.id')) - ) + Column('id', Integer, primary_key=True), + Column('a_id', Integer, ForeignKey('a.id')) + ) a_to_b = Table('a_to_b', m, - Column('a_id', Integer, ForeignKey('a.id')), - Column('b_id', Integer, ForeignKey('b.id')), - ) + Column('a_id', Integer, ForeignKey('a.id')), + Column('b_id', Integer, ForeignKey('b.id')), + ) c = Table('c', m, - Column('id', Integer, primary_key=True), - Column('b_id', Integer, ForeignKey('b.id')) - ) + Column('id', Integer, primary_key=True), + Column('b_id', Integer, ForeignKey('b.id')) + ) d = Table('d', m, - Column('id', Integer, primary_key=True), - Column('c_id', Integer, ForeignKey('c.id')) - ) + Column('id', Integer, primary_key=True), + Column('c_id', Integer, ForeignKey('c.id')) + ) e = Table('e', m, - Column('id', Integer, primary_key=True) - ) + Column('id', Integer, primary_key=True) + ) f = Table('f', m, - Column('id', Integer, primary_key=True), - Column('a_id', ForeignKey('a.id')) - ) + Column('id', Integer, primary_key=True), + Column('a_id', ForeignKey('a.id')) + ) b_key = Table('b_key', m, - Column('id', Integer, primary_key=True, key='bid'), - ) + Column('id', Integer, primary_key=True, key='bid'), + ) a_to_b_key = Table('a_to_b_key', m, - Column('aid', Integer, ForeignKey('a.id')), - Column('bid', Integer, ForeignKey('b_key.bid')), - ) + Column('aid', Integer, ForeignKey('a.id')), + Column('bid', Integer, ForeignKey('b_key.bid')), + ) + class _JoinRewriteTestBase(AssertsCompiledSQL): + def _test(self, s, assert_): self.assert_compile( s, @@ -111,7 +114,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j2 = a.join(j1) s = select([a, b_key.c.bid], use_labels=True).\ - select_from(j2) + select_from(j2) self._test(s, self._a_bkeyassoc) @@ -123,7 +126,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j2 = a.join(j1) s = select([a, bkey_alias.c.bid], use_labels=True).\ - select_from(j2) + select_from(j2) self._test(s, self._a_bkeyassoc_aliased) @@ -137,7 +140,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): where(b.c.id == 2).\ where(c.c.id == 3).\ where(d.c.id == 4).\ - order_by(a.c.id, b.c.id, c.c.id, d.c.id) + order_by(a.c.id, b.c.id, c.c.id, d.c.id) self._test( s, @@ -146,7 +149,8 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): def test_a_bc_comma_a1_selbc(self): # test here we're emulating is - # test.orm.inheritance.test_polymorphic_rel:PolymorphicJoinsTest.test_multi_join + # test.orm.inheritance.test_polymorphic_rel: + # PolymorphicJoinsTest.test_multi_join j1 = b.join(c) j2 = b.join(c).select(use_labels=True).alias() j3 = a.join(j1) @@ -154,7 +158,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j4 = a_a.join(j2) s = select([a, a_a, b, c, j2], use_labels=True).\ - select_from(j3).select_from(j4).order_by(j2.c.b_id) + select_from(j3).select_from(j4).order_by(j2.c.b_id) self._test( s, @@ -170,10 +174,14 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): # TODO: if we put straight a_to_b_alias here, # it fails to alias the columns clause. - s = select([a, a_to_b_alias.c.a_id, a_to_b_alias.c.b_id, - b_alias.c.id, b_alias.c.a_id, - exists().select_from(c).where(c.c.b_id == b_alias.c.id).label(None) - ], use_labels=True).select_from(j2) + s = select([a, + a_to_b_alias.c.a_id, + a_to_b_alias.c.b_id, + b_alias.c.id, + b_alias.c.a_id, + exists().select_from(c). + where(c.c.b_id == b_alias.c.id).label(None)], + use_labels=True).select_from(j2) self._test( s, @@ -202,9 +210,9 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): b_j2 = b.join(j2) s = union( - select([b_j1], use_labels=True), - select([b_j2], use_labels=True) - ).select(use_labels=True) + select([b_j1], use_labels=True), + select([b_j2], use_labels=True) + ).select(use_labels=True) self._test( s, @@ -216,10 +224,10 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): # this involves annotations so try to loop those in. j1 = b.join(b_a, b.c.id == b_a.c.id) annot = [ - b.c.id._annotate({}), - b.c.a_id._annotate({}), - b_a.c.id._annotate({}) - ] + b.c.id._annotate({}), + b.c.a_id._annotate({}), + b_a.c.id._annotate({}) + ] s = select(annot).select_from(j1).apply_labels().alias() @@ -245,6 +253,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): + """test rendering of each join with right-nested rewritten as aliased SELECT statements..""" @@ -255,49 +264,49 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): return dialect _a__b_dc = ( - "SELECT a.id AS a_id, anon_1.b_id AS b_id, " - "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " - "anon_1.c_b_id AS c_b_id, anon_1.d_id AS d_id, " - "anon_1.d_c_id AS d_c_id " - "FROM a JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, " - "anon_2.c_id AS c_id, anon_2.c_b_id AS c_b_id, " - "anon_2.d_id AS d_id, anon_2.d_c_id AS d_c_id " - "FROM b JOIN (SELECT c.id AS c_id, c.b_id AS c_b_id, " - "d.id AS d_id, d.c_id AS d_c_id " - "FROM c JOIN d ON c.id = d.c_id) AS anon_2 " - "ON b.id = anon_2.c_b_id) AS anon_1 ON a.id = anon_1.b_a_id " - "WHERE anon_1.b_id = :id_1 AND anon_1.c_id = :id_2 AND " - "anon_1.d_id = :id_3 " - "ORDER BY a.id, anon_1.b_id, anon_1.c_id, anon_1.d_id" - ) + "SELECT a.id AS a_id, anon_1.b_id AS b_id, " + "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " + "anon_1.c_b_id AS c_b_id, anon_1.d_id AS d_id, " + "anon_1.d_c_id AS d_c_id " + "FROM a JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, " + "anon_2.c_id AS c_id, anon_2.c_b_id AS c_b_id, " + "anon_2.d_id AS d_id, anon_2.d_c_id AS d_c_id " + "FROM b JOIN (SELECT c.id AS c_id, c.b_id AS c_b_id, " + "d.id AS d_id, d.c_id AS d_c_id " + "FROM c JOIN d ON c.id = d.c_id) AS anon_2 " + "ON b.id = anon_2.c_b_id) AS anon_1 ON a.id = anon_1.b_a_id " + "WHERE anon_1.b_id = :id_1 AND anon_1.c_id = :id_2 AND " + "anon_1.d_id = :id_3 " + "ORDER BY a.id, anon_1.b_id, anon_1.c_id, anon_1.d_id" + ) _a_bc = ( - "SELECT a.id AS a_id, anon_1.b_id AS b_id, " - "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " - "anon_1.c_b_id AS c_b_id FROM a JOIN " - "(SELECT b.id AS b_id, b.a_id AS b_a_id, " - "c.id AS c_id, c.b_id AS c_b_id " - "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " - "ON a.id = anon_1.b_a_id " - "WHERE anon_1.b_id = :id_1 AND anon_1.c_id = :id_2 " - "ORDER BY a.id, anon_1.b_id, anon_1.c_id" - ) + "SELECT a.id AS a_id, anon_1.b_id AS b_id, " + "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " + "anon_1.c_b_id AS c_b_id FROM a JOIN " + "(SELECT b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, c.b_id AS c_b_id " + "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " + "ON a.id = anon_1.b_a_id " + "WHERE anon_1.b_id = :id_1 AND anon_1.c_id = :id_2 " + "ORDER BY a.id, anon_1.b_id, anon_1.c_id" + ) _a_bc_comma_a1_selbc = ( - "SELECT a.id AS a_id, a_1.id AS a_1_id, anon_1.b_id AS b_id, " - "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " - "anon_1.c_b_id AS c_b_id, anon_2.b_id AS anon_2_b_id, " - "anon_2.b_a_id AS anon_2_b_a_id, anon_2.c_id AS anon_2_c_id, " - "anon_2.c_b_id AS anon_2_c_b_id FROM a " - "JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, c.id AS c_id, " - "c.b_id AS c_b_id FROM b JOIN c ON b.id = c.b_id) AS anon_1 " - "ON a.id = anon_1.b_a_id, " - "a AS a_1 JOIN " - "(SELECT b.id AS b_id, b.a_id AS b_a_id, " - "c.id AS c_id, c.b_id AS c_b_id " - "FROM b JOIN c ON b.id = c.b_id) AS anon_2 " - "ON a_1.id = anon_2.b_a_id ORDER BY anon_2.b_id" - ) + "SELECT a.id AS a_id, a_1.id AS a_1_id, anon_1.b_id AS b_id, " + "anon_1.b_a_id AS b_a_id, anon_1.c_id AS c_id, " + "anon_1.c_b_id AS c_b_id, anon_2.b_id AS anon_2_b_id, " + "anon_2.b_a_id AS anon_2_b_a_id, anon_2.c_id AS anon_2_c_id, " + "anon_2.c_b_id AS anon_2_c_b_id FROM a " + "JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, c.id AS c_id, " + "c.b_id AS c_b_id FROM b JOIN c ON b.id = c.b_id) AS anon_1 " + "ON a.id = anon_1.b_a_id, " + "a AS a_1 JOIN " + "(SELECT b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, c.b_id AS c_b_id " + "FROM b JOIN c ON b.id = c.b_id) AS anon_2 " + "ON a_1.id = anon_2.b_a_id ORDER BY anon_2.b_id" + ) _a_bkeyassoc = ( "SELECT a.id AS a_id, anon_1.b_key_id AS b_key_id " @@ -306,7 +315,7 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "a_to_b_key.bid AS a_to_b_key_bid FROM b_key " "JOIN a_to_b_key ON b_key.id = a_to_b_key.bid) AS anon_1 " "ON a.id = anon_1.a_to_b_key_aid" - ) + ) _a_bkeyassoc_aliased = ( "SELECT a.id AS a_id, anon_1.b_key_1_id AS b_key_1_id " @@ -315,46 +324,49 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "a_to_b_key_1.bid AS a_to_b_key_1_bid FROM b_key AS b_key_1 " "JOIN a_to_b_key AS a_to_b_key_1 ON b_key_1.id = a_to_b_key_1.bid) AS " "anon_1 ON a.id = anon_1.a_to_b_key_1_aid" - ) + ) _a_bkeyselect_bkey = ( "SELECT a.id AS a_id, anon_2.anon_1_aid AS anon_1_aid, " "anon_2.anon_1_bid AS anon_1_bid, anon_2.b_key_id AS b_key_id " - "FROM a JOIN (SELECT anon_1.aid AS anon_1_aid, anon_1.bid AS anon_1_bid, " - "b_key.id AS b_key_id " - "FROM (SELECT a_to_b_key.aid AS aid, a_to_b_key.bid AS bid " - "FROM a_to_b_key) AS anon_1 " - "JOIN b_key ON b_key.id = anon_1.bid) AS anon_2 ON a.id = anon_2.anon_1_aid" - ) + "FROM a JOIN (SELECT anon_1.aid AS anon_1_aid, " + "anon_1.bid AS anon_1_bid, " + "b_key.id AS b_key_id " + "FROM (SELECT a_to_b_key.aid AS aid, a_to_b_key.bid AS bid " + "FROM a_to_b_key) AS anon_1 " + "JOIN b_key ON b_key.id = anon_1.bid) AS anon_2 " + "ON a.id = anon_2.anon_1_aid") _a_atobalias_balias_c_w_exists = ( "SELECT a.id AS a_id, " - "anon_1.a_to_b_1_a_id AS a_to_b_1_a_id, anon_1.a_to_b_1_b_id AS a_to_b_1_b_id, " + "anon_1.a_to_b_1_a_id AS a_to_b_1_a_id, " + "anon_1.a_to_b_1_b_id AS a_to_b_1_b_id, " "anon_1.b_1_id AS b_1_id, anon_1.b_1_a_id AS b_1_a_id, " "EXISTS (SELECT * FROM c WHERE c.b_id = anon_1.b_1_id) AS anon_2 " "FROM a LEFT OUTER JOIN (SELECT a_to_b_1.a_id AS a_to_b_1_a_id, " - "a_to_b_1.b_id AS a_to_b_1_b_id, b_1.id AS b_1_id, b_1.a_id AS b_1_a_id " + "a_to_b_1.b_id AS a_to_b_1_b_id, b_1.id AS b_1_id, " + "b_1.a_id AS b_1_a_id " "FROM a_to_b AS a_to_b_1 " "JOIN b AS b_1 ON b_1.id = a_to_b_1.b_id) AS anon_1 " - "ON a.id = anon_1.a_to_b_1_a_id" - ) + "ON a.id = anon_1.a_to_b_1_a_id") _a_atobalias_balias = ( "SELECT a.id AS a_id, anon_1.a_to_b_1_a_id AS a_to_b_1_a_id, " "anon_1.a_to_b_1_b_id AS a_to_b_1_b_id, anon_1.b_1_id AS b_1_id, " "anon_1.b_1_a_id AS b_1_a_id FROM a LEFT OUTER JOIN " - "(SELECT a_to_b_1.a_id AS a_to_b_1_a_id, a_to_b_1.b_id AS a_to_b_1_b_id, " + "(SELECT a_to_b_1.a_id AS a_to_b_1_a_id, " + "a_to_b_1.b_id AS a_to_b_1_b_id, " "b_1.id AS b_1_id, b_1.a_id AS b_1_a_id FROM a_to_b AS a_to_b_1 " - "JOIN b AS b_1 ON b_1.id = a_to_b_1.b_id) AS anon_1 ON a.id = anon_1.a_to_b_1_a_id" - ) + "JOIN b AS b_1 ON b_1.id = a_to_b_1.b_id) AS anon_1 " + "ON a.id = anon_1.a_to_b_1_a_id") _b_ab1_union_c_ab2 = ( "SELECT b_id AS b_id, b_a_id AS b_a_id, a_id AS a_id, b1_id AS b1_id, " "b1_a_id AS b1_a_id FROM " "(SELECT b.id AS b_id, b.a_id AS b_a_id, anon_1.a_id AS a_id, " - "anon_1.b1_id AS b1_id, anon_1.b1_a_id AS b1_a_id " - "FROM b JOIN (SELECT a.id AS a_id, b1.id AS b1_id, b1.a_id AS b1_a_id " - "FROM a JOIN b1 ON a.id = b1.a_id) AS anon_1 ON anon_1.a_id = b.a_id " + "anon_1.b1_id AS b1_id, anon_1.b1_a_id AS b1_a_id " + "FROM b JOIN (SELECT a.id AS a_id, b1.id AS b1_id, b1.a_id AS b1_a_id " + "FROM a JOIN b1 ON a.id = b1.a_id) AS anon_1 ON anon_1.a_id = b.a_id " "UNION " "SELECT b.id AS b_id, b.a_id AS b_a_id, anon_2.a_id AS a_id, " "anon_2.b2_id AS b2_id, anon_2.b2_a_id AS b2_a_id " @@ -377,7 +389,9 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "FROM a JOIN b2 ON a.id = b2.a_id)" ) + class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): + """test rendering of each join with normal nesting.""" @util.classproperty def __dialect__(cls): @@ -387,53 +401,52 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): _a_bkeyselect_bkey = ( "SELECT a.id AS a_id, b_key.id AS b_key_id FROM a JOIN " "((SELECT a_to_b_key.aid AS aid, a_to_b_key.bid AS bid " - "FROM a_to_b_key) AS anon_1 JOIN b_key ON b_key.id = anon_1.bid) " + "FROM a_to_b_key) AS anon_1 JOIN b_key ON b_key.id = anon_1.bid) " "ON a.id = anon_1.aid" ) _a__b_dc = ( - "SELECT a.id AS a_id, b.id AS b_id, " - "b.a_id AS b_a_id, c.id AS c_id, " - "c.b_id AS c_b_id, d.id AS d_id, " - "d.c_id AS d_c_id " - "FROM a JOIN (b JOIN (c JOIN d ON c.id = d.c_id) " - "ON b.id = c.b_id) ON a.id = b.a_id " - "WHERE b.id = :id_1 AND c.id = :id_2 AND " - "d.id = :id_3 " - "ORDER BY a.id, b.id, c.id, d.id" - ) - + "SELECT a.id AS a_id, b.id AS b_id, " + "b.a_id AS b_a_id, c.id AS c_id, " + "c.b_id AS c_b_id, d.id AS d_id, " + "d.c_id AS d_c_id " + "FROM a JOIN (b JOIN (c JOIN d ON c.id = d.c_id) " + "ON b.id = c.b_id) ON a.id = b.a_id " + "WHERE b.id = :id_1 AND c.id = :id_2 AND " + "d.id = :id_3 " + "ORDER BY a.id, b.id, c.id, d.id" + ) _a_bc = ( - "SELECT a.id AS a_id, b.id AS b_id, " - "b.a_id AS b_a_id, c.id AS c_id, " - "c.b_id AS c_b_id FROM a JOIN " - "(b JOIN c ON b.id = c.b_id) " - "ON a.id = b.a_id " - "WHERE b.id = :id_1 AND c.id = :id_2 " - "ORDER BY a.id, b.id, c.id" - ) + "SELECT a.id AS a_id, b.id AS b_id, " + "b.a_id AS b_a_id, c.id AS c_id, " + "c.b_id AS c_b_id FROM a JOIN " + "(b JOIN c ON b.id = c.b_id) " + "ON a.id = b.a_id " + "WHERE b.id = :id_1 AND c.id = :id_2 " + "ORDER BY a.id, b.id, c.id" + ) _a_bc_comma_a1_selbc = ( - "SELECT a.id AS a_id, a_1.id AS a_1_id, b.id AS b_id, " - "b.a_id AS b_a_id, c.id AS c_id, " - "c.b_id AS c_b_id, anon_1.b_id AS anon_1_b_id, " - "anon_1.b_a_id AS anon_1_b_a_id, anon_1.c_id AS anon_1_c_id, " - "anon_1.c_b_id AS anon_1_c_b_id FROM a " - "JOIN (b JOIN c ON b.id = c.b_id) " - "ON a.id = b.a_id, " - "a AS a_1 JOIN " - "(SELECT b.id AS b_id, b.a_id AS b_a_id, " - "c.id AS c_id, c.b_id AS c_b_id " - "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " - "ON a_1.id = anon_1.b_a_id ORDER BY anon_1.b_id" - ) + "SELECT a.id AS a_id, a_1.id AS a_1_id, b.id AS b_id, " + "b.a_id AS b_a_id, c.id AS c_id, " + "c.b_id AS c_b_id, anon_1.b_id AS anon_1_b_id, " + "anon_1.b_a_id AS anon_1_b_a_id, anon_1.c_id AS anon_1_c_id, " + "anon_1.c_b_id AS anon_1_c_b_id FROM a " + "JOIN (b JOIN c ON b.id = c.b_id) " + "ON a.id = b.a_id, " + "a AS a_1 JOIN " + "(SELECT b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, c.b_id AS c_b_id " + "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " + "ON a_1.id = anon_1.b_a_id ORDER BY anon_1.b_id" + ) _a_bkeyassoc = ( "SELECT a.id AS a_id, b_key.id AS b_key_id " "FROM a JOIN " "(b_key JOIN a_to_b_key ON b_key.id = a_to_b_key.bid) " "ON a.id = a_to_b_key.aid" - ) + ) _a_bkeyassoc_aliased = ( "SELECT a.id AS a_id, b_key_1.id AS b_key_1_id FROM a " @@ -443,12 +456,12 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): _a_atobalias_balias_c_w_exists = ( "SELECT a.id AS a_id, a_to_b_1.a_id AS a_to_b_1_a_id, " - "a_to_b_1.b_id AS a_to_b_1_b_id, b_1.id AS b_1_id, b_1.a_id AS b_1_a_id, " + "a_to_b_1.b_id AS a_to_b_1_b_id, b_1.id AS b_1_id, " + "b_1.a_id AS b_1_a_id, " "EXISTS (SELECT * FROM c WHERE c.b_id = b_1.id) AS anon_1 " "FROM a LEFT OUTER JOIN " "(a_to_b AS a_to_b_1 JOIN b AS b_1 ON b_1.id = a_to_b_1.b_id) " - "ON a.id = a_to_b_1.a_id" - ) + "ON a.id = a_to_b_1.a_id") _a_atobalias_balias = ( "SELECT a.id AS a_id, a_to_b_1.a_id AS a_to_b_1_a_id, " @@ -461,14 +474,14 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): _b_ab1_union_c_ab2 = ( "SELECT b_id AS b_id, b_a_id AS b_a_id, a_id AS a_id, b1_id AS b1_id, " "b1_a_id AS b1_a_id FROM " - "(SELECT b.id AS b_id, b.a_id AS b_a_id, a.id AS a_id, b1.id AS b1_id, " + "(SELECT b.id AS b_id, b.a_id AS b_a_id, a.id AS a_id, " + "b1.id AS b1_id, " "b1.a_id AS b1_a_id FROM b " "JOIN (a JOIN b1 ON a.id = b1.a_id) ON a.id = b.a_id " "UNION " "SELECT b.id AS b_id, b.a_id AS b_a_id, a.id AS a_id, b2.id AS b2_id, " "b2.a_id AS b2_a_id FROM b " - "JOIN (a JOIN b2 ON a.id = b2.a_id) ON a.id = b.a_id)" - ) + "JOIN (a JOIN b2 ON a.id = b2.a_id) ON a.id = b.a_id)") _b_a_id_double_overlap_annotated = ( "SELECT anon_1.b_id AS anon_1_b_id, anon_1.b_a_id AS anon_1_b_a_id, " @@ -484,7 +497,9 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): "FROM a JOIN b2 ON a.id = b2.a_id)" ) + class JoinNoUseLabelsTest(_JoinRewriteTestBase, fixtures.TestBase): + @util.classproperty def __dialect__(cls): dialect = default.DefaultDialect() @@ -500,51 +515,51 @@ class JoinNoUseLabelsTest(_JoinRewriteTestBase, fixtures.TestBase): _a_bkeyselect_bkey = ( "SELECT a.id, b_key.id FROM a JOIN ((SELECT a_to_b_key.aid AS aid, " - "a_to_b_key.bid AS bid FROM a_to_b_key) AS anon_1 " - "JOIN b_key ON b_key.id = anon_1.bid) ON a.id = anon_1.aid" + "a_to_b_key.bid AS bid FROM a_to_b_key) AS anon_1 " + "JOIN b_key ON b_key.id = anon_1.bid) ON a.id = anon_1.aid" ) _a__b_dc = ( - "SELECT a.id, b.id, " - "b.a_id, c.id, " - "c.b_id, d.id, " - "d.c_id " - "FROM a JOIN (b JOIN (c JOIN d ON c.id = d.c_id) " - "ON b.id = c.b_id) ON a.id = b.a_id " - "WHERE b.id = :id_1 AND c.id = :id_2 AND " - "d.id = :id_3 " - "ORDER BY a.id, b.id, c.id, d.id" - ) + "SELECT a.id, b.id, " + "b.a_id, c.id, " + "c.b_id, d.id, " + "d.c_id " + "FROM a JOIN (b JOIN (c JOIN d ON c.id = d.c_id) " + "ON b.id = c.b_id) ON a.id = b.a_id " + "WHERE b.id = :id_1 AND c.id = :id_2 AND " + "d.id = :id_3 " + "ORDER BY a.id, b.id, c.id, d.id" + ) _a_bc = ( - "SELECT a.id, b.id, " - "b.a_id, c.id, " - "c.b_id FROM a JOIN " - "(b JOIN c ON b.id = c.b_id) " - "ON a.id = b.a_id " - "WHERE b.id = :id_1 AND c.id = :id_2 " - "ORDER BY a.id, b.id, c.id" - ) + "SELECT a.id, b.id, " + "b.a_id, c.id, " + "c.b_id FROM a JOIN " + "(b JOIN c ON b.id = c.b_id) " + "ON a.id = b.a_id " + "WHERE b.id = :id_1 AND c.id = :id_2 " + "ORDER BY a.id, b.id, c.id" + ) _a_bc_comma_a1_selbc = ( - "SELECT a.id, a_1.id, b.id, " - "b.a_id, c.id, " - "c.b_id, anon_1.b_id, " - "anon_1.b_a_id, anon_1.c_id, " - "anon_1.c_b_id FROM a " - "JOIN (b JOIN c ON b.id = c.b_id) " - "ON a.id = b.a_id, " - "a AS a_1 JOIN " - "(SELECT b.id AS b_id, b.a_id AS b_a_id, " - "c.id AS c_id, c.b_id AS c_b_id " - "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " - "ON a_1.id = anon_1.b_a_id ORDER BY anon_1.b_id" - ) + "SELECT a.id, a_1.id, b.id, " + "b.a_id, c.id, " + "c.b_id, anon_1.b_id, " + "anon_1.b_a_id, anon_1.c_id, " + "anon_1.c_b_id FROM a " + "JOIN (b JOIN c ON b.id = c.b_id) " + "ON a.id = b.a_id, " + "a AS a_1 JOIN " + "(SELECT b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, c.b_id AS c_b_id " + "FROM b JOIN c ON b.id = c.b_id) AS anon_1 " + "ON a_1.id = anon_1.b_a_id ORDER BY anon_1.b_id" + ) _a_bkeyassoc = ( "SELECT a.id, b_key.id FROM a JOIN (b_key JOIN a_to_b_key " "ON b_key.id = a_to_b_key.bid) ON a.id = a_to_b_key.aid" - ) + ) _a_bkeyassoc_aliased = ( "SELECT a.id, b_key_1.id FROM a JOIN (b_key AS b_key_1 " @@ -590,7 +605,9 @@ class JoinNoUseLabelsTest(_JoinRewriteTestBase, fixtures.TestBase): "FROM a JOIN b2 ON a.id = b2.a_id)" ) + class JoinExecTest(_JoinRewriteTestBase, fixtures.TestBase): + """invoke the SQL on the current backend to ensure compatibility""" __backend__ = True @@ -617,13 +634,17 @@ class JoinExecTest(_JoinRewriteTestBase, fixtures.TestBase): def test_a_atobalias_balias_c_w_exists(self): super(JoinExecTest, self).test_a_atobalias_balias_c_w_exists() - @testing.only_on("sqlite", "non-standard aliasing rules used at the moment, " - "possibly fix this or add another test that uses " - "cross-compatible aliasing") + @testing.only_on( + "sqlite", + "non-standard aliasing rules used at the moment, " + "possibly fix this or add another test that uses " + "cross-compatible aliasing") def test_b_ab1_union_b_ab2(self): super(JoinExecTest, self).test_b_ab1_union_b_ab2() + class DialectFlagTest(fixtures.TestBase, AssertsCompiledSQL): + def test_dialect_flag(self): d1 = default.DefaultDialect(supports_right_nested_joins=True) d2 = default.DefaultDialect(supports_right_nested_joins=False) @@ -636,18 +657,16 @@ class DialectFlagTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( s, - "SELECT a.id AS a_id, b.id AS b_id, b.a_id AS b_a_id, c.id AS c_id, " + "SELECT a.id AS a_id, b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, " "c.b_id AS c_b_id FROM a JOIN (b JOIN c ON b.id = c.b_id) " "ON a.id = b.a_id", - dialect=d1 - ) + dialect=d1) self.assert_compile( - s, - "SELECT a.id AS a_id, anon_1.b_id AS b_id, " + s, "SELECT a.id AS a_id, anon_1.b_id AS b_id, " "anon_1.b_a_id AS b_a_id, " "anon_1.c_id AS c_id, anon_1.c_b_id AS c_b_id " - "FROM a JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, c.id AS c_id, " + "FROM a JOIN (SELECT b.id AS b_id, b.a_id AS b_a_id, " + "c.id AS c_id, " "c.b_id AS c_b_id FROM b JOIN c ON b.id = c.b_id) AS anon_1 " - "ON a.id = anon_1.b_a_id", - dialect=d2 - ) + "ON a.id = anon_1.b_a_id", dialect=d2) diff --git a/test/sql/test_labels.py b/test/sql/test_labels.py index fd45d303f..451757b99 100644 --- a/test/sql/test_labels.py +++ b/test/sql/test_labels.py @@ -12,14 +12,14 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'DefaultDialect' table1 = table('some_large_named_table', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + column('this_is_the_primarykey_column'), + column('this_is_the_data_column') + ) table2 = table('table_with_exactly_29_characs', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + column('this_is_the_primarykey_column'), + column('this_is_the_data_column') + ) def _length_fixture(self, length=IDENT_LENGTH, positional=False): dialect = default.DefaultDialect() @@ -38,11 +38,11 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( self.table2.alias().select(), 'SELECT ' - 'table_with_exactly_29_c_1.' - 'this_is_the_primarykey_column, ' - 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'table_with_exactly_29_c_1.' + 'this_is_the_primarykey_column, ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' 'FROM ' - 'table_with_exactly_29_characs ' + 'table_with_exactly_29_characs ' 'AS table_with_exactly_29_c_1', dialect=self._length_fixture() ) @@ -54,31 +54,31 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): on = table1.c.this_is_the_data_column == ta.c.this_is_the_data_column self.assert_compile( select([table1, ta]).select_from(table1.join(ta, on)). - where(ta.c.this_is_the_data_column == 'data3'), + where(ta.c.this_is_the_data_column == 'data3'), 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column, ' - 'some_large_named_table.this_is_the_data_column, ' - 'table_with_exactly_29_c_1.this_is_the_primarykey_column, ' - 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'some_large_named_table.this_is_the_primarykey_column, ' + 'some_large_named_table.this_is_the_data_column, ' + 'table_with_exactly_29_c_1.this_is_the_primarykey_column, ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' 'FROM ' - 'some_large_named_table ' + 'some_large_named_table ' 'JOIN ' - 'table_with_exactly_29_characs ' + 'table_with_exactly_29_characs ' 'AS ' - 'table_with_exactly_29_c_1 ' + 'table_with_exactly_29_c_1 ' 'ON ' - 'some_large_named_table.this_is_the_data_column = ' - 'table_with_exactly_29_c_1.this_is_the_data_column ' + 'some_large_named_table.this_is_the_data_column = ' + 'table_with_exactly_29_c_1.this_is_the_data_column ' 'WHERE ' - 'table_with_exactly_29_c_1.this_is_the_data_column = ' - ':this_is_the_data_column_1', + 'table_with_exactly_29_c_1.this_is_the_data_column = ' + ':this_is_the_data_column_1', dialect=self._length_fixture() ) def test_too_long_name_disallowed(self): m = MetaData() t = Table('this_name_is_too_long_for_what_were_doing_in_this_test', - m, Column('foo', Integer)) + m, Column('foo', Integer)) eng = self._engine_fixture() methods = (t.create, t.drop, m.create_all, m.drop_all) for meth in methods: @@ -89,27 +89,27 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): compiled = s.compile(dialect=self._length_fixture()) assert set(compiled.result_map['some_large_named_table__2'][1]).\ - issuperset( - [ - 'some_large_named_table_this_is_the_data_column', - 'some_large_named_table__2', - table1.c.this_is_the_data_column - ] - ) + issuperset( + [ + 'some_large_named_table_this_is_the_data_column', + 'some_large_named_table__2', + table1.c.this_is_the_data_column + ] + ) assert set(compiled.result_map['some_large_named_table__1'][1]).\ - issuperset( - [ - 'some_large_named_table_this_is_the_primarykey_column', - 'some_large_named_table__1', - table1.c.this_is_the_primarykey_column - ] - ) + issuperset( + [ + 'some_large_named_table_this_is_the_primarykey_column', + 'some_large_named_table__1', + table1.c.this_is_the_primarykey_column + ] + ) def test_result_map_use_labels(self): table1 = self.table1 s = table1.select().apply_labels().\ - order_by(table1.c.this_is_the_primarykey_column) + order_by(table1.c.this_is_the_primarykey_column) self._assert_labeled_table1_select(s) @@ -120,25 +120,25 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): # generated result map corresponds to the selected table, not the # select query s = table1.select(use_labels=True, - order_by=[table1.c.this_is_the_primarykey_column]).\ - limit(2) + order_by=[table1.c.this_is_the_primarykey_column]).\ + limit(2) self._assert_labeled_table1_select(s) def test_result_map_subquery(self): table1 = self.table1 s = table1.select( - table1.c.this_is_the_primarykey_column == 4).\ - alias('foo') + table1.c.this_is_the_primarykey_column == 4).\ + alias('foo') s2 = select([s]) compiled = s2.compile(dialect=self._length_fixture()) assert \ set(compiled.result_map['this_is_the_data_column'][1]).\ issuperset(['this_is_the_data_column', - s.c.this_is_the_data_column]) + s.c.this_is_the_data_column]) assert \ set(compiled.result_map['this_is_the_primarykey_column'][1]).\ issuperset(['this_is_the_primarykey_column', - s.c.this_is_the_primarykey_column]) + s.c.this_is_the_primarykey_column]) def test_result_map_anon_alias(self): table1 = self.table1 @@ -147,41 +147,40 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias() s = select([q]).apply_labels() - self.assert_compile(s, - 'SELECT ' - 'anon_1.this_is_the_primarykey_column ' - 'AS anon_1_this_is_the_prim_1, ' - 'anon_1.this_is_the_data_column ' - 'AS anon_1_this_is_the_data_2 ' + self.assert_compile( + s, 'SELECT ' + 'anon_1.this_is_the_primarykey_column ' + 'AS anon_1_this_is_the_prim_1, ' + 'anon_1.this_is_the_data_column ' + 'AS anon_1_this_is_the_data_2 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.' - 'this_is_the_primarykey_column ' - 'AS this_is_the_primarykey_column, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS this_is_the_data_column ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :this_is_the_primarykey__1' - ') ' - 'AS anon_1', - dialect=dialect) + 'SELECT ' + 'some_large_named_table.' + 'this_is_the_primarykey_column ' + 'AS this_is_the_primarykey_column, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_is_the_data_column ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_is_the_primarykey__1' + ') ' + 'AS anon_1', dialect=dialect) compiled = s.compile(dialect=dialect) assert set(compiled.result_map['anon_1_this_is_the_data_2'][1]).\ - issuperset([ - 'anon_1_this_is_the_data_2', - q.corresponding_column( - table1.c.this_is_the_data_column) - ]) + issuperset([ + 'anon_1_this_is_the_data_2', + q.corresponding_column( + table1.c.this_is_the_data_column) + ]) assert set(compiled.result_map['anon_1_this_is_the_prim_1'][1]).\ - issuperset([ - 'anon_1_this_is_the_prim_1', - q.corresponding_column( - table1.c.this_is_the_primarykey_column) - ]) + issuperset([ + 'anon_1_this_is_the_prim_1', + q.corresponding_column( + table1.c.this_is_the_primarykey_column) + ]) def test_column_bind_labels_1(self): table1 = self.table1 @@ -254,14 +253,14 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'DefaultDialect' table1 = table('some_large_named_table', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + column('this_is_the_primarykey_column'), + column('this_is_the_data_column') + ) table2 = table('table_with_exactly_29_characs', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + column('this_is_the_primarykey_column'), + column('this_is_the_data_column') + ) def test_adjustable_1(self): table1 = self.table1 @@ -269,23 +268,22 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): table1.c.this_is_the_primarykey_column == 4).alias('foo') x = select([q]) compile_dialect = default.DefaultDialect(label_length=10) - self.assert_compile(x, - 'SELECT ' - 'foo.this_1, foo.this_2 ' + self.assert_compile( + x, 'SELECT ' + 'foo.this_1, foo.this_2 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column ' - 'AS this_1, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS this_2 ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :this_1' - ') ' - 'AS foo', - dialect=compile_dialect) + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS this_1, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_2 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_1' + ') ' + 'AS foo', dialect=compile_dialect) def test_adjustable_2(self): table1 = self.table1 @@ -295,23 +293,22 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): x = select([q]) compile_dialect = default.DefaultDialect(label_length=10) - self.assert_compile(x, - 'SELECT ' - 'foo.this_1, foo.this_2 ' + self.assert_compile( + x, 'SELECT ' + 'foo.this_1, foo.this_2 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column ' - 'AS this_1, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS this_2 ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :this_1' - ') ' - 'AS foo', - dialect=compile_dialect) + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS this_1, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_2 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_1' + ') ' + 'AS foo', dialect=compile_dialect) def test_adjustable_3(self): table1 = self.table1 @@ -321,23 +318,22 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): table1.c.this_is_the_primarykey_column == 4).alias('foo') x = select([q]) - self.assert_compile(x, - 'SELECT ' - 'foo._1, foo._2 ' + self.assert_compile( + x, 'SELECT ' + 'foo._1, foo._2 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column ' - 'AS _1, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS _2 ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :_1' - ') ' - 'AS foo', - dialect=compile_dialect) + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS _1, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS _2 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :_1' + ') ' + 'AS foo', dialect=compile_dialect) def test_adjustable_4(self): table1 = self.table1 @@ -346,24 +342,23 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): x = select([q], use_labels=True) compile_dialect = default.DefaultDialect(label_length=10) - self.assert_compile(x, - 'SELECT ' - 'anon_1.this_2 AS anon_1, ' - 'anon_1.this_4 AS anon_3 ' + self.assert_compile( + x, 'SELECT ' + 'anon_1.this_2 AS anon_1, ' + 'anon_1.this_4 AS anon_3 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column ' - 'AS this_2, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS this_4 ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :this_1' - ') ' - 'AS anon_1', - dialect=compile_dialect) + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS this_2, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS this_4 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :this_1' + ') ' + 'AS anon_1', dialect=compile_dialect) def test_adjustable_5(self): table1 = self.table1 @@ -371,31 +366,30 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): x = select([q], use_labels=True) compile_dialect = default.DefaultDialect(label_length=4) - self.assert_compile(x, - 'SELECT ' - '_1._2 AS _1, ' - '_1._4 AS _3 ' + self.assert_compile( + x, 'SELECT ' + '_1._2 AS _1, ' + '_1._4 AS _3 ' 'FROM (' - 'SELECT ' - 'some_large_named_table.this_is_the_primarykey_column ' - 'AS _2, ' - 'some_large_named_table.this_is_the_data_column ' - 'AS _4 ' - 'FROM ' - 'some_large_named_table ' - 'WHERE ' - 'some_large_named_table.this_is_the_primarykey_column ' - '= :_1' - ') ' - 'AS _1', - dialect=compile_dialect) + 'SELECT ' + 'some_large_named_table.this_is_the_primarykey_column ' + 'AS _2, ' + 'some_large_named_table.this_is_the_data_column ' + 'AS _4 ' + 'FROM ' + 'some_large_named_table ' + 'WHERE ' + 'some_large_named_table.this_is_the_primarykey_column ' + '= :_1' + ') ' + 'AS _1', dialect=compile_dialect) def test_adjustable_result_schema_column_1(self): table1 = self.table1 q = table1.select( table1.c.this_is_the_primarykey_column == 4).apply_labels().\ - alias('foo') + alias('foo') dialect = default.DefaultDialect(label_length=10) compiled = q.compile(dialect=dialect) @@ -452,25 +446,26 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): anon = a_table.alias() - j1 = other_table.outerjoin(anon, - anon.c.id == other_table.c.thirty_characters_table_id) + j1 = other_table.outerjoin( + anon, + anon.c.id == other_table.c.thirty_characters_table_id) self.assert_compile( select([other_table, anon]). - select_from(j1).apply_labels(), + select_from(j1).apply_labels(), 'SELECT ' - 'other_thirty_characters_table_.id ' - 'AS other_thirty_characters__1, ' - 'other_thirty_characters_table_.thirty_characters_table_id ' - 'AS other_thirty_characters__2, ' - 'thirty_characters_table__1.id ' - 'AS thirty_characters_table__3 ' + 'other_thirty_characters_table_.id ' + 'AS other_thirty_characters__1, ' + 'other_thirty_characters_table_.thirty_characters_table_id ' + 'AS other_thirty_characters__2, ' + 'thirty_characters_table__1.id ' + 'AS thirty_characters_table__3 ' 'FROM ' - 'other_thirty_characters_table_ ' + 'other_thirty_characters_table_ ' 'LEFT OUTER JOIN ' - 'thirty_characters_table_xxxxxx AS thirty_characters_table__1 ' + 'thirty_characters_table_xxxxxx AS thirty_characters_table__1 ' 'ON thirty_characters_table__1.id = ' - 'other_thirty_characters_table_.thirty_characters_table_id', + 'other_thirty_characters_table_.thirty_characters_table_id', dialect=compile_dialect) def test_colnames_longer_than_labels_lowercase(self): @@ -490,8 +485,8 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): # needs to have all characters s = select([a1]) self.assert_compile(select([a1]), - 'SELECT asdf.abcde FROM a AS asdf', - dialect=dialect) + 'SELECT asdf.abcde FROM a AS asdf', + dialect=dialect) compiled = s.compile(dialect=dialect) assert set(compiled.result_map['abcde'][1]).issuperset([ 'abcde', a1.c.abcde, 'abcde']) @@ -499,8 +494,8 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): # column still there, but short label s = select([a1]).apply_labels() self.assert_compile(s, - 'SELECT asdf.abcde AS _1 FROM a AS asdf', - dialect=dialect) + 'SELECT asdf.abcde AS _1 FROM a AS asdf', + dialect=dialect) compiled = s.compile(dialect=dialect) assert set(compiled.result_map['_1'][1]).issuperset([ 'asdf_abcde', a1.c.abcde, '_1']) diff --git a/test/sql/test_metadata.py b/test/sql/test_metadata.py index 8bd419964..3a252c646 100644 --- a/test/sql/test_metadata.py +++ b/test/sql/test_metadata.py @@ -17,12 +17,14 @@ from sqlalchemy.testing import ComparesTables, AssertsCompiledSQL from sqlalchemy.testing import eq_, is_, mock from contextlib import contextmanager + class MetaDataTest(fixtures.TestBase, ComparesTables): + def test_metadata_connect(self): metadata = MetaData() t1 = Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20))) + Column('col1', Integer, primary_key=True), + Column('col2', String(20))) metadata.bind = testing.db metadata.create_all() try: @@ -52,16 +54,16 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): Column('baz', String(), unique=True), Column(Integer(), primary_key=True), Column('bar', Integer(), Sequence('foo_seq'), primary_key=True, - key='bar'), + key='bar'), Column(Integer(), ForeignKey('bat.blah'), doc="this is a col"), Column('bar', Integer(), ForeignKey('bat.blah'), primary_key=True, - key='bar'), + key='bar'), Column('bar', Integer(), info={'foo': 'bar'}), ]: c2 = col.copy() for attr in ('name', 'type', 'nullable', - 'primary_key', 'key', 'unique', 'info', - 'doc'): + 'primary_key', 'key', 'unique', 'info', + 'doc'): eq_(getattr(col, attr), getattr(c2, attr)) eq_(len(col.foreign_keys), len(c2.foreign_keys)) if col.default: @@ -72,6 +74,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_col_subclass_copy(self): class MyColumn(schema.Column): + def __init__(self, *args, **kw): self.widget = kw.pop('widget', None) super(MyColumn, self).__init__(*args, **kw) @@ -87,6 +90,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_uninitialized_column_copy_events(self): msgs = [] + def write(c, t): msgs.append("attach %s.%s" % (t.name, c.name)) c1 = Column('foo', String()) @@ -150,21 +154,22 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_dupe_tables(self): metadata = self.metadata Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20))) + Column('col1', Integer, primary_key=True), + Column('col2', String(20))) metadata.create_all() Table('table1', metadata, autoload=True) + def go(): Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20))) + Column('col1', Integer, primary_key=True), + Column('col2', String(20))) assert_raises_message( tsa.exc.InvalidRequestError, - "Table 'table1' is already defined for this " - "MetaData instance. Specify 'extend_existing=True' " - "to redefine options and columns on an existing " - "Table object.", + "Table 'table1' is already defined for this " + "MetaData instance. Specify 'extend_existing=True' " + "to redefine options and columns on an existing " + "Table object.", go ) @@ -175,8 +180,8 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): t1 = Table('t', m, c1, c2) kw = dict(onupdate="X", - ondelete="Y", use_alter=True, name='f1', - deferrable="Z", initially="Q", link_to_name=True) + ondelete="Y", use_alter=True, name='f1', + deferrable="Z", initially="Q", link_to_name=True) fk1 = ForeignKey(c1, **kw) fk2 = ForeignKeyConstraint((c1,), (c2,), **kw) @@ -248,6 +253,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_fk_given_non_col_clauseelem(self): class Foo(object): + def __clause_element__(self): return bindparam('x') assert_raises_message( @@ -267,7 +273,9 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_fk_given_col_non_table_clauseelem(self): t = Table('t', MetaData(), Column('x', Integer)) + class Foo(object): + def __clause_element__(self): return t.alias().c.x @@ -306,50 +314,46 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): getattr, list(a.foreign_keys)[0], "column" ) - - def test_pickle_metadata_sequence_restated(self): m1 = MetaData() Table('a', m1, - Column('id', Integer, primary_key=True), - Column('x', Integer, Sequence("x_seq"))) + Column('id', Integer, primary_key=True), + Column('x', Integer, Sequence("x_seq"))) m2 = pickle.loads(pickle.dumps(m1)) s2 = Sequence("x_seq") t2 = Table('a', m2, - Column('id', Integer, primary_key=True), - Column('x', Integer, s2), - extend_existing=True) + Column('id', Integer, primary_key=True), + Column('x', Integer, s2), + extend_existing=True) assert m2._sequences['x_seq'] is t2.c.x.default assert m2._sequences['x_seq'] is s2 - def test_sequence_restated_replaced(self): """Test restatement of Sequence replaces.""" m1 = MetaData() s1 = Sequence("x_seq") t = Table('a', m1, - Column('x', Integer, s1) - ) + Column('x', Integer, s1) + ) assert m1._sequences['x_seq'] is s1 s2 = Sequence('x_seq') Table('a', m1, - Column('x', Integer, s2), - extend_existing=True - ) + Column('x', Integer, s2), + extend_existing=True + ) assert t.c.x.default is s2 assert m1._sequences['x_seq'] is s2 - def test_pickle_metadata_sequence_implicit(self): m1 = MetaData() Table('a', m1, - Column('id', Integer, primary_key=True), - Column('x', Integer, Sequence("x_seq"))) + Column('id', Integer, primary_key=True), + Column('x', Integer, Sequence("x_seq"))) m2 = pickle.loads(pickle.dumps(m1)) @@ -360,14 +364,14 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_pickle_metadata_schema(self): m1 = MetaData() Table('a', m1, - Column('id', Integer, primary_key=True), - Column('x', Integer, Sequence("x_seq")), - schema='y') + Column('id', Integer, primary_key=True), + Column('x', Integer, Sequence("x_seq")), + schema='y') m2 = pickle.loads(pickle.dumps(m1)) Table('a', m2, schema='y', - extend_existing=True) + extend_existing=True) eq_(m2._schemas, m1._schemas) @@ -378,24 +382,24 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): m4 = MetaData() for i, (name, metadata, schema, quote_schema, - exp_schema, exp_quote_schema) in enumerate([ - ('t1', m1, None, None, 'sch1', None), - ('t2', m1, 'sch2', None, 'sch2', None), - ('t3', m1, 'sch2', True, 'sch2', True), - ('t4', m1, 'sch1', None, 'sch1', None), - ('t1', m2, None, None, 'sch1', True), - ('t2', m2, 'sch2', None, 'sch2', None), - ('t3', m2, 'sch2', True, 'sch2', True), - ('t4', m2, 'sch1', None, 'sch1', None), - ('t1', m3, None, None, 'sch1', False), - ('t2', m3, 'sch2', None, 'sch2', None), - ('t3', m3, 'sch2', True, 'sch2', True), - ('t4', m3, 'sch1', None, 'sch1', None), - ('t1', m4, None, None, None, None), - ('t2', m4, 'sch2', None, 'sch2', None), - ('t3', m4, 'sch2', True, 'sch2', True), - ('t4', m4, 'sch1', None, 'sch1', None), - ]): + exp_schema, exp_quote_schema) in enumerate([ + ('t1', m1, None, None, 'sch1', None), + ('t2', m1, 'sch2', None, 'sch2', None), + ('t3', m1, 'sch2', True, 'sch2', True), + ('t4', m1, 'sch1', None, 'sch1', None), + ('t1', m2, None, None, 'sch1', True), + ('t2', m2, 'sch2', None, 'sch2', None), + ('t3', m2, 'sch2', True, 'sch2', True), + ('t4', m2, 'sch1', None, 'sch1', None), + ('t1', m3, None, None, 'sch1', False), + ('t2', m3, 'sch2', None, 'sch2', None), + ('t3', m3, 'sch2', True, 'sch2', True), + ('t4', m3, 'sch1', None, 'sch1', None), + ('t1', m4, None, None, None, None), + ('t2', m4, 'sch2', None, 'sch2', None), + ('t3', m4, 'sch2', True, 'sch2', True), + ('t4', m4, 'sch1', None, 'sch1', None), + ]): kw = {} if schema is not None: kw['schema'] = schema @@ -404,13 +408,13 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): t = Table(name, metadata, **kw) eq_(t.schema, exp_schema, "test %d, table schema" % i) eq_(t.schema.quote if t.schema is not None else None, - exp_quote_schema, - "test %d, table quote_schema" % i) + exp_quote_schema, + "test %d, table quote_schema" % i) seq = Sequence(name, metadata=metadata, **kw) eq_(seq.schema, exp_schema, "test %d, seq schema" % i) eq_(seq.schema.quote if seq.schema is not None else None, - exp_quote_schema, - "test %d, seq quote_schema" % i) + exp_quote_schema, + "test %d, seq quote_schema" % i) def test_manual_dependencies(self): meta = MetaData() @@ -432,8 +436,8 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_nonexistent(self): assert_raises(tsa.exc.NoSuchTableError, Table, - 'fake_table', - MetaData(testing.db), autoload=True) + 'fake_table', + MetaData(testing.db), autoload=True) def test_assorted_repr(self): t1 = Table("foo", MetaData(), Column("x", Integer)) @@ -456,9 +460,9 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): (i1, "Index('bar', Column('x', Integer(), table=<foo>))"), (schema.FetchedValue(), "FetchedValue()"), (ck, - "CheckConstraint(" - "%s" - ", name='someconstraint')" % repr(ck.sqltext)), + "CheckConstraint(" + "%s" + ", name='someconstraint')" % repr(ck.sqltext)), ): eq_( repr(const), @@ -472,26 +476,51 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): from sqlalchemy.testing.schema import Table meta = MetaData() - table = Table('mytable', meta, - Column('myid', Integer, Sequence('foo_id_seq'), primary_key=True), - Column('name', String(40), nullable=True), - Column('foo', String(40), nullable=False, server_default='x', - server_onupdate='q'), - Column('bar', String(40), nullable=False, default='y', - onupdate='z'), - Column('description', String(30), - CheckConstraint("description='hi'")), + table = Table( + 'mytable', + meta, + Column( + 'myid', + Integer, + Sequence('foo_id_seq'), + primary_key=True), + Column( + 'name', + String(40), + nullable=True), + Column( + 'foo', + String(40), + nullable=False, + server_default='x', + server_onupdate='q'), + Column( + 'bar', + String(40), + nullable=False, + default='y', + onupdate='z'), + Column( + 'description', + String(30), + CheckConstraint("description='hi'")), UniqueConstraint('name'), - test_needs_fk=True - ) - - table2 = Table('othertable', meta, - Column('id', Integer, Sequence('foo_seq'), primary_key=True), - Column('myid', Integer, - ForeignKey('mytable.myid'), - ), - test_needs_fk=True - ) + test_needs_fk=True) + + table2 = Table( + 'othertable', + meta, + Column( + 'id', + Integer, + Sequence('foo_seq'), + primary_key=True), + Column( + 'myid', + Integer, + ForeignKey('mytable.myid'), + ), + test_needs_fk=True) def test_to_metadata(): meta2 = MetaData() @@ -560,7 +589,6 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): assert c.columns.contains_column(table_c.c.name) assert not c.columns.contains_column(table.c.name) - finally: meta.drop_all(testing.db) @@ -576,29 +604,28 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): a2 = a.tometadata(m2) assert b2.c.y.references(a2.c.x) - def test_change_schema(self): meta = MetaData() table = Table('mytable', meta, - Column('myid', Integer, primary_key=True), - Column('name', String(40), nullable=True), - Column('description', String(30), - CheckConstraint("description='hi'")), - UniqueConstraint('name'), - ) + Column('myid', Integer, primary_key=True), + Column('name', String(40), nullable=True), + Column('description', String(30), + CheckConstraint("description='hi'")), + UniqueConstraint('name'), + ) table2 = Table('othertable', meta, - Column('id', Integer, primary_key=True), - Column('myid', Integer, ForeignKey('mytable.myid')), - ) + Column('id', Integer, primary_key=True), + Column('myid', Integer, ForeignKey('mytable.myid')), + ) meta2 = MetaData() table_c = table.tometadata(meta2, schema='someschema') table2_c = table2.tometadata(meta2, schema='someschema') eq_(str(table_c.join(table2_c).onclause), str(table_c.c.myid - == table2_c.c.myid)) + == table2_c.c.myid)) eq_(str(table_c.join(table2_c).onclause), 'someschema.mytable.myid = someschema.othertable.myid') @@ -606,26 +633,34 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): meta = MetaData() table = Table('mytable', meta, - Column('myid', Integer, primary_key=True), - Column('name', String(40), nullable=True), - Column('description', String(30), - CheckConstraint("description='hi'")), - UniqueConstraint('name'), + Column('myid', Integer, primary_key=True), + Column('name', String(40), nullable=True), + Column('description', String(30), + CheckConstraint("description='hi'")), + UniqueConstraint('name'), + schema='myschema', + ) + + table2 = Table( + 'othertable', + meta, + Column( + 'id', + Integer, + primary_key=True), + Column( + 'myid', + Integer, + ForeignKey('myschema.mytable.myid')), schema='myschema', ) - table2 = Table('othertable', meta, - Column('id', Integer, primary_key=True), - Column('myid', Integer, ForeignKey('myschema.mytable.myid')), - schema='myschema', - ) - meta2 = MetaData() table_c = table.tometadata(meta2) table2_c = table2.tometadata(meta2) eq_(str(table_c.join(table2_c).onclause), str(table_c.c.myid - == table2_c.c.myid)) + == table2_c.c.myid)) eq_(str(table_c.join(table2_c).onclause), 'myschema.mytable.myid = myschema.othertable.myid') @@ -634,7 +669,7 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): existing_schema = t2.schema if schema: t2c = t2.tometadata(m2, schema=schema, - referred_schema_fn=referred_schema_fn) + referred_schema_fn=referred_schema_fn) eq_(t2c.schema, schema) else: t2c = t2.tometadata(m2, referred_schema_fn=referred_schema_fn) @@ -679,7 +714,7 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): m = MetaData() t2 = Table('t2', m, Column('y', Integer, - ForeignKey('q.t1.x')), schema="q") + ForeignKey('q.t1.x')), schema="q") self._assert_fk(t2, None, "q.t1.x") @@ -690,7 +725,7 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): m = MetaData() t2 = Table('t2', m, Column('y', Integer, - ForeignKey('q.t1.x')), schema="q") + ForeignKey('q.t1.x')), schema="q") self._assert_fk(t2, "z", "z.t1.x") @@ -702,23 +737,22 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): t1 = Table('t1', m, Column('x', Integer), schema='q') t2 = Table('t2', m, Column('y', Integer, - ForeignKey(t1.c.x)), schema='q') + ForeignKey(t1.c.x)), schema='q') self._assert_fk(t2, None, "q.t1.x") - def test_fk_and_referent_has_same_schema_col_new_schema(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer), schema='q') t2 = Table('t2', m, Column('y', Integer, - ForeignKey(t1.c.x)), schema='q') + ForeignKey(t1.c.x)), schema='q') self._assert_fk(t2, 'z', "z.t1.x") def test_fk_and_referent_has_diff_schema_string_retain_schema(self): m = MetaData() t2 = Table('t2', m, Column('y', Integer, - ForeignKey('p.t1.x')), schema="q") + ForeignKey('p.t1.x')), schema="q") self._assert_fk(t2, None, "p.t1.x") @@ -729,7 +763,7 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): m = MetaData() t2 = Table('t2', m, Column('y', Integer, - ForeignKey('p.t1.x')), schema="q") + ForeignKey('p.t1.x')), schema="q") self._assert_fk(t2, "z", "p.t1.x") @@ -741,22 +775,21 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): t1 = Table('t1', m, Column('x', Integer), schema='p') t2 = Table('t2', m, Column('y', Integer, - ForeignKey(t1.c.x)), schema='q') + ForeignKey(t1.c.x)), schema='q') self._assert_fk(t2, None, "p.t1.x") - def test_fk_and_referent_has_diff_schema_col_new_schema(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer), schema='p') t2 = Table('t2', m, Column('y', Integer, - ForeignKey(t1.c.x)), schema='q') + ForeignKey(t1.c.x)), schema='q') self._assert_fk(t2, 'z', "p.t1.x") def test_fk_custom_system(self): m = MetaData() t2 = Table('t2', m, Column('y', Integer, - ForeignKey('p.t1.x')), schema='q') + ForeignKey('p.t1.x')), schema='q') def ref_fn(table, to_schema, constraint, referred_schema): assert table is t2 @@ -765,7 +798,6 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): return "h" self._assert_fk(t2, 'z', "h.t1.x", referred_schema_fn=ref_fn) - def test_copy_info(self): m = MetaData() fk = ForeignKey('t2.id') @@ -780,7 +812,7 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): t.info['tinfo'] = True t.primary_key.info['pkinfo'] = True fkc = [const for const in t.constraints if - isinstance(const, ForeignKeyConstraint)][0] + isinstance(const, ForeignKeyConstraint)][0] fkc.info['fkcinfo'] = True m2 = MetaData() @@ -800,21 +832,20 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): eq_(t2.primary_key.info, {"pkinfo": True}) fkc2 = [const for const in t2.constraints - if isinstance(const, ForeignKeyConstraint)][0] + if isinstance(const, ForeignKeyConstraint)][0] eq_(fkc2.info, {"fkcinfo": True}) ck2 = [const for const in - t2.constraints if isinstance(const, CheckConstraint)][0] + t2.constraints if isinstance(const, CheckConstraint)][0] eq_(ck2.info, {"ckinfo": True}) - def test_dialect_kwargs(self): meta = MetaData() table = Table('mytable', meta, - Column('myid', Integer, primary_key=True), - mysql_engine='InnoDB', - ) + Column('myid', Integer, primary_key=True), + mysql_engine='InnoDB', + ) meta2 = MetaData() table_c = table.tometadata(meta2) @@ -827,10 +858,10 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): meta = MetaData() table = Table('mytable', meta, - Column('id', Integer, primary_key=True), - Column('data1', Integer, index=True), - Column('data2', Integer), - ) + Column('id', Integer, primary_key=True), + Column('data1', Integer, index=True), + Column('data2', Integer), + ) Index('multi', table.c.data1, table.c.data2), meta2 = MetaData() @@ -838,8 +869,8 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def _get_key(i): return [i.name, i.unique] + \ - sorted(i.kwargs.items()) + \ - list(i.columns.keys()) + sorted(i.kwargs.items()) + \ + list(i.columns.keys()) eq_( sorted([_get_key(i) for i in table.indexes]), @@ -851,12 +882,12 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): meta1 = MetaData() table1 = Table('mytable', meta1, - Column('myid', Integer, primary_key=True), - ) + Column('myid', Integer, primary_key=True), + ) meta2 = MetaData() table2 = Table('mytable', meta2, - Column('yourid', Integer, primary_key=True), - ) + Column('yourid', Integer, primary_key=True), + ) table_c = table1.tometadata(meta2) table_d = table2.tometadata(meta2) @@ -867,59 +898,72 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def test_default_schema_metadata(self): meta = MetaData(schema='myschema') - table = Table('mytable', meta, - Column('myid', Integer, primary_key=True), - Column('name', String(40), nullable=True), - Column('description', String(30), CheckConstraint("description='hi'")), + table = Table( + 'mytable', + meta, + Column( + 'myid', + Integer, + primary_key=True), + Column( + 'name', + String(40), + nullable=True), + Column( + 'description', + String(30), + CheckConstraint("description='hi'")), UniqueConstraint('name'), ) - table2 = Table('othertable', meta, - Column('id', Integer, primary_key=True), - Column('myid', Integer, ForeignKey('myschema.mytable.myid')), - ) + table2 = Table( + 'othertable', meta, Column( + 'id', Integer, primary_key=True), Column( + 'myid', Integer, ForeignKey('myschema.mytable.myid')), ) meta2 = MetaData(schema='someschema') table_c = table.tometadata(meta2, schema=None) table2_c = table2.tometadata(meta2, schema=None) eq_(str(table_c.join(table2_c).onclause), - str(table_c.c.myid == table2_c.c.myid)) + str(table_c.c.myid == table2_c.c.myid)) eq_(str(table_c.join(table2_c).onclause), - "someschema.mytable.myid = someschema.othertable.myid") + "someschema.mytable.myid = someschema.othertable.myid") def test_strip_schema(self): meta = MetaData() table = Table('mytable', meta, - Column('myid', Integer, primary_key=True), - Column('name', String(40), nullable=True), - Column('description', String(30), - CheckConstraint("description='hi'")), - UniqueConstraint('name'), - ) + Column('myid', Integer, primary_key=True), + Column('name', String(40), nullable=True), + Column('description', String(30), + CheckConstraint("description='hi'")), + UniqueConstraint('name'), + ) table2 = Table('othertable', meta, - Column('id', Integer, primary_key=True), - Column('myid', Integer, ForeignKey('mytable.myid')), - ) + Column('id', Integer, primary_key=True), + Column('myid', Integer, ForeignKey('mytable.myid')), + ) meta2 = MetaData() table_c = table.tometadata(meta2, schema=None) table2_c = table2.tometadata(meta2, schema=None) eq_(str(table_c.join(table2_c).onclause), str(table_c.c.myid - == table2_c.c.myid)) + == table2_c.c.myid)) eq_(str(table_c.join(table2_c).onclause), 'mytable.myid = othertable.myid') + class TableTest(fixtures.TestBase, AssertsCompiledSQL): + @testing.skip_if('mssql', 'different col format') def test_prefixes(self): from sqlalchemy import Table table1 = Table("temporary_table_1", MetaData(), - Column("col1", Integer), - prefixes=["TEMPORARY"]) + Column("col1", Integer), + prefixes=["TEMPORARY"]) self.assert_compile( schema.CreateTable(table1), @@ -927,8 +971,8 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): ) table2 = Table("temporary_table_2", MetaData(), - Column("col1", Integer), - prefixes=["VIRTUAL"]) + Column("col1", Integer), + prefixes=["VIRTUAL"]) self.assert_compile( schema.CreateTable(table2), "CREATE VIRTUAL TABLE temporary_table_2 (col1 INTEGER)" @@ -972,23 +1016,23 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): m = MetaData() t = Table('t', m, - Column('id', Integer, primary_key=True) - ) + Column('id', Integer, primary_key=True) + ) is_(t._autoincrement_column, t.c.id) t = Table('t', m, - Column('id', Integer, primary_key=True), - extend_existing=True - ) + Column('id', Integer, primary_key=True), + extend_existing=True + ) is_(t._autoincrement_column, t.c.id) def test_pk_args_standalone(self): m = MetaData() t = Table('t', m, - Column('x', Integer, primary_key=True), - PrimaryKeyConstraint(mssql_clustered=True) - ) + Column('x', Integer, primary_key=True), + PrimaryKeyConstraint(mssql_clustered=True) + ) eq_( list(t.primary_key), [t.c.x] ) @@ -999,11 +1043,11 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): def test_pk_cols_sets_flags(self): m = MetaData() t = Table('t', m, - Column('x', Integer), - Column('y', Integer), - Column('z', Integer), - PrimaryKeyConstraint('x', 'y') - ) + Column('x', Integer), + Column('y', Integer), + Column('z', Integer), + PrimaryKeyConstraint('x', 'y') + ) eq_(t.c.x.primary_key, True) eq_(t.c.y.primary_key, True) eq_(t.c.z.primary_key, False) @@ -1013,11 +1057,11 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.SAWarning, "Table 't' specifies columns 'x' as primary_key=True, " - "not matching locally specified columns 'q'", + "not matching locally specified columns 'q'", Table, 't', m, - Column('x', Integer, primary_key=True), - Column('q', Integer), - PrimaryKeyConstraint('q') + Column('x', Integer, primary_key=True), + Column('q', Integer), + PrimaryKeyConstraint('q') ) def test_pk_col_mismatch_two(self): @@ -1025,33 +1069,33 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.SAWarning, "Table 't' specifies columns 'a', 'b', 'c' as primary_key=True, " - "not matching locally specified columns 'b', 'c'", + "not matching locally specified columns 'b', 'c'", Table, 't', m, - Column('a', Integer, primary_key=True), - Column('b', Integer, primary_key=True), - Column('c', Integer, primary_key=True), - PrimaryKeyConstraint('b', 'c') + Column('a', Integer, primary_key=True), + Column('b', Integer, primary_key=True), + Column('c', Integer, primary_key=True), + PrimaryKeyConstraint('b', 'c') ) @testing.emits_warning("Table 't'") def test_pk_col_mismatch_three(self): m = MetaData() t = Table('t', m, - Column('x', Integer, primary_key=True), - Column('q', Integer), - PrimaryKeyConstraint('q') - ) + Column('x', Integer, primary_key=True), + Column('q', Integer), + PrimaryKeyConstraint('q') + ) eq_(list(t.primary_key), [t.c.q]) @testing.emits_warning("Table 't'") def test_pk_col_mismatch_four(self): m = MetaData() t = Table('t', m, - Column('a', Integer, primary_key=True), - Column('b', Integer, primary_key=True), - Column('c', Integer, primary_key=True), - PrimaryKeyConstraint('b', 'c') - ) + Column('a', Integer, primary_key=True), + Column('b', Integer, primary_key=True), + Column('c', Integer, primary_key=True), + PrimaryKeyConstraint('b', 'c') + ) eq_(list(t.primary_key), [t.c.b, t.c.c]) def test_pk_always_flips_nullable(self): @@ -1073,6 +1117,7 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): class SchemaTypeTest(fixtures.TestBase): + class MyType(sqltypes.SchemaType, sqltypes.TypeEngine): column = None table = None @@ -1094,6 +1139,7 @@ class SchemaTypeTest(fixtures.TestBase): self.evt_targets += (target,) class MyTypeWImpl(MyType): + def _gen_dialect_impl(self, dialect): return self.adapt(SchemaTypeTest.MyTypeImpl) @@ -1236,7 +1282,14 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): def test_ad_hoc_schema_equiv_fk(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer), schema="foo") - t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x')), schema="foo") + t2 = Table( + 't2', + m, + Column( + 'x', + Integer, + ForeignKey('t1.x')), + schema="foo") assert_raises( exc.NoReferencedTableError, lambda: t2.c.x.references(t1.c.x) @@ -1246,7 +1299,7 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): m = MetaData(schema="foo") t1 = Table('t1', m, Column('x', Integer)) t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x')), - schema="bar") + schema="bar") assert t2.c.x.references(t1.c.x) def test_default_schema_metadata_fk_alt_local_raises(self): @@ -1281,12 +1334,26 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): def test_iteration(self): metadata = MetaData() - table1 = Table('table1', metadata, Column('col1', Integer, - primary_key=True), schema='someschema') - table2 = Table('table2', metadata, Column('col1', Integer, - primary_key=True), Column('col2', Integer, - ForeignKey('someschema.table1.col1')), - schema='someschema') + table1 = Table( + 'table1', + metadata, + Column( + 'col1', + Integer, + primary_key=True), + schema='someschema') + table2 = Table( + 'table2', + metadata, + Column( + 'col1', + Integer, + primary_key=True), + Column( + 'col2', + Integer, + ForeignKey('someschema.table1.col1')), + schema='someschema') t1 = str(schema.CreateTable(table1).compile(bind=testing.db)) t2 = str(schema.CreateTable(table2).compile(bind=testing.db)) @@ -1299,11 +1366,12 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): class UseExistingTest(fixtures.TablesTest): + @classmethod def define_tables(cls, metadata): Table('users', metadata, - Column('id', Integer, primary_key=True), - Column('name', String(30))) + Column('id', Integer, primary_key=True), + Column('name', String(30))) def _useexisting_fixture(self): meta2 = MetaData(testing.db) @@ -1315,23 +1383,23 @@ class UseExistingTest(fixtures.TablesTest): def test_exception_no_flags(self): meta2 = self._useexisting_fixture() + def go(): Table('users', meta2, Column('name', - Unicode), autoload=True) + Unicode), autoload=True) assert_raises_message( exc.InvalidRequestError, - "Table 'users' is already defined for this "\ - "MetaData instance.", + "Table 'users' is already defined for this " + "MetaData instance.", go ) - def test_keep_plus_existing_raises(self): meta2 = self._useexisting_fixture() assert_raises( exc.ArgumentError, Table, 'users', meta2, keep_existing=True, - extend_existing=True + extend_existing=True ) @testing.uses_deprecated() @@ -1340,47 +1408,47 @@ class UseExistingTest(fixtures.TablesTest): assert_raises( exc.ArgumentError, Table, 'users', meta2, useexisting=True, - extend_existing=True + extend_existing=True ) def test_keep_existing_no_dupe_constraints(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, - Column('id', Integer), - Column('name', Unicode), - UniqueConstraint('name'), - keep_existing=True - ) + Column('id', Integer), + Column('name', Unicode), + UniqueConstraint('name'), + keep_existing=True + ) assert 'name' in users.c assert 'id' in users.c eq_(len(users.constraints), 2) u2 = Table('users', meta2, - Column('id', Integer), - Column('name', Unicode), - UniqueConstraint('name'), - keep_existing=True - ) + Column('id', Integer), + Column('name', Unicode), + UniqueConstraint('name'), + keep_existing=True + ) eq_(len(u2.constraints), 2) def test_extend_existing_dupes_constraints(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, - Column('id', Integer), - Column('name', Unicode), - UniqueConstraint('name'), - extend_existing=True - ) + Column('id', Integer), + Column('name', Unicode), + UniqueConstraint('name'), + extend_existing=True + ) assert 'name' in users.c assert 'id' in users.c eq_(len(users.constraints), 2) u2 = Table('users', meta2, - Column('id', Integer), - Column('name', Unicode), - UniqueConstraint('name'), - extend_existing=True - ) + Column('id', Integer), + Column('name', Unicode), + UniqueConstraint('name'), + extend_existing=True + ) # constraint got duped eq_(len(u2.constraints), 3) @@ -1399,8 +1467,8 @@ class UseExistingTest(fixtures.TablesTest): def test_keep_existing_add_column(self): meta2 = self._useexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), - autoload=True, + Column('foo', Integer), + autoload=True, keep_existing=True) assert "foo" not in users.c @@ -1411,20 +1479,20 @@ class UseExistingTest(fixtures.TablesTest): assert isinstance(users.c.name.type, Unicode) @testing.skip_if( - lambda: testing.db.dialect.requires_name_normalize, - "test depends on lowercase as case insensitive") + lambda: testing.db.dialect.requires_name_normalize, + "test depends on lowercase as case insensitive") def test_keep_existing_quote_no_orig(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, quote=True, - autoload=True, + autoload=True, keep_existing=True) assert users.name.quote def test_keep_existing_add_column_no_orig(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), - autoload=True, + Column('foo', Integer), + autoload=True, keep_existing=True) assert "foo" in users.c @@ -1443,7 +1511,7 @@ class UseExistingTest(fixtures.TablesTest): def test_keep_existing_add_column_no_reflection(self): meta2 = self._useexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), + Column('foo', Integer), keep_existing=True) assert "foo" not in users.c @@ -1459,14 +1527,14 @@ class UseExistingTest(fixtures.TablesTest): tsa.exc.ArgumentError, "Can't redefine 'quote' or 'quote_schema' arguments", Table, 'users', meta2, quote=True, autoload=True, - extend_existing=True + extend_existing=True ) def test_extend_existing_add_column(self): meta2 = self._useexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), - autoload=True, + Column('foo', Integer), + autoload=True, extend_existing=True) assert "foo" in users.c @@ -1477,20 +1545,20 @@ class UseExistingTest(fixtures.TablesTest): assert isinstance(users.c.name.type, Unicode) @testing.skip_if( - lambda: testing.db.dialect.requires_name_normalize, - "test depends on lowercase as case insensitive") + lambda: testing.db.dialect.requires_name_normalize, + "test depends on lowercase as case insensitive") def test_extend_existing_quote_no_orig(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, quote=True, - autoload=True, + autoload=True, extend_existing=True) assert users.name.quote def test_extend_existing_add_column_no_orig(self): meta2 = self._notexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), - autoload=True, + Column('foo', Integer), + autoload=True, extend_existing=True) assert "foo" in users.c @@ -1506,17 +1574,19 @@ class UseExistingTest(fixtures.TablesTest): tsa.exc.ArgumentError, "Can't redefine 'quote' or 'quote_schema' arguments", Table, 'users', meta2, quote=True, - extend_existing=True + extend_existing=True ) def test_extend_existing_add_column_no_reflection(self): meta2 = self._useexisting_fixture() users = Table('users', meta2, - Column('foo', Integer), + Column('foo', Integer), extend_existing=True) assert "foo" in users.c + class IndexTest(fixtures.TestBase): + def _assert(self, t, i, columns=True): eq_(t.indexes, set([i])) if columns: @@ -1584,21 +1654,22 @@ class IndexTest(fixtures.TestBase): class ConstraintTest(fixtures.TestBase): + def _single_fixture(self): m = MetaData() t1 = Table('t1', m, - Column('a', Integer), - Column('b', Integer) - ) + Column('a', Integer), + Column('b', Integer) + ) t2 = Table('t2', m, - Column('a', Integer, ForeignKey('t1.a')) - ) + Column('a', Integer, ForeignKey('t1.a')) + ) t3 = Table('t3', m, - Column('a', Integer) - ) + Column('a', Integer) + ) return t1, t2, t3 def test_table_references(self): @@ -1633,13 +1704,13 @@ class ConstraintTest(fixtures.TestBase): def test_related_column_not_present_atfirst_ok(self): m = MetaData() base_table = Table("base", m, - Column("id", Integer, primary_key=True) - ) + Column("id", Integer, primary_key=True) + ) fk = ForeignKey('base.q') derived_table = Table("derived", m, - Column("id", None, fk, - primary_key=True), - ) + Column("id", None, fk, + primary_key=True), + ) base_table.append_column(Column('q', Integer)) assert fk.column is base_table.c.q @@ -1651,7 +1722,7 @@ class ConstraintTest(fixtures.TestBase): assert_raises_message( exc.ArgumentError, r"ForeignKeyConstraint on t1\(x, y\) refers to " - "multiple remote tables: t2 and t3", + "multiple remote tables: t2 and t3", Table, 't1', m, Column('x', Integer), Column('y', Integer), ForeignKeyConstraint(['x', 'y'], ['t2.x', 't3.y']) @@ -1666,7 +1737,7 @@ class ConstraintTest(fixtures.TestBase): assert_raises_message( exc.ArgumentError, r"ForeignKeyConstraint on t1\(x, y\) refers to " - "multiple remote tables: t2 and t3", + "multiple remote tables: t2 and t3", Table, 't1', m, Column('x', Integer), Column('y', Integer), ForeignKeyConstraint(['x', 'y'], [t2.c.x, t3.c.y]) @@ -1680,17 +1751,17 @@ class ConstraintTest(fixtures.TestBase): # no error is raised for this one right now. # which is a minor bug. Table('t1', m, Column('x', Integer), Column('y', Integer), - ForeignKeyConstraint(['x', 'y'], [x, y]) - ) + ForeignKeyConstraint(['x', 'y'], [x, y]) + ) - t2 = Table('t2', m, x) - t3 = Table('t3', m, y) + Table('t2', m, x) + Table('t3', m, y) def test_constraint_copied_to_proxy_ok(self): m = MetaData() - t1 = Table('t1', m, Column('id', Integer, primary_key=True)) + Table('t1', m, Column('id', Integer, primary_key=True)) t2 = Table('t2', m, Column('id', Integer, ForeignKey('t1.id'), - primary_key=True)) + primary_key=True)) s = tsa.select([t2]) t2fk = list(t2.c.id.foreign_keys)[0] @@ -1711,9 +1782,10 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_composite_fk_string(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True), - Column('key2', String(40), primary_key=True)) + Table( + 'a', metadata, + Column('key1', Integer, primary_key=True), + Column('key2', String(40), primary_key=True)) b = Table('b', metadata, Column('a_key1', None), @@ -1745,8 +1817,9 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_standalone_fk_string(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True)) + Table( + 'a', metadata, + Column('key1', Integer, primary_key=True)) b = Table('b', metadata, Column('a_key1', None, ForeignKey("a.key1")), @@ -1767,8 +1840,10 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_chained_string_source_first(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True)) + Table( + 'a', metadata, + Column('key1', Integer, primary_key=True) + ) b = Table('b', metadata, Column('a_key1', None, ForeignKey("a.key1")), @@ -1792,8 +1867,9 @@ class ConstraintTest(fixtures.TestBase): Column('b_key1', None, ForeignKey("b.a_key1")), ) - a = Table('a', metadata, - Column('key1', Integer, primary_key=True)) + Table( + 'a', metadata, + Column('key1', Integer, primary_key=True)) assert isinstance(b.c.a_key1.type, Integer) assert isinstance(c.c.b_key1.type, Integer) @@ -1823,8 +1899,10 @@ class ConstraintTest(fixtures.TestBase): c1 = Column('x', Integer) class CThing(object): + def __init__(self, c): self.c = c + def __clause_element__(self): return self.c @@ -1842,7 +1920,7 @@ class ConstraintTest(fixtures.TestBase): def test_column_accessor_string_no_parent_table(self): fk = ForeignKey("sometable.somecol") - c1 = Column('x', fk) + Column('x', fk) assert_raises_message( exc.InvalidRequestError, "this ForeignKey's parent column is not yet " @@ -1853,7 +1931,7 @@ class ConstraintTest(fixtures.TestBase): def test_column_accessor_string_no_target_table(self): fk = ForeignKey("sometable.somecol") c1 = Column('x', fk) - t1 = Table('t', MetaData(), c1) + Table('t', MetaData(), c1) assert_raises_message( exc.NoReferencedTableError, "Foreign key associated with column 't.x' could not find " @@ -1866,8 +1944,8 @@ class ConstraintTest(fixtures.TestBase): fk = ForeignKey("sometable.somecol") c1 = Column('x', fk) m = MetaData() - t1 = Table('t', m, c1) - t2 = Table("sometable", m, Column('notsomecol', Integer)) + Table('t', m, c1) + Table("sometable", m, Column('notsomecol', Integer)) assert_raises_message( exc.NoReferencedColumnError, "Could not initialize target column for ForeignKey " @@ -1914,20 +1992,21 @@ class ConstraintTest(fixtures.TestBase): class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): + """Test Column() construction.""" __dialect__ = 'default' def columns(self): return [Column(Integer), - Column('b', Integer), - Column(Integer), - Column('d', Integer), - Column(Integer, name='e'), - Column(type_=Integer), - Column(Integer()), - Column('h', Integer()), - Column(type_=Integer())] + Column('b', Integer), + Column(Integer), + Column('d', Integer), + Column(Integer, name='e'), + Column(type_=Integer), + Column(Integer()), + Column('h', Integer()), + Column(type_=Integer())] def test_basic(self): c = self.columns() @@ -2006,7 +2085,7 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): def test_bogus(self): assert_raises(exc.ArgumentError, Column, 'foo', name='bar') assert_raises(exc.ArgumentError, Column, 'foo', Integer, - type_=Integer()) + type_=Integer()) def test_custom_subclass_proxy(self): """test proxy generation of a Column subclass, can be compiled.""" @@ -2016,6 +2095,7 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): from sqlalchemy.sql import select class MyColumn(Column): + def _constructor(self, name, type, **kw): kw['name'] = name return MyColumn(type, **kw) @@ -2036,9 +2116,9 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): name = MyColumn(String) name.name = 'name' t1 = Table('foo', MetaData(), - id, - name - ) + id, + name + ) # goofy thing eq_(t1.c.name.my_goofy_thing(), "hi") @@ -2062,6 +2142,7 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): from sqlalchemy.sql import select class MyColumn(Column): + def __init__(self, type, **kw): Column.__init__(self, type, **kw) @@ -2070,9 +2151,9 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): name = MyColumn(String) name.name = 'name' t1 = Table('foo', MetaData(), - id, - name - ) + id, + name + ) assert_raises_message( TypeError, "Could not create a copy of this <class " @@ -2092,9 +2173,9 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): return compiler.visit_create_column(element, **kw) text = "%s SPECIAL DIRECTIVE %s" % ( - column.name, - compiler.type_compiler.process(column.type) - ) + column.name, + compiler.type_compiler.process(column.type) + ) default = compiler.get_column_default_string(column) if default is not None: text += " DEFAULT " + default @@ -2104,26 +2185,30 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): if column.constraints: text += " ".join( - compiler.process(const) - for const in column.constraints) + compiler.process(const) + for const in column.constraints) return text - t = Table('mytable', MetaData(), - Column('x', Integer, info={"special": True}, primary_key=True), - Column('y', String(50)), - Column('z', String(20), info={"special": True}) - ) + t = Table( + 'mytable', MetaData(), + Column('x', Integer, info={ + "special": True}, primary_key=True), + Column('y', String(50)), + Column('z', String(20), info={ + "special": True})) self.assert_compile( schema.CreateTable(t), "CREATE TABLE mytable (x SPECIAL DIRECTIVE INTEGER " - "NOT NULL, y VARCHAR(50), " - "z SPECIAL DIRECTIVE VARCHAR(20), PRIMARY KEY (x))" + "NOT NULL, y VARCHAR(50), " + "z SPECIAL DIRECTIVE VARCHAR(20), PRIMARY KEY (x))" ) deregister(schema.CreateColumn) + class ColumnDefaultsTest(fixtures.TestBase): + """test assignment of default fixures to columns""" def _fixture(self, *arg, **kw): @@ -2232,6 +2317,7 @@ class ColumnDefaultsTest(fixtures.TestBase): assert c.onupdate.arg == target assert c.onupdate.column is c + class ColumnOptionsTest(fixtures.TestBase): def test_default_generators(self): @@ -2283,7 +2369,6 @@ class ColumnOptionsTest(fixtures.TestBase): self._no_error(Column("foo", ForeignKey('bar.id'), default="foo")) self._no_error(Column("foo", ForeignKey('bar.id'), Sequence("a"))) - def test_column_info(self): c1 = Column('foo', String, info={'x': 'y'}) @@ -2297,28 +2382,36 @@ class ColumnOptionsTest(fixtures.TestBase): c.info['bar'] = 'zip' assert c.info['bar'] == 'zip' + class CatchAllEventsTest(fixtures.RemovesEvents, fixtures.TestBase): def test_all_events(self): canary = [] + def before_attach(obj, parent): canary.append("%s->%s" % (obj.__class__.__name__, - parent.__class__.__name__)) + parent.__class__.__name__)) def after_attach(obj, parent): canary.append("%s->%s" % (obj.__class__.__name__, parent)) - self.event_listen(schema.SchemaItem, "before_parent_attach", before_attach) - self.event_listen(schema.SchemaItem, "after_parent_attach", after_attach) + self.event_listen( + schema.SchemaItem, + "before_parent_attach", + before_attach) + self.event_listen( + schema.SchemaItem, + "after_parent_attach", + after_attach) m = MetaData() Table('t1', m, - Column('id', Integer, Sequence('foo_id'), primary_key=True), - Column('bar', String, ForeignKey('t2.id')) - ) + Column('id', Integer, Sequence('foo_id'), primary_key=True), + Column('bar', String, ForeignKey('t2.id')) + ) Table('t2', m, - Column('id', Integer, primary_key=True), - ) + Column('id', Integer, primary_key=True), + ) eq_( canary, @@ -2339,7 +2432,7 @@ class CatchAllEventsTest(fixtures.RemovesEvents, fixtures.TestBase): def evt(target): def before_attach(obj, parent): canary.append("%s->%s" % (target.__name__, - parent.__class__.__name__)) + parent.__class__.__name__)) def after_attach(obj, parent): assert hasattr(obj, 'name') # so we can change it @@ -2357,18 +2450,18 @@ class CatchAllEventsTest(fixtures.RemovesEvents, fixtures.TestBase): m = MetaData() Table('t1', m, - Column('id', Integer, Sequence('foo_id'), primary_key=True), - Column('bar', String, ForeignKey('t2.id'), index=True), - Column('bat', Integer, unique=True), - ) + Column('id', Integer, Sequence('foo_id'), primary_key=True), + Column('bar', String, ForeignKey('t2.id'), index=True), + Column('bat', Integer, unique=True), + ) Table('t2', m, - Column('id', Integer, primary_key=True), - Column('bar', Integer), - Column('bat', Integer), - CheckConstraint("bar>5"), - UniqueConstraint('bar', 'bat'), - Index(None, 'bar', 'bat') - ) + Column('id', Integer, primary_key=True), + Column('bar', Integer), + Column('bat', Integer), + CheckConstraint("bar>5"), + UniqueConstraint('bar', 'bat'), + Index(None, 'bar', 'bat') + ) eq_( canary, [ @@ -2383,10 +2476,13 @@ class CatchAllEventsTest(fixtures.RemovesEvents, fixtures.TestBase): ] ) + class DialectKWArgTest(fixtures.TestBase): + @contextmanager def _fixture(self): from sqlalchemy.engine.default import DefaultDialect + class ParticipatingDialect(DefaultDialect): construct_arguments = [ (schema.Index, { @@ -2445,7 +2541,12 @@ class DialectKWArgTest(fixtures.TestBase): def test_nonparticipating(self): with self._fixture(): - idx = Index('a', 'b', 'c', nonparticipating_y=True, nonparticipating_q=5) + idx = Index( + 'a', + 'b', + 'c', + nonparticipating_y=True, + nonparticipating_q=5) eq_( idx.dialect_kwargs, { @@ -2459,9 +2560,10 @@ class DialectKWArgTest(fixtures.TestBase): assert_raises_message( TypeError, "Additional arguments should be named " - "<dialectname>_<argument>, got 'foobar'", + "<dialectname>_<argument>, got 'foobar'", Index, 'a', 'b', 'c', foobar=True ) + def test_unknown_dialect_warning(self): with self._fixture(): assert_raises_message( @@ -2503,7 +2605,7 @@ class DialectKWArgTest(fixtures.TestBase): def test_unknown_dialect_warning_still_populates_multiple(self): with self._fixture(): idx = Index('a', 'b', 'c', unknown_y=True, unknown_z=5, - otherunknown_foo='bar', participating_y=8) + otherunknown_foo='bar', participating_y=8) eq_( idx.dialect_options, { @@ -2514,14 +2616,14 @@ class DialectKWArgTest(fixtures.TestBase): ) eq_(idx.dialect_kwargs, {'unknown_z': 5, 'participating_y': 8, - 'unknown_y': True, - 'otherunknown_foo': 'bar'} - ) # still populates + 'unknown_y': True, + 'otherunknown_foo': 'bar'} + ) # still populates def test_runs_safekwarg(self): with mock.patch("sqlalchemy.util.safe_kwarg", - lambda arg: "goofy_%s" % arg): + lambda arg: "goofy_%s" % arg): with self._fixture(): idx = Index('a', 'b') idx.kwargs[u'participating_x'] = 7 @@ -2534,7 +2636,7 @@ class DialectKWArgTest(fixtures.TestBase): def test_combined(self): with self._fixture(): idx = Index('a', 'b', 'c', participating_x=7, - nonparticipating_y=True) + nonparticipating_y=True) eq_( idx.dialect_options, @@ -2557,7 +2659,7 @@ class DialectKWArgTest(fixtures.TestBase): participating_x=7, participating2_x=15, participating2_y="lazy" - ) + ) eq_( idx.dialect_options, { @@ -2579,7 +2681,10 @@ class DialectKWArgTest(fixtures.TestBase): m = MetaData() fk = ForeignKey('t2.id', participating_foobar=True) t = Table('t', m, Column('id', Integer, fk)) - fkc = [c for c in t.constraints if isinstance(c, ForeignKeyConstraint)][0] + fkc = [ + c for c in t.constraints if isinstance( + c, + ForeignKeyConstraint)][0] eq_( fkc.dialect_kwargs, {'participating_foobar': True} @@ -2602,9 +2707,9 @@ class DialectKWArgTest(fixtures.TestBase): with self._fixture(): m = MetaData() t = Table('x', m, Column('x', Integer), - participating2_xyz='foo', - participating2_engine='InnoDB', - ) + participating2_xyz='foo', + participating2_engine='InnoDB', + ) eq_( t.dialect_kwargs, { @@ -2636,48 +2741,47 @@ class DialectKWArgTest(fixtures.TestBase): t = Table('x', m, Column('x', Integer), participating2_foobar=5) assert 'foobar' in t.dialect_options['participating2'] - def test_update(self): with self._fixture(): idx = Index('a', 'b', 'c', participating_x=20) eq_(idx.dialect_kwargs, { - "participating_x": 20, - }) + "participating_x": 20, + }) idx._validate_dialect_kwargs({ - "participating_x": 25, - "participating_z_one": "default"}) + "participating_x": 25, + "participating_z_one": "default"}) eq_(idx.dialect_options, { - "participating": {"x": 25, "y": False, "z_one": "default"} - }) + "participating": {"x": 25, "y": False, "z_one": "default"} + }) eq_(idx.dialect_kwargs, { - "participating_x": 25, - 'participating_z_one': "default" - }) + "participating_x": 25, + 'participating_z_one': "default" + }) idx._validate_dialect_kwargs({ - "participating_x": 25, - "participating_z_one": "default"}) + "participating_x": 25, + "participating_z_one": "default"}) eq_(idx.dialect_options, { - "participating": {"x": 25, "y": False, "z_one": "default"} - }) + "participating": {"x": 25, "y": False, "z_one": "default"} + }) eq_(idx.dialect_kwargs, { - "participating_x": 25, - 'participating_z_one': "default" - }) + "participating_x": 25, + 'participating_z_one': "default" + }) idx._validate_dialect_kwargs({ - "participating_y": True, - 'participating2_y': "p2y"}) + "participating_y": True, + 'participating2_y': "p2y"}) eq_(idx.dialect_options, { - "participating": {"x": 25, "y": True, "z_one": "default"}, - "participating2": {"y": "p2y", "pp": "default", "x": 9} - }) + "participating": {"x": 25, "y": True, "z_one": "default"}, + "participating2": {"y": "p2y", "pp": "default", "x": 9} + }) eq_(idx.dialect_kwargs, { - "participating_x": 25, - "participating_y": True, - 'participating2_y': "p2y", - "participating_z_one": "default"}) + "participating_x": 25, + "participating_y": True, + 'participating2_y': "p2y", + "participating_z_one": "default"}) def test_key_error_kwargs_no_dialect(self): with self._fixture(): @@ -2718,8 +2822,8 @@ class DialectKWArgTest(fixtures.TestBase): assert_raises( KeyError, - idx.dialect_options['nonparticipating'].__getitem__, 'asdfaso890' - ) + idx.dialect_options['nonparticipating'].__getitem__, + 'asdfaso890') def test_ad_hoc_participating_via_opt(self): with self._fixture(): @@ -2798,11 +2902,10 @@ class DialectKWArgTest(fixtures.TestBase): assert_raises_message( exc.ArgumentError, "Dialect 'nonparticipating' does have keyword-argument " - "validation and defaults enabled configured", + "validation and defaults enabled configured", Index.argument_for, "nonparticipating", "xyzqpr", False ) - def test_add_new_arguments_invalid_dialect(self): with self._fixture(): assert_raises_message( @@ -2819,18 +2922,18 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): m1 = MetaData(naming_convention=naming_convention) u1 = Table('user', m1, - Column('id', Integer, primary_key=True), - Column('version', Integer, primary_key=True), - Column('data', String(30)), - schema=table_schema - ) + Column('id', Integer, primary_key=True), + Column('version', Integer, primary_key=True), + Column('data', String(30)), + schema=table_schema + ) return u1 def test_uq_name(self): u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_name)s" - }) + "uq": "uq_%(table_name)s_%(column_0_name)s" + }) uq = UniqueConstraint(u1.c.data) eq_(uq.name, "uq_user_data") @@ -2863,16 +2966,16 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): def test_column_attached_ck_name(self): m = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) + "ck": "ck_%(table_name)s_%(constraint_name)s" + }) ck = CheckConstraint('x > 5', name='x1') Table('t', m, Column('x', ck)) eq_(ck.name, "ck_t_x1") def test_table_attached_ck_name(self): m = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) + "ck": "ck_%(table_name)s_%(constraint_name)s" + }) ck = CheckConstraint('x > 5', name='x1') Table('t', m, Column('x', Integer), ck) eq_(ck.name, "ck_t_x1") @@ -2888,67 +2991,64 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): t.append_constraint(uq) eq_(uq.name, "my_special_key") - def test_fk_name_schema(self): u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(column_0_name)s_" - "%(referred_table_name)s_%(referred_column_0_name)s" - }, table_schema="foo") + "fk": "fk_%(table_name)s_%(column_0_name)s_" + "%(referred_table_name)s_%(referred_column_0_name)s" + }, table_schema="foo") m1 = u1.metadata a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('user_id', Integer), - Column('user_version_id', Integer) - ) + Column('id', Integer, primary_key=True), + Column('user_id', Integer), + Column('user_version_id', Integer) + ) fk = ForeignKeyConstraint(['user_id', 'user_version_id'], - ['foo.user.id', 'foo.user.version']) + ['foo.user.id', 'foo.user.version']) a1.append_constraint(fk) eq_(fk.name, "fk_address_user_id_user_id") - def test_fk_attrs(self): u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(column_0_name)s_" - "%(referred_table_name)s_%(referred_column_0_name)s" - }) + "fk": "fk_%(table_name)s_%(column_0_name)s_" + "%(referred_table_name)s_%(referred_column_0_name)s" + }) m1 = u1.metadata a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('user_id', Integer), - Column('user_version_id', Integer) - ) + Column('id', Integer, primary_key=True), + Column('user_id', Integer), + Column('user_version_id', Integer) + ) fk = ForeignKeyConstraint(['user_id', 'user_version_id'], - ['user.id', 'user.version']) + ['user.id', 'user.version']) a1.append_constraint(fk) eq_(fk.name, "fk_address_user_id_user_id") - def test_custom(self): def key_hash(const, table): return "HASH_%s" % table.name u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(key_hash)s", - "key_hash": key_hash - }) + "fk": "fk_%(table_name)s_%(key_hash)s", + "key_hash": key_hash + }) m1 = u1.metadata a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('user_id', Integer), - Column('user_version_id', Integer) - ) + Column('id', Integer, primary_key=True), + Column('user_id', Integer), + Column('user_version_id', Integer) + ) fk = ForeignKeyConstraint(['user_id', 'user_version_id'], - ['user.id', 'user.version']) + ['user.id', 'user.version']) a1.append_constraint(fk) eq_(fk.name, "fk_address_HASH_address") def test_schematype_ck_name_boolean(self): m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s"}) + "ck": "ck_%(table_name)s_%(constraint_name)s"}) u1 = Table('user', m1, - Column('x', Boolean(name='foo')) - ) + Column('x', Boolean(name='foo')) + ) # constraint is not hit eq_( [c for c in u1.constraints @@ -2965,11 +3065,11 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): def test_schematype_ck_name_enum(self): m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s"}) + "ck": "ck_%(table_name)s_%(constraint_name)s"}) u1 = Table('user', m1, - Column('x', Enum('a', 'b', name='foo')) - ) + Column('x', Enum('a', 'b', name='foo')) + ) eq_( [c for c in u1.constraints if isinstance(c, CheckConstraint)][0].name, "foo" @@ -2978,18 +3078,18 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.CreateTable(u1), 'CREATE TABLE "user" (' - "x VARCHAR(1), " - "CONSTRAINT ck_user_foo CHECK (x IN ('a', 'b'))" + "x VARCHAR(1), " + "CONSTRAINT ck_user_foo CHECK (x IN ('a', 'b'))" ")" ) def test_schematype_ck_name_propagate_conv(self): m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s"}) + "ck": "ck_%(table_name)s_%(constraint_name)s"}) u1 = Table('user', m1, - Column('x', Enum('a', 'b', name=naming.conv('foo'))) - ) + Column('x', Enum('a', 'b', name=naming.conv('foo'))) + ) eq_( [c for c in u1.constraints if isinstance(c, CheckConstraint)][0].name, "foo" @@ -2998,8 +3098,8 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.CreateTable(u1), 'CREATE TABLE "user" (' - "x VARCHAR(1), " - "CONSTRAINT foo CHECK (x IN ('a', 'b'))" + "x VARCHAR(1), " + "CONSTRAINT foo CHECK (x IN ('a', 'b'))" ")" ) @@ -3051,10 +3151,9 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'CREATE TABLE "user" (x BOOLEAN, CHECK (x IN (0, 1)))' ) - def test_ck_constraint_redundant_event(self): u1 = self._fixture(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s"}) + "ck": "ck_%(table_name)s_%(constraint_name)s"}) ck1 = CheckConstraint(u1.c.version > 3, name='foo') u1.append_constraint(ck1) @@ -3062,4 +3161,3 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): u1.append_constraint(ck1) eq_(ck1.name, "ck_user_foo") - diff --git a/test/sql/test_operators.py b/test/sql/test_operators.py index 9b6b2297f..5c401845b 100644 --- a/test/sql/test_operators.py +++ b/test/sql/test_operators.py @@ -3,8 +3,8 @@ from sqlalchemy import testing from sqlalchemy.testing import assert_raises_message from sqlalchemy.sql import column, desc, asc, literal, collate, null, true, false from sqlalchemy.sql.expression import BinaryExpression, \ - ClauseList, Grouping, \ - UnaryExpression, select, union, func, tuple_ + ClauseList, Grouping, \ + UnaryExpression, select, union, func, tuple_ from sqlalchemy.sql import operators, table import operator from sqlalchemy import String, Integer, LargeBinary @@ -14,7 +14,7 @@ from sqlalchemy.sql.elements import _literal_as_text from sqlalchemy.schema import Column, Table, MetaData from sqlalchemy.types import TypeEngine, TypeDecorator, UserDefinedType, Boolean from sqlalchemy.dialects import mysql, firebird, postgresql, oracle, \ - sqlite, mssql + sqlite, mssql from sqlalchemy import util import datetime import collections @@ -22,10 +22,13 @@ from sqlalchemy import text, literal_column from sqlalchemy import and_, not_, between, or_ from sqlalchemy.sql import true, false, null + class LoopOperate(operators.ColumnOperators): + def operate(self, op, *other, **kwargs): return op + class DefaultColumnComparatorTest(fixtures.TestBase): def _do_scalar_test(self, operator, compare_to): @@ -38,13 +41,21 @@ class DefaultColumnComparatorTest(fixtures.TestBase): def _do_operate_test(self, operator, right=column('right')): left = column('left') - assert left.comparator.operate(operator, right).compare( - BinaryExpression(_literal_as_text(left), _literal_as_text(right), operator) - ) - - assert operator(left, right).compare( - BinaryExpression(_literal_as_text(left), _literal_as_text(right), operator) - ) + assert left.comparator.operate( + operator, + right).compare( + BinaryExpression( + _literal_as_text(left), + _literal_as_text(right), + operator)) + + assert operator( + left, + right).compare( + BinaryExpression( + _literal_as_text(left), + _literal_as_text(right), + operator)) self._loop_test(operator, right) @@ -130,27 +141,27 @@ class DefaultColumnComparatorTest(fixtures.TestBase): def test_in(self): left = column('left') assert left.comparator.operate(operators.in_op, [1, 2, 3]).compare( - BinaryExpression( - left, - Grouping(ClauseList( - literal(1), literal(2), literal(3) - )), - operators.in_op - ) + BinaryExpression( + left, + Grouping(ClauseList( + literal(1), literal(2), literal(3) + )), + operators.in_op ) + ) self._loop_test(operators.in_op, [1, 2, 3]) def test_notin(self): left = column('left') assert left.comparator.operate(operators.notin_op, [1, 2, 3]).compare( - BinaryExpression( - left, - Grouping(ClauseList( - literal(1), literal(2), literal(3) - )), - operators.notin_op - ) + BinaryExpression( + left, + Grouping(ClauseList( + literal(1), literal(2), literal(3) + )), + operators.notin_op ) + ) self._loop_test(operators.notin_op, [1, 2, 3]) def test_in_no_accept_list_of_non_column_element(self): @@ -174,7 +185,9 @@ class DefaultColumnComparatorTest(fixtures.TestBase): def test_in_no_accept_non_list_thing_with_getitem(self): # test [ticket:2726] class HasGetitem(String): + class comparator_factory(String.Comparator): + def __getitem__(self, value): return value @@ -196,26 +209,29 @@ class DefaultColumnComparatorTest(fixtures.TestBase): def test_concat(self): self._do_operate_test(operators.concat_op) + class CustomUnaryOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' def _factorial_fixture(self): class MyInteger(Integer): + class comparator_factory(Integer.Comparator): + def factorial(self): return UnaryExpression(self.expr, - modifier=operators.custom_op("!"), - type_=MyInteger) + modifier=operators.custom_op("!"), + type_=MyInteger) def factorial_prefix(self): return UnaryExpression(self.expr, - operator=operators.custom_op("!!"), - type_=MyInteger) + operator=operators.custom_op("!!"), + type_=MyInteger) def __invert__(self): return UnaryExpression(self.expr, - operator=operators.custom_op("!!!"), - type_=MyInteger) + operator=operators.custom_op("!!!"), + type_=MyInteger) return MyInteger @@ -265,29 +281,31 @@ class CustomUnaryOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): assert_raises_message( exc.CompileError, "Unary expression does not support operator and " - "modifier simultaneously", + "modifier simultaneously", UnaryExpression(literal("x"), - operator=operators.custom_op("x"), - modifier=operators.custom_op("y")).compile + operator=operators.custom_op("x"), + modifier=operators.custom_op("y")).compile ) + class _CustomComparatorTests(object): + def test_override_builtin(self): c1 = Column('foo', self._add_override_factory()) self._assert_add_override(c1) def test_column_proxy(self): t = Table('t', MetaData(), - Column('foo', self._add_override_factory()) - ) + Column('foo', self._add_override_factory()) + ) proxied = t.select().c.foo self._assert_add_override(proxied) self._assert_and_override(proxied) def test_alias_proxy(self): t = Table('t', MetaData(), - Column('foo', self._add_override_factory()) - ) + Column('foo', self._add_override_factory()) + ) proxied = t.alias().c.foo self._assert_add_override(proxied) self._assert_and_override(proxied) @@ -332,11 +350,15 @@ class _CustomComparatorTests(object): expr.op("goofy_and")(text("5")) ) + class CustomComparatorTest(_CustomComparatorTests, fixtures.TestBase): + def _add_override_factory(self): class MyInteger(Integer): + class comparator_factory(TypeEngine.Comparator): + def __init__(self, expr): self.expr = expr @@ -350,12 +372,14 @@ class CustomComparatorTest(_CustomComparatorTests, fixtures.TestBase): class TypeDecoratorComparatorTest(_CustomComparatorTests, fixtures.TestBase): + def _add_override_factory(self): class MyInteger(TypeDecorator): impl = Integer class comparator_factory(TypeDecorator.Comparator): + def __init__(self, expr): self.expr = expr @@ -365,14 +389,19 @@ class TypeDecoratorComparatorTest(_CustomComparatorTests, fixtures.TestBase): def __and__(self, other): return self.expr.op("goofy_and")(other) - return MyInteger -class TypeDecoratorWVariantComparatorTest(_CustomComparatorTests, fixtures.TestBase): + +class TypeDecoratorWVariantComparatorTest( + _CustomComparatorTests, + fixtures.TestBase): + def _add_override_factory(self): class SomeOtherInteger(Integer): + class comparator_factory(TypeEngine.Comparator): + def __init__(self, expr): self.expr = expr @@ -386,6 +415,7 @@ class TypeDecoratorWVariantComparatorTest(_CustomComparatorTests, fixtures.TestB impl = Integer class comparator_factory(TypeDecorator.Comparator): + def __init__(self, expr): self.expr = expr @@ -398,10 +428,15 @@ class TypeDecoratorWVariantComparatorTest(_CustomComparatorTests, fixtures.TestB return MyInteger().with_variant(SomeOtherInteger, "mysql") -class CustomEmbeddedinTypeDecoratorTest(_CustomComparatorTests, fixtures.TestBase): +class CustomEmbeddedinTypeDecoratorTest( + _CustomComparatorTests, + fixtures.TestBase): + def _add_override_factory(self): class MyInteger(Integer): + class comparator_factory(TypeEngine.Comparator): + def __init__(self, expr): self.expr = expr @@ -411,16 +446,19 @@ class CustomEmbeddedinTypeDecoratorTest(_CustomComparatorTests, fixtures.TestBas def __and__(self, other): return self.expr.op("goofy_and")(other) - class MyDecInteger(TypeDecorator): impl = MyInteger return MyDecInteger + class NewOperatorTest(_CustomComparatorTests, fixtures.TestBase): + def _add_override_factory(self): class MyInteger(Integer): + class comparator_factory(TypeEngine.Comparator): + def __init__(self, expr): self.expr = expr @@ -442,12 +480,15 @@ class NewOperatorTest(_CustomComparatorTests, fixtures.TestBase): def _assert_not_and_override(self, expr): pass + class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' def test_contains(self): class MyType(UserDefinedType): + class comparator_factory(UserDefinedType.Comparator): + def contains(self, other, **kw): return self.op("->")(other) @@ -458,7 +499,9 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_getitem(self): class MyType(UserDefinedType): + class comparator_factory(UserDefinedType.Comparator): + def __getitem__(self, index): return self.op("->")(index) @@ -470,7 +513,9 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_op_not_an_iterator(self): # see [ticket:2726] class MyType(UserDefinedType): + class comparator_factory(UserDefinedType.Comparator): + def __getitem__(self, index): return self.op("->")(index) @@ -479,7 +524,9 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_lshift(self): class MyType(UserDefinedType): + class comparator_factory(UserDefinedType.Comparator): + def __lshift__(self, other): return self.op("->")(other) @@ -490,7 +537,9 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_rshift(self): class MyType(UserDefinedType): + class comparator_factory(UserDefinedType.Comparator): + def __rshift__(self, other): return self.op("->")(other) @@ -501,6 +550,7 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): class BooleanEvalTest(fixtures.TestBase, testing.AssertsCompiledSQL): + """test standalone booleans being wrapped in an AsBoolean, as well as true/false compilation.""" @@ -623,6 +673,7 @@ class BooleanEvalTest(fixtures.TestBase, testing.AssertsCompiledSQL): class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): + """test interaction of and_()/or_() with boolean , null constants """ __dialect__ = default.DefaultDialect(supports_native_boolean=True) @@ -639,9 +690,8 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_four(self): x = column('x') self.assert_compile( - and_(or_(x == 5), or_(x == 7)), - "x = :x_1 AND x = :x_2") - + and_(or_(x == 5), or_(x == 7)), + "x = :x_1 AND x = :x_2") def test_five(self): x = column("x") @@ -659,23 +709,29 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_six_pt_five(self): x = column("x") self.assert_compile(select([x]).where(or_(x == 7, true())), - "SELECT x WHERE true") + "SELECT x WHERE true") - self.assert_compile(select([x]).where(or_(x == 7, true())), - "SELECT x WHERE 1 = 1", - dialect=default.DefaultDialect(supports_native_boolean=False)) + self.assert_compile( + select( + [x]).where( + or_( + x == 7, + true())), + "SELECT x WHERE 1 = 1", + dialect=default.DefaultDialect( + supports_native_boolean=False)) def test_seven(self): x = column("x") self.assert_compile( - and_(true(), x == 7, true(), x == 9), - "x = :x_1 AND x = :x_2") + and_(true(), x == 7, true(), x == 9), + "x = :x_1 AND x = :x_2") def test_eight(self): x = column("x") self.assert_compile( - or_(false(), x == 7, false(), x == 9), - "x = :x_1 OR x = :x_2") + or_(false(), x == 7, false(), x == 9), + "x = :x_1 OR x = :x_2") def test_nine(self): x = column("x") @@ -726,86 +782,94 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' - table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), - ) + column('myid', Integer), + column('name', String), + column('description', String), + ) table2 = table('op', column('field')) def test_operator_precedence_1(self): self.assert_compile( - self.table2.select((self.table2.c.field == 5) == None), + self.table2.select((self.table2.c.field == 5) == None), "SELECT op.field FROM op WHERE (op.field = :field_1) IS NULL") def test_operator_precedence_2(self): self.assert_compile( - self.table2.select( - (self.table2.c.field + 5) == self.table2.c.field), + self.table2.select( + (self.table2.c.field + 5) == self.table2.c.field), "SELECT op.field FROM op WHERE op.field + :field_1 = op.field") def test_operator_precedence_3(self): self.assert_compile( - self.table2.select((self.table2.c.field + 5) * 6), + self.table2.select((self.table2.c.field + 5) * 6), "SELECT op.field FROM op WHERE (op.field + :field_1) * :param_1") def test_operator_precedence_4(self): - self.assert_compile(self.table2.select((self.table2.c.field * 5) + 6), + self.assert_compile( + self.table2.select( + (self.table2.c.field * 5) + 6), "SELECT op.field FROM op WHERE op.field * :field_1 + :param_1") def test_operator_precedence_5(self): self.assert_compile(self.table2.select( 5 + self.table2.c.field.in_([5, 6])), - "SELECT op.field FROM op WHERE :param_1 + " - "(op.field IN (:field_1, :field_2))") + "SELECT op.field FROM op WHERE :param_1 + " + "(op.field IN (:field_1, :field_2))") def test_operator_precedence_6(self): self.assert_compile(self.table2.select( - (5 + self.table2.c.field).in_([5, 6])), + (5 + self.table2.c.field).in_([5, 6])), "SELECT op.field FROM op WHERE :field_1 + op.field " - "IN (:param_1, :param_2)") + "IN (:param_1, :param_2)") def test_operator_precedence_7(self): self.assert_compile(self.table2.select( - not_(and_(self.table2.c.field == 5, - self.table2.c.field == 7))), + not_(and_(self.table2.c.field == 5, + self.table2.c.field == 7))), "SELECT op.field FROM op WHERE NOT " - "(op.field = :field_1 AND op.field = :field_2)") + "(op.field = :field_1 AND op.field = :field_2)") def test_operator_precedence_8(self): - self.assert_compile(self.table2.select(not_(self.table2.c.field == 5)), + self.assert_compile( + self.table2.select( + not_( + self.table2.c.field == 5)), "SELECT op.field FROM op WHERE op.field != :field_1") def test_operator_precedence_9(self): self.assert_compile(self.table2.select( - not_(self.table2.c.field.between(5, 6))), + not_(self.table2.c.field.between(5, 6))), "SELECT op.field FROM op WHERE " - "op.field NOT BETWEEN :field_1 AND :field_2") + "op.field NOT BETWEEN :field_1 AND :field_2") def test_operator_precedence_10(self): - self.assert_compile(self.table2.select(not_(self.table2.c.field) == 5), + self.assert_compile( + self.table2.select( + not_( + self.table2.c.field) == 5), "SELECT op.field FROM op WHERE (NOT op.field) = :param_1") def test_operator_precedence_11(self): self.assert_compile(self.table2.select( - (self.table2.c.field == self.table2.c.field).\ - between(False, True)), + (self.table2.c.field == self.table2.c.field). + between(False, True)), "SELECT op.field FROM op WHERE (op.field = op.field) " - "BETWEEN :param_1 AND :param_2") + "BETWEEN :param_1 AND :param_2") def test_operator_precedence_12(self): self.assert_compile(self.table2.select( - between((self.table2.c.field == self.table2.c.field), - False, True)), + between((self.table2.c.field == self.table2.c.field), + False, True)), "SELECT op.field FROM op WHERE (op.field = op.field) " - "BETWEEN :param_1 AND :param_2") + "BETWEEN :param_1 AND :param_2") def test_operator_precedence_13(self): - self.assert_compile(self.table2.select( - self.table2.c.field.match( - self.table2.c.field).is_(None)), + self.assert_compile( + self.table2.select( + self.table2.c.field.match( + self.table2.c.field).is_(None)), "SELECT op.field FROM op WHERE (op.field MATCH op.field) IS NULL") def test_operator_precedence_collate_1(self): @@ -839,7 +903,7 @@ class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_operator_precedence_collate_5(self): self.assert_compile( select([self.table1.c.name]).order_by( - self.table1.c.name.collate('utf-8').desc()), + self.table1.c.name.collate('utf-8').desc()), "SELECT mytable.name FROM mytable " "ORDER BY mytable.name COLLATE utf-8 DESC" ) @@ -847,7 +911,7 @@ class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_operator_precedence_collate_6(self): self.assert_compile( select([self.table1.c.name]).order_by( - self.table1.c.name.collate('utf-8').desc().nullslast()), + self.table1.c.name.collate('utf-8').desc().nullslast()), "SELECT mytable.name FROM mytable " "ORDER BY mytable.name COLLATE utf-8 DESC NULLS LAST" ) @@ -855,22 +919,22 @@ class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_operator_precedence_collate_7(self): self.assert_compile( select([self.table1.c.name]).order_by( - self.table1.c.name.collate('utf-8').asc()), + self.table1.c.name.collate('utf-8').asc()), "SELECT mytable.name FROM mytable " "ORDER BY mytable.name COLLATE utf-8 ASC" ) def test_commutative_operators(self): self.assert_compile( - literal("a") + literal("b") * literal("c"), - ":param_1 || :param_2 * :param_3" + literal("a") + literal("b") * literal("c"), + ":param_1 || :param_2 * :param_3" ) def test_op_operators(self): self.assert_compile( self.table1.select(self.table1.c.myid.op('hoho')(12) == 14), "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable WHERE (mytable.myid hoho :myid_1) = :param_1" + "mytable WHERE (mytable.myid hoho :myid_1) = :param_1" ) def test_op_operators_comma_precedence(self): @@ -893,6 +957,7 @@ class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile(op2, "mytable.myid hoho :myid_1 lala :param_1") self.assert_compile(op3, "(mytable.myid hoho :myid_1) lala :param_1") + class OperatorAssociativityTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' @@ -912,7 +977,6 @@ class OperatorAssociativityTest(fixtures.TestBase, testing.AssertsCompiledSQL): f = column('f') self.assert_compile((f - f).label('foo') - f, "(f - f) - f") - def test_associativity_5(self): f = column('f') self.assert_compile(f - (f - f), "f - (f - f)") @@ -985,12 +1049,13 @@ class OperatorAssociativityTest(fixtures.TestBase, testing.AssertsCompiledSQL): f = column('f') self.assert_compile(f / (f / (f - f)), "f / (f / (f - f))") + class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - ) + column('myid', Integer), + ) table2 = table( 'myothertable', column('otherid', Integer), @@ -999,152 +1064,164 @@ class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_in_1(self): self.assert_compile(self.table1.c.myid.in_(['a']), - "mytable.myid IN (:myid_1)") + "mytable.myid IN (:myid_1)") def test_in_2(self): self.assert_compile(~self.table1.c.myid.in_(['a']), - "mytable.myid NOT IN (:myid_1)") + "mytable.myid NOT IN (:myid_1)") def test_in_3(self): self.assert_compile(self.table1.c.myid.in_(['a', 'b']), - "mytable.myid IN (:myid_1, :myid_2)") + "mytable.myid IN (:myid_1, :myid_2)") def test_in_4(self): self.assert_compile(self.table1.c.myid.in_(iter(['a', 'b'])), - "mytable.myid IN (:myid_1, :myid_2)") + "mytable.myid IN (:myid_1, :myid_2)") def test_in_5(self): self.assert_compile(self.table1.c.myid.in_([literal('a')]), - "mytable.myid IN (:param_1)") + "mytable.myid IN (:param_1)") def test_in_6(self): self.assert_compile(self.table1.c.myid.in_([literal('a'), 'b']), - "mytable.myid IN (:param_1, :myid_1)") + "mytable.myid IN (:param_1, :myid_1)") def test_in_7(self): self.assert_compile( - self.table1.c.myid.in_([literal('a'), literal('b')]), - "mytable.myid IN (:param_1, :param_2)") + self.table1.c.myid.in_([literal('a'), literal('b')]), + "mytable.myid IN (:param_1, :param_2)") def test_in_8(self): self.assert_compile(self.table1.c.myid.in_(['a', literal('b')]), - "mytable.myid IN (:myid_1, :param_1)") + "mytable.myid IN (:myid_1, :param_1)") def test_in_9(self): self.assert_compile(self.table1.c.myid.in_([literal(1) + 'a']), - "mytable.myid IN (:param_1 + :param_2)") + "mytable.myid IN (:param_1 + :param_2)") def test_in_10(self): self.assert_compile(self.table1.c.myid.in_([literal('a') + 'a', 'b']), - "mytable.myid IN (:param_1 || :param_2, :myid_1)") + "mytable.myid IN (:param_1 || :param_2, :myid_1)") def test_in_11(self): - self.assert_compile(self.table1.c.myid.in_([literal('a') + \ - literal('a'), literal('b')]), - "mytable.myid IN (:param_1 || :param_2, :param_3)") + self.assert_compile( + self.table1.c.myid.in_( + [ + literal('a') + + literal('a'), + literal('b')]), + "mytable.myid IN (:param_1 || :param_2, :param_3)") def test_in_12(self): self.assert_compile(self.table1.c.myid.in_([1, literal(3) + 4]), - "mytable.myid IN (:myid_1, :param_1 + :param_2)") + "mytable.myid IN (:myid_1, :param_1 + :param_2)") def test_in_13(self): self.assert_compile(self.table1.c.myid.in_([literal('a') < 'b']), - "mytable.myid IN (:param_1 < :param_2)") + "mytable.myid IN (:param_1 < :param_2)") def test_in_14(self): self.assert_compile(self.table1.c.myid.in_([self.table1.c.myid]), - "mytable.myid IN (mytable.myid)") + "mytable.myid IN (mytable.myid)") def test_in_15(self): self.assert_compile(self.table1.c.myid.in_(['a', self.table1.c.myid]), - "mytable.myid IN (:myid_1, mytable.myid)") + "mytable.myid IN (:myid_1, mytable.myid)") def test_in_16(self): self.assert_compile(self.table1.c.myid.in_([literal('a'), - self.table1.c.myid]), - "mytable.myid IN (:param_1, mytable.myid)") + self.table1.c.myid]), + "mytable.myid IN (:param_1, mytable.myid)") def test_in_17(self): - self.assert_compile(self.table1.c.myid.in_([literal('a'), \ - self.table1.c.myid + 'a']), - "mytable.myid IN (:param_1, mytable.myid + :myid_1)") + self.assert_compile( + self.table1.c.myid.in_( + [ + literal('a'), + self.table1.c.myid + + 'a']), + "mytable.myid IN (:param_1, mytable.myid + :myid_1)") def test_in_18(self): - self.assert_compile(self.table1.c.myid.in_([literal(1), 'a' + \ - self.table1.c.myid]), - "mytable.myid IN (:param_1, :myid_1 + mytable.myid)") + self.assert_compile( + self.table1.c.myid.in_( + [ + literal(1), + 'a' + + self.table1.c.myid]), + "mytable.myid IN (:param_1, :myid_1 + mytable.myid)") def test_in_19(self): self.assert_compile(self.table1.c.myid.in_([1, 2, 3]), - "mytable.myid IN (:myid_1, :myid_2, :myid_3)") + "mytable.myid IN (:myid_1, :myid_2, :myid_3)") def test_in_20(self): self.assert_compile(self.table1.c.myid.in_( - select([self.table2.c.otherid])), - "mytable.myid IN (SELECT myothertable.otherid FROM myothertable)") + select([self.table2.c.otherid])), + "mytable.myid IN (SELECT myothertable.otherid FROM myothertable)") def test_in_21(self): self.assert_compile(~self.table1.c.myid.in_( select([self.table2.c.otherid])), - "mytable.myid NOT IN (SELECT myothertable.otherid FROM myothertable)") + "mytable.myid NOT IN (SELECT myothertable.otherid FROM myothertable)") def test_in_22(self): self.assert_compile( - self.table1.c.myid.in_( - text("SELECT myothertable.otherid FROM myothertable") - ), - "mytable.myid IN (SELECT myothertable.otherid " - "FROM myothertable)" + self.table1.c.myid.in_( + text("SELECT myothertable.otherid FROM myothertable") + ), + "mytable.myid IN (SELECT myothertable.otherid " + "FROM myothertable)" ) @testing.emits_warning('.*empty sequence.*') def test_in_23(self): self.assert_compile(self.table1.c.myid.in_([]), - "mytable.myid != mytable.myid") + "mytable.myid != mytable.myid") def test_in_24(self): self.assert_compile( select([self.table1.c.myid.in_(select([self.table2.c.otherid]))]), "SELECT mytable.myid IN (SELECT myothertable.otherid " - "FROM myothertable) AS anon_1 FROM mytable" + "FROM myothertable) AS anon_1 FROM mytable" ) def test_in_25(self): self.assert_compile( select([self.table1.c.myid.in_( - select([self.table2.c.otherid]).as_scalar())]), + select([self.table2.c.otherid]).as_scalar())]), "SELECT mytable.myid IN (SELECT myothertable.otherid " - "FROM myothertable) AS anon_1 FROM mytable" + "FROM myothertable) AS anon_1 FROM mytable" ) def test_in_26(self): self.assert_compile(self.table1.c.myid.in_( union( - select([self.table1.c.myid], self.table1.c.myid == 5), - select([self.table1.c.myid], self.table1.c.myid == 12), + select([self.table1.c.myid], self.table1.c.myid == 5), + select([self.table1.c.myid], self.table1.c.myid == 12), ) - ), "mytable.myid IN ("\ - "SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1 "\ - "UNION SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_2)") + ), "mytable.myid IN (" + "SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1 " + "UNION SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_2)") def test_in_27(self): # test that putting a select in an IN clause does not # blow away its ORDER BY clause self.assert_compile( select([self.table1, self.table2], - self.table2.c.otherid.in_( - select([self.table2.c.otherid], - order_by=[self.table2.c.othername], - limit=10, correlate=False) - ), + self.table2.c.otherid.in_( + select([self.table2.c.otherid], + order_by=[self.table2.c.othername], + limit=10, correlate=False) + ), from_obj=[self.table1.join(self.table2, - self.table1.c.myid == self.table2.c.otherid)], + self.table1.c.myid == self.table2.c.otherid)], order_by=[self.table1.c.myid] ), "SELECT mytable.myid, " - "myothertable.otherid, myothertable.othername FROM mytable "\ + "myothertable.otherid, myothertable.othername FROM mytable " "JOIN myothertable ON mytable.myid = myothertable.otherid " - "WHERE myothertable.otherid IN (SELECT myothertable.otherid "\ + "WHERE myothertable.otherid IN (SELECT myothertable.otherid " "FROM myothertable ORDER BY myothertable.othername " "LIMIT :param_1) ORDER BY mytable.myid", {'param_1': 10} @@ -1159,20 +1236,20 @@ class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): @testing.emits_warning('.*empty sequence.*') def test_in_29(self): self.assert_compile(self.table1.c.myid.notin_([]), - "mytable.myid = mytable.myid") + "mytable.myid = mytable.myid") @testing.emits_warning('.*empty sequence.*') def test_in_30(self): self.assert_compile(~self.table1.c.myid.in_([]), - "mytable.myid = mytable.myid") + "mytable.myid = mytable.myid") class MathOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - ) + column('myid', Integer), + ) def _test_math_op(self, py_op, sql_op): for (lhs, rhs, res) in ( @@ -1181,11 +1258,11 @@ class MathOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): (self.table1.c.myid, 'b', 'mytable.myid %s :myid_1'), (self.table1.c.myid, literal(2.7), 'mytable.myid %s :param_1'), (self.table1.c.myid, self.table1.c.myid, - 'mytable.myid %s mytable.myid'), + 'mytable.myid %s mytable.myid'), (literal(5), 8, ':param_1 %s :param_2'), (literal(6), self.table1.c.myid, ':param_1 %s mytable.myid'), (literal(7), literal(5.5), ':param_1 %s :param_2'), - ): + ): self.assert_compile(py_op(lhs, rhs), res % sql_op) def test_math_op_add(self): @@ -1203,17 +1280,18 @@ class MathOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): else: self._test_math_op(operator.div, '/') + class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - ) + column('myid', Integer), + ) def test_pickle_operators_one(self): clause = (self.table1.c.myid == 12) & \ - self.table1.c.myid.between(15, 20) & \ - self.table1.c.myid.like('hoho') + self.table1.c.myid.between(15, 20) & \ + self.table1.c.myid.like('hoho') eq_(str(clause), str(util.pickle.loads(util.pickle.dumps(clause)))) def test_pickle_operators_two(self): @@ -1228,13 +1306,13 @@ class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): (self.table1.c.myid, 'b', 'mytable.myid', ':myid_1'), (self.table1.c.myid, literal('b'), 'mytable.myid', ':param_1'), (self.table1.c.myid, self.table1.c.myid, - 'mytable.myid', 'mytable.myid'), + 'mytable.myid', 'mytable.myid'), (literal('a'), 'b', ':param_1', ':param_2'), (literal('a'), self.table1.c.myid, ':param_1', 'mytable.myid'), (literal('a'), literal('b'), ':param_1', ':param_2'), (dt, literal('b'), ':param_2', ':param_1'), (literal('b'), dt, ':param_1', ':param_2'), - ): + ): # the compiled clause should match either (e.g.): # 'a' < 'b' -or- 'b' > 'a'. @@ -1264,7 +1342,9 @@ class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_comparison_operators_ge(self): self._test_comparison_op(operator.ge, '>=', '<=') + class NonZeroTest(fixtures.TestBase): + def _raises(self, expr): assert_raises_message( TypeError, @@ -1316,13 +1396,14 @@ class NonZeroTest(fixtures.TestBase): expr2 = (c1 > 5).label(None) self._assert_false(expr1 == expr2) + class NegationTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + column('myid', Integer), + column('name', String), + ) def test_negate_operators_1(self): for (py_op, op) in ( @@ -1337,187 +1418,188 @@ class NegationTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_negate_operators_2(self): self.assert_compile( - self.table1.select((self.table1.c.myid != 12) & - ~(self.table1.c.name == 'john')), - "SELECT mytable.myid, mytable.name FROM " + self.table1.select((self.table1.c.myid != 12) & + ~(self.table1.c.name == 'john')), + "SELECT mytable.myid, mytable.name FROM " "mytable WHERE mytable.myid != :myid_1 " "AND mytable.name != :name_1" ) def test_negate_operators_3(self): self.assert_compile( - self.table1.select((self.table1.c.myid != 12) & - ~(self.table1.c.name.between('jack', 'john'))), - "SELECT mytable.myid, mytable.name FROM " - "mytable WHERE mytable.myid != :myid_1 AND "\ - "mytable.name NOT BETWEEN :name_1 AND :name_2" + self.table1.select((self.table1.c.myid != 12) & + ~(self.table1.c.name.between('jack', 'john'))), + "SELECT mytable.myid, mytable.name FROM " + "mytable WHERE mytable.myid != :myid_1 AND " + "mytable.name NOT BETWEEN :name_1 AND :name_2" ) def test_negate_operators_4(self): self.assert_compile( - self.table1.select((self.table1.c.myid != 12) & - ~and_(self.table1.c.name == 'john', - self.table1.c.name == 'ed', - self.table1.c.name == 'fred')), - "SELECT mytable.myid, mytable.name FROM " - "mytable WHERE mytable.myid != :myid_1 AND "\ - "NOT (mytable.name = :name_1 AND mytable.name = :name_2 " - "AND mytable.name = :name_3)" + self.table1.select((self.table1.c.myid != 12) & + ~and_(self.table1.c.name == 'john', + self.table1.c.name == 'ed', + self.table1.c.name == 'fred')), + "SELECT mytable.myid, mytable.name FROM " + "mytable WHERE mytable.myid != :myid_1 AND " + "NOT (mytable.name = :name_1 AND mytable.name = :name_2 " + "AND mytable.name = :name_3)" ) def test_negate_operators_5(self): self.assert_compile( - self.table1.select((self.table1.c.myid != 12) & ~self.table1.c.name), - "SELECT mytable.myid, mytable.name FROM " - "mytable WHERE mytable.myid != :myid_1 AND NOT mytable.name" - ) - + self.table1.select( + (self.table1.c.myid != 12) & ~self.table1.c.name), + "SELECT mytable.myid, mytable.name FROM " + "mytable WHERE mytable.myid != :myid_1 AND NOT mytable.name") class LikeTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + column('myid', Integer), + column('name', String), + ) def test_like_1(self): self.assert_compile( - self.table1.c.myid.like('somstr'), - "mytable.myid LIKE :myid_1") + self.table1.c.myid.like('somstr'), + "mytable.myid LIKE :myid_1") def test_like_2(self): self.assert_compile( - ~self.table1.c.myid.like('somstr'), - "mytable.myid NOT LIKE :myid_1") + ~self.table1.c.myid.like('somstr'), + "mytable.myid NOT LIKE :myid_1") def test_like_3(self): self.assert_compile( - self.table1.c.myid.like('somstr', escape='\\'), - "mytable.myid LIKE :myid_1 ESCAPE '\\'") + self.table1.c.myid.like('somstr', escape='\\'), + "mytable.myid LIKE :myid_1 ESCAPE '\\'") def test_like_4(self): self.assert_compile( - ~self.table1.c.myid.like('somstr', escape='\\'), - "mytable.myid NOT LIKE :myid_1 ESCAPE '\\'") + ~self.table1.c.myid.like('somstr', escape='\\'), + "mytable.myid NOT LIKE :myid_1 ESCAPE '\\'") def test_like_5(self): self.assert_compile( - self.table1.c.myid.ilike('somstr', escape='\\'), - "lower(mytable.myid) LIKE lower(:myid_1) ESCAPE '\\'") + self.table1.c.myid.ilike('somstr', escape='\\'), + "lower(mytable.myid) LIKE lower(:myid_1) ESCAPE '\\'") def test_like_6(self): self.assert_compile( - ~self.table1.c.myid.ilike('somstr', escape='\\'), - "lower(mytable.myid) NOT LIKE lower(:myid_1) ESCAPE '\\'") + ~self.table1.c.myid.ilike('somstr', escape='\\'), + "lower(mytable.myid) NOT LIKE lower(:myid_1) ESCAPE '\\'") def test_like_7(self): self.assert_compile( - self.table1.c.myid.ilike('somstr', escape='\\'), - "mytable.myid ILIKE %(myid_1)s ESCAPE '\\\\'", - dialect=postgresql.dialect()) + self.table1.c.myid.ilike('somstr', escape='\\'), + "mytable.myid ILIKE %(myid_1)s ESCAPE '\\\\'", + dialect=postgresql.dialect()) def test_like_8(self): self.assert_compile( - ~self.table1.c.myid.ilike('somstr', escape='\\'), - "mytable.myid NOT ILIKE %(myid_1)s ESCAPE '\\\\'", - dialect=postgresql.dialect()) + ~self.table1.c.myid.ilike('somstr', escape='\\'), + "mytable.myid NOT ILIKE %(myid_1)s ESCAPE '\\\\'", + dialect=postgresql.dialect()) def test_like_9(self): self.assert_compile( - self.table1.c.name.ilike('%something%'), - "lower(mytable.name) LIKE lower(:name_1)") + self.table1.c.name.ilike('%something%'), + "lower(mytable.name) LIKE lower(:name_1)") def test_like_10(self): self.assert_compile( - self.table1.c.name.ilike('%something%'), - "mytable.name ILIKE %(name_1)s", - dialect=postgresql.dialect()) + self.table1.c.name.ilike('%something%'), + "mytable.name ILIKE %(name_1)s", + dialect=postgresql.dialect()) def test_like_11(self): self.assert_compile( - ~self.table1.c.name.ilike('%something%'), - "lower(mytable.name) NOT LIKE lower(:name_1)") + ~self.table1.c.name.ilike('%something%'), + "lower(mytable.name) NOT LIKE lower(:name_1)") def test_like_12(self): self.assert_compile( - ~self.table1.c.name.ilike('%something%'), - "mytable.name NOT ILIKE %(name_1)s", - dialect=postgresql.dialect()) + ~self.table1.c.name.ilike('%something%'), + "mytable.name NOT ILIKE %(name_1)s", + dialect=postgresql.dialect()) + class BetweenTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + column('myid', Integer), + column('name', String), + ) def test_between_1(self): self.assert_compile( - self.table1.c.myid.between(1, 2), - "mytable.myid BETWEEN :myid_1 AND :myid_2") + self.table1.c.myid.between(1, 2), + "mytable.myid BETWEEN :myid_1 AND :myid_2") def test_between_2(self): self.assert_compile( - ~self.table1.c.myid.between(1, 2), - "mytable.myid NOT BETWEEN :myid_1 AND :myid_2") + ~self.table1.c.myid.between(1, 2), + "mytable.myid NOT BETWEEN :myid_1 AND :myid_2") def test_between_3(self): self.assert_compile( - self.table1.c.myid.between(1, 2, symmetric=True), - "mytable.myid BETWEEN SYMMETRIC :myid_1 AND :myid_2") + self.table1.c.myid.between(1, 2, symmetric=True), + "mytable.myid BETWEEN SYMMETRIC :myid_1 AND :myid_2") def test_between_4(self): self.assert_compile( - ~self.table1.c.myid.between(1, 2, symmetric=True), - "mytable.myid NOT BETWEEN SYMMETRIC :myid_1 AND :myid_2") + ~self.table1.c.myid.between(1, 2, symmetric=True), + "mytable.myid NOT BETWEEN SYMMETRIC :myid_1 AND :myid_2") def test_between_5(self): self.assert_compile( - between(self.table1.c.myid, 1, 2, symmetric=True), - "mytable.myid BETWEEN SYMMETRIC :myid_1 AND :myid_2") + between(self.table1.c.myid, 1, 2, symmetric=True), + "mytable.myid BETWEEN SYMMETRIC :myid_1 AND :myid_2") def test_between_6(self): self.assert_compile( - ~between(self.table1.c.myid, 1, 2, symmetric=True), - "mytable.myid NOT BETWEEN SYMMETRIC :myid_1 AND :myid_2") - + ~between(self.table1.c.myid, 1, 2, symmetric=True), + "mytable.myid NOT BETWEEN SYMMETRIC :myid_1 AND :myid_2") class MatchTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + column('myid', Integer), + column('name', String), + ) def test_match_1(self): self.assert_compile(self.table1.c.myid.match('somstr'), - "mytable.myid MATCH ?", - dialect=sqlite.dialect()) + "mytable.myid MATCH ?", + dialect=sqlite.dialect()) def test_match_2(self): - self.assert_compile(self.table1.c.myid.match('somstr'), - "MATCH (mytable.myid) AGAINST (%s IN BOOLEAN MODE)", - dialect=mysql.dialect()) + self.assert_compile( + self.table1.c.myid.match('somstr'), + "MATCH (mytable.myid) AGAINST (%s IN BOOLEAN MODE)", + dialect=mysql.dialect()) def test_match_3(self): self.assert_compile(self.table1.c.myid.match('somstr'), - "CONTAINS (mytable.myid, :myid_1)", - dialect=mssql.dialect()) + "CONTAINS (mytable.myid, :myid_1)", + dialect=mssql.dialect()) def test_match_4(self): self.assert_compile(self.table1.c.myid.match('somstr'), - "mytable.myid @@ to_tsquery(%(myid_1)s)", - dialect=postgresql.dialect()) + "mytable.myid @@ to_tsquery(%(myid_1)s)", + dialect=postgresql.dialect()) def test_match_5(self): self.assert_compile(self.table1.c.myid.match('somstr'), - "CONTAINS (mytable.myid, :myid_1)", - dialect=oracle.dialect()) + "CONTAINS (mytable.myid, :myid_1)", + dialect=oracle.dialect()) + class ComposedLikeOperatorsTest(fixtures.TestBase, testing.AssertsCompiledSQL): __dialect__ = 'default' @@ -1760,7 +1842,9 @@ class ComposedLikeOperatorsTest(fixtures.TestBase, testing.AssertsCompiledSQL): dialect=mysql.dialect() ) + class CustomOpTest(fixtures.TestBase): + def test_is_comparison(self): c = column('x') c2 = column('y') @@ -1770,6 +1854,7 @@ class CustomOpTest(fixtures.TestBase): assert operators.is_comparison(op1) assert not operators.is_comparison(op2) + class TupleTypingTest(fixtures.TestBase): def _assert_types(self, expr): @@ -1778,13 +1863,19 @@ class TupleTypingTest(fixtures.TestBase): eq_(expr.clauses[2].type._type_affinity, LargeBinary()._type_affinity) def test_type_coersion_on_eq(self): - a, b, c = column('a', Integer), column('b', String), column('c', LargeBinary) + a, b, c = column( + 'a', Integer), column( + 'b', String), column( + 'c', LargeBinary) t1 = tuple_(a, b, c) expr = t1 == (3, 'hi', 'there') self._assert_types(expr.right) def test_type_coersion_on_in(self): - a, b, c = column('a', Integer), column('b', String), column('c', LargeBinary) + a, b, c = column( + 'a', Integer), column( + 'b', String), column( + 'c', LargeBinary) t1 = tuple_(a, b, c) expr = t1.in_([(3, 'hi', 'there'), (4, 'Q', 'P')]) eq_(len(expr.right.clauses), 2) diff --git a/test/sql/test_query.py b/test/sql/test_query.py index 48d9295fb..039e8d7e5 100644 --- a/test/sql/test_query.py +++ b/test/sql/test_query.py @@ -40,7 +40,7 @@ class QueryTest(fixtures.TestBase): Column('user_id', Integer, ForeignKey('query_users.user_id')), Column('address', String(30)), test_needs_acid=True - ) + ) users2 = Table( 'u2', metadata, @@ -237,6 +237,7 @@ class QueryTest(fixtures.TestBase): eng = engines.testing_engine() class ExcCtx(sqlite.base.SQLiteExecutionContext): + def get_lastrowid(self): return 0 eng.dialect.execution_ctx_cls = ExcCtx @@ -482,6 +483,7 @@ class QueryTest(fixtures.TestBase): row = testing.db.execute(select([1])).first() class unprintable(object): + def __str__(self): raise ValueError("nope") @@ -1436,6 +1438,7 @@ class RequiredBindTest(fixtures.TablesTest): class TableInsertTest(fixtures.TablesTest): + """test for consistent insert behavior across dialects regarding the inline=True flag, lower-case 't' tables. @@ -1907,6 +1910,7 @@ class LimitTest(fixtures.TestBase): class CompoundTest(fixtures.TestBase): + """test compound statements like UNION, INTERSECT, particularly their ability to nest on different databases.""" @@ -2212,6 +2216,7 @@ t1 = t2 = t3 = None class JoinTest(fixtures.TestBase): + """Tests join execution. The compiled SQL emitted by the dialect might be ANSI joins or @@ -2260,7 +2265,7 @@ class JoinTest(fixtures.TestBase): """Execute a statement and assert that rows returned equal expected.""" found = sorted([tuple(row) - for row in statement.execute().fetchall()]) + for row in statement.execute().fetchall()]) eq_(found, sorted(expected)) diff --git a/test/sql/test_quote.py b/test/sql/test_quote.py index 6a8abde0b..6b0ab4ece 100644 --- a/test/sql/test_quote.py +++ b/test/sql/test_quote.py @@ -6,6 +6,7 @@ from sqlalchemy import testing from sqlalchemy.sql.elements import quoted_name, _truncated_label, _anonymous_label from sqlalchemy.testing.util import picklers + class QuoteExecTest(fixtures.TestBase): __backend__ = True @@ -19,14 +20,14 @@ class QuoteExecTest(fixtures.TestBase): metadata = MetaData(testing.db) table1 = Table('WorstCase1', metadata, - Column('lowercase', Integer, primary_key=True), - Column('UPPERCASE', Integer), - Column('MixedCase', Integer), - Column('ASC', Integer, key='a123')) + Column('lowercase', Integer, primary_key=True), + Column('UPPERCASE', Integer), + Column('MixedCase', Integer), + Column('ASC', Integer, key='a123')) table2 = Table('WorstCase2', metadata, - Column('desc', Integer, primary_key=True, key='d123'), - Column('Union', Integer, key='u123'), - Column('MixedCase', Integer)) + Column('desc', Integer, primary_key=True, key='d123'), + Column('Union', Integer, key='u123'), + Column('MixedCase', Integer)) table1.create() table2.create() @@ -70,25 +71,25 @@ class QuoteExecTest(fixtures.TestBase): else: testing.db.execute("CREATE TABLE tab1 (id INTEGER)") testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("tab2")) + preparer.quote_identifier("tab2")) testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("TAB3")) + preparer.quote_identifier("TAB3")) testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("TAB4")) + preparer.quote_identifier("TAB4")) t1 = Table('tab1', self.metadata, - Column('id', Integer, primary_key=True), - ) + Column('id', Integer, primary_key=True), + ) t2 = Table('tab2', self.metadata, - Column('id', Integer, primary_key=True), - quote=True - ) + Column('id', Integer, primary_key=True), + quote=True + ) t3 = Table('TAB3', self.metadata, - Column('id', Integer, primary_key=True), - ) + Column('id', Integer, primary_key=True), + ) t4 = Table('TAB4', self.metadata, - Column('id', Integer, primary_key=True), - quote=True) + Column('id', Integer, primary_key=True), + quote=True) insp = inspect(testing.db) assert testing.db.has_table(t1.name) @@ -103,8 +104,6 @@ class QuoteExecTest(fixtures.TestBase): assert testing.db.has_table(t4.name) eq_([c['name'] for c in insp.get_columns(t4.name)], ['id']) - - def test_basic(self): table1.insert().execute( {'lowercase': 1, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4}, @@ -159,6 +158,7 @@ class QuoteExecTest(fixtures.TestBase): result = select(columns, use_labels=True).execute().fetchall() assert(result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)]) + class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -172,14 +172,14 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): metadata = MetaData(testing.db) table1 = Table('WorstCase1', metadata, - Column('lowercase', Integer, primary_key=True), - Column('UPPERCASE', Integer), - Column('MixedCase', Integer), - Column('ASC', Integer, key='a123')) + Column('lowercase', Integer, primary_key=True), + Column('UPPERCASE', Integer), + Column('MixedCase', Integer), + Column('ASC', Integer, key='a123')) table2 = Table('WorstCase2', metadata, - Column('desc', Integer, primary_key=True, key='d123'), - Column('Union', Integer, key='u123'), - Column('MixedCase', Integer)) + Column('desc', Integer, primary_key=True, key='d123'), + Column('Union', Integer, key='u123'), + Column('MixedCase', Integer)) @testing.crashes('oracle', 'FIXME: unknown, verify not fails_on') @testing.requires.subqueries @@ -206,17 +206,17 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table1.select(distinct=True).alias('LaLa').select(), 'SELECT ' - '"LaLa".lowercase, ' - '"LaLa"."UPPERCASE", ' - '"LaLa"."MixedCase", ' - '"LaLa"."ASC" ' + '"LaLa".lowercase, ' + '"LaLa"."UPPERCASE", ' + '"LaLa"."MixedCase", ' + '"LaLa"."ASC" ' 'FROM (' - 'SELECT DISTINCT ' - '"WorstCase1".lowercase AS lowercase, ' - '"WorstCase1"."UPPERCASE" AS "UPPERCASE", ' - '"WorstCase1"."MixedCase" AS "MixedCase", ' - '"WorstCase1"."ASC" AS "ASC" ' - 'FROM "WorstCase1"' + 'SELECT DISTINCT ' + '"WorstCase1".lowercase AS lowercase, ' + '"WorstCase1"."UPPERCASE" AS "UPPERCASE", ' + '"WorstCase1"."MixedCase" AS "MixedCase", ' + '"WorstCase1"."ASC" AS "ASC" ' + 'FROM "WorstCase1"' ') AS "LaLa"' ) @@ -224,8 +224,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer), - schema='foo') + Column('col1', Integer), + schema='foo') # Note that the names are not quoted b/c they are all lower case result = 'CREATE TABLE foo.t1 (col1 INTEGER)' @@ -234,8 +234,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create the same table with quotes set to True now metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer, quote=True), - schema='foo', quote=True, quote_schema=True) + Column('col1', Integer, quote=True), + schema='foo', quote=True, quote_schema=True) # Note that the names are now quoted result = 'CREATE TABLE "foo"."t1" ("col1" INTEGER)' @@ -245,8 +245,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() t1 = Table('TABLE1', metadata, - Column('COL1', Integer), - schema='FOO') + Column('COL1', Integer), + schema='FOO') # Note that the names are quoted b/c they are not all lower case result = 'CREATE TABLE "FOO"."TABLE1" ("COL1" INTEGER)' @@ -255,8 +255,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create the same table with quotes set to False now metadata = MetaData() t1 = Table('TABLE1', metadata, - Column('COL1', Integer, quote=False), - schema='FOO', quote=False, quote_schema=False) + Column('COL1', Integer, quote=False), + schema='FOO', quote=False, quote_schema=False) # Note that the names are now unquoted result = 'CREATE TABLE FOO.TABLE1 (COL1 INTEGER)' @@ -266,8 +266,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() t1 = Table('Table1', metadata, - Column('Col1', Integer), - schema='Foo') + Column('Col1', Integer), + schema='Foo') # Note that the names are quoted b/c they are not all lower case result = 'CREATE TABLE "Foo"."Table1" ("Col1" INTEGER)' @@ -276,8 +276,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create the same table with quotes set to False now metadata = MetaData() t1 = Table('Table1', metadata, - Column('Col1', Integer, quote=False), - schema='Foo', quote=False, quote_schema=False) + Column('Col1', Integer, quote=False), + schema='Foo', quote=False, quote_schema=False) # Note that the names are now unquoted result = 'CREATE TABLE Foo.Table1 (Col1 INTEGER)' @@ -287,8 +287,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() t1 = Table('35table', metadata, - Column('25column', Integer), - schema='45schema') + Column('25column', Integer), + schema='45schema') # Note that the names are quoted b/c the initial # character is in ['$','0', '1' ... '9'] @@ -298,8 +298,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create the same table with quotes set to False now metadata = MetaData() t1 = Table('35table', metadata, - Column('25column', Integer, quote=False), - schema='45schema', quote=False, quote_schema=False) + Column('25column', Integer, quote=False), + schema='45schema', quote=False, quote_schema=False) # Note that the names are now unquoted result = 'CREATE TABLE 45schema.35table (25column INTEGER)' @@ -309,8 +309,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() t1 = Table('$table', metadata, - Column('$column', Integer), - schema='$schema') + Column('$column', Integer), + schema='$schema') # Note that the names are quoted b/c the initial # character is in ['$','0', '1' ... '9'] @@ -320,8 +320,8 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create the same table with quotes set to False now metadata = MetaData() t1 = Table('$table', metadata, - Column('$column', Integer, quote=False), - schema='$schema', quote=False, quote_schema=False) + Column('$column', Integer, quote=False), + schema='$schema', quote=False, quote_schema=False) # Note that the names are now unquoted result = 'CREATE TABLE $schema.$table ($column INTEGER)' @@ -331,117 +331,117 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Create table with quote defaults metadata = MetaData() table = Table('foreign', metadata, - Column('col1', Integer), - Column('from', Integer), - Column('order', Integer), - schema='create') + Column('col1', Integer), + Column('from', Integer), + Column('order', Integer), + schema='create') # Note that the names are quoted b/c they are reserved words x = select([table.c.col1, table.c['from'], table.c.order]) self.assert_compile(x, - 'SELECT ' - '"create"."foreign".col1, ' - '"create"."foreign"."from", ' - '"create"."foreign"."order" ' - 'FROM "create"."foreign"' - ) + 'SELECT ' + '"create"."foreign".col1, ' + '"create"."foreign"."from", ' + '"create"."foreign"."order" ' + 'FROM "create"."foreign"' + ) # Create the same table with quotes set to False now metadata = MetaData() table = Table('foreign', metadata, - Column('col1', Integer), - Column('from', Integer, quote=False), - Column('order', Integer, quote=False), - schema='create', quote=False, quote_schema=False) + Column('col1', Integer), + Column('from', Integer, quote=False), + Column('order', Integer, quote=False), + schema='create', quote=False, quote_schema=False) # Note that the names are now unquoted x = select([table.c.col1, table.c['from'], table.c.order]) self.assert_compile(x, - 'SELECT ' - 'create.foreign.col1, ' - 'create.foreign.from, ' - 'create.foreign.order ' - 'FROM create.foreign' - ) + 'SELECT ' + 'create.foreign.col1, ' + 'create.foreign.from, ' + 'create.foreign.order ' + 'FROM create.foreign' + ) def test_subquery_one(self): # Lower case names, should not quote metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer), - schema='foo') + Column('col1', Integer), + schema='foo') a = t1.select().alias('anon') b = select([1], a.c.col1 == 2, from_obj=a) self.assert_compile(b, - 'SELECT 1 ' - 'FROM (' - 'SELECT ' - 'foo.t1.col1 AS col1 ' - 'FROM ' - 'foo.t1' - ') AS anon ' - 'WHERE anon.col1 = :col1_1' - ) + 'SELECT 1 ' + 'FROM (' + 'SELECT ' + 'foo.t1.col1 AS col1 ' + 'FROM ' + 'foo.t1' + ') AS anon ' + 'WHERE anon.col1 = :col1_1' + ) def test_subquery_two(self): # Lower case names, quotes on, should quote metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer, quote=True), - schema='foo', quote=True, quote_schema=True) + Column('col1', Integer, quote=True), + schema='foo', quote=True, quote_schema=True) a = t1.select().alias('anon') b = select([1], a.c.col1 == 2, from_obj=a) self.assert_compile(b, - 'SELECT 1 ' - 'FROM (' - 'SELECT ' - '"foo"."t1"."col1" AS "col1" ' - 'FROM ' - '"foo"."t1"' - ') AS anon ' - 'WHERE anon."col1" = :col1_1' - ) + 'SELECT 1 ' + 'FROM (' + 'SELECT ' + '"foo"."t1"."col1" AS "col1" ' + 'FROM ' + '"foo"."t1"' + ') AS anon ' + 'WHERE anon."col1" = :col1_1' + ) def test_subquery_three(self): # Not lower case names, should quote metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer), - schema='Foo') + Column('Col1', Integer), + schema='Foo') a = t1.select().alias('Anon') b = select([1], a.c.Col1 == 2, from_obj=a) self.assert_compile(b, - 'SELECT 1 ' - 'FROM (' - 'SELECT ' - '"Foo"."T1"."Col1" AS "Col1" ' - 'FROM ' - '"Foo"."T1"' - ') AS "Anon" ' - 'WHERE ' - '"Anon"."Col1" = :Col1_1' - ) + 'SELECT 1 ' + 'FROM (' + 'SELECT ' + '"Foo"."T1"."Col1" AS "Col1" ' + 'FROM ' + '"Foo"."T1"' + ') AS "Anon" ' + 'WHERE ' + '"Anon"."Col1" = :Col1_1' + ) def test_subquery_four(self): # Not lower case names, quotes off, should not quote metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer, quote=False), - schema='Foo', quote=False, quote_schema=False) + Column('Col1', Integer, quote=False), + schema='Foo', quote=False, quote_schema=False) a = t1.select().alias('Anon') b = select([1], a.c.Col1 == 2, from_obj=a) self.assert_compile(b, - 'SELECT 1 ' - 'FROM (' - 'SELECT ' - 'Foo.T1.Col1 AS Col1 ' - 'FROM ' - 'Foo.T1' - ') AS "Anon" ' - 'WHERE ' - '"Anon".Col1 = :Col1_1' - ) + 'SELECT 1 ' + 'FROM (' + 'SELECT ' + 'Foo.T1.Col1 AS Col1 ' + 'FROM ' + 'Foo.T1' + ') AS "Anon" ' + 'WHERE ' + '"Anon".Col1 = :Col1_1' + ) def test_simple_order_by_label(self): m = MetaData() @@ -456,170 +456,188 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): # Lower case names, should not quote metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer)) + Column('col1', Integer)) t2 = Table('t2', metadata, - Column('col1', Integer), - Column('t1col1', Integer, ForeignKey('t1.col1'))) + Column('col1', Integer), + Column('t1col1', Integer, ForeignKey('t1.col1'))) self.assert_compile(t2.join(t1).select(), - 'SELECT ' - 't2.col1, t2.t1col1, t1.col1 ' - 'FROM ' - 't2 ' - 'JOIN ' - 't1 ON t1.col1 = t2.t1col1' - ) + 'SELECT ' + 't2.col1, t2.t1col1, t1.col1 ' + 'FROM ' + 't2 ' + 'JOIN ' + 't1 ON t1.col1 = t2.t1col1' + ) # Lower case names, quotes on, should quote metadata = MetaData() t1 = Table('t1', metadata, - Column('col1', Integer, quote=True), - quote=True) - t2 = Table('t2', metadata, - Column('col1', Integer, quote=True), - Column('t1col1', Integer, ForeignKey('t1.col1'), quote=True), - quote=True) + Column('col1', Integer, quote=True), + quote=True) + t2 = Table( + 't2', + metadata, + Column( + 'col1', + Integer, + quote=True), + Column( + 't1col1', + Integer, + ForeignKey('t1.col1'), + quote=True), + quote=True) self.assert_compile(t2.join(t1).select(), - 'SELECT ' - '"t2"."col1", "t2"."t1col1", "t1"."col1" ' - 'FROM ' - '"t2" ' - 'JOIN ' - '"t1" ON "t1"."col1" = "t2"."t1col1"' - ) + 'SELECT ' + '"t2"."col1", "t2"."t1col1", "t1"."col1" ' + 'FROM ' + '"t2" ' + 'JOIN ' + '"t1" ON "t1"."col1" = "t2"."t1col1"' + ) # Not lower case names, should quote metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer)) + Column('Col1', Integer)) t2 = Table('T2', metadata, - Column('Col1', Integer), - Column('T1Col1', Integer, ForeignKey('T1.Col1'))) + Column('Col1', Integer), + Column('T1Col1', Integer, ForeignKey('T1.Col1'))) self.assert_compile(t2.join(t1).select(), - 'SELECT ' - '"T2"."Col1", "T2"."T1Col1", "T1"."Col1" ' - 'FROM ' - '"T2" ' - 'JOIN ' - '"T1" ON "T1"."Col1" = "T2"."T1Col1"' - ) + 'SELECT ' + '"T2"."Col1", "T2"."T1Col1", "T1"."Col1" ' + 'FROM ' + '"T2" ' + 'JOIN ' + '"T1" ON "T1"."Col1" = "T2"."T1Col1"' + ) # Not lower case names, quotes off, should not quote metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer, quote=False), - quote=False) - t2 = Table('T2', metadata, - Column('Col1', Integer, quote=False), - Column('T1Col1', Integer, ForeignKey('T1.Col1'), quote=False), - quote=False) + Column('Col1', Integer, quote=False), + quote=False) + t2 = Table( + 'T2', + metadata, + Column( + 'Col1', + Integer, + quote=False), + Column( + 'T1Col1', + Integer, + ForeignKey('T1.Col1'), + quote=False), + quote=False) self.assert_compile(t2.join(t1).select(), - 'SELECT ' - 'T2.Col1, T2.T1Col1, T1.Col1 ' - 'FROM ' - 'T2 ' - 'JOIN ' - 'T1 ON T1.Col1 = T2.T1Col1' - ) + 'SELECT ' + 'T2.Col1, T2.T1Col1, T1.Col1 ' + 'FROM ' + 'T2 ' + 'JOIN ' + 'T1 ON T1.Col1 = T2.T1Col1' + ) def test_label_and_alias(self): # Lower case names, should not quote metadata = MetaData() table = Table('t1', metadata, - Column('col1', Integer)) + Column('col1', Integer)) x = select([table.c.col1.label('label1')]).alias('alias1') self.assert_compile(select([x.c.label1]), - 'SELECT ' - 'alias1.label1 ' - 'FROM (' - 'SELECT ' - 't1.col1 AS label1 ' - 'FROM t1' - ') AS alias1' - ) + 'SELECT ' + 'alias1.label1 ' + 'FROM (' + 'SELECT ' + 't1.col1 AS label1 ' + 'FROM t1' + ') AS alias1' + ) # Not lower case names, should quote metadata = MetaData() table = Table('T1', metadata, - Column('Col1', Integer)) + Column('Col1', Integer)) x = select([table.c.Col1.label('Label1')]).alias('Alias1') self.assert_compile(select([x.c.Label1]), - 'SELECT ' - '"Alias1"."Label1" ' - 'FROM (' - 'SELECT ' - '"T1"."Col1" AS "Label1" ' - 'FROM "T1"' - ') AS "Alias1"' - ) + 'SELECT ' + '"Alias1"."Label1" ' + 'FROM (' + 'SELECT ' + '"T1"."Col1" AS "Label1" ' + 'FROM "T1"' + ') AS "Alias1"' + ) def test_literal_column_already_with_quotes(self): # Lower case names metadata = MetaData() table = Table('t1', metadata, - Column('col1', Integer)) + Column('col1', Integer)) # Note that 'col1' is already quoted (literal_column) columns = [sql.literal_column("'col1'").label('label1')] x = select(columns, from_obj=[table]).alias('alias1') x = x.select() self.assert_compile(x, - 'SELECT ' - 'alias1.label1 ' - 'FROM (' - 'SELECT ' - '\'col1\' AS label1 ' - 'FROM t1' - ') AS alias1' - ) + 'SELECT ' + 'alias1.label1 ' + 'FROM (' + 'SELECT ' + '\'col1\' AS label1 ' + 'FROM t1' + ') AS alias1' + ) # Not lower case names metadata = MetaData() table = Table('T1', metadata, - Column('Col1', Integer)) + Column('Col1', Integer)) # Note that 'Col1' is already quoted (literal_column) columns = [sql.literal_column("'Col1'").label('Label1')] x = select(columns, from_obj=[table]).alias('Alias1') x = x.select() self.assert_compile(x, - 'SELECT ' - '"Alias1"."Label1" ' - 'FROM (' - 'SELECT ' - '\'Col1\' AS "Label1" ' - 'FROM "T1"' - ') AS "Alias1"' - ) + 'SELECT ' + '"Alias1"."Label1" ' + 'FROM (' + 'SELECT ' + '\'Col1\' AS "Label1" ' + 'FROM "T1"' + ') AS "Alias1"' + ) def test_apply_labels_should_quote(self): # Not lower case names, should quote metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer), - schema='Foo') + Column('Col1', Integer), + schema='Foo') self.assert_compile(t1.select().apply_labels(), - 'SELECT ' - '"Foo"."T1"."Col1" AS "Foo_T1_Col1" ' - 'FROM ' - '"Foo"."T1"' - ) + 'SELECT ' + '"Foo"."T1"."Col1" AS "Foo_T1_Col1" ' + 'FROM ' + '"Foo"."T1"' + ) def test_apply_labels_shouldnt_quote(self): # Not lower case names, quotes off metadata = MetaData() t1 = Table('T1', metadata, - Column('Col1', Integer, quote=False), - schema='Foo', quote=False, quote_schema=False) + Column('Col1', Integer, quote=False), + schema='Foo', quote=False, quote_schema=False) # TODO: is this what we really want here ? # what if table/schema *are* quoted? self.assert_compile(t1.select().apply_labels(), - 'SELECT ' - 'Foo.T1.Col1 AS Foo_T1_Col1 ' - 'FROM ' - 'Foo.T1' - ) + 'SELECT ' + 'Foo.T1.Col1 AS Foo_T1_Col1 ' + 'FROM ' + 'Foo.T1' + ) def test_quote_flag_propagate_check_constraint(self): m = MetaData() @@ -657,7 +675,9 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): 'SELECT "t2".x AS "t2_x" FROM "t2"' ) + class PreparerTest(fixtures.TestBase): + """Test the db-agnostic quoting services of IdentifierPreparer.""" def test_unformat(self): @@ -711,7 +731,9 @@ class PreparerTest(fixtures.TestBase): a_eq(unformat('`foo`.bar'), ['foo', 'bar']) a_eq(unformat('`foo`.`b``a``r`.`baz`'), ['foo', 'b`a`r', 'baz']) + class QuotedIdentTest(fixtures.TestBase): + def test_concat_quotetrue(self): q1 = quoted_name("x", True) self._assert_not_quoted("y" + q1) @@ -802,4 +824,3 @@ class QuotedIdentTest(fixtures.TestBase): def _assert_not_quoted(self, value): assert not isinstance(value, quoted_name) - diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py index 394fe1002..26dbcdaa2 100644 --- a/test/sql/test_returning.py +++ b/test/sql/test_returning.py @@ -4,10 +4,11 @@ from sqlalchemy import testing from sqlalchemy.testing.schema import Table, Column from sqlalchemy.types import TypeDecorator from sqlalchemy.testing import fixtures, AssertsExecutionResults, engines, \ - assert_raises_message + assert_raises_message from sqlalchemy import exc as sa_exc import itertools + class ReturningTest(fixtures.TestBase, AssertsExecutionResults): __requires__ = 'returning', __backend__ = True @@ -29,29 +30,30 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults): return None return value + "BAR" - table = Table('tables', meta, - Column('id', Integer, primary_key=True, test_needs_autoincrement=True), - Column('persons', Integer), - Column('full', Boolean), - Column('goofy', GoofyType(50)) - ) + table = Table( + 'tables', meta, Column( + 'id', Integer, primary_key=True, test_needs_autoincrement=True), Column( + 'persons', Integer), Column( + 'full', Boolean), Column( + 'goofy', GoofyType(50))) table.create(checkfirst=True) def teardown(self): table.drop() def test_column_targeting(self): - result = table.insert().returning(table.c.id, table.c.full).execute({'persons': 1, 'full': False}) + result = table.insert().returning( + table.c.id, table.c.full).execute({'persons': 1, 'full': False}) row = result.first() assert row[table.c.id] == row['id'] == 1 assert row[table.c.full] == row['full'] == False result = table.insert().values(persons=5, full=True, goofy="somegoofy").\ - returning(table.c.persons, table.c.full, table.c.goofy).execute() + returning(table.c.persons, table.c.full, table.c.goofy).execute() row = result.first() assert row[table.c.persons] == row['persons'] == 5 - assert row[table.c.full] == row['full'] == True + assert row[table.c.full] == row['full'] eq_(row[table.c.goofy], row['goofy']) eq_(row['goofy'], "FOOsomegoofyBAR") @@ -59,57 +61,65 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults): @testing.fails_on('firebird', "fb can't handle returning x AS y") def test_labeling(self): result = table.insert().values(persons=6).\ - returning(table.c.persons.label('lala')).execute() + returning(table.c.persons.label('lala')).execute() row = result.first() assert row['lala'] == 6 - @testing.fails_on('firebird', "fb/kintersbasdb can't handle the bind params") + @testing.fails_on( + 'firebird', + "fb/kintersbasdb can't handle the bind params") @testing.fails_on('oracle+zxjdbc', "JDBC driver bug") def test_anon_expressions(self): result = table.insert().values(goofy="someOTHERgoofy").\ - returning(func.lower(table.c.goofy, type_=GoofyType)).execute() + returning(func.lower(table.c.goofy, type_=GoofyType)).execute() row = result.first() eq_(row[0], "foosomeothergoofyBAR") result = table.insert().values(persons=12).\ - returning(table.c.persons + 18).execute() + returning(table.c.persons + 18).execute() row = result.first() eq_(row[0], 30) def test_update_returning(self): - table.insert().execute([{'persons': 5, 'full': False}, {'persons': 3, 'full': False}]) + table.insert().execute( + [{'persons': 5, 'full': False}, {'persons': 3, 'full': False}]) - result = table.update(table.c.persons > 4, dict(full=True)).returning(table.c.id).execute() + result = table.update( + table.c.persons > 4, dict( + full=True)).returning( + table.c.id).execute() eq_(result.fetchall(), [(1,)]) - result2 = select([table.c.id, table.c.full]).order_by(table.c.id).execute() + result2 = select([table.c.id, table.c.full]).order_by( + table.c.id).execute() eq_(result2.fetchall(), [(1, True), (2, False)]) def test_insert_returning(self): - result = table.insert().returning(table.c.id).execute({'persons': 1, 'full': False}) + result = table.insert().returning( + table.c.id).execute({'persons': 1, 'full': False}) eq_(result.fetchall(), [(1,)]) @testing.requires.multivalues_inserts def test_multirow_returning(self): ins = table.insert().returning(table.c.id, table.c.persons).values( - [ - {'persons': 1, 'full': False}, - {'persons': 2, 'full': True}, - {'persons': 3, 'full': False}, - ] - ) + [ + {'persons': 1, 'full': False}, + {'persons': 2, 'full': True}, + {'persons': 3, 'full': False}, + ] + ) result = testing.db.execute(ins) eq_( - result.fetchall(), - [(1, 1), (2, 2), (3, 3)] + result.fetchall(), + [(1, 1), (2, 2), (3, 3)] ) def test_no_ipk_on_returning(self): result = testing.db.execute( - table.insert().returning(table.c.id), - {'persons': 1, 'full': False} - ) + table.insert().returning(table.c.id), + {'persons': 1, 'full': False} + ) assert_raises_message( sa_exc.InvalidRequestError, "Can't call inserted_primary_key when returning\(\) is used.", @@ -123,18 +133,25 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults): else: literal_true = "1" - result4 = testing.db.execute('insert into tables (id, persons, "full") ' - 'values (5, 10, %s) returning persons' % literal_true) + result4 = testing.db.execute( + 'insert into tables (id, persons, "full") ' + 'values (5, 10, %s) returning persons' % + literal_true) eq_([dict(row) for row in result4], [{'persons': 10}]) def test_delete_returning(self): - table.insert().execute([{'persons': 5, 'full': False}, {'persons': 3, 'full': False}]) + table.insert().execute( + [{'persons': 5, 'full': False}, {'persons': 3, 'full': False}]) - result = table.delete(table.c.persons > 4).returning(table.c.id).execute() + result = table.delete( + table.c.persons > 4).returning( + table.c.id).execute() eq_(result.fetchall(), [(1,)]) - result2 = select([table.c.id, table.c.full]).order_by(table.c.id).execute() - eq_(result2.fetchall(), [(2, False),]) + result2 = select([table.c.id, table.c.full]).order_by( + table.c.id).execute() + eq_(result2.fetchall(), [(2, False), ]) + class SequenceReturningTest(fixtures.TestBase): __requires__ = 'returning', 'sequences' @@ -145,9 +162,9 @@ class SequenceReturningTest(fixtures.TestBase): global table, seq seq = Sequence('tid_seq') table = Table('tables', meta, - Column('id', Integer, seq, primary_key=True), - Column('data', String(50)) - ) + Column('id', Integer, seq, primary_key=True), + Column('data', String(50)) + ) table.create(checkfirst=True) def teardown(self): @@ -158,7 +175,9 @@ class SequenceReturningTest(fixtures.TestBase): assert r.first() == (1, ) assert seq.execute() == 2 + class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults): + """test returning() works with columns that define 'key'.""" __requires__ = 'returning', @@ -168,9 +187,18 @@ class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults): meta = MetaData(testing.db) global table - table = Table('tables', meta, - Column('id', Integer, primary_key=True, key='foo_id', test_needs_autoincrement=True), - Column('data', String(20)), + table = Table( + 'tables', + meta, + Column( + 'id', + Integer, + primary_key=True, + key='foo_id', + test_needs_autoincrement=True), + Column( + 'data', + String(20)), ) table.create(checkfirst=True) @@ -180,7 +208,9 @@ class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults): @testing.exclude('firebird', '<', (2, 0), '2.0+ feature') @testing.exclude('postgresql', '<', (8, 2), '8.2+ feature') def test_insert(self): - result = table.insert().returning(table.c.foo_id).execute(data='somedata') + result = table.insert().returning( + table.c.foo_id).execute( + data='somedata') row = result.first() assert row[table.c.foo_id] == row['id'] == 1 @@ -207,18 +237,18 @@ class ReturnDefaultsTest(fixtures.TablesTest): def compile(element, compiler, **kw): return str(next(counter)) - Table("t1", metadata, - Column("id", Integer, primary_key=True, test_needs_autoincrement=True), - Column("data", String(50)), - Column("insdef", Integer, default=IncDefault()), - Column("upddef", Integer, onupdate=IncDefault()) - ) + Table( + "t1", metadata, Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True), Column( + "data", String(50)), Column( + "insdef", Integer, default=IncDefault()), Column( + "upddef", Integer, onupdate=IncDefault())) def test_chained_insert_pk(self): t1 = self.tables.t1 result = testing.db.execute( - t1.insert().values(upddef=1).return_defaults(t1.c.insdef) - ) + t1.insert().values(upddef=1).return_defaults(t1.c.insdef) + ) eq_( [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)], [1, 0] @@ -227,8 +257,8 @@ class ReturnDefaultsTest(fixtures.TablesTest): def test_arg_insert_pk(self): t1 = self.tables.t1 result = testing.db.execute( - t1.insert(return_defaults=[t1.c.insdef]).values(upddef=1) - ) + t1.insert(return_defaults=[t1.c.insdef]).values(upddef=1) + ) eq_( [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)], [1, 0] @@ -237,10 +267,10 @@ class ReturnDefaultsTest(fixtures.TablesTest): def test_chained_update_pk(self): t1 = self.tables.t1 testing.db.execute( - t1.insert().values(upddef=1) - ) + t1.insert().values(upddef=1) + ) result = testing.db.execute(t1.update().values(data='d1'). - return_defaults(t1.c.upddef)) + return_defaults(t1.c.upddef)) eq_( [result.returned_defaults[k] for k in (t1.c.upddef,)], [1] @@ -249,10 +279,10 @@ class ReturnDefaultsTest(fixtures.TablesTest): def test_arg_update_pk(self): t1 = self.tables.t1 testing.db.execute( - t1.insert().values(upddef=1) - ) + t1.insert().values(upddef=1) + ) result = testing.db.execute(t1.update(return_defaults=[t1.c.upddef]). - values(data='d1')) + values(data='d1')) eq_( [result.returned_defaults[k] for k in (t1.c.upddef,)], [1] @@ -264,8 +294,8 @@ class ReturnDefaultsTest(fixtures.TablesTest): t1 = self.tables.t1 result = testing.db.execute( - t1.insert().values(upddef=1).return_defaults(t1.c.data) - ) + t1.insert().values(upddef=1).return_defaults(t1.c.data) + ) eq_( [result.returned_defaults[k] for k in (t1.c.id, t1.c.data,)], [1, None] @@ -277,10 +307,12 @@ class ReturnDefaultsTest(fixtures.TablesTest): t1 = self.tables.t1 testing.db.execute( - t1.insert().values(upddef=1) - ) - result = testing.db.execute(t1.update(). - values(upddef=2).return_defaults(t1.c.data)) + t1.insert().values(upddef=1) + ) + result = testing.db.execute( + t1.update(). values( + upddef=2).return_defaults( + t1.c.data)) eq_( [result.returned_defaults[k] for k in (t1.c.data,)], [None] @@ -290,9 +322,9 @@ class ReturnDefaultsTest(fixtures.TablesTest): def test_insert_non_default_plus_default(self): t1 = self.tables.t1 result = testing.db.execute( - t1.insert().values(upddef=1).return_defaults( - t1.c.data, t1.c.insdef) - ) + t1.insert().values(upddef=1).return_defaults( + t1.c.data, t1.c.insdef) + ) eq_( dict(result.returned_defaults), {"id": 1, "data": None, "insdef": 0} @@ -302,33 +334,35 @@ class ReturnDefaultsTest(fixtures.TablesTest): def test_update_non_default_plus_default(self): t1 = self.tables.t1 testing.db.execute( - t1.insert().values(upddef=1) - ) + t1.insert().values(upddef=1) + ) result = testing.db.execute(t1.update(). - values(insdef=2).return_defaults( - t1.c.data, t1.c.upddef)) + values(insdef=2).return_defaults( + t1.c.data, t1.c.upddef)) eq_( dict(result.returned_defaults), {"data": None, 'upddef': 1} ) + class ImplicitReturningFlag(fixtures.TestBase): __backend__ = True def test_flag_turned_off(self): - e = engines.testing_engine(options={'implicit_returning':False}) + e = engines.testing_engine(options={'implicit_returning': False}) assert e.dialect.implicit_returning is False c = e.connect() assert e.dialect.implicit_returning is False def test_flag_turned_on(self): - e = engines.testing_engine(options={'implicit_returning':True}) + e = engines.testing_engine(options={'implicit_returning': True}) assert e.dialect.implicit_returning is True c = e.connect() assert e.dialect.implicit_returning is True def test_flag_turned_default(self): supports = [False] + def go(): supports[0] = True testing.requires.returning(go)() diff --git a/test/sql/test_rowcount.py b/test/sql/test_rowcount.py index 2d3c51fa2..8913b955d 100644 --- a/test/sql/test_rowcount.py +++ b/test/sql/test_rowcount.py @@ -4,6 +4,7 @@ from sqlalchemy import testing class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): + """tests rowcount functionality""" __requires__ = ('sane_rowcount', ) @@ -14,29 +15,29 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): global employees_table, metadata metadata = MetaData(testing.db) - employees_table = Table('employees', metadata, - Column('employee_id', Integer, - Sequence('employee_id_seq', optional=True), - primary_key=True), - Column('name', String(50)), - Column('department', String(1)), - ) + employees_table = Table( + 'employees', metadata, Column( + 'employee_id', Integer, Sequence( + 'employee_id_seq', optional=True), primary_key=True), Column( + 'name', String(50)), Column( + 'department', String(1)), ) metadata.create_all() def setup(self): global data - data = [ ('Angela', 'A'), - ('Andrew', 'A'), - ('Anand', 'A'), - ('Bob', 'B'), - ('Bobette', 'B'), - ('Buffy', 'B'), - ('Charlie', 'C'), - ('Cynthia', 'C'), - ('Chris', 'C') ] + data = [('Angela', 'A'), + ('Andrew', 'A'), + ('Anand', 'A'), + ('Bob', 'B'), + ('Bobette', 'B'), + ('Buffy', 'B'), + ('Charlie', 'C'), + ('Cynthia', 'C'), + ('Chris', 'C')] i = employees_table.insert() - i.execute(*[{'name':n, 'department':d} for n, d in data]) + i.execute(*[{'name': n, 'department': d} for n, d in data]) + def teardown(self): employees_table.delete().execute() @@ -53,21 +54,20 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): def test_update_rowcount1(self): # WHERE matches 3, 3 rows changed department = employees_table.c.department - r = employees_table.update(department=='C').execute(department='Z') + r = employees_table.update(department == 'C').execute(department='Z') print("expecting 3, dialect reports %s" % r.rowcount) assert r.rowcount == 3 def test_update_rowcount2(self): # WHERE matches 3, 0 rows changed department = employees_table.c.department - r = employees_table.update(department=='C').execute(department='C') + r = employees_table.update(department == 'C').execute(department='C') print("expecting 3, dialect reports %s" % r.rowcount) assert r.rowcount == 3 def test_delete_rowcount(self): # WHERE matches 3, 3 rows deleted department = employees_table.c.department - r = employees_table.delete(department=='C').execute() + r = employees_table.delete(department == 'C').execute() print("expecting 3, dialect reports %s" % r.rowcount) assert r.rowcount == 3 - diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py index 3ee8127b6..c5736b26f 100644 --- a/test/sql/test_selectable.py +++ b/test/sql/test_selectable.py @@ -14,27 +14,31 @@ from sqlalchemy.schema import Column, Table, MetaData metadata = MetaData() table1 = Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20)), - Column('col3', Integer), - Column('colx', Integer), + Column('col1', Integer, primary_key=True), + Column('col2', String(20)), + Column('col3', Integer), + Column('colx', Integer), -) + ) table2 = Table('table2', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', Integer, ForeignKey('table1.col1')), - Column('col3', String(20)), - Column('coly', Integer), -) + Column('col1', Integer, primary_key=True), + Column('col2', Integer, ForeignKey('table1.col1')), + Column('col3', String(20)), + Column('coly', Integer), + ) keyed = Table('keyed', metadata, - Column('x', Integer, key='colx'), - Column('y', Integer, key='coly'), - Column('z', Integer), -) + Column('x', Integer, key='colx'), + Column('y', Integer, key='coly'), + Column('z', Integer), + ) -class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiledSQL): + +class SelectableTest( + fixtures.TestBase, + AssertsExecutionResults, + AssertsCompiledSQL): __dialect__ = 'default' def test_indirect_correspondence_on_labels(self): @@ -44,7 +48,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled # same column three times s = select([table1.c.col1.label('c2'), table1.c.col1, - table1.c.col1.label('c1')]) + table1.c.col1.label('c1')]) # this tests the same thing as # test_direct_correspondence_on_labels below - @@ -149,7 +153,6 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled s = select([t])._clone() assert c in s.c.bar.proxy_set - def test_no_error_on_unsupported_expr_key(self): from sqlalchemy.dialects.postgresql import ARRAY @@ -203,7 +206,6 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled set([s3c1]) ) - def test_distance_on_aliases(self): a1 = table1.alias('a1') for s in (select([a1, table1], use_labels=True), @@ -241,7 +243,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled tojoin = select([ literal_column('1').label('a'), literal_column('2').label('b') - ]) + ]) basefrom = basesel.alias('basefrom') joinfrom = tojoin.alias('joinfrom') sel = select([basefrom.c.a]) @@ -298,13 +300,13 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled assert sel.corresponding_column(table1.c.col1) \ is sel.c.table1_col1 - assert sel.corresponding_column(table1.c.col1, - require_embedded=True) is sel.c.table1_col1 + assert sel.corresponding_column( + table1.c.col1, + require_embedded=True) is sel.c.table1_col1 assert table1.corresponding_column(sel.c.table1_col1) \ is table1.c.col1 assert table1.corresponding_column(sel.c.table1_col1, - require_embedded=True) is None - + require_embedded=True) is None def test_join_against_join(self): j = outerjoin(table1, table2, table1.c.col1 == table2.c.col2) @@ -332,11 +334,15 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled # with a certain Table, against a column in a Union where one of # its underlying Selects matches to that same Table - u = select([table1.c.col1, table1.c.col2, table1.c.col3, - table1.c.colx, null().label('coly' - )]).union(select([table2.c.col1, table2.c.col2, - table2.c.col3, null().label('colx'), - table2.c.coly])) + u = select([table1.c.col1, + table1.c.col2, + table1.c.col3, + table1.c.colx, + null().label('coly')]).union(select([table2.c.col1, + table2.c.col2, + table2.c.col3, + null().label('colx'), + table2.c.coly])) s1 = table1.select(use_labels=True) s2 = table2.select(use_labels=True) @@ -362,11 +368,9 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled assert u1.corresponding_column(table1.c.colx) is u1.c.col2 assert u1.corresponding_column(table1.c.col3) is u1.c.col1 - def test_singular_union(self): - u = union(select([table1.c.col1, table1.c.col2, - table1.c.col3]), select([table1.c.col1, - table1.c.col2, table1.c.col3])) + u = union(select([table1.c.col1, table1.c.col2, table1.c.col3]), select( + [table1.c.col1, table1.c.col2, table1.c.col3])) u = union(select([table1.c.col1, table1.c.col2, table1.c.col3])) assert u.c.col1 is not None assert u.c.col2 is not None @@ -376,11 +380,15 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled # same as testunion, except its an alias of the union - u = select([table1.c.col1, table1.c.col2, table1.c.col3, - table1.c.colx, null().label('coly' - )]).union(select([table2.c.col1, table2.c.col2, - table2.c.col3, null().label('colx'), - table2.c.coly])).alias('analias') + u = select([table1.c.col1, + table1.c.col2, + table1.c.col3, + table1.c.colx, + null().label('coly')]).union(select([table2.c.col1, + table2.c.col2, + table2.c.col3, + null().label('colx'), + table2.c.coly])).alias('analias') s1 = table1.select(use_labels=True) s2 = table2.select(use_labels=True) assert u.corresponding_column(s1.c.table1_col2) is u.c.col2 @@ -403,7 +411,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled def test_union_of_text(self): s1 = select([table1.c.col1, table1.c.col2]) s2 = text("select col1, col2 from foo").columns( - column('col1'), column('col2')) + column('col1'), column('col2')) u1 = union(s1, s2) assert u1.corresponding_column(s1.c.col1) is u1.c.col1 @@ -419,7 +427,8 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled s2 = select([table2.c.col1, table2.c.col2, table2.c.col3]) u1 = union(s1, s2) - assert u1.corresponding_column(s1.c._all_columns[0]) is u1.c._all_columns[0] + assert u1.corresponding_column( + s1.c._all_columns[0]) is u1.c._all_columns[0] assert u1.corresponding_column(s2.c.col1) is u1.c._all_columns[0] assert u1.corresponding_column(s1.c.col2) is u1.c.col2 assert u1.corresponding_column(s2.c.col2) is u1.c.col2 @@ -435,7 +444,8 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled s2 = select([table2.c.col1, table2.c.col2, table2.c.col3]) u1 = union(s1, s2) - assert u1.corresponding_column(s1.c._all_columns[0]) is u1.c._all_columns[0] + assert u1.corresponding_column( + s1.c._all_columns[0]) is u1.c._all_columns[0] assert u1.corresponding_column(s2.c.col1) is u1.c._all_columns[0] assert u1.corresponding_column(s1.c.col2) is u1.c.col2 assert u1.corresponding_column(s2.c.col2) is u1.c.col2 @@ -447,16 +457,19 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled assert u1.corresponding_column(table2.c.col1) is u1.c._all_columns[0] assert u1.corresponding_column(table2.c.col3) is u1.c._all_columns[2] - def test_select_union(self): # like testaliasunion, but off a Select off the union. - u = select([table1.c.col1, table1.c.col2, table1.c.col3, - table1.c.colx, null().label('coly' - )]).union(select([table2.c.col1, table2.c.col2, - table2.c.col3, null().label('colx'), - table2.c.coly])).alias('analias') + u = select([table1.c.col1, + table1.c.col2, + table1.c.col3, + table1.c.colx, + null().label('coly')]).union(select([table2.c.col1, + table2.c.col2, + table2.c.col3, + null().label('colx'), + table2.c.coly])).alias('analias') s = select([u]) s1 = table1.select(use_labels=True) s2 = table2.select(use_labels=True) @@ -467,11 +480,15 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled # same as testunion, except its an alias of the union - u = select([table1.c.col1, table1.c.col2, table1.c.col3, - table1.c.colx, null().label('coly' - )]).union(select([table2.c.col1, table2.c.col2, - table2.c.col3, null().label('colx'), - table2.c.coly])).alias('analias') + u = select([table1.c.col1, + table1.c.col2, + table1.c.col3, + table1.c.colx, + null().label('coly')]).union(select([table2.c.col1, + table2.c.col2, + table2.c.col3, + null().label('colx'), + table2.c.coly])).alias('analias') j1 = table1.join(table2) assert u.corresponding_column(j1.c.table1_colx) is u.c.colx assert j1.corresponding_column(u.c.colx) is j1.c.table1_colx @@ -510,8 +527,8 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled def test_column_labels(self): a = select([table1.c.col1.label('acol1'), - table1.c.col2.label('acol2'), - table1.c.col3.label('acol3')]) + table1.c.col2.label('acol2'), + table1.c.col3.label('acol3')]) j = join(a, table2) criterion = a.c.acol1 == table2.c.col2 self.assert_(criterion.compare(j.onclause)) @@ -535,7 +552,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled def test_table_joined_to_select_of_table(self): metadata = MetaData() a = Table('a', metadata, - Column('id', Integer, primary_key=True)) + Column('id', Integer, primary_key=True)) j2 = select([a.c.id.label('aid')]).alias('bar') @@ -627,9 +644,9 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled eq_(c2._from_objects, [t]) self.assert_compile(select([c1]), - "SELECT t.c1 FROM t") + "SELECT t.c1 FROM t") self.assert_compile(select([c2]), - "SELECT t.c2 FROM t") + "SELECT t.c2 FROM t") def test_from_list_deferred_whereclause(self): c1 = Column('c1', Integer) @@ -643,9 +660,9 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled eq_(c2._from_objects, [t]) self.assert_compile(select([c1]), - "SELECT t.c1 FROM t") + "SELECT t.c1 FROM t") self.assert_compile(select([c2]), - "SELECT t.c2 FROM t") + "SELECT t.c2 FROM t") def test_from_list_deferred_fromlist(self): m = MetaData() @@ -659,7 +676,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled eq_(c1._from_objects, [t2]) self.assert_compile(select([c1]), - "SELECT t2.c1 FROM t2") + "SELECT t2.c1 FROM t2") def test_from_list_deferred_cloning(self): c1 = Column('c1', Integer) @@ -681,21 +698,21 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled table2 = table('t2', column('b')) s1 = select([table1.c.a, table2.c.b]) self.assert_compile(s1, - "SELECT t1.a, t2.b FROM t1, t2" - ) + "SELECT t1.a, t2.b FROM t1, t2" + ) s2 = s1.with_only_columns([table2.c.b]) self.assert_compile(s2, - "SELECT t2.b FROM t2" - ) + "SELECT t2.b FROM t2" + ) s3 = sql_util.ClauseAdapter(table1).traverse(s1) self.assert_compile(s3, - "SELECT t1.a, t2.b FROM t1, t2" - ) + "SELECT t1.a, t2.b FROM t1, t2" + ) s4 = s3.with_only_columns([table2.c.b]) self.assert_compile(s4, - "SELECT t2.b FROM t2" - ) + "SELECT t2.b FROM t2" + ) def test_from_list_warning_against_existing(self): c1 = Column('c1', Integer) @@ -746,6 +763,7 @@ class SelectableTest(fixtures.TestBase, AssertsExecutionResults, AssertsCompiled class RefreshForNewColTest(fixtures.TestBase): + def test_join_uninit(self): a = table('a', column('x')) b = table('b', column('y')) @@ -766,7 +784,6 @@ class RefreshForNewColTest(fixtures.TestBase): j._refresh_for_new_column(q) assert j.c.b_q is q - def test_join_samename_init(self): a = table('a', column('x')) b = table('b', column('y')) @@ -845,11 +862,12 @@ class RefreshForNewColTest(fixtures.TestBase): q = column('q') a.append_column(q) assert_raises_message( - NotImplementedError, - "CompoundSelect constructs don't support addition of " - "columns to underlying selectables", - s3._refresh_for_new_column, q + NotImplementedError, + "CompoundSelect constructs don't support addition of " + "columns to underlying selectables", + s3._refresh_for_new_column, q ) + def test_nested_join_uninit(self): a = table('a', column('x')) b = table('b', column('y')) @@ -873,7 +891,9 @@ class RefreshForNewColTest(fixtures.TestBase): j._refresh_for_new_column(q) assert j.c.b_q is q + class AnonLabelTest(fixtures.TestBase): + """Test behaviors fixed by [ticket:2168].""" def test_anon_labels_named_column(self): @@ -904,6 +924,7 @@ class AnonLabelTest(fixtures.TestBase): c1 = literal_column('x') eq_(str(select([c1.label('y')])), "SELECT x AS y") + class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -977,6 +998,7 @@ class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL): "JOIN (c JOIN d ON c.c = d.d) ON b.b = c.c) AS anon_1" ) + class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -984,18 +1006,18 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): m = MetaData() t1 = Table('t1', m, Column('id', Integer)) t2 = Table('t2', m, - Column('id', Integer), - Column('t1id', ForeignKey('t1.id'))) + Column('id', Integer), + Column('t1id', ForeignKey('t1.id'))) t3 = Table('t3', m, - Column('id', Integer), - Column('t1id', ForeignKey('t1.id')), - Column('t2id', ForeignKey('t2.id'))) + Column('id', Integer), + Column('t1id', ForeignKey('t1.id')), + Column('t2id', ForeignKey('t2.id'))) t4 = Table('t4', m, Column('id', Integer), - Column('t2id', ForeignKey('t2.id'))) + Column('t2id', ForeignKey('t2.id'))) t5 = Table('t5', m, - Column('t1id1', ForeignKey('t1.id')), - Column('t1id2', ForeignKey('t1.id')), - ) + Column('t1id1', ForeignKey('t1.id')), + Column('t1id2', ForeignKey('t1.id')), + ) t1t2 = t1.join(t2) t2t3 = t2.join(t3) @@ -1009,10 +1031,12 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): (t2t3.join(t1), t4, None, t2t3.c.t2_id == t4.c.t2id), (t2t3.join(t1), t4, t1, t2t3.c.t2_id == t4.c.t2id), (t1t2, t2t3, t2, t1t2.c.t2_id == t2t3.c.t3_t2id), - ]: - assert expected.compare(sql_util.join_condition(left, - right, a_subset=a_subset)) - + ]: + assert expected.compare( + sql_util.join_condition( + left, + right, + a_subset=a_subset)) # these are ambiguous, or have no joins for left, right, a_subset in [ @@ -1048,28 +1072,32 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): # these are right-nested joins j = t1t2.join(t2t3) assert j.onclause.compare(t2.c.id == t3.c.t2id) - self.assert_compile(j, - "t1 JOIN t2 ON t1.id = t2.t1id JOIN " - "(t2 JOIN t3 ON t2.id = t3.t2id) ON t2.id = t3.t2id") + self.assert_compile( + j, "t1 JOIN t2 ON t1.id = t2.t1id JOIN " + "(t2 JOIN t3 ON t2.id = t3.t2id) ON t2.id = t3.t2id") st2t3 = t2t3.select(use_labels=True) j = t1t2.join(st2t3) assert j.onclause.compare(t2.c.id == st2t3.c.t3_t2id) - self.assert_compile(j, - "t1 JOIN t2 ON t1.id = t2.t1id JOIN " - "(SELECT t2.id AS t2_id, t2.t1id AS t2_t1id, " - "t3.id AS t3_id, t3.t1id AS t3_t1id, t3.t2id AS t3_t2id " - "FROM t2 JOIN t3 ON t2.id = t3.t2id) ON t2.id = t3_t2id") - + self.assert_compile( + j, "t1 JOIN t2 ON t1.id = t2.t1id JOIN " + "(SELECT t2.id AS t2_id, t2.t1id AS t2_t1id, " + "t3.id AS t3_id, t3.t1id AS t3_t1id, t3.t2id AS t3_t2id " + "FROM t2 JOIN t3 ON t2.id = t3.t2id) ON t2.id = t3_t2id") def test_join_multiple_equiv_fks(self): m = MetaData() t1 = Table('t1', m, - Column('id', Integer, primary_key=True) - ) - t2 = Table('t2', m, - Column('t1id', Integer, ForeignKey('t1.id'), ForeignKey('t1.id')) - ) + Column('id', Integer, primary_key=True) + ) + t2 = Table( + 't2', + m, + Column( + 't1id', + Integer, + ForeignKey('t1.id'), + ForeignKey('t1.id'))) assert sql_util.join_condition(t1, t2).compare(t1.c.id == t2.c.t1id) @@ -1079,10 +1107,10 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): # try to get coverage to get the "continue" statements # in the loop... t1 = Table('t1', m, - Column('y', Integer, ForeignKey('t22.id')), - Column('x', Integer, ForeignKey('t2.id')), - Column('q', Integer, ForeignKey('t22.id')), - ) + Column('y', Integer, ForeignKey('t22.id')), + Column('x', Integer, ForeignKey('t2.id')), + Column('q', Integer, ForeignKey('t22.id')), + ) t2 = Table('t2', m, Column('id', Integer)) assert sql_util.join_condition(t1, t2).compare(t1.c.x == t2.c.id) assert sql_util.join_condition(t2, t1).compare(t1.c.x == t2.c.id) @@ -1090,7 +1118,7 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): def test_join_cond_no_such_unrelated_column(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer, ForeignKey('t2.id')), - Column('y', Integer, ForeignKey('t3.q'))) + Column('y', Integer, ForeignKey('t3.q'))) t2 = Table('t2', m, Column('id', Integer)) Table('t3', m, Column('id', Integer)) assert sql_util.join_condition(t1, t2).compare(t1.c.x == t2.c.id) @@ -1125,7 +1153,7 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): exc.NoReferencedColumnError, "Could not initialize target column for " "ForeignKey 't2.q' on table 't1': " - "table 't2' has no column named 'q'", + "table 't2' has no column named 'q'", sql_util.join_condition, t1, t2 ) @@ -1133,10 +1161,11 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): exc.NoReferencedColumnError, "Could not initialize target column for " "ForeignKey 't2.q' on table 't1': " - "table 't2' has no column named 'q'", + "table 't2' has no column named 'q'", sql_util.join_condition, t2, t1 ) + class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): def test_join_pk_collapse_implicit(self): @@ -1147,11 +1176,11 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): meta = MetaData() a = Table('a', meta, Column('id', Integer, primary_key=True)) b = Table('b', meta, Column('id', Integer, ForeignKey('a.id'), - primary_key=True)) + primary_key=True)) c = Table('c', meta, Column('id', Integer, ForeignKey('b.id'), - primary_key=True)) + primary_key=True)) d = Table('d', meta, Column('id', Integer, ForeignKey('c.id'), - primary_key=True)) + primary_key=True)) assert c.c.id.references(b.c.id) assert not d.c.id.references(a.c.id) assert list(a.join(b).primary_key) == [a.c.id] @@ -1161,7 +1190,6 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): assert list(d.join(c).join(b).primary_key) == [b.c.id] assert list(a.join(b).join(c).join(d).primary_key) == [a.c.id] - def test_join_pk_collapse_explicit(self): """test that redundant columns in a join get 'collapsed' into a minimal primary key, which is the root column along a chain of @@ -1171,11 +1199,11 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): a = Table('a', meta, Column('id', Integer, primary_key=True), Column('x', Integer)) b = Table('b', meta, Column('id', Integer, ForeignKey('a.id'), - primary_key=True), Column('x', Integer)) + primary_key=True), Column('x', Integer)) c = Table('c', meta, Column('id', Integer, ForeignKey('b.id'), - primary_key=True), Column('x', Integer)) + primary_key=True), Column('x', Integer)) d = Table('d', meta, Column('id', Integer, ForeignKey('c.id'), - primary_key=True), Column('x', Integer)) + primary_key=True), Column('x', Integer)) print(list(a.join(b, a.c.x == b.c.id).primary_key)) assert list(a.join(b, a.c.x == b.c.id).primary_key) == [a.c.id] assert list(b.join(c, b.c.x == c.c.id).primary_key) == [b.c.id] @@ -1185,21 +1213,26 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): == [b.c.id] assert list(b.join(c, c.c.id == b.c.x).join(d).primary_key) \ == [b.c.id] - assert list(d.join(b, d.c.id == b.c.id).join(c, b.c.id - == c.c.x).primary_key) == [b.c.id] + assert list( + d.join( + b, + d.c.id == b.c.id).join( + c, + b.c.id == c.c.x).primary_key) == [ + b.c.id] assert list(a.join(b).join(c, c.c.id - == b.c.x).join(d).primary_key) == [a.c.id] + == b.c.x).join(d).primary_key) == [a.c.id] assert list(a.join(b, and_(a.c.id == b.c.id, a.c.x - == b.c.id)).primary_key) == [a.c.id] + == b.c.id)).primary_key) == [a.c.id] def test_init_doesnt_blowitaway(self): meta = MetaData() a = Table('a', meta, - Column('id', Integer, primary_key=True), - Column('x', Integer)) + Column('id', Integer, primary_key=True), + Column('x', Integer)) b = Table('b', meta, - Column('id', Integer, ForeignKey('a.id'), primary_key=True), - Column('x', Integer)) + Column('id', Integer, ForeignKey('a.id'), primary_key=True), + Column('x', Integer)) j = a.join(b) assert list(j.primary_key) == [a.c.id] @@ -1210,11 +1243,11 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): def test_non_column_clause(self): meta = MetaData() a = Table('a', meta, - Column('id', Integer, primary_key=True), - Column('x', Integer)) + Column('id', Integer, primary_key=True), + Column('x', Integer)) b = Table('b', meta, - Column('id', Integer, ForeignKey('a.id'), primary_key=True), - Column('x', Integer, primary_key=True)) + Column('id', Integer, ForeignKey('a.id'), primary_key=True), + Column('x', Integer, primary_key=True)) j = a.join(b, and_(a.c.id == b.c.id, b.c.x == 5)) assert str(j) == "a JOIN b ON a.id = b.id AND b.x = :x_1", str(j) @@ -1224,35 +1257,51 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): metadata = MetaData() employee = Table('Employee', metadata, - Column('name', String(100)), - Column('id', Integer, primary_key=True), - ) + Column('name', String(100)), + Column('id', Integer, primary_key=True), + ) engineer = Table('Engineer', metadata, - Column('id', Integer, - ForeignKey('Employee.id'), primary_key=True)) - + Column('id', Integer, + ForeignKey('Employee.id'), primary_key=True)) eq_(util.column_set(employee.join(engineer, employee.c.id - == engineer.c.id).primary_key), + == engineer.c.id).primary_key), util.column_set([employee.c.id])) eq_(util.column_set(employee.join(engineer, engineer.c.id - == employee.c.id).primary_key), + == employee.c.id).primary_key), util.column_set([employee.c.id])) class ReduceTest(fixtures.TestBase, AssertsExecutionResults): + def test_reduce(self): meta = MetaData() t1 = Table('t1', meta, - Column('t1id', Integer, primary_key=True), - Column('t1data', String(30))) - t2 = Table('t2', meta, - Column('t2id', Integer, ForeignKey('t1.t1id'), primary_key=True), - Column('t2data', String(30))) - t3 = Table('t3', meta, - Column('t3id', Integer, ForeignKey('t2.t2id'), primary_key=True), - Column('t3data', String(30))) + Column('t1id', Integer, primary_key=True), + Column('t1data', String(30))) + t2 = Table( + 't2', + meta, + Column( + 't2id', + Integer, + ForeignKey('t1.t1id'), + primary_key=True), + Column( + 't2data', + String(30))) + t3 = Table( + 't3', + meta, + Column( + 't3id', + Integer, + ForeignKey('t2.t2id'), + primary_key=True), + Column( + 't3data', + String(30))) eq_(util.column_set(sql_util.reduce_columns([ t1.c.t1id, @@ -1261,31 +1310,30 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): t2.c.t2data, t3.c.t3id, t3.c.t3data, - ])), util.column_set([t1.c.t1id, t1.c.t1data, t2.c.t2data, - t3.c.t3data])) - + ])), util.column_set([t1.c.t1id, t1.c.t1data, t2.c.t2data, + t3.c.t3data])) def test_reduce_selectable(self): metadata = MetaData() engineers = Table('engineers', metadata, - Column('engineer_id', Integer, primary_key=True), + Column('engineer_id', Integer, primary_key=True), Column('engineer_name', String(50))) managers = Table('managers', metadata, - Column('manager_id', Integer, primary_key=True), + Column('manager_id', Integer, primary_key=True), Column('manager_name', String(50))) s = select([engineers, - managers]).where(engineers.c.engineer_name - == managers.c.manager_name) + managers]).where(engineers.c.engineer_name + == managers.c.manager_name) eq_(util.column_set(sql_util.reduce_columns(list(s.c), s)), util.column_set([s.c.engineer_id, s.c.engineer_name, - s.c.manager_id])) + s.c.manager_id])) def test_reduce_generation(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer, primary_key=True), - Column('y', Integer)) + Column('y', Integer)) t2 = Table('t2', m, Column('z', Integer, ForeignKey('t1.x')), - Column('q', Integer)) + Column('q', Integer)) s1 = select([t1, t2]) s2 = s1.reduce_columns(only_synonyms=False) eq_( @@ -1299,13 +1347,12 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): set([t1.c.x, t1.c.y, t2.c.z, t2.c.q]) ) - def test_reduce_only_synonym_fk(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer, primary_key=True), - Column('y', Integer)) + Column('y', Integer)) t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x')), - Column('q', Integer, ForeignKey('t1.y'))) + Column('q', Integer, ForeignKey('t1.y'))) s1 = select([t1, t2]) s1 = s1.reduce_columns(only_synonyms=True) eq_( @@ -1316,89 +1363,107 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): def test_reduce_only_synonym_lineage(self): m = MetaData() t1 = Table('t1', m, Column('x', Integer, primary_key=True), - Column('y', Integer), - Column('z', Integer) - ) + Column('y', Integer), + Column('z', Integer) + ) # test that the first appearance in the columns clause # wins - t1 is first, t1.c.x wins s1 = select([t1]) s2 = select([t1, s1]).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z) eq_( - set(s2.reduce_columns().inner_columns), - set([t1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]) + set(s2.reduce_columns().inner_columns), + set([t1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]) ) # reverse order, s1.c.x wins s1 = select([t1]) s2 = select([s1, t1]).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z) eq_( - set(s2.reduce_columns().inner_columns), - set([s1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]) + set(s2.reduce_columns().inner_columns), + set([s1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]) ) def test_reduce_aliased_join(self): metadata = MetaData() - people = Table('people', metadata, Column('person_id', Integer, - Sequence('person_id_seq', optional=True), - primary_key=True), Column('name', String(50)), - Column('type', String(30))) + people = Table( + 'people', metadata, Column( + 'person_id', Integer, Sequence( + 'person_id_seq', optional=True), primary_key=True), Column( + 'name', String(50)), Column( + 'type', String(30))) engineers = Table( 'engineers', metadata, Column('person_id', Integer, ForeignKey('people.person_id' - ), primary_key=True), + ), primary_key=True), Column('status', String(30)), Column('engineer_name', String(50)), Column('primary_language', String(50)), - ) - managers = Table('managers', metadata, Column('person_id', - Integer, ForeignKey('people.person_id'), - primary_key=True), Column('status', - String(30)), Column('manager_name', - String(50))) + ) + managers = Table( + 'managers', metadata, Column( + 'person_id', Integer, ForeignKey('people.person_id'), primary_key=True), Column( + 'status', String(30)), Column( + 'manager_name', String(50))) pjoin = \ people.outerjoin(engineers).outerjoin(managers).\ select(use_labels=True).alias('pjoin' - ) + ) eq_(util.column_set(sql_util.reduce_columns([pjoin.c.people_person_id, - pjoin.c.engineers_person_id, pjoin.c.managers_person_id])), + pjoin.c.engineers_person_id, + pjoin.c.managers_person_id])), util.column_set([pjoin.c.people_person_id])) def test_reduce_aliased_union(self): metadata = MetaData() - item_table = Table('item', metadata, Column('id', Integer, - ForeignKey('base_item.id'), - primary_key=True), Column('dummy', Integer, - default=0)) - base_item_table = Table('base_item', metadata, Column('id', - Integer, primary_key=True), - Column('child_name', String(255), - default=None)) + item_table = Table( + 'item', + metadata, + Column( + 'id', + Integer, + ForeignKey('base_item.id'), + primary_key=True), + Column( + 'dummy', + Integer, + default=0)) + base_item_table = Table( + 'base_item', metadata, Column( + 'id', Integer, primary_key=True), Column( + 'child_name', String(255), default=None)) from sqlalchemy.orm.util import polymorphic_union item_join = polymorphic_union({ - 'BaseItem': - base_item_table.select( - base_item_table.c.child_name - == 'BaseItem'), + 'BaseItem': + base_item_table.select( + base_item_table.c.child_name + == 'BaseItem'), 'Item': base_item_table.join(item_table)}, - None, 'item_join') + None, 'item_join') eq_(util.column_set(sql_util.reduce_columns([item_join.c.id, - item_join.c.dummy, item_join.c.child_name])), - util.column_set([item_join.c.id, item_join.c.dummy, - item_join.c.child_name])) + item_join.c.dummy, + item_join.c.child_name])), + util.column_set([item_join.c.id, + item_join.c.dummy, + item_join.c.child_name])) def test_reduce_aliased_union_2(self): metadata = MetaData() page_table = Table('page', metadata, Column('id', Integer, - primary_key=True)) + primary_key=True)) magazine_page_table = Table('magazine_page', metadata, Column('page_id', Integer, - ForeignKey('page.id'), - primary_key=True)) - classified_page_table = Table('classified_page', metadata, - Column('magazine_page_id', Integer, - ForeignKey('magazine_page.page_id'), primary_key=True)) + ForeignKey('page.id'), + primary_key=True)) + classified_page_table = Table( + 'classified_page', + metadata, + Column( + 'magazine_page_id', + Integer, + ForeignKey('magazine_page.page_id'), + primary_key=True)) # this is essentially the union formed by the ORM's # polymorphic_union function. we define two versions with @@ -1408,25 +1473,24 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): # classified_page.magazine_page_id pjoin = union( - select([ - page_table.c.id, - magazine_page_table.c.page_id, - classified_page_table.c.magazine_page_id - ]). - select_from( - page_table.join(magazine_page_table). - join(classified_page_table)), - - select([ - page_table.c.id, - magazine_page_table.c.page_id, - cast(null(), Integer).label('magazine_page_id') - ]). - select_from(page_table.join(magazine_page_table)) - ).alias('pjoin') - eq_(util.column_set(sql_util.reduce_columns([pjoin.c.id, - pjoin.c.page_id, pjoin.c.magazine_page_id])), - util.column_set([pjoin.c.id])) + select([ + page_table.c.id, + magazine_page_table.c.page_id, + classified_page_table.c.magazine_page_id + ]). + select_from( + page_table.join(magazine_page_table). + join(classified_page_table)), + + select([ + page_table.c.id, + magazine_page_table.c.page_id, + cast(null(), Integer).label('magazine_page_id') + ]). + select_from(page_table.join(magazine_page_table)) + ).alias('pjoin') + eq_(util.column_set(sql_util.reduce_columns( + [pjoin.c.id, pjoin.c.page_id, pjoin.c.magazine_page_id])), util.column_set([pjoin.c.id])) # the first selectable has a CAST, which is a placeholder for # classified_page.magazine_page_id in the second selectable. @@ -1436,25 +1500,26 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): # first selectable only. pjoin = union(select([ - page_table.c.id, - magazine_page_table.c.page_id, - cast(null(), Integer).label('magazine_page_id') - ]). - select_from(page_table.join(magazine_page_table)), - - select([ - page_table.c.id, - magazine_page_table.c.page_id, - classified_page_table.c.magazine_page_id - ]). - select_from(page_table.join(magazine_page_table). - join(classified_page_table)) - ).alias('pjoin') - eq_(util.column_set(sql_util.reduce_columns([pjoin.c.id, - pjoin.c.page_id, pjoin.c.magazine_page_id])), - util.column_set([pjoin.c.id])) + page_table.c.id, + magazine_page_table.c.page_id, + cast(null(), Integer).label('magazine_page_id') + ]). + select_from(page_table.join(magazine_page_table)), + + select([ + page_table.c.id, + magazine_page_table.c.page_id, + classified_page_table.c.magazine_page_id + ]). + select_from(page_table.join(magazine_page_table). + join(classified_page_table)) + ).alias('pjoin') + eq_(util.column_set(sql_util.reduce_columns( + [pjoin.c.id, pjoin.c.page_id, pjoin.c.magazine_page_id])), util.column_set([pjoin.c.id])) + class DerivedTest(fixtures.TestBase, AssertsExecutionResults): + def test_table(self): meta = MetaData() @@ -1466,7 +1531,6 @@ class DerivedTest(fixtures.TestBase, AssertsExecutionResults): assert t1.is_derived_from(t1) assert not t2.is_derived_from(t1) - def test_alias(self): meta = MetaData() t1 = Table('t1', meta, Column('c1', Integer, primary_key=True), @@ -1496,6 +1560,7 @@ class DerivedTest(fixtures.TestBase, AssertsExecutionResults): assert select([t1, t2]).alias('foo').is_derived_from(t1) assert not t2.select().alias('foo').is_derived_from(t1) + class AnnotationsTest(fixtures.TestBase): def test_hashing(self): @@ -1551,8 +1616,8 @@ class AnnotationsTest(fixtures.TestBase): def test_basic_attrs(self): t = Table('t', MetaData(), - Column('x', Integer, info={'q': 'p'}), - Column('y', Integer, key='q')) + Column('x', Integer, info={'q': 'p'}), + Column('y', Integer, key='q')) x_a = t.c.x._annotate({}) y_a = t.c.q._annotate({}) t.c.x.info['z'] = 'h' @@ -1564,7 +1629,9 @@ class AnnotationsTest(fixtures.TestBase): def test_custom_constructions(self): from sqlalchemy.schema import Column + class MyColumn(Column): + def __init__(self): Column.__init__(self, 'foo', Integer) _constructor = Column @@ -1584,16 +1651,18 @@ class AnnotationsTest(fixtures.TestBase): # [ticket:2918] from sqlalchemy.schema import Column from sqlalchemy.sql.elements import AnnotatedColumnElement + class MyColumn(Column): pass assert isinstance( - MyColumn('x', Integer)._annotate({"foo": "bar"}), - AnnotatedColumnElement) + MyColumn('x', Integer)._annotate({"foo": "bar"}), + AnnotatedColumnElement) def test_custom_construction_correct_anno_expr(self): # [ticket:2918] from sqlalchemy.schema import Column + class MyColumn(Column): pass @@ -1619,29 +1688,31 @@ class AnnotationsTest(fixtures.TestBase): inner = select([s1]) - assert inner.corresponding_column(t2.c.col1, - require_embedded=False) \ - is inner.corresponding_column(t2.c.col1, - require_embedded=True) is inner.c.col1 - assert inner.corresponding_column(t1.c.col1, - require_embedded=False) \ - is inner.corresponding_column(t1.c.col1, - require_embedded=True) is inner.c.col1 + assert inner.corresponding_column( + t2.c.col1, + require_embedded=False) is inner.corresponding_column( + t2.c.col1, + require_embedded=True) is inner.c.col1 + assert inner.corresponding_column( + t1.c.col1, + require_embedded=False) is inner.corresponding_column( + t1.c.col1, + require_embedded=True) is inner.c.col1 def test_annotated_visit(self): table1 = table('table1', column("col1"), column("col2")) bin = table1.c.col1 == bindparam('foo', value=None) assert str(bin) == "table1.col1 = :foo" + def visit_binary(b): b.right = table1.c.col2 b2 = visitors.cloned_traverse(bin, {}, {'binary': visit_binary}) assert str(b2) == "table1.col1 = table1.col2" - b3 = visitors.cloned_traverse(bin._annotate({}), {}, {'binary': - visit_binary}) + visit_binary}) assert str(b3) == 'table1.col1 = table1.col2' def visit_binary(b): @@ -1665,15 +1736,15 @@ class AnnotationsTest(fixtures.TestBase): table1 = table('table1', column('col1'), column('col2')) for expr, expected in [(table1.c.col1, 'table1.col1'), (table1.c.col1 == 5, - 'table1.col1 = :col1_1'), + 'table1.col1 = :col1_1'), (table1.c.col1.in_([2, 3, 4]), - 'table1.col1 IN (:col1_1, :col1_2, ' - ':col1_3)')]: + 'table1.col1 IN (:col1_1, :col1_2, ' + ':col1_3)')]: eq_(str(expr), expected) eq_(str(expr._annotate({})), expected) eq_(str(sql_util._deep_annotate(expr, {})), expected) - eq_(str(sql_util._deep_annotate(expr, {}, - exclude=[table1.c.col1])), expected) + eq_(str(sql_util._deep_annotate( + expr, {}, exclude=[table1.c.col1])), expected) def test_deannotate(self): table1 = table('table1', column("col1"), column("col2")) @@ -1688,7 +1759,7 @@ class AnnotationsTest(fixtures.TestBase): assert '_orm_adapt' in elem for elem in b3._annotations, b3.left._annotations, \ - b4._annotations, b4.left._annotations: + b4._annotations, b4.left._annotations: assert elem == {} assert b2.left is not bin.left @@ -1711,8 +1782,8 @@ class AnnotationsTest(fixtures.TestBase): table2 = table('table2', column('y')) a1 = table1.alias() s = select([a1.c.x]).select_from( - a1.join(table2, a1.c.x == table2.c.y) - ) + a1.join(table2, a1.c.x == table2.c.y) + ) for sel in ( sql_util._deep_deannotate(s), visitors.cloned_traverse(s, {}, {}), @@ -1737,15 +1808,14 @@ class AnnotationsTest(fixtures.TestBase): # re49563072578 eq_(str(s), str(sel)) - def test_annotate_varied_annot_same_col(self): """test two instances of the same column with different annotations preserving them when deep_annotate is run on them. """ t1 = table('table1', column("col1"), column("col2")) - s = select([t1.c.col1._annotate({"foo":"bar"})]) - s2 = select([t1.c.col1._annotate({"bat":"hoho"})]) + s = select([t1.c.col1._annotate({"foo": "bar"})]) + s2 = select([t1.c.col1._annotate({"bat": "hoho"})]) s3 = s.union(s2) sel = sql_util._deep_annotate(s3, {"new": "thing"}) @@ -1762,7 +1832,7 @@ class AnnotationsTest(fixtures.TestBase): def test_deannotate_2(self): table1 = table('table1', column("col1"), column("col2")) j = table1.c.col1._annotate({"remote": True}) == \ - table1.c.col2._annotate({"local": True}) + table1.c.col2._annotate({"local": True}) j2 = sql_util._deep_deannotate(j) eq_( j.left._annotations, {"remote": True} @@ -1773,12 +1843,12 @@ class AnnotationsTest(fixtures.TestBase): def test_deannotate_3(self): table1 = table('table1', column("col1"), column("col2"), - column("col3"), column("col4")) + column("col3"), column("col4")) j = and_( - table1.c.col1._annotate({"remote": True}) == - table1.c.col2._annotate({"local": True}), - table1.c.col3._annotate({"remote": True}) == - table1.c.col4._annotate({"local": True}) + table1.c.col1._annotate({"remote": True}) == + table1.c.col2._annotate({"local": True}), + table1.c.col3._annotate({"remote": True}) == + table1.c.col4._annotate({"local": True}) ) j2 = sql_util._deep_deannotate(j) eq_( @@ -1800,8 +1870,8 @@ class AnnotationsTest(fixtures.TestBase): table2 = table('table2', column('y')) a1 = table1.alias() s = select([a1.c.x]).select_from( - a1.join(table2, a1.c.x == table2.c.y) - ) + a1.join(table2, a1.c.x == table2.c.y) + ) assert_s = select([select([s])]) for fn in ( @@ -1814,7 +1884,6 @@ class AnnotationsTest(fixtures.TestBase): sel = fn(select([fn(select([fn(s)]))])) eq_(str(assert_s), str(sel)) - def test_bind_unique_test(self): table('t', column('a'), column('b')) @@ -1857,7 +1926,9 @@ class AnnotationsTest(fixtures.TestBase): assert (c2 == 5).left._annotations == {"foo": "bar", "bat": "hoho"} + class WithLabelsTest(fixtures.TestBase): + def _assert_labels_warning(self, s): assert_raises_message( exc.SAWarning, @@ -2010,7 +2081,9 @@ class WithLabelsTest(fixtures.TestBase): ) self._assert_result_keys(sel, ['t1_a', 't2_b']) + class SelectProxyTest(fixtures.TestBase): + def _fixture(self): m = MetaData() t = Table('t', m, Column('x', Integer), Column('y', Integer)) @@ -2019,10 +2092,10 @@ class SelectProxyTest(fixtures.TestBase): def _mapping(self, stmt): compiled = stmt.compile() return dict( - (elem, key) - for key, elements in compiled.result_map.items() - for elem in elements[1] - ) + (elem, key) + for key, elements in compiled.result_map.items() + for elem in elements[1] + ) def test_select_label_alt_name(self): t = self._fixture() @@ -2079,6 +2152,7 @@ class SelectProxyTest(fixtures.TestBase): assert l1 in mapping assert ta.c.x not in mapping + class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = "default" @@ -2127,8 +2201,8 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL): eq_(s2._for_update_arg.read, True) eq_(s2._for_update_arg.of, [t.c.c]) self.assert_compile(s2, - "SELECT t.c FROM t FOR SHARE OF t", - dialect="postgresql") + "SELECT t.c FROM t FOR SHARE OF t", + dialect="postgresql") def test_adapt(self): t = table('t', column('c')) @@ -2137,5 +2211,5 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL): s2 = sql_util.ClauseAdapter(a).traverse(s) eq_(s2._for_update_arg.of, [a.c.c]) self.assert_compile(s2, - "SELECT t_1.c FROM t AS t_1 FOR SHARE OF t_1", - dialect="postgresql") + "SELECT t_1.c FROM t AS t_1 FOR SHARE OF t_1", + dialect="postgresql") diff --git a/test/sql/test_text.py b/test/sql/test_text.py index 98eff7604..6e9be9eea 100644 --- a/test/sql/test_text.py +++ b/test/sql/test_text.py @@ -2,15 +2,15 @@ from sqlalchemy.testing import fixtures, AssertsCompiledSQL, eq_, assert_raises_message from sqlalchemy import text, select, Integer, String, Float, \ - bindparam, and_, func, literal_column, exc, MetaData, Table, Column + bindparam, and_, func, literal_column, exc, MetaData, Table, Column from sqlalchemy.types import NullType from sqlalchemy.sql import table, column table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), -) + column('myid', Integer), + column('name', String), + column('description', String), + ) table2 = table( 'myothertable', @@ -18,6 +18,7 @@ table2 = table( column('othername', String), ) + class CompileTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -27,7 +28,9 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): "select * from foo where lala = bar" ) + class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): + """test the usage of text() implicit within the select() construct when strings are passed.""" @@ -38,7 +41,7 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): ["foobar(a)", "pk_foo_bar(syslaal)"], "a = 12", from_obj=["foobar left outer join lala on foobar.foo = lala.foo"] - ), + ), "SELECT foobar(a), pk_foo_bar(syslaal) FROM foobar " "left outer join lala on foobar.foo = lala.foo WHERE a = 12" ) @@ -52,12 +55,12 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): s = s.order_by("column1") s.append_from("table1") self.assert_compile(s, "SELECT column1, column2 FROM table1 WHERE " - "column1=12 AND column2=19 ORDER BY column1") + "column1=12 AND column2=19 ORDER BY column1") def test_select_composition_three(self): self.assert_compile( select(["column1", "column2"], - from_obj=table1).alias('somealias').select(), + from_obj=table1).alias('somealias').select(), "SELECT somealias.column1, somealias.column2 FROM " "(SELECT column1, column2 FROM mytable) AS somealias" ) @@ -66,7 +69,7 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): # test that use_labels doesn't interfere with literal columns self.assert_compile( select(["column1", "column2", table1.c.myid], from_obj=table1, - use_labels=True), + use_labels=True), "SELECT column1, column2, mytable.myid AS mytable_myid " "FROM mytable" ) @@ -76,7 +79,7 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): # with literal columns that have textual labels self.assert_compile( select(["column1 AS foobar", "column2 AS hoho", table1.c.myid], - from_obj=table1, use_labels=True), + from_obj=table1, use_labels=True), "SELECT column1 AS foobar, column2 AS hoho, " "mytable.myid AS mytable_myid FROM mytable" ) @@ -87,10 +90,10 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): # exported columns don't get quoted self.assert_compile( select(["column1 AS foobar", "column2 AS hoho", table1.c.myid], - from_obj=[table1]).select(), + from_obj=[table1]).select(), "SELECT column1 AS foobar, column2 AS hoho, myid FROM " "(SELECT column1 AS foobar, column2 AS hoho, " - "mytable.myid AS myid FROM mytable)" + "mytable.myid AS myid FROM mytable)" ) def test_select_composition_seven(self): @@ -105,8 +108,8 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): "foo.f = t.id", from_obj=["(select f from bar where lala=heyhey) foo"] ), - "SELECT t.myid, t.name, t.description, foo.f FROM mytable AS t, " - "(select f from bar where lala=heyhey) foo WHERE foo.f = t.id") + "SELECT t.myid, t.name, t.description, foo.f FROM mytable AS t, " + "(select f from bar where lala=heyhey) foo WHERE foo.f = t.id") def test_select_bundle_columns(self): self.assert_compile(select( @@ -117,17 +120,18 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): table1.c.myid == table2.c.otherid, ) ), - "SELECT mytable.myid, mytable.name, mytable.description, " - "myothertable.otherid, sysdate(), foo, bar, lala " - "FROM mytable, myothertable WHERE foo.id = foofoo(lala) AND " - "datetime(foo) = Today AND mytable.myid = myothertable.otherid") + "SELECT mytable.myid, mytable.name, mytable.description, " + "myothertable.otherid, sysdate(), foo, bar, lala " + "FROM mytable, myothertable WHERE foo.id = foofoo(lala) AND " + "datetime(foo) = Today AND mytable.myid = myothertable.otherid") + class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' def test_legacy(self): t = text("select * from foo where lala=:bar and hoho=:whee", - bindparams=[bindparam('bar', 4), bindparam('whee', 7)]) + bindparams=[bindparam('bar', 4), bindparam('whee', 7)]) self.assert_compile( t, @@ -187,44 +191,43 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): t = text("select * from table :foo :bar :bat") self._assert_type_map(t, {"foo": NullType(), - "bar": NullType(), - "bat": NullType()}) + "bar": NullType(), + "bat": NullType()}) t = t.bindparams(bindparam('foo', type_=String)) self._assert_type_map(t, {"foo": String(), - "bar": NullType(), - "bat": NullType()}) + "bar": NullType(), + "bat": NullType()}) t = t.bindparams(bindparam('bar', type_=Integer)) self._assert_type_map(t, {"foo": String(), - "bar": Integer(), - "bat": NullType()}) + "bar": Integer(), + "bat": NullType()}) t = t.bindparams(bat=45.564) self._assert_type_map(t, {"foo": String(), - "bar": Integer(), - "bat": Float()}) - + "bar": Integer(), + "bat": Float()}) def test_binds_compiled_named(self): self.assert_compile( text("select * from foo where lala=:bar and hoho=:whee"). - bindparams(bar=4, whee=7), - "select * from foo where lala=%(bar)s and hoho=%(whee)s", - checkparams={'bar': 4, 'whee': 7}, - dialect="postgresql" + bindparams(bar=4, whee=7), + "select * from foo where lala=%(bar)s and hoho=%(whee)s", + checkparams={'bar': 4, 'whee': 7}, + dialect="postgresql" ) def test_binds_compiled_positional(self): self.assert_compile( text("select * from foo where lala=:bar and hoho=:whee"). - bindparams(bar=4, whee=7), - "select * from foo where lala=? and hoho=?", - checkparams={'bar': 4, 'whee': 7}, - dialect="sqlite" + bindparams(bar=4, whee=7), + "select * from foo where lala=? and hoho=?", + checkparams={'bar': 4, 'whee': 7}, + dialect="sqlite" ) def test_missing_bind_kw(self): @@ -232,110 +235,124 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): exc.ArgumentError, "This text\(\) construct doesn't define a bound parameter named 'bar'", text(":foo").bindparams, - foo=5, bar=7 - ) + foo=5, + bar=7) def test_missing_bind_posn(self): assert_raises_message( exc.ArgumentError, "This text\(\) construct doesn't define a bound parameter named 'bar'", text(":foo").bindparams, - bindparam('foo', value=5), bindparam('bar', value=7) - ) + bindparam( + 'foo', + value=5), + bindparam( + 'bar', + value=7)) def test_escaping_colons(self): # test escaping out text() params with a backslash self.assert_compile( text("select * from foo where clock='05:06:07' " - "and mork='\:mindy'"), + "and mork='\:mindy'"), "select * from foo where clock='05:06:07' and mork=':mindy'", checkparams={}, params={}, dialect="postgresql" ) - def test_text_in_select_nonfrom(self): generate_series = text("generate_series(:x, :y, :z) as s(a)").\ - bindparams(x=None, y=None, z=None) + bindparams(x=None, y=None, z=None) s = select([ - (func.current_date() + literal_column("s.a")).label("dates") - ]).select_from(generate_series) + (func.current_date() + literal_column("s.a")).label("dates") + ]).select_from(generate_series) self.assert_compile( - s, - "SELECT CURRENT_DATE + s.a AS dates FROM " - "generate_series(:x, :y, :z) as s(a)", - checkparams={'y': None, 'x': None, 'z': None} - ) + s, + "SELECT CURRENT_DATE + s.a AS dates FROM " + "generate_series(:x, :y, :z) as s(a)", + checkparams={'y': None, 'x': None, 'z': None} + ) self.assert_compile( - s.params(x=5, y=6, z=7), - "SELECT CURRENT_DATE + s.a AS dates FROM " - "generate_series(:x, :y, :z) as s(a)", - checkparams={'y': 6, 'x': 5, 'z': 7} - ) + s.params(x=5, y=6, z=7), + "SELECT CURRENT_DATE + s.a AS dates FROM " + "generate_series(:x, :y, :z) as s(a)", + checkparams={'y': 6, 'x': 5, 'z': 7} + ) + class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' def test_basic_toplevel_resultmap_positional(self): t = text("select id, name from user").columns( - column('id', Integer), - column('name') - ) + column('id', Integer), + column('name') + ) compiled = t.compile() - eq_( - compiled.result_map, - { - 'id': ('id', (t.c.id._proxies[0], 'id', 'id'), t.c.id.type), - 'name': ('name', (t.c.name._proxies[0], 'name', 'name'), t.c.name.type) - } - ) + eq_(compiled.result_map, + {'id': ('id', + (t.c.id._proxies[0], + 'id', + 'id'), + t.c.id.type), + 'name': ('name', + (t.c.name._proxies[0], + 'name', + 'name'), + t.c.name.type)}) def test_basic_toplevel_resultmap(self): t = text("select id, name from user").columns(id=Integer, name=String) compiled = t.compile() - eq_( - compiled.result_map, - { - 'id': ('id', (t.c.id._proxies[0], 'id', 'id'), t.c.id.type), - 'name': ('name', (t.c.name._proxies[0], 'name', 'name'), t.c.name.type) - } - ) + eq_(compiled.result_map, + {'id': ('id', + (t.c.id._proxies[0], + 'id', + 'id'), + t.c.id.type), + 'name': ('name', + (t.c.name._proxies[0], + 'name', + 'name'), + t.c.name.type)}) def test_basic_subquery_resultmap(self): t = text("select id, name from user").columns(id=Integer, name=String) stmt = select([table1.c.myid]).select_from( - table1.join(t, table1.c.myid == t.c.id)) + table1.join(t, table1.c.myid == t.c.id)) compiled = stmt.compile() eq_( compiled.result_map, { "myid": ("myid", - (table1.c.myid, "myid", "myid"), table1.c.myid.type), + (table1.c.myid, "myid", "myid"), table1.c.myid.type), } ) def test_column_collection_ordered(self): t = text("select a, b, c from foo").columns(column('a'), - column('b'), column('c')) + column('b'), column('c')) eq_(t.c.keys(), ['a', 'b', 'c']) def test_column_collection_pos_plus_bykey(self): # overlapping positional names + type names - t = text("select a, b, c from foo").columns(column('a'), - column('b'), b=Integer, c=String) + t = text("select a, b, c from foo").columns( + column('a'), + column('b'), + b=Integer, + c=String) eq_(t.c.keys(), ['a', 'b', 'c']) eq_(t.c.b.type._type_affinity, Integer) eq_(t.c.c.type._type_affinity, String) - def _xy_table_fixture(self): m = MetaData() t = Table('t', m, Column('x', Integer), Column('y', Integer)) @@ -344,10 +361,10 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): def _mapping(self, stmt): compiled = stmt.compile() return dict( - (elem, key) - for key, elements in compiled.result_map.items() - for elem in elements[1] - ) + (elem, key) + for key, elements in compiled.result_map.items() + for elem in elements[1] + ) def test_select_label_alt_name(self): t = self._xy_table_fixture() @@ -404,7 +421,9 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): assert ta.c.x not in mapping def test_cte(self): - t = text("select id, name from user").columns(id=Integer, name=String).cte('t') + t = text("select id, name from user").columns( + id=Integer, + name=String).cte('t') s = select([table1]).where(table1.c.myid == t.c.id) self.assert_compile( @@ -414,9 +433,10 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): "FROM mytable, t WHERE mytable.myid = t.id" ) - def test_alias(self): - t = text("select id, name from user").columns(id=Integer, name=String).alias('t') + t = text("select id, name from user").columns( + id=Integer, + name=String).alias('t') s = select([table1]).where(table1.c.myid == t.c.id) self.assert_compile( @@ -449,4 +469,4 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): eq_( set(t.element._bindparams), set(["bat", "foo", "bar"]) - )
\ No newline at end of file + ) diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py index b65e4f24f..c82ad3b94 100644 --- a/test/sql/test_type_expressions.py +++ b/test/sql/test_type_expressions.py @@ -5,8 +5,10 @@ from sqlalchemy.testing import eq_ class _ExprFixture(object): + def _fixture(self): class MyString(String): + def bind_expression(self, bindvalue): return func.lower(bindvalue) @@ -14,11 +16,12 @@ class _ExprFixture(object): return func.lower(col) test_table = Table( - 'test_table', - MetaData(), Column('x', String), Column('y', MyString) + 'test_table', + MetaData(), Column('x', String), Column('y', MyString) ) return test_table + class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -70,13 +73,13 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): table = self._fixture() self.assert_compile( - table.insert(), - "INSERT INTO test_table (x, y) VALUES (:x, lower(:y))" + table.insert(), + "INSERT INTO test_table (x, y) VALUES (:x, lower(:y))" ) self.assert_compile( - table.insert().values(y="hi"), - "INSERT INTO test_table (y) VALUES (lower(:y))" + table.insert().values(y="hi"), + "INSERT INTO test_table (y) VALUES (lower(:y))" ) def test_select_binds(self): @@ -87,6 +90,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "test_table WHERE test_table.y = lower(:y_1)" ) + class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): __dialect__ = 'default' @@ -95,7 +99,7 @@ class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table.select().select(), "SELECT x, lower(y) AS y FROM (SELECT test_table.x " - "AS x, test_table.y AS y FROM test_table)" + "AS x, test_table.y AS y FROM test_table)" ) def test_select_from_alias(self): @@ -103,8 +107,8 @@ class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table.select().alias().select(), "SELECT anon_1.x, lower(anon_1.y) AS y FROM (SELECT " - "test_table.x AS x, test_table.y AS y " - "FROM test_table) AS anon_1" + "test_table.x AS x, test_table.y AS y " + "FROM test_table) AS anon_1" ) def test_select_from_aliased_join(self): @@ -113,16 +117,17 @@ class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): s2 = table.select().alias() j = s1.join(s2, s1.c.x == s2.c.x) s3 = j.select() - self.assert_compile(s3, - "SELECT anon_1.x, lower(anon_1.y) AS y, anon_2.x, " + self.assert_compile( + s3, "SELECT anon_1.x, lower(anon_1.y) AS y, anon_2.x, " "lower(anon_2.y) AS y " "FROM (SELECT test_table.x AS x, test_table.y AS y " "FROM test_table) AS anon_1 JOIN (SELECT " "test_table.x AS x, test_table.y AS y " - "FROM test_table) AS anon_2 ON anon_1.x = anon_2.x" - ) + "FROM test_table) AS anon_2 ON anon_1.x = anon_2.x") + class RoundTripTestBase(object): + def test_round_trip(self): testing.db.execute( self.tables.test_table.insert(), @@ -145,7 +150,7 @@ class RoundTripTestBase(object): # conversion back to upper eq_( testing.db.execute( - select([self.tables.test_table]).\ + select([self.tables.test_table]). order_by(self.tables.test_table.c.y) ).fetchall(), [ @@ -183,7 +188,7 @@ class RoundTripTestBase(object): {"x": "X1", "y": "Y1"}, ) row = testing.db.execute(select([self.tables.test_table]). - apply_labels()).first() + apply_labels()).first() eq_( row[self.tables.test_table.c.y], "Y1" @@ -195,18 +200,21 @@ class RoundTripTestBase(object): {"x": "X1", "y": "Y1"}, ) row = testing.db.execute(select([ - self.tables.test_table.c.x.label('xbar'), - self.tables.test_table.c.y.label('ybar') - ])).first() + self.tables.test_table.c.x.label('xbar'), + self.tables.test_table.c.y.label('ybar') + ])).first() eq_( row[self.tables.test_table.c.y], "Y1" ) + class StringRoundTripTest(fixtures.TablesTest, RoundTripTestBase): + @classmethod def define_tables(cls, metadata): class MyString(String): + def bind_expression(self, bindvalue): return func.lower(bindvalue) @@ -214,19 +222,21 @@ class StringRoundTripTest(fixtures.TablesTest, RoundTripTestBase): return func.upper(col) Table( - 'test_table', - metadata, - Column('x', String(50)), - Column('y', MyString(50) - ) + 'test_table', + metadata, + Column('x', String(50)), + Column('y', MyString(50) + ) ) class TypeDecRoundTripTest(fixtures.TablesTest, RoundTripTestBase): + @classmethod def define_tables(cls, metadata): class MyString(TypeDecorator): impl = String + def bind_expression(self, bindvalue): return func.lower(bindvalue) @@ -234,38 +244,38 @@ class TypeDecRoundTripTest(fixtures.TablesTest, RoundTripTestBase): return func.upper(col) Table( - 'test_table', - metadata, - Column('x', String(50)), - Column('y', MyString(50) - ) + 'test_table', + metadata, + Column('x', String(50)), + Column('y', MyString(50) + ) ) + class ReturningTest(fixtures.TablesTest): __requires__ = 'returning', @classmethod def define_tables(cls, metadata): class MyString(String): + def column_expression(self, col): return func.lower(col) Table( - 'test_table', - metadata, Column('x', String(50)), - Column('y', MyString(50), server_default="YVALUE") + 'test_table', + metadata, Column('x', String(50)), + Column('y', MyString(50), server_default="YVALUE") ) @testing.provide_metadata def test_insert_returning(self): table = self.tables.test_table result = testing.db.execute( - table.insert().returning(table.c.y), - {"x": "xvalue"} + table.insert().returning(table.c.y), + {"x": "xvalue"} ) eq_( result.first(), ("yvalue",) ) - - diff --git a/test/sql/test_types.py b/test/sql/test_types.py index d54745bf5..852591543 100644 --- a/test/sql/test_types.py +++ b/test/sql/test_types.py @@ -26,6 +26,7 @@ from sqlalchemy.testing import fixtures class AdaptTest(fixtures.TestBase): + def _all_dialect_modules(self): return [ getattr(dialects, d) @@ -192,6 +193,7 @@ class AdaptTest(fixtures.TestBase): class TypeAffinityTest(fixtures.TestBase): + def test_type_affinity(self): for type_, affin in [ (String(), String), @@ -233,6 +235,7 @@ class TypeAffinityTest(fixtures.TestBase): class PickleMetadataTest(fixtures.TestBase): + def testmeta(self): for loads, dumps in picklers(): column_types = [ @@ -261,6 +264,7 @@ class PickleMetadataTest(fixtures.TestBase): class UserDefinedTest(fixtures.TablesTest, AssertsCompiledSQL): + """tests user-defined types.""" def test_processing(self): @@ -386,12 +390,14 @@ class UserDefinedTest(fixtures.TablesTest, AssertsCompiledSQL): def test_user_defined_typedec_impl_bind(self): class TypeOne(types.TypeEngine): + def bind_processor(self, dialect): def go(value): return value + " ONE" return go class TypeTwo(types.TypeEngine): + def bind_processor(self, dialect): def go(value): return value + " TWO" @@ -422,6 +428,7 @@ class UserDefinedTest(fixtures.TablesTest, AssertsCompiledSQL): def test_user_defined_dialect_specific_args(self): class MyType(types.UserDefinedType): + def __init__(self, foo='foo', **kwargs): super(MyType, self).__init__() self.foo = foo @@ -437,6 +444,7 @@ class UserDefinedTest(fixtures.TablesTest, AssertsCompiledSQL): @classmethod def define_tables(cls, metadata): class MyType(types.UserDefinedType): + def get_col_spec(self): return "VARCHAR(100)" @@ -500,6 +508,7 @@ class UserDefinedTest(fixtures.TablesTest, AssertsCompiledSQL): return MyNewIntType() class MyNewIntSubClass(MyNewIntType): + def process_result_value(self, value, dialect): return value * 15 @@ -595,6 +604,7 @@ class TypeCoerceCastTest(fixtures.TablesTest): # test coerce from nulltype - e.g. use an object that # does't match to a known type class MyObj(object): + def __str__(self): return "THISISMYOBJ" @@ -716,6 +726,7 @@ class TypeCoerceCastTest(fixtures.TablesTest): t.insert().values(data=coerce_fn('d1', MyType)).execute() class MyFoob(object): + def __clause_element__(self): return t.c.data @@ -758,8 +769,10 @@ class TypeCoerceCastTest(fixtures.TablesTest): class VariantTest(fixtures.TestBase, AssertsCompiledSQL): + def setup(self): class UTypeOne(types.UserDefinedType): + def get_col_spec(self): return "UTYPEONE" @@ -769,6 +782,7 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL): return process class UTypeTwo(types.UserDefinedType): + def get_col_spec(self): return "UTYPETWO" @@ -778,6 +792,7 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL): return process class UTypeThree(types.UserDefinedType): + def get_col_spec(self): return "UTYPETHREE" @@ -873,6 +888,7 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL): class UnicodeTest(fixtures.TestBase): + """Exercise the Unicode and related types. Note: unicode round trip tests are now in @@ -920,7 +936,7 @@ class UnicodeTest(fixtures.TestBase): ('mysql', 'mysqlconnector'), ('sqlite', 'pysqlite'), ('oracle', 'zxjdbc'), - ) + ) eq_( testing.db.dialect.returns_unicode_strings, @@ -992,6 +1008,7 @@ enum_table = non_native_enum_table = metadata = None class EnumTest(AssertsCompiledSQL, fixtures.TestBase): + @classmethod def setup_class(cls): global enum_table, non_native_enum_table, metadata @@ -1080,10 +1097,12 @@ class EnumTest(AssertsCompiledSQL, fixtures.TestBase): def test_non_native_constraint_custom_type(self): class Foob(object): + def __init__(self, name): self.name = name class MyEnum(types.SchemaType, TypeDecorator): + def __init__(self, values): self.impl = Enum( *[v.name for v in values], name="myenum", @@ -1260,6 +1279,7 @@ class ExpressionTest( global test_table, meta, MyCustomType, MyTypeDec class MyCustomType(types.UserDefinedType): + def get_col_spec(self): return "INT" @@ -1274,6 +1294,7 @@ class ExpressionTest( return process class MyOldCustomType(MyCustomType): + def adapt_operator(self, op): return { operators.add: operators.sub, @@ -1315,7 +1336,7 @@ class ExpressionTest( eq_( test_table.select().execute().fetchall(), [(1, 'somedata', datetime.date(2007, 10, 15), 25, - 'BIND_INfooBIND_OUT')] + 'BIND_INfooBIND_OUT')] ) def test_bind_adapt(self): @@ -1619,10 +1640,12 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): class NumericRawSQLTest(fixtures.TestBase): + """Test what DBAPIs and dialects return without any typing information supplied at the SQLA level. """ + def _fixture(self, metadata, type, data): t = Table('t', metadata, Column("val", type)) metadata.create_all() @@ -1671,6 +1694,7 @@ interval_table = metadata = None class IntervalTest(fixtures.TestBase, AssertsExecutionResults): + @classmethod def setup_class(cls): global interval_table, metadata @@ -1700,7 +1724,7 @@ class IntervalTest(fixtures.TestBase, AssertsExecutionResults): def test_non_native_adapt(self): interval = Interval(native=False) adapted = interval.dialect_impl(testing.db.dialect) - assert type(adapted) is Interval + assert isinstance(adapted, Interval) assert adapted.native is False eq_(str(adapted), "DATETIME") @@ -1735,6 +1759,7 @@ class IntervalTest(fixtures.TestBase, AssertsExecutionResults): class BooleanTest( fixtures.TablesTest, AssertsExecutionResults, AssertsCompiledSQL): + """test edge cases for booleans. Note that the main boolean test suite is now in testing/suite/test_types.py @@ -1768,6 +1793,7 @@ class BooleanTest( def test_non_native_constraint_custom_type(self): class Foob(object): + def __init__(self, value): self.value = value @@ -1797,6 +1823,7 @@ class BooleanTest( class PickleTest(fixtures.TestBase): + def test_eq_comparison(self): p1 = PickleType() @@ -1826,6 +1853,7 @@ meta = None class CallableTest(fixtures.TestBase): + @classmethod def setup_class(cls): global meta diff --git a/test/sql/test_unicode.py b/test/sql/test_unicode.py index fc5205a3d..e29aea54f 100644 --- a/test/sql/test_unicode.py +++ b/test/sql/test_unicode.py @@ -7,6 +7,7 @@ from sqlalchemy import testing from sqlalchemy.testing.schema import Table, Column from sqlalchemy.util import u, ue + class UnicodeSchemaTest(fixtures.TestBase): __requires__ = ('unicode_ddl',) __backend__ = True @@ -17,17 +18,26 @@ class UnicodeSchemaTest(fixtures.TestBase): metadata = MetaData(testing.db) t1 = Table(u('unitable1'), metadata, - Column(u('méil'), Integer, primary_key=True), - Column(ue('\u6e2c\u8a66'), Integer), - test_needs_fk=True, - ) - t2 = Table(u('Unitéble2'), metadata, - Column(u('méil'), Integer, primary_key=True, key="a"), - Column(ue('\u6e2c\u8a66'), Integer, ForeignKey(u('unitable1.méil')), - key="b" - ), + Column(u('méil'), Integer, primary_key=True), + Column(ue('\u6e2c\u8a66'), Integer), test_needs_fk=True, - ) + ) + t2 = Table( + u('Unitéble2'), + metadata, + Column( + u('méil'), + Integer, + primary_key=True, + key="a"), + Column( + ue('\u6e2c\u8a66'), + Integer, + ForeignKey( + u('unitable1.méil')), + key="b"), + test_needs_fk=True, + ) # Few DBs support Unicode foreign keys if testing.against('sqlite'): @@ -68,8 +78,8 @@ class UnicodeSchemaTest(fixtures.TestBase): metadata.drop_all() def test_insert(self): - t1.insert().execute({u('méil'):1, ue('\u6e2c\u8a66'):5}) - t2.insert().execute({u('a'):1, u('b'):1}) + t1.insert().execute({u('méil'): 1, ue('\u6e2c\u8a66'): 5}) + t2.insert().execute({u('a'): 1, u('b'): 1}) t3.insert().execute({ue('\u6e2c\u8a66_id'): 1, ue('unitable1_\u6e2c\u8a66'): 5, u('Unitéble2_b'): 1, @@ -121,10 +131,16 @@ class UnicodeSchemaTest(fixtures.TestBase): u('Unitéble2_b'): 1, ue('\u6e2c\u8a66_self'): 1}) - self.assert_(tt1.select(order_by=desc(u('méil'))).execute().fetchall() == - [(2, 7), (1, 5)]) - self.assert_(tt2.select(order_by=desc(u('méil'))).execute().fetchall() == - [(2, 2), (1, 1)]) + self.assert_( + tt1.select( + order_by=desc( + u('méil'))).execute().fetchall() == [ + (2, 7), (1, 5)]) + self.assert_( + tt2.select( + order_by=desc( + u('méil'))).execute().fetchall() == [ + (2, 2), (1, 1)]) self.assert_(tt3.select(order_by=desc(ue('\u6e2c\u8a66_id'))). execute().fetchall() == [(2, 7, 2, 2), (1, 5, 1, 1)]) @@ -132,14 +148,16 @@ class UnicodeSchemaTest(fixtures.TestBase): def test_repr(self): m = MetaData() - t = Table(ue('\u6e2c\u8a66'), m, Column(ue('\u6e2c\u8a66_id'), Integer)) + t = Table( + ue('\u6e2c\u8a66'), + m, + Column( + ue('\u6e2c\u8a66_id'), + Integer)) # I hardly understand what's going on with the backslashes in # this one on py2k vs. py3k - eq_( - repr(t), - ( - "Table('\\u6e2c\\u8a66', MetaData(bind=None), " - "Column('\\u6e2c\\u8a66_id', Integer(), table=<\u6e2c\u8a66>), " - "schema=None)")) - + eq_(repr(t), + ("Table('\\u6e2c\\u8a66', MetaData(bind=None), " + "Column('\\u6e2c\\u8a66_id', Integer(), table=<\u6e2c\u8a66>), " + "schema=None)")) diff --git a/test/sql/test_update.py b/test/sql/test_update.py index a08d5f672..58c86613b 100644 --- a/test/sql/test_update.py +++ b/test/sql/test_update.py @@ -7,6 +7,7 @@ from sqlalchemy.testing.schema import Table, Column class _UpdateFromTestBase(object): + @classmethod def define_tables(cls, metadata): Table('mytable', metadata, @@ -74,8 +75,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( table1.update(). - where(table1.c.myid == 7). - values({table1.c.myid: 5}), + where(table1.c.myid == 7). + values({table1.c.myid: 5}), 'UPDATE mytable SET myid=:myid WHERE mytable.myid = :myid_1', checkparams={'myid': 5, 'myid_1': 7}) @@ -99,8 +100,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( update(table1, - whereclause=table1.c.name == bindparam('crit'), - values={table1.c.name: 'hi'}), + whereclause=table1.c.name == bindparam('crit'), + values={table1.c.name: 'hi'}), 'UPDATE mytable SET name=:name WHERE mytable.name = :crit', params={'crit': 'notthere'}, checkparams={'crit': 'notthere', 'name': 'hi'}) @@ -110,8 +111,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( update(table1, - table1.c.myid == 12, - values={table1.c.name: table1.c.myid}), + table1.c.myid == 12, + values={table1.c.name: table1.c.myid}), 'UPDATE mytable ' 'SET name=mytable.myid, description=:description ' 'WHERE mytable.myid = :myid_1', @@ -152,8 +153,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): update(table1, table1.c.myid == 12, values=v1).values(v2), 'UPDATE mytable ' 'SET ' - 'name=(mytable.name || :name_1), ' - 'description=:description ' + 'name=(mytable.name || :name_1), ' + 'description=:description ' 'WHERE mytable.myid = :myid_1', params={'description': 'test'}) @@ -164,29 +165,32 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1.c.name: table1.c.name + 'lala', table1.c.myid: func.do_stuff(table1.c.myid, literal('hoho')) } - self.assert_compile(update(table1, - (table1.c.myid == func.hoho(4)) & - (table1.c.name == literal('foo') + - table1.c.name + literal('lala')), - values=values), + self.assert_compile( + update( + table1, + (table1.c.myid == func.hoho(4)) & ( + table1.c.name == literal('foo') + + table1.c.name + + literal('lala')), + values=values), 'UPDATE mytable ' 'SET ' - 'myid=do_stuff(mytable.myid, :param_1), ' - 'name=(mytable.name || :name_1) ' + 'myid=do_stuff(mytable.myid, :param_1), ' + 'name=(mytable.name || :name_1) ' 'WHERE ' - 'mytable.myid = hoho(:hoho_1) AND ' - 'mytable.name = :param_2 || mytable.name || :param_3') + 'mytable.myid = hoho(:hoho_1) AND ' + 'mytable.name = :param_2 || mytable.name || :param_3') def test_where_empty(self): table1 = self.tables.mytable self.assert_compile( - table1.update().where(and_()), - "UPDATE mytable SET myid=:myid, name=:name, description=:description" - ) + table1.update().where( + and_()), + "UPDATE mytable SET myid=:myid, name=:name, description=:description") self.assert_compile( - table1.update().where(or_()), - "UPDATE mytable SET myid=:myid, name=:name, description=:description" - ) + table1.update().where( + or_()), + "UPDATE mytable SET myid=:myid, name=:name, description=:description") def test_prefix_with(self): table1 = self.tables.mytable @@ -196,14 +200,14 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): prefix_with('C', 'D') self.assert_compile(stmt, - 'UPDATE C D mytable SET myid=:myid, name=:name, ' - 'description=:description') + 'UPDATE C D mytable SET myid=:myid, name=:name, ' + 'description=:description') - self.assert_compile(stmt, + self.assert_compile( + stmt, 'UPDATE A B C D mytable SET myid=%s, name=%s, description=%s', dialect=mysql.dialect()) - def test_update_to_expression(self): """test update from an expression. @@ -216,7 +220,7 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): expr = func.foo(table1.c.myid) eq_(expr.key, None) self.assert_compile(table1.update().values({expr: 'bar'}), - 'UPDATE mytable SET foo(myid)=:param_1') + 'UPDATE mytable SET foo(myid)=:param_1') def test_update_bound_ordering(self): """test that bound parameters between the UPDATE and FROM clauses @@ -227,8 +231,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): table2 = self.tables.myothertable sel = select([table2]).where(table2.c.otherid == 5).alias() upd = table1.update().\ - where(table1.c.name == sel.c.othername).\ - values(name='foo') + where(table1.c.name == sel.c.othername).\ + values(name='foo') dialect = default.DefaultDialect() dialect.positional = True @@ -256,7 +260,6 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): ) - class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): __dialect__ = 'default' @@ -272,7 +275,7 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, # in values. The behavior here isn't really defined self.assert_compile( update(talias1, talias1.c.myid == 7). - values({table1.c.name: "fred"}), + values({table1.c.name: "fred"}), 'UPDATE mytable AS t1 ' 'SET name=:name ' 'WHERE t1.myid = :myid_1') @@ -287,13 +290,13 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, # as an "extra table", hence we see the full table name rendered. self.assert_compile( update(talias1, table1.c.myid == 7). - values({table1.c.name: 'fred'}), + values({table1.c.name: 'fred'}), 'UPDATE mytable AS t1 ' 'SET name=:mytable_name ' 'FROM mytable ' 'WHERE mytable.myid = :myid_1', checkparams={'mytable_name': 'fred', 'myid_1': 7}, - ) + ) def test_alias_two_mysql(self): table1 = self.tables.mytable @@ -301,7 +304,7 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, self.assert_compile( update(talias1, table1.c.myid == 7). - values({table1.c.name: 'fred'}), + values({table1.c.name: 'fred'}), "UPDATE mytable AS t1, mytable SET mytable.name=%s " "WHERE mytable.myid = %s", checkparams={'mytable_name': 'fred', 'myid_1': 7}, @@ -312,11 +315,11 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, self.assert_compile( users.update(). - values(name='newname').\ - values({addresses.c.name: "new address"}).\ - where(users.c.id == addresses.c.user_id), + values(name='newname'). + values({addresses.c.name: "new address"}). + where(users.c.id == addresses.c.user_id), "UPDATE users, addresses SET addresses.name=%s, " - "users.name=%s WHERE users.id = addresses.user_id", + "users.name=%s WHERE users.id = addresses.user_id", checkparams={'addresses_name': 'new address', 'name': 'newname'}, dialect='mysql' ) @@ -326,14 +329,14 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, self.assert_compile( users.update(). - values(name='newname'). - where(users.c.id == addresses.c.user_id). - where(addresses.c.email_address == 'e1'), + values(name='newname'). + where(users.c.id == addresses.c.user_id). + where(addresses.c.email_address == 'e1'), 'UPDATE users ' 'SET name=:name FROM addresses ' 'WHERE ' - 'users.id = addresses.user_id AND ' - 'addresses.email_address = :email_address_1', + 'users.id = addresses.user_id AND ' + 'addresses.email_address = :email_address_1', checkparams={'email_address_1': 'e1', 'name': 'newname'}) def test_render_multi_table(self): @@ -349,19 +352,19 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, self.assert_compile( users.update(). - values(name='newname'). - where(users.c.id == addresses.c.user_id). - where(addresses.c.email_address == 'e1'). - where(addresses.c.id == dingalings.c.address_id). - where(dingalings.c.id == 2), + values(name='newname'). + where(users.c.id == addresses.c.user_id). + where(addresses.c.email_address == 'e1'). + where(addresses.c.id == dingalings.c.address_id). + where(dingalings.c.id == 2), 'UPDATE users ' 'SET name=:name ' 'FROM addresses, dingalings ' 'WHERE ' - 'users.id = addresses.user_id AND ' - 'addresses.email_address = :email_address_1 AND ' - 'addresses.id = dingalings.address_id AND ' - 'dingalings.id = :id_1', + 'users.id = addresses.user_id AND ' + 'addresses.email_address = :email_address_1 AND ' + 'addresses.id = dingalings.address_id AND ' + 'dingalings.id = :id_1', checkparams=checkparams) def test_render_table_mysql(self): @@ -369,14 +372,14 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, self.assert_compile( users.update(). - values(name='newname'). - where(users.c.id == addresses.c.user_id). - where(addresses.c.email_address == 'e1'), + values(name='newname'). + where(users.c.id == addresses.c.user_id). + where(addresses.c.email_address == 'e1'), 'UPDATE users, addresses ' 'SET users.name=%s ' 'WHERE ' - 'users.id = addresses.user_id AND ' - 'addresses.email_address = %s', + 'users.id = addresses.user_id AND ' + 'addresses.email_address = %s', checkparams={'email_address_1': 'e1', 'name': 'newname'}, dialect=mysql.dialect()) @@ -398,17 +401,17 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, subq = select(cols).where(addresses.c.id == 7).alias() self.assert_compile( users.update(). - values(name='newname'). - where(users.c.id == subq.c.user_id). - where(subq.c.email_address == 'e1'), + values(name='newname'). + where(users.c.id == subq.c.user_id). + where(subq.c.email_address == 'e1'), 'UPDATE users ' 'SET name=:name FROM (' - 'SELECT ' - 'addresses.id AS id, ' - 'addresses.user_id AS user_id, ' - 'addresses.email_address AS email_address ' - 'FROM addresses ' - 'WHERE addresses.id = :id_1' + 'SELECT ' + 'addresses.id AS id, ' + 'addresses.user_id AS user_id, ' + 'addresses.email_address AS email_address ' + 'FROM addresses ' + 'WHERE addresses.id = :id_1' ') AS anon_1 ' 'WHERE users.id = anon_1.user_id ' 'AND anon_1.email_address = :email_address_1', @@ -424,9 +427,9 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): testing.db.execute( addresses.update(). - values(email_address=users.c.name). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + values(email_address=users.c.name). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed')) expected = [ (1, 7, 'x', 'jack@bean.com'), @@ -443,10 +446,10 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): a1 = addresses.alias() testing.db.execute( addresses.update(). - values(email_address=users.c.name). - where(users.c.id == a1.c.user_id). - where(users.c.name == 'ed'). - where(a1.c.id == addresses.c.id) + values(email_address=users.c.name). + where(users.c.id == a1.c.user_id). + where(users.c.name == 'ed'). + where(a1.c.id == addresses.c.id) ) expected = [ @@ -465,11 +468,11 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): testing.db.execute( addresses.update(). - values(email_address=users.c.name). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed'). - where(addresses.c.id == dingalings.c.address_id). - where(dingalings.c.id == 1)) + values(email_address=users.c.name). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed'). + where(addresses.c.id == dingalings.c.address_id). + where(dingalings.c.id == 1)) expected = [ (1, 7, 'x', 'jack@bean.com'), @@ -490,9 +493,9 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): testing.db.execute( addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + values(values). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed')) expected = [ (1, 7, 'x', 'jack@bean.com'), @@ -520,9 +523,9 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): testing.db.execute( addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + values(values). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed')) expected = [ (1, 7, 'x', 'jack@bean.com'), @@ -565,7 +568,7 @@ class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, test_needs_autoincrement=True), Column('user_id', None, ForeignKey('users.id')), Column('email_address', String(50), nullable=False), - ) + ) Table('foobar', metadata, Column('id', Integer, primary_key=True, @@ -573,7 +576,7 @@ class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, Column('user_id', None, ForeignKey('users.id')), Column('data', String(30)), Column('some_update', String(30), onupdate='im the other update') - ) + ) @classmethod def fixtures(cls): @@ -608,9 +611,9 @@ class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, ret = testing.db.execute( addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + values(values). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed')) eq_(set(ret.prefetch_cols()), set([users.c.some_update])) @@ -636,9 +639,9 @@ class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, ret = testing.db.execute( users.update(). - values(values). - where(users.c.id == foobar.c.user_id). - where(users.c.name == 'ed')) + values(values). + where(users.c.id == foobar.c.user_id). + where(users.c.name == 'ed')) eq_( set(ret.prefetch_cols()), @@ -662,9 +665,9 @@ class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, ret = testing.db.execute( addresses.update(). - values({'email_address': users.c.name}). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + values({'email_address': users.c.name}). + where(users.c.id == addresses.c.user_id). + where(users.c.name == 'ed')) eq_(ret.prefetch_cols(), []) @@ -35,6 +35,6 @@ commands = python -m flake8 setup.py sqla_nose.py test/aaa_profiling/ [flake8] show-source = True -ignore = E711,E265,H305,H307,H402,H405,H703,H803,H904 +ignore = E711,E712,F841,F811 exclude=.venv,.git,.tox,dist,doc,*egg,build |