diff options
| author | Mike Bayer <mike_mp@zzzcomputing.com> | 2019-01-06 01:14:26 -0500 |
|---|---|---|
| committer | mike bayer <mike_mp@zzzcomputing.com> | 2019-01-06 17:34:50 +0000 |
| commit | 1e1a38e7801f410f244e4bbb44ec795ae152e04e (patch) | |
| tree | 28e725c5c8188bd0cfd133d1e268dbca9b524978 /test/sql | |
| parent | 404e69426b05a82d905cbb3ad33adafccddb00dd (diff) | |
| download | sqlalchemy-1e1a38e7801f410f244e4bbb44ec795ae152e04e.tar.gz | |
Run black -l 79 against all source files
This is a straight reformat run using black as is, with no edits
applied at all.
The black run will format code consistently, however in
some cases that are prevalent in SQLAlchemy code it produces
too-long lines. The too-long lines will be resolved in the
following commit that will resolve all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.
Change-Id: I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9
Diffstat (limited to 'test/sql')
30 files changed, 15430 insertions, 12875 deletions
diff --git a/test/sql/test_case_statement.py b/test/sql/test_case_statement.py index d81ff20cd..181dd79a1 100644 --- a/test/sql/test_case_statement.py +++ b/test/sql/test_case_statement.py @@ -1,51 +1,73 @@ from sqlalchemy.testing import assert_raises, eq_, assert_raises_message from sqlalchemy.testing import fixtures, AssertsCompiledSQL from sqlalchemy import ( - testing, exc, case, select, literal_column, text, and_, Integer, cast, - String, Column, Table, MetaData) + testing, + exc, + case, + select, + literal_column, + text, + and_, + Integer, + cast, + String, + Column, + Table, + MetaData, +) from sqlalchemy.sql import table, column info_table = None class CaseTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): metadata = MetaData(testing.db) global info_table info_table = Table( - 'infos', metadata, - Column('pk', Integer, primary_key=True), - Column('info', String(30))) + "infos", + metadata, + Column("pk", Integer, primary_key=True), + Column("info", String(30)), + ) info_table.create() info_table.insert().execute( - {'pk': 1, 'info': 'pk_1_data'}, - {'pk': 2, 'info': 'pk_2_data'}, - {'pk': 3, 'info': 'pk_3_data'}, - {'pk': 4, 'info': 'pk_4_data'}, - {'pk': 5, 'info': 'pk_5_data'}, - {'pk': 6, 'info': 'pk_6_data'}) + {"pk": 1, "info": "pk_1_data"}, + {"pk": 2, "info": "pk_2_data"}, + {"pk": 3, "info": "pk_3_data"}, + {"pk": 4, "info": "pk_4_data"}, + {"pk": 5, "info": "pk_5_data"}, + {"pk": 6, "info": "pk_6_data"}, + ) @classmethod def teardown_class(cls): info_table.drop() - @testing.fails_on('firebird', 'FIXME: unknown') + @testing.fails_on("firebird", "FIXME: unknown") @testing.requires.subqueries def test_case(self): inner = select( [ case( [ - [info_table.c.pk < 3, 'lessthan3'], + [info_table.c.pk < 3, "lessthan3"], [ and_(info_table.c.pk >= 3, info_table.c.pk < 7), - 'gt3']]).label('x'), - info_table.c.pk, info_table.c.info], from_obj=[info_table]) + "gt3", + ], + ] + ).label("x"), + info_table.c.pk, + info_table.c.info, + ], + from_obj=[info_table], + ) inner_result = inner.execute().fetchall() @@ -57,25 +79,25 @@ class CaseTest(fixtures.TestBase, AssertsCompiledSQL): # gt3 5 pk_5_data # gt3 6 pk_6_data assert inner_result == [ - ('lessthan3', 1, 'pk_1_data'), - ('lessthan3', 2, 'pk_2_data'), - ('gt3', 3, 'pk_3_data'), - ('gt3', 4, 'pk_4_data'), - ('gt3', 5, 'pk_5_data'), - ('gt3', 6, 'pk_6_data') + ("lessthan3", 1, "pk_1_data"), + ("lessthan3", 2, "pk_2_data"), + ("gt3", 3, "pk_3_data"), + ("gt3", 4, "pk_4_data"), + ("gt3", 5, "pk_5_data"), + ("gt3", 6, "pk_6_data"), ] - outer = select([inner.alias('q_inner')]) + outer = select([inner.alias("q_inner")]) outer_result = outer.execute().fetchall() assert outer_result == [ - ('lessthan3', 1, 'pk_1_data'), - ('lessthan3', 2, 'pk_2_data'), - ('gt3', 3, 'pk_3_data'), - ('gt3', 4, 'pk_4_data'), - ('gt3', 5, 'pk_5_data'), - ('gt3', 6, 'pk_6_data') + ("lessthan3", 1, "pk_1_data"), + ("lessthan3", 2, "pk_2_data"), + ("gt3", 3, "pk_3_data"), + ("gt3", 4, "pk_4_data"), + ("gt3", 5, "pk_5_data"), + ("gt3", 6, "pk_6_data"), ] w_else = select( @@ -83,48 +105,54 @@ class CaseTest(fixtures.TestBase, AssertsCompiledSQL): case( [ [info_table.c.pk < 3, cast(3, Integer)], - [ - and_( - info_table.c.pk >= 3, info_table.c.pk < 6), - 6]], - else_=0).label('x'), - info_table.c.pk, info_table.c.info], - from_obj=[info_table]) + [and_(info_table.c.pk >= 3, info_table.c.pk < 6), 6], + ], + else_=0, + ).label("x"), + info_table.c.pk, + info_table.c.info, + ], + from_obj=[info_table], + ) else_result = w_else.execute().fetchall() assert else_result == [ - (3, 1, 'pk_1_data'), - (3, 2, 'pk_2_data'), - (6, 3, 'pk_3_data'), - (6, 4, 'pk_4_data'), - (6, 5, 'pk_5_data'), - (0, 6, 'pk_6_data') + (3, 1, "pk_1_data"), + (3, 2, "pk_2_data"), + (6, 3, "pk_3_data"), + (6, 4, "pk_4_data"), + (6, 5, "pk_5_data"), + (0, 6, "pk_6_data"), ] def test_literal_interpretation_ambiguous(self): assert_raises_message( exc.ArgumentError, r"Ambiguous literal: 'x'. Use the 'text\(\)' function", - case, [("x", "y")] + case, + [("x", "y")], ) def test_literal_interpretation_ambiguous_tuple(self): assert_raises_message( exc.ArgumentError, r"Ambiguous literal: \('x', 'y'\). Use the 'text\(\)' function", - case, [(("x", "y"), "z")] + case, + [(("x", "y"), "z")], ) def test_literal_interpretation(self): - t = table('test', column('col1')) + t = table("test", column("col1")) self.assert_compile( case([("x", "y")], value=t.c.col1), - "CASE test.col1 WHEN :param_1 THEN :param_2 END") + "CASE test.col1 WHEN :param_1 THEN :param_2 END", + ) self.assert_compile( case([(t.c.col1 == 7, "y")], else_="z"), - "CASE WHEN (test.col1 = :col1_1) THEN :param_1 ELSE :param_2 END") + "CASE WHEN (test.col1 = :col1_1) THEN :param_1 ELSE :param_2 END", + ) def test_text_doesnt_explode(self): @@ -132,69 +160,81 @@ class CaseTest(fixtures.TestBase, AssertsCompiledSQL): select( [ case( - [ - ( - info_table.c.info == 'pk_4_data', - text("'yes'"))], - else_=text("'no'")) - ]).order_by(info_table.c.info), - + [(info_table.c.info == "pk_4_data", text("'yes'"))], + else_=text("'no'"), + ) + ] + ).order_by(info_table.c.info), select( [ case( [ ( - info_table.c.info == 'pk_4_data', - literal_column("'yes'"))], - else_=literal_column("'no'") - )] + info_table.c.info == "pk_4_data", + literal_column("'yes'"), + ) + ], + else_=literal_column("'no'"), + ) + ] ).order_by(info_table.c.info), - ]: if testing.against("firebird"): - eq_(s.execute().fetchall(), [ - ('no ', ), ('no ', ), ('no ', ), ('yes', ), - ('no ', ), ('no ', ), - ]) + eq_( + s.execute().fetchall(), + [ + ("no ",), + ("no ",), + ("no ",), + ("yes",), + ("no ",), + ("no ",), + ], + ) else: - eq_(s.execute().fetchall(), [ - ('no', ), ('no', ), ('no', ), ('yes', ), - ('no', ), ('no', ), - ]) + eq_( + s.execute().fetchall(), + [("no",), ("no",), ("no",), ("yes",), ("no",), ("no",)], + ) - @testing.fails_on('firebird', 'FIXME: unknown') + @testing.fails_on("firebird", "FIXME: unknown") def testcase_with_dict(self): query = select( [ case( { - info_table.c.pk < 3: 'lessthan3', - info_table.c.pk >= 3: 'gt3', - }, else_='other'), - info_table.c.pk, info_table.c.info + info_table.c.pk < 3: "lessthan3", + info_table.c.pk >= 3: "gt3", + }, + else_="other", + ), + info_table.c.pk, + info_table.c.info, ], - from_obj=[info_table]) + from_obj=[info_table], + ) assert query.execute().fetchall() == [ - ('lessthan3', 1, 'pk_1_data'), - ('lessthan3', 2, 'pk_2_data'), - ('gt3', 3, 'pk_3_data'), - ('gt3', 4, 'pk_4_data'), - ('gt3', 5, 'pk_5_data'), - ('gt3', 6, 'pk_6_data') + ("lessthan3", 1, "pk_1_data"), + ("lessthan3", 2, "pk_2_data"), + ("gt3", 3, "pk_3_data"), + ("gt3", 4, "pk_4_data"), + ("gt3", 5, "pk_5_data"), + ("gt3", 6, "pk_6_data"), ] simple_query = select( [ case( - {1: 'one', 2: 'two', }, - value=info_table.c.pk, else_='other'), - info_table.c.pk + {1: "one", 2: "two"}, value=info_table.c.pk, else_="other" + ), + info_table.c.pk, ], whereclause=info_table.c.pk < 4, - from_obj=[info_table]) + from_obj=[info_table], + ) assert simple_query.execute().fetchall() == [ - ('one', 1), - ('two', 2), - ('other', 3), + ("one", 1), + ("two", 2), + ("other", 3), ] diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py index f543b8677..f3305743a 100644 --- a/test/sql/test_compiler.py +++ b/test/sql/test_compiler.py @@ -10,147 +10,201 @@ styling and coherent test organization. """ -from sqlalchemy.testing import eq_, is_, assert_raises, \ - assert_raises_message, eq_ignore_whitespace +from sqlalchemy.testing import ( + eq_, + is_, + assert_raises, + assert_raises_message, + eq_ignore_whitespace, +) from sqlalchemy import testing 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, union, except_,\ - intersect, union_all, Boolean, distinct, join, outerjoin, asc, desc,\ - over, subquery, case, true, CheckConstraint, Sequence +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, + union, + except_, + intersect, + union_all, + Boolean, + distinct, + join, + outerjoin, + asc, + desc, + over, + subquery, + case, + true, + CheckConstraint, + Sequence, +) import decimal from sqlalchemy.util import u from sqlalchemy import exc, sql, util, types, schema 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 +from sqlalchemy.dialects import ( + mysql, + mssql, + postgresql, + oracle, + sqlite, + sybase, +) from sqlalchemy.dialects.postgresql.base import PGCompiler, PGDialect from sqlalchemy.ext.compiler import compiles from sqlalchemy.sql import compiler -table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), - ) +table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), +) table2 = table( - 'myothertable', - column('otherid', Integer), - column('othername', String), + "myothertable", column("otherid", Integer), column("othername", String) ) table3 = table( - 'thirdtable', - column('userid', Integer), - column('otherstuff', String), + "thirdtable", column("userid", Integer), column("otherstuff", String) ) metadata = MetaData() # table with a schema table4 = Table( - 'remotetable', metadata, - Column('rem_id', Integer, primary_key=True), - Column('datatype_id', Integer), - Column('value', String(20)), - schema='remote_owner' + "remotetable", + metadata, + Column("rem_id", Integer, primary_key=True), + Column("datatype_id", Integer), + Column("value", String(20)), + schema="remote_owner", ) # table with a 'multipart' schema table5 = Table( - 'remotetable', metadata, - Column('rem_id', Integer, primary_key=True), - Column('datatype_id', Integer), - Column('value', String(20)), - schema='dbo.remote_owner' + "remotetable", + metadata, + Column("rem_id", Integer, primary_key=True), + Column("datatype_id", Integer), + Column("value", String(20)), + schema="dbo.remote_owner", ) -users = table('users', - column('user_id'), - column('user_name'), - column('password'), - ) +users = table( + "users", 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') - ) +addresses = table( + "addresses", + 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), - ) +keyed = Table( + "keyed", + metadata, + Column("x", Integer, key="colx"), + Column("y", Integer, key="coly"), + Column("z", Integer), +) class SelectTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_attribute_sanity(self): - assert hasattr(table1, 'c') - assert hasattr(table1.select(), 'c') - assert not hasattr(table1.c.myid.self_group(), 'columns') - assert hasattr(table1.select().self_group(), 'columns') - assert not hasattr(table1.c.myid, 'columns') - assert not hasattr(table1.c.myid, 'c') - assert not hasattr(table1.select().c.myid, 'c') - assert not hasattr(table1.select().c.myid, 'columns') - assert not hasattr(table1.alias().c.myid, 'columns') - assert not hasattr(table1.alias().c.myid, 'c') + assert hasattr(table1, "c") + assert hasattr(table1.select(), "c") + assert not hasattr(table1.c.myid.self_group(), "columns") + assert hasattr(table1.select().self_group(), "columns") + assert not hasattr(table1.c.myid, "columns") + assert not hasattr(table1.c.myid, "c") + assert not hasattr(table1.select().c.myid, "c") + assert not hasattr(table1.select().c.myid, "columns") + assert not hasattr(table1.alias().c.myid, "columns") + assert not hasattr(table1.alias().c.myid, "c") if util.compat.py32: assert_raises_message( exc.InvalidRequestError, - 'Scalar Select expression has no ' - 'columns; use this object directly within a ' - 'column-level expression.', + "Scalar Select expression has no " + "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')) + "Scalar Select expression has no " + "columns; use this object directly within a " + "column-level expression.", + lambda: hasattr( + select([table1.c.myid]).as_scalar(), "columns" + ), + ) else: assert not hasattr( - select([table1.c.myid]).as_scalar().self_group(), - 'columns') - assert not hasattr(select([table1.c.myid]).as_scalar(), '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 - ) + + assert_raises( + exc.ArgumentError, + 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( + table1.select(), + "SELECT mytable.myid, mytable.name, " + "mytable.description FROM mytable", + ) self.assert_compile( - select( - [ - table1, - table2]), + select([table1, table2]), "SELECT mytable.myid, mytable.name, mytable.description, " "myothertable.otherid, myothertable.othername FROM mytable, " - "myothertable") + "myothertable", + ) def test_invalid_col_argument(self): assert_raises(exc.ArgumentError, select, table1) @@ -178,13 +232,12 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): exp1 = literal_column("Q") exp2 = literal_column("Y") self.assert_compile( - select([1]).limit(exp1).offset(exp2), - "SELECT 1 LIMIT Q OFFSET Y" + select([1]).limit(exp1).offset(exp2), "SELECT 1 LIMIT Q OFFSET Y" ) self.assert_compile( - select([1]).limit(bindparam('x')).offset(bindparam('y')), - "SELECT 1 LIMIT :x OFFSET :y" + select([1]).limit(bindparam("x")).offset(bindparam("y")), + "SELECT 1 LIMIT :x OFFSET :y", ) def test_limit_offset_no_int_coercion_two(self): @@ -196,14 +249,18 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): exc.CompileError, "This SELECT structure does not use a simple integer " "value for limit", - getattr, sel, "_limit" + getattr, + sel, + "_limit", ) assert_raises_message( exc.CompileError, "This SELECT structure does not use a simple integer " "value for offset", - getattr, sel, "_offset" + getattr, + sel, + "_offset", ) def test_limit_offset_no_int_coercion_three(self): @@ -215,37 +272,47 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): exc.CompileError, "This SELECT structure does not use a simple integer " "value for limit", - getattr, sel, "_limit" + getattr, + sel, + "_limit", ) assert_raises_message( exc.CompileError, "This SELECT structure does not use a simple integer " "value for offset", - getattr, sel, "_offset" + getattr, + sel, + "_offset", ) 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}), - (0, 0, "LIMIT :param_1 OFFSET :param_2", - {'param_1': 0, 'param_2': 0}), + ( + 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}), + ( + 0, + 0, + "LIMIT :param_1 OFFSET :param_2", + {"param_1": 0, "param_2": 0}, + ), ]: self.assert_compile( select([1]).limit(lim).offset(offset), "SELECT 1 " + exp, - checkparams=params + checkparams=params, ) def test_limit_offset_select_literal_binds(self): stmt = select([1]).limit(5).offset(6) self.assert_compile( - stmt, - "SELECT 1 LIMIT 5 OFFSET 6", - literal_binds=True + stmt, "SELECT 1 LIMIT 5 OFFSET 6", literal_binds=True ) def test_limit_offset_compound_select_literal_binds(self): @@ -253,25 +320,24 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( stmt, "SELECT 1 UNION SELECT 2 LIMIT 5 OFFSET 6", - literal_binds=True + literal_binds=True, ) def test_select_precol_compile_ordering(self): - s1 = select([column('x')]).select_from(text('a')).limit(5).as_scalar() + s1 = select([column("x")]).select_from(text("a")).limit(5).as_scalar() s2 = select([s1]).limit(10) class MyCompiler(compiler.SQLCompiler): - def get_select_precolumns(self, select, **kw): result = "" if select._limit: result += "FIRST %s " % self.process( - literal( - select._limit), **kw) + literal(select._limit), **kw + ) if select._offset: result += "SKIP %s " % self.process( - literal( - select._offset), **kw) + literal(select._offset), **kw + ) return result def limit_clause(self, select, **kw): @@ -279,13 +345,13 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): dialect = default.DefaultDialect() dialect.statement_compiler = MyCompiler - dialect.paramstyle = 'qmark' + dialect.paramstyle = "qmark" dialect.positional = True self.assert_compile( s2, "SELECT FIRST ? (SELECT FIRST ? x FROM a) AS anon_1", checkpositional=(10, 5), - dialect=dialect + dialect=dialect, ) def test_from_subquery(self): @@ -293,16 +359,15 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): another select, for the purposes of selecting from the exported columns of that select.""" - s = select([table1], table1.c.name == 'jack') + s = select([table1], table1.c.name == "jack") self.assert_compile( - select( - [s], - s.c.myid == 7), + 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") + "WHERE mytable.name = :name_1) WHERE myid = :myid_1", + ) sq = select([table1]) self.assert_compile( @@ -310,44 +375,42 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT myid, name, description FROM " "(SELECT mytable.myid AS myid, " "mytable.name AS name, mytable.description " - "AS description FROM mytable)" + "AS description FROM mytable)", ) - sq = select( - [table1], - ).alias('sq') + sq = select([table1]).alias("sq") self.assert_compile( sq.select(sq.c.myid == 7), "SELECT sq.myid, sq.name, sq.description FROM " "(SELECT mytable.myid AS myid, mytable.name AS name, " "mytable.description AS description FROM mytable) AS sq " - "WHERE sq.myid = :myid_1" + "WHERE sq.myid = :myid_1", ) sq = select( [table1, table2], and_(table1.c.myid == 7, table2.c.otherid == table1.c.myid), - use_labels=True - ).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 "\ + use_labels=True, + ).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" + ) 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.myothertable_othername FROM (%s) AS sq" % sqstring, + ) - sq2 = select( - [sq], - use_labels=True - ).alias('sq2') + sq2 = select([sq], use_labels=True).alias("sq2") self.assert_compile( sq2.select(), @@ -359,53 +422,53 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "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) + "FROM (%s) AS sq) AS sq2" % sqstring, + ) def test_select_from_clauselist(self): self.assert_compile( - select([ClauseList(column('a'), column('b'))] - ).select_from(text('sometable')), - 'SELECT a, b FROM sometable' + select([ClauseList(column("a"), column("b"))]).select_from( + text("sometable") + ), + "SELECT a, b FROM sometable", ) def test_use_labels(self): self.assert_compile( select([table1.c.myid == 5], use_labels=True), - "SELECT mytable.myid = :myid_1 AS anon_1 FROM mytable" + "SELECT mytable.myid = :myid_1 AS anon_1 FROM mytable", ) self.assert_compile( - select([func.foo()], use_labels=True), - "SELECT foo() AS foo_1" + select([func.foo()], use_labels=True), "SELECT foo() AS foo_1" ) # this is native_boolean=False for default dialect self.assert_compile( select([not_(True)], use_labels=True), - "SELECT :param_1 = 0 AS anon_1" + "SELECT :param_1 = 0 AS anon_1", ) self.assert_compile( select([cast("data", Integer)], use_labels=True), - "SELECT CAST(:param_1 AS INTEGER) AS anon_1" + "SELECT CAST(:param_1 AS INTEGER) AS anon_1", ) self.assert_compile( - select([func.sum( - func.lala(table1.c.myid).label('foo')).label('bar')]), - "SELECT sum(lala(mytable.myid)) AS bar FROM mytable" + select( + [func.sum(func.lala(table1.c.myid).label("foo")).label("bar")] + ), + "SELECT sum(lala(mytable.myid)) AS bar FROM mytable", ) self.assert_compile( - select([keyed]), - "SELECT keyed.x, keyed.y" - ", keyed.z FROM keyed" + select([keyed]), "SELECT keyed.x, keyed.y" ", keyed.z FROM keyed" ) self.assert_compile( select([keyed]).apply_labels(), "SELECT keyed.x AS keyed_x, keyed.y AS " - "keyed_y, keyed.z AS keyed_z FROM keyed" + "keyed_y, keyed.z AS keyed_z FROM keyed", ) def test_paramstyles(self): @@ -414,40 +477,40 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( stmt, "select ?, ?, ? from sometable", - dialect=default.DefaultDialect(paramstyle='qmark') + dialect=default.DefaultDialect(paramstyle="qmark"), ) self.assert_compile( stmt, "select :foo, :bar, :bat from sometable", - dialect=default.DefaultDialect(paramstyle='named') + dialect=default.DefaultDialect(paramstyle="named"), ) self.assert_compile( stmt, "select %s, %s, %s from sometable", - dialect=default.DefaultDialect(paramstyle='format') + dialect=default.DefaultDialect(paramstyle="format"), ) self.assert_compile( stmt, "select :1, :2, :3 from sometable", - dialect=default.DefaultDialect(paramstyle='numeric') + dialect=default.DefaultDialect(paramstyle="numeric"), ) self.assert_compile( stmt, "select %(foo)s, %(bar)s, %(bat)s from sometable", - dialect=default.DefaultDialect(paramstyle='pyformat') + dialect=default.DefaultDialect(paramstyle="pyformat"), ) def test_anon_param_name_on_keys(self): self.assert_compile( keyed.insert(), "INSERT INTO keyed (x, y, z) VALUES (%(colx)s, %(coly)s, %(z)s)", - dialect=default.DefaultDialect(paramstyle='pyformat') + dialect=default.DefaultDialect(paramstyle="pyformat"), ) self.assert_compile( keyed.c.coly == 5, "keyed.y = %(coly_1)s", - checkparams={'coly_1': 5}, - dialect=default.DefaultDialect(paramstyle='pyformat') + checkparams={"coly_1": 5}, + dialect=default.DefaultDialect(paramstyle="pyformat"), ) def test_dupe_columns(self): @@ -455,51 +518,54 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): element identity, not rendered result.""" self.assert_compile( - select([column('a'), column('a'), column('a')]), - "SELECT a, a, a", dialect=default.DefaultDialect() + select([column("a"), column("a"), column("a")]), + "SELECT a, a, a", + dialect=default.DefaultDialect(), ) - c = column('a') + c = column("a") self.assert_compile( - select([c, c, c]), - "SELECT a", dialect=default.DefaultDialect() + select([c, c, c]), "SELECT a", dialect=default.DefaultDialect() ) - a, b = column('a'), column('b') + a, b = column("a"), column("b") self.assert_compile( select([a, b, b, b, a, a]), - "SELECT a, b", dialect=default.DefaultDialect() + "SELECT a, b", + dialect=default.DefaultDialect(), ) # using alternate keys. - a, b, c = Column('a', Integer, key='b'), \ - Column('b', Integer), \ - Column('c', Integer, key='a') + a, b, c = ( + Column("a", Integer, key="b"), + 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() + "SELECT a, b, c", + dialect=default.DefaultDialect(), ) self.assert_compile( - select([bindparam('a'), bindparam('b'), bindparam('c')]), + 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([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( - select([column("a"), column("a"), column("a")]), - "SELECT a, a, a" + select([column("a"), column("a"), column("a")]), "SELECT a, a, a" ) - s = select([bindparam('a'), bindparam('b'), bindparam('c')]) - s = s.compile(dialect=default.DefaultDialect(paramstyle='qmark')) - eq_(s.positiontup, ['a', 'b', 'c']) + s = select([bindparam("a"), bindparam("b"), bindparam("c")]) + s = s.compile(dialect=default.DefaultDialect(paramstyle="qmark")) + eq_(s.positiontup, ["a", "b", "c"]) def test_nested_label_targeting(self): """test nested anonymous label generation. @@ -510,234 +576,275 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): s3 = select([s2], use_labels=True) s4 = s3.alias() s5 = select([s4], use_labels=True) - self.assert_compile(s5, - 'SELECT anon_1.anon_2_myid AS ' - 'anon_1_anon_2_myid, anon_1.anon_2_name AS ' - 'anon_1_anon_2_name, anon_1.anon_2_descript' - 'ion AS anon_1_anon_2_description FROM ' - '(SELECT anon_2.myid AS anon_2_myid, ' - 'anon_2.name AS anon_2_name, ' - 'anon_2.description AS anon_2_description ' - 'FROM (SELECT mytable.myid AS myid, ' - 'mytable.name AS name, mytable.description ' - 'AS description FROM mytable) AS anon_2) ' - 'AS anon_1') + self.assert_compile( + s5, + "SELECT anon_1.anon_2_myid AS " + "anon_1_anon_2_myid, anon_1.anon_2_name AS " + "anon_1_anon_2_name, anon_1.anon_2_descript" + "ion AS anon_1_anon_2_description FROM " + "(SELECT anon_2.myid AS anon_2_myid, " + "anon_2.name AS anon_2_name, " + "anon_2.description AS anon_2_description " + "FROM (SELECT mytable.myid AS myid, " + "mytable.name AS name, mytable.description " + "AS description FROM mytable) AS anon_2) " + "AS anon_1", + ) def test_nested_label_targeting_keyed(self): s1 = keyed.select() 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") + 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", + ) 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" - ) + 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", + ) 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)" - ) - - self.assert_compile(exists(s.as_scalar()), - "EXISTS (SELECT mytable.myid FROM mytable " - "WHERE mytable.myid = :myid_1)" - ) - - self.assert_compile(exists([table1.c.myid], table1.c.myid - == 5).select(), - 'SELECT EXISTS (SELECT mytable.myid FROM ' - 'mytable WHERE mytable.myid = :myid_1) AS anon_1', - params={'mytable_myid': 5}) - self.assert_compile(select([table1, exists([1], - from_obj=table2)]), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description, EXISTS (SELECT 1 ' - 'FROM myothertable) AS anon_1 FROM mytable', - params={}) - 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( + exists(s), + "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)", + ) + + self.assert_compile( + exists([table1.c.myid], table1.c.myid == 5).select(), + "SELECT EXISTS (SELECT mytable.myid FROM " + "mytable WHERE mytable.myid = :myid_1) AS anon_1", + params={"mytable_myid": 5}, + ) + self.assert_compile( + select([table1, exists([1], from_obj=table2)]), + "SELECT mytable.myid, mytable.name, " + "mytable.description, EXISTS (SELECT 1 " + "FROM myothertable) AS anon_1 FROM mytable", + params={}, + ) + 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)') + 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)') + 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)') + 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([ - or_( - exists().where(table2.c.otherid == 'foo'), - exists().where(table2.c.otherid == 'bar') - ) - ]), + 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( + [ + or_( + exists().where(table2.c.otherid == "foo"), + exists().where(table2.c.otherid == "bar"), + ) + ] + ), "SELECT (EXISTS (SELECT * FROM myothertable " "WHERE myothertable.otherid = :otherid_1)) " "OR (EXISTS (SELECT * FROM myothertable WHERE " - "myothertable.otherid = :otherid_2)) AS anon_1" + "myothertable.otherid = :otherid_2)) AS anon_1", ) self.assert_compile( - select([exists([1])]), - "SELECT EXISTS (SELECT 1) AS anon_1" + select([exists([1])]), "SELECT EXISTS (SELECT 1) AS anon_1" ) self.assert_compile( - select([~exists([1])]), - "SELECT NOT (EXISTS (SELECT 1)) AS anon_1" + select([~exists([1])]), "SELECT NOT (EXISTS (SELECT 1)) AS anon_1" ) self.assert_compile( select([~(~exists([1]))]), - "SELECT NOT (NOT (EXISTS (SELECT 1))) AS anon_1" + "SELECT NOT (NOT (EXISTS (SELECT 1))) 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') + s = select( + [addresses.c.street], + addresses.c.user_id == users.c.user_id, + correlate=True, + ).alias("s") # don't correlate in a FROM list - self.assert_compile(select([users, s.c.street], from_obj=s), - "SELECT users.user_id, users.user_name, " - "users.password, s.street FROM users, " - "(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( + select([users, s.c.street], from_obj=s), + "SELECT users.user_id, users.user_name, " + "users.password, s.street FROM users, " + "(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 + 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)), - '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)) - self.assert_compile(select([s, table1]), - 'SELECT sq2.myid, sq2.name, ' - 'sq2.description, mytable.myid, ' - 'mytable.name, mytable.description FROM ' - '(SELECT ta.myid AS myid, ta.name AS name, ' - 'ta.description AS description FROM ' - 'mytable AS ta WHERE EXISTS (SELECT 1 FROM ' - 'myothertable WHERE myothertable.otherid = ' - 'ta.myid)) AS sq2, mytable') + "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)), + "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) + ) + self.assert_compile( + select([s, table1]), + "SELECT sq2.myid, sq2.name, " + "sq2.description, mytable.myid, " + "mytable.name, mytable.description FROM " + "(SELECT ta.myid AS myid, ta.name AS name, " + "ta.description AS description FROM " + "mytable AS ta WHERE EXISTS (SELECT 1 FROM " + "myothertable WHERE myothertable.otherid = " + "ta.myid)) AS sq2, mytable", + ) # test constructing the outer query via append_column(), which # occurs in the ORM's Query object - s = select([], exists([1], table2.c.otherid == table1.c.myid), - from_obj=table1) + s = select( + [], exists([1], table2.c.otherid == table1.c.myid), from_obj=table1 + ) s.append_column(table1) - self.assert_compile(s, - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description FROM mytable WHERE ' - 'EXISTS (SELECT 1 FROM myothertable WHERE ' - 'myothertable.otherid = mytable.myid)') + self.assert_compile( + s, + "SELECT mytable.myid, mytable.name, " + "mytable.description FROM mytable WHERE " + "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=[ - desc(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) DESC') + [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, + ) + ) + ] + ), + "SELECT mytable.myid, mytable.name, " + "mytable.description FROM mytable ORDER BY " + "(SELECT myothertable.otherid FROM " + "myothertable WHERE mytable.myid = " + "myothertable.otherid) DESC", + ) def test_scalar_select(self): assert_raises_message( @@ -745,72 +852,86 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): r"Select objects don't have a type\. Call as_scalar\(\) " r"on this Select object to return a 'scalar' " r"version of this Select\.", - func.coalesce, select([table1.c.myid]) + func.coalesce, + select([table1.c.myid]), ) s = select([table1.c.myid], correlate=False).as_scalar() - self.assert_compile(select([table1, s]), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description, (SELECT mytable.myid ' - 'FROM mytable) AS anon_1 FROM mytable') + self.assert_compile( + select([table1, s]), + "SELECT mytable.myid, mytable.name, " + "mytable.description, (SELECT mytable.myid " + "FROM mytable) AS anon_1 FROM mytable", + ) s = select([table1.c.myid]).as_scalar() - self.assert_compile(select([table2, s]), - 'SELECT myothertable.otherid, ' - 'myothertable.othername, (SELECT ' - 'mytable.myid FROM mytable) AS anon_1 FROM ' - 'myothertable') + self.assert_compile( + select([table2, s]), + "SELECT myothertable.otherid, " + "myothertable.othername, (SELECT " + "mytable.myid FROM mytable) AS anon_1 FROM " + "myothertable", + ) s = select([table1.c.myid]).correlate(None).as_scalar() - self.assert_compile(select([table1, s]), - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description, (SELECT mytable.myid ' - 'FROM mytable) AS anon_1 FROM mytable') + self.assert_compile( + select([table1, s]), + "SELECT mytable.myid, mytable.name, " + "mytable.description, (SELECT mytable.myid " + "FROM mytable) AS anon_1 FROM mytable", + ) s = select([table1.c.myid]).as_scalar() s2 = s.where(table1.c.myid == 5) self.assert_compile( s2, - "(SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1)" - ) - self.assert_compile( - s, "(SELECT mytable.myid FROM mytable)" + "(SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1)", ) + self.assert_compile(s, "(SELECT mytable.myid FROM mytable)") # test that aliases use as_scalar() when used in an explicitly # scalar context s = select([table1.c.myid]).alias() - self.assert_compile(select([table1.c.myid]).where(table1.c.myid - == 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), - 'SELECT mytable.myid FROM mytable WHERE ' - 'mytable.myid < (SELECT mytable.myid FROM ' - 'mytable)') + self.assert_compile( + select([table1.c.myid]).where(table1.c.myid == 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), + "SELECT mytable.myid FROM mytable WHERE " + "mytable.myid < (SELECT mytable.myid FROM " + "mytable)", + ) s = select([table1.c.myid]).as_scalar() - self.assert_compile(select([table2, s]), - 'SELECT myothertable.otherid, ' - 'myothertable.othername, (SELECT ' - 'mytable.myid FROM mytable) AS anon_1 FROM ' - 'myothertable') + self.assert_compile( + select([table2, s]), + "SELECT myothertable.otherid, " + "myothertable.othername, (SELECT " + "mytable.myid FROM mytable) AS anon_1 FROM " + "myothertable", + ) # test expressions against scalar selects - 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]).as_scalar() - + 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') + 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]).as_scalar() + 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", + ) # scalar selects should not have any attributes on their 'c' or # 'columns' attribute @@ -819,101 +940,129 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): try: s.c.foo except exc.InvalidRequestError as err: - assert str(err) \ - == 'Scalar Select expression has no columns; use this '\ - 'object directly within a column-level expression.' + assert ( + str(err) + == "Scalar Select expression has no columns; use this " + "object directly within a column-level expression." + ) try: s.columns.foo except exc.InvalidRequestError as err: - assert str(err) \ - == 'Scalar Select expression has no columns; use this '\ - 'object directly within a column-level expression.' - - zips = table('zips', - column('zipcode'), - column('latitude'), - column('longitude'), - ) - places = table('places', - column('id'), - column('nm') - ) - zip = '12345' - qlat = select([zips.c.latitude], zips.c.zipcode == zip).\ - correlate(None).as_scalar() - qlng = select([zips.c.longitude], zips.c.zipcode == zip).\ - 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] - ) - - self.assert_compile(q, - 'SELECT places.id, places.nm, ' - 'zips.zipcode, latlondist((SELECT ' - 'zips.latitude FROM zips WHERE ' - 'zips.zipcode = :zipcode_1), (SELECT ' - 'zips.longitude FROM zips WHERE ' - 'zips.zipcode = :zipcode_2)) AS dist FROM ' - 'places, zips WHERE zips.zipcode = ' - ':zipcode_3 ORDER BY dist, places.nm') - - zalias = zips.alias('main_zip') - qlat = select([zips.c.latitude], zips.c.zipcode == zalias.c.zipcode).\ - as_scalar() - qlng = select([zips.c.longitude], zips.c.zipcode == zalias.c.zipcode).\ - as_scalar() - q = select([places.c.id, places.c.nm, zalias.c.zipcode, - func.latlondist(qlat, qlng).label('dist')], - order_by=['dist', places.c.nm]) - self.assert_compile(q, - 'SELECT places.id, places.nm, ' - 'main_zip.zipcode, latlondist((SELECT ' - 'zips.latitude FROM zips WHERE ' - 'zips.zipcode = main_zip.zipcode), (SELECT ' - 'zips.longitude FROM zips WHERE ' - 'zips.zipcode = main_zip.zipcode)) AS dist ' - 'FROM places, zips AS main_zip ORDER BY ' - 'dist, places.nm') - - a1 = table2.alias('t2alias') + assert ( + str(err) + == "Scalar Select expression has no columns; use this " + "object directly within a column-level expression." + ) + + zips = table( + "zips", column("zipcode"), column("latitude"), column("longitude") + ) + places = table("places", column("id"), column("nm")) + zip = "12345" + qlat = ( + select([zips.c.latitude], zips.c.zipcode == zip) + .correlate(None) + .as_scalar() + ) + qlng = ( + select([zips.c.longitude], zips.c.zipcode == zip) + .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], + ) + + self.assert_compile( + q, + "SELECT places.id, places.nm, " + "zips.zipcode, latlondist((SELECT " + "zips.latitude FROM zips WHERE " + "zips.zipcode = :zipcode_1), (SELECT " + "zips.longitude FROM zips WHERE " + "zips.zipcode = :zipcode_2)) AS dist FROM " + "places, zips WHERE zips.zipcode = " + ":zipcode_3 ORDER BY dist, places.nm", + ) + + zalias = zips.alias("main_zip") + qlat = select( + [zips.c.latitude], zips.c.zipcode == zalias.c.zipcode + ).as_scalar() + qlng = select( + [zips.c.longitude], zips.c.zipcode == zalias.c.zipcode + ).as_scalar() + q = select( + [ + places.c.id, + places.c.nm, + zalias.c.zipcode, + func.latlondist(qlat, qlng).label("dist"), + ], + order_by=["dist", places.c.nm], + ) + self.assert_compile( + q, + "SELECT places.id, places.nm, " + "main_zip.zipcode, latlondist((SELECT " + "zips.latitude FROM zips WHERE " + "zips.zipcode = main_zip.zipcode), (SELECT " + "zips.longitude FROM zips WHERE " + "zips.zipcode = main_zip.zipcode)) AS dist " + "FROM places, zips AS main_zip ORDER BY " + "dist, places.nm", + ) + + a1 = table2.alias("t2alias") s1 = select([a1.c.otherid], table1.c.myid == a1.c.otherid).as_scalar() j1 = table1.join(table2, table1.c.myid == table2.c.otherid) s2 = select([table1, s1], from_obj=j1) - self.assert_compile(s2, - 'SELECT mytable.myid, mytable.name, ' - 'mytable.description, (SELECT ' - 't2alias.otherid FROM myothertable AS ' - 't2alias WHERE mytable.myid = ' - 't2alias.otherid) AS anon_1 FROM mytable ' - 'JOIN myothertable ON mytable.myid = ' - 'myothertable.otherid') + self.assert_compile( + s2, + "SELECT mytable.myid, mytable.name, " + "mytable.description, (SELECT " + "t2alias.otherid FROM myothertable AS " + "t2alias WHERE mytable.myid = " + "t2alias.otherid) AS anon_1 FROM mytable " + "JOIN myothertable ON mytable.myid = " + "myothertable.otherid", + ) def test_label_comparison_one(self): - x = func.lala(table1.c.myid).label('foo') - self.assert_compile(select([x], x == 5), - 'SELECT lala(mytable.myid) AS foo FROM ' - 'mytable WHERE lala(mytable.myid) = ' - ':param_1') + x = func.lala(table1.c.myid).label("foo") + self.assert_compile( + select([x], x == 5), + "SELECT lala(mytable.myid) AS foo FROM " + "mytable WHERE lala(mytable.myid) = " + ":param_1", + ) 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') - lab2 = func.somefunc(table1.c.name).label('bar') + lab1 = (table1.c.myid + 12).label("foo") + lab2 = func.somefunc(table1.c.name).label("bar") 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 - ) + 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, + ) # the function embedded label renders as the function self.assert_compile( @@ -921,16 +1070,17 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT mytable.myid + :myid_1 AS foo, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY hoho(mytable.myid + :myid_1), bar DESC", - dialect=dialect + dialect=dialect, ) # 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 - ) + 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, + ) # labels within functions in the columns clause render # with the expression @@ -939,98 +1089,92 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT mytable.myid + :myid_1 AS foo, " "foo(mytable.myid + :myid_1) AS foo_1 FROM mytable " "ORDER BY foo, foo(mytable.myid + :myid_1)", - dialect=dialect + dialect=dialect, ) - lx = (table1.c.myid + table1.c.myid).label('lx') - ly = (func.lower(table1.c.name) + table1.c.description).label('ly') + lx = (table1.c.myid + table1.c.myid).label("lx") + ly = (func.lower(table1.c.name) + table1.c.description).label("ly") self.assert_compile( select([lx, ly]).order_by(lx, ly.desc()), "SELECT mytable.myid + mytable.myid AS lx, " "lower(mytable.name) || mytable.description AS ly " "FROM mytable ORDER BY lx, ly DESC", - dialect=dialect + dialect=dialect, ) # expression isn't actually the same thing (even though label is) self.assert_compile( select([lab1, lab2]).order_by( - table1.c.myid.label('foo'), - desc(table1.c.name.label('bar')) + table1.c.myid.label("foo"), desc(table1.c.name.label("bar")) ), "SELECT mytable.myid + :myid_1 AS foo, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY mytable.myid, mytable.name DESC", - dialect=dialect + dialect=dialect, ) # it's also an exact match, not aliased etc. self.assert_compile( select([lab1, lab2]).order_by( - desc(table1.alias().c.name.label('bar')) + desc(table1.alias().c.name.label("bar")) ), "SELECT mytable.myid + :myid_1 AS foo, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY mytable_1.name DESC", - dialect=dialect + dialect=dialect, ) # but! it's based on lineage lab2_lineage = lab2.element._clone() self.assert_compile( - select([lab1, lab2]).order_by( - desc(lab2_lineage.label('bar')) - ), + select([lab1, lab2]).order_by(desc(lab2_lineage.label("bar"))), "SELECT mytable.myid + :myid_1 AS foo, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY bar DESC", - dialect=dialect + dialect=dialect, ) # here, 'name' is implicitly available, but w/ #3882 we don't # want to render a name that isn't specifically a Label elsewhere # in the query self.assert_compile( - select([table1.c.myid]).order_by(table1.c.name.label('name')), - "SELECT mytable.myid FROM mytable ORDER BY mytable.name" + select([table1.c.myid]).order_by(table1.c.name.label("name")), + "SELECT mytable.myid FROM mytable ORDER BY mytable.name", ) # as well as if it doesn't match self.assert_compile( select([table1.c.myid]).order_by( - func.lower(table1.c.name).label('name')), - "SELECT mytable.myid FROM mytable ORDER BY lower(mytable.name)" + func.lower(table1.c.name).label("name") + ), + "SELECT mytable.myid FROM mytable ORDER BY lower(mytable.name)", ) def test_order_by_labels_disabled(self): - lab1 = (table1.c.myid + 12).label('foo') - lab2 = func.somefunc(table1.c.name).label('bar') + 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)), + 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, " "somefunc(mytable.name) AS bar FROM mytable " "ORDER BY hoho(mytable.myid + :myid_1), " "somefunc(mytable.name) DESC", - dialect=dialect + dialect=dialect, ) def test_no_group_by_labels(self): - lab1 = (table1.c.myid + 12).label('foo') - lab2 = func.somefunc(table1.c.name).label('bar') + lab1 = (table1.c.myid + 12).label("foo") + lab2 = func.somefunc(table1.c.name).label("bar") dialect = default.DefaultDialect() self.assert_compile( @@ -1038,140 +1182,140 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT mytable.myid + :myid_1 AS foo, somefunc(mytable.name) " "AS bar FROM mytable GROUP BY mytable.myid + :myid_1, " "somefunc(mytable.name)", - dialect=dialect + dialect=dialect, ) def test_conjunctions(self): - a, b, c = text('a'), text('b'), text('c') + a, b, c = text("a"), text("b"), text("c") x = and_(a, b, c) assert isinstance(x.type, Boolean) - assert str(x) == 'a AND b AND c' + assert str(x) == "a AND b AND c" self.assert_compile( - select([x.label('foo')]), - 'SELECT a AND b AND c AS foo' + select([x.label("foo")]), "SELECT a AND b AND c AS foo" ) self.assert_compile( - and_(table1.c.myid == 12, table1.c.name == 'asdf', - table2.c.othername == 'foo', text("sysdate() = today()")), + and_( + table1.c.myid == 12, + table1.c.name == "asdf", + table2.c.othername == "foo", + text("sysdate() = today()"), + ), "mytable.myid = :myid_1 AND mytable.name = :name_1 " "AND myothertable.othername = " - ":othername_1 AND sysdate() = today()" + ":othername_1 AND sysdate() = today()", ) self.assert_compile( and_( table1.c.myid == 12, - or_(table2.c.othername == 'asdf', - table2.c.othername == 'foo', table2.c.otherid == 9), + or_( + table2.c.othername == "asdf", + table2.c.othername == "foo", + table2.c.otherid == 9, + ), text("sysdate() = today()"), ), - 'mytable.myid = :myid_1 AND (myothertable.othername = ' - ':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} + "mytable.myid = :myid_1 AND (myothertable.othername = " + ":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, + }, ) # test a generator self.assert_compile( and_( - conj for conj in [ - table1.c.myid == 12, - table1.c.name == 'asdf' - ] + conj for conj in [table1.c.myid == 12, table1.c.name == "asdf"] ), - "mytable.myid = :myid_1 AND mytable.name = :name_1" + "mytable.myid = :myid_1 AND mytable.name = :name_1", ) def test_nested_conjunctions_short_circuit(self): """test that empty or_(), and_() conjunctions are collapsed by an enclosing conjunction.""" - t = table('t', column('x')) + t = table("t", column("x")) self.assert_compile( - select([t]).where(and_(t.c.x == 5, - or_(and_(or_(t.c.x == 7))))), - "SELECT t.x FROM t WHERE t.x = :x_1 AND t.x = :x_2" + select([t]).where(and_(t.c.x == 5, 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))))), - "SELECT t.x FROM t WHERE t.x = :x_1 OR t.x = :x_2" + select([t]).where(and_(or_(t.c.x == 12, 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( + select([t]).where( and_( or_( or_(t.c.x == 12), - and_( - or_(), - or_(and_(t.c.x == 8)), - and_() - ) + and_(or_(), or_(and_(t.c.x == 8)), and_()), ) ) ), - "SELECT t.x FROM t WHERE t.x = :x_1 OR t.x = :x_2" + "SELECT t.x FROM t WHERE t.x = :x_1 OR t.x = :x_2", ) def test_true_short_circuit(self): - t = table('t', column('x')) + t = table("t", column("x")) self.assert_compile( select([t]).where(true()), "SELECT t.x FROM t WHERE 1 = 1", - dialect=default.DefaultDialect(supports_native_boolean=False) + dialect=default.DefaultDialect(supports_native_boolean=False), ) self.assert_compile( select([t]).where(true()), "SELECT t.x FROM t WHERE true", - dialect=default.DefaultDialect(supports_native_boolean=True) + dialect=default.DefaultDialect(supports_native_boolean=True), ) self.assert_compile( select([t]), "SELECT t.x FROM t", - dialect=default.DefaultDialect(supports_native_boolean=True) + dialect=default.DefaultDialect(supports_native_boolean=True), ) def test_distinct(self): self.assert_compile( select([table1.c.myid.distinct()]), - "SELECT DISTINCT mytable.myid FROM mytable" + "SELECT DISTINCT mytable.myid FROM mytable", ) self.assert_compile( select([distinct(table1.c.myid)]), - "SELECT DISTINCT mytable.myid FROM mytable" + "SELECT DISTINCT mytable.myid FROM mytable", ) self.assert_compile( select([table1.c.myid]).distinct(), - "SELECT DISTINCT mytable.myid FROM mytable" + "SELECT DISTINCT mytable.myid FROM mytable", ) self.assert_compile( select([func.count(table1.c.myid.distinct())]), - "SELECT count(DISTINCT mytable.myid) AS count_1 FROM mytable" + "SELECT count(DISTINCT mytable.myid) AS count_1 FROM mytable", ) self.assert_compile( select([func.count(distinct(table1.c.myid))]), - "SELECT count(DISTINCT mytable.myid) AS count_1 FROM mytable" + "SELECT count(DISTINCT mytable.myid) AS count_1 FROM mytable", ) def test_where_empty(self): self.assert_compile( select([table1.c.myid]).where(and_()), - "SELECT mytable.myid FROM mytable" + "SELECT mytable.myid FROM mytable", ) self.assert_compile( select([table1.c.myid]).where(or_()), - "SELECT mytable.myid FROM mytable" + "SELECT mytable.myid FROM mytable", ) def test_multiple_col_binds(self): @@ -1179,133 +1323,165 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): select( [literal_column("*")], or_( - table1.c.myid == 12, table1.c.myid == 'asdf', - table1.c.myid == 'foo') + table1.c.myid == 12, + table1.c.myid == "asdf", + table1.c.myid == "foo", + ), ), "SELECT * FROM mytable WHERE mytable.myid = :myid_1 " - "OR mytable.myid = :myid_2 OR mytable.myid = :myid_3" + "OR mytable.myid = :myid_2 OR mytable.myid = :myid_3", ) def test_order_by_nulls(self): self.assert_compile( - table2.select(order_by=[table2.c.otherid, - table2.c.othername.desc().nullsfirst()]), + table2.select( + order_by=[ + table2.c.otherid, + table2.c.othername.desc().nullsfirst(), + ] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " - "myothertable.othername DESC NULLS FIRST" + "myothertable.othername DESC NULLS FIRST", ) self.assert_compile( - table2.select(order_by=[ - table2.c.otherid, table2.c.othername.desc().nullslast()]), + table2.select( + order_by=[ + table2.c.otherid, + table2.c.othername.desc().nullslast(), + ] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " - "myothertable.othername DESC NULLS LAST" + "myothertable.othername DESC NULLS LAST", ) self.assert_compile( - table2.select(order_by=[ - table2.c.otherid.nullslast(), - table2.c.othername.desc().nullsfirst()]), + table2.select( + order_by=[ + 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" + "myothertable.othername DESC NULLS FIRST", ) self.assert_compile( - table2.select(order_by=[table2.c.otherid.nullsfirst(), - table2.c.othername.desc()]), + table2.select( + order_by=[ + table2.c.otherid.nullsfirst(), + table2.c.othername.desc(), + ] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid NULLS FIRST, " - "myothertable.othername DESC" + "myothertable.othername DESC", ) self.assert_compile( - table2.select(order_by=[table2.c.otherid.nullsfirst(), - table2.c.othername.desc().nullslast()]), + table2.select( + order_by=[ + table2.c.otherid.nullsfirst(), + table2.c.othername.desc().nullslast(), + ] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid NULLS FIRST, " - "myothertable.othername DESC NULLS LAST" + "myothertable.othername DESC NULLS LAST", ) def test_orderby_groupby(self): self.assert_compile( - table2.select(order_by=[table2.c.otherid, - asc(table2.c.othername)]), + table2.select( + order_by=[table2.c.otherid, asc(table2.c.othername)] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " - "myothertable.othername ASC" + "myothertable.othername ASC", ) self.assert_compile( - table2.select(order_by=[table2.c.otherid, - table2.c.othername.desc()]), + table2.select( + order_by=[table2.c.otherid, table2.c.othername.desc()] + ), "SELECT myothertable.otherid, myothertable.othername FROM " "myothertable ORDER BY myothertable.otherid, " - "myothertable.othername DESC" + "myothertable.othername DESC", ) # 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" + "myothertable.othername DESC", ) self.assert_compile( - table2.select().order_by(table2.c.otherid). - order_by(table2.c.othername.desc() - ).order_by(None), + table2.select() + .order_by(table2.c.otherid) + .order_by(table2.c.othername.desc()) + .order_by(None), "SELECT myothertable.otherid, myothertable.othername " - "FROM myothertable" + "FROM myothertable", ) 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" + "FROM myothertable GROUP BY myothertable.othername", ) # generative group by self.assert_compile( - select([table2.c.othername, func.count(table2.c.otherid)]). - group_by(table2.c.othername), + select( + [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" + "FROM myothertable GROUP BY myothertable.othername", ) self.assert_compile( - select([table2.c.othername, func.count(table2.c.otherid)]). - group_by(table2.c.othername).group_by(None), + select([table2.c.othername, func.count(table2.c.otherid)]) + .group_by(table2.c.othername) + .group_by(None), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " - "FROM myothertable" + "FROM myothertable", ) self.assert_compile( - select([table2.c.othername, func.count(table2.c.otherid)], - group_by=[table2.c.othername], - order_by=[table2.c.othername]), + select( + [table2.c.othername, func.count(table2.c.otherid)], + group_by=[table2.c.othername], + order_by=[table2.c.othername], + ), "SELECT myothertable.othername, " "count(myothertable.otherid) AS count_1 " "FROM myothertable " - "GROUP BY myothertable.othername ORDER BY myothertable.othername" + "GROUP BY myothertable.othername ORDER BY myothertable.othername", ) def test_custom_order_by_clause(self): class CustomCompiler(PGCompiler): def order_by_clause(self, select, **kw): - return super(CustomCompiler, self).\ - order_by_clause(select, **kw) + " CUSTOMIZED" + return ( + super(CustomCompiler, self).order_by_clause(select, **kw) + + " CUSTOMIZED" + ) class CustomDialect(PGDialect): - name = 'custom' + name = "custom" statement_compiler = CustomCompiler stmt = select([table1.c.myid]).order_by(table1.c.myid) @@ -1313,17 +1489,19 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT mytable.myid FROM mytable ORDER BY " "mytable.myid CUSTOMIZED", - dialect=CustomDialect() + dialect=CustomDialect(), ) def test_custom_group_by_clause(self): class CustomCompiler(PGCompiler): def group_by_clause(self, select, **kw): - return super(CustomCompiler, self).\ - group_by_clause(select, **kw) + " CUSTOMIZED" + return ( + super(CustomCompiler, self).group_by_clause(select, **kw) + + " CUSTOMIZED" + ) class CustomDialect(PGDialect): - name = 'custom' + name = "custom" statement_compiler = CustomCompiler stmt = select([table1.c.myid]).group_by(table1.c.myid) @@ -1331,44 +1509,51 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT mytable.myid FROM mytable GROUP BY " "mytable.myid CUSTOMIZED", - dialect=CustomDialect() + dialect=CustomDialect(), ) def test_for_update(self): self.assert_compile( table1.select(table1.c.myid == 7).with_for_update(), "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable WHERE mytable.myid = :myid_1 FOR UPDATE") + "FROM mytable WHERE mytable.myid = :myid_1 FOR UPDATE", + ) # not supported by dialect, should just use update self.assert_compile( table1.select(table1.c.myid == 7).with_for_update(nowait=True), "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable WHERE mytable.myid = :myid_1 FOR UPDATE") + "FROM mytable WHERE mytable.myid = :myid_1 FOR UPDATE", + ) assert_raises_message( exc.ArgumentError, "Unknown for_update argument: 'unknown_mode'", - table1.select, table1.c.myid == 7, for_update='unknown_mode' + 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". self.assert_compile( - select([table1.alias('foo')]), - "SELECT foo.myid, foo.name, foo.description FROM mytable AS foo") + select([table1.alias("foo")]), + "SELECT foo.myid, foo.name, foo.description FROM mytable AS foo", + ) for dialect in (oracle.dialect(),): self.assert_compile( - select([table1.alias('foo')]), + select([table1.alias("foo")]), "SELECT foo.myid, foo.name, foo.description FROM mytable foo", - dialect=dialect) + dialect=dialect, + ) self.assert_compile( select([table1.alias()]), "SELECT mytable_1.myid, mytable_1.name, mytable_1.description " - "FROM mytable AS mytable_1") + "FROM mytable AS mytable_1", + ) # create a select for a join of two tables. use_labels # means the column names will have labels tablename_columnname, @@ -1377,12 +1562,13 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # from the first table1. q = select( [table1, table2.c.otherid], - table1.c.myid == table2.c.otherid, use_labels=True + 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". - a = alias(q, 't2view') + a = alias(q, "t2view") # select from that alias, also using labels. two levels of labels # should produce two underscores. @@ -1401,26 +1587,26 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "myothertable_otherid FROM mytable, myothertable " "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" + "mytable.myid, mytable.name, mytable.description FROM mytable", ) 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'), + table1.select() + .prefix_with("SQL_CALC_FOUND_ROWS", 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() + dialect=mysql.dialect(), ) def test_render_binds_as_literal(self): @@ -1431,140 +1617,149 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): class Compiler(dialect.statement_compiler): ansi_bind_rules = True + dialect.statement_compiler = Compiler self.assert_compile( select([literal("someliteral")]), "SELECT 'someliteral' AS anon_1", - dialect=dialect + dialect=dialect, ) self.assert_compile( select([table1.c.myid + 3]), "SELECT mytable.myid + 3 AS anon_1 FROM mytable", - dialect=dialect + dialect=dialect, ) self.assert_compile( select([table1.c.myid.in_([4, 5, 6])]), "SELECT mytable.myid IN (4, 5, 6) AS anon_1 FROM mytable", - dialect=dialect + dialect=dialect, ) self.assert_compile( select([func.mod(table1.c.myid, 5)]), "SELECT mod(mytable.myid, 5) AS mod_1 FROM mytable", - dialect=dialect + dialect=dialect, ) self.assert_compile( select([literal("foo").in_([])]), "SELECT 1 != 1 AS anon_1", - dialect=dialect + dialect=dialect, ) self.assert_compile( select([literal(util.b("foo"))]), "SELECT 'foo' AS anon_1", - dialect=dialect + dialect=dialect, ) # test callable self.assert_compile( select([table1.c.myid == bindparam("foo", callable_=lambda: 5)]), "SELECT mytable.myid = 5 AS anon_1 FROM mytable", - dialect=dialect + dialect=dialect, ) - empty_in_dialect = default.DefaultDialect(empty_in_strategy='dynamic') + empty_in_dialect = default.DefaultDialect(empty_in_strategy="dynamic") empty_in_dialect.statement_compiler = Compiler assert_raises_message( exc.CompileError, "Bind parameter 'foo' without a " "renderable value not allowed here.", - bindparam("foo").in_( - []).compile, - dialect=empty_in_dialect) + bindparam("foo").in_([]).compile, + dialect=empty_in_dialect, + ) def test_collate(self): # columns clause self.assert_compile( - select([column('x').collate('bar')]), - "SELECT x COLLATE bar AS anon_1" + select([column("x").collate("bar")]), + "SELECT x COLLATE bar AS anon_1", ) # WHERE clause self.assert_compile( - select([column('x')]).where(column('x').collate('bar') == 'foo'), - "SELECT x WHERE (x COLLATE bar) = :param_1" + select([column("x")]).where(column("x").collate("bar") == "foo"), + "SELECT x WHERE (x COLLATE bar) = :param_1", ) # ORDER BY clause self.assert_compile( - select([column('x')]).order_by(column('x').collate('bar')), - "SELECT x ORDER BY x COLLATE bar" + select([column("x")]).order_by(column("x").collate("bar")), + "SELECT x ORDER BY x COLLATE bar", ) def test_literal(self): - self.assert_compile(select([literal('foo')]), - "SELECT :param_1 AS anon_1") + self.assert_compile( + select([literal("foo")]), "SELECT :param_1 AS anon_1" + ) self.assert_compile( - select( - [ - literal("foo") + - literal("bar")], - from_obj=[table1]), - "SELECT :param_1 || :param_2 AS anon_1 FROM mytable") + 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), - ) + value_tbl = table( + "values", + 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( + [ + 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" + "/ 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( + [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" + "(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( + [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" + "/ values.val1 > :param_1", ) def test_percent_chars(self): - t = table("table%name", - column("percent%"), - column("%(oneofthese)s"), - column("spaces % more spaces"), - ) + t = table( + "table%name", + 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 % ''' - '''more spaces" FROM "table%name"''' + """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): @@ -1572,22 +1767,31 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): join(table2, table1, table1.c.myid == table2.c.otherid).select(), "SELECT myothertable.otherid, myothertable.othername, " "mytable.myid, mytable.name, mytable.description FROM " - "myothertable JOIN mytable ON mytable.myid = myothertable.otherid" + "myothertable JOIN mytable ON mytable.myid = myothertable.otherid", ) self.assert_compile( select( [table1], - from_obj=[join(table1, table2, table1.c.myid - == table2.c.otherid)] + from_obj=[ + join(table1, table2, table1.c.myid == table2.c.otherid) + ], ), "SELECT mytable.myid, mytable.name, mytable.description FROM " - "mytable JOIN myothertable ON mytable.myid = myothertable.otherid") + "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)] + [ + join( + join( + table1, table2, table1.c.myid == table2.c.otherid + ), + table3, + table1.c.myid == table3.c.userid, + ) + ] ), "SELECT mytable.myid, mytable.name, mytable.description, " "myothertable.otherid, myothertable.othername, " @@ -1595,27 +1799,29 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "thirdtable.otherstuff FROM mytable JOIN myothertable " "ON mytable.myid =" " myothertable.otherid JOIN thirdtable ON " - "mytable.myid = thirdtable.userid" + "mytable.myid = thirdtable.userid", ) self.assert_compile( - join(users, addresses, users.c.user_id == - addresses.c.user_id).select(), + join( + users, addresses, users.c.user_id == 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 " "FROM users JOIN addresses " - "ON users.user_id = addresses.user_id" + "ON users.user_id = addresses.user_id", ) self.assert_compile( - select([table1, table2, table3], - - from_obj=[join(table1, table2, - table1.c.myid == table2.c.otherid). - outerjoin(table3, - table1.c.myid == table3.c.userid)] - ), + 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," @@ -1623,15 +1829,21 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "JOIN myothertable ON mytable.myid " "= myothertable.otherid LEFT OUTER JOIN thirdtable " "ON mytable.myid =" - " thirdtable.userid" + " 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( + [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," @@ -1639,47 +1851,49 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "(myothertable " "JOIN thirdtable ON myothertable.otherid = " "thirdtable.userid) ON " - "mytable.myid = myothertable.otherid" + "mytable.myid = myothertable.otherid", ) query = select( [table1, table2], or_( - table1.c.name == 'fred', + table1.c.name == "fred", table1.c.myid == 10, - table2.c.othername != 'jack', - text("EXISTS (select yay from foo where boo = lar)") + table2.c.othername != "jack", + text("EXISTS (select yay from foo where boo = lar)"), ), - from_obj=[outerjoin(table1, table2, - table1.c.myid == table2.c.otherid)] + from_obj=[ + outerjoin(table1, table2, table1.c.myid == table2.c.otherid) + ], ) self.assert_compile( - query, "SELECT mytable.myid, mytable.name, mytable.description, " + 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_full_outer_join(self): for spec in [ join(table1, table2, table1.c.myid == table2.c.otherid, full=True), outerjoin( - table1, table2, - table1.c.myid == table2.c.otherid, full=True), - table1.join( - table2, - table1.c.myid == table2.c.otherid, full=True), + table1, table2, table1.c.myid == table2.c.otherid, full=True + ), + table1.join(table2, table1.c.myid == table2.c.otherid, full=True), table1.outerjoin( - table2, - table1.c.myid == table2.c.otherid, full=True), + table2, table1.c.myid == table2.c.otherid, full=True + ), ]: stmt = select([table1]).select_from(spec) self.assert_compile( stmt, "SELECT mytable.myid, mytable.name, mytable.description FROM " "mytable FULL OUTER JOIN myothertable " - "ON mytable.myid = myothertable.otherid") + "ON mytable.myid = myothertable.otherid", + ) def test_compound_selects(self): assert_raises_message( @@ -1687,7 +1901,9 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "All selectables passed to CompoundSelect " "must have identical numbers of columns; " "select #1 has 2 columns, select #2 has 3", - union, table3.select(), table1.select() + union, + table3.select(), + table1.select(), ) x = union( @@ -1697,36 +1913,39 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): ) self.assert_compile( - x, "SELECT mytable.myid, mytable.name, " + 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]) + "ORDER BY mytable.myid", ) + + x = union(select([table1]), select([table1])) x = union(x, select([table1])) self.assert_compile( - x, "(SELECT mytable.myid, mytable.name, mytable.description " + 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") + " mytable.name, mytable.description FROM mytable", + ) u1 = union( select([table1.c.myid, table1.c.name]), select([table2]), - select([table3]) + select([table3]), ) self.assert_compile( - u1, "SELECT mytable.myid, mytable.name " + u1, + "SELECT mytable.myid, mytable.name " "FROM mytable UNION SELECT myothertable.otherid, " "myothertable.othername FROM myothertable " "UNION SELECT thirdtable.userid, thirdtable.otherstuff " - "FROM thirdtable") + "FROM thirdtable", + ) assert u1.corresponding_column(table2.c.otherid) is u1.c.myid @@ -1734,25 +1953,30 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): union( select([table1.c.myid, table1.c.name]), select([table2]), - order_by=['myid'], + order_by=["myid"], offset=10, - limit=5 + limit=5, ), "SELECT mytable.myid, mytable.name " "FROM mytable UNION SELECT myothertable.otherid, " "myothertable.othername " "FROM myothertable ORDER BY myid " # note table name is omitted "LIMIT :param_1 OFFSET :param_2", - {'param_1': 5, 'param_2': 10} + {"param_1": 5, "param_2": 10}, ) 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]), - table1.select(table1.c.name == 'name1') + select( + [ + 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, " "max(mytable.description) AS max_1 " @@ -1760,183 +1984,155 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "GROUP BY mytable.myid, " "mytable.name UNION SELECT mytable.myid, mytable.name, " "mytable.description " - "FROM mytable WHERE mytable.name = :name_2" + "FROM mytable WHERE mytable.name = :name_2", ) self.assert_compile( union( - select([literal(100).label('value')]), - select([literal(200).label('value')]) + 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( union_all( select([table1.c.myid]), - union( - select([table2.c.otherid]), - select([table3.c.userid]), - ) + union(select([table2.c.otherid]), select([table3.c.userid])), ), - "SELECT mytable.myid FROM mytable UNION ALL " "(SELECT myothertable.otherid FROM myothertable UNION " - "SELECT thirdtable.userid FROM thirdtable)" + "SELECT thirdtable.userid FROM thirdtable)", ) - s = select([column('foo'), column('bar')]) + s = select([column("foo"), column("bar")]) self.assert_compile( - union( - s.order_by("foo"), - s.order_by("bar")), + union(s.order_by("foo"), s.order_by("bar")), "(SELECT foo, bar ORDER BY foo) UNION " - "(SELECT foo, bar ORDER BY bar)") + "(SELECT foo, bar ORDER BY bar)", + ) self.assert_compile( - union(s.order_by("foo").self_group(), - s.order_by("bar").limit(10).self_group()), + union( + s.order_by("foo").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)", - {'param_1': 10} - + {"param_1": 10}, ) def test_compound_grouping(self): - s = select([column('foo'), column('bar')]).select_from(text('bat')) + s = select([column("foo"), column("bar")]).select_from(text("bat")) self.assert_compile( union(union(union(s, s), 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) UNION SELECT foo, bar FROM bat", ) self.assert_compile( union(s, s, 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( 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( select([s.alias()]), - 'SELECT anon_1.foo, anon_1.bar FROM ' - '(SELECT foo, bar FROM bat) AS anon_1' + "SELECT anon_1.foo, anon_1.bar FROM " + "(SELECT foo, bar FROM bat) AS anon_1", ) self.assert_compile( 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 anon_1.foo, anon_1.bar FROM " + "(SELECT foo, bar FROM bat UNION " + "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 anon_1.foo, anon_1.bar FROM " + "(SELECT foo, bar FROM bat EXCEPT " + "SELECT foo, bar FROM bat) AS anon_1", ) # this query sqlite specifically chokes on self.assert_compile( - union( - except_(s, s), - s - ), + union(except_(s, s), s), "(SELECT foo, bar FROM bat EXCEPT SELECT foo, bar FROM bat) " - "UNION SELECT foo, bar FROM bat" + "UNION SELECT foo, bar FROM bat", ) self.assert_compile( - union( - s, - except_(s, s), - ), + union(s, except_(s, s)), "SELECT foo, bar FROM bat " - "UNION (SELECT foo, bar FROM bat EXCEPT SELECT foo, bar FROM bat)" + "UNION (SELECT foo, bar FROM bat EXCEPT SELECT foo, bar FROM bat)", ) # this solves it self.assert_compile( - union( - except_(s, s).alias().select(), - s - ), + union(except_(s, s).alias().select(), s), "SELECT anon_1.foo, anon_1.bar FROM " "(SELECT foo, bar FROM bat EXCEPT " "SELECT foo, bar FROM bat) AS anon_1 " - "UNION SELECT foo, bar FROM bat" + "UNION SELECT foo, bar FROM bat", ) self.assert_compile( - except_( - union(s, s), - union(s, s) - ), + except_(union(s, s), union(s, s)), "(SELECT foo, bar FROM bat UNION SELECT foo, bar FROM bat) " - "EXCEPT (SELECT foo, bar FROM bat UNION SELECT foo, bar FROM bat)" + "EXCEPT (SELECT foo, bar FROM bat UNION SELECT foo, bar FROM bat)", ) s2 = union(s, s) s3 = union(s2, s2) - self.assert_compile(s3, "(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( + s3, + "(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( - union( - intersect(s, s), - intersect(s, s) - ), + union(intersect(s, s), intersect(s, s)), "(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)", ) # tests for [ticket:2528] # sqlite hates all of these. self.assert_compile( - union( - s.limit(1), - s.offset(2) - ), + union(s.limit(1), s.offset(2)), "(SELECT foo, bar FROM bat LIMIT :param_1) " - "UNION (SELECT foo, bar FROM bat LIMIT -1 OFFSET :param_2)" + "UNION (SELECT foo, bar FROM bat LIMIT -1 OFFSET :param_2)", ) self.assert_compile( - union( - s.order_by(column('bar')), - s.offset(2) - ), + union(s.order_by(column("bar")), s.offset(2)), "(SELECT foo, bar FROM bat ORDER BY bar) " - "UNION (SELECT foo, bar FROM bat LIMIT -1 OFFSET :param_1)" + "UNION (SELECT foo, bar FROM bat LIMIT -1 OFFSET :param_1)", ) self.assert_compile( - union( - s.limit(1).alias('a'), - s.limit(2).alias('b') - ), + union(s.limit(1).alias("a"), s.limit(2).alias("b")), "(SELECT foo, bar FROM bat LIMIT :param_1) " - "UNION (SELECT foo, bar FROM bat LIMIT :param_2)" + "UNION (SELECT foo, bar FROM bat LIMIT :param_2)", ) self.assert_compile( - union( - s.limit(1).self_group(), - s.limit(2).self_group() - ), + union(s.limit(1).self_group(), s.limit(2).self_group()), "(SELECT foo, bar FROM bat LIMIT :param_1) " - "UNION (SELECT foo, bar FROM bat LIMIT :param_2)" + "UNION (SELECT foo, bar FROM bat LIMIT :param_2)", ) self.assert_compile( @@ -1944,22 +2140,19 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT anon_1.foo, anon_1.bar FROM " "((SELECT foo, bar FROM bat LIMIT :param_1) " "UNION (SELECT foo, bar FROM bat LIMIT :param_2 OFFSET :param_3)) " - "AS anon_1" + "AS anon_1", ) # this version works for SQLite self.assert_compile( - union( - s.limit(1).alias().select(), - s.offset(2).alias().select(), - ), + union(s.limit(1).alias().select(), s.offset(2).alias().select()), "SELECT anon_1.foo, anon_1.bar " "FROM (SELECT foo, bar FROM bat" " LIMIT :param_1) AS anon_1 " "UNION SELECT anon_2.foo, anon_2.bar " "FROM (SELECT foo, bar " "FROM bat" - " LIMIT -1 OFFSET :param_2) AS anon_2" + " LIMIT -1 OFFSET :param_2) AS anon_2", ) def test_binds(self): @@ -1971,15 +2164,16 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): expected_default_params_list, test_param_dict, expected_test_params_dict, - expected_test_params_list + expected_test_params_list, ) in [ ( select( [table1, table2], and_( table1.c.myid == table2.c.otherid, - table1.c.name == bindparam('mytablename') - )), + table1.c.name == bindparam("mytablename"), + ), + ), "SELECT mytable.myid, mytable.name, mytable.description, " "myothertable.otherid, myothertable.othername FROM mytable, " "myothertable WHERE mytable.myid = myothertable.otherid " @@ -1988,55 +2182,80 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "myothertable.otherid, myothertable.othername FROM mytable, " "myothertable WHERE mytable.myid = myothertable.otherid AND " "mytable.name = ?", - {'mytablename': None}, [None], - {'mytablename': 5}, {'mytablename': 5}, [5] + {"mytablename": None}, + [None], + {"mytablename": 5}, + {"mytablename": 5}, + [5], ), ( - select([table1], or_(table1.c.myid == bindparam('myid'), - table2.c.otherid == bindparam('myid'))), + 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] + {"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"), + 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] + {"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( + [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] + {"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'"), + 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 @@ -2044,89 +2263,125 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): select( [table1], or_( - table1.c.myid == bindparam('myid'), - table2.c.otherid == bindparam('myotherid') - )).params({'myid': 8, 'myotherid': 7}), + 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] + {"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( + [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] + {"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()) + 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_( + [pp[k] for k in positional.positiontup], + expected_default_params_list, + ) - eq_(nonpositional.construct_params(test_param_dict), - expected_test_params_dict) + 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 + 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'))) - s2 = s.params({'myid': 8, 'myotherid': 7}) - s3 = s2.params({'myid': 9}) - assert s.compile().params == {'myid': None, 'myotherid': None} - assert s2.compile().params == {'myid': 8, 'myotherid': 7} - assert s3.compile().params == {'myid': 9, 'myotherid': 7} + s = select( + [table1], + or_( + table1.c.myid == bindparam("myid"), + 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} + assert s2.compile().params == {"myid": 8, "myotherid": 7} + assert s3.compile().params == {"myid": 9, "myotherid": 7} # 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, " + 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)") + "(SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1)", + ) positional = s2.compile(dialect=sqlite.dialect()) pp = positional.params assert [pp[k] for k in positional.positiontup] == [12, 12] # check that conflicts with "unique" params are caught - s = select([table1], or_(table1.c.myid == 7, - table1.c.myid == bindparam('myid_1'))) - assert_raises_message(exc.CompileError, - "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'))) - assert_raises_message(exc.CompileError, - "conflicts with unique bind parameter " - "of the same name", - str, s) + s = select( + [table1], + or_(table1.c.myid == 7, table1.c.myid == bindparam("myid_1")), + ) + assert_raises_message( + exc.CompileError, + "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"), + ), + ) + assert_raises_message( + exc.CompileError, + "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 @@ -2134,84 +2389,85 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): total_params = 100000 - in_clause = [':in%d' % i for i in range(total_params)] - params = dict(('in%d' % i, i) for i in range(total_params)) - t = text('text clause %s' % ', '.join(in_clause)) + in_clause = [":in%d" % i for i in range(total_params)] + params = dict(("in%d" % i, i) for i in range(total_params)) + t = text("text clause %s" % ", ".join(in_clause)) eq_(len(t.bindparams), total_params) c = t.compile() pp = c.construct_params(params) - eq_(len(set(pp)), total_params, '%s %s' % (len(set(pp)), len(pp))) + 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')) + t = table("foo", column("id")) - s = select([t, literal('lala').label('hoho')]) + s = select([t, literal("lala").label("hoho")]) self.assert_compile(s, "SELECT foo.id, :param_1 AS hoho FROM foo") assert [str(c) for c in s.c] == ["id", "hoho"] def test_bind_callable(self): - expr = column('x') == bindparam("key", callable_=lambda: 12) - self.assert_compile( - expr, - "x = :key", - {'x': 12} - ) + expr = column("x") == bindparam("key", callable_=lambda: 12) + self.assert_compile(expr, "x = :key", {"x": 12}) def test_bind_params_missing(self): assert_raises_message( exc.InvalidRequestError, r"A value is required for bind parameter 'x'", - select( - [table1]).where( + select([table1]) + .where( and_( table1.c.myid == bindparam("x", required=True), - table1.c.name == bindparam("y", required=True) + table1.c.name == bindparam("y", required=True), ) - ).compile().construct_params, - params=dict(y=5) + ) + .compile() + .construct_params, + params=dict(y=5), ) 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, r"A value is required for bind parameter 'x', " "in parameter group 2", - select( - [table1]).where( + select([table1]) + .where( and_( table1.c.myid == bindparam("x", required=True), - table1.c.name == bindparam("y", required=True) + table1.c.name == bindparam("y", required=True), ) - ).compile().construct_params, - params=dict(y=5), _group_number=2) + ) + .compile() + .construct_params, + params=dict(y=5), + _group_number=2, + ) 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) + 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')]), + tuple_(table1.c.myid, table1.c.name).in_([(1, "foo"), (5, "bar")]), "(mytable.myid, mytable.name) IN " - "((:param_1, :param_2), (:param_3, :param_4))" + "((:param_1, :param_2), (:param_3, :param_4))", ) self.assert_compile( @@ -2219,7 +2475,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): [tuple_(table2.c.otherid, table2.c.othername)] ), "(mytable.myid, mytable.name) IN " - "((myothertable.otherid, myothertable.othername))" + "((myothertable.otherid, myothertable.othername))", ) self.assert_compile( @@ -2227,226 +2483,245 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): select([table2.c.otherid, table2.c.othername]) ), "(mytable.myid, mytable.name) IN (SELECT " - "myothertable.otherid, myothertable.othername FROM myothertable)" + "myothertable.otherid, myothertable.othername FROM myothertable)", ) def test_expanding_parameter(self): self.assert_compile( tuple_(table1.c.myid, table1.c.name).in_( - bindparam('foo', expanding=True)), - "(mytable.myid, mytable.name) IN ([EXPANDING_foo])" + bindparam("foo", expanding=True) + ), + "(mytable.myid, mytable.name) IN ([EXPANDING_foo])", ) self.assert_compile( - table1.c.myid.in_(bindparam('foo', expanding=True)), - "mytable.myid IN ([EXPANDING_foo])" + table1.c.myid.in_(bindparam("foo", expanding=True)), + "mytable.myid IN ([EXPANDING_foo])", ) def test_cast(self): - tbl = table('casttest', - column('id', Integer), - column('v1', Float), - column('v2', Float), - column('ts', TIMESTAMP), - ) + tbl = table( + "casttest", + column("id", Integer), + column("v1", Float), + column("v2", Float), + column("ts", TIMESTAMP), + ) def check_results(dialect, expected_results, literal): - eq_(len(expected_results), 5, - 'Incorrect number of expected results') - eq_(str(cast(tbl.c.v1, Numeric).compile(dialect=dialect)), - 'CAST(casttest.v1 AS %s)' % expected_results[0]) - eq_(str(tbl.c.v1.cast(Numeric).compile(dialect=dialect)), - '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]) - eq_(str(cast(tbl.c.ts, Date).compile(dialect=dialect)), - 'CAST(casttest.ts AS %s)' % expected_results[2]) - eq_(str(cast(1234, Text).compile(dialect=dialect)), - '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])) + eq_( + len(expected_results), + 5, + "Incorrect number of expected results", + ) + eq_( + str(cast(tbl.c.v1, Numeric).compile(dialect=dialect)), + "CAST(casttest.v1 AS %s)" % expected_results[0], + ) + eq_( + str(tbl.c.v1.cast(Numeric).compile(dialect=dialect)), + "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], + ) + eq_( + str(cast(tbl.c.ts, Date).compile(dialect=dialect)), + "CAST(casttest.ts AS %s)" % expected_results[2], + ) + eq_( + str(cast(1234, Text).compile(dialect=dialect)), + "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]), + ) # fixme: shoving all of this dialect-specific stuff in one test # is now officially completely ridiculous AND non-obviously omits # coverage on other dialects. sel = select([tbl, cast(tbl.c.v1, Numeric)]).compile( - dialect=dialect) + dialect=dialect + ) if isinstance(dialect, type(mysql.dialect())): - eq_(str(sel), + eq_( + str(sel), "SELECT casttest.id, casttest.v1, casttest.v2, " "casttest.ts, " - "CAST(casttest.v1 AS DECIMAL) AS anon_1 \nFROM casttest") + "CAST(casttest.v1 AS DECIMAL) AS anon_1 \nFROM casttest", + ) else: - eq_(str(sel), + eq_( + str(sel), "SELECT casttest.id, casttest.v1, casttest.v2, " "casttest.ts, CAST(casttest.v1 AS NUMERIC) AS " - "anon_1 \nFROM casttest") + "anon_1 \nFROM casttest", + ) # first test with PostgreSQL engine check_results( - postgresql.dialect(), [ - 'NUMERIC', 'NUMERIC(12, 9)', 'DATE', 'TEXT', 'VARCHAR(20)'], - '%(param_1)s') + 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') + 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)'], '?') + check_results( + sqlite.dialect(), + ["NUMERIC", "NUMERIC(12, 9)", "DATE", "TEXT", "VARCHAR(20)"], + "?", + ) # then the MySQL engine - check_results(mysql.dialect(), ['DECIMAL', 'DECIMAL(12, 9)', - 'DATE', 'CHAR', 'CHAR(20)'], '%s') - - self.assert_compile(cast(text('NULL'), Integer), - 'CAST(NULL AS INTEGER)', - dialect=sqlite.dialect()) - self.assert_compile(cast(null(), Integer), - 'CAST(NULL AS INTEGER)', - dialect=sqlite.dialect()) - self.assert_compile(cast(literal_column('NULL'), Integer), - 'CAST(NULL AS INTEGER)', - dialect=sqlite.dialect()) + check_results( + mysql.dialect(), + ["DECIMAL", "DECIMAL(12, 9)", "DATE", "CHAR", "CHAR(20)"], + "%s", + ) - def test_over(self): self.assert_compile( - func.row_number().over(), - "row_number() OVER ()" + cast(text("NULL"), Integer), + "CAST(NULL AS INTEGER)", + dialect=sqlite.dialect(), + ) + self.assert_compile( + cast(null(), Integer), + "CAST(NULL AS INTEGER)", + dialect=sqlite.dialect(), + ) + self.assert_compile( + cast(literal_column("NULL"), Integer), + "CAST(NULL AS INTEGER)", + dialect=sqlite.dialect(), ) + + def test_over(self): + self.assert_compile(func.row_number().over(), "row_number() OVER ()") self.assert_compile( func.row_number().over( order_by=[table1.c.name, table1.c.description] ), - "row_number() OVER (ORDER BY mytable.name, mytable.description)" + "row_number() OVER (ORDER BY mytable.name, mytable.description)", ) self.assert_compile( func.row_number().over( partition_by=[table1.c.name, table1.c.description] ), "row_number() OVER (PARTITION BY mytable.name, " - "mytable.description)" + "mytable.description)", ) self.assert_compile( func.row_number().over( - partition_by=[table1.c.name], - order_by=[table1.c.description] + partition_by=[table1.c.name], order_by=[table1.c.description] ), "row_number() OVER (PARTITION BY mytable.name " - "ORDER BY mytable.description)" + "ORDER BY mytable.description)", ) self.assert_compile( func.row_number().over( - partition_by=table1.c.name, - order_by=table1.c.description + partition_by=table1.c.name, order_by=table1.c.description ), "row_number() OVER (PARTITION BY mytable.name " - "ORDER BY mytable.description)" + "ORDER BY mytable.description)", ) self.assert_compile( func.row_number().over( partition_by=table1.c.name, - order_by=[table1.c.name, table1.c.description] + order_by=[table1.c.name, table1.c.description], ), "row_number() OVER (PARTITION BY mytable.name " - "ORDER BY mytable.name, mytable.description)" + "ORDER BY mytable.name, mytable.description)", ) self.assert_compile( func.row_number().over( - partition_by=[], - order_by=[table1.c.name, table1.c.description] + partition_by=[], order_by=[table1.c.name, table1.c.description] ), - "row_number() OVER (ORDER BY mytable.name, mytable.description)" + "row_number() OVER (ORDER BY mytable.name, mytable.description)", ) self.assert_compile( func.row_number().over( - partition_by=[table1.c.name, table1.c.description], - order_by=[] + partition_by=[table1.c.name, table1.c.description], order_by=[] ), "row_number() OVER (PARTITION BY mytable.name, " - "mytable.description)" + "mytable.description)", ) self.assert_compile( - func.row_number().over( - partition_by=[], - order_by=[] - ), - "row_number() OVER ()" + func.row_number().over(partition_by=[], order_by=[]), + "row_number() OVER ()", ) self.assert_compile( - select([func.row_number().over( - order_by=table1.c.description - ).label('foo')]), + select( + [ + func.row_number() + .over(order_by=table1.c.description) + .label("foo") + ] + ), "SELECT row_number() OVER (ORDER BY mytable.description) " - "AS foo FROM mytable" + "AS foo FROM mytable", ) # test from_obj generation. # from func: self.assert_compile( - select([ - func.max(table1.c.name).over( - partition_by=['description'] - ) - ]), + select( + [func.max(table1.c.name).over(partition_by=["description"])] + ), "SELECT max(mytable.name) OVER (PARTITION BY mytable.description) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) # from partition_by self.assert_compile( - select([ - func.row_number().over( - partition_by=[table1.c.name] - ) - ]), + select([func.row_number().over(partition_by=[table1.c.name])]), "SELECT row_number() OVER (PARTITION BY mytable.name) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) # from order_by self.assert_compile( - select([ - func.row_number().over( - order_by=table1.c.name - ) - ]), + select([func.row_number().over(order_by=table1.c.name)]), "SELECT row_number() OVER (ORDER BY mytable.name) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) # this tests that _from_objects # concantenates OK self.assert_compile( select([column("x") + over(func.foo())]), - "SELECT x + foo() OVER () AS anon_1" + "SELECT x + foo() OVER () AS anon_1", ) # test a reference to a label that in the referecned selectable; # this resolves - expr = (table1.c.myid + 5).label('sum') + expr = (table1.c.myid + 5).label("sum") stmt = select([expr]).alias() self.assert_compile( select([stmt.c.sum, func.row_number().over(order_by=stmt.c.sum)]), "SELECT anon_1.sum, row_number() OVER (ORDER BY anon_1.sum) " "AS anon_2 FROM (SELECT mytable.myid + :myid_1 AS sum " - "FROM mytable) AS anon_1" + "FROM mytable) AS anon_1", ) # test a reference to a label that's at the same level as the OVER # in the columns clause; doesn't resolve - expr = (table1.c.myid + 5).label('sum') + expr = (table1.c.myid + 5).label("sum") self.assert_compile( select([expr, func.row_number().over(order_by=expr)]), "SELECT mytable.myid + :myid_1 AS sum, " "row_number() OVER " - "(ORDER BY mytable.myid + :myid_1) AS anon_1 FROM mytable" + "(ORDER BY mytable.myid + :myid_1) AS anon_1 FROM mytable", ) def test_over_framespec(self): @@ -2457,7 +2732,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT row_number() OVER " "(ORDER BY mytable.myid ROWS BETWEEN CURRENT " "ROW AND UNBOUNDED FOLLOWING)" - " AS anon_1 FROM mytable" + " AS anon_1 FROM mytable", ) self.assert_compile( @@ -2465,7 +2740,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT row_number() OVER " "(ORDER BY mytable.myid ROWS BETWEEN UNBOUNDED " "PRECEDING AND UNBOUNDED FOLLOWING)" - " AS anon_1 FROM mytable" + " AS anon_1 FROM mytable", ) self.assert_compile( @@ -2473,7 +2748,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT row_number() OVER " "(ORDER BY mytable.myid RANGE BETWEEN " "UNBOUNDED PRECEDING AND CURRENT ROW)" - " AS anon_1 FROM mytable" + " AS anon_1 FROM mytable", ) self.assert_compile( @@ -2482,7 +2757,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "(ORDER BY mytable.myid RANGE BETWEEN " ":param_1 PRECEDING AND :param_2 FOLLOWING)" " AS anon_1 FROM mytable", - checkparams={'param_1': 5, 'param_2': 10} + checkparams={"param_1": 5, "param_2": 10}, ) self.assert_compile( @@ -2491,7 +2766,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "(ORDER BY mytable.myid RANGE BETWEEN " ":param_1 FOLLOWING AND :param_2 FOLLOWING)" " AS anon_1 FROM mytable", - checkparams={'param_1': 1, 'param_2': 10} + checkparams={"param_1": 1, "param_2": 10}, ) self.assert_compile( @@ -2500,89 +2775,108 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): "(ORDER BY mytable.myid RANGE BETWEEN " ":param_1 PRECEDING AND :param_2 PRECEDING)" " AS anon_1 FROM mytable", - checkparams={'param_1': 10, 'param_2': 1} + checkparams={"param_1": 10, "param_2": 1}, ) def test_over_invalid_framespecs(self): assert_raises_message( exc.ArgumentError, "Integer or None expected for range value", - func.row_number().over, range_=("foo", 8) + func.row_number().over, + range_=("foo", 8), ) assert_raises_message( exc.ArgumentError, "Integer or None expected for range value", - func.row_number().over, range_=(-5, "foo") + func.row_number().over, + range_=(-5, "foo"), ) assert_raises_message( exc.ArgumentError, "'range_' and 'rows' are mutually exclusive", - func.row_number().over, range_=(-5, 8), rows=(-2, 5) + func.row_number().over, + range_=(-5, 8), + rows=(-2, 5), ) def test_over_within_group(self): from sqlalchemy import within_group - stmt = select([ - table1.c.myid, - within_group( - func.percentile_cont(0.5), - table1.c.name.desc() - ).over( - range_=(1, 2), - partition_by=table1.c.name, - order_by=table1.c.myid - ) - ]) + + stmt = select( + [ + table1.c.myid, + within_group( + func.percentile_cont(0.5), table1.c.name.desc() + ).over( + range_=(1, 2), + partition_by=table1.c.name, + order_by=table1.c.myid, + ), + ] + ) eq_ignore_whitespace( str(stmt), "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name DESC) " "OVER (PARTITION BY mytable.name ORDER BY mytable.myid " "RANGE BETWEEN :param_1 FOLLOWING AND :param_2 FOLLOWING) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", + ) + + stmt = select( + [ + table1.c.myid, + within_group( + func.percentile_cont(0.5), table1.c.name.desc() + ).over( + rows=(1, 2), + partition_by=table1.c.name, + order_by=table1.c.myid, + ), + ] ) - - stmt = select([ - table1.c.myid, - within_group( - func.percentile_cont(0.5), - table1.c.name.desc() - ).over( - rows=(1, 2), - partition_by=table1.c.name, - order_by=table1.c.myid - ) - ]) eq_ignore_whitespace( str(stmt), "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name DESC) " "OVER (PARTITION BY mytable.name ORDER BY mytable.myid " "ROWS BETWEEN :param_1 FOLLOWING AND :param_2 FOLLOWING) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) - - def test_date_between(self): import datetime - table = Table('dt', metadata, - Column('date', Date)) + + table = Table("dt", metadata, Column("date", Date)) self.assert_compile( - table.select(table.c.date.between(datetime.date(2006, 6, 1), - datetime.date(2006, 6, 5))), + table.select( + table.c.date.between( + datetime.date(2006, 6, 1), 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)}) + checkparams={ + "date_1": datetime.date(2006, 6, 1), + "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))), + table.select( + sql.between( + table.c.date, + datetime.date(2006, 6, 1), + 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)}) + checkparams={ + "date_1": datetime.date(2006, 6, 1), + "date_2": datetime.date(2006, 6, 5), + }, + ) def test_delayed_col_naming(self): my_str = Column(String) @@ -2592,18 +2886,18 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.InvalidRequestError, "Cannot initialize a sub-selectable with this Column", - lambda: sel1.c + lambda: sel1.c, ) # calling label or as_scalar doesn't compile # anything. - sel2 = select([func.substr(my_str, 2, 3)]).label('my_substr') + sel2 = select([func.substr(my_str, 2, 3)]).label("my_substr") assert_raises_message( exc.CompileError, "Cannot compile Column object until its 'name' is assigned.", sel2.compile, - dialect=default.DefaultDialect() + dialect=default.DefaultDialect(), ) sel3 = select([my_str]).as_scalar() @@ -2611,24 +2905,17 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): exc.CompileError, "Cannot compile Column object until its 'name' is assigned.", sel3.compile, - dialect=default.DefaultDialect() + dialect=default.DefaultDialect(), ) - my_str.name = 'foo' + my_str.name = "foo" + self.assert_compile(sel1, "SELECT foo") self.assert_compile( - sel1, - "SELECT foo", - ) - self.assert_compile( - sel2, - '(SELECT substr(foo, :substr_2, :substr_3) AS substr_1)', + sel2, "(SELECT substr(foo, :substr_2, :substr_3) AS substr_1)" ) - self.assert_compile( - sel3, - "(SELECT foo)" - ) + self.assert_compile(sel3, "(SELECT foo)") def test_naming(self): # TODO: the part where we check c.keys() are not "compile" tests, they @@ -2636,36 +2923,46 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # version of that suite f1 = func.hoho(table1.c.name) - s1 = select([table1.c.myid, table1.c.myid.label('foobar'), - f1, - func.lala(table1.c.name).label('gg')]) - - eq_( - list(s1.c.keys()), - ['myid', 'foobar', str(f1), 'gg'] + s1 = select( + [ + table1.c.myid, + table1.c.myid.label("foobar"), + f1, + func.lala(table1.c.name).label("gg"), + ] ) + eq_(list(s1.c.keys()), ["myid", "foobar", str(f1), "gg"]) + meta = MetaData() - t1 = Table('mytable', meta, Column('col1', Integer)) + t1 = Table("mytable", meta, Column("col1", Integer)) exprs = ( table1.c.myid == 12, func.hoho(table1.c.myid), cast(table1.c.name, Numeric), - literal('x'), + literal("x"), ) 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'), - (t1.c.col1, 'col1', 'mytable.col1', None), - (column('some wacky thing'), 'some wacky thing', - '"some wacky thing"', ''), - (exprs[3], exprs[3].key, ":param_1", "anon_1") + (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", + ), + (t1.c.col1, "col1", "mytable.col1", None), + ( + column("some wacky thing"), + "some wacky thing", + '"some wacky thing"', + "", + ), + (exprs[3], exprs[3].key, ":param_1", "anon_1"), ): - if getattr(col, 'table', None) is not None: + if getattr(col, "table", None) is not None: t = col.table else: t = table1 @@ -2675,107 +2972,151 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): if lbl: self.assert_compile( - s1, "SELECT %s AS %s FROM mytable" % - (expr, lbl)) + s1, "SELECT %s AS %s FROM mytable" % (expr, lbl) + ) else: self.assert_compile(s1, "SELECT %s FROM mytable" % (expr,)) s1 = select([s1]) if lbl: self.assert_compile( - s1, "SELECT %s FROM (SELECT %s AS %s FROM mytable)" % - (lbl, expr, lbl)) + 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)) + 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)) + self.assert_compile( + s1, + "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") - s2 = select([table1.c.myid]).\ - with_hint(table1, "index(%(name)s idx)", 'oracle').\ - with_hint(table1, "WITH HINT INDEX idx", 'sybase') + s2 = ( + select([table1.c.myid]) + .with_hint(table1, "index(%(name)s idx)", "oracle") + .with_hint(table1, "WITH HINT INDEX idx", "sybase") + ) a1 = table1.alias() s3 = select([a1.c.myid]).with_hint(a1, "index(%(name)s hint)") - subs4 = select([ - table1, table2 - ]).select_from( - table1.join(table2, table1.c.myid == table2.c.otherid)).\ - with_hint(table1, 'hint1') + subs4 = ( + select([table1, table2]) + .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 + s4 = ( + select([table3]) + .select_from( + table3.join(subs4, subs4.c.othername == table3.c.otherstuff) ) - ).\ - with_hint(table3, 'hint3') + .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') - a2 = t1.alias('SomeName') - s7 = select([a2.c.col1]).where(a2.c.col1 > 10).\ - with_hint(a2, '%(name)s idx1') + t1 = table("QuotedName", column("col1")) + s6 = ( + select([t1.c.col1]) + .where(t1.c.col1 > 10) + .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") + ) - mysql_d, oracle_d, sybase_d = \ - mysql.dialect(), \ - oracle.dialect(), \ - sybase.dialect() + mysql_d, oracle_d, sybase_d = ( + 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, + (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, + "index(mytable_1 hint)", + ), + ( + s3, + oracle_d, "SELECT /*+ index(mytable_1 hint) */ mytable_1.myid FROM " - "mytable mytable_1"), - (s3, sybase_d, + "mytable mytable_1", + ), + ( + s3, + sybase_d, "SELECT mytable_1.myid FROM mytable AS mytable_1 " - "index(mytable_1 hint)"), - (s4, mysql_d, + "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, + "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, + "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"), + " thirdtable.otherstuff", + ), # TODO: figure out dictionary ordering solution here # (s5, oracle_d, # "SELECT /*+ hint3 */ /*+ hint1 */ thirdtable.userid, " @@ -2785,68 +3126,64 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL): # " myothertable.othername FROM mytable JOIN myothertable ON" # " mytable.myid = myothertable.otherid) ON othername =" # " thirdtable.otherstuff"), - (s6, oracle_d, + ( + 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"""), + """FROM "QuotedName" WHERE "QuotedName".col1 > :col1_1""", + ), + ( + s7, + oracle_d, + """SELECT /*+ "SomeName" idx1 */ "SomeName".col1 FROM """ + """"QuotedName" "SomeName" WHERE "SomeName".col1 > :col1_1""", + ), ]: - self.assert_compile( - stmt, - expected, - dialect=dialect - ) + self.assert_compile(stmt, expected, dialect=dialect) def test_statement_hints(self): - stmt = select([table1.c.myid]).\ - with_statement_hint("test hint one").\ - with_statement_hint("test hint two", 'mysql') + stmt = ( + select([table1.c.myid]) + .with_statement_hint("test hint one") + .with_statement_hint("test hint two", "mysql") + ) self.assert_compile( - stmt, - "SELECT mytable.myid FROM mytable test hint one", + stmt, "SELECT mytable.myid FROM mytable test hint one" ) self.assert_compile( stmt, "SELECT mytable.myid FROM mytable test hint one test hint two", - dialect='mysql' + dialect="mysql", ) def test_literal_as_text_fromstring(self): - self.assert_compile( - and_(text("a"), text("b")), - "a AND b" - ) + self.assert_compile(and_(text("a"), text("b")), "a AND b") def test_literal_as_text_nonstring_raise(self): - assert_raises(exc.ArgumentError, - and_, ("a",), ("b",) - ) + assert_raises(exc.ArgumentError, 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' + __visit_name__ = "some_element" assert_raises_message( exc.UnsupportedCompilationError, r"Compiler <sqlalchemy.sql.compiler.StrSQLCompiler .*" r"can't render element of type <class '.*SomeElement'>", - SomeElement().compile + SomeElement().compile, ) 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" @@ -2855,7 +3192,7 @@ class UnsupportedTest(fixtures.TestBase): exc.UnsupportedCompilationError, r"Compiler <sqlalchemy.sql.compiler.StrSQLCompiler .*" r"can't render element of type <class '.*SomeElement'>", - SomeElement().compile + SomeElement().compile, ) def test_unsupported_operator(self): @@ -2863,12 +3200,13 @@ class UnsupportedTest(fixtures.TestBase): def myop(x, y): pass + binary = BinaryExpression(column("foo"), column("bar"), myop) assert_raises_message( exc.UnsupportedCompilationError, r"Compiler <sqlalchemy.sql.compiler.StrSQLCompiler .*" r"can't render element of type <function.*", - binary.compile + binary.compile, ) @@ -2878,15 +3216,12 @@ class StringifySpecialTest(fixtures.TestBase): eq_ignore_whitespace( str(stmt), "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable WHERE mytable.myid = :myid_1" + "FROM mytable WHERE mytable.myid = :myid_1", ) def test_unnamed_column(self): stmt = Column(Integer) == 5 - eq_ignore_whitespace( - str(stmt), - '"<name unknown>" = :param_1' - ) + eq_ignore_whitespace(str(stmt), '"<name unknown>" = :param_1') def test_cte(self): # stringify of these was supported anyway by defaultdialect. @@ -2895,7 +3230,7 @@ class StringifySpecialTest(fixtures.TestBase): eq_ignore_whitespace( str(stmt), "WITH anon_1 AS (SELECT mytable.myid AS myid FROM mytable) " - "SELECT anon_1.myid FROM anon_1" + "SELECT anon_1.myid FROM anon_1", ) def test_next_sequence_value(self): @@ -2906,8 +3241,7 @@ class StringifySpecialTest(fixtures.TestBase): seq = Sequence("my_sequence") eq_ignore_whitespace( - str(seq.next_value()), - "<next sequence value: my_sequence>" + str(seq.next_value()), "<next sequence value: my_sequence>" ) def test_returning(self): @@ -2916,47 +3250,43 @@ class StringifySpecialTest(fixtures.TestBase): eq_ignore_whitespace( str(stmt), "INSERT INTO mytable (myid, name, description) " - "VALUES (:myid, :name, :description) RETURNING mytable.myid" + "VALUES (:myid, :name, :description) RETURNING mytable.myid", ) def test_array_index(self): - stmt = select([column('foo', types.ARRAY(Integer))[5]]) + stmt = select([column("foo", types.ARRAY(Integer))[5]]) - eq_ignore_whitespace( - str(stmt), - "SELECT foo[:foo_1] AS anon_1" - ) + eq_ignore_whitespace(str(stmt), "SELECT foo[:foo_1] AS anon_1") def test_unknown_type(self): class MyType(types.TypeEngine): - __visit_name__ = 'mytype' + __visit_name__ = "mytype" stmt = select([cast(table1.c.myid, MyType)]) eq_ignore_whitespace( str(stmt), - "SELECT CAST(mytable.myid AS MyType) AS anon_1 FROM mytable" + "SELECT CAST(mytable.myid AS MyType) AS anon_1 FROM mytable", ) def test_within_group(self): # stringify of these was supported anyway by defaultdialect. from sqlalchemy import within_group - stmt = select([ - table1.c.myid, - within_group( - func.percentile_cont(0.5), - table1.c.name.desc() - ) - ]) + + stmt = select( + [ + table1.c.myid, + within_group(func.percentile_cont(0.5), table1.c.name.desc()), + ] + ) eq_ignore_whitespace( str(stmt), "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " - "WITHIN GROUP (ORDER BY mytable.name DESC) AS anon_1 FROM mytable" + "WITHIN GROUP (ORDER BY mytable.name DESC) AS anon_1 FROM mytable", ) class KwargPropagationTest(fixtures.TestBase): - @classmethod def setup_class(cls): from sqlalchemy.sql.expression import ColumnClause, TableClause @@ -2969,7 +3299,7 @@ class KwargPropagationTest(fixtures.TestBase): cls.column = CatchCol("x") cls.table = CatchTable("y") - cls.criterion = cls.column == CatchCol('y') + cls.criterion = cls.column == CatchCol("y") @compiles(CatchCol) def compile_col(element, compiler, **kw): @@ -2983,16 +3313,18 @@ class KwargPropagationTest(fixtures.TestBase): def _do_test(self, element): d = default.DefaultDialect() - d.statement_compiler(d, element, - compile_kwargs={"canary": True}) + d.statement_compiler(d, element, 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) + s = ( + select([self.column]) + .select_from(self.table) + .where(self.column == self.criterion) + .order_by(self.column) + ) self._do_test(s) def test_case(self): @@ -3029,8 +3361,11 @@ class ExecutionOptionsTest(fixtures.TestBase): def test_embedded_element_true_to_false(self): stmt = table1.insert().cte() eq_(stmt._execution_options, {"autocommit": True}) - s2 = select([table1]).select_from(stmt).\ - execution_options(autocommit=False) + s2 = ( + select([table1]) + .select_from(stmt) + .execution_options(autocommit=False) + ) eq_(s2._execution_options, {"autocommit": False}) compiled = s2.compile() @@ -3038,7 +3373,7 @@ class ExecutionOptionsTest(fixtures.TestBase): class DDLTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def _illegal_type_fixture(self): class MyType(types.TypeEngine): @@ -3047,195 +3382,197 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL): @compiles(MyType) def compile(element, compiler, **kw): raise exc.CompileError("Couldn't compile type") + return MyType def test_reraise_of_column_spec_issue(self): MyType = self._illegal_type_fixture() - t1 = Table('t', MetaData(), - Column('x', MyType()) - ) + t1 = Table("t", MetaData(), Column("x", MyType())) assert_raises_message( exc.CompileError, r"\(in table 't', column 'x'\): Couldn't compile type", - schema.CreateTable(t1).compile + schema.CreateTable(t1).compile, ) def test_reraise_of_column_spec_issue_unicode(self): MyType = self._illegal_type_fixture() - t1 = Table('t', MetaData(), - Column(u('méil'), MyType()) - ) + t1 = Table("t", MetaData(), Column(u("méil"), MyType())) assert_raises_message( exc.CompileError, u(r"\(in table 't', column 'méil'\): Couldn't compile type"), - schema.CreateTable(t1).compile + schema.CreateTable(t1).compile, ) def test_system_flag(self): m = MetaData() - t = Table('t', m, Column('x', Integer), - Column('y', Integer, system=True), - Column('z', Integer)) + t = Table( + "t", + m, + Column("x", Integer), + Column("y", Integer, system=True), + Column("z", Integer), + ) self.assert_compile( - schema.CreateTable(t), - "CREATE TABLE t (x INTEGER, z INTEGER)" + schema.CreateTable(t), "CREATE TABLE t (x INTEGER, z INTEGER)" ) m2 = MetaData() t2 = t.tometadata(m2) self.assert_compile( - schema.CreateTable(t2), - "CREATE TABLE t (x INTEGER, z INTEGER)" + schema.CreateTable(t2), "CREATE TABLE t (x INTEGER, z INTEGER)" ) def test_composite_pk_constraint_autoinc_first_implicit(self): m = MetaData() t = Table( - 't', m, - Column('a', Integer, primary_key=True), - Column('b', Integer, primary_key=True, autoincrement=True) + "t", + m, + Column("a", Integer, primary_key=True), + Column("b", Integer, primary_key=True, autoincrement=True), ) self.assert_compile( schema.CreateTable(t), "CREATE TABLE t (" "a INTEGER NOT NULL, " "b INTEGER NOT NULL, " - "PRIMARY KEY (b, a))" + "PRIMARY KEY (b, a))", ) def test_composite_pk_constraint_maintains_order_explicit(self): m = MetaData() t = Table( - 't', m, - Column('a', Integer), - Column('b', Integer, autoincrement=True), - schema.PrimaryKeyConstraint('a', 'b') + "t", + m, + Column("a", Integer), + Column("b", Integer, autoincrement=True), + schema.PrimaryKeyConstraint("a", "b"), ) self.assert_compile( schema.CreateTable(t), "CREATE TABLE t (" "a INTEGER NOT NULL, " "b INTEGER NOT NULL, " - "PRIMARY KEY (a, b))" + "PRIMARY KEY (a, b))", ) def test_create_table_suffix(self): class MyDialect(default.DefaultDialect): class MyCompiler(compiler.DDLCompiler): def create_table_suffix(self, table): - return 'SOME SUFFIX' + return "SOME SUFFIX" ddl_compiler = MyCompiler m = MetaData() - t1 = Table('t1', m, Column('q', Integer)) + t1 = Table("t1", m, Column("q", Integer)) self.assert_compile( schema.CreateTable(t1), "CREATE TABLE t1 SOME SUFFIX (q INTEGER)", - dialect=MyDialect() + dialect=MyDialect(), ) def test_table_no_cols(self): m = MetaData() - t1 = Table('t1', m) - self.assert_compile( - schema.CreateTable(t1), - "CREATE TABLE t1 ()" - ) + t1 = Table("t1", m) + self.assert_compile(schema.CreateTable(t1), "CREATE TABLE t1 ()") def test_table_no_cols_w_constraint(self): m = MetaData() - t1 = Table('t1', m, CheckConstraint('a = 1')) + t1 = Table("t1", m, CheckConstraint("a = 1")) self.assert_compile( - schema.CreateTable(t1), - "CREATE TABLE t1 (CHECK (a = 1))" + schema.CreateTable(t1), "CREATE TABLE t1 (CHECK (a = 1))" ) def test_table_one_col_w_constraint(self): m = MetaData() - t1 = Table('t1', m, Column('q', Integer), CheckConstraint('a = 1')) + t1 = Table("t1", m, Column("q", Integer), CheckConstraint("a = 1")) self.assert_compile( schema.CreateTable(t1), - "CREATE TABLE t1 (q INTEGER, CHECK (a = 1))" + "CREATE TABLE t1 (q INTEGER, CHECK (a = 1))", ) def test_schema_translate_map_table(self): m = MetaData() - t1 = Table('t1', m, Column('q', Integer)) - t2 = Table('t2', m, Column('q', Integer), schema='foo') - t3 = Table('t3', m, Column('q', Integer), schema='bar') + t1 = Table("t1", m, Column("q", Integer)) + t2 = Table("t2", m, Column("q", Integer), schema="foo") + t3 = Table("t3", m, Column("q", Integer), schema="bar") schema_translate_map = {None: "z", "bar": None, "foo": "bat"} self.assert_compile( schema.CreateTable(t1), "CREATE TABLE z.t1 (q INTEGER)", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( schema.CreateTable(t2), "CREATE TABLE bat.t2 (q INTEGER)", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( schema.CreateTable(t3), "CREATE TABLE t3 (q INTEGER)", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) def test_schema_translate_map_sequence(self): - s1 = schema.Sequence('s1') - s2 = schema.Sequence('s2', schema='foo') - s3 = schema.Sequence('s3', schema='bar') + s1 = schema.Sequence("s1") + s2 = schema.Sequence("s2", schema="foo") + s3 = schema.Sequence("s3", schema="bar") schema_translate_map = {None: "z", "bar": None, "foo": "bat"} self.assert_compile( schema.CreateSequence(s1), "CREATE SEQUENCE z.s1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( schema.CreateSequence(s2), "CREATE SEQUENCE bat.s2", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( schema.CreateSequence(s3), "CREATE SEQUENCE s3", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __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(), + "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')), + 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") + " remote_owner.remotetable.value = :value_1", + ) - s = table4.select(and_(table4.c.datatype_id == 7, - table4.c.value == 'hi'), use_labels=True) + 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" + s, + "SELECT remote_owner.remotetable.rem_id AS" " remote_owner_remotetable_rem_id, " "remote_owner.remotetable.datatype_id AS" " remote_owner_remotetable_datatype_id, " @@ -3243,86 +3580,94 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): "AS remote_owner_remotetable_value FROM " "remote_owner.remotetable WHERE " "remote_owner.remotetable.datatype_id = :datatype_id_1 AND " - "remote_owner.remotetable.value = :value_1") + "remote_owner.remotetable.value = :value_1", + ) # 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' - ) + 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', + ) # 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' - ) + 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', + ) def test_schema_translate_select(self): m = MetaData() table1 = Table( - 'mytable', m, Column('myid', Integer), - Column('name', String), - Column('description', String) + "mytable", + m, + Column("myid", Integer), + Column("name", String), + Column("description", String), ) - schema_translate_map = {"remote_owner": "foob", None: 'bar'} + schema_translate_map = {"remote_owner": "foob", None: "bar"} self.assert_compile( - table1.select().where(table1.c.name == 'hi'), + table1.select().where(table1.c.name == "hi"), "SELECT bar.mytable.myid, bar.mytable.name, " "bar.mytable.description FROM bar.mytable " "WHERE bar.mytable.name = :name_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table4.select().where(table4.c.value == 'hi'), + table4.select().where(table4.c.value == "hi"), "SELECT foob.remotetable.rem_id, foob.remotetable.datatype_id, " "foob.remotetable.value FROM foob.remotetable " "WHERE foob.remotetable.value = :value_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) schema_translate_map = {"remote_owner": "foob"} self.assert_compile( - select([ - table1, table4 - ]).select_from( + select([table1, table4]).select_from( join(table1, table4, table1.c.myid == table4.c.rem_id) ), "SELECT mytable.myid, mytable.name, mytable.description, " "foob.remotetable.rem_id, foob.remotetable.datatype_id, " "foob.remotetable.value FROM mytable JOIN foob.remotetable " "ON mytable.myid = foob.remotetable.rem_id", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) def test_schema_translate_aliases(self): - schema_translate_map = {None: 'bar'} + schema_translate_map = {None: "bar"} m = MetaData() table1 = Table( - 'mytable', m, Column('myid', Integer), - Column('name', String), - Column('description', String) + "mytable", + m, + Column("myid", Integer), + Column("name", String), + Column("description", String), ) table2 = Table( - 'myothertable', m, Column('otherid', Integer), - Column('othername', String), + "myothertable", + m, + Column("otherid", Integer), + Column("othername", String), ) alias = table1.alias() - stmt = select([ - table2, alias - ]).select_from(table2.join(alias, table2.c.otherid == alias.c.myid)).\ - where(alias.c.name == 'foo') + stmt = ( + select([table2, alias]) + .select_from(table2.join(alias, table2.c.otherid == alias.c.myid)) + .where(alias.c.name == "foo") + ) self.assert_compile( stmt, @@ -3331,109 +3676,122 @@ class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): "FROM bar.myothertable JOIN bar.mytable AS mytable_1 " "ON bar.myothertable.otherid = mytable_1.myid " "WHERE mytable_1.name = :name_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) def test_schema_translate_crud(self): - schema_translate_map = {"remote_owner": "foob", None: 'bar'} + schema_translate_map = {"remote_owner": "foob", None: "bar"} m = MetaData() table1 = Table( - 'mytable', m, - Column('myid', Integer), Column('name', String), - Column('description', String) + "mytable", + m, + Column("myid", Integer), + Column("name", String), + Column("description", String), ) self.assert_compile( - table1.insert().values(description='foo'), + table1.insert().values(description="foo"), "INSERT INTO bar.mytable (description) VALUES (:description)", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table1.update().where(table1.c.name == 'hi'). - values(description='foo'), + table1.update() + .where(table1.c.name == "hi") + .values(description="foo"), "UPDATE bar.mytable SET description=:description " "WHERE bar.mytable.name = :name_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table1.delete().where(table1.c.name == 'hi'), + table1.delete().where(table1.c.name == "hi"), "DELETE FROM bar.mytable WHERE bar.mytable.name = :name_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table4.insert().values(value='there'), + table4.insert().values(value="there"), "INSERT INTO foob.remotetable (value) VALUES (:value)", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table4.update().where(table4.c.value == 'hi'). - values(value='there'), + table4.update() + .where(table4.c.value == "hi") + .values(value="there"), "UPDATE foob.remotetable SET value=:value " "WHERE foob.remotetable.value = :value_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) self.assert_compile( - table4.delete().where(table4.c.value == 'hi'), + table4.delete().where(table4.c.value == "hi"), "DELETE FROM foob.remotetable WHERE " "foob.remotetable.value = :value_1", - schema_translate_map=schema_translate_map + schema_translate_map=schema_translate_map, ) def test_alias(self): - a = alias(table4, 'remtable') - self.assert_compile(a.select(a.c.datatype_id == 7), - "SELECT remtable.rem_id, remtable.datatype_id, " - "remtable.value FROM" - " remote_owner.remotetable AS remtable " - "WHERE remtable.datatype_id = :datatype_id_1") + a = alias(table4, "remtable") + self.assert_compile( + a.select(a.c.datatype_id == 7), + "SELECT remtable.rem_id, remtable.datatype_id, " + "remtable.value FROM" + " remote_owner.remotetable AS remtable " + "WHERE remtable.datatype_id = :datatype_id_1", + ) def test_update(self): self.assert_compile( - table4.update(table4.c.value == 'test', - values={table4.c.datatype_id: 12}), + 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") + "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)") + 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)", + ) class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_dont_overcorrelate(self): - self.assert_compile(select([table1], from_obj=[table1, - table1.select()]), - "SELECT mytable.myid, mytable.name, " - "mytable.description FROM mytable, (SELECT " - "mytable.myid AS myid, mytable.name AS " - "name, mytable.description AS description " - "FROM mytable)") + self.assert_compile( + select([table1], from_obj=[table1, table1.select()]), + "SELECT mytable.myid, mytable.name, " + "mytable.description FROM mytable, (SELECT " + "mytable.myid AS myid, mytable.name AS " + "name, mytable.description AS description " + "FROM mytable)", + ) def _fixture(self): - t1 = table('t1', column('a')) - t2 = table('t2', column('a')) + t1 = table("t1", column("a")) + t2 = table("t2", column("a")) return t1, t2, select([t1]).where(t1.c.a == t2.c.a) 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)") + "(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)") + "(SELECT t1.a WHERE t1.a = t2.a)", + ) # note there's no more "backwards" correlation after # we've done #2746 @@ -3452,171 +3810,197 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( stmt, "SELECT t2.a, (SELECT t1.a FROM t1 WHERE t1.a = t2.a) " - "AS anon_1 FROM t2") + "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") + "(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)") + self.assert_compile( + stmt, + "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") + "(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") + "(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)") + self.assert_compile( + stmt, + "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") + self.assert_compile( + stmt, + "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)") + self.assert_compile( + stmt, + "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)") + self.assert_compile( + stmt, "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()])) + self._assert_from_uncorrelated(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)) + self._assert_where_correlated(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()])) + self._assert_column_correlated(select([t2, s1.as_scalar()])) def test_correlate_auto_from(self): t1, t2, s1 = self._fixture() - self._assert_from_uncorrelated( - select([t2, s1.alias()])) + self._assert_from_uncorrelated(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)) + self._assert_having_correlated(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() assert_raises_message( exc.InvalidRequestError, "returned no FROM clauses due to auto-correlation", - select([t1, t2]).where(t2.c.a == s1).compile + select([t1, t2]).where(t2.c.a == s1).compile, ) def test_correlate_from_all_ok(self): @@ -3624,16 +4008,16 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([t1, t2, s1]), "SELECT t1.a, t2.a, a FROM t1, t2, " - "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a)" + "(SELECT t1.a AS a FROM t1, t2 WHERE t1.a = t2.a)", ) def test_correlate_auto_where_singlefrom(self): t1, t2, s1 = self._fixture() 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)") + self.assert_compile( + s2, "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() @@ -3654,89 +4038,103 @@ class CorrelateTest(fixtures.TestBase, AssertsCompiledSQL): def test_correlate_alone_noeffect(self): # 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") + self.assert_compile( + s1.correlate(t1, t2), "SELECT t1.a FROM t1, t2 WHERE t1.a = t2.a" + ) def test_correlate_except_froms(self): # new as of #2748 - t1 = table('t1', column('a')) - t2 = table('t2', column('a'), column('b')) + t1 = table("t1", column("a")) + t2 = table("t2", column("a"), column("b")) s = select([t2.c.b]).where(t1.c.a == t2.c.a) - s = s.correlate_except(t2).alias('s') + s = s.correlate_except(t2).alias("s") 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 " + 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')) + 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 * " + 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)") + "ORDER BY child.pos LIMIT :param_1) WHERE id = :id_1)", + ) def test_no_contextless_correlate_except(self): # new as of #2748 - t1 = table('t1', column('x')) - t2 = table('t2', column('y')) - t3 = table('t3', column('z')) + t1 = table("t1", column("x")) + t2 = table("t2", column("y")) + t3 = table("t3", column("z")) - s = select([t1]).where(t1.c.x == t2.c.y).\ - where(t2.c.y == t3.c.z).correlate_except(t1) + s = ( + select([t1]) + .where(t1.c.x == t2.c.y) + .where(t2.c.y == t3.c.z) + .correlate_except(t1) + ) self.assert_compile( - s, - "SELECT t1.x FROM t1, t2, t3 WHERE t1.x = t2.y AND t2.y = t3.z") + 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): # test that implicit correlation with multilevel WHERE correlation # behaves like 0.8.1, 0.7 (i.e. doesn't happen) - t1 = table('t1', column('x')) - t2 = table('t2', column('y')) - t3 = table('t3', column('z')) + t1 = table("t1", column("x")) + t2 = table("t2", column("y")) + t3 = table("t3", column("z")) s = select([t1.c.x]).where(t1.c.x == t2.c.y) s2 = select([t3.c.z]).where(t3.c.z == s.as_scalar()) 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))" - ) + 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))", + ) def test_from_implicit_correlation_disabled(self): # test that implicit correlation with immediate and # multilevel FROM clauses behaves like 0.8.1 (i.e. doesn't happen) - t1 = table('t1', column('x')) - t2 = table('t2', column('y')) + t1 = table("t1", column("x")) + t2 = table("t2", column("y")) s = select([t1.c.x]).where(t1.c.x == t2.c.y) s2 = select([t2, s]) 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))" - ) + 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))", + ) class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): @@ -3744,28 +4142,27 @@ class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): def _fixture(self): m = MetaData() - return Table('foo', m, - Column('id', Integer)) + return Table("foo", m, Column("id", Integer)) - bool_table = table('t', column('x', Boolean)) + bool_table = table("t", column("x", Boolean)) def test_coerce_bool_where(self): self.assert_compile( select([self.bool_table]).where(self.bool_table.c.x), - "SELECT t.x FROM t WHERE t.x" + "SELECT t.x FROM t WHERE t.x", ) def test_coerce_bool_where_non_native(self): self.assert_compile( select([self.bool_table]).where(self.bool_table.c.x), "SELECT t.x FROM t WHERE t.x = 1", - dialect=default.DefaultDialect(supports_native_boolean=False) + dialect=default.DefaultDialect(supports_native_boolean=False), ) self.assert_compile( select([self.bool_table]).where(~self.bool_table.c.x), "SELECT t.x FROM t WHERE t.x = 0", - dialect=default.DefaultDialect(supports_native_boolean=False) + dialect=default.DefaultDialect(supports_native_boolean=False), ) def test_null_constant(self): @@ -3779,40 +4176,35 @@ class CoercionTest(fixtures.TestBase, AssertsCompiledSQL): def test_val_and_false(self): t = self._fixture() - self.assert_compile(and_(t.c.id == 1, False), - "false") + self.assert_compile(and_(t.c.id == 1, False), "false") def test_val_and_true_coerced(self): t = self._fixture() - self.assert_compile(and_(t.c.id == 1, True), - "foo.id = :id_1") + self.assert_compile(and_(t.c.id == 1, True), "foo.id = :id_1") def test_val_is_null_coerced(self): t = self._fixture() - self.assert_compile(and_(t.c.id == None), # noqa - "foo.id IS NULL") + self.assert_compile(and_(t.c.id == None), "foo.id IS NULL") # noqa def test_val_and_None(self): t = self._fixture() - self.assert_compile(and_(t.c.id == 1, None), - "foo.id = :id_1 AND NULL") + self.assert_compile(and_(t.c.id == 1, None), "foo.id = :id_1 AND NULL") def test_None_and_val(self): t = self._fixture() - self.assert_compile(and_(None, t.c.id == 1), - "NULL AND foo.id = :id_1") + self.assert_compile(and_(None, t.c.id == 1), "NULL AND foo.id = :id_1") def test_None_and_nothing(self): # current convention is None in and_() # returns None May want # to revise this at some point. - self.assert_compile( - and_(None), "NULL") + self.assert_compile(and_(None), "NULL") def test_val_and_null(self): t = self._fixture() - self.assert_compile(and_(t.c.id == 1, null()), - "foo.id = :id_1 AND NULL") + self.assert_compile( + and_(t.c.id == 1, null()), "foo.id = :id_1 AND NULL" + ) class ResultMapTest(fixtures.TestBase): @@ -3823,101 +4215,109 @@ class ResultMapTest(fixtures.TestBase): """ def test_compound_populates(self): - t = Table('t', MetaData(), Column('a', Integer), Column('b', Integer)) + t = Table("t", MetaData(), Column("a", Integer), Column("b", Integer)) stmt = select([t]).union(select([t])) comp = stmt.compile() eq_( comp._create_result_map(), - {'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type), - 'b': ('b', (t.c.b, 'b', 'b'), t.c.b.type)} + { + "a": ("a", (t.c.a, "a", "a"), t.c.a.type), + "b": ("b", (t.c.b, "b", "b"), t.c.b.type), + }, ) def test_compound_not_toplevel_doesnt_populate(self): - t = Table('t', MetaData(), Column('a', Integer), Column('b', Integer)) + t = Table("t", MetaData(), Column("a", Integer), Column("b", Integer)) subq = select([t]).union(select([t])) stmt = select([t.c.a]).select_from(t.join(subq, t.c.a == subq.c.a)) comp = stmt.compile() eq_( comp._create_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): - t = Table('t', MetaData(), Column('a', Integer), Column('b', Integer)) + t = Table("t", MetaData(), Column("a", Integer), Column("b", Integer)) stmt = select([t.c.a]).union(select([t.c.b])) comp = stmt.compile() eq_( comp._create_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): - t = Table('t', MetaData(), Column('a', Integer)) - l1 = t.c.a.label('bar') + t = Table("t", MetaData(), Column("a", Integer)) + l1 = t.c.a.label("bar") tc = type_coerce(t.c.a, String) stmt = select([t.c.a, l1, tc]) comp = stmt.compile() - tc_anon_label = comp._create_result_map()['anon_1'][1][0] + tc_anon_label = comp._create_result_map()["anon_1"][1][0] eq_( comp._create_result_map(), { - 'a': ('a', (t.c.a, 'a', 'a'), t.c.a.type), - 'bar': ('bar', (l1, 'bar'), l1.type), - 'anon_1': ( - '%%(%d anon)s' % id(tc), - (tc_anon_label, 'anon_1', tc), tc.type), + "a": ("a", (t.c.a, "a", "a"), t.c.a.type), + "bar": ("bar", (l1, "bar"), l1.type), + "anon_1": ( + "%%(%d anon)s" % id(tc), + (tc_anon_label, "anon_1", tc), + tc.type, + ), }, ) def test_label_conflict_union(self): - t1 = Table('t1', MetaData(), Column('a', Integer), - Column('b', Integer)) - t2 = Table('t2', MetaData(), Column('t1_a', Integer)) + t1 = Table( + "t1", MetaData(), Column("a", 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() + stmt = ( + select([t1, t1_alias]) + .select_from(t1.join(union, t1.c.a == union.c.t1_a)) + .apply_labels() + ) comp = stmt.compile() eq_( set(comp._create_result_map()), - set(['t1_1_b', 't1_1_a', 't1_a', 't1_b']) - ) - is_( - comp._create_result_map()['t1_a'][1][2], t1.c.a + set(["t1_1_b", "t1_1_a", "t1_a", "t1_b"]), ) + is_(comp._create_result_map()["t1_a"][1][2], t1.c.a) def test_insert_with_select_values(self): - astring = Column('a', String) - aint = Column('a', Integer) + astring = Column("a", String) + aint = Column("a", Integer) m = MetaData() - Table('t1', m, astring) - t2 = Table('t2', m, aint) + Table("t1", m, astring) + t2 = Table("t2", m, aint) stmt = t2.insert().values(a=select([astring])).returning(aint) comp = stmt.compile(dialect=postgresql.dialect()) eq_( comp._create_result_map(), - {'a': ('a', (aint, 'a', 'a'), aint.type)} + {"a": ("a", (aint, "a", "a"), aint.type)}, ) def test_insert_from_select(self): - astring = Column('a', String) - aint = Column('a', Integer) + astring = Column("a", String) + aint = Column("a", Integer) m = MetaData() - Table('t1', m, astring) - t2 = Table('t2', m, aint) + Table("t1", m, astring) + t2 = Table("t2", m, aint) - stmt = t2.insert().from_select(['a'], select([astring])).\ - returning(aint) + stmt = ( + t2.insert().from_select(["a"], select([astring])).returning(aint) + ) comp = stmt.compile(dialect=postgresql.dialect()) eq_( comp._create_result_map(), - {'a': ('a', (aint, 'a', 'a'), aint.type)} + {"a": ("a", (aint, "a", "a"), aint.type)}, ) def test_nested_api(self): from sqlalchemy.engine.result import ResultMetaData + stmt2 = select([table2]) stmt1 = select([table1]).select_from(stmt2) @@ -3936,7 +4336,8 @@ class ResultMapTest(fixtures.TestBase): self._add_to_result_map("k1", "k1", (1, 2, 3), int_) else: text = super(MyCompiler, self).visit_select( - stmt, *arg, **kw) + stmt, *arg, **kw + ) self._add_to_result_map("k2", "k2", (3, 4, 5), int_) return text @@ -3945,62 +4346,68 @@ class ResultMapTest(fixtures.TestBase): eq_( ResultMetaData._create_result_map(contexts[stmt2][0]), { - 'otherid': ( - 'otherid', - (table2.c.otherid, 'otherid', 'otherid'), - table2.c.otherid.type), - 'othername': ( - 'othername', - (table2.c.othername, 'othername', 'othername'), - table2.c.othername.type), - 'k1': ('k1', (1, 2, 3), int_) - } + "otherid": ( + "otherid", + (table2.c.otherid, "otherid", "otherid"), + table2.c.otherid.type, + ), + "othername": ( + "othername", + (table2.c.othername, "othername", "othername"), + table2.c.othername.type, + ), + "k1": ("k1", (1, 2, 3), int_), + }, ) eq_( comp._create_result_map(), { - 'myid': ( - 'myid', - (table1.c.myid, 'myid', 'myid'), table1.c.myid.type + "myid": ( + "myid", + (table1.c.myid, "myid", "myid"), + table1.c.myid.type, + ), + "k2": ("k2", (3, 4, 5), int_), + "name": ( + "name", + (table1.c.name, "name", "name"), + table1.c.name.type, ), - 'k2': ('k2', (3, 4, 5), int_), - 'name': ( - 'name', (table1.c.name, 'name', 'name'), - table1.c.name.type), - 'description': ( - 'description', - (table1.c.description, 'description', 'description'), - table1.c.description.type)} + "description": ( + "description", + (table1.c.description, "description", "description"), + table1.c.description.type, + ), + }, ) def test_select_wraps_for_translate_ambiguity(self): # test for issue #3657 - t = table('a', column('x'), column('y'), column('z')) + t = table("a", column("x"), column("y"), column("z")) - l1, l2, l3 = t.c.z.label('a'), t.c.x.label('b'), t.c.x.label('c') + l1, l2, l3 = t.c.z.label("a"), t.c.x.label("b"), t.c.x.label("c") orig = [t.c.x, t.c.y, l1, l2, l3] stmt = select(orig) wrapped = stmt._generate() wrapped = wrapped.column( - func.ROW_NUMBER().over(order_by=t.c.z)).alias() + func.ROW_NUMBER().over(order_by=t.c.z) + ).alias() wrapped_again = select([c for c in wrapped.c]) compiled = wrapped_again.compile( - compile_kwargs={'select_wraps_for': stmt}) + compile_kwargs={"select_wraps_for": stmt} + ) proxied = [obj[0] for (k, n, obj, type_) in compiled._result_columns] - for orig_obj, proxied_obj in zip( - orig, - proxied - ): + for orig_obj, proxied_obj in zip(orig, proxied): is_(orig_obj, proxied_obj) def test_select_wraps_for_translate_ambiguity_dupe_cols(self): # test for issue #3657 - t = table('a', column('x'), column('y'), column('z')) + t = table("a", column("x"), column("y"), column("z")) - l1, l2, l3 = t.c.z.label('a'), t.c.x.label('b'), t.c.x.label('c') + l1, l2, l3 = t.c.z.label("a"), t.c.x.label("b"), t.c.x.label("c") orig = [t.c.x, t.c.y, l1, l2, l3] # create the statement with some duplicate columns. right now @@ -4018,7 +4425,8 @@ class ResultMapTest(fixtures.TestBase): wrapped = stmt._generate() wrapped = wrapped.column( - func.ROW_NUMBER().over(order_by=t.c.z)).alias() + func.ROW_NUMBER().over(order_by=t.c.z) + ).alias() # so when we wrap here we're going to have only 5 columns wrapped_again = select([c for c in wrapped.c]) @@ -4027,11 +4435,9 @@ class ResultMapTest(fixtures.TestBase): # "select_wraps_for" can't use inner_columns to match because # these collections are not the same compiled = wrapped_again.compile( - compile_kwargs={'select_wraps_for': stmt}) + compile_kwargs={"select_wraps_for": stmt} + ) proxied = [obj[0] for (k, n, obj, type_) in compiled._result_columns] - for orig_obj, proxied_obj in zip( - orig, - proxied - ): + for orig_obj, proxied_obj in zip(orig, proxied): is_(orig_obj, proxied_obj) diff --git a/test/sql/test_constraints.py b/test/sql/test_constraints.py index 3365b3cf0..a5d2043ce 100644 --- a/test/sql/test_constraints.py +++ b/test/sql/test_constraints.py @@ -1,81 +1,109 @@ from sqlalchemy.testing import assert_raises, assert_raises_message -from sqlalchemy import Table, Integer, String, Column, PrimaryKeyConstraint,\ - ForeignKeyConstraint, ForeignKey, UniqueConstraint, Index, MetaData, \ - CheckConstraint, func, text +from sqlalchemy import ( + Table, + Integer, + String, + Column, + PrimaryKeyConstraint, + ForeignKeyConstraint, + ForeignKey, + UniqueConstraint, + Index, + MetaData, + CheckConstraint, + func, + text, +) from sqlalchemy import exc, schema -from sqlalchemy.testing import fixtures, AssertsExecutionResults, \ - AssertsCompiledSQL +from sqlalchemy.testing import ( + fixtures, + AssertsExecutionResults, + AssertsCompiledSQL, +) from sqlalchemy import testing from sqlalchemy.engine import default from sqlalchemy.testing import engines from sqlalchemy.testing.assertions import expect_warnings from sqlalchemy.testing import eq_ -from sqlalchemy.testing.assertsql import (AllOf, - RegexSQL, - CompiledSQL, - DialectSQL) +from sqlalchemy.testing.assertsql import ( + AllOf, + RegexSQL, + CompiledSQL, + DialectSQL, +) from sqlalchemy.sql import table, column class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): - __dialect__ = 'default' + __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') - ) - 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']) - ) + Table( + "employees", + metadata, + 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"] + ), + ) 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)' - ')' - ), - 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)' - ')' - ) - ) - - @testing.force_drop_names('a', 'b') + CompiledSQL( + "CREATE TABLE employees (" + "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)" + ")" + ), + ) + + @testing.force_drop_names("a", "b") def test_fk_cant_drop_cycled_unnamed(self): metadata = 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), + "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"])) + ForeignKeyConstraint(["aid"], ["a.id"]), + ) metadata.create_all(testing.db) if testing.db.dialect.supports_alter: assert_raises_message( @@ -85,159 +113,186 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): "that the ForeignKey and ForeignKeyConstraint objects " "involved in the cycle have names so that they can be " "dropped using DROP CONSTRAINT.", - metadata.drop_all, testing.db + metadata.drop_all, + testing.db, ) else: with expect_warnings( - "Can't sort tables for DROP; an unresolvable " - "foreign key dependency "): + "Can't sort tables for DROP; an unresolvable " + "foreign key dependency " + ): with self.sql_execution_asserter() as asserter: metadata.drop_all(testing.db, checkfirst=False) asserter.assert_( - AllOf( - CompiledSQL("DROP TABLE a"), - CompiledSQL("DROP TABLE b") - ) + AllOf(CompiledSQL("DROP TABLE a"), CompiledSQL("DROP TABLE b")) ) @testing.provide_metadata def test_fk_table_auto_alter_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), + "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"], name="bfk")) + ForeignKeyConstraint(["aid"], ["a.id"], name="bfk"), + ) self._assert_cyclic_constraint( - metadata, auto=True, sqlite_warning=True) + metadata, auto=True, sqlite_warning=True + ) @testing.provide_metadata def test_fk_column_auto_alter_inline_constraint_create(self): metadata = self.metadata - Table("a", metadata, - 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", name="bfk") - ), - ) + Table( + "a", + metadata, + 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", name="bfk")), + ) self._assert_cyclic_constraint( - metadata, auto=True, sqlite_warning=True) + metadata, auto=True, sqlite_warning=True + ) @testing.provide_metadata def test_fk_column_use_alter_inline_constraint_create(self): metadata = self.metadata - Table("a", metadata, - 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", name="bfk", use_alter=True) - ), - ) + Table( + "a", + metadata, + 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", name="bfk", use_alter=True) + ), + ) self._assert_cyclic_constraint(metadata, auto=False) @testing.provide_metadata def test_fk_table_use_alter_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), + "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")) + ["aid"], ["a.id"], use_alter=True, name="bfk" + ), + ) self._assert_cyclic_constraint(metadata) @testing.provide_metadata def test_fk_column_use_alter_constraint_create(self): metadata = self.metadata - Table("a", metadata, - 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") - ), - ) + Table( + "a", + metadata, + 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") + ), + ) self._assert_cyclic_constraint(metadata, auto=False) def _assert_cyclic_constraint( - self, metadata, auto=False, sqlite_warning=False): + self, metadata, auto=False, sqlite_warning=False + ): if testing.db.dialect.supports_alter: self._assert_cyclic_constraint_supports_alter(metadata, auto=auto) else: self._assert_cyclic_constraint_no_alter( - metadata, auto=auto, sqlite_warning=sqlite_warning) + metadata, auto=auto, sqlite_warning=sqlite_warning + ) def _assert_cyclic_constraint_supports_alter(self, metadata, auto=False): table_assertions = [] if auto: table_assertions = [ - CompiledSQL('CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ), CompiledSQL( - 'CREATE TABLE a (' - 'id INTEGER NOT NULL, ' - 'bid INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ) + "CREATE TABLE b (" + "id INTEGER NOT NULL, " + "aid INTEGER, " + "PRIMARY KEY (id)" + ")" + ), + CompiledSQL( + "CREATE TABLE a (" + "id INTEGER NOT NULL, " + "bid INTEGER, " + "PRIMARY KEY (id)" + ")" + ), ] else: table_assertions = [ - CompiledSQL('CREATE TABLE b (' - '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)' - ')' - ) + "CREATE TABLE b (" + "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)" + ")" + ), ] assertions = [AllOf(*table_assertions)] fk_assertions = [] fk_assertions.append( - CompiledSQL('ALTER TABLE b ADD CONSTRAINT bfk ' - 'FOREIGN KEY(aid) REFERENCES a (id)') + CompiledSQL( + "ALTER TABLE b ADD CONSTRAINT bfk " + "FOREIGN KEY(aid) REFERENCES a (id)" + ) ) if auto: fk_assertions.append( - CompiledSQL('ALTER TABLE a ADD ' - 'FOREIGN KEY(bid) REFERENCES b (id)') + CompiledSQL( + "ALTER TABLE a ADD " "FOREIGN KEY(bid) REFERENCES b (id)" + ) ) assertions.append(AllOf(*fk_assertions)) @@ -246,9 +301,9 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): asserter.assert_(*assertions) assertions = [ - CompiledSQL('ALTER TABLE b DROP CONSTRAINT bfk'), + CompiledSQL("ALTER TABLE b DROP CONSTRAINT bfk"), CompiledSQL("DROP TABLE a"), - CompiledSQL("DROP TABLE b") + CompiledSQL("DROP TABLE b"), ] with self.sql_execution_asserter() as asserter: @@ -256,49 +311,50 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): asserter.assert_(*assertions) def _assert_cyclic_constraint_no_alter( - self, metadata, auto=False, sqlite_warning=False): + self, metadata, auto=False, sqlite_warning=False + ): table_assertions = [] if auto: table_assertions.append( DialectSQL( - 'CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id), ' - 'CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)' - ')' + "CREATE TABLE b (" + "id INTEGER NOT NULL, " + "aid INTEGER, " + "PRIMARY KEY (id), " + "CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)" + ")" ) ) table_assertions.append( DialectSQL( - 'CREATE TABLE a (' - 'id INTEGER NOT NULL, ' - 'bid INTEGER, ' - 'PRIMARY KEY (id), ' - 'FOREIGN KEY(bid) REFERENCES b (id)' - ')' + "CREATE TABLE a (" + "id INTEGER NOT NULL, " + "bid INTEGER, " + "PRIMARY KEY (id), " + "FOREIGN KEY(bid) REFERENCES b (id)" + ")" ) ) else: table_assertions.append( DialectSQL( - 'CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id), ' - 'CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)' - ')' + "CREATE TABLE b (" + "id INTEGER NOT NULL, " + "aid INTEGER, " + "PRIMARY KEY (id), " + "CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)" + ")" ) ) table_assertions.append( DialectSQL( - 'CREATE TABLE a (' - 'id INTEGER NOT NULL, ' - 'bid INTEGER, ' - 'PRIMARY KEY (id), ' - 'FOREIGN KEY(bid) REFERENCES b (id)' - ')' + "CREATE TABLE a (" + "id INTEGER NOT NULL, " + "bid INTEGER, " + "PRIMARY KEY (id), " + "FOREIGN KEY(bid) REFERENCES b (id)" + ")" ) ) @@ -308,10 +364,9 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata.create_all(checkfirst=False) asserter.assert_(*assertions) - assertions = [AllOf( - CompiledSQL("DROP TABLE a"), - CompiledSQL("DROP TABLE b") - )] + assertions = [ + AllOf(CompiledSQL("DROP TABLE a"), CompiledSQL("DROP TABLE b")) + ] if sqlite_warning: with expect_warnings("Can't sort tables for DROP; "): @@ -326,38 +381,44 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): def test_cycle_unnamed_fks(self): metadata = MetaData(testing.db) - Table("a", metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer, ForeignKey("b.id")), - ) + Table( + "a", + metadata, + 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")), - ) + Table( + "b", + metadata, + Column("id", Integer, primary_key=True), + Column("aid", Integer, ForeignKey("a.id")), + ) assertions = [ AllOf( CompiledSQL( - 'CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id)' - ')' + "CREATE TABLE b (" + "id INTEGER NOT NULL, " + "aid INTEGER, " + "PRIMARY KEY (id)" + ")" ), CompiledSQL( - 'CREATE TABLE a (' - 'id INTEGER NOT NULL, ' - 'bid INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ) + "CREATE TABLE a (" + "id INTEGER NOT NULL, " + "bid INTEGER, " + "PRIMARY KEY (id)" + ")" + ), ), AllOf( - CompiledSQL('ALTER TABLE b ADD ' - 'FOREIGN KEY(aid) REFERENCES a (id)'), - CompiledSQL('ALTER TABLE a ADD ' - 'FOREIGN KEY(bid) REFERENCES b (id)') + CompiledSQL( + "ALTER TABLE b ADD " "FOREIGN KEY(aid) REFERENCES a (id)" + ), + CompiledSQL( + "ALTER TABLE a ADD " "FOREIGN KEY(bid) REFERENCES b (id)" + ), ), ] with self.sql_execution_asserter() as asserter: @@ -374,58 +435,65 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): "ForeignKey and ForeignKeyConstraint objects involved in the " "cycle have names so that they can be dropped using " "DROP CONSTRAINT.", - metadata.drop_all, checkfirst=False + metadata.drop_all, + checkfirst=False, ) else: with expect_warnings( - "Can't sort tables for DROP; an unresolvable " - "foreign key dependency exists between tables"): + "Can't sort tables for DROP; an unresolvable " + "foreign key dependency exists between tables" + ): with self.sql_execution_asserter() as asserter: metadata.drop_all(checkfirst=False) asserter.assert_( - AllOf( - CompiledSQL("DROP TABLE b"), - CompiledSQL("DROP TABLE a"), - ) + AllOf(CompiledSQL("DROP TABLE b"), CompiledSQL("DROP TABLE a")) ) @testing.force_drop_names("a", "b") def test_cycle_named_fks(self): metadata = MetaData(testing.db) - Table("a", metadata, - Column('id', Integer, primary_key=True), - Column('bid', Integer, ForeignKey("b.id")), - ) + Table( + "a", + metadata, + 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='aidfk')), - ) + Table( + "b", + metadata, + Column("id", Integer, primary_key=True), + Column( + "aid", + Integer, + ForeignKey("a.id", use_alter=True, name="aidfk"), + ), + ) assertions = [ AllOf( CompiledSQL( - 'CREATE TABLE b (' - 'id INTEGER NOT NULL, ' - 'aid INTEGER, ' - 'PRIMARY KEY (id)' - ')' + "CREATE TABLE b (" + "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)' - ')' - ) + "CREATE TABLE a (" + "id INTEGER NOT NULL, " + "bid INTEGER, " + "PRIMARY KEY (id), " + "FOREIGN KEY(bid) REFERENCES b (id)" + ")" + ), + ), + CompiledSQL( + "ALTER TABLE b ADD CONSTRAINT aidfk " + "FOREIGN KEY(aid) REFERENCES a (id)" ), - CompiledSQL('ALTER TABLE b ADD CONSTRAINT aidfk ' - 'FOREIGN KEY(aid) REFERENCES a (id)'), ] with self.sql_execution_asserter() as asserter: metadata.create_all(checkfirst=False) @@ -439,19 +507,15 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): asserter.assert_( CompiledSQL("ALTER TABLE b DROP CONSTRAINT aidfk"), AllOf( - CompiledSQL("DROP TABLE b"), - CompiledSQL("DROP TABLE a"), - ) + CompiledSQL("DROP TABLE b"), CompiledSQL("DROP TABLE a") + ), ) else: with self.sql_execution_asserter() as asserter: metadata.drop_all(checkfirst=False) asserter.assert_( - AllOf( - CompiledSQL("DROP TABLE b"), - CompiledSQL("DROP TABLE a"), - ), + AllOf(CompiledSQL("DROP TABLE b"), CompiledSQL("DROP TABLE a")) ) @testing.requires.check_constraints @@ -459,89 +523,112 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): def test_check_constraint_create(self): metadata = self.metadata - Table('foo', metadata, - 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) - ) + Table( + "foo", + metadata, + 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), + ) 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)' - ')' - ), - CompiledSQL('CREATE TABLE bar (' - 'id INTEGER NOT NULL, ' - 'x INTEGER CHECK (x>7), ' - 'z INTEGER, ' - 'PRIMARY KEY (id)' - ')' - ) - ) + CompiledSQL( + "CREATE TABLE foo (" + "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)" + ")" + ), + ), ) @testing.provide_metadata def test_unique_constraint_create(self): metadata = self.metadata - Table('foo', metadata, - 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') - ) + Table( + "foo", + metadata, + 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"), + ) 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)' - ')'), - CompiledSQL('CREATE TABLE bar (' - 'id INTEGER NOT NULL, ' - 'value VARCHAR(30), ' - 'value2 VARCHAR(30), ' - 'PRIMARY KEY (id), ' - 'CONSTRAINT uix1 UNIQUE (value, value2)' - ')') - ) + CompiledSQL( + "CREATE TABLE foo (" + "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)" + ")" + ), + ), ) @testing.provide_metadata def test_index_create(self): metadata = self.metadata - employees = Table('employees', metadata, - Column('id', Integer, primary_key=True), - Column('first_name', String(30)), - Column('last_name', String(30)), - Column('email_address', String(30))) + employees = Table( + "employees", + metadata, + Column("id", Integer, primary_key=True), + Column("first_name", String(30)), + Column("last_name", String(30)), + Column("email_address", String(30)), + ) - i = Index('employee_name_index', - employees.c.last_name, employees.c.first_name) + i = Index( + "employee_name_index", + employees.c.last_name, + employees.c.first_name, + ) assert i in employees.indexes - i2 = Index('employee_email_index', - employees.c.email_address, unique=True) + i2 = Index( + "employee_email_index", employees.c.email_address, unique=True + ) assert i2 in employees.indexes self.assert_sql_execution( @@ -549,11 +636,17 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): lambda: metadata.create_all(checkfirst=False), RegexSQL("^CREATE TABLE"), AllOf( - CompiledSQL('CREATE INDEX employee_name_index ON ' - 'employees (last_name, first_name)', []), - CompiledSQL('CREATE UNIQUE INDEX employee_email_index ON ' - 'employees (email_address)', []) - ) + CompiledSQL( + "CREATE INDEX employee_name_index ON " + "employees (last_name, first_name)", + [], + ), + CompiledSQL( + "CREATE UNIQUE INDEX employee_email_index ON " + "employees (email_address)", + [], + ), + ), ) @testing.provide_metadata @@ -562,27 +655,36 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata - employees = Table('companyEmployees', metadata, - Column('id', Integer, primary_key=True), - Column('firstName', String(30)), - Column('lastName', String(30)), - Column('emailAddress', String(30))) + employees = Table( + "companyEmployees", + metadata, + Column("id", Integer, primary_key=True), + Column("firstName", String(30)), + Column("lastName", String(30)), + Column("emailAddress", String(30)), + ) - Index('employeeNameIndex', - employees.c.lastName, employees.c.firstName) + Index("employeeNameIndex", employees.c.lastName, employees.c.firstName) - Index('employeeEmailIndex', - employees.c.emailAddress, unique=True) + Index("employeeEmailIndex", employees.c.emailAddress, unique=True) self.assert_sql_execution( - testing.db, lambda: metadata.create_all( - checkfirst=False), RegexSQL("^CREATE TABLE"), AllOf( + testing.db, + lambda: metadata.create_all(checkfirst=False), + RegexSQL("^CREATE TABLE"), + AllOf( CompiledSQL( 'CREATE INDEX "employeeNameIndex" ON ' - '"companyEmployees" ("lastName", "firstName")', []), + '"companyEmployees" ("lastName", "firstName")', + [], + ), CompiledSQL( 'CREATE UNIQUE INDEX "employeeEmailIndex" ON ' - '"companyEmployees" ("emailAddress")', []))) + '"companyEmployees" ("emailAddress")', + [], + ), + ), + ) @testing.provide_metadata def test_index_create_inline(self): @@ -590,22 +692,32 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): metadata = self.metadata - events = Table('events', metadata, - Column('id', Integer, primary_key=True), - Column('name', String(30), index=True, unique=True), - Column('location', String(30), index=True), - Column('sport', String(30)), - Column('announcer', String(30)), - Column('winner', String(30))) + events = Table( + "events", + metadata, + Column("id", Integer, primary_key=True), + Column("name", String(30), index=True, unique=True), + Column("location", String(30), index=True), + Column("sport", String(30)), + Column("announcer", String(30)), + Column("winner", String(30)), + ) - Index('sport_announcer', events.c.sport, events.c.announcer, - unique=True) - Index('idx_winners', events.c.winner) + Index( + "sport_announcer", events.c.sport, events.c.announcer, 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']) + set( + [ + "ix_events_name", + "ix_events_location", + "sport_announcer", + "idx_winners", + ] + ), ) self.assert_sql_execution( @@ -613,72 +725,71 @@ class ConstraintGenTest(fixtures.TestBase, AssertsExecutionResults): lambda: events.create(testing.db), RegexSQL("^CREATE TABLE events"), AllOf( - CompiledSQL('CREATE UNIQUE INDEX ix_events_name ON events ' - '(name)'), - CompiledSQL('CREATE INDEX ix_events_location ON events ' - '(location)'), - CompiledSQL('CREATE UNIQUE INDEX sport_announcer ON events ' - '(sport, announcer)'), - CompiledSQL('CREATE INDEX idx_winners ON events (winner)'), - ) + CompiledSQL( + "CREATE UNIQUE INDEX ix_events_name ON events " "(name)" + ), + CompiledSQL( + "CREATE INDEX ix_events_location ON events " "(location)" + ), + CompiledSQL( + "CREATE UNIQUE INDEX sport_announcer ON events " + "(sport, announcer)" + ), + CompiledSQL("CREATE INDEX idx_winners ON events (winner)"), + ), ) @testing.provide_metadata def test_index_functional_create(self): metadata = self.metadata - t = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String(50)) - ) - Index('myindex', t.c.data.desc()) + t = Table( + "sometable", + metadata, + 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))'), - CompiledSQL('CREATE INDEX myindex ON sometable (data DESC)') + CompiledSQL( + "CREATE TABLE sometable (id INTEGER NOT NULL, " + "data VARCHAR(50), PRIMARY KEY (id))" + ), + CompiledSQL("CREATE INDEX myindex ON sometable (data DESC)"), ) class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_create_index_plain(self): - t = Table('t', MetaData(), Column('x', Integer)) + t = Table("t", MetaData(), Column("x", Integer)) i = Index("xyz", t.c.x) - self.assert_compile( - schema.CreateIndex(i), - "CREATE INDEX xyz ON t (x)" - ) + self.assert_compile(schema.CreateIndex(i), "CREATE INDEX xyz ON t (x)") def test_drop_index_plain_unattached(self): self.assert_compile( - schema.DropIndex(Index(name="xyz")), - "DROP INDEX xyz" + schema.DropIndex(Index(name="xyz")), "DROP INDEX xyz" ) def test_drop_index_plain(self): self.assert_compile( - schema.DropIndex(Index(name="xyz")), - "DROP INDEX xyz" + schema.DropIndex(Index(name="xyz")), "DROP INDEX xyz" ) def test_create_index_schema(self): - t = Table('t', MetaData(), Column('x', Integer), schema="foo") + t = Table("t", MetaData(), Column("x", Integer), schema="foo") i = Index("xyz", t.c.x) self.assert_compile( - schema.CreateIndex(i), - "CREATE INDEX xyz ON foo.t (x)" + schema.CreateIndex(i), "CREATE INDEX xyz ON foo.t (x)" ) def test_drop_index_schema(self): - t = Table('t', MetaData(), Column('x', Integer), schema="foo") + t = Table("t", MetaData(), Column("x", Integer), schema="foo") i = Index("xyz", t.c.x) - self.assert_compile( - schema.DropIndex(i), - "DROP INDEX foo.xyz" - ) + self.assert_compile(schema.DropIndex(i), "DROP INDEX foo.xyz") def test_too_long_index_name(self): dialect = testing.db.dialect.__class__() @@ -688,157 +799,171 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): dialect.max_index_name_length = max_index for tname, cname, exp in [ - ('sometable', 'this_name_is_too_long', 'ix_sometable_t_09aa'), - ('sometable', 'this_name_alsois_long', 'ix_sometable_t_3cf1'), + ("sometable", "this_name_is_too_long", "ix_sometable_t_09aa"), + ("sometable", "this_name_alsois_long", "ix_sometable_t_3cf1"), ]: - t1 = Table(tname, MetaData(), - Column(cname, Integer, index=True), - ) + t1 = Table( + tname, MetaData(), Column(cname, Integer, index=True) + ) ix1 = list(t1.indexes)[0] self.assert_compile( schema.CreateIndex(ix1), - "CREATE INDEX %s " - "ON %s (%s)" % (exp, tname, cname), - dialect=dialect + "CREATE INDEX %s " "ON %s (%s)" % (exp, tname, cname), + dialect=dialect, ) dialect.max_identifier_length = 22 dialect.max_index_name_length = None - t1 = Table('t', MetaData(), Column('c', Integer)) + t1 = Table("t", MetaData(), Column("c", Integer)) assert_raises( exc.IdentifierError, - schema.CreateIndex(Index( - "this_other_name_is_too_long_for_what_were_doing", - t1.c.c)).compile, - dialect=dialect + schema.CreateIndex( + Index( + "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)) - ) - idx = Index('y', func.lower(x.c.q)) + x = Table("x", metadata, Column("q", String(50))) + idx = Index("y", func.lower(x.c.q)) self.assert_compile( - schema.CreateIndex(idx), - "CREATE INDEX y ON x (lower(q))" + schema.CreateIndex(idx), "CREATE INDEX y ON x (lower(q))" ) self.assert_compile( schema.CreateIndex(idx), "CREATE INDEX y ON x (lower(q))", - dialect=testing.db.dialect + dialect=testing.db.dialect, ) def test_index_against_text_separate(self): metadata = MetaData() - idx = Index('y', text("some_function(q)")) - t = Table('x', metadata, - Column('q', String(50)) - ) + idx = Index("y", text("some_function(q)")) + t = Table("x", metadata, Column("q", String(50))) t.append_constraint(idx) self.assert_compile( - schema.CreateIndex(idx), - "CREATE INDEX y ON x (some_function(q))" + schema.CreateIndex(idx), "CREATE INDEX y ON x (some_function(q))" ) def test_index_against_text_inline(self): metadata = MetaData() - idx = Index('y', text("some_function(q)")) - x = Table('x', metadata, - Column('q', String(50)), - idx - ) + idx = Index("y", text("some_function(q)")) + x = Table("x", metadata, Column("q", String(50)), idx) self.assert_compile( - schema.CreateIndex(idx), - "CREATE INDEX y ON x (some_function(q))" + 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') - ) + t1 = Table( + "t1", + metadata, + 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)" + "CREATE INDEX foo ON t1 (x, y)", ) def _test_deferrable(self, constraint_factory): dialect = default.DefaultDialect() - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer), - constraint_factory(deferrable=True)) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column("b", Integer), + constraint_factory(deferrable=True), + ) sql = str(schema.CreateTable(t).compile(dialect=dialect)) - assert 'DEFERRABLE' in sql, sql - assert 'NOT DEFERRABLE' not in sql, sql + assert "DEFERRABLE" in sql, sql + assert "NOT DEFERRABLE" not in sql, sql - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer), - constraint_factory(deferrable=False)) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column("b", Integer), + constraint_factory(deferrable=False), + ) sql = str(schema.CreateTable(t).compile(dialect=dialect)) - assert 'NOT DEFERRABLE' in sql + assert "NOT DEFERRABLE" in sql - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer), - constraint_factory(deferrable=True, initially='IMMEDIATE')) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column("b", Integer), + constraint_factory(deferrable=True, initially="IMMEDIATE"), + ) sql = str(schema.CreateTable(t).compile(dialect=dialect)) - assert 'NOT DEFERRABLE' not in sql - assert 'INITIALLY IMMEDIATE' in sql + assert "NOT DEFERRABLE" not in sql + assert "INITIALLY IMMEDIATE" in sql - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer), - constraint_factory(deferrable=True, initially='DEFERRED')) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column("b", Integer), + constraint_factory(deferrable=True, initially="DEFERRED"), + ) sql = str(schema.CreateTable(t).compile(dialect=dialect)) - assert 'NOT DEFERRABLE' not in sql - assert 'INITIALLY DEFERRED' in sql + assert "NOT DEFERRABLE" not in sql + assert "INITIALLY DEFERRED" in sql def test_column_level_ck_name(self): t = Table( - 'tbl', + "tbl", MetaData(), Column( - 'a', + "a", Integer, - CheckConstraint( - "a > 5", - name="ck_a_greater_five"))) + 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))" + "ck_a_greater_five CHECK (a > 5))", ) def test_deferrable_pk(self): - def factory(**kw): return PrimaryKeyConstraint('a', **kw) + def factory(**kw): + return PrimaryKeyConstraint("a", **kw) + self._test_deferrable(factory) def test_deferrable_table_fk(self): - def factory(**kw): return ForeignKeyConstraint(['b'], ['tbl.a'], **kw) + def factory(**kw): + return ForeignKeyConstraint(["b"], ["tbl.a"], **kw) + self._test_deferrable(factory) def test_deferrable_column_fk(self): - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer, - ForeignKey('tbl.a', deferrable=True, - initially='DEFERRED'))) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column( + "b", + Integer, + ForeignKey("tbl.a", deferrable=True, initially="DEFERRED"), + ), + ) self.assert_compile( schema.CreateTable(t), @@ -848,10 +973,12 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): ) def test_fk_match_clause(self): - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer, - ForeignKey('tbl.a', match="SIMPLE"))) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column("b", Integer, ForeignKey("tbl.a", match="SIMPLE")), + ) self.assert_compile( schema.CreateTable(t), @@ -863,55 +990,64 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.AddConstraint(list(t.foreign_keys)[0].constraint), "ALTER TABLE tbl ADD FOREIGN KEY(b) " - "REFERENCES tbl (a) MATCH SIMPLE" + "REFERENCES tbl (a) MATCH SIMPLE", ) def test_create_table_omit_fks(self): fkcs = [ - ForeignKeyConstraint(['a'], ['remote.id'], name='foo'), - ForeignKeyConstraint(['b'], ['remote.id'], name='bar'), - ForeignKeyConstraint(['c'], ['remote.id'], name='bat'), + ForeignKeyConstraint(["a"], ["remote.id"], name="foo"), + ForeignKeyConstraint(["b"], ["remote.id"], name="bar"), + ForeignKeyConstraint(["c"], ["remote.id"], name="bat"), ] m = MetaData() t = Table( - 't', m, - Column('a', Integer), - Column('b', Integer), - Column('c', Integer), + "t", + m, + Column("a", Integer), + Column("b", Integer), + Column("c", Integer), *fkcs ) - Table('remote', m, Column('id', Integer, primary_key=True)) + Table("remote", m, Column("id", Integer, primary_key=True)) self.assert_compile( schema.CreateTable(t, include_foreign_key_constraints=[]), - "CREATE TABLE t (a INTEGER, b INTEGER, c INTEGER)" + "CREATE TABLE t (a INTEGER, b INTEGER, c INTEGER)", ) self.assert_compile( schema.CreateTable(t, include_foreign_key_constraints=fkcs[0:2]), "CREATE TABLE t (a INTEGER, b INTEGER, c INTEGER, " "CONSTRAINT foo FOREIGN KEY(a) REFERENCES remote (id), " - "CONSTRAINT bar FOREIGN KEY(b) REFERENCES remote (id))" + "CONSTRAINT bar FOREIGN KEY(b) REFERENCES remote (id))", ) def test_deferrable_unique(self): - def factory(**kw): return UniqueConstraint('b', **kw) + def factory(**kw): + return UniqueConstraint("b", **kw) + self._test_deferrable(factory) def test_deferrable_table_check(self): - def factory(**kw): return CheckConstraint('a < b', **kw) + def factory(**kw): + return CheckConstraint("a < b", **kw) + self._test_deferrable(factory) def test_multiple(self): m = MetaData() - Table("foo", m, - 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')), - ) + Table( + "foo", + m, + 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")), + ) self.assert_compile( schema.CreateTable(tb), "CREATE TABLE some_table (" @@ -920,93 +1056,106 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): "foo_bar INTEGER, " "PRIMARY KEY (id), " "FOREIGN KEY(foo_id) REFERENCES foo (id), " - "FOREIGN KEY(foo_bar) REFERENCES foo (bar))" + "FOREIGN KEY(foo_bar) REFERENCES foo (bar))", ) def test_empty_pkc(self): # test that an empty primary key is ignored metadata = MetaData() - tbl = Table('test', metadata, - Column('x', Integer, autoincrement=False), - Column('y', Integer, autoincrement=False), - PrimaryKeyConstraint()) - self.assert_compile(schema.CreateTable(tbl), - "CREATE TABLE test (x INTEGER, y INTEGER)" - ) + tbl = Table( + "test", + metadata, + Column("x", Integer, autoincrement=False), + Column("y", Integer, autoincrement=False), + PrimaryKeyConstraint(), + ) + self.assert_compile( + schema.CreateTable(tbl), "CREATE TABLE test (x INTEGER, y INTEGER)" + ) def test_empty_uc(self): # test that an empty constraint is ignored metadata = MetaData() - tbl = Table('test', metadata, - Column('x', Integer, autoincrement=False), - Column('y', Integer, autoincrement=False), - UniqueConstraint()) - self.assert_compile(schema.CreateTable(tbl), - "CREATE TABLE test (x INTEGER, y INTEGER)" - ) + tbl = Table( + "test", + metadata, + Column("x", Integer, autoincrement=False), + Column("y", Integer, autoincrement=False), + UniqueConstraint(), + ) + self.assert_compile( + schema.CreateTable(tbl), "CREATE TABLE test (x INTEGER, y INTEGER)" + ) def test_deferrable_column_check(self): - t = Table('tbl', MetaData(), - Column('a', Integer), - Column('b', Integer, - CheckConstraint('a < b', - deferrable=True, - initially='DEFERRED'))) + t = Table( + "tbl", + MetaData(), + Column("a", Integer), + Column( + "b", + Integer, + CheckConstraint( + "a < b", deferrable=True, initially="DEFERRED" + ), + ), + ) 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), - ) + Table("t", m, 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')) - ) + Table( + "t2", + m, + 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') + e = engines.mock_engine(dialect_name="postgresql") m.create_all(e) m.drop_all(e) - e.assert_sql([ - 'CREATE TABLE t (a INTEGER)', - 'CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb ' - 'FOREIGN KEY(b) REFERENCES t (a))', - 'ALTER TABLE t2 ' - 'ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)', - 'ALTER TABLE t2 DROP CONSTRAINT fk_ta', - 'DROP TABLE t2', - 'DROP TABLE t' - ]) + e.assert_sql( + [ + "CREATE TABLE t (a INTEGER)", + "CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb " + "FOREIGN KEY(b) REFERENCES t (a))", + "ALTER TABLE t2 " + "ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)", + "ALTER TABLE t2 DROP CONSTRAINT fk_ta", + "DROP TABLE t2", + "DROP TABLE t", + ] + ) def _constraint_create_fixture(self): m = MetaData() - t = Table('tbl', m, - Column('a', Integer), - Column('b', Integer) - ) + t = Table("tbl", m, Column("a", Integer), Column("b", Integer)) - t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + t2 = Table("t2", m, Column("a", Integer), Column("b", Integer)) return t, t2 def test_render_ck_constraint_inline(self): t, t2 = self._constraint_create_fixture() - CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + CheckConstraint( + "a < b", + name="my_test_constraint", + deferrable=True, + initially="DEFERRED", + table=t, + ) # before we create an AddConstraint, # the CONSTRAINT comes out inline @@ -1017,28 +1166,36 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): "b INTEGER, " "CONSTRAINT my_test_constraint CHECK (a < b) " "DEFERRABLE INITIALLY DEFERRED" - ")" + ")", ) def test_render_ck_constraint_external(self): t, t2 = self._constraint_create_fixture() - constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + constraint = CheckConstraint( + "a < b", + name="my_test_constraint", + 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) + constraint = CheckConstraint( + "a < b", + name="my_test_constraint", + deferrable=True, + initially="DEFERRED", + table=t, + ) schema.AddConstraint(constraint) @@ -1047,34 +1204,39 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): # is disabled self.assert_compile( schema.CreateTable(t), - "CREATE TABLE tbl (" - "a INTEGER, " - "b INTEGER" - ")" + "CREATE TABLE tbl (" "a INTEGER, " "b INTEGER" ")", ) def test_render_drop_constraint(self): t, t2 = self._constraint_create_fixture() - constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + constraint = CheckConstraint( + "a < b", + name="my_test_constraint", + deferrable=True, + initially="DEFERRED", + table=t, + ) self.assert_compile( schema.DropConstraint(constraint), - "ALTER TABLE tbl DROP CONSTRAINT my_test_constraint" + "ALTER TABLE tbl DROP CONSTRAINT my_test_constraint", ) def test_render_drop_constraint_cascade(self): t, t2 = self._constraint_create_fixture() - constraint = CheckConstraint('a < b', name="my_test_constraint", - deferrable=True, initially='DEFERRED', - table=t) + constraint = CheckConstraint( + "a < b", + name="my_test_constraint", + deferrable=True, + initially="DEFERRED", + table=t, + ) self.assert_compile( schema.DropConstraint(constraint, cascade=True), - "ALTER TABLE tbl DROP CONSTRAINT my_test_constraint CASCADE" + "ALTER TABLE tbl DROP CONSTRAINT my_test_constraint CASCADE", ) def test_render_add_fk_constraint_stringcol(self): @@ -1084,7 +1246,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t.append_constraint(constraint) self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE tbl ADD FOREIGN KEY(b) REFERENCES t2 (a)" + "ALTER TABLE tbl ADD FOREIGN KEY(b) REFERENCES t2 (a)", ) def test_render_add_fk_constraint_realcol(self): @@ -1094,7 +1256,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t.append_constraint(constraint) self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE tbl ADD FOREIGN KEY(a) REFERENCES t2 (b)" + "ALTER TABLE tbl ADD FOREIGN KEY(a) REFERENCES t2 (b)", ) def test_render_add_uq_constraint_stringcol(self): @@ -1104,7 +1266,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): t2.append_constraint(constraint) self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE t2 ADD CONSTRAINT uq_cst UNIQUE (a, b)" + "ALTER TABLE t2 ADD CONSTRAINT uq_cst UNIQUE (a, b)", ) def test_render_add_uq_constraint_realcol(self): @@ -1113,7 +1275,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): constraint = UniqueConstraint(t2.c.a, t2.c.b, name="uq_cs2") self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE t2 ADD CONSTRAINT uq_cs2 UNIQUE (a, b)" + "ALTER TABLE t2 ADD CONSTRAINT uq_cs2 UNIQUE (a, b)", ) def test_render_add_pk_constraint(self): @@ -1124,7 +1286,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): assert t.c.a.primary_key is True self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE tbl ADD PRIMARY KEY (a)" + "ALTER TABLE tbl ADD PRIMARY KEY (a)", ) def test_render_check_constraint_sql_literal(self): @@ -1134,7 +1296,7 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.AddConstraint(constraint), - "ALTER TABLE tbl ADD CHECK (a > 5)" + "ALTER TABLE tbl ADD CHECK (a > 5)", ) def test_render_check_constraint_inline_sql_literal(self): @@ -1142,20 +1304,20 @@ class ConstraintCompilationTest(fixtures.TestBase, AssertsCompiledSQL): m = MetaData() t = Table( - 't', m, - Column('a', Integer, CheckConstraint(Column('a', Integer) > 5))) + "t", + m, + Column("a", Integer, CheckConstraint(Column("a", Integer) > 5)), + ) self.assert_compile( - schema.CreateColumn(t.c.a), - "a INTEGER CHECK (a > 5)" + schema.CreateColumn(t.c.a), "a INTEGER CHECK (a > 5)" ) def test_render_index_sql_literal(self): t, t2 = self._constraint_create_fixture() - constraint = Index('name', t.c.a + 5) + constraint = Index("name", t.c.a + 5) self.assert_compile( - schema.CreateIndex(constraint), - "CREATE INDEX name ON tbl (a + 5)" + schema.CreateIndex(constraint), "CREATE INDEX name ON tbl (a + 5)" ) diff --git a/test/sql/test_cte.py b/test/sql/test_cte.py index efc4640ed..74c32387f 100644 --- a/test/sql/test_cte.py +++ b/test/sql/test_cte.py @@ -1,7 +1,15 @@ from sqlalchemy.testing import fixtures, eq_ from sqlalchemy.testing import AssertsCompiledSQL, assert_raises_message -from sqlalchemy.sql import table, column, select, func, literal, exists, \ - and_, bindparam +from sqlalchemy.sql import ( + table, + column, + select, + func, + literal, + exists, + and_, + bindparam, +) from sqlalchemy.dialects import mssql from sqlalchemy.engine import default from sqlalchemy.exc import CompileError @@ -11,36 +19,49 @@ from sqlalchemy.sql.visitors import cloned_traverse class CTETest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default_enhanced' + __dialect__ = "default_enhanced" def test_nonrecursive(self): - orders = table('orders', - 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") - - 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") - - 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 = table( + "orders", + 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") + ) + + 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") + ) + + 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) + ) # needs to render regional_sales first as top_regions # refers to it @@ -59,41 +80,51 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "sum(orders.amount) AS product_sales " "FROM orders WHERE orders.region " "IN (SELECT top_regions.region FROM top_regions) " - "GROUP BY orders.region, orders.product" + "GROUP BY orders.region, orders.product", ) def test_recursive(self): - parts = table('parts', - 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 = table( + "parts", 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) + ) incl_alias = included_parts.alias() parts_alias = parts.alias() included_parts = included_parts.union( - select([ - parts_alias.c.sub_part, - parts_alias.c.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)).\ - group_by(included_parts.c.sub_part) + select( + [ + parts_alias.c.sub_part, + parts_alias.c.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 + ) + ) + .group_by(included_parts.c.sub_part) + ) self.assert_compile( - s, "WITH RECURSIVE anon_1(sub_part, part, quantity) " + 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 " @@ -104,12 +135,14 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "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") + "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) " + 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 " @@ -120,40 +153,52 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "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()) + "GROUP BY anon_1.sub_part", + dialect=mssql.dialect(), + ) def test_recursive_inner_cte_unioned_to_alias(self): - parts = table('parts', - 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) - - incl_alias = included_parts.alias('incl') + parts = table( + "parts", 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) + ) + + incl_alias = included_parts.alias("incl") parts_alias = parts.alias() included_parts = incl_alias.union( - select([ - parts_alias.c.sub_part, - parts_alias.c.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)).\ - group_by(included_parts.c.sub_part) + select( + [ + parts_alias.c.sub_part, + parts_alias.c.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 + ) + ) + .group_by(included_parts.c.sub_part) + ) self.assert_compile( - s, "WITH RECURSIVE incl(sub_part, part, quantity) " + s, + "WITH RECURSIVE incl(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 " @@ -164,37 +209,38 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "SELECT incl.sub_part, " "sum(incl.quantity) AS total_quantity FROM incl " "JOIN parts ON incl.part = parts.part " - "GROUP BY incl.sub_part") + "GROUP BY incl.sub_part", + ) def test_recursive_union_no_alias_one(self): s1 = select([literal(0).label("x")]) cte = s1.cte(name="cte", recursive=True) - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ) + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)) 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" - ) + 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", + ) def test_recursive_union_alias_one(self): s1 = select([literal(0).label("x")]) cte = s1.cte(name="cte", recursive=True) - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ).alias("cr1") + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)).alias( + "cr1" + ) 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 cr1.x FROM cte AS cr1" - ) + 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 cr1.x FROM cte AS cr1", + ) def test_recursive_union_no_alias_two(self): """ @@ -216,14 +262,15 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): t = select([func.values(1).label("n")]).cte("t", recursive=True) 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" - ) + 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", + ) def test_recursive_union_alias_two(self): """ @@ -234,16 +281,17 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): # we're cheating here. also yes we need the SELECT, # sorry PG. t = select([func.values(1).label("n")]).cte("t", recursive=True) - t = t.union_all(select([t.c.n + 1]).where(t.c.n < 100)).alias('ta') + t = t.union_all(select([t.c.n + 1]).where(t.c.n < 100)).alias("ta") 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(ta.n) AS sum_1 FROM t AS ta" - ) + 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(ta.n) AS sum_1 FROM t AS ta", + ) def test_recursive_union_no_alias_three(self): # like test one, but let's refer to the CTE @@ -254,20 +302,19 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): # can't do it here... # bar = select([cte]).cte('bar') - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ) - bar = select([cte]).cte('bar') + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)) + bar = select([cte]).cte("bar") 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" - ) + 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", + ) def test_recursive_union_alias_three(self): # like test one, but let's refer to the CTE @@ -278,20 +325,21 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): # can't do it here... # bar = select([cte]).cte('bar') - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ).alias("cs1") - bar = select([cte]).cte('bar').alias("cs2") + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)).alias( + "cs1" + ) + bar = select([cte]).cte("bar").alias("cs2") 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 cs1.x AS x FROM cte AS cs1) " - "SELECT cs1.x, cs2.x FROM cte AS cs1, bar AS cs2" - ) + 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 cs1.x AS x FROM cte AS cs1) " + "SELECT cs1.x, cs2.x FROM cte AS cs1, bar AS cs2", + ) def test_recursive_union_no_alias_four(self): # like test one and three, but let's refer @@ -302,43 +350,45 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): s1 = select([literal(0).label("x")]) cte = s1.cte(name="cte", recursive=True) - bar = select([cte]).cte('bar') - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ) + bar = select([cte]).cte("bar") + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)) # outer cte rendered first, then bar, which # 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" - ) + 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", + ) # 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" - ) + 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", + ) # 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), " + 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") + "SELECT bar.x, cte.x FROM bar, cte", + ) def test_recursive_union_alias_four(self): # like test one and three, but let's refer @@ -349,222 +399,228 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): s1 = select([literal(0).label("x")]) cte = s1.cte(name="cte", recursive=True) - bar = select([cte]).cte('bar').alias("cs1") - cte = cte.union_all( - select([cte.c.x + 1]).where(cte.c.x < 10) - ).alias("cs2") + bar = select([cte]).cte("bar").alias("cs1") + cte = cte.union_all(select([cte.c.x + 1]).where(cte.c.x < 10)).alias( + "cs2" + ) # outer cte rendered first, then bar, which # 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 cs2.x, cs1.x FROM cte AS cs2, bar AS cs1" - ) + 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 cs2.x, cs1.x FROM cte AS cs2, bar AS cs1", + ) # 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 cs1.x FROM bar AS cs1" - ) + self.assert_compile( + s2, + "WITH RECURSIVE cte(x) AS " + "(SELECT :param_1 AS x), " + "bar AS (SELECT cte.x AS x FROM cte) " + "SELECT cs1.x FROM bar AS cs1", + ) # 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), " + 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 cs1.x, cs2.x FROM bar AS cs1, cte AS cs2") + "SELECT cs1.x, cs2.x FROM bar AS cs1, cte AS cs2", + ) 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) + 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 + "Multiple, unrelated CTEs found " "with the same name: 'cte1'", + s.compile, ) def test_union(self): - orders = table('orders', - column('region'), - column('amount'), - ) - - regional_sales = select([ - orders.c.region, - orders.c.amount - ]).cte("regional_sales") - - s = select( - [regional_sales.c.region]).where( + orders = table("orders", column("region"), column("amount")) + + regional_sales = select([orders.c.region, orders.c.amount]).cte( + "regional_sales" + ) + + 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") + 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", + ) s = s.union_all( - select([regional_sales.c.region]). - where( + 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") + 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", + ) def test_union_cte_aliases(self): - orders = table('orders', - column('region'), - column('amount'), - ) - - regional_sales = select([ - orders.c.region, - orders.c.amount - ]).cte("regional_sales").alias("rs") - - s = select( - [regional_sales.c.region]).where( + orders = table("orders", column("region"), column("amount")) + + regional_sales = ( + select([orders.c.region, orders.c.amount]) + .cte("regional_sales") + .alias("rs") + ) + + 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 rs.region " - "FROM regional_sales AS rs WHERE " - "rs.amount > :amount_1") + self.assert_compile( + s, + "WITH regional_sales AS " + "(SELECT orders.region AS region, " + "orders.amount AS amount FROM orders) " + "SELECT rs.region " + "FROM regional_sales AS rs WHERE " + "rs.amount > :amount_1", + ) s = s.union_all( - select([regional_sales.c.region]). - where( + 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 rs.region FROM regional_sales AS rs " - "WHERE rs.amount > :amount_1 " - "UNION ALL SELECT rs.region " - "FROM regional_sales AS rs WHERE " - "rs.amount < :amount_2") + self.assert_compile( + s, + "WITH regional_sales AS " + "(SELECT orders.region AS region, " + "orders.amount AS amount FROM orders) " + "SELECT rs.region FROM regional_sales AS rs " + "WHERE rs.amount > :amount_1 " + "UNION ALL SELECT rs.region " + "FROM regional_sales AS rs WHERE " + "rs.amount < :amount_2", + ) cloned = cloned_traverse(s, {}, {}) - self.assert_compile(cloned, - "WITH regional_sales AS " - "(SELECT orders.region AS region, " - "orders.amount AS amount FROM orders) " - "SELECT rs.region FROM regional_sales AS rs " - "WHERE rs.amount > :amount_1 " - "UNION ALL SELECT rs.region " - "FROM regional_sales AS rs WHERE " - "rs.amount < :amount_2") + self.assert_compile( + cloned, + "WITH regional_sales AS " + "(SELECT orders.region AS region, " + "orders.amount AS amount FROM orders) " + "SELECT rs.region FROM regional_sales AS rs " + "WHERE rs.amount > :amount_1 " + "UNION ALL SELECT rs.region " + "FROM regional_sales AS rs WHERE " + "rs.amount < :amount_2", + ) def test_cloned_alias(self): entity = table( - 'entity', column('id'), column('employer_id'), column('name')) - tag = table('tag', column('tag'), column('entity_id')) + "entity", column("id"), column("employer_id"), column("name") + ) + tag = table("tag", column("tag"), column("entity_id")) - tags = select([ - tag.c.entity_id, - func.array_agg(tag.c.tag).label('tags'), - ]).group_by(tag.c.entity_id).cte('unaliased_tags') + tags = ( + select([tag.c.entity_id, func.array_agg(tag.c.tag).label("tags")]) + .group_by(tag.c.entity_id) + .cte("unaliased_tags") + ) - entity_tags = tags.alias(name='entity_tags') - employer_tags = tags.alias(name='employer_tags') + entity_tags = tags.alias(name="entity_tags") + employer_tags = tags.alias(name="employer_tags") q = ( select([entity.c.name]) .select_from( - entity - .outerjoin(entity_tags, tags.c.entity_id == entity.c.id) - .outerjoin(employer_tags, - tags.c.entity_id == entity.c.employer_id) + entity.outerjoin( + entity_tags, tags.c.entity_id == entity.c.id + ).outerjoin( + employer_tags, tags.c.entity_id == entity.c.employer_id + ) ) - .where(entity_tags.c.tags.op('@>')(bindparam('tags'))) - .where(employer_tags.c.tags.op('@>')(bindparam('tags'))) + .where(entity_tags.c.tags.op("@>")(bindparam("tags"))) + .where(employer_tags.c.tags.op("@>")(bindparam("tags"))) ) self.assert_compile( q, - 'WITH unaliased_tags AS ' - '(SELECT tag.entity_id AS entity_id, array_agg(tag.tag) AS tags ' - 'FROM tag GROUP BY tag.entity_id)' - ' SELECT entity.name ' - 'FROM entity ' - 'LEFT OUTER JOIN unaliased_tags AS entity_tags ON ' - 'unaliased_tags.entity_id = entity.id ' - 'LEFT OUTER JOIN unaliased_tags AS employer_tags ON ' - 'unaliased_tags.entity_id = entity.employer_id ' - 'WHERE (entity_tags.tags @> :tags) AND ' - '(employer_tags.tags @> :tags)' - ) - - cloned = q.params(tags=['tag1', 'tag2']) + "WITH unaliased_tags AS " + "(SELECT tag.entity_id AS entity_id, array_agg(tag.tag) AS tags " + "FROM tag GROUP BY tag.entity_id)" + " SELECT entity.name " + "FROM entity " + "LEFT OUTER JOIN unaliased_tags AS entity_tags ON " + "unaliased_tags.entity_id = entity.id " + "LEFT OUTER JOIN unaliased_tags AS employer_tags ON " + "unaliased_tags.entity_id = entity.employer_id " + "WHERE (entity_tags.tags @> :tags) AND " + "(employer_tags.tags @> :tags)", + ) + + cloned = q.params(tags=["tag1", "tag2"]) self.assert_compile( cloned, - 'WITH unaliased_tags AS ' - '(SELECT tag.entity_id AS entity_id, array_agg(tag.tag) AS tags ' - 'FROM tag GROUP BY tag.entity_id)' - ' SELECT entity.name ' - 'FROM entity ' - 'LEFT OUTER JOIN unaliased_tags AS entity_tags ON ' - 'unaliased_tags.entity_id = entity.id ' - 'LEFT OUTER JOIN unaliased_tags AS employer_tags ON ' - 'unaliased_tags.entity_id = entity.employer_id ' - 'WHERE (entity_tags.tags @> :tags) AND ' - '(employer_tags.tags @> :tags)') + "WITH unaliased_tags AS " + "(SELECT tag.entity_id AS entity_id, array_agg(tag.tag) AS tags " + "FROM tag GROUP BY tag.entity_id)" + " SELECT entity.name " + "FROM entity " + "LEFT OUTER JOIN unaliased_tags AS entity_tags ON " + "unaliased_tags.entity_id = entity.id " + "LEFT OUTER JOIN unaliased_tags AS employer_tags ON " + "unaliased_tags.entity_id = entity.employer_id " + "WHERE (entity_tags.tags @> :tags) AND " + "(employer_tags.tags @> :tags)", + ) def test_reserved_quote(self): - orders = table('orders', - column('order'), - ) + orders = table("orders", 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" - ) + self.assert_compile( + s, + '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') + cte = select([literal(1).label("id")]).cte(name="CTE") s1 = select([cte.c.id]).alias() s2 = select([cte.c.id]).alias() @@ -573,13 +629,13 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( s, 'WITH "CTE" AS (SELECT :param_1 AS id) ' - 'SELECT anon_1.id, anon_2.id FROM ' + "SELECT anon_1.id, anon_2.id FROM " '(SELECT "CTE".id AS id FROM "CTE") AS anon_1, ' - '(SELECT "CTE".id AS id FROM "CTE") AS anon_2' + '(SELECT "CTE".id AS id FROM "CTE") AS anon_2', ) def test_multi_subq_alias(self): - cte = select([literal(1).label("id")]).cte(name='cte1').alias("aa") + cte = select([literal(1).label("id")]).cte(name="cte1").alias("aa") s1 = select([cte.c.id]).alias() s2 = select([cte.c.id]).alias() @@ -590,37 +646,33 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "WITH cte1 AS (SELECT :param_1 AS id) " "SELECT anon_1.id, anon_2.id FROM " "(SELECT aa.id AS id FROM cte1 AS aa) AS anon_1, " - "(SELECT aa.id AS id FROM cte1 AS aa) AS anon_2" + "(SELECT aa.id AS id FROM cte1 AS aa) AS anon_2", ) def test_cte_refers_to_aliased_cte_twice(self): # test issue #4204 - a = table('a', column('id')) - b = table('b', column('id'), column('fid')) - c = table('c', column('id'), column('fid')) + a = table("a", column("id")) + b = table("b", column("id"), column("fid")) + c = table("c", column("id"), column("fid")) - cte1 = ( - select([a.c.id]) - .cte(name='cte1') - ) + cte1 = select([a.c.id]).cte(name="cte1") - aa = cte1.alias('aa') + aa = cte1.alias("aa") cte2 = ( select([b.c.id]) .select_from(b.join(aa, b.c.fid == aa.c.id)) - .cte(name='cte2') + .cte(name="cte2") ) cte3 = ( select([c.c.id]) .select_from(c.join(aa, c.c.fid == aa.c.id)) - .cte(name='cte3') + .cte(name="cte3") ) - stmt = ( - select([cte3.c.id, cte2.c.id]) - .select_from(cte2.join(cte3, cte2.c.id == cte3.c.id)) + stmt = select([cte3.c.id, cte2.c.id]).select_from( + cte2.join(cte3, cte2.c.id == cte3.c.id) ) self.assert_compile( stmt, @@ -629,11 +681,11 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "JOIN cte1 AS aa ON b.fid = aa.id), " "cte3 AS (SELECT c.id AS id FROM c " "JOIN cte1 AS aa ON c.fid = aa.id) " - "SELECT cte3.id, cte2.id FROM cte2 JOIN cte3 ON cte2.id = cte3.id" + "SELECT cte3.id, cte2.id FROM cte2 JOIN cte3 ON cte2.id = cte3.id", ) def test_named_alias_no_quote(self): - cte = select([literal(1).label("id")]).cte(name='CTE') + cte = select([literal(1).label("id")]).cte(name="CTE") s1 = select([cte.c.id]).alias(name="no_quotes") @@ -641,12 +693,12 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( s, 'WITH "CTE" AS (SELECT :param_1 AS id) ' - 'SELECT no_quotes.id FROM ' - '(SELECT "CTE".id AS id FROM "CTE") AS no_quotes' + "SELECT no_quotes.id FROM " + '(SELECT "CTE".id AS id FROM "CTE") AS no_quotes', ) def test_named_alias_quote(self): - cte = select([literal(1).label("id")]).cte(name='CTE') + cte = select([literal(1).label("id")]).cte(name="CTE") s1 = select([cte.c.id]).alias(name="Quotes Required") @@ -655,79 +707,96 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): s, 'WITH "CTE" AS (SELECT :param_1 AS id) ' 'SELECT "Quotes Required".id FROM ' - '(SELECT "CTE".id AS id FROM "CTE") AS "Quotes Required"' + '(SELECT "CTE".id AS id FROM "CTE") AS "Quotes Required"', ) def test_named_alias_disable_quote(self): cte = select([literal(1).label("id")]).cte( - name=quoted_name('CTE', quote=False)) + name=quoted_name("CTE", quote=False) + ) s1 = select([cte.c.id]).alias( - name=quoted_name("DontQuote", quote=False)) + name=quoted_name("DontQuote", quote=False) + ) s = select([s1]) self.assert_compile( s, - 'WITH CTE AS (SELECT :param_1 AS id) ' - 'SELECT DontQuote.id FROM ' - '(SELECT CTE.id AS id FROM CTE) AS DontQuote' + "WITH CTE AS (SELECT :param_1 AS id) " + "SELECT DontQuote.id FROM " + "(SELECT CTE.id AS id FROM CTE) AS DontQuote", ) def test_positional_binds(self): - orders = table('orders', - column('order'), - ) + orders = table("orders", 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' + dialect.paramstyle = "numeric" 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" ' + 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([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 ' + 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'), - ) + orders = table("orders", 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") + dialect.paramstyle = "numeric" + s1 = ( + select([orders.c.order]) + .where(orders.c.order == "x") + .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") + s2 = ( + select( + [ + orders.c.order == "y", + s1a.c.order, + orders.c.order, + s1.c.order, + ] + ) + .where(orders.c.order == "z") + .cte("regional_sales_2") + ) s3 = select([s2]) @@ -739,52 +808,65 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'anon_2."order" AS "order", ' 'orders."order" AS "order", ' 'regional_sales_1."order" AS "order" FROM orders, ' - 'regional_sales_1 ' - 'AS anon_2, regional_sales_1 ' + "regional_sales_1 " + "AS anon_2, regional_sales_1 " 'WHERE orders."order" = :3) SELECT regional_sales_2.anon_1, ' 'regional_sales_2."order" FROM regional_sales_2', - checkpositional=('x', 'y', 'z'), dialect=dialect) + checkpositional=("x", "y", "z"), + dialect=dialect, + ) def test_positional_binds_2_asliteral(self): - orders = table('orders', - column('order'), - ) + orders = table("orders", 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") + dialect.paramstyle = "numeric" + s1 = ( + select([orders.c.order]) + .where(orders.c.order == "x") + .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") + s2 = ( + select( + [ + orders.c.order == "y", + s1a.c.order, + orders.c.order, + s1.c.order, + ] + ) + .where(orders.c.order == "z") + .cte("regional_sales_2") + ) s3 = select([s2]) self.assert_compile( s3, - 'WITH regional_sales_1 AS ' + "WITH regional_sales_1 AS " '(SELECT orders."order" AS "order" ' - 'FROM orders ' - 'WHERE orders."order" = \'x\'), ' - 'regional_sales_2 AS ' - '(SELECT orders."order" = \'y\' AS anon_1, ' + "FROM orders " + "WHERE orders.\"order\" = 'x'), " + "regional_sales_2 AS " + "(SELECT orders.\"order\" = 'y' AS anon_1, " 'anon_2."order" AS "order", orders."order" AS "order", ' 'regional_sales_1."order" AS "order" ' - 'FROM orders, regional_sales_1 AS anon_2, regional_sales_1 ' - 'WHERE orders."order" = \'z\') ' + "FROM orders, regional_sales_1 AS anon_2, regional_sales_1 " + "WHERE orders.\"order\" = 'z') " 'SELECT regional_sales_2.anon_1, regional_sales_2."order" ' - 'FROM regional_sales_2', - checkpositional=(), dialect=dialect, - literal_binds=True) + "FROM regional_sales_2", + checkpositional=(), + dialect=dialect, + literal_binds=True, + ) def test_all_aliases(self): - orders = table('order', column('order')) + orders = table("order", column("order")) s = select([orders.c.order]).cte("regional_sales") r1 = s.alias() @@ -797,38 +879,36 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'WITH regional_sales AS (SELECT "order"."order" ' 'AS "order" FROM "order") ' 'SELECT anon_1."order", anon_2."order" ' - 'FROM regional_sales AS anon_1, ' - 'regional_sales AS anon_2 WHERE anon_1."order" > anon_2."order"' + "FROM regional_sales AS anon_1, " + '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, - 'WITH regional_sales AS ' + "WITH regional_sales AS " '(SELECT "order"."order" AS "order" ' 'FROM "order")' ' SELECT "order"."order" ' 'FROM "order" JOIN regional_sales AS anon_1 ' - 'ON anon_1."order" = "order"."order"' + 'ON anon_1."order" = "order"."order"', ) def test_suffixes(self): - orders = table('order', column('order')) + orders = table("order", column("order")) s = select([orders.c.order]).cte("regional_sales") - s = s.suffix_with("pg suffix", dialect='postgresql') - s = s.suffix_with('oracle suffix', dialect='oracle') + s = s.suffix_with("pg suffix", dialect="postgresql") + s = s.suffix_with("oracle suffix", dialect="oracle") stmt = select([orders]).where(orders.c.order > s.c.order) self.assert_compile( stmt, 'WITH regional_sales AS (SELECT "order"."order" AS "order" ' 'FROM "order") SELECT "order"."order" FROM "order", ' - 'regional_sales WHERE "order"."order" > regional_sales."order"' + 'regional_sales WHERE "order"."order" > regional_sales."order"', ) self.assert_compile( @@ -837,7 +917,7 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'FROM "order") oracle suffix ' 'SELECT "order"."order" FROM "order", ' 'regional_sales WHERE "order"."order" > regional_sales."order"', - dialect='oracle' + dialect="oracle", ) self.assert_compile( @@ -845,30 +925,36 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): 'WITH regional_sales AS (SELECT "order"."order" AS "order" ' 'FROM "order") pg suffix SELECT "order"."order" FROM "order", ' 'regional_sales WHERE "order"."order" > regional_sales."order"', - dialect='postgresql' + dialect="postgresql", ) def test_upsert_from_select(self): orders = table( - 'orders', - column('region'), - column('amount'), - column('product'), - column('quantity') + "orders", + column("region"), + column("amount"), + column("product"), + column("quantity"), ) upsert = ( orders.update() - .where(orders.c.region == 'Region1') - .values(amount=1.0, product='Product1', quantity=1) - .returning(*(orders.c._all_columns)).cte('upsert')) + .where(orders.c.region == "Region1") + .values(amount=1.0, product="Product1", quantity=1) + .returning(*(orders.c._all_columns)) + .cte("upsert") + ) insert = orders.insert().from_select( orders.c.keys(), - select([ - literal('Region1'), literal(1.0), - literal('Product1'), literal(1) - ]).where(~exists(upsert.select())) + select( + [ + literal("Region1"), + literal(1.0), + literal("Product1"), + literal(1), + ] + ).where(~exists(upsert.select())), ) self.assert_compile( @@ -882,52 +968,55 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "SELECT :param_1 AS anon_1, :param_2 AS anon_2, " ":param_3 AS anon_3, :param_4 AS anon_4 WHERE NOT (EXISTS " "(SELECT upsert.region, upsert.amount, upsert.product, " - "upsert.quantity FROM upsert))" + "upsert.quantity FROM upsert))", ) def test_anon_update_cte(self): - orders = table( - 'orders', - column('region') + orders = table("orders", column("region")) + stmt = ( + orders.update() + .where(orders.c.region == "x") + .values(region="y") + .returning(orders.c.region) + .cte() ) - stmt = orders.update().where(orders.c.region == 'x').\ - values(region='y').\ - returning(orders.c.region).cte() self.assert_compile( stmt.select(), "WITH anon_1 AS (UPDATE orders SET region=:region " "WHERE orders.region = :region_1 RETURNING orders.region) " - "SELECT anon_1.region FROM anon_1" + "SELECT anon_1.region FROM anon_1", ) def test_anon_insert_cte(self): - orders = table( - 'orders', - column('region') + orders = table("orders", column("region")) + stmt = ( + orders.insert().values(region="y").returning(orders.c.region).cte() ) - stmt = orders.insert().\ - values(region='y').\ - returning(orders.c.region).cte() self.assert_compile( stmt.select(), "WITH anon_1 AS (INSERT INTO orders (region) " "VALUES (:region) RETURNING orders.region) " - "SELECT anon_1.region FROM anon_1" + "SELECT anon_1.region FROM anon_1", ) def test_pg_example_one(self): - products = table('products', column('id'), column('date')) - products_log = table('products_log', column('id'), column('date')) + products = table("products", column("id"), column("date")) + products_log = table("products_log", column("id"), column("date")) - moved_rows = products.delete().where(and_( - products.c.date >= 'dateone', - products.c.date < 'datetwo')).returning(*products.c).\ - cte('moved_rows') + moved_rows = ( + products.delete() + .where( + and_(products.c.date >= "dateone", products.c.date < "datetwo") + ) + .returning(*products.c) + .cte("moved_rows") + ) stmt = products_log.insert().from_select( - products_log.c, moved_rows.select()) + products_log.c, moved_rows.select() + ) self.assert_compile( stmt, "WITH moved_rows AS " @@ -935,17 +1024,21 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "AND products.date < :date_2 " "RETURNING products.id, products.date) " "INSERT INTO products_log (id, date) " - "SELECT moved_rows.id, moved_rows.date FROM moved_rows" + "SELECT moved_rows.id, moved_rows.date FROM moved_rows", ) def test_pg_example_two(self): - products = table('products', column('id'), column('price')) + products = table("products", column("id"), column("price")) - t = products.update().values(price='someprice').\ - returning(*products.c).cte('t') + t = ( + products.update() + .values(price="someprice") + .returning(*products.c) + .cte("t") + ) stmt = t.select() - assert 'autocommit' not in stmt._execution_options - eq_(stmt.compile().execution_options['autocommit'], True) + assert "autocommit" not in stmt._execution_options + eq_(stmt.compile().execution_options["autocommit"], True) self.assert_compile( stmt, @@ -953,34 +1046,29 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "(UPDATE products SET price=:price " "RETURNING products.id, products.price) " "SELECT t.id, t.price " - "FROM t" + "FROM t", ) def test_pg_example_three(self): - parts = table( - 'parts', - column('part'), - column('sub_part'), - ) + parts = table("parts", column("part"), column("sub_part")) - included_parts = select([ - parts.c.sub_part, - parts.c.part]).\ - where(parts.c.part == 'our part').\ - cte("included_parts", recursive=True) + included_parts = ( + select([parts.c.sub_part, parts.c.part]) + .where(parts.c.part == "our part") + .cte("included_parts", recursive=True) + ) - pr = included_parts.alias('pr') - p = parts.alias('p') + pr = included_parts.alias("pr") + p = parts.alias("p") included_parts = included_parts.union_all( - select([ - p.c.sub_part, - p.c.part]). - where(p.c.part == pr.c.sub_part) + select([p.c.sub_part, p.c.part]).where(p.c.part == pr.c.sub_part) + ) + stmt = ( + parts.delete() + .where(parts.c.part.in_(select([included_parts.c.part]))) + .returning(parts.c.part) ) - stmt = parts.delete().where( - parts.c.part.in_(select([included_parts.c.part]))).returning( - parts.c.part) # the outer RETURNING is a bonus over what PG's docs have self.assert_compile( @@ -994,19 +1082,23 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "WHERE p.part = pr.sub_part) " "DELETE FROM parts WHERE parts.part IN " "(SELECT included_parts.part FROM included_parts) " - "RETURNING parts.part" + "RETURNING parts.part", ) def test_insert_in_the_cte(self): - products = table('products', column('id'), column('price')) + products = table("products", column("id"), column("price")) - cte = products.insert().values(id=1, price=27.0).\ - returning(*products.c).cte('pd') + cte = ( + products.insert() + .values(id=1, price=27.0) + .returning(*products.c) + .cte("pd") + ) stmt = select([cte]) - assert 'autocommit' not in stmt._execution_options - eq_(stmt.compile().execution_options['autocommit'], True) + assert "autocommit" not in stmt._execution_options + eq_(stmt.compile().execution_options["autocommit"], True) self.assert_compile( stmt, @@ -1014,17 +1106,17 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "(INSERT INTO products (id, price) VALUES (:id, :price) " "RETURNING products.id, products.price) " "SELECT pd.id, pd.price " - "FROM pd" + "FROM pd", ) def test_update_pulls_from_cte(self): - products = table('products', column('id'), column('price')) + products = table("products", column("id"), column("price")) - cte = products.select().cte('pd') - assert 'autocommit' not in cte._execution_options + cte = products.select().cte("pd") + assert "autocommit" not in cte._execution_options stmt = products.update().where(products.c.price == cte.c.price) - eq_(stmt.compile().execution_options['autocommit'], True) + eq_(stmt.compile().execution_options["autocommit"], True) self.assert_compile( stmt, @@ -1032,5 +1124,5 @@ class CTETest(fixtures.TestBase, AssertsCompiledSQL): "(SELECT products.id AS id, products.price AS price " "FROM products) " "UPDATE products SET id=:id, price=:price FROM pd " - "WHERE products.price = pd.price" + "WHERE products.price = pd.price", ) diff --git a/test/sql/test_ddlemit.py b/test/sql/test_ddlemit.py index 25f9c595f..6c949f9ee 100644 --- a/test/sql/test_ddlemit.py +++ b/test/sql/test_ddlemit.py @@ -6,54 +6,65 @@ 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) - return Mock(dialect=Mock( - supports_sequences=True, - has_table=Mock(side_effect=has_item), - has_sequence=Mock(side_effect=has_item), - supports_comments=True, - inline_comments=False, - ) - ) - - def _mock_create_fixture(self, checkfirst, tables, - item_exists=lambda item: False): + return Mock( + dialect=Mock( + supports_sequences=True, + has_table=Mock(side_effect=has_item), + has_sequence=Mock(side_effect=has_item), + supports_comments=True, + inline_comments=False, + ) + ) + + def _mock_create_fixture( + self, checkfirst, tables, item_exists=lambda item: False + ): connection = self._mock_connection(item_exists) - return SchemaGenerator(connection.dialect, connection, - checkfirst=checkfirst, - tables=tables) + return SchemaGenerator( + connection.dialect, + connection, + checkfirst=checkfirst, + tables=tables, + ) - def _mock_drop_fixture(self, checkfirst, tables, - item_exists=lambda item: True): + def _mock_drop_fixture( + self, checkfirst, tables, item_exists=lambda item: True + ): connection = self._mock_connection(item_exists) - return SchemaDropper(connection.dialect, connection, - checkfirst=checkfirst, - tables=tables) + return SchemaDropper( + connection.dialect, + connection, + 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) + return (m,) + tuple( + Table("t%d" % i, m, Column("x", Integer)) for i in range(1, 6) ) def _use_alter_fixture_one(self): m = MetaData() t1 = Table( - 't1', m, Column('id', Integer, primary_key=True), - Column('t2id', Integer, ForeignKey('t2.id')) + "t1", + m, + Column("id", Integer, primary_key=True), + Column("t2id", Integer, ForeignKey("t2.id")), ) t2 = Table( - 't2', m, Column('id', Integer, primary_key=True), - Column('t1id', Integer, ForeignKey('t1.id')) + "t2", + m, + Column("id", Integer, primary_key=True), + Column("t1id", Integer, ForeignKey("t1.id")), ) return m, t1, t2 @@ -61,33 +72,30 @@ class EmitDDLTest(fixtures.TestBase): m = MetaData() t1 = Table( - 't1', m, Column('id', Integer, primary_key=True), - Column('t2id', Integer, ForeignKey('t2.id')) - ) - t2 = Table( - 't2', m, Column('id', Integer, primary_key=True), + "t1", + m, + Column("id", Integer, primary_key=True), + Column("t2id", Integer, ForeignKey("t2.id")), ) + t2 = Table("t2", m, Column("id", Integer, primary_key=True)) return m, t1, t2 def _table_seq_fixture(self): m = MetaData() - s1 = Sequence('s1') - s2 = Sequence('s2') - t1 = Table('t1', m, Column("x", Integer, s1, primary_key=True)) - t2 = Table('t2', m, Column("x", Integer, s2, primary_key=True)) + s1 = Sequence("s1") + s2 = Sequence("s2") + t1 = Table("t1", m, Column("x", Integer, s1, primary_key=True)) + t2 = Table("t2", m, Column("x", Integer, s2, primary_key=True)) return m, t1, t2, s1, s2 def _table_comment_fixture(self): m = MetaData() - c1 = Column('id', Integer, comment='c1') + c1 = Column("id", Integer, comment="c1") - t1 = Table( - 't1', m, c1, - comment='t1' - ) + t1 = Table("t1", m, c1, comment="t1") return m, t1, c1 @@ -95,154 +103,127 @@ class EmitDDLTest(fixtures.TestBase): m, t1, c1 = self._table_comment_fixture() generator = self._mock_create_fixture( - False, [t1], item_exists=lambda t: t not in ("t1",)) + False, [t1], item_exists=lambda t: t not in ("t1",) + ) self._assert_create_comment([t1, t1, c1], generator, m) 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + 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")) + False, None, item_exists=lambda t: t in ("t2", "t4") + ) self._assert_drop_tables([t1, t2, t3, t4, t5], generator, m) def test_create_metadata_auto_alter_fk(self): m, t1, t2 = self._use_alter_fixture_one() - generator = self._mock_create_fixture( - False, [t1, t2] - ) + generator = self._mock_create_fixture(False, [t1, t2]) self._assert_create_w_alter( - [t1, t2] + - list(t1.foreign_key_constraints) + - list(t2.foreign_key_constraints), + [t1, t2] + + list(t1.foreign_key_constraints) + + list(t2.foreign_key_constraints), generator, - m + m, ) def test_create_metadata_inline_fk(self): m, t1, t2 = self._fk_fixture_one() - generator = self._mock_create_fixture( - False, [t1, t2] - ) + generator = self._mock_create_fixture(False, [t1, t2]) self._assert_create_w_alter( - [t1, t2] + - list(t1.foreign_key_constraints) + - list(t2.foreign_key_constraints), + [t1, t2] + + list(t1.foreign_key_constraints) + + list(t2.foreign_key_constraints), generator, - m + m, ) def _assert_create_tables(self, elements, generator, argument): @@ -254,38 +235,60 @@ class EmitDDLTest(fixtures.TestBase): def _assert_create(self, elements, generator, argument): self._assert_ddl( (schema.CreateTable, schema.CreateSequence), - elements, generator, argument) + elements, + generator, + argument, + ) def _assert_drop(self, elements, generator, argument): self._assert_ddl( (schema.DropTable, schema.DropSequence), - elements, generator, argument) + elements, + generator, + argument, + ) def _assert_create_w_alter(self, elements, generator, argument): self._assert_ddl( (schema.CreateTable, schema.CreateSequence, schema.AddConstraint), - elements, generator, argument) + elements, + generator, + argument, + ) def _assert_drop_w_alter(self, elements, generator, argument): self._assert_ddl( (schema.DropTable, schema.DropSequence, schema.DropConstraint), - elements, generator, argument) + elements, + generator, + argument, + ) def _assert_create_comment(self, elements, generator, argument): self._assert_ddl( - (schema.CreateTable, schema.SetTableComment, schema.SetColumnComment), - elements, generator, argument) + ( + schema.CreateTable, + schema.SetTableComment, + schema.SetColumnComment, + ), + elements, + generator, + argument, + ) def _assert_ddl(self, ddl_cls, elements, generator, argument): generator.traverse_single(argument) for call_ in generator.connection.execute.mock_calls: c = call_[1][0] assert isinstance(c, ddl_cls) - assert c.element in elements, "element %r was not expected"\ - % c.element + assert c.element in elements, ( + "element %r was not expected" % c.element + ) elements.remove(c.element) - if getattr(c, 'include_foreign_key_constraints', None) is not None: + if getattr(c, "include_foreign_key_constraints", None) is not None: elements[:] = [ - e for e in elements - if e not in set(c.include_foreign_key_constraints)] + e + for e in elements + if e not in set(c.include_foreign_key_constraints) + ] assert not elements, "elements remain in list: %r" % elements diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py index c5efdf132..b518a606f 100644 --- a/test/sql/test_defaults.py +++ b/test/sql/test_defaults.py @@ -1,5 +1,10 @@ -from sqlalchemy.testing import eq_, assert_raises_message, \ - assert_raises, AssertsCompiledSQL, expect_warnings +from sqlalchemy.testing import ( + eq_, + assert_raises_message, + assert_raises, + AssertsCompiledSQL, + expect_warnings, +) import datetime from sqlalchemy.schema import CreateSequence, DropSequence, CreateTable from sqlalchemy.sql import select, text, literal_column @@ -7,8 +12,19 @@ import sqlalchemy as sa from sqlalchemy import testing from sqlalchemy.testing import engines from sqlalchemy import ( - MetaData, Integer, String, ForeignKey, Boolean, exc, Sequence, func, - literal, Unicode, cast, DateTime) + MetaData, + Integer, + String, + ForeignKey, + Boolean, + exc, + Sequence, + func, + literal, + Unicode, + cast, + DateTime, +) from sqlalchemy.types import TypeDecorator, TypeEngine from sqlalchemy.testing.schema import Table, Column from sqlalchemy.dialects import sqlite @@ -23,96 +39,100 @@ t = f = f2 = ts = currenttime = metadata = default_generator = None class DDLTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_string(self): # note: that the datatype is an Integer here doesn't matter, # the server_default is interpreted independently of the # column's datatype. m = MetaData() - t = Table('t', m, Column('x', Integer, server_default='5')) + t = Table("t", m, Column("x", Integer, server_default="5")) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT '5')" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT '5')" ) def test_string_w_quotes(self): m = MetaData() - t = Table('t', m, Column('x', Integer, server_default="5'6")) + t = Table("t", m, Column("x", Integer, server_default="5'6")) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT '5''6')" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT '5''6')" ) def test_text(self): m = MetaData() - t = Table('t', m, Column('x', Integer, server_default=text('5 + 8'))) + t = Table("t", m, Column("x", Integer, server_default=text("5 + 8"))) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT 5 + 8)" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT 5 + 8)" ) def test_text_w_quotes(self): m = MetaData() - t = Table('t', m, Column('x', Integer, server_default=text("5 ' 8"))) + t = Table("t", m, Column("x", Integer, server_default=text("5 ' 8"))) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT 5 ' 8)" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT 5 ' 8)" ) def test_literal_binds_w_quotes(self): m = MetaData() - t = Table('t', m, Column('x', Integer, - server_default=literal("5 ' 8"))) + t = Table( + "t", m, Column("x", Integer, server_default=literal("5 ' 8")) + ) self.assert_compile( - CreateTable(t), - """CREATE TABLE t (x INTEGER DEFAULT '5 '' 8')""" + CreateTable(t), """CREATE TABLE t (x INTEGER DEFAULT '5 '' 8')""" ) def test_text_literal_binds(self): m = MetaData() t = Table( - 't', m, + "t", + m, Column( - 'x', Integer, server_default=text('q + :x1').bindparams(x1=7))) + "x", Integer, server_default=text("q + :x1").bindparams(x1=7) + ), + ) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT q + 7)" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT q + 7)" ) def test_sqlexpr(self): m = MetaData() - t = Table('t', m, Column( - 'x', Integer, - server_default=literal_column('a') + literal_column('b')) + t = Table( + "t", + m, + Column( + "x", + Integer, + server_default=literal_column("a") + literal_column("b"), + ), ) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT a + b)" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT a + b)" ) def test_literal_binds_plain(self): m = MetaData() - t = Table('t', m, Column( - 'x', Integer, - server_default=literal('a') + literal('b')) + t = Table( + "t", + m, + Column("x", Integer, server_default=literal("a") + literal("b")), ) self.assert_compile( - CreateTable(t), - "CREATE TABLE t (x INTEGER DEFAULT 'a' || 'b')" + CreateTable(t), "CREATE TABLE t (x INTEGER DEFAULT 'a' || 'b')" ) def test_literal_binds_pgarray(self): from sqlalchemy.dialects.postgresql import ARRAY, array + m = MetaData() - t = Table('t', m, Column( - 'x', ARRAY(Integer), - server_default=array([1, 2, 3])) + t = Table( + "t", + m, + Column("x", ARRAY(Integer), server_default=array([1, 2, 3])), ) self.assert_compile( CreateTable(t), "CREATE TABLE t (x INTEGER[] DEFAULT ARRAY[1, 2, 3])", - dialect='postgresql' + dialect="postgresql", ) @@ -125,30 +145,29 @@ class DefaultTest(fixtures.TestBase): db = testing.db metadata = MetaData(db) - default_generator = {'x': 50} + default_generator = {"x": 50} def mydefault(): - default_generator['x'] += 1 - return default_generator['x'] + default_generator["x"] += 1 + return default_generator["x"] def myupdate_with_ctx(ctx): conn = ctx.connection - return conn.execute(sa.select([sa.text('13')])).scalar() + return conn.execute(sa.select([sa.text("13")])).scalar() def mydefault_using_connection(ctx): conn = ctx.connection try: - return conn.execute(sa.select([sa.text('12')])).scalar() + return conn.execute(sa.select([sa.text("12")])).scalar() finally: # ensure a "close()" on this connection does nothing, # since its a "branched" connection conn.close() - use_function_defaults = testing.against('postgresql', 'mssql') - is_oracle = testing.against('oracle') + use_function_defaults = testing.against("postgresql", "mssql") + is_oracle = testing.against("oracle") class MyClass(object): - @classmethod def gen_default(cls, ctx): return "hi" @@ -172,89 +191,92 @@ class DefaultTest(fixtures.TestBase): func.trunc( func.current_timestamp(), sa.literal_column("'DAY'"), - type_=sa.Date)])) + type_=sa.Date, + ) + ] + ) + ) assert isinstance(ts, datetime.date) and not isinstance( - ts, datetime.datetime) - f = sa.select([func.length('abcdef')], bind=db).scalar() - f2 = sa.select([func.length('abcdefghijk')], bind=db).scalar() + ts, datetime.datetime + ) + f = sa.select([func.length("abcdef")], bind=db).scalar() + f2 = sa.select([func.length("abcdefghijk")], bind=db).scalar() # TODO: engine propigation across nested functions not working currenttime = func.trunc( - currenttime, sa.literal_column("'DAY'"), bind=db, - type_=sa.Date) + currenttime, sa.literal_column("'DAY'"), bind=db, type_=sa.Date + ) def1 = currenttime def2 = func.trunc( sa.text("current_timestamp"), - sa.literal_column("'DAY'"), type_=sa.Date) + sa.literal_column("'DAY'"), + type_=sa.Date, + ) deftype = sa.Date elif use_function_defaults: - f = sa.select([func.length('abcdef')], bind=db).scalar() - f2 = sa.select([func.length('abcdefghijk')], bind=db).scalar() + f = sa.select([func.length("abcdef")], bind=db).scalar() + f2 = sa.select([func.length("abcdefghijk")], bind=db).scalar() def1 = currenttime deftype = sa.Date - if testing.against('mssql'): + if testing.against("mssql"): def2 = sa.text("getdate()") else: def2 = sa.text("current_date") ts = db.scalar(func.current_date()) else: - f = len('abcdef') - f2 = len('abcdefghijk') + f = len("abcdef") + f2 = len("abcdefghijk") def1 = def2 = "3" ts = 3 deftype = Integer t = Table( - 'default_test1', metadata, + "default_test1", + metadata, # python function - Column('col1', Integer, primary_key=True, - default=mydefault), - + Column("col1", Integer, primary_key=True, default=mydefault), # python literal - Column('col2', String(20), - default="imthedefault", - onupdate="im the update"), - + Column( + "col2", + String(20), + default="imthedefault", + onupdate="im the update", + ), # preexecute expression - Column('col3', Integer, - default=func.length('abcdef'), - onupdate=func.length('abcdefghijk')), - + Column( + "col3", + Integer, + default=func.length("abcdef"), + onupdate=func.length("abcdefghijk"), + ), # SQL-side default from sql expression - Column('col4', deftype, - server_default=def1), - + Column("col4", deftype, server_default=def1), # SQL-side default from literal expression - Column('col5', deftype, - server_default=def2), - + Column("col5", deftype, server_default=def2), # preexecute + update timestamp - Column('col6', sa.Date, - default=currenttime, - onupdate=currenttime), - - Column('boolcol1', sa.Boolean, default=True), - Column('boolcol2', sa.Boolean, default=False), - + Column("col6", sa.Date, default=currenttime, onupdate=currenttime), + Column("boolcol1", sa.Boolean, default=True), + Column("boolcol2", sa.Boolean, default=False), # python function which uses ExecutionContext - Column('col7', Integer, - default=mydefault_using_connection, - onupdate=myupdate_with_ctx), - + Column( + "col7", + Integer, + default=mydefault_using_connection, + onupdate=myupdate_with_ctx, + ), # python builtin - Column('col8', sa.Date, - default=datetime.date.today, - onupdate=datetime.date.today), + Column( + "col8", + sa.Date, + default=datetime.date.today, + onupdate=datetime.date.today, + ), # combo - Column('col9', String(20), - default='py', - server_default='ddl'), - + Column("col9", String(20), default="py", server_default="ddl"), # python method w/ context - Column('col10', String(20), default=MyClass.gen_default), - + Column("col10", String(20), default=MyClass.gen_default), # fixed default w/ type that has bound processor - Column('col11', MyType(), default='foo') + Column("col11", MyType(), default="foo"), ) t.create() @@ -264,12 +286,14 @@ class DefaultTest(fixtures.TestBase): t.drop() def teardown(self): - default_generator['x'] = 50 + default_generator["x"] = 50 t.delete().execute() def test_bad_arg_signature(self): - ex_msg = "ColumnDefault Python function takes zero " \ + ex_msg = ( + "ColumnDefault Python function takes zero " "or one positional arguments" + ) def fn1(x, y): pass @@ -278,22 +302,21 @@ 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() for fn in fn1, fn2, fn3, fn4: assert_raises_message( - sa.exc.ArgumentError, ex_msg, sa.ColumnDefault, fn) + sa.exc.ArgumentError, ex_msg, sa.ColumnDefault, fn + ) def test_arg_signature(self): - def fn1(): pass @@ -305,50 +328,52 @@ class DefaultTest(fixtures.TestBase): def fn4(x=1, y=2, z=3): eq_(x, 1) + 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() for fn in fn1, fn2, fn3, fn4, fn5, fn6a, fn6b, fn7, fn8: c = sa.ColumnDefault(fn) c.arg("context") - @testing.fails_on('firebird', 'Data type unknown') + @testing.fails_on("firebird", "Data type unknown") def test_standalone(self): c = testing.db.engine.contextual_connect() x = c.execute(t.c.col1.default) y = t.c.col2.default.execute() z = c.execute(t.c.col3.default) assert 50 <= x <= 57 - eq_(y, 'imthedefault') + eq_(y, "imthedefault") eq_(z, f) eq_(f2, 11) def test_py_vs_server_default_detection(self): - def has_(name, *wanted): slots = [ - 'default', 'onupdate', 'server_default', 'server_onupdate'] + "default", + "onupdate", + "server_default", + "server_onupdate", + ] col = tbl.c[name] for slot in wanted: slots.remove(slot) @@ -357,94 +382,146 @@ class DefaultTest(fixtures.TestBase): assert getattr(col, slot) is None, getattr(col, slot) tbl = t - has_('col1', 'default') - has_('col2', 'default', 'onupdate') - has_('col3', 'default', 'onupdate') - has_('col4', 'server_default') - has_('col5', 'server_default') - has_('col6', 'default', 'onupdate') - has_('boolcol1', 'default') - has_('boolcol2', 'default') - has_('col7', 'default', 'onupdate') - has_('col8', 'default', 'onupdate') - has_('col9', 'default', 'server_default') + has_("col1", "default") + has_("col2", "default", "onupdate") + has_("col3", "default", "onupdate") + has_("col4", "server_default") + has_("col5", "server_default") + has_("col6", "default", "onupdate") + has_("boolcol1", "default") + has_("boolcol2", "default") + has_("col7", "default", "onupdate") + has_("col8", "default", "onupdate") + has_("col9", "default", "server_default") ColumnDefault, DefaultClause = sa.ColumnDefault, sa.DefaultClause - t2 = Table('t2', MetaData(), - Column('col1', Integer, Sequence('foo')), - Column('col2', Integer, - default=Sequence('foo'), - server_default='y'), - Column('col3', Integer, - Sequence('foo'), - server_default='x'), - Column('col4', Integer, - ColumnDefault('x'), - DefaultClause('y')), - Column('col4', Integer, - ColumnDefault('x'), - DefaultClause('y'), - DefaultClause('y', for_update=True)), - Column('col5', Integer, - ColumnDefault('x'), - DefaultClause('y'), - onupdate='z'), - Column('col6', Integer, - ColumnDefault('x'), - server_default='y', - onupdate='z'), - Column('col7', Integer, - default='x', - server_default='y', - onupdate='z'), - Column('col8', Integer, - server_onupdate='u', - default='x', - server_default='y', - onupdate='z')) + t2 = Table( + "t2", + MetaData(), + Column("col1", Integer, Sequence("foo")), + Column( + "col2", Integer, default=Sequence("foo"), server_default="y" + ), + Column("col3", Integer, Sequence("foo"), server_default="x"), + Column("col4", Integer, ColumnDefault("x"), DefaultClause("y")), + Column( + "col4", + Integer, + ColumnDefault("x"), + DefaultClause("y"), + DefaultClause("y", for_update=True), + ), + Column( + "col5", + Integer, + ColumnDefault("x"), + DefaultClause("y"), + onupdate="z", + ), + Column( + "col6", + Integer, + ColumnDefault("x"), + server_default="y", + onupdate="z", + ), + Column( + "col7", Integer, default="x", server_default="y", onupdate="z" + ), + Column( + "col8", + Integer, + server_onupdate="u", + default="x", + server_default="y", + onupdate="z", + ), + ) tbl = t2 - has_('col1', 'default') - has_('col2', 'default', 'server_default') - has_('col3', 'default', 'server_default') - has_('col4', 'default', 'server_default', 'server_onupdate') - has_('col5', 'default', 'server_default', 'onupdate') - has_('col6', 'default', 'server_default', 'onupdate') - has_('col7', 'default', 'server_default', 'onupdate') + has_("col1", "default") + has_("col2", "default", "server_default") + has_("col3", "default", "server_default") + has_("col4", "default", "server_default", "server_onupdate") + has_("col5", "default", "server_default", "onupdate") + has_("col6", "default", "server_default", "onupdate") + has_("col7", "default", "server_default", "onupdate") has_( - 'col8', 'default', 'server_default', 'onupdate', 'server_onupdate') + "col8", "default", "server_default", "onupdate", "server_onupdate" + ) - @testing.fails_on('firebird', 'Data type unknown') + @testing.fails_on("firebird", "Data type unknown") def test_insert(self): r = t.insert().execute() assert r.lastrow_has_defaults() - eq_(set(r.context.postfetch_cols), - set([t.c.col3, t.c.col5, t.c.col4, t.c.col6])) + eq_( + set(r.context.postfetch_cols), + set([t.c.col3, t.c.col5, t.c.col4, t.c.col6]), + ) r = t.insert(inline=True).execute() assert r.lastrow_has_defaults() - eq_(set(r.context.postfetch_cols), - set([t.c.col3, t.c.col5, t.c.col4, t.c.col6])) + eq_( + set(r.context.postfetch_cols), + set([t.c.col3, t.c.col5, t.c.col4, t.c.col6]), + ) t.insert().execute() ctexec = sa.select( - [currenttime.label('now')], bind=testing.db).scalar() + [currenttime.label("now")], bind=testing.db + ).scalar() result = t.select().order_by(t.c.col1).execute() today = datetime.date.today() - eq_(result.fetchall(), [ - (x, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo') - for x in range(51, 54)]) + eq_( + result.fetchall(), + [ + ( + x, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ) + for x in range(51, 54) + ], + ) t.insert().execute(col9=None) assert r.lastrow_has_defaults() - eq_(set(r.context.postfetch_cols), - set([t.c.col3, t.c.col5, t.c.col4, t.c.col6])) + eq_( + set(r.context.postfetch_cols), + set([t.c.col3, t.c.col5, t.c.col4, t.c.col6]), + ) - eq_(t.select(t.c.col1 == 54).execute().fetchall(), - [(54, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, None, 'hi', 'BINDfoo')]) + eq_( + t.select(t.c.col1 == 54).execute().fetchall(), + [ + ( + 54, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + None, + "hi", + "BINDfoo", + ) + ], + ) def test_insertmany(self): t.insert().execute({}, {}, {}) @@ -452,13 +529,56 @@ class DefaultTest(fixtures.TestBase): ctexec = currenttime.scalar() result = t.select().order_by(t.c.col1).execute() today = datetime.date.today() - eq_(result.fetchall(), - [(51, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo'), - (52, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo'), - (53, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo')]) + eq_( + result.fetchall(), + [ + ( + 51, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 52, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 53, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ], + ) @testing.requires.multivalues_inserts def test_insert_multivalues(self): @@ -468,13 +588,56 @@ class DefaultTest(fixtures.TestBase): ctexec = currenttime.scalar() result = t.select().order_by(t.c.col1).execute() today = datetime.date.today() - eq_(result.fetchall(), - [(51, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo'), - (52, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo'), - (53, 'imthedefault', f, ts, ts, ctexec, True, False, - 12, today, 'py', 'hi', 'BINDfoo')]) + eq_( + result.fetchall(), + [ + ( + 51, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 52, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 53, + "imthedefault", + f, + ts, + ts, + ctexec, + True, + False, + 12, + today, + "py", + "hi", + "BINDfoo", + ), + ], + ) def test_no_embed_in_sql(self): """Using a DefaultGenerator, Sequence, DefaultClause @@ -482,25 +645,28 @@ class DefaultTest(fixtures.TestBase): clause of insert, update, raises an informative error""" for const in ( - sa.Sequence('y'), - sa.ColumnDefault('y'), - sa.DefaultClause('y') + sa.Sequence("y"), + sa.ColumnDefault("y"), + sa.DefaultClause("y"), ): assert_raises_message( sa.exc.ArgumentError, "SQL expression object or string expected, got object of type " "<.* 'list'> instead", - t.select, [const] + t.select, + [const], ) assert_raises_message( sa.exc.InvalidRequestError, "cannot be used directly as a column expression.", - str, t.insert().values(col4=const) + str, + t.insert().values(col4=const), ) assert_raises_message( sa.exc.InvalidRequestError, "cannot be used directly as a column expression.", - str, t.update().values(col4=const) + str, + t.update().values(col4=const), ) def test_missing_many_param(self): @@ -509,45 +675,89 @@ class DefaultTest(fixtures.TestBase): "A value is required for bind parameter 'col7', in parameter " "group 1", t.insert().execute, - {'col4': 7, 'col7': 12, 'col8': 19}, - {'col4': 7, 'col8': 19}, - {'col4': 7, 'col7': 12, 'col8': 19}, + {"col4": 7, "col7": 12, "col8": 19}, + {"col4": 7, "col8": 19}, + {"col4": 7, "col7": 12, "col8": 19}, ) def test_insert_values(self): - t.insert(values={'col3': 50}).execute() + t.insert(values={"col3": 50}).execute() result = t.select().execute() - eq_(50, result.first()['col3']) + eq_(50, result.first()["col3"]) - @testing.fails_on('firebird', 'Data type unknown') + @testing.fails_on("firebird", "Data type unknown") def test_updatemany(self): # MySQL-Python 1.2.2 breaks functions in execute_many :( - if (testing.against('mysql+mysqldb') and - testing.db.dialect.dbapi.version_info[:3] == (1, 2, 2)): + if testing.against( + "mysql+mysqldb" + ) and testing.db.dialect.dbapi.version_info[:3] == (1, 2, 2): return t.insert().execute({}, {}, {}) - t.update(t.c.col1 == sa.bindparam('pkval')).execute( - {'pkval': 51, 'col7': None, 'col8': None, 'boolcol1': False}) + t.update(t.c.col1 == sa.bindparam("pkval")).execute( + {"pkval": 51, "col7": None, "col8": None, "boolcol1": False} + ) - t.update(t.c.col1 == sa.bindparam('pkval')).execute( - {'pkval': 51}, - {'pkval': 52}, - {'pkval': 53}) + t.update(t.c.col1 == sa.bindparam("pkval")).execute( + {"pkval": 51}, {"pkval": 52}, {"pkval": 53} + ) result = t.select().execute() ctexec = currenttime.scalar() today = datetime.date.today() - eq_(result.fetchall(), - [(51, 'im the update', f2, ts, ts, ctexec, False, False, - 13, today, 'py', 'hi', 'BINDfoo'), - (52, 'im the update', f2, ts, ts, ctexec, True, False, - 13, today, 'py', 'hi', 'BINDfoo'), - (53, 'im the update', f2, ts, ts, ctexec, True, False, - 13, today, 'py', 'hi', 'BINDfoo')]) - - @testing.fails_on('firebird', 'Data type unknown') + eq_( + result.fetchall(), + [ + ( + 51, + "im the update", + f2, + ts, + ts, + ctexec, + False, + False, + 13, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 52, + "im the update", + f2, + ts, + ts, + ctexec, + True, + False, + 13, + today, + "py", + "hi", + "BINDfoo", + ), + ( + 53, + "im the update", + f2, + ts, + ts, + ctexec, + True, + False, + 13, + today, + "py", + "hi", + "BINDfoo", + ), + ], + ) + + @testing.fails_on("firebird", "Data type unknown") def test_update(self): r = t.insert().execute() pk = r.inserted_primary_key[0] @@ -555,39 +765,56 @@ class DefaultTest(fixtures.TestBase): ctexec = currenttime.scalar() result = t.select(t.c.col1 == pk).execute() result = result.first() - eq_(result, - (pk, 'im the update', f2, None, None, ctexec, True, False, - 13, datetime.date.today(), 'py', 'hi', 'BINDfoo')) + eq_( + result, + ( + pk, + "im the update", + f2, + None, + None, + ctexec, + True, + False, + 13, + datetime.date.today(), + "py", + "hi", + "BINDfoo", + ), + ) eq_(11, f2) - @testing.fails_on('firebird', 'Data type unknown') + @testing.fails_on("firebird", "Data type unknown") def test_update_values(self): r = t.insert().execute() pk = r.inserted_primary_key[0] - t.update(t.c.col1 == pk, values={'col3': 55}).execute() + t.update(t.c.col1 == pk, values={"col3": 55}).execute() result = t.select(t.c.col1 == pk).execute() result = result.first() - eq_(55, result['col3']) + eq_(55, result["col3"]) class CTEDefaultTest(fixtures.TablesTest): - __requires__ = ('ctes', 'returning', 'ctes_on_dml') + __requires__ = ("ctes", "returning", "ctes_on_dml") __backend__ = True @classmethod def define_tables(cls, metadata): Table( - 'q', metadata, - Column('x', Integer, default=2), - Column('y', Integer, onupdate=5), - Column('z', Integer) + "q", + metadata, + Column("x", Integer, default=2), + Column("y", Integer, onupdate=5), + Column("z", Integer), ) Table( - 'p', metadata, - Column('s', Integer), - Column('t', Integer), - Column('u', Integer, onupdate=1) + "p", + metadata, + Column("s", Integer), + Column("t", Integer), + Column("u", Integer, onupdate=1), ) def _test_a_in_b(self, a, b): @@ -595,48 +822,53 @@ class CTEDefaultTest(fixtures.TablesTest): p = self.tables.p with testing.db.connect() as conn: - if a == 'delete': + if a == "delete": conn.execute(q.insert().values(y=10, z=1)) - cte = q.delete().\ - where(q.c.z == 1).returning(q.c.z).cte('c') + cte = q.delete().where(q.c.z == 1).returning(q.c.z).cte("c") expected = None elif a == "insert": - cte = q.insert().values(z=1, y=10).returning(q.c.z).cte('c') + cte = q.insert().values(z=1, y=10).returning(q.c.z).cte("c") expected = (2, 10) elif a == "update": conn.execute(q.insert().values(x=5, y=10, z=1)) - cte = q.update().\ - where(q.c.z == 1).values(x=7).returning(q.c.z).cte('c') + cte = ( + q.update() + .where(q.c.z == 1) + .values(x=7) + .returning(q.c.z) + .cte("c") + ) expected = (7, 5) elif a == "select": conn.execute(q.insert().values(x=5, y=10, z=1)) - cte = sa.select([q.c.z]).cte('c') + cte = sa.select([q.c.z]).cte("c") expected = (5, 10) if b == "select": conn.execute(p.insert().values(s=1)) stmt = select([p.c.s, cte.c.z]) elif b == "insert": - sel = select([1, cte.c.z, ]) - stmt = p.insert().from_select(['s', 't'], sel).returning( - p.c.s, p.c.t) + sel = select([1, cte.c.z]) + stmt = ( + p.insert() + .from_select(["s", "t"], sel) + .returning(p.c.s, p.c.t) + ) elif b == "delete": - stmt = p.insert().values(s=1, t=cte.c.z).returning( - p.c.s, cte.c.z) + stmt = ( + p.insert().values(s=1, t=cte.c.z).returning(p.c.s, cte.c.z) + ) elif b == "update": conn.execute(p.insert().values(s=1)) - stmt = p.update().values(t=5).\ - where(p.c.s == cte.c.z).\ - returning(p.c.u, cte.c.z) - eq_( - conn.execute(stmt).fetchall(), - [(1, 1)] - ) + stmt = ( + p.update() + .values(t=5) + .where(p.c.s == cte.c.z) + .returning(p.c.u, cte.c.z) + ) + eq_(conn.execute(stmt).fetchall(), [(1, 1)]) - eq_( - conn.execute(select([q.c.x, q.c.y])).fetchone(), - expected - ) + eq_(conn.execute(select([q.c.x, q.c.y])).fetchone(), expected) @testing.requires.ctes_on_dml def test_update_in_select(self): @@ -661,27 +893,34 @@ class CTEDefaultTest(fixtures.TablesTest): class PKDefaultTest(fixtures.TablesTest): - __requires__ = ('subqueries',) + __requires__ = ("subqueries",) __backend__ = True @classmethod def define_tables(cls, metadata): - t2 = Table( - 't2', metadata, - Column('nextid', Integer)) + t2 = Table("t2", metadata, Column("nextid", Integer)) Table( - 't1', metadata, + "t1", + metadata, Column( - 'id', Integer, primary_key=True, - default=sa.select([func.max(t2.c.nextid)]).as_scalar()), - Column('data', String(30))) + "id", + Integer, + primary_key=True, + default=sa.select([func.max(t2.c.nextid)]).as_scalar(), + ), + Column("data", String(30)), + ) Table( - 'date_table', metadata, + "date_table", + metadata, Column( - 'date_id', - DateTime, default=text("current_timestamp"), primary_key=True) + "date_id", + DateTime, + default=text("current_timestamp"), + primary_key=True, + ), ) @testing.requires.returning @@ -693,21 +932,24 @@ class PKDefaultTest(fixtures.TablesTest): def _test(self, returning): t2, t1, date_table = ( - self.tables.t2, self.tables.t1, self.tables.date_table + self.tables.t2, + self.tables.t1, + self.tables.date_table, ) if not returning and not testing.db.dialect.implicit_returning: engine = testing.db else: engine = engines.testing_engine( - options={'implicit_returning': returning}) + options={"implicit_returning": returning} + ) with engine.begin() as conn: conn.execute(t2.insert(), nextid=1) - r = conn.execute(t1.insert(), data='hi') + r = conn.execute(t1.insert(), data="hi") eq_([1], r.inserted_primary_key) conn.execute(t2.insert(), nextid=2) - r = conn.execute(t1.insert(), data='there') + r = conn.execute(t1.insert(), data="there") eq_([2], r.inserted_primary_key) r = conn.execute(date_table.insert()) @@ -715,19 +957,26 @@ class PKDefaultTest(fixtures.TablesTest): class PKIncrementTest(fixtures.TablesTest): - run_define_tables = 'each' + run_define_tables = "each" __backend__ = True @classmethod def define_tables(cls, metadata): - Table("aitable", metadata, - Column('id', Integer, Sequence('ai_id_seq', optional=True), - primary_key=True), - Column('int1', Integer), - Column('str1', String(20))) + Table( + "aitable", + metadata, + Column( + "id", + Integer, + Sequence("ai_id_seq", optional=True), + primary_key=True, + ), + Column("int1", Integer), + Column("str1", String(20)), + ) # TODO: add coverage for increment on a secondary column in a key - @testing.fails_on('firebird', 'Data type unknown') + @testing.fails_on("firebird", "Data type unknown") def _test_autoincrement(self, bind): aitable = self.tables.aitable @@ -738,19 +987,19 @@ class PKIncrementTest(fixtures.TablesTest): self.assert_(last not in ids) ids.add(last) - rs = bind.execute(aitable.insert(), str1='row 2') + rs = bind.execute(aitable.insert(), str1="row 2") last = rs.inserted_primary_key[0] self.assert_(last) self.assert_(last not in ids) ids.add(last) - rs = bind.execute(aitable.insert(), int1=3, str1='row 3') + rs = bind.execute(aitable.insert(), int1=3, str1="row 3") last = rs.inserted_primary_key[0] self.assert_(last) self.assert_(last not in ids) ids.add(last) - rs = bind.execute(aitable.insert(values={'int1': func.length('four')})) + rs = bind.execute(aitable.insert(values={"int1": func.length("four")})) last = rs.inserted_primary_key[0] self.assert_(last) self.assert_(last not in ids) @@ -758,8 +1007,10 @@ class PKIncrementTest(fixtures.TablesTest): eq_(ids, set([1, 2, 3, 4])) - eq_(list(bind.execute(aitable.select().order_by(aitable.c.id))), - [(1, 1, None), (2, None, 'row 2'), (3, 3, 'row 3'), (4, 4, None)]) + eq_( + list(bind.execute(aitable.select().order_by(aitable.c.id))), + [(1, 1, None), (2, None, "row 2"), (3, 3, "row 3"), (4, 4, None)], + ) def test_autoincrement_autocommit(self): self._test_autoincrement(testing.db) @@ -785,85 +1036,87 @@ class PKIncrementTest(fixtures.TablesTest): class EmptyInsertTest(fixtures.TestBase): __backend__ = True - @testing.exclude('sqlite', '<', (3, 3, 8), 'no empty insert support') - @testing.fails_on('oracle', 'FIXME: unknown') + @testing.exclude("sqlite", "<", (3, 3, 8), "no empty insert support") + @testing.fails_on("oracle", "FIXME: unknown") @testing.provide_metadata def test_empty_insert(self): t1 = Table( - 't1', self.metadata, - Column('is_true', Boolean, server_default=('1'))) + "t1", + self.metadata, + Column("is_true", Boolean, server_default=("1")), + ) self.metadata.create_all() t1.insert().execute() - eq_(1, select([func.count(text('*'))], from_obj=t1).scalar()) + eq_(1, select([func.count(text("*"))], from_obj=t1).scalar()) eq_(True, t1.select().scalar()) class AutoIncrementTest(fixtures.TablesTest): - __requires__ = ('identity',) - run_define_tables = 'each' + __requires__ = ("identity",) + run_define_tables = "each" __backend__ = True @classmethod def define_tables(cls, metadata): """Each test manipulates self.metadata individually.""" - @testing.exclude('sqlite', '<', (3, 4), 'no database support') + @testing.exclude("sqlite", "<", (3, 4), "no database support") def test_autoincrement_single_col(self): - single = Table('single', self.metadata, - Column('id', Integer, primary_key=True)) + single = Table( + "single", self.metadata, Column("id", Integer, primary_key=True) + ) single.create() r = single.insert().execute() id_ = r.inserted_primary_key[0] eq_(id_, 1) - eq_(1, sa.select([func.count(sa.text('*'))], from_obj=single).scalar()) + eq_(1, sa.select([func.count(sa.text("*"))], from_obj=single).scalar()) def test_autoincrement_fk(self): nodes = Table( - 'nodes', self.metadata, - Column('id', Integer, primary_key=True), - Column('parent_id', Integer, ForeignKey('nodes.id')), - Column('data', String(30))) + "nodes", + self.metadata, + Column("id", Integer, primary_key=True), + Column("parent_id", Integer, ForeignKey("nodes.id")), + Column("data", String(30)), + ) nodes.create() - r = nodes.insert().execute(data='foo') + r = nodes.insert().execute(data="foo") id_ = r.inserted_primary_key[0] - nodes.insert().execute(data='bar', parent_id=id_) + nodes.insert().execute(data="bar", parent_id=id_) def test_autoinc_detection_no_affinity(self): class MyType(TypeDecorator): impl = TypeEngine assert MyType()._type_affinity is None - t = Table( - 'x', MetaData(), - Column('id', MyType(), primary_key=True) - ) + t = Table("x", MetaData(), Column("id", MyType(), primary_key=True)) assert t._autoincrement_column is None def test_autoincrement_ignore_fk(self): m = MetaData() - Table( - 'y', m, - Column('id', Integer(), primary_key=True) - ) + Table("y", m, Column("id", Integer(), primary_key=True)) x = Table( - 'x', m, + "x", + m, Column( - 'id', Integer(), ForeignKey('y.id'), - autoincrement="ignore_fk", primary_key=True) + "id", + Integer(), + ForeignKey("y.id"), + autoincrement="ignore_fk", + primary_key=True, + ), ) assert x._autoincrement_column is x.c.id def test_autoincrement_fk_disqualifies(self): m = MetaData() - Table( - 'y', m, - Column('id', Integer(), primary_key=True) - ) + Table("y", m, Column("id", Integer(), primary_key=True)) x = Table( - 'x', m, - Column('id', Integer(), ForeignKey('y.id'), primary_key=True) + "x", + m, + Column("id", Integer(), ForeignKey("y.id"), primary_key=True), ) assert x._autoincrement_column is None @@ -871,124 +1124,129 @@ class AutoIncrementTest(fixtures.TablesTest): def test_non_autoincrement(self): # sqlite INT primary keys can be non-unique! (only for ints) nonai = Table( - "nonaitest", self.metadata, - Column('id', Integer, autoincrement=False, primary_key=True), - Column('data', String(20))) + "nonaitest", + self.metadata, + Column("id", Integer, autoincrement=False, primary_key=True), + Column("data", String(20)), + ) nonai.create() def go(): # postgresql + mysql strict will fail on first row, # mysql in legacy mode fails on second row - nonai.insert().execute(data='row 1') - nonai.insert().execute(data='row 2') + nonai.insert().execute(data="row 1") + nonai.insert().execute(data="row 2") # just testing SQLite for now, it passes - with expect_warnings( - ".*has no Python-side or server-side default.*", - ): + with expect_warnings(".*has no Python-side or server-side default.*"): go() def test_col_w_sequence_non_autoinc_no_firing(self): metadata = self.metadata # plain autoincrement/PK table in the actual schema - Table( - "x", metadata, - Column("set_id", Integer, primary_key=True) - ) + Table("x", metadata, Column("set_id", Integer, primary_key=True)) metadata.create_all() # for the INSERT use a table with a Sequence # and autoincrement=False. Using a ForeignKey # would have the same effect dataset_no_autoinc = Table( - "x", MetaData(), + "x", + MetaData(), Column( - "set_id", Integer, Sequence("some_seq"), - primary_key=True, autoincrement=False) + "set_id", + Integer, + Sequence("some_seq"), + primary_key=True, + autoincrement=False, + ), ) testing.db.execute(dataset_no_autoinc.insert()) eq_( testing.db.scalar( - select([func.count('*')]).select_from(dataset_no_autoinc)), 1 + select([func.count("*")]).select_from(dataset_no_autoinc) + ), + 1, ) class SequenceDDLTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" __backend__ = True def test_create_drop_ddl(self): self.assert_compile( - CreateSequence(Sequence('foo_seq')), - "CREATE SEQUENCE foo_seq", + CreateSequence(Sequence("foo_seq")), "CREATE SEQUENCE foo_seq" ) self.assert_compile( - CreateSequence(Sequence('foo_seq', start=5)), + CreateSequence(Sequence("foo_seq", start=5)), "CREATE SEQUENCE foo_seq START WITH 5", ) self.assert_compile( - CreateSequence(Sequence('foo_seq', increment=2)), + CreateSequence(Sequence("foo_seq", increment=2)), "CREATE SEQUENCE foo_seq INCREMENT BY 2", ) self.assert_compile( - CreateSequence(Sequence('foo_seq', increment=2, start=5)), + CreateSequence(Sequence("foo_seq", increment=2, start=5)), "CREATE SEQUENCE foo_seq INCREMENT BY 2 START WITH 5", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', increment=2, start=0, minvalue=0)), + CreateSequence( + Sequence("foo_seq", increment=2, start=0, minvalue=0) + ), "CREATE SEQUENCE foo_seq INCREMENT BY 2 START WITH 0 MINVALUE 0", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', increment=2, start=1, maxvalue=5)), + CreateSequence( + Sequence("foo_seq", increment=2, start=1, maxvalue=5) + ), "CREATE SEQUENCE foo_seq INCREMENT BY 2 START WITH 1 MAXVALUE 5", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', increment=2, start=1, nomaxvalue=True)), + CreateSequence( + Sequence("foo_seq", increment=2, start=1, nomaxvalue=True) + ), "CREATE SEQUENCE foo_seq INCREMENT BY 2 START WITH 1 NO MAXVALUE", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', increment=2, start=0, nominvalue=True)), + CreateSequence( + Sequence("foo_seq", increment=2, start=0, nominvalue=True) + ), "CREATE SEQUENCE foo_seq INCREMENT BY 2 START WITH 0 NO MINVALUE", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', start=1, maxvalue=10, cycle=True)), + CreateSequence( + Sequence("foo_seq", start=1, maxvalue=10, cycle=True) + ), "CREATE SEQUENCE foo_seq START WITH 1 MAXVALUE 10 CYCLE", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', cache=1000, order=True)), + CreateSequence(Sequence("foo_seq", cache=1000, order=True)), "CREATE SEQUENCE foo_seq CACHE 1000 ORDER", ) self.assert_compile( - CreateSequence(Sequence( - 'foo_seq', order=True)), + CreateSequence(Sequence("foo_seq", order=True)), "CREATE SEQUENCE foo_seq ORDER", ) self.assert_compile( - DropSequence(Sequence('foo_seq')), - "DROP SEQUENCE foo_seq", + DropSequence(Sequence("foo_seq")), "DROP SEQUENCE foo_seq" ) class SequenceExecTest(fixtures.TestBase): - __requires__ = ('sequences',) + __requires__ = ("sequences",) __backend__ = True @classmethod @@ -1042,28 +1300,23 @@ class SequenceExecTest(fixtures.TestBase): """test can use next_value() in select column expr""" s = Sequence("my_sequence") - self._assert_seq_result( - testing.db.scalar(select([s.next_value()])) - ) + self._assert_seq_result(testing.db.scalar(select([s.next_value()]))) - @testing.fails_on('oracle', "ORA-02287: sequence number not allowed here") + @testing.fails_on("oracle", "ORA-02287: sequence number not allowed here") @testing.provide_metadata def test_func_embedded_whereclause(self): """test can use next_value() in whereclause""" metadata = self.metadata - t1 = Table( - 't', metadata, - Column('x', Integer) - ) + t1 = Table("t", metadata, Column("x", Integer)) t1.create(testing.db) - testing.db.execute(t1.insert(), [{'x': 1}, {'x': 300}, {'x': 301}]) + testing.db.execute(t1.insert(), [{"x": 1}, {"x": 300}, {"x": 301}]) s = Sequence("my_sequence") eq_( testing.db.execute( t1.select().where(t1.c.x > s.next_value()) ).fetchall(), - [(300, ), (301, )] + [(300,), (301,)], ) @testing.provide_metadata @@ -1071,18 +1324,11 @@ class SequenceExecTest(fixtures.TestBase): """test can use next_value() in values() of _ValuesBase""" metadata = self.metadata - t1 = Table( - 't', metadata, - Column('x', Integer) - ) + t1 = Table("t", metadata, Column("x", Integer)) t1.create(testing.db) s = Sequence("my_sequence") - testing.db.execute( - t1.insert().values(x=s.next_value()) - ) - self._assert_seq_result( - testing.db.scalar(t1.select()) - ) + testing.db.execute(t1.insert().values(x=s.next_value())) + self._assert_seq_result(testing.db.scalar(t1.select())) @testing.provide_metadata def test_inserted_pk_no_returning(self): @@ -1090,13 +1336,10 @@ class SequenceExecTest(fixtures.TestBase): pk_col=next_value(), implicit returning is not used.""" metadata = self.metadata - e = engines.testing_engine(options={'implicit_returning': False}) + e = engines.testing_engine(options={"implicit_returning": False}) s = Sequence("my_sequence") metadata.bind = e - t1 = Table( - 't', metadata, - Column('x', Integer, primary_key=True) - ) + t1 = Table("t", metadata, Column("x", Integer, primary_key=True)) t1.create() r = e.execute(t1.insert().values(x=s.next_value())) eq_(r.inserted_primary_key, [None]) @@ -1108,35 +1351,29 @@ class SequenceExecTest(fixtures.TestBase): pk_col=next_value(), when implicit returning is used.""" metadata = self.metadata - e = engines.testing_engine(options={'implicit_returning': True}) + e = engines.testing_engine(options={"implicit_returning": True}) s = Sequence("my_sequence") metadata.bind = e - t1 = Table( - 't', metadata, - Column('x', Integer, primary_key=True) - ) + t1 = Table("t", metadata, Column("x", Integer, primary_key=True)) t1.create() - r = e.execute( - t1.insert().values(x=s.next_value()) - ) + r = e.execute(t1.insert().values(x=s.next_value())) self._assert_seq_result(r.inserted_primary_key[0]) class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __requires__ = ('sequences',) + __requires__ = ("sequences",) __backend__ = True - @testing.fails_on('firebird', 'no FB support for start/increment') + @testing.fails_on("firebird", "no FB support for start/increment") def test_start_increment(self): for seq in ( - Sequence('foo_seq'), - Sequence('foo_seq', start=8), - Sequence('foo_seq', increment=5)): + Sequence("foo_seq"), + Sequence("foo_seq", start=8), + Sequence("foo_seq", increment=5), + ): seq.create(testing.db) try: - values = [ - testing.db.execute(seq) for i in range(3) - ] + values = [testing.db.execute(seq) for i in range(3)] start = seq.start or 1 inc = seq.increment or 1 assert values == list(range(start, start + inc * 3, inc)) @@ -1153,7 +1390,10 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): for s in (Sequence("my_seq"), Sequence("my_seq", optional=True)): assert str(s.next_value().compile(dialect=testing.db.dialect)) in ( - "nextval('my_seq')", "gen_id(my_seq, 1)", "my_seq.nextval",) + "nextval('my_seq')", + "gen_id(my_seq, 1)", + "my_seq.nextval", + ) def test_nextval_unsupported(self): """test next_value() used on non-sequence platform @@ -1165,37 +1405,37 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): NotImplementedError, "Dialect 'sqlite' does not support sequence increments.", s.next_value().compile, - dialect=d + dialect=d, ) def test_checkfirst_sequence(self): s = Sequence("my_sequence") s.create(testing.db, checkfirst=False) - assert self._has_sequence('my_sequence') + assert self._has_sequence("my_sequence") s.create(testing.db, checkfirst=True) s.drop(testing.db, checkfirst=False) - assert not self._has_sequence('my_sequence') + assert not self._has_sequence("my_sequence") s.drop(testing.db, checkfirst=True) def test_checkfirst_metadata(self): m = MetaData() Sequence("my_sequence", metadata=m) m.create_all(testing.db, checkfirst=False) - assert self._has_sequence('my_sequence') + assert self._has_sequence("my_sequence") m.create_all(testing.db, checkfirst=True) m.drop_all(testing.db, checkfirst=False) - assert not self._has_sequence('my_sequence') + assert not self._has_sequence("my_sequence") m.drop_all(testing.db, checkfirst=True) def test_checkfirst_table(self): m = MetaData() s = Sequence("my_sequence") - t = Table('t', m, Column('c', Integer, s, primary_key=True)) + t = Table("t", m, Column("c", Integer, s, primary_key=True)) t.create(testing.db, checkfirst=False) - assert self._has_sequence('my_sequence') + assert self._has_sequence("my_sequence") t.create(testing.db, checkfirst=True) t.drop(testing.db, checkfirst=False) - assert not self._has_sequence('my_sequence') + assert not self._has_sequence("my_sequence") t.drop(testing.db, checkfirst=True) @testing.provide_metadata @@ -1204,9 +1444,7 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): Sequence("s1", metadata=metadata) s2 = Sequence("s2", metadata=metadata) s3 = Sequence("s3") - t = Table( - 't', metadata, - Column('c', Integer, s3, primary_key=True)) + t = Table("t", metadata, Column("c", Integer, s3, primary_key=True)) assert s3.metadata is metadata t.create(testing.db, checkfirst=True) @@ -1216,29 +1454,33 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): # re-created since it's linked to 't'. # 's1' and 's2' are, however. metadata.create_all(testing.db) - assert self._has_sequence('s1') - assert self._has_sequence('s2') - assert not self._has_sequence('s3') + assert self._has_sequence("s1") + assert self._has_sequence("s2") + assert not self._has_sequence("s3") s2.drop(testing.db) - assert self._has_sequence('s1') - assert not self._has_sequence('s2') + assert self._has_sequence("s1") + assert not self._has_sequence("s2") metadata.drop_all(testing.db) - assert not self._has_sequence('s1') - assert not self._has_sequence('s2') + assert not self._has_sequence("s1") + assert not self._has_sequence("s2") @testing.requires.returning @testing.provide_metadata def test_freestanding_sequence_via_autoinc(self): t = Table( - 'some_table', self.metadata, + "some_table", + self.metadata, Column( - 'id', Integer, + "id", + Integer, autoincrement=True, primary_key=True, default=Sequence( - 'my_sequence', metadata=self.metadata).next_value()) + "my_sequence", metadata=self.metadata + ).next_value(), + ), ) self.metadata.create_all(testing.db) @@ -1250,7 +1492,7 @@ cartitems = sometable = metadata = None class TableBoundSequenceTest(fixtures.TestBase): - __requires__ = ('sequences',) + __requires__ = ("sequences",) __backend__ = True @classmethod @@ -1258,19 +1500,25 @@ class TableBoundSequenceTest(fixtures.TestBase): global cartitems, sometable, metadata metadata = MetaData(testing.db) cartitems = Table( - "cartitems", metadata, + "cartitems", + metadata, Column( - "cart_id", Integer, Sequence('cart_id_seq'), primary_key=True), + "cart_id", Integer, Sequence("cart_id_seq"), primary_key=True + ), Column("description", String(40)), - Column("createdate", sa.DateTime()) + Column("createdate", sa.DateTime()), ) sometable = Table( - 'Manager', metadata, - Column('obj_id', Integer, Sequence('obj_id_seq')), - Column('name', String(128)), + "Manager", + metadata, + Column("obj_id", Integer, Sequence("obj_id_seq")), + Column("name", String(128)), Column( - 'id', Integer, Sequence('Manager_id_seq', optional=True), - primary_key=True), + "id", + Integer, + Sequence("Manager_id_seq", optional=True), + primary_key=True, + ), ) metadata.create_all() @@ -1280,24 +1528,30 @@ class TableBoundSequenceTest(fixtures.TestBase): metadata.drop_all() def test_insert_via_seq(self): - cartitems.insert().execute(description='hi') - cartitems.insert().execute(description='there') - r = cartitems.insert().execute(description='lala') + cartitems.insert().execute(description="hi") + cartitems.insert().execute(description="there") + r = cartitems.insert().execute(description="lala") assert r.inserted_primary_key and r.inserted_primary_key[0] is not None id_ = r.inserted_primary_key[0] - eq_(1, - sa.select([func.count(cartitems.c.cart_id)], - sa.and_(cartitems.c.description == 'lala', - cartitems.c.cart_id == id_)).scalar()) + eq_( + 1, + sa.select( + [func.count(cartitems.c.cart_id)], + sa.and_( + cartitems.c.description == "lala", + cartitems.c.cart_id == id_, + ), + ).scalar(), + ) cartitems.select().execute().fetchall() def test_seq_nonpk(self): """test sequences fire off as defaults on non-pk columns""" - engine = engines.testing_engine(options={'implicit_returning': False}) + engine = engines.testing_engine(options={"implicit_returning": False}) result = engine.execute(sometable.insert(), name="somename") assert set(result.postfetch_cols()) == set([sometable.c.obj_id]) @@ -1305,22 +1559,25 @@ class TableBoundSequenceTest(fixtures.TestBase): result = engine.execute(sometable.insert(), name="someother") assert set(result.postfetch_cols()) == set([sometable.c.obj_id]) - sometable.insert().execute( - {'name': 'name3'}, - {'name': 'name4'}) - eq_(sometable.select().order_by(sometable.c.id).execute().fetchall(), - [(1, "somename", 1), - (2, "someother", 2), - (3, "name3", 3), - (4, "name4", 4)]) + sometable.insert().execute({"name": "name3"}, {"name": "name4"}) + eq_( + sometable.select().order_by(sometable.c.id).execute().fetchall(), + [ + (1, "somename", 1), + (2, "someother", 2), + (3, "name3", 3), + (4, "name4", 4), + ], + ) class SequenceAsServerDefaultTest( - testing.AssertsExecutionResults, fixtures.TablesTest): - __requires__ = ('sequences_as_server_defaults',) + testing.AssertsExecutionResults, fixtures.TablesTest +): + __requires__ = ("sequences_as_server_defaults",) __backend__ = True - run_create_tables = 'each' + run_create_tables = "each" @classmethod def define_tables(cls, metadata): @@ -1328,16 +1585,18 @@ class SequenceAsServerDefaultTest( s = Sequence("t_seq", metadata=m) Table( - "t_seq_test", m, + "t_seq_test", + m, Column("id", Integer, s, server_default=s.next_value()), - Column("data", String(50)) + Column("data", String(50)), ) s2 = Sequence("t_seq_2", metadata=m) Table( - "t_seq_test_2", m, + "t_seq_test_2", + m, Column("id", Integer, server_default=s2.next_value()), - Column("data", String(50)) + Column("data", String(50)), ) def test_default_textual_w_default(self): @@ -1356,7 +1615,8 @@ class SequenceAsServerDefaultTest( def test_default_textual_server_only(self): with testing.db.connect() as conn: conn.execute( - "insert into t_seq_test_2 (data) values ('some data')") + "insert into t_seq_test_2 (data) values ('some data')" + ) eq_(conn.scalar("select id from t_seq_test_2"), 1) @@ -1372,24 +1632,18 @@ class SequenceAsServerDefaultTest( testing.db, lambda: self.metadata.drop_all(checkfirst=False), AllOf( - CompiledSQL( - "DROP TABLE t_seq_test_2", - {} - ), + CompiledSQL("DROP TABLE t_seq_test_2", {}), EachOf( + CompiledSQL("DROP TABLE t_seq_test", {}), CompiledSQL( - "DROP TABLE t_seq_test", - {} - ), - CompiledSQL( - "DROP SEQUENCE t_seq", # dropped as part of t_seq_test - {} + "DROP SEQUENCE t_seq", # dropped as part of t_seq_test + {}, ), ), ), CompiledSQL( "DROP SEQUENCE t_seq_2", # dropped as part of metadata level - {} + {}, ), ) @@ -1402,6 +1656,7 @@ class SpecialTypePKTest(fixtures.TestBase): column.type._type_affinity, rather than the class of "type" itself. """ + __backend__ = True @classmethod @@ -1424,33 +1679,31 @@ class SpecialTypePKTest(fixtures.TestBase): @testing.provide_metadata def _run_test(self, *arg, **kw): metadata = self.metadata - implicit_returning = kw.pop('implicit_returning', True) - kw['primary_key'] = True - if kw.get('autoincrement', True): - kw['test_needs_autoincrement'] = True + implicit_returning = kw.pop("implicit_returning", True) + kw["primary_key"] = True + if kw.get("autoincrement", True): + kw["test_needs_autoincrement"] = True t = Table( - 'x', metadata, - Column('y', self.MyInteger, *arg, **kw), - Column('data', Integer), - implicit_returning=implicit_returning + "x", + metadata, + Column("y", self.MyInteger, *arg, **kw), + Column("data", Integer), + implicit_returning=implicit_returning, ) t.create() r = t.insert().values(data=5).execute() # we don't pre-fetch 'server_default'. - if 'server_default' in kw and ( - not testing.db.dialect.implicit_returning or - not implicit_returning): + if "server_default" in kw and ( + not testing.db.dialect.implicit_returning or not implicit_returning + ): eq_(r.inserted_primary_key, [None]) else: - eq_(r.inserted_primary_key, ['INT_1']) + eq_(r.inserted_primary_key, ["INT_1"]) r.close() - eq_( - t.select().execute().first(), - ('INT_1', 5) - ) + eq_(t.select().execute().first(), ("INT_1", 5)) def test_plain(self): # among other things, tests that autoincrement @@ -1459,7 +1712,8 @@ class SpecialTypePKTest(fixtures.TestBase): def test_literal_default_label(self): self._run_test( - default=literal("INT_1", type_=self.MyInteger).label('foo')) + default=literal("INT_1", type_=self.MyInteger).label("foo") + ) def test_literal_default_no_label(self): self._run_test(default=literal("INT_1", type_=self.MyInteger)) @@ -1468,16 +1722,16 @@ class SpecialTypePKTest(fixtures.TestBase): self._run_test(default=literal_column("1", type_=self.MyInteger)) def test_sequence(self): - self._run_test(Sequence('foo_seq')) + self._run_test(Sequence("foo_seq")) def test_text_clause_default_no_type(self): - self._run_test(default=text('1')) + self._run_test(default=text("1")) def test_server_default(self): - self._run_test(server_default='1',) + self._run_test(server_default="1") def test_server_default_no_autoincrement(self): - self._run_test(server_default='1', autoincrement=False) + self._run_test(server_default="1", autoincrement=False) def test_clause(self): stmt = select([cast("INT_1", type_=self.MyInteger)]).as_scalar() @@ -1489,7 +1743,7 @@ class SpecialTypePKTest(fixtures.TestBase): @testing.requires.returning def test_server_default_no_implicit_returning(self): - self._run_test(server_default='1', autoincrement=False) + self._run_test(server_default="1", autoincrement=False) class ServerDefaultsOnPKTest(fixtures.TestBase): @@ -1508,19 +1762,18 @@ class ServerDefaultsOnPKTest(fixtures.TestBase): metadata = self.metadata t = Table( - 'x', metadata, + "x", + metadata, Column( - 'y', String(10), server_default='key_one', primary_key=True), - Column('data', String(10)), - implicit_returning=False + "y", String(10), server_default="key_one", primary_key=True + ), + Column("data", String(10)), + implicit_returning=False, ) metadata.create_all() - r = t.insert().execute(data='data') + r = t.insert().execute(data="data") eq_(r.inserted_primary_key, [None]) - eq_( - t.select().execute().fetchall(), - [('key_one', 'data')] - ) + eq_(t.select().execute().fetchall(), [("key_one", "data")]) @testing.requires.returning @testing.provide_metadata @@ -1530,103 +1783,91 @@ class ServerDefaultsOnPKTest(fixtures.TestBase): metadata = self.metadata t = Table( - 'x', metadata, + "x", + metadata, Column( - 'y', String(10), server_default='key_one', primary_key=True), - Column('data', String(10)) + "y", String(10), server_default="key_one", primary_key=True + ), + Column("data", String(10)), ) metadata.create_all() - r = t.insert().execute(data='data') - eq_(r.inserted_primary_key, ['key_one']) - eq_( - t.select().execute().fetchall(), - [('key_one', 'data')] - ) + r = t.insert().execute(data="data") + eq_(r.inserted_primary_key, ["key_one"]) + eq_(t.select().execute().fetchall(), [("key_one", "data")]) @testing.provide_metadata def test_int_default_none_on_insert(self): metadata = self.metadata t = Table( - 'x', metadata, - Column('y', Integer, server_default='5', primary_key=True), - Column('data', String(10)), - implicit_returning=False + "x", + metadata, + Column("y", Integer, server_default="5", primary_key=True), + Column("data", String(10)), + implicit_returning=False, ) assert t._autoincrement_column is None metadata.create_all() - r = t.insert().execute(data='data') + r = t.insert().execute(data="data") eq_(r.inserted_primary_key, [None]) - if testing.against('sqlite'): - eq_( - t.select().execute().fetchall(), - [(1, 'data')] - ) + if testing.against("sqlite"): + eq_(t.select().execute().fetchall(), [(1, "data")]) else: - eq_( - t.select().execute().fetchall(), - [(5, 'data')] - ) + eq_(t.select().execute().fetchall(), [(5, "data")]) @testing.provide_metadata def test_autoincrement_reflected_from_server_default(self): metadata = self.metadata t = Table( - 'x', metadata, - Column('y', Integer, server_default='5', primary_key=True), - Column('data', String(10)), - implicit_returning=False + "x", + metadata, + Column("y", Integer, server_default="5", primary_key=True), + Column("data", String(10)), + implicit_returning=False, ) assert t._autoincrement_column is None metadata.create_all() m2 = MetaData(metadata.bind) - t2 = Table('x', m2, autoload=True, implicit_returning=False) + t2 = Table("x", m2, autoload=True, implicit_returning=False) assert t2._autoincrement_column is None @testing.provide_metadata def test_int_default_none_on_insert_reflected(self): metadata = self.metadata Table( - 'x', metadata, - Column('y', Integer, server_default='5', primary_key=True), - Column('data', String(10)), - implicit_returning=False + "x", + metadata, + Column("y", Integer, server_default="5", primary_key=True), + Column("data", String(10)), + implicit_returning=False, ) metadata.create_all() m2 = MetaData(metadata.bind) - t2 = Table('x', m2, autoload=True, implicit_returning=False) + t2 = Table("x", m2, autoload=True, implicit_returning=False) - r = t2.insert().execute(data='data') + r = t2.insert().execute(data="data") eq_(r.inserted_primary_key, [None]) - if testing.against('sqlite'): - eq_( - t2.select().execute().fetchall(), - [(1, 'data')] - ) + if testing.against("sqlite"): + eq_(t2.select().execute().fetchall(), [(1, "data")]) else: - eq_( - t2.select().execute().fetchall(), - [(5, 'data')] - ) + eq_(t2.select().execute().fetchall(), [(5, "data")]) @testing.requires.returning @testing.provide_metadata def test_int_default_on_insert_with_returning(self): metadata = self.metadata t = Table( - 'x', metadata, - Column('y', Integer, server_default='5', primary_key=True), - Column('data', String(10)) + "x", + metadata, + Column("y", Integer, server_default="5", primary_key=True), + Column("data", String(10)), ) metadata.create_all() - r = t.insert().execute(data='data') + r = t.insert().execute(data="data") eq_(r.inserted_primary_key, [5]) - eq_( - t.select().execute().fetchall(), - [(5, 'data')] - ) + eq_(t.select().execute().fetchall(), [(5, "data")]) class UnicodeDefaultsTest(fixtures.TestBase): @@ -1636,18 +1877,19 @@ class UnicodeDefaultsTest(fixtures.TestBase): Column(Unicode(32)) def test_unicode_default(self): - default = u('foo') + default = u("foo") Column(Unicode(32), default=default) def test_nonunicode_default(self): - default = b('foo') + default = b("foo") assert_raises_message( sa.exc.SAWarning, "Unicode column 'foobar' has non-unicode " "default value b?'foo' specified.", Column, - "foobar", Unicode(32), - default=default + "foobar", + Unicode(32), + default=default, ) @@ -1656,34 +1898,34 @@ class InsertFromSelectTest(fixtures.TestBase): def _fixture(self): data = Table( - 'data', self.metadata, - Column('x', Integer), - Column('y', Integer) + "data", self.metadata, Column("x", Integer), Column("y", Integer) ) data.create() - testing.db.execute(data.insert(), {'x': 2, 'y': 5}, {'x': 7, 'y': 12}) + testing.db.execute(data.insert(), {"x": 2, "y": 5}, {"x": 7, "y": 12}) return data @testing.provide_metadata def test_insert_from_select_override_defaults(self): data = self._fixture() - table = Table('sometable', self.metadata, - Column('x', Integer), - Column('foo', Integer, default=12), - Column('y', Integer)) + table = Table( + "sometable", + self.metadata, + Column("x", Integer), + Column("foo", Integer, default=12), + Column("y", Integer), + ) table.create() sel = select([data.c.x, data.c.y]) - ins = table.insert().\ - from_select(["x", "y"], sel) + ins = table.insert().from_select(["x", "y"], sel) testing.db.execute(ins) eq_( testing.db.execute(table.select().order_by(table.c.x)).fetchall(), - [(2, 12, 5), (7, 12, 12)] + [(2, 12, 5), (7, 12, 12)], ) @testing.provide_metadata @@ -1695,25 +1937,28 @@ class InsertFromSelectTest(fixtures.TestBase): def foo(ctx): return next(counter) - table = Table('sometable', self.metadata, - Column('x', Integer), - Column('foo', Integer, default=foo), - Column('y', Integer)) + table = Table( + "sometable", + self.metadata, + Column("x", Integer), + Column("foo", Integer, default=foo), + Column("y", Integer), + ) table.create() sel = select([data.c.x, data.c.y]) - ins = table.insert().\ - from_select(["x", "y"], sel) + ins = table.insert().from_select(["x", "y"], sel) testing.db.execute(ins) # counter is only called once! eq_( testing.db.execute(table.select().order_by(table.c.x)).fetchall(), - [(2, 1, 5), (7, 1, 12)] + [(2, 1, 5), (7, 1, 12)], ) + class CurrentParametersTest(fixtures.TablesTest): __backend__ = True @@ -1723,15 +1968,16 @@ class CurrentParametersTest(fixtures.TablesTest): pass Table( - "some_table", metadata, - Column('x', String(50), default=gen_default), - Column('y', String(50)), + "some_table", + metadata, + Column("x", String(50), default=gen_default), + Column("y", String(50)), ) def _fixture(self, fn): - def gen_default(context): fn(context) + some_table = self.tables.some_table some_table.c.x.default.arg = gen_default return fn @@ -1744,12 +1990,12 @@ class CurrentParametersTest(fixtures.TablesTest): collect(context.get_current_parameters()) table = self.tables.some_table - if exec_type in ('multivalues', 'executemany'): + if exec_type in ("multivalues", "executemany"): parameters = [{"y": "h1"}, {"y": "h2"}] else: parameters = [{"y": "hello"}] - if exec_type == 'multivalues': + if exec_type == "multivalues": stmt, params = table.insert().values(parameters), {} else: stmt, params = table.insert(), parameters @@ -1758,7 +2004,7 @@ class CurrentParametersTest(fixtures.TablesTest): conn.execute(stmt, params) eq_( collect.mock_calls, - [mock.call({"y": param['y'], "x": None}) for param in parameters] + [mock.call({"y": param["y"], "x": None}) for param in parameters], ) def test_single_w_attribute(self): diff --git a/test/sql/test_delete.py b/test/sql/test_delete.py index 331a53601..cb5e696f2 100644 --- a/test/sql/test_delete.py +++ b/test/sql/test_delete.py @@ -1,128 +1,153 @@ #! coding:utf-8 -from sqlalchemy import Integer, String, ForeignKey, delete, select, and_, \ - or_, exists +from sqlalchemy import ( + Integer, + String, + ForeignKey, + delete, + select, + and_, + or_, + exists, +) from sqlalchemy.dialects import mysql from sqlalchemy.engine import default from sqlalchemy import testing from sqlalchemy import exc -from sqlalchemy.testing import AssertsCompiledSQL, fixtures, eq_, \ - assert_raises_message +from sqlalchemy.testing import ( + AssertsCompiledSQL, + fixtures, + eq_, + assert_raises_message, +) from sqlalchemy.testing.schema import Table, Column class _DeleteTestBase(object): - @classmethod def define_tables(cls, metadata): - Table('mytable', metadata, - Column('myid', Integer), - Column('name', String(30)), - Column('description', String(50))) - Table('myothertable', metadata, - Column('otherid', Integer), - Column('othername', String(30))) + Table( + "mytable", + metadata, + Column("myid", Integer), + Column("name", String(30)), + Column("description", String(50)), + ) + Table( + "myothertable", + metadata, + Column("otherid", Integer), + Column("othername", String(30)), + ) class DeleteTest(_DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_delete_literal_binds(self): table1 = self.tables.mytable - stmt = table1.delete().where(table1.c.name == 'jill') + stmt = table1.delete().where(table1.c.name == "jill") self.assert_compile( stmt, "DELETE FROM mytable WHERE mytable.name = 'jill'", - literal_binds=True) + literal_binds=True, + ) def test_delete(self): table1 = self.tables.mytable self.assert_compile( delete(table1, table1.c.myid == 7), - 'DELETE FROM mytable WHERE mytable.myid = :myid_1') + "DELETE FROM mytable WHERE mytable.myid = :myid_1", + ) self.assert_compile( table1.delete().where(table1.c.myid == 7), - 'DELETE FROM mytable WHERE mytable.myid = :myid_1') + "DELETE FROM mytable WHERE mytable.myid = :myid_1", + ) self.assert_compile( - table1.delete(). - where(table1.c.myid == 7). - where(table1.c.name == 'somename'), - 'DELETE FROM mytable ' - 'WHERE mytable.myid = :myid_1 ' - 'AND mytable.name = :name_1') + table1.delete() + .where(table1.c.myid == 7) + .where(table1.c.name == "somename"), + "DELETE FROM mytable " + "WHERE mytable.myid = :myid_1 " + "AND mytable.name = :name_1", + ) def test_where_empty(self): table1 = self.tables.mytable self.assert_compile( - table1.delete().where(and_()), - "DELETE FROM mytable" + table1.delete().where(and_()), "DELETE FROM mytable" ) self.assert_compile( - table1.delete().where(or_()), - "DELETE FROM mytable" + table1.delete().where(or_()), "DELETE FROM mytable" ) def test_prefix_with(self): table1 = self.tables.mytable - stmt = table1.delete().\ - prefix_with('A', 'B', dialect='mysql').\ - prefix_with('C', 'D') + stmt = ( + table1.delete() + .prefix_with("A", "B", dialect="mysql") + .prefix_with("C", "D") + ) - self.assert_compile(stmt, - 'DELETE C D FROM mytable') + self.assert_compile(stmt, "DELETE C D FROM mytable") - self.assert_compile(stmt, - 'DELETE A B C D FROM mytable', - dialect=mysql.dialect()) + self.assert_compile( + stmt, "DELETE A B C D FROM mytable", dialect=mysql.dialect() + ) def test_alias(self): table1 = self.tables.mytable - talias1 = table1.alias('t1') + talias1 = table1.alias("t1") stmt = delete(talias1).where(talias1.c.myid == 7) self.assert_compile( - stmt, - 'DELETE FROM mytable AS t1 WHERE t1.myid = :myid_1') + stmt, "DELETE FROM mytable AS t1 WHERE t1.myid = :myid_1" + ) def test_correlated(self): table1, table2 = self.tables.mytable, self.tables.myothertable # 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' - ')') + 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" + ")", + ) # 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' - ')') + 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" + ")", + ) class DeleteFromCompileTest( - _DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL): + _DeleteTestBase, fixtures.TablesTest, AssertsCompiledSQL +): # DELETE FROM is also tested by individual dialects since there is no # consistent syntax. here we use the StrSQLcompiler which has a fake # syntax. - __dialect__ = 'default_enhanced' + __dialect__ = "default_enhanced" def test_delete_extra_froms(self): table1, table2 = self.tables.mytable, self.tables.myothertable @@ -137,10 +162,15 @@ class DeleteFromCompileTest( def test_correlation_to_extra(self): table1, table2 = self.tables.mytable, self.tables.myothertable - stmt = table1.delete().where( - table1.c.myid == table2.c.otherid).where( - ~exists().where(table2.c.otherid == table1.c.myid). - where(table2.c.othername == 'x').correlate(table2) + stmt = ( + table1.delete() + .where(table1.c.myid == table2.c.otherid) + .where( + ~exists() + .where(table2.c.otherid == table1.c.myid) + .where(table2.c.othername == "x") + .correlate(table2) + ) ) self.assert_compile( @@ -154,10 +184,15 @@ class DeleteFromCompileTest( def test_dont_correlate_to_extra(self): table1, table2 = self.tables.mytable, self.tables.myothertable - stmt = table1.delete().where( - table1.c.myid == table2.c.otherid).where( - ~exists().where(table2.c.otherid == table1.c.myid). - where(table2.c.othername == 'x').correlate() + stmt = ( + table1.delete() + .where(table1.c.myid == table2.c.otherid) + .where( + ~exists() + .where(table2.c.otherid == table1.c.myid) + .where(table2.c.othername == "x") + .correlate() + ) ) self.assert_compile( @@ -172,16 +207,21 @@ class DeleteFromCompileTest( def test_autocorrelate_error(self): table1, table2 = self.tables.mytable, self.tables.myothertable - stmt = table1.delete().where( - table1.c.myid == table2.c.otherid).where( - ~exists().where(table2.c.otherid == table1.c.myid). - where(table2.c.othername == 'x') + stmt = ( + table1.delete() + .where(table1.c.myid == table2.c.otherid) + .where( + ~exists() + .where(table2.c.otherid == table1.c.myid) + .where(table2.c.othername == "x") + ) ) assert_raises_message( exc.InvalidRequestError, ".*returned no FROM clauses due to auto-correlation.*", - stmt.compile, dialect=default.StrCompileDialect() + stmt.compile, + dialect=default.StrCompileDialect(), ) @@ -190,56 +230,77 @@ class DeleteFromRoundTripTest(fixtures.TablesTest): @classmethod def define_tables(cls, metadata): - Table('mytable', metadata, - Column('myid', Integer), - Column('name', String(30)), - Column('description', String(50))) - Table('myothertable', metadata, - Column('otherid', Integer), - Column('othername', String(30))) - Table('users', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('name', String(30), nullable=False)) - Table('addresses', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('user_id', None, ForeignKey('users.id')), - Column('name', String(30), nullable=False), - Column('email_address', String(50), nullable=False)) - Table('dingalings', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('address_id', None, ForeignKey('addresses.id')), - Column('data', String(30))) - Table('update_w_default', metadata, - Column('id', Integer, primary_key=True), - Column('x', Integer), - Column('ycol', Integer, key='y'), - Column('data', String(30), onupdate=lambda: "hi")) + Table( + "mytable", + metadata, + Column("myid", Integer), + Column("name", String(30)), + Column("description", String(50)), + ) + Table( + "myothertable", + metadata, + Column("otherid", Integer), + Column("othername", String(30)), + ) + Table( + "users", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("name", String(30), nullable=False), + ) + Table( + "addresses", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("user_id", None, ForeignKey("users.id")), + Column("name", String(30), nullable=False), + Column("email_address", String(50), nullable=False), + ) + Table( + "dingalings", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("address_id", None, ForeignKey("addresses.id")), + Column("data", String(30)), + ) + Table( + "update_w_default", + metadata, + Column("id", Integer, primary_key=True), + Column("x", Integer), + Column("ycol", Integer, key="y"), + Column("data", String(30), onupdate=lambda: "hi"), + ) @classmethod def fixtures(cls): return dict( users=( - ('id', 'name'), - (7, 'jack'), - (8, 'ed'), - (9, 'fred'), - (10, 'chuck') + ("id", "name"), + (7, "jack"), + (8, "ed"), + (9, "fred"), + (10, "chuck"), ), addresses=( - ('id', 'user_id', 'name', 'email_address'), - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'ed@wood.com'), - (3, 8, 'x', 'ed@bettyboop.com'), - (4, 8, 'x', 'ed@lala.com'), - (5, 9, 'x', 'fred@fred.com') + ("id", "user_id", "name", "email_address"), + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "ed@wood.com"), + (3, 8, "x", "ed@bettyboop.com"), + (4, 8, "x", "ed@lala.com"), + (5, 9, "x", "fred@fred.com"), ), dingalings=( - ('id', 'address_id', 'data'), - (1, 2, 'ding 1/2'), - (2, 5, 'ding 2/5') + ("id", "address_id", "data"), + (1, 2, "ding 1/2"), + (2, 5, "ding 2/5"), ), ) @@ -252,14 +313,14 @@ class DeleteFromRoundTripTest(fixtures.TablesTest): conn.execute(dingalings.delete()) # fk violation otherwise conn.execute( - addresses.delete(). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed') + addresses.delete() + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (5, 9, 'x', 'fred@fred.com') + (1, 7, "x", "jack@bean.com"), + (5, 9, "x", "fred@fred.com"), ] self._assert_table(addresses, expected) @@ -270,14 +331,13 @@ class DeleteFromRoundTripTest(fixtures.TablesTest): dingalings = self.tables.dingalings testing.db.execute( - dingalings.delete(). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed'). - where(addresses.c.id == dingalings.c.address_id)) - - expected = [ - (2, 5, 'ding 2/5') - ] + dingalings.delete() + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + .where(addresses.c.id == dingalings.c.address_id) + ) + + expected = [(2, 5, "ding 2/5")] self._assert_table(dingalings, expected) @testing.requires.delete_from @@ -289,16 +349,13 @@ class DeleteFromRoundTripTest(fixtures.TablesTest): conn.execute(dingalings.delete()) # fk violation otherwise a1 = addresses.alias() conn.execute( - addresses.delete(). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed'). - where(a1.c.id == addresses.c.id) + addresses.delete() + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + .where(a1.c.id == addresses.c.id) ) - expected = [ - (1, 7, 'x', 'jack@bean.com'), - (5, 9, 'x', 'fred@fred.com') - ] + expected = [(1, 7, "x", "jack@bean.com"), (5, 9, "x", "fred@fred.com")] self._assert_table(addresses, expected) @testing.requires.delete_from @@ -309,14 +366,13 @@ class DeleteFromRoundTripTest(fixtures.TablesTest): d1 = dingalings.alias() testing.db.execute( - delete(d1). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed'). - where(addresses.c.id == d1.c.address_id)) - - expected = [ - (2, 5, 'ding 2/5') - ] + delete(d1) + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + .where(addresses.c.id == d1.c.address_id) + ) + + expected = [(2, 5, "ding 2/5")] self._assert_table(dingalings, expected) def _assert_table(self, table, expected): diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py index 6fba7519c..b775df740 100644 --- a/test/sql/test_functions.py +++ b/test/sql/test_functions.py @@ -1,8 +1,24 @@ from sqlalchemy.testing import eq_, is_ import datetime -from sqlalchemy import func, select, Integer, literal, DateTime, Table, \ - Column, Sequence, MetaData, extract, Date, String, bindparam, \ - literal_column, ARRAY, Numeric, Boolean +from sqlalchemy import ( + func, + select, + Integer, + literal, + DateTime, + Table, + Column, + Sequence, + MetaData, + extract, + Date, + String, + bindparam, + literal_column, + ARRAY, + Numeric, + Boolean, +) from sqlalchemy.sql import table, column from sqlalchemy import sql, util from sqlalchemy.sql.compiler import BIND_TEMPLATES @@ -16,31 +32,35 @@ from sqlalchemy.testing import fixtures, AssertsCompiledSQL, engines from sqlalchemy.dialects import sqlite, postgresql, mysql, oracle from sqlalchemy.testing import assert_raises_message, assert_raises -table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), - ) +table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), +) class CompileTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def tear_down(self): functions._registry.clear() def test_compile(self): - for dialect in all_dialects(exclude=('sybase', )): + for dialect in all_dialects(exclude=("sybase",)): bindtemplate = BIND_TEMPLATES[dialect.paramstyle] - self.assert_compile(func.current_timestamp(), - "CURRENT_TIMESTAMP", dialect=dialect) + self.assert_compile( + func.current_timestamp(), "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) + if dialect.name in ("firebird",): + self.assert_compile( + func.nosuchfunction(), "nosuchfunction", dialect=dialect + ) else: - self.assert_compile(func.nosuchfunction(), - "nosuchfunction()", dialect=dialect) + self.assert_compile( + func.nosuchfunction(), "nosuchfunction()", dialect=dialect + ) # test generic function compile class fake_func(GenericFunction): @@ -50,15 +70,17 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): GenericFunction.__init__(self, arg, **kwargs) self.assert_compile( - fake_func('foo'), - "fake_func(%s)" % - bindtemplate % {'name': 'fake_func_1', 'position': 1}, - dialect=dialect) + fake_func("foo"), + "fake_func(%s)" + % bindtemplate + % {"name": "fake_func_1", "position": 1}, + dialect=dialect, + ) def test_use_labels(self): - self.assert_compile(select([func.foo()], use_labels=True), - "SELECT foo() AS foo_1" - ) + self.assert_compile( + select([func.foo()], use_labels=True), "SELECT foo() AS foo_1" + ) def test_underscores(self): self.assert_compile(func.if_(), "if()") @@ -67,10 +89,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): assert isinstance(func.now().type, sqltypes.DateTime) for ret, dialect in [ - ('CURRENT_TIMESTAMP', sqlite.dialect()), - ('now()', postgresql.dialect()), - ('now()', mysql.dialect()), - ('CURRENT_TIMESTAMP', oracle.dialect()) + ("CURRENT_TIMESTAMP", sqlite.dialect()), + ("now()", postgresql.dialect()), + ("now()", mysql.dialect()), + ("CURRENT_TIMESTAMP", oracle.dialect()), ]: self.assert_compile(func.now(), ret, dialect=dialect) @@ -79,54 +101,55 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): assert isinstance(func.random(type_=Integer).type, Integer) for ret, dialect in [ - ('random()', sqlite.dialect()), - ('random()', postgresql.dialect()), - ('rand()', mysql.dialect()), - ('random()', oracle.dialect()) + ("random()", sqlite.dialect()), + ("random()", postgresql.dialect()), + ("rand()", mysql.dialect()), + ("random()", oracle.dialect()), ]: self.assert_compile(func.random(), ret, dialect=dialect) def test_cube_operators(self): - t = table('t', column('value'), - column('x'), column('y'), column('z'), column('q')) + t = table( + "t", + column("value"), + column("x"), + column("y"), + column("z"), + column("q"), + ) stmt = select([func.sum(t.c.value)]) self.assert_compile( stmt.group_by(func.cube(t.c.x, t.c.y)), - "SELECT sum(t.value) AS sum_1 FROM t GROUP BY CUBE(t.x, t.y)" + "SELECT sum(t.value) AS sum_1 FROM t GROUP BY CUBE(t.x, t.y)", ) self.assert_compile( stmt.group_by(func.rollup(t.c.x, t.c.y)), - "SELECT sum(t.value) AS sum_1 FROM t GROUP BY ROLLUP(t.x, t.y)" + "SELECT sum(t.value) AS sum_1 FROM t GROUP BY ROLLUP(t.x, t.y)", ) self.assert_compile( - stmt.group_by( - func.grouping_sets(t.c.x, t.c.y) - ), + stmt.group_by(func.grouping_sets(t.c.x, t.c.y)), "SELECT sum(t.value) AS sum_1 FROM t " - "GROUP BY GROUPING SETS(t.x, t.y)" + "GROUP BY GROUPING SETS(t.x, t.y)", ) self.assert_compile( stmt.group_by( func.grouping_sets( - sql.tuple_(t.c.x, t.c.y), - sql.tuple_(t.c.z, t.c.q), + sql.tuple_(t.c.x, t.c.y), sql.tuple_(t.c.z, t.c.q) ) ), "SELECT sum(t.value) AS sum_1 FROM t GROUP BY " - "GROUPING SETS((t.x, t.y), (t.z, t.q))" + "GROUPING SETS((t.x, t.y), (t.z, t.q))", ) def test_generic_annotation(self): - fn = func.coalesce('x', 'y')._annotate({"foo": "bar"}) - self.assert_compile( - fn, "coalesce(:coalesce_1, :coalesce_2)" - ) + fn = func.coalesce("x", "y")._annotate({"foo": "bar"}) + self.assert_compile(fn, "coalesce(:coalesce_1, :coalesce_2)") def test_custom_default_namespace(self): class myfunc(GenericFunction): @@ -160,6 +183,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def cls1(pk_name): class myfunc(GenericFunction): package = pk_name + return myfunc f1 = cls1("mypackage") @@ -170,15 +194,14 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def test_custom_name(self): class MyFunction(GenericFunction): - name = 'my_func' + name = "my_func" def __init__(self, *args): args = args + (3,) super(MyFunction, self).__init__(*args) self.assert_compile( - func.my_func(1, 2), - "my_func(:my_func_1, :my_func_2, :my_func_3)" + func.my_func(1, 2), "my_func(:my_func_1, :my_func_2, :my_func_3)" ) def test_custom_registered_identifier(self): @@ -197,120 +220,109 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): type = Integer identifier = "buf3" - self.assert_compile( - func.geo.buf1(), - "BufferOne()" - ) - self.assert_compile( - func.buf2(), - "BufferTwo()" - ) - self.assert_compile( - func.buf3(), - "BufferThree()" - ) + self.assert_compile(func.geo.buf1(), "BufferOne()") + self.assert_compile(func.buf2(), "BufferTwo()") + self.assert_compile(func.buf3(), "BufferThree()") def test_custom_args(self): class myfunc(GenericFunction): pass self.assert_compile( - myfunc(1, 2, 3), - "myfunc(:myfunc_1, :myfunc_2, :myfunc_3)" + myfunc(1, 2, 3), "myfunc(:myfunc_1, :myfunc_2, :myfunc_3)" ) def test_namespacing_conflicts(self): - self.assert_compile(func.text('foo'), 'text(:text_1)') + self.assert_compile(func.text("foo"), "text(:text_1)") def test_generic_count(self): assert isinstance(func.count().type, sqltypes.Integer) - self.assert_compile(func.count(), 'count(*)') - self.assert_compile(func.count(1), 'count(:count_1)') - c = column('abc') - self.assert_compile(func.count(c), 'count(abc)') + self.assert_compile(func.count(), "count(*)") + self.assert_compile(func.count(1), "count(:count_1)") + c = column("abc") + self.assert_compile(func.count(c), "count(abc)") def test_ansi_functions_with_args(self): - ct = func.current_timestamp('somearg') + ct = func.current_timestamp("somearg") self.assert_compile(ct, "CURRENT_TIMESTAMP(:current_timestamp_1)") def test_char_length_fixed_args(self): - assert_raises( - TypeError, - func.char_length, 'a', 'b' - ) - assert_raises( - TypeError, - func.char_length - ) + assert_raises(TypeError, func.char_length, "a", "b") + assert_raises(TypeError, func.char_length) def test_return_type_detection(self): 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), + ( + (datetime.date(2007, 10, 5), datetime.date(2005, 10, 15)), + sqltypes.Date, + ), ((3, 5), sqltypes.Integer), - ((decimal.Decimal(3), decimal.Decimal(5)), - sqltypes.Numeric), + ((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.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_) + assert isinstance(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), - ) + table1 = table("mytable", column("myid", Integer)) - table2 = table( - 'myothertable', - column('otherid', Integer), - ) + table2 = table("myothertable", column("otherid", Integer)) # 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") + 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", + ) # test it in a SELECT - self.assert_compile(select( - [func.count(table1.c.myid)]), - "SELECT count(mytable.myid) AS count_1 FROM mytable") + 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)]), - "SELECT foo.bar.lala(mytable.myid) AS lala_1 FROM mytable") + 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") + self.assert_compile( + select([func.foo.bar.lala(12)]), + "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)") + 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 @@ -322,33 +334,40 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): 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) - )]) - - 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" - ) - - 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 " + "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", + ) + + 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 " "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) @@ -359,263 +378,253 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def test_select_method_one(self): expr = func.rows("foo") - self.assert_compile( - expr.select(), - "SELECT rows(:rows_2) AS rows_1" - ) + self.assert_compile(expr.select(), "SELECT rows(:rows_2) AS rows_1") def test_alias_method_one(self): expr = func.rows("foo") - self.assert_compile( - expr.alias(), - "rows(:rows_1)" - ) + self.assert_compile(expr.alias(), "rows(:rows_1)") def test_select_method_two(self): expr = func.rows("foo") self.assert_compile( - select(['*']).select_from(expr.select()), - "SELECT * FROM (SELECT rows(:rows_2) AS rows_1)" + select(["*"]).select_from(expr.select()), + "SELECT * FROM (SELECT rows(:rows_2) AS rows_1)", ) def test_select_method_three(self): expr = func.rows("foo") self.assert_compile( - select([column('foo')]).select_from(expr), - "SELECT foo FROM rows(:rows_1)" + select([column("foo")]).select_from(expr), + "SELECT foo FROM rows(:rows_1)", ) def test_alias_method_two(self): expr = func.rows("foo") self.assert_compile( - select(['*']).select_from(expr.alias('bar')), - "SELECT * FROM rows(:rows_1) AS bar" + select(["*"]).select_from(expr.alias("bar")), + "SELECT * FROM rows(:rows_1) AS bar", ) def test_alias_method_columns(self): - expr = func.rows("foo").alias('bar') + expr = func.rows("foo").alias("bar") # this isn't very useful but is the old behavior # prior to #2974. # testing here that the expression exports its column # list in a way that at least doesn't break. self.assert_compile( - select([expr]), - "SELECT bar.rows_1 FROM rows(:rows_2) AS bar" + select([expr]), "SELECT bar.rows_1 FROM rows(:rows_2) AS bar" ) def test_alias_method_columns_two(self): - expr = func.rows("foo").alias('bar') + expr = func.rows("foo").alias("bar") assert len(expr.c) def test_funcfilter_empty(self): - self.assert_compile( - func.count(1).filter(), - "count(:count_1)" - ) + self.assert_compile(func.count(1).filter(), "count(:count_1)") def test_funcfilter_criterion(self): self.assert_compile( - func.count(1).filter( - table1.c.name != None # noqa - ), - "count(:count_1) FILTER (WHERE mytable.name IS NOT NULL)" + func.count(1).filter(table1.c.name != None), # noqa + "count(:count_1) FILTER (WHERE mytable.name IS NOT NULL)", ) def test_funcfilter_compound_criterion(self): self.assert_compile( func.count(1).filter( - table1.c.name == None, # noqa - table1.c.myid > 0 + table1.c.name == None, table1.c.myid > 0 # noqa ), "count(:count_1) FILTER (WHERE mytable.name IS NULL AND " - "mytable.myid > :myid_1)" + "mytable.myid > :myid_1)", ) def test_funcfilter_label(self): self.assert_compile( - select([func.count(1).filter( - table1.c.description != None # noqa - ).label('foo')]), + select( + [ + func.count(1) + .filter(table1.c.description != None) # noqa + .label("foo") + ] + ), "SELECT count(:count_1) FILTER (WHERE mytable.description " - "IS NOT NULL) AS foo FROM mytable" + "IS NOT NULL) AS foo FROM mytable", ) def test_funcfilter_fromobj_fromfunc(self): # test from_obj generation. # from func: self.assert_compile( - select([ - func.max(table1.c.name).filter( - literal_column('description') != None # noqa - ) - ]), + select( + [ + func.max(table1.c.name).filter( + literal_column("description") != None # noqa + ) + ] + ), "SELECT max(mytable.name) FILTER (WHERE description " - "IS NOT NULL) AS anon_1 FROM mytable" + "IS NOT NULL) AS anon_1 FROM mytable", ) def test_funcfilter_fromobj_fromcriterion(self): # from criterion: self.assert_compile( - select([ - func.count(1).filter( - table1.c.name == 'name' - ) - ]), + select([func.count(1).filter(table1.c.name == "name")]), "SELECT count(:count_1) FILTER (WHERE mytable.name = :name_1) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) def test_funcfilter_chaining(self): # test chaining: self.assert_compile( - select([ - func.count(1).filter( - table1.c.name == 'name' - ).filter( - table1.c.description == 'description' - ) - ]), + select( + [ + func.count(1) + .filter(table1.c.name == "name") + .filter(table1.c.description == "description") + ] + ), "SELECT count(:count_1) FILTER (WHERE " "mytable.name = :name_1 AND mytable.description = :description_1) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) def test_funcfilter_windowing_orderby(self): # test filtered windowing: self.assert_compile( - select([ - func.rank().filter( - table1.c.name > 'foo' - ).over( - order_by=table1.c.name - ) - ]), + select( + [ + func.rank() + .filter(table1.c.name > "foo") + .over(order_by=table1.c.name) + ] + ), "SELECT rank() FILTER (WHERE mytable.name > :name_1) " - "OVER (ORDER BY mytable.name) AS anon_1 FROM mytable" + "OVER (ORDER BY mytable.name) AS anon_1 FROM mytable", ) def test_funcfilter_windowing_orderby_partitionby(self): self.assert_compile( - select([ - func.rank().filter( - table1.c.name > 'foo' - ).over( - order_by=table1.c.name, - partition_by=['description'] - ) - ]), + select( + [ + func.rank() + .filter(table1.c.name > "foo") + .over(order_by=table1.c.name, partition_by=["description"]) + ] + ), "SELECT rank() FILTER (WHERE mytable.name > :name_1) " "OVER (PARTITION BY mytable.description ORDER BY mytable.name) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) def test_funcfilter_windowing_range(self): self.assert_compile( - select([ - func.rank().filter( - table1.c.name > 'foo' - ).over( - range_=(1, 5), - partition_by=['description'] - ) - ]), + select( + [ + func.rank() + .filter(table1.c.name > "foo") + .over(range_=(1, 5), partition_by=["description"]) + ] + ), "SELECT rank() FILTER (WHERE mytable.name > :name_1) " "OVER (PARTITION BY mytable.description RANGE BETWEEN :param_1 " "FOLLOWING AND :param_2 FOLLOWING) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) def test_funcfilter_windowing_rows(self): self.assert_compile( - select([ - func.rank().filter( - table1.c.name > 'foo' - ).over( - rows=(1, 5), - partition_by=['description'] - ) - ]), + select( + [ + func.rank() + .filter(table1.c.name > "foo") + .over(rows=(1, 5), partition_by=["description"]) + ] + ), "SELECT rank() FILTER (WHERE mytable.name > :name_1) " "OVER (PARTITION BY mytable.description ROWS BETWEEN :param_1 " "FOLLOWING AND :param_2 FOLLOWING) " - "AS anon_1 FROM mytable" + "AS anon_1 FROM mytable", ) def test_funcfilter_within_group(self): - stmt = select([ - table1.c.myid, - func.percentile_cont(0.5).within_group( - table1.c.name - ) - ]) + stmt = select( + [ + table1.c.myid, + func.percentile_cont(0.5).within_group(table1.c.name), + ] + ) self.assert_compile( stmt, "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name) " "AS anon_1 " "FROM mytable", - {'percentile_cont_1': 0.5} + {"percentile_cont_1": 0.5}, ) def test_funcfilter_within_group_multi(self): - stmt = select([ - table1.c.myid, - func.percentile_cont(0.5).within_group( - table1.c.name, table1.c.description - ) - ]) + stmt = select( + [ + table1.c.myid, + func.percentile_cont(0.5).within_group( + table1.c.name, table1.c.description + ), + ] + ) self.assert_compile( stmt, "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name, mytable.description) " "AS anon_1 " "FROM mytable", - {'percentile_cont_1': 0.5} + {"percentile_cont_1": 0.5}, ) def test_funcfilter_within_group_desc(self): - stmt = select([ - table1.c.myid, - func.percentile_cont(0.5).within_group( - table1.c.name.desc() - ) - ]) + stmt = select( + [ + table1.c.myid, + func.percentile_cont(0.5).within_group(table1.c.name.desc()), + ] + ) self.assert_compile( stmt, "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name DESC) " "AS anon_1 " "FROM mytable", - {'percentile_cont_1': 0.5} + {"percentile_cont_1": 0.5}, ) def test_funcfilter_within_group_w_over(self): - stmt = select([ - table1.c.myid, - func.percentile_cont(0.5).within_group( - table1.c.name.desc() - ).over(partition_by=table1.c.description) - ]) + stmt = select( + [ + table1.c.myid, + func.percentile_cont(0.5) + .within_group(table1.c.name.desc()) + .over(partition_by=table1.c.description), + ] + ) self.assert_compile( stmt, "SELECT mytable.myid, percentile_cont(:percentile_cont_1) " "WITHIN GROUP (ORDER BY mytable.name DESC) " "OVER (PARTITION BY mytable.description) AS anon_1 " "FROM mytable", - {'percentile_cont_1': 0.5} + {"percentile_cont_1": 0.5}, ) def test_incorrect_none_type(self): class MissingType(FunctionElement): - name = 'mt' + name = "mt" type = None assert_raises_message( TypeError, "Object None associated with '.type' attribute is " "not a TypeEngine class or object", - MissingType().compile + MissingType().compile, ) def test_as_comparison(self): @@ -624,21 +633,24 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): is_(fn.type._type_affinity, Boolean) self.assert_compile( - fn.left, ":substring_1", - checkparams={'substring_1': 'foo'}) + fn.left, ":substring_1", checkparams={"substring_1": "foo"} + ) self.assert_compile( - fn.right, ":substring_1", - checkparams={'substring_1': 'foobar'}) + fn.right, ":substring_1", checkparams={"substring_1": "foobar"} + ) self.assert_compile( - fn, "substring(:substring_1, :substring_2)", - checkparams={"substring_1": "foo", "substring_2": "foobar"}) + fn, + "substring(:substring_1, :substring_2)", + checkparams={"substring_1": "foo", "substring_2": "foobar"}, + ) def test_as_comparison_annotate(self): fn = func.foobar("x", "y", "q", "p", "r").as_comparison(2, 5) from sqlalchemy.sql import annotation + fn_annotated = annotation._deep_annotate(fn, {"token": "yes"}) eq_(fn.left._annotations, {}) @@ -646,15 +658,21 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def test_as_comparison_many_argument(self): - fn = func.some_comparison("x", "y", "z", "p", "q", "r").as_comparison(2, 5) + fn = func.some_comparison("x", "y", "z", "p", "q", "r").as_comparison( + 2, 5 + ) is_(fn.type._type_affinity, Boolean) self.assert_compile( - fn.left, ":some_comparison_1", - checkparams={"some_comparison_1": "y"}) + fn.left, + ":some_comparison_1", + checkparams={"some_comparison_1": "y"}, + ) self.assert_compile( - fn.right, ":some_comparison_1", - checkparams={"some_comparison_1": "q"}) + fn.right, + ":some_comparison_1", + checkparams={"some_comparison_1": "q"}, + ) from sqlalchemy.sql import visitors @@ -667,9 +685,14 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): ":some_comparison_3, " ":some_comparison_4, :some_comparison_5, :some_comparison_6)", checkparams={ - 'some_comparison_1': 'x', 'some_comparison_2': 'y', - 'some_comparison_3': 'z', 'some_comparison_4': 'p', - 'some_comparison_5': 'q', 'some_comparison_6': 'r'}) + "some_comparison_1": "x", + "some_comparison_2": "y", + "some_comparison_3": "z", + "some_comparison_4": "p", + "some_comparison_5": "q", + "some_comparison_6": "r", + }, + ) self.assert_compile( fn_2, @@ -677,27 +700,30 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): ":some_comparison_3, " ":some_comparison_4, ABC, :some_comparison_5)", checkparams={ - 'some_comparison_1': 'x', 'some_comparison_2': 'y', - 'some_comparison_3': 'z', 'some_comparison_4': 'p', - 'some_comparison_5': 'r'} + "some_comparison_1": "x", + "some_comparison_2": "y", + "some_comparison_3": "z", + "some_comparison_4": "p", + "some_comparison_5": "r", + }, ) class ReturnTypeTest(AssertsCompiledSQL, fixtures.TestBase): - def test_array_agg(self): - expr = func.array_agg(column('data', Integer)) + expr = func.array_agg(column("data", Integer)) is_(expr.type._type_affinity, ARRAY) is_(expr.type.item_type._type_affinity, Integer) def test_array_agg_array_datatype(self): - expr = func.array_agg(column('data', ARRAY(Integer))) + expr = func.array_agg(column("data", ARRAY(Integer))) is_(expr.type._type_affinity, ARRAY) is_(expr.type.item_type._type_affinity, Integer) def test_array_agg_array_literal_implicit_type(self): from sqlalchemy.dialects.postgresql import array, ARRAY as PG_ARRAY - expr = array([column('data', Integer), column('d2', Integer)]) + + expr = array([column("data", Integer), column("d2", Integer)]) assert isinstance(expr.type, PG_ARRAY) @@ -707,54 +733,50 @@ class ReturnTypeTest(AssertsCompiledSQL, fixtures.TestBase): is_(agg_expr.type.item_type._type_affinity, Integer) self.assert_compile( - agg_expr, - "array_agg(ARRAY[data, d2])", - dialect="postgresql" + agg_expr, "array_agg(ARRAY[data, d2])", dialect="postgresql" ) def test_array_agg_array_literal_explicit_type(self): from sqlalchemy.dialects.postgresql import array - expr = array([column('data', Integer), column('d2', Integer)]) + + expr = array([column("data", Integer), column("d2", Integer)]) agg_expr = func.array_agg(expr, type_=ARRAY(Integer)) is_(agg_expr.type._type_affinity, ARRAY) is_(agg_expr.type.item_type._type_affinity, Integer) self.assert_compile( - agg_expr, - "array_agg(ARRAY[data, d2])", - dialect="postgresql" + agg_expr, "array_agg(ARRAY[data, d2])", dialect="postgresql" ) def test_mode(self): - expr = func.mode(0.5).within_group( - column('data', Integer).desc()) + expr = func.mode(0.5).within_group(column("data", Integer).desc()) is_(expr.type._type_affinity, Integer) def test_percentile_cont(self): - expr = func.percentile_cont(0.5).within_group(column('data', Integer)) + expr = func.percentile_cont(0.5).within_group(column("data", Integer)) is_(expr.type._type_affinity, Integer) def test_percentile_cont_array(self): expr = func.percentile_cont(0.5, 0.7).within_group( - column('data', Integer)) + column("data", Integer) + ) is_(expr.type._type_affinity, ARRAY) is_(expr.type.item_type._type_affinity, Integer) def test_percentile_cont_array_desc(self): expr = func.percentile_cont(0.5, 0.7).within_group( - column('data', Integer).desc()) + column("data", Integer).desc() + ) is_(expr.type._type_affinity, ARRAY) is_(expr.type.item_type._type_affinity, Integer) def test_cume_dist(self): - expr = func.cume_dist(0.5).within_group( - column('data', Integer).desc()) + expr = func.cume_dist(0.5).within_group(column("data", Integer).desc()) is_(expr.type._type_affinity, Numeric) def test_percent_rank(self): - expr = func.percent_rank(0.5).within_group( - column('data', Integer)) + expr = func.percent_rank(0.5).within_group(column("data", Integer)) is_(expr.type._type_affinity, Numeric) @@ -790,13 +812,13 @@ class ExecuteTest(fixtures.TestBase): f = func.foo() eq_(f._execution_options, {}) - f = f.execution_options(foo='bar') - eq_(f._execution_options, {'foo': 'bar'}) + f = f.execution_options(foo="bar") + eq_(f._execution_options, {"foo": "bar"}) s = f.select() - eq_(s._execution_options, {'foo': 'bar'}) + eq_(s._execution_options, {"foo": "bar"}) - ret = testing.db.execute(func.now().execution_options(foo='bar')) - eq_(ret.context.execution_options, {'foo': 'bar'}) + ret = testing.db.execute(func.now().execution_options(foo="bar")) + eq_(ret.context.execution_options, {"foo": "bar"}) ret.close() @engines.close_first @@ -809,67 +831,83 @@ class ExecuteTest(fixtures.TestBase): """ meta = self.metadata - t = Table('t1', meta, - 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") - ) + t = Table( + "t1", + meta, + 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"), + ) meta.create_all() t.insert(values=dict(value=func.length("one"))).execute() - assert t.select().execute().first()['value'] == 3 + assert t.select().execute().first()["value"] == 3 t.update(values=dict(value=func.length("asfda"))).execute() - assert t.select().execute().first()['value'] == 5 + assert t.select().execute().first()["value"] == 5 r = t.insert(values=dict(value=func.length("sfsaafsda"))).execute() id = r.inserted_primary_key[0] - assert t.select(t.c.id == id).execute().first()['value'] == 9 + 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 + assert t.select().execute().first()["value"] == 4 t2.insert().execute() t2.insert(values=dict(value=func.length("one"))).execute() - t2.insert(values=dict(value=func.length("asfda") + -19)).\ - execute(stuff="hi") + t2.insert(values=dict(value=func.length("asfda") + -19)).execute( + stuff="hi" + ) res = exec_sorted(select([t2.c.value, t2.c.stuff])) - eq_(res, [(-14, 'hi'), (3, None), (7, None)]) + eq_(res, [(-14, "hi"), (3, None), (7, None)]) - t2.update(values=dict(value=func.length("asdsafasd"))).\ - execute(stuff="some stuff") - assert select([t2.c.value, t2.c.stuff]).execute().fetchall() == \ - [(9, "some stuff"), (9, "some stuff"), - (9, "some stuff")] + t2.update(values=dict(value=func.length("asdsafasd"))).execute( + stuff="some stuff" + ) + assert select([t2.c.value, t2.c.stuff]).execute().fetchall() == [ + (9, "some stuff"), + (9, "some stuff"), + (9, "some stuff"), + ] t2.delete().execute() t2.insert(values=dict(value=func.length("one") + 8)).execute() - assert t2.select().execute().first()['value'] == 11 + assert t2.select().execute().first()["value"] == 11 t2.update(values=dict(value=func.length("asfda"))).execute() eq_( select([t2.c.value, t2.c.stuff]).execute().first(), - (5, "thisisstuff") + (5, "thisisstuff"), ) - t2.update(values={t2.c.value: func.length("asfdaasdf"), - t2.c.stuff: "foo"}).execute() - eq_(select([t2.c.value, t2.c.stuff]).execute().first(), - (9, "foo") - ) + t2.update( + values={t2.c.value: func.length("asfdaasdf"), t2.c.stuff: "foo"} + ).execute() + eq_(select([t2.c.value, t2.c.stuff]).execute().first(), (9, "foo")) - @testing.fails_on_everything_except('postgresql') + @testing.fails_on_everything_except("postgresql") def test_as_from(self): # TODO: shouldn't this work on oracle too ? x = func.current_date(bind=testing.db).execute().scalar() 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() + w = select( + ["*"], from_obj=[func.current_date(bind=testing.db)] + ).scalar() assert x == y == z == w @@ -881,28 +919,30 @@ class ExecuteTest(fixtures.TestBase): def execute(field): return testing.db.execute(select([extract(field, date)])).scalar() - assert execute('year') == 2010 - assert execute('month') == 5 - assert execute('day') == 1 + assert execute("year") == 2010 + assert execute("month") == 5 + assert execute("day") == 1 date = datetime.datetime(2010, 5, 1, 12, 11, 10) - assert execute('year') == 2010 - assert execute('month') == 5 - assert execute('day') == 1 + assert execute("year") == 2010 + assert execute("month") == 5 + assert execute("day") == 1 def test_extract_expression(self): meta = MetaData(testing.db) - table = Table('test', meta, - Column('dt', DateTime), - Column('d', Date)) + table = Table("test", meta, Column("dt", DateTime), Column("d", Date)) meta.create_all() try: table.insert().execute( - {'dt': datetime.datetime(2010, 5, 1, 12, 11, 10), - 'd': datetime.date(2010, 5, 1)}) - rs = select([extract('year', table.c.dt), - extract('month', table.c.d)]).execute() + { + "dt": datetime.datetime(2010, 5, 1, 12, 11, 10), + "d": datetime.date(2010, 5, 1), + } + ) + rs = select( + [extract("year", table.c.dt), extract("month", table.c.d)] + ).execute() row = rs.first() assert row[0] == 2010 assert row[1] == 5 @@ -914,5 +954,6 @@ class ExecuteTest(fixtures.TestBase): def exec_sorted(statement, *args, **kw): """Executes a statement and returns a sorted list plain tuple rows.""" - return sorted([tuple(row) - for row in statement.execute(*args, **kw).fetchall()]) + 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 8b1436879..1d064dd3a 100644 --- a/test/sql/test_generative.py +++ b/test/sql/test_generative.py @@ -1,21 +1,45 @@ from sqlalchemy.sql import table, column, ClauseElement, operators 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, literal_column -from sqlalchemy.testing import fixtures, AssertsExecutionResults, \ - AssertsCompiledSQL +from sqlalchemy import ( + func, + select, + Integer, + Table, + Column, + MetaData, + extract, + String, + bindparam, + tuple_, + and_, + union, + text, + case, + ForeignKey, + literal_column, +) +from sqlalchemy.testing import ( + fixtures, + AssertsExecutionResults, + AssertsCompiledSQL, +) from sqlalchemy import testing -from sqlalchemy.sql.visitors import ClauseVisitor, CloningVisitor, \ - cloned_traverse, ReplacingCloningVisitor +from sqlalchemy.sql.visitors import ( + ClauseVisitor, + CloningVisitor, + cloned_traverse, + ReplacingCloningVisitor, +) from sqlalchemy.sql import visitors from sqlalchemy import exc from sqlalchemy.sql import util as sql_util -from sqlalchemy.testing import (eq_, - is_, - is_not_, - assert_raises, - assert_raises_message) +from sqlalchemy.testing import ( + eq_, + is_, + is_not_, + assert_raises, + assert_raises_message, +) A = B = t1 = t2 = t3 = table1 = table2 = table3 = table4 = None @@ -33,7 +57,7 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): # define deep equality semantics as well as deep # identity semantics. class A(ClauseElement): - __visit_name__ = 'a' + __visit_name__ = "a" def __init__(self, expr): self.expr = expr @@ -53,7 +77,7 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): return "A(%s)" % repr(self.expr) class B(ClauseElement): - __visit_name__ = 'b' + __visit_name__ = "b" def __init__(self, *items): self.items = items @@ -93,8 +117,9 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): a1 = A("expr1") 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")) + struct3 = B( + a1, A("expr2"), B(A("expr1b"), A("expr2bmodified")), A("expr3") + ) assert a1.is_other(a1) assert struct.is_other(struct) @@ -104,11 +129,11 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): assert not struct.is_other(struct3) def test_clone(self): - struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) + struct = B( + A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3") + ) class Vis(CloningVisitor): - def visit_a(self, a): pass @@ -121,11 +146,11 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): assert not struct.is_other(s2) def test_no_clone(self): - struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) + struct = B( + A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3") + ) class Vis(ClauseVisitor): - def visit_a(self, a): pass @@ -139,7 +164,8 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): def test_clone_anon_label(self): from sqlalchemy.sql.elements import Grouping - c1 = Grouping(literal_column('q')) + + c1 = Grouping(literal_column("q")) s1 = select([c1]) class Vis(CloningVisitor): @@ -151,15 +177,23 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): eq_(list(s2.inner_columns)[0].anon_label, c1.anon_label) def test_change_in_place(self): - struct = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2b")), A("expr3")) - struct2 = B(A("expr1"), A("expr2modified"), B(A("expr1b"), - A("expr2b")), A("expr3")) - struct3 = B(A("expr1"), A("expr2"), B(A("expr1b"), - A("expr2bmodified")), A("expr3")) + struct = B( + A("expr1"), A("expr2"), B(A("expr1b"), A("expr2b")), A("expr3") + ) + struct2 = B( + A("expr1"), + A("expr2modified"), + B(A("expr1b"), A("expr2b")), + A("expr3"), + ) + struct3 = B( + A("expr1"), + A("expr2"), + B(A("expr1b"), A("expr2bmodified")), + A("expr3"), + ) class Vis(CloningVisitor): - def visit_a(self, a): if a.expr == "expr2": a.expr = "expr2modified" @@ -174,7 +208,6 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): assert struct2 == s2 class Vis2(CloningVisitor): - def visit_a(self, a): if a.expr == "expr2b": a.expr = "expr2bmodified" @@ -194,9 +227,9 @@ class TraversalTest(fixtures.TestBase, AssertsExecutionResults): class CustomObj(Column): pass - assert CustomObj.__visit_name__ == Column.__visit_name__ == 'column' + assert CustomObj.__visit_name__ == Column.__visit_name__ == "column" - foo, bar = CustomObj('foo', String), CustomObj('bar', String) + foo, bar = CustomObj("foo", String), CustomObj("bar", String) bin = foo == bar set(ClauseVisitor().iterate(bin)) assert set(ClauseVisitor().iterate(bin)) == set([foo, bar, bin]) @@ -212,19 +245,13 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): def visit(binary, l, r): canary.append((binary.operator, l, r)) print(binary.operator, l, r) + sql_util.visit_binary_product(visit, expr) - eq_( - canary, expected - ) + eq_(canary, expected) def test_basic(self): a, b = column("a"), column("b") - self._assert_traversal( - a == b, - [ - (operators.eq, a, b) - ] - ) + self._assert_traversal(a == b, [(operators.eq, a, b)]) def test_with_tuples(self): a, b, c, d, b1, b1a, b1b, e, f = ( @@ -236,11 +263,9 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): column("b1a"), column("b1b"), column("e"), - column("f") + column("f"), ) - expr = tuple_( - a, b, b1 == tuple_(b1a, b1b == d), c - ) > tuple_( + expr = tuple_(a, b, b1 == tuple_(b1a, b1b == d), c) > tuple_( func.go(e + f) ) self._assert_traversal( @@ -253,8 +278,8 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): (operators.eq, b1, b1a), (operators.eq, b1b, d), (operators.gt, c, e), - (operators.gt, c, f) - ] + (operators.gt, c, f), + ], ) def test_composed(self): @@ -267,13 +292,7 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): column("j"), column("r"), ) - expr = and_( - (a + b) == q + func.sum(e + f), - and_( - j == r, - f == q - ) - ) + expr = and_((a + b) == q + func.sum(e + f), and_(j == r, f == q)) self._assert_traversal( expr, [ @@ -285,7 +304,7 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): (operators.eq, b, f), (operators.eq, j, r), (operators.eq, f, q), - ] + ], ) def test_subquery(self): @@ -293,11 +312,7 @@ class BinaryEndpointTraversalTest(fixtures.TestBase): subq = select([c]).where(c == a).as_scalar() expr = and_(a == b, b == subq) self._assert_traversal( - expr, - [ - (operators.eq, a, b), - (operators.eq, b, subq), - ] + expr, [(operators.eq, a, b), (operators.eq, b, subq)] ) @@ -305,36 +320,31 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): """test copy-in-place behavior of various ClauseElements.""" - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): global t1, t2, t3 - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) - t3 = Table('table3', MetaData(), - Column('col1', Integer), - Column('col2', Integer) - ) + t1 = table("table1", column("col1"), column("col2"), column("col3")) + t2 = table("table2", column("col1"), column("col2"), column("col3")) + t3 = Table( + "table3", + MetaData(), + Column("col1", Integer), + Column("col2", Integer), + ) def test_binary(self): clause = t1.c.col2 == t2.c.col2 eq_(str(clause), str(CloningVisitor().traverse(clause))) def test_binary_anon_label_quirk(self): - t = table('t1', column('col1')) + 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") + self.assert_compile( + select([f]), "SELECT t1.col1 * :col1_1 AS anon_1 FROM t1" + ) f.anon_label @@ -342,9 +352,8 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): 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") + 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) @@ -352,7 +361,6 @@ 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 @@ -368,24 +376,23 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): adapter = sql_util.ColumnAdapter(aliased) - f = select([ - adapter.columns[c] - for c in aliased2.c - ]).select_from(aliased) + f = select([adapter.columns[c] for c in aliased2.c]).select_from( + aliased + ) s = select([aliased2]).select_from(aliased) eq_(str(s), str(f)) - f = select([ - adapter.columns[func.count(aliased2.c.col1)] - ]).select_from(aliased) + f = select([adapter.columns[func.count(aliased2.c.col1)]]).select_from( + aliased + ) eq_( str(select([func.count(aliased2.c.col1)]).select_from(aliased)), - str(f) + str(f), ) def test_aliased_cloned_column_adapt_inner(self): - clause = select([t1.c.col1, func.foo(t1.c.col2).label('foo')]) + clause = select([t1.c.col1, func.foo(t1.c.col2).label("foo")]) aliased1 = select([clause.c.col1, clause.c.foo]) aliased2 = clause @@ -397,20 +404,12 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): # aliased2. corresponding_column checks these # now. adapter = sql_util.ColumnAdapter(aliased1) - f1 = select([ - adapter.columns[c] - for c in aliased2._raw_columns - ]) - f2 = select([ - adapter.columns[c] - for c in aliased3._raw_columns - ]) - eq_( - str(f1), str(f2) - ) + f1 = select([adapter.columns[c] for c in aliased2._raw_columns]) + f2 = select([adapter.columns[c] for c in aliased3._raw_columns]) + eq_(str(f1), str(f2)) def test_aliased_cloned_column_adapt_exported(self): - clause = select([t1.c.col1, func.foo(t1.c.col2).label('foo')]) + clause = select([t1.c.col1, func.foo(t1.c.col2).label("foo")]) aliased1 = select([clause.c.col1, clause.c.foo]) aliased2 = clause @@ -422,20 +421,12 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): # have an _is_clone_of pointer. But we now modified _make_proxy # to assign this. adapter = sql_util.ColumnAdapter(aliased1) - f1 = select([ - adapter.columns[c] - for c in aliased2.c - ]) - f2 = select([ - adapter.columns[c] - for c in aliased3.c - ]) - eq_( - str(f1), str(f2) - ) + f1 = select([adapter.columns[c] for c in aliased2.c]) + f2 = select([adapter.columns[c] for c in aliased3.c]) + eq_(str(f1), str(f2)) def test_aliased_cloned_schema_column_adapt_exported(self): - clause = select([t3.c.col1, func.foo(t3.c.col2).label('foo')]) + clause = select([t3.c.col1, func.foo(t3.c.col2).label("foo")]) aliased1 = select([clause.c.col1, clause.c.foo]) aliased2 = clause @@ -447,20 +438,12 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): # have an _is_clone_of pointer. But we now modified _make_proxy # to assign this. adapter = sql_util.ColumnAdapter(aliased1) - f1 = select([ - adapter.columns[c] - for c in aliased2.c - ]) - f2 = select([ - adapter.columns[c] - for c in aliased3.c - ]) - eq_( - str(f1), str(f2) - ) + f1 = select([adapter.columns[c] for c in aliased2.c]) + f2 = select([adapter.columns[c] for c in aliased3.c]) + eq_(str(f1), str(f2)) def test_labeled_expression_adapt(self): - lbl_x = (t3.c.col1 == 1).label('x') + lbl_x = (t3.c.col1 == 1).label("x") t3_alias = t3.alias() adapter = sql_util.ColumnAdapter(t3_alias) @@ -471,13 +454,13 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): lblx_adapted = adapter.traverse(lbl_x) self.assert_compile( select([lblx_adapted.self_group()]), - "SELECT (table3_1.col1 = :col1_1) AS x FROM table3 AS table3_1" + "SELECT (table3_1.col1 = :col1_1) AS x FROM table3 AS table3_1", ) self.assert_compile( select([lblx_adapted.is_(True)]), "SELECT (table3_1.col1 = :col1_1) IS 1 AS anon_1 " - "FROM table3 AS table3_1" + "FROM table3 AS table3_1", ) def test_cte_w_union(self): @@ -486,50 +469,55 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s = select([func.sum(t.c.n)]) from sqlalchemy.sql.visitors import cloned_traverse + cloned = cloned_traverse(s, {}, {}) - self.assert_compile(cloned, - "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" - ) + self.assert_compile( + cloned, + "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_aliased_cte_w_union(self): - t = select([func.values(1).label("n")]).\ - cte("t", recursive=True).alias('foo') + t = ( + select([func.values(1).label("n")]) + .cte("t", recursive=True) + .alias("foo") + ) t = t.union_all(select([t.c.n + 1]).where(t.c.n < 100)) s = select([func.sum(t.c.n)]) from sqlalchemy.sql.visitors import cloned_traverse + cloned = cloned_traverse(s, {}, {}) self.assert_compile( cloned, "WITH RECURSIVE foo(n) AS (SELECT values(:values_1) AS n " "UNION ALL SELECT foo.n + :n_1 AS anon_1 FROM foo " - "WHERE foo.n < :n_2) SELECT sum(foo.n) AS sum_1 FROM foo" + "WHERE foo.n < :n_2) SELECT sum(foo.n) AS sum_1 FROM foo", ) 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') + text._bindparams["lala"] = bindparam("lala") clause2 = Vis().traverse(clause) assert c1 == str(clause) assert str(clause2) == c1 + " SOME MODIFIER=:lala" - assert list(clause._bindparams.keys()) == ['bar'] - assert set(clause2._bindparams.keys()) == set(['bar', 'lala']) + assert list(clause._bindparams.keys()) == ["bar"] + assert set(clause2._bindparams.keys()) == set(["bar", "lala"]) def test_select(self): s2 = select([t1]) @@ -537,9 +525,9 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): 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) assert str(s3) == s3_assert assert str(s2) == s2_assert @@ -547,18 +535,18 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): 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) print(str(s3)) print(str(s4)) @@ -568,11 +556,11 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): 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 binary.right = bindparam("col1", unique=True) + s5 = Vis().traverse(s4) print(str(s4)) print(str(s5)) @@ -591,18 +579,18 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): assert str(u) == str(u2) assert [str(c) for c in u2.c] == cols - s1 = select([t1], t1.c.col1 == bindparam('id_param')) + s1 = select([t1], t1.c.col1 == bindparam("id_param")) s2 = select([t2]) u = union(s1, s2) 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']) + expr = t1.c.col1.in_(["foo", "bar"]) expr2 = CloningVisitor().traverse(expr) assert str(expr) == str(expr2) @@ -628,7 +616,7 @@ 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) + t1.select().where(t1.c.col1 == 5), ).alias() assert sql_util.ClauseAdapter(u).traverse(t1) is u @@ -642,48 +630,54 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s3 = select([s], s.c.col2 == s2.c.col2) self.assert_compile( - s3, "SELECT anon_1.col1, anon_1.col2, anon_1.col3 FROM " + 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, " "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 " "AS col3 FROM table1 WHERE table1.col1 = :param_2) AS anon_2 " - "WHERE anon_1.col2 = anon_2.col2") + "WHERE anon_1.col2 = anon_2.col2", + ) 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 " + 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, " "(SELECT table1.col1 AS col1, table1.col2 AS col2, table1.col3 " "AS col3 FROM table1 WHERE table1.col1 = :col1_2) AS anon_2 " - "WHERE anon_1.col2 = anon_2.col2") + "WHERE anon_1.col2 = anon_2.col2", + ) def test_extract(self): - s = select([extract('foo', t1.c.col1).label('col1')]) + s = select([extract("foo", t1.c.col1).label("col1")]) self.assert_compile( - s, - "SELECT EXTRACT(foo FROM table1.col1) AS col1 FROM table1") + 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(s3, - "SELECT anon_1.col1 FROM (SELECT EXTRACT(foo FROM " - "table1.col1) AS col1 FROM table1) AS anon_1") + 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", + ) - @testing.emits_warning('.*replaced by another column with the same key') + @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)] - ) + 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)], + ) orig = str(s) s2 = CloningVisitor().traverse(s) assert orig == str(s) == str(s2) @@ -691,26 +685,26 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): s4 = CloningVisitor().traverse(s2) assert orig == str(s) == str(s2) == str(s4) - s3 = sql_util.ClauseAdapter(table('foo')).traverse(s) + s3 = sql_util.ClauseAdapter(table("foo")).traverse(s) assert orig == str(s) == str(s3) - s4 = sql_util.ClauseAdapter(table('foo')).traverse(s3) + s4 = sql_util.ClauseAdapter(table("foo")).traverse(s3) assert orig == str(s) == str(s3) == str(s4) - 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)] - ) + 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)], + ) s5 = CloningVisitor().traverse(s) assert orig == str(s) == str(s5) def test_correlated_select(self): - s = select([literal_column('*')], t1.c.col1 == t2.c.col1, - from_obj=[t1, t2]).correlate(t2) + s = select( + [literal_column("*")], t1.c.col1 == t2.c.col1, from_obj=[t1, t2] + ).correlate(t2) class Vis(CloningVisitor): - def visit_select(self, select): select.append_whereclause(t1.c.col2 == 7) @@ -719,26 +713,30 @@ class ClauseTest(fixtures.TestBase, AssertsCompiledSQL): "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)" + "AND table1.col2 = :col2_1)", ) def test_this_thing(self): - s = select([t1]).where(t1.c.col1 == 'foo').alias() + s = select([t1]).where(t1.c.col1 == "foo").alias() s2 = select([s.c.col1]) - self.assert_compile(s2, - 'SELECT anon_1.col1 FROM (SELECT ' - 'table1.col1 AS col1, table1.col2 AS col2, ' - 'table1.col3 AS col3 FROM table1 WHERE ' - 'table1.col1 = :col1_1) AS anon_1') + self.assert_compile( + s2, + "SELECT anon_1.col1 FROM (SELECT " + "table1.col1 AS col1, table1.col2 AS col2, " + "table1.col3 AS col3 FROM table1 WHERE " + "table1.col1 = :col1_1) AS anon_1", + ) t1a = t1.alias() s2 = sql_util.ClauseAdapter(t1a).traverse(s2) - self.assert_compile(s2, - 'SELECT anon_1.col1 FROM (SELECT ' - 'table1_1.col1 AS col1, table1_1.col2 AS ' - 'col2, table1_1.col3 AS col3 FROM table1 ' - 'AS table1_1 WHERE table1_1.col1 = ' - ':col1_1) AS anon_1') + self.assert_compile( + s2, + "SELECT anon_1.col1 FROM (SELECT " + "table1_1.col1 AS col1, table1_1.col2 AS " + "col2, table1_1.col3 AS col3 FROM table1 " + "AS table1_1 WHERE table1_1.col1 = " + ":col1_1) AS anon_1", + ) def test_select_fromtwice_one(self): t1a = t1.alias() @@ -746,95 +744,91 @@ 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 " + 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 " + 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() + 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 " + 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)") + "AS anon_1 WHERE table1.col1 = anon_1.col1)", + ) s4 = ReplacingCloningVisitor().traverse(s3) self.assert_compile( - s4, "SELECT table1.col1, table1.col2, table1.col3 " + 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)") + "AS anon_1 WHERE table1.col1 = anon_1.col1)", + ) class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): global t1, t2 - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - column("col4") - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + t1 = table( + "table1", + column("col1"), + column("col2"), + column("col3"), + column("col4"), + ) + t2 = table("table2", column("col1"), column("col2"), column("col3")) def test_traverse_memoizes_w_columns(self): t1a = t1.alias() adapter = sql_util.ColumnAdapter(t1a, anonymize_labels=True) - expr = select([t1a.c.col1]).label('x') + expr = select([t1a.c.col1]).label("x") expr_adapted = adapter.traverse(expr) is_not_(expr, expr_adapted) - is_( - adapter.columns[expr], - expr_adapted - ) + is_(adapter.columns[expr], expr_adapted) def test_traverse_memoizes_w_itself(self): t1a = t1.alias() adapter = sql_util.ColumnAdapter(t1a, anonymize_labels=True) - expr = select([t1a.c.col1]).label('x') + expr = select([t1a.c.col1]).label("x") expr_adapted = adapter.traverse(expr) is_not_(expr, expr_adapted) - is_( - adapter.traverse(expr), - expr_adapted - ) + is_(adapter.traverse(expr), expr_adapted) def test_columns_memoizes_w_itself(self): t1a = t1.alias() adapter = sql_util.ColumnAdapter(t1a, anonymize_labels=True) - expr = select([t1a.c.col1]).label('x') + expr = select([t1a.c.col1]).label("x") expr_adapted = adapter.columns[expr] is_not_(expr, expr_adapted) - is_( - adapter.columns[expr], - expr_adapted - ) + is_(adapter.columns[expr], expr_adapted) def test_wrapping_fallthrough(self): t1a = t1.alias(name="t1a") @@ -850,57 +844,35 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # t1.c.col1 -> s1.c.t1a_col1 # adapted by a2 - is_( - a3.columns[t1.c.col1], s1.c.t1a_col1 - ) - is_( - a4.columns[t1.c.col1], s1.c.t1a_col1 - ) + is_(a3.columns[t1.c.col1], s1.c.t1a_col1) + is_(a4.columns[t1.c.col1], s1.c.t1a_col1) # chaining can't fall through because a1 grabs it # first - is_( - a5.columns[t1.c.col1], t1a.c.col1 - ) + is_(a5.columns[t1.c.col1], t1a.c.col1) # t2.c.col1 -> s1.c.t2a_col1 # adapted by a2 - is_( - a3.columns[t2.c.col1], s1.c.t2a_col1 - ) - is_( - a4.columns[t2.c.col1], s1.c.t2a_col1 - ) + is_(a3.columns[t2.c.col1], s1.c.t2a_col1) + is_(a4.columns[t2.c.col1], s1.c.t2a_col1) # chaining, t2 hits s1 - is_( - a5.columns[t2.c.col1], s1.c.t2a_col1 - ) + is_(a5.columns[t2.c.col1], s1.c.t2a_col1) # t1.c.col2 -> t1a.c.col2 # fallthrough to a1 - is_( - a3.columns[t1.c.col2], t1a.c.col2 - ) - is_( - a4.columns[t1.c.col2], t1a.c.col2 - ) + is_(a3.columns[t1.c.col2], t1a.c.col2) + is_(a4.columns[t1.c.col2], t1a.c.col2) # chaining hits a1 - is_( - a5.columns[t1.c.col2], t1a.c.col2 - ) + is_(a5.columns[t1.c.col2], t1a.c.col2) # t2.c.col2 -> t2.c.col2 # fallthrough to no adaption - is_( - a3.columns[t2.c.col2], t2.c.col2 - ) - is_( - a4.columns[t2.c.col2], t2.c.col2 - ) + is_(a3.columns[t2.c.col2], t2.c.col2) + is_(a4.columns[t2.c.col2], t2.c.col2) def test_wrapping_ordering(self): """illustrate an example where order of wrappers matters. @@ -926,25 +898,15 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # in different contexts, order of wrapping matters # t2.c.col1 via a2 is stmt2.c.col1; then ignored by a1 - is_( - a2_to_a1.columns[t2.c.col1], stmt2.c.col1 - ) + is_(a2_to_a1.columns[t2.c.col1], stmt2.c.col1) # t2.c.col1 via a1 is stmt.c.table2_col1; a2 then # sends this to stmt2.c.table2_col1 - is_( - a1_to_a2.columns[t2.c.col1], stmt2.c.table2_col1 - ) + is_(a1_to_a2.columns[t2.c.col1], stmt2.c.table2_col1) # for mutually exclusive columns, order doesn't matter - is_( - a2_to_a1.columns[t1.c.col1], stmt2.c.table1_col1 - ) - is_( - a1_to_a2.columns[t1.c.col1], stmt2.c.table1_col1 - ) - is_( - a2_to_a1.columns[t2.c.col2], stmt2.c.col2 - ) + is_(a2_to_a1.columns[t1.c.col1], stmt2.c.table1_col1) + is_(a1_to_a2.columns[t1.c.col1], stmt2.c.table1_col1) + is_(a2_to_a1.columns[t2.c.col2], stmt2.c.col2) def test_wrapping_multiple(self): """illustrate that wrapping runs both adapters""" @@ -959,7 +921,7 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( a3.traverse(stmt), - "SELECT t1a.col1, t2a.col2 FROM table1 AS t1a, table2 AS t2a" + "SELECT t1a.col1, t2a.col2 FROM table1 AS t1a, table2 AS t2a", ) # chaining does too because these adapters don't share any @@ -967,7 +929,7 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): a4 = a2.chain(a1) self.assert_compile( a4.traverse(stmt), - "SELECT t1a.col1, t2a.col2 FROM table1 AS t1a, table2 AS t2a" + "SELECT t1a.col1, t2a.col2 FROM table1 AS t1a, table2 AS t2a", ) def test_wrapping_inclusions(self): @@ -977,13 +939,13 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): t1a = t1.alias(name="t1a") t2a = t2.alias(name="t2a") a1 = sql_util.ColumnAdapter( - t1a, - include_fn=lambda col: "a1" in col._annotations) + t1a, include_fn=lambda col: "a1" in col._annotations + ) s1 = select([t1a, t2a]).apply_labels().alias() a2 = sql_util.ColumnAdapter( - s1, - include_fn=lambda col: "a2" in col._annotations) + s1, include_fn=lambda col: "a2" in col._annotations + ) a3 = a2.wrap(a1) c1a1 = t1.c.col1._annotate(dict(a1=True)) @@ -994,62 +956,45 @@ class ColumnAdapterTest(fixtures.TestBase, AssertsCompiledSQL): c2a2 = t2.c.col1._annotate(dict(a2=True)) c2aa = t2.c.col1._annotate(dict(a1=True, a2=True)) - is_( - a3.columns[c1a1], t1a.c.col1 - ) - is_( - a3.columns[c1a2], s1.c.t1a_col1 - ) - is_( - a3.columns[c1aa], s1.c.t1a_col1 - ) + is_(a3.columns[c1a1], t1a.c.col1) + is_(a3.columns[c1a2], s1.c.t1a_col1) + is_(a3.columns[c1aa], s1.c.t1a_col1) # not covered by a1, accepted by a2 - is_( - a3.columns[c2aa], s1.c.t2a_col1 - ) + is_(a3.columns[c2aa], s1.c.t2a_col1) # not covered by a1, accepted by a2 - is_( - a3.columns[c2a2], s1.c.t2a_col1 - ) + is_(a3.columns[c2a2], s1.c.t2a_col1) # not covered by a1, rejected by a2 - is_( - a3.columns[c2a1], c2a1 - ) + is_(a3.columns[c2a1], c2a1) class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): global t1, t2 - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + t1 = table("table1", column("col1"), column("col2"), column("col3")) + t2 = table("table2", column("col1"), column("col2"), column("col3")) def test_correlation_on_clone(self): - t1alias = t1.alias('t1alias') - t2alias = t2.alias('t2alias') + t1alias = t1.alias("t1alias") + t2alias = t2.alias("t2alias") vis = sql_util.ClauseAdapter(t1alias) - s = select([literal_column('*')], - from_obj=[t1alias, t2alias]).as_scalar() + s = select( + [literal_column("*")], from_obj=[t1alias, t2alias] + ).as_scalar() assert t2alias in s._froms assert t1alias in s._froms - self.assert_compile(select([literal_column('*')], t2alias.c.col1 == s), - 'SELECT * FROM table2 AS t2alias WHERE ' - 't2alias.col1 = (SELECT * FROM table1 AS ' - 't1alias)') + self.assert_compile( + select([literal_column("*")], t2alias.c.col1 == s), + "SELECT * FROM table2 AS t2alias WHERE " + "t2alias.col1 = (SELECT * FROM table1 AS " + "t1alias)", + ) s = vis.traverse(s) assert t2alias not in s._froms # not present because it's been @@ -1060,61 +1005,91 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # correlate list on "s" needs to take into account the full # _cloned_set for each element in _froms when correlating - self.assert_compile(select([literal_column('*')], t2alias.c.col1 == s), - 'SELECT * FROM table2 AS t2alias WHERE ' - 't2alias.col1 = (SELECT * FROM table1 AS ' - 't1alias)') - s = select([literal_column('*')], - from_obj=[t1alias, t2alias]).correlate(t2alias).as_scalar() - self.assert_compile(select([literal_column('*')], t2alias.c.col1 == s), - 'SELECT * FROM table2 AS t2alias WHERE ' - 't2alias.col1 = (SELECT * FROM table1 AS ' - 't1alias)') + self.assert_compile( + select([literal_column("*")], t2alias.c.col1 == s), + "SELECT * FROM table2 AS t2alias WHERE " + "t2alias.col1 = (SELECT * FROM table1 AS " + "t1alias)", + ) + s = ( + select([literal_column("*")], from_obj=[t1alias, t2alias]) + .correlate(t2alias) + .as_scalar() + ) + self.assert_compile( + select([literal_column("*")], t2alias.c.col1 == s), + "SELECT * FROM table2 AS t2alias WHERE " + "t2alias.col1 = (SELECT * FROM table1 AS " + "t1alias)", + ) s = vis.traverse(s) - self.assert_compile(select([literal_column('*')], t2alias.c.col1 == s), - 'SELECT * FROM table2 AS t2alias WHERE ' - 't2alias.col1 = (SELECT * FROM table1 AS ' - 't1alias)') + self.assert_compile( + select([literal_column("*")], t2alias.c.col1 == s), + "SELECT * FROM table2 AS t2alias WHERE " + "t2alias.col1 = (SELECT * FROM table1 AS " + "t1alias)", + ) s = CloningVisitor().traverse(s) - self.assert_compile(select([literal_column('*')], t2alias.c.col1 == s), - 'SELECT * FROM table2 AS t2alias WHERE ' - 't2alias.col1 = (SELECT * FROM table1 AS ' - 't1alias)') + self.assert_compile( + select([literal_column("*")], t2alias.c.col1 == s), + "SELECT * FROM table2 AS t2alias WHERE " + "t2alias.col1 = (SELECT * FROM table1 AS " + "t1alias)", + ) - s = select([literal_column('*')]).where(t1.c.col1 == t2.c.col1) \ + s = ( + select([literal_column("*")]) + .where(t1.c.col1 == t2.c.col1) .as_scalar() - self.assert_compile(select([t1.c.col1, s]), - 'SELECT table1.col1, (SELECT * FROM table2 ' - 'WHERE table1.col1 = table2.col1) AS ' - 'anon_1 FROM table1') + ) + self.assert_compile( + select([t1.c.col1, s]), + "SELECT table1.col1, (SELECT * FROM table2 " + "WHERE table1.col1 = table2.col1) AS " + "anon_1 FROM table1", + ) vis = sql_util.ClauseAdapter(t1alias) s = vis.traverse(s) - self.assert_compile(select([t1alias.c.col1, s]), - 'SELECT t1alias.col1, (SELECT * FROM ' - 'table2 WHERE t1alias.col1 = table2.col1) ' - 'AS anon_1 FROM table1 AS t1alias') + self.assert_compile( + select([t1alias.c.col1, s]), + "SELECT t1alias.col1, (SELECT * FROM " + "table2 WHERE t1alias.col1 = table2.col1) " + "AS anon_1 FROM table1 AS t1alias", + ) s = CloningVisitor().traverse(s) - self.assert_compile(select([t1alias.c.col1, s]), - 'SELECT t1alias.col1, (SELECT * FROM ' - 'table2 WHERE t1alias.col1 = table2.col1) ' - 'AS anon_1 FROM table1 AS t1alias') - s = select([literal_column('*')]).where(t1.c.col1 == t2.c.col1) \ - .correlate(t1).as_scalar() - self.assert_compile(select([t1.c.col1, s]), - 'SELECT table1.col1, (SELECT * FROM table2 ' - 'WHERE table1.col1 = table2.col1) AS ' - 'anon_1 FROM table1') + self.assert_compile( + select([t1alias.c.col1, s]), + "SELECT t1alias.col1, (SELECT * FROM " + "table2 WHERE t1alias.col1 = table2.col1) " + "AS anon_1 FROM table1 AS t1alias", + ) + s = ( + select([literal_column("*")]) + .where(t1.c.col1 == t2.c.col1) + .correlate(t1) + .as_scalar() + ) + self.assert_compile( + select([t1.c.col1, s]), + "SELECT table1.col1, (SELECT * FROM table2 " + "WHERE table1.col1 = table2.col1) AS " + "anon_1 FROM table1", + ) vis = sql_util.ClauseAdapter(t1alias) s = vis.traverse(s) - self.assert_compile(select([t1alias.c.col1, s]), - 'SELECT t1alias.col1, (SELECT * FROM ' - 'table2 WHERE t1alias.col1 = table2.col1) ' - 'AS anon_1 FROM table1 AS t1alias') + self.assert_compile( + select([t1alias.c.col1, s]), + "SELECT t1alias.col1, (SELECT * FROM " + "table2 WHERE t1alias.col1 = table2.col1) " + "AS anon_1 FROM table1 AS t1alias", + ) s = CloningVisitor().traverse(s) - self.assert_compile(select([t1alias.c.col1, s]), - 'SELECT t1alias.col1, (SELECT * FROM ' - 'table2 WHERE t1alias.col1 = table2.col1) ' - 'AS anon_1 FROM table1 AS t1alias') + self.assert_compile( + select([t1alias.c.col1, s]), + "SELECT t1alias.col1, (SELECT * FROM " + "table2 WHERE t1alias.col1 = table2.col1) " + "AS anon_1 FROM table1 AS t1alias", + ) @testing.fails_on_everything_except() def test_joins_dont_adapt(self): @@ -1122,284 +1097,319 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # make much sense. ClauseAdapter doesn't make any changes if # it's against a straight join. - users = table('users', column('id')) - addresses = table('addresses', column('id'), column('user_id')) + users = table("users", column("id")) + addresses = table("addresses", column("id"), column("user_id")) ualias = users.alias() - s = select([func.count(addresses.c.id)], users.c.id - == addresses.c.user_id).correlate(users) + s = select( + [func.count(addresses.c.id)], users.c.id == addresses.c.user_id + ).correlate(users) s = sql_util.ClauseAdapter(ualias).traverse(s) j1 = addresses.join(ualias, addresses.c.user_id == ualias.c.id) - self.assert_compile(sql_util.ClauseAdapter(j1).traverse(s), - 'SELECT count(addresses.id) AS count_1 ' - 'FROM addresses WHERE users_1.id = ' - 'addresses.user_id') + self.assert_compile( + sql_util.ClauseAdapter(j1).traverse(s), + "SELECT count(addresses.id) AS count_1 " + "FROM addresses WHERE users_1.id = " + "addresses.user_id", + ) def test_table_to_alias_1(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - ff = vis.traverse(func.count(t1.c.col1).label('foo')) + ff = vis.traverse(func.count(t1.c.col1).label("foo")) assert list(_from_objects(ff)) == [t1alias] def test_table_to_alias_2(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( - vis.traverse(select([literal_column('*')], from_obj=[t1])), - 'SELECT * FROM table1 AS t1alias') + vis.traverse(select([literal_column("*")], from_obj=[t1])), + "SELECT * FROM table1 AS t1alias", + ) def test_table_to_alias_3(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( - select([literal_column('*')], t1.c.col1 == t2.c.col2), - 'SELECT * FROM table1, table2 WHERE table1.col1 = table2.col2') + select([literal_column("*")], t1.c.col1 == t2.c.col2), + "SELECT * FROM table1, table2 WHERE table1.col1 = table2.col2", + ) def test_table_to_alias_4(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(vis.traverse(select([literal_column('*')], - t1.c.col1 == t2.c.col2)), - 'SELECT * FROM table1 AS t1alias, table2 ' - 'WHERE t1alias.col1 = table2.col2') + self.assert_compile( + vis.traverse( + select([literal_column("*")], t1.c.col1 == 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') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( vis.traverse( select( - [literal_column('*')], + [literal_column("*")], t1.c.col1 == t2.c.col2, - from_obj=[ - t1, - t2])), - 'SELECT * FROM table1 AS t1alias, table2 ' - 'WHERE t1alias.col1 = table2.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') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(select([t1alias, t2]).where( - t1alias.c.col1 == vis.traverse( - select([literal_column('*')], - t1.c.col1 == t2.c.col2, from_obj=[t1, t2]).correlate(t1) - ) - ), + self.assert_compile( + select([t1alias, t2]).where( + t1alias.c.col1 + == vis.traverse( + select( + [literal_column("*")], + 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 * FROM table2 WHERE t1alias.col1 = table2.col2)", ) def test_table_to_alias_7(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) self.assert_compile( - select([t1alias, t2]). - where(t1alias.c.col1 == vis.traverse( - select([literal_column('*')], - t1.c.col1 == t2.c.col2, from_obj=[t1, t2]). - correlate(t2))), + select([t1alias, t2]).where( + t1alias.c.col1 + == vis.traverse( + select( + [literal_column("*")], + 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)") + "WHERE t1alias.col1 = table2.col2)", + ) def test_table_to_alias_8(self): - t1alias = t1.alias('t1alias') + 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') + "CASE WHEN (t1alias.col1 = :col1_1) THEN " + "t1alias.col2 ELSE t1alias.col1 END", + ) def test_table_to_alias_9(self): - t1alias = t1.alias('t1alias') + 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') + 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([literal_column('*')], from_obj=[t1]).alias('foo') - self.assert_compile(s.select(), - 'SELECT foo.* FROM (SELECT * FROM table1) ' - 'AS foo') + s = select([literal_column("*")], from_obj=[t1]).alias("foo") + self.assert_compile( + s.select(), "SELECT foo.* FROM (SELECT * FROM table1) " "AS foo" + ) def test_table_to_alias_11(self): - s = select([literal_column('*')], from_obj=[t1]).alias('foo') - t1alias = t1.alias('t1alias') + s = select([literal_column("*")], from_obj=[t1]).alias("foo") + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - self.assert_compile(vis.traverse(s.select()), - 'SELECT foo.* FROM (SELECT * FROM table1 ' - 'AS t1alias) AS foo') + self.assert_compile( + vis.traverse(s.select()), + "SELECT foo.* FROM (SELECT * FROM table1 " "AS t1alias) AS foo", + ) def test_table_to_alias_12(self): - s = select([literal_column('*')], from_obj=[t1]).alias('foo') - self.assert_compile(s.select(), - 'SELECT foo.* FROM (SELECT * FROM table1) ' - 'AS foo') + s = select([literal_column("*")], from_obj=[t1]).alias("foo") + self.assert_compile( + s.select(), "SELECT foo.* FROM (SELECT * FROM table1) " "AS foo" + ) def test_table_to_alias_13(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - ff = vis.traverse(func.count(t1.c.col1).label('foo')) - self.assert_compile(select([ff]), - 'SELECT count(t1alias.col1) AS foo FROM ' - 'table1 AS t1alias') + ff = vis.traverse(func.count(t1.c.col1).label("foo")) + self.assert_compile( + select([ff]), + "SELECT count(t1alias.col1) AS foo FROM " "table1 AS t1alias", + ) assert list(_from_objects(ff)) == [t1alias] # 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") + # 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") def test_table_to_alias_14(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - t2alias = t2.alias('t2alias') + t2alias = t2.alias("t2alias") vis.chain(sql_util.ClauseAdapter(t2alias)) self.assert_compile( vis.traverse( - select([literal_column('*')], t1.c.col1 == t2.c.col2)), - 'SELECT * FROM table1 AS t1alias, table2 ' - 'AS t2alias WHERE t1alias.col1 = ' - 't2alias.col2') + select([literal_column("*")], t1.c.col1 == t2.c.col2) + ), + "SELECT * FROM table1 AS t1alias, table2 " + "AS t2alias WHERE t1alias.col1 = " + "t2alias.col2", + ) def test_table_to_alias_15(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - t2alias = t2.alias('t2alias') + 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') + 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') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - t2alias = t2.alias('t2alias') + t2alias = t2.alias("t2alias") 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)) + 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)" + "WHERE t1alias.col1 = t2alias.col2)", ) def test_table_to_alias_17(self): - t1alias = t1.alias('t1alias') + t1alias = t1.alias("t1alias") vis = sql_util.ClauseAdapter(t1alias) - t2alias = t2.alias('t2alias') + t2alias = t2.alias("t2alias") vis.chain(sql_util.ClauseAdapter(t2alias)) self.assert_compile( t2alias.select().where( - t2alias.c.col2 == vis.traverse( + 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)') + ["*"], 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)", + ) 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) - ) - ) - - e = (a.c.id == a.c.xxx_id) + a = Table( + "a", + m, + 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_fn=lambda x: x in set([a.c.id]), - equivalents={a.c.id: set([a.c.id])} - ).traverse(e) + e = sql_util.ClauseAdapter( + b, + include_fn=lambda x: x in set([a.c.id]), + equivalents={a.c.id: set([a.c.id])}, + ).traverse(e) assert str(e) == "a_1.id = a.xxx_id" def test_recursive_equivalents(self): m = MetaData() - a = Table('a', m, Column('x', Integer), Column('y', Integer)) - b = Table('b', m, Column('x', Integer), Column('y', Integer)) - c = Table('c', m, Column('x', Integer), Column('y', Integer)) + a = Table("a", m, Column("x", Integer), Column("y", Integer)) + b = Table("b", m, Column("x", Integer), Column("y", Integer)) + c = Table("c", m, Column("x", Integer), Column("y", Integer)) # 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])}) + 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): m = MetaData() - a = Table('a', m, Column('x', Integer), Column('y', Integer)) - b = Table('b', m, Column('x', Integer), Column('y', Integer)) - c = Table('c', m, Column('x', Integer), Column('y', Integer)) + a = Table("a", m, Column("x", Integer), Column("y", Integer)) + b = Table("b", m, Column("x", Integer), Column("y", Integer)) + c = Table("c", m, Column("x", Integer), Column("y", Integer)) alias = select([a]).select_from(a.join(b, a.c.x == b.c.x)).alias() # 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])}) + 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)) - b = Table('b', metadata, - 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')), - ) - - d = Table('d', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + a = Table("a", metadata, Column("id", Integer, primary_key=True)) + b = Table( + "b", + metadata, + 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")), + ) + + d = Table( + "d", + metadata, + Column("id", Integer, primary_key=True), + Column("aid", Integer, ForeignKey("a.id")), + ) j1 = a.outerjoin(b) j2 = select([j1], use_labels=True) @@ -1407,12 +1417,14 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): j3 = c.join(j2, j2.c.b_id == c.c.bid) j4 = j3.outerjoin(d) - self.assert_compile(j4, - 'c JOIN (SELECT a.id AS a_id, b.id AS ' - 'b_id, b.aid AS b_aid FROM a LEFT OUTER ' - 'JOIN b ON a.id = b.aid) ON b_id = c.bid ' - 'LEFT OUTER JOIN d ON a_id = d.aid') - j5 = j3.alias('foo') + self.assert_compile( + j4, + "c JOIN (SELECT a.id AS a_id, b.id AS " + "b_id, b.aid AS b_aid FROM a LEFT OUTER " + "JOIN b ON a.id = b.aid) ON b_id = c.bid " + "LEFT OUTER JOIN d ON a_id = d.aid", + ) + j5 = j3.alias("foo") j6 = sql_util.ClauseAdapter(j5).copy_and_process([j4])[0] # this statement takes c join(a join b), wraps it inside an @@ -1420,14 +1432,16 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # right side "left outer join d" stays the same, except "d" # joins against foo.a_id instead of plain "a_id" - self.assert_compile(j6, - '(SELECT c.id AS c_id, c.bid AS c_bid, ' - 'a_id AS a_id, b_id AS b_id, b_aid AS ' - 'b_aid FROM c JOIN (SELECT a.id AS a_id, ' - 'b.id AS b_id, b.aid AS b_aid FROM a LEFT ' - 'OUTER JOIN b ON a.id = b.aid) ON b_id = ' - 'c.bid) AS foo LEFT OUTER JOIN d ON ' - 'foo.a_id = d.aid') + self.assert_compile( + j6, + "(SELECT c.id AS c_id, c.bid AS c_bid, " + "a_id AS a_id, b_id AS b_id, b_aid AS " + "b_aid FROM c JOIN (SELECT a.id AS a_id, " + "b.id AS b_id, b.aid AS b_aid FROM a LEFT " + "OUTER JOIN b ON a.id = b.aid) ON b_id = " + "c.bid) AS foo LEFT OUTER JOIN d ON " + "foo.a_id = d.aid", + ) def test_derived_from(self): assert select([t1]).is_derived_from(t1) @@ -1435,7 +1449,7 @@ 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') + s1 = select([t1, t2]).alias("foo") s2 = select([s1]).limit(5).offset(10).alias() assert s2.is_derived_from(s1) s2 = s2._clone() @@ -1445,111 +1459,117 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): # original issue from ticket #904 - s1 = select([t1]).alias('foo') + s1 = select([t1]).alias("foo") s2 = select([s1]).limit(5).offset(10).alias() - self.assert_compile(sql_util.ClauseAdapter(s2).traverse(s1), - 'SELECT foo.col1, foo.col2, foo.col3 FROM ' - '(SELECT table1.col1 AS col1, table1.col2 ' - 'AS col2, table1.col3 AS col3 FROM table1) ' - 'AS foo LIMIT :param_1 OFFSET :param_2', - {'param_1': 5, 'param_2': 10}) + self.assert_compile( + sql_util.ClauseAdapter(s2).traverse(s1), + "SELECT foo.col1, foo.col2, foo.col3 FROM " + "(SELECT table1.col1 AS col1, table1.col2 " + "AS col2, table1.col3 AS col3 FROM table1) " + "AS foo LIMIT :param_1 OFFSET :param_2", + {"param_1": 5, "param_2": 10}, + ) def test_aliasedselect_to_aliasedselect_join(self): - s1 = select([t1]).alias('foo') + s1 = select([t1]).alias("foo") s2 = select([s1]).limit(5).offset(10).alias() j = s1.outerjoin(t2, s1.c.col1 == t2.c.col1) - self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(), - 'SELECT anon_1.col1, anon_1.col2, ' - 'anon_1.col3, table2.col1, table2.col2, ' - 'table2.col3 FROM (SELECT foo.col1 AS ' - 'col1, foo.col2 AS col2, foo.col3 AS col3 ' - 'FROM (SELECT table1.col1 AS col1, ' - 'table1.col2 AS col2, table1.col3 AS col3 ' - 'FROM table1) AS foo LIMIT :param_1 OFFSET ' - ':param_2) AS anon_1 LEFT OUTER JOIN ' - 'table2 ON anon_1.col1 = table2.col1', - {'param_1': 5, 'param_2': 10}) + self.assert_compile( + sql_util.ClauseAdapter(s2).traverse(j).select(), + "SELECT anon_1.col1, anon_1.col2, " + "anon_1.col3, table2.col1, table2.col2, " + "table2.col3 FROM (SELECT foo.col1 AS " + "col1, foo.col2 AS col2, foo.col3 AS col3 " + "FROM (SELECT table1.col1 AS col1, " + "table1.col2 AS col2, table1.col3 AS col3 " + "FROM table1) AS foo LIMIT :param_1 OFFSET " + ":param_2) AS anon_1 LEFT OUTER JOIN " + "table2 ON anon_1.col1 = table2.col1", + {"param_1": 5, "param_2": 10}, + ) def test_aliasedselect_to_aliasedselect_join_nested_table(self): - s1 = select([t1]).alias('foo') + s1 = select([t1]).alias("foo") s2 = select([s1]).limit(5).offset(10).alias() - talias = t1.alias('bar') + talias = t1.alias("bar") assert not s2.is_derived_from(talias) j = s1.outerjoin(talias, s1.c.col1 == talias.c.col1) - self.assert_compile(sql_util.ClauseAdapter(s2).traverse(j).select(), - 'SELECT anon_1.col1, anon_1.col2, ' - 'anon_1.col3, bar.col1, bar.col2, bar.col3 ' - 'FROM (SELECT foo.col1 AS col1, foo.col2 ' - 'AS col2, foo.col3 AS col3 FROM (SELECT ' - 'table1.col1 AS col1, table1.col2 AS col2, ' - 'table1.col3 AS col3 FROM table1) AS foo ' - '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}) + self.assert_compile( + sql_util.ClauseAdapter(s2).traverse(j).select(), + "SELECT anon_1.col1, anon_1.col2, " + "anon_1.col3, bar.col1, bar.col2, bar.col3 " + "FROM (SELECT foo.col1 AS col1, foo.col2 " + "AS col2, foo.col3 AS col3 FROM (SELECT " + "table1.col1 AS col1, table1.col2 AS col2, " + "table1.col3 AS col3 FROM table1) AS foo " + "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}, + ) 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 ' - 'FROM table1 AS table1_1') + self.assert_compile( + sql_util.ClauseAdapter(t1.alias()).traverse(s), + "SELECT count(table1_1.col1) AS count_1 " + "FROM table1 AS table1_1", + ) def test_recursive(self): metadata = MetaData() - a = Table('a', metadata, - Column('id', Integer, primary_key=True)) - b = Table('b', metadata, - 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')), - ) - - d = Table('d', metadata, - Column('id', Integer, primary_key=True), - Column('aid', Integer, ForeignKey('a.id')), - ) + a = Table("a", metadata, Column("id", Integer, primary_key=True)) + b = Table( + "b", + metadata, + 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")), + ) + + d = Table( + "d", + metadata, + Column("id", Integer, primary_key=True), + Column("aid", Integer, ForeignKey("a.id")), + ) u = union( a.join(b).select().apply_labels(), - a.join(d).select().apply_labels() + a.join(d).select().apply_labels(), ).alias() self.assert_compile( - sql_util.ClauseAdapter(u). - traverse(select([c.c.bid]).where(c.c.bid == u.c.b_aid)), + 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 " "FROM a JOIN d ON a.id = d.aid) AS anon_1 " - "WHERE c.bid = anon_1.b_aid" + "WHERE c.bid = anon_1.b_aid", ) - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + t1 = table("table1", column("col1"), column("col2"), column("col3")) + t2 = table("table2", column("col1"), column("col2"), column("col3")) def test_label_anonymize_one(self): t1a = t1.alias() adapter = sql_util.ClauseAdapter(t1a, anonymize_labels=True) - expr = select([t1.c.col2]).where(t1.c.col3 == 5).label('expr') + expr = select([t1.c.col2]).where(t1.c.col3 == 5).label("expr") expr_adapted = adapter.traverse(expr) stmt = select([expr, expr_adapted]).order_by(expr, expr_adapted) @@ -1560,7 +1580,7 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): "AS expr, " "(SELECT table1_1.col2 FROM table1 AS table1_1 " "WHERE table1_1.col3 = :col3_2) AS anon_1 " - "ORDER BY expr, anon_1" + "ORDER BY expr, anon_1", ) def test_label_anonymize_two(self): @@ -1578,14 +1598,14 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): "AS anon_1, " "(SELECT table1_1.col2 FROM table1 AS table1_1 " "WHERE table1_1.col3 = :col3_2) AS anon_2 " - "ORDER BY anon_1, anon_2" + "ORDER BY anon_1, anon_2", ) def test_label_anonymize_three(self): t1a = t1.alias() adapter = sql_util.ColumnAdapter( - t1a, anonymize_labels=True, - allow_label_resolve=False) + t1a, anonymize_labels=True, allow_label_resolve=False + ) expr = select([t1.c.col2]).where(t1.c.col3 == 5).label(None) l1 = expr @@ -1603,236 +1623,235 @@ class ClauseAdapterTest(fixtures.TestBase, AssertsCompiledSQL): class SpliceJoinsTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): global table1, table2, table3, table4 def _table(name): - return table(name, column('col1'), column('col2'), - column('col3')) + return table(name, column("col1"), column("col2"), column("col3")) table1, table2, table3, table4 = [ - _table(name) for name in ( - '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 ' - 'AS col2, table1.col3 AS col3 FROM table1 ' - 'WHERE table1.col2 < :col2_1) AS anon_1 ' - 'JOIN table2 ON anon_1.col1 = table2.col1 ' - 'JOIN table1 AS table1_1 ON table2.col1 = ' - 'table1_1.col1 JOIN table2 AS table2_1 ON ' - 'table2_1.col1 = anon_1.col1') + self.assert_compile( + sql_util.splice_joins(s, j), + "(SELECT table1.col1 AS col1, table1.col2 " + "AS col2, table1.col3 AS col3 FROM table1 " + "WHERE table1.col2 < :col2_1) AS anon_1 " + "JOIN table2 ON anon_1.col1 = table2.col1 " + "JOIN table1 AS table1_1 ON table2.col1 = " + "table1_1.col1 JOIN table2 AS table2_1 ON " + "table2_1.col1 = anon_1.col1", + ) def test_stop_on(self): t1, t2, t3 = table1, table2, table3 j1 = t1.join(t2, t1.c.col1 == t2.c.col1) j2 = j1.join(t3, t2.c.col1 == t3.c.col1) s = select([t1]).select_from(j1).alias() - self.assert_compile(sql_util.splice_joins(s, j2), - '(SELECT table1.col1 AS col1, table1.col2 ' - 'AS col2, table1.col3 AS col3 FROM table1 ' - 'JOIN table2 ON table1.col1 = table2.col1) ' - 'AS anon_1 JOIN table2 ON anon_1.col1 = ' - 'table2.col1 JOIN table3 ON table2.col1 = ' - 'table3.col1') - self.assert_compile(sql_util.splice_joins(s, j2, j1), - '(SELECT table1.col1 AS col1, table1.col2 ' - 'AS col2, table1.col3 AS col3 FROM table1 ' - 'JOIN table2 ON table1.col1 = table2.col1) ' - 'AS anon_1 JOIN table3 ON table2.col1 = ' - 'table3.col1') + self.assert_compile( + sql_util.splice_joins(s, j2), + "(SELECT table1.col1 AS col1, table1.col2 " + "AS col2, table1.col3 AS col3 FROM table1 " + "JOIN table2 ON table1.col1 = table2.col1) " + "AS anon_1 JOIN table2 ON anon_1.col1 = " + "table2.col1 JOIN table3 ON table2.col1 = " + "table3.col1", + ) + self.assert_compile( + sql_util.splice_joins(s, j2, j1), + "(SELECT table1.col1 AS col1, table1.col2 " + "AS col2, table1.col3 AS col3 FROM table1 " + "JOIN table2 ON table1.col1 = table2.col1) " + "AS anon_1 JOIN table3 ON table2.col1 = " + "table3.col1", + ) 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), - 'table1 JOIN table2 AS table2_1 ON ' - 'table1.col1 = table2_1.col1 JOIN table3 ' - 'AS table3_1 ON table2_1.col2 = ' - 'table3_1.col2') - 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(table1, j1), + "table1 JOIN table2 AS table2_1 ON " + "table1.col1 = table2_1.col1 JOIN table3 " + "AS table3_1 ON table2_1.col2 = " + "table3_1.col2", + ) + 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", + ) class SelectTest(fixtures.TestBase, AssertsCompiledSQL): """tests the generative capability of Select""" - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): global t1, t2 - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + t1 = table("table1", column("col1"), column("col2"), column("col3")) + t2 = table("table2", column("col1"), column("col2"), column("col3")) def test_columns(self): s = t1.select() - self.assert_compile(s, - 'SELECT table1.col1, table1.col2, ' - 'table1.col3 FROM table1') - select_copy = s.column(column('yyy')) - self.assert_compile(select_copy, - 'SELECT table1.col1, table1.col2, ' - 'table1.col3, yyy FROM table1') + self.assert_compile( + s, "SELECT table1.col1, table1.col2, " "table1.col3 FROM table1" + ) + select_copy = s.column(column("yyy")) + self.assert_compile( + select_copy, + "SELECT table1.col1, table1.col2, " "table1.col3, yyy FROM table1", + ) assert s.columns is not select_copy.columns assert s._columns is not select_copy._columns assert s._raw_columns is not select_copy._raw_columns - 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" + ) def test_froms(self): s = t1.select() - 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" + ) select_copy = s.select_from(t2) - self.assert_compile(select_copy, - 'SELECT table1.col1, table1.col2, ' - 'table1.col3 FROM table1, table2') + self.assert_compile( + select_copy, + "SELECT table1.col1, table1.col2, " + "table1.col3 FROM table1, table2", + ) assert s._froms is not select_copy._froms - 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" + ) def test_prefixes(self): s = t1.select() - self.assert_compile(s, - 'SELECT table1.col1, table1.col2, ' - 'table1.col3 FROM table1') - select_copy = s.prefix_with('FOOBER') - self.assert_compile(select_copy, - 'SELECT FOOBER table1.col1, table1.col2, ' - 'table1.col3 FROM table1') - 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" + ) + select_copy = s.prefix_with("FOOBER") + self.assert_compile( + select_copy, + "SELECT FOOBER table1.col1, table1.col2, " + "table1.col3 FROM table1", + ) + self.assert_compile( + s, "SELECT table1.col1, table1.col2, " "table1.col3 FROM table1" + ) def test_execution_options(self): - s = select().execution_options(foo='bar') - s2 = s.execution_options(bar='baz') - s3 = s.execution_options(foo='not bar') + s = select().execution_options(foo="bar") + s2 = s.execution_options(bar="baz") + s3 = s.execution_options(foo="not bar") # The original select should not be modified. - assert s._execution_options == dict(foo='bar') + assert s._execution_options == dict(foo="bar") # s2 should have its execution_options based on s, though. - assert s2._execution_options == dict(foo='bar', bar='baz') - assert s3._execution_options == dict(foo='not bar') + assert s2._execution_options == dict(foo="bar", bar="baz") + assert s3._execution_options == dict(foo="not bar") def test_invalid_options(self): assert_raises( - exc.ArgumentError, - select().execution_options, compiled_cache={} + exc.ArgumentError, select().execution_options, compiled_cache={} ) assert_raises( exc.ArgumentError, select().execution_options, - isolation_level='READ_COMMITTED' + isolation_level="READ_COMMITTED", ) # this feature not available yet def _NOTYET_test_execution_options_in_kwargs(self): - s = select(execution_options=dict(foo='bar')) - s2 = s.execution_options(bar='baz') + s = select(execution_options=dict(foo="bar")) + s2 = s.execution_options(bar="baz") # The original select should not be modified. - assert s._execution_options == dict(foo='bar') + assert s._execution_options == dict(foo="bar") # s2 should have its execution_options based on s, though. - assert s2._execution_options == dict(foo='bar', bar='baz') + assert s2._execution_options == dict(foo="bar", bar="baz") # this feature not available yet def _NOTYET_test_execution_options_in_text(self): - s = text('select 42', execution_options=dict(foo='bar')) - assert s._execution_options == dict(foo='bar') + 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' + __dialect__ = "default" # fixme: consolidate converage from elsewhere here and expand @classmethod def setup_class(cls): global t1, t2 - t1 = table("table1", - column("col1"), - column("col2"), - column("col3"), - ) - t2 = table("table2", - column("col1"), - column("col2"), - column("col3"), - ) + t1 = table("table1", column("col1"), column("col2"), column("col3")) + t2 = table("table2", column("col1"), column("col2"), column("col3")) def test_prefixes(self): i = t1.insert() - self.assert_compile(i, - "INSERT INTO table1 (col1, col2, col3) " - "VALUES (:col1, :col2, :col3)") + self.assert_compile( + i, + "INSERT INTO table1 (col1, col2, col3) " + "VALUES (:col1, :col2, :col3)", + ) gen = i.prefix_with("foober") - self.assert_compile(gen, - "INSERT foober INTO table1 (col1, col2, col3) " - "VALUES (:col1, :col2, :col3)") + self.assert_compile( + gen, + "INSERT foober INTO table1 (col1, col2, col3) " + "VALUES (:col1, :col2, :col3)", + ) - self.assert_compile(i, - "INSERT INTO table1 (col1, col2, col3) " - "VALUES (:col1, :col2, :col3)") + self.assert_compile( + i, + "INSERT INTO table1 (col1, col2, col3) " + "VALUES (:col1, :col2, :col3)", + ) - i2 = t1.insert(prefixes=['squiznart']) - self.assert_compile(i2, - "INSERT squiznart INTO table1 (col1, col2, col3) " - "VALUES (:col1, :col2, :col3)") + i2 = t1.insert(prefixes=["squiznart"]) + self.assert_compile( + i2, + "INSERT squiznart INTO table1 (col1, col2, col3) " + "VALUES (:col1, :col2, :col3)", + ) gen2 = i2.prefix_with("quux") - self.assert_compile(gen2, - "INSERT squiznart quux INTO " - "table1 (col1, col2, col3) " - "VALUES (:col1, :col2, :col3)") + self.assert_compile( + gen2, + "INSERT squiznart quux INTO " + "table1 (col1, col2, col3) " + "VALUES (:col1, :col2, :col3)", + ) def test_add_kwarg(self): i = t1.insert() @@ -1857,11 +1876,13 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): i = t1.insert() 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}, - ] - ) + eq_( + i.parameters, + [ + {"col1": 5, "col2": 6, "col3": 7}, + {"col1": 8, "col2": 9, "col3": 10}, + ], + ) def test_inline_values_single(self): i = t1.insert(values={"col1": 5}) @@ -1895,7 +1916,8 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.InvalidRequestError, "This construct already has multiple parameter sets.", - i.values, col2=7 + i.values, + col2=7, ) def test_cant_mix_single_multi_formats_dict_to_list(self): @@ -1904,7 +1926,8 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): exc.ArgumentError, "Can't mix single-values and multiple values " "formats in one statement", - i.values, [{"col1": 6}] + i.values, + [{"col1": 6}], ) def test_cant_mix_single_multi_formats_list_to_dict(self): @@ -1913,7 +1936,8 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): exc.ArgumentError, "Can't mix single-values and multiple values " "formats in one statement", - i.values, {"col1": 5} + i.values, + {"col1": 5}, ) def test_erroneous_multi_args_dicts(self): @@ -1922,7 +1946,9 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): exc.ArgumentError, "Only a single dictionary/tuple or list of " "dictionaries/tuples is accepted positionally.", - i.values, {"col1": 5}, {"col1": 7} + i.values, + {"col1": 5}, + {"col1": 7}, ) def test_erroneous_multi_args_tuples(self): @@ -1931,7 +1957,9 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): exc.ArgumentError, "Only a single dictionary/tuple or list of " "dictionaries/tuples is accepted positionally.", - i.values, (5, 6, 7), (8, 9, 10) + i.values, + (5, 6, 7), + (8, 9, 10), ) def test_erroneous_multi_args_plus_kw(self): @@ -1939,7 +1967,9 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.ArgumentError, "Can't pass kwargs and multiple parameter sets simultaneously", - i.values, [{"col1": 5}], col2=7 + i.values, + [{"col1": 5}], + col2=7, ) def test_update_no_support_multi_values(self): @@ -1947,12 +1977,14 @@ class ValuesBaseTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.InvalidRequestError, "This construct does not support multiple parameter sets.", - u.values, [{"col1": 5}, {"col1": 7}] + u.values, + [{"col1": 5}, {"col1": 7}], ) def test_update_no_support_multi_constructor(self): assert_raises_message( exc.InvalidRequestError, "This construct does not support multiple parameter sets.", - t1.update, values=[{"col1": 5}, {"col1": 7}] + t1.update, + values=[{"col1": 5}, {"col1": 7}], ) diff --git a/test/sql/test_insert.py b/test/sql/test_insert.py index 729c420c0..3643deabd 100644 --- a/test/sql/test_insert.py +++ b/test/sql/test_insert.py @@ -1,144 +1,167 @@ #! coding:utf-8 -from sqlalchemy import Column, Integer, MetaData, String, Table,\ - bindparam, exc, func, insert, select, column, text, table,\ - Sequence +from sqlalchemy import ( + Column, + Integer, + MetaData, + String, + Table, + bindparam, + exc, + func, + insert, + select, + column, + text, + table, + Sequence, +) from sqlalchemy.dialects import mysql, postgresql from sqlalchemy.engine import default -from sqlalchemy.testing import AssertsCompiledSQL,\ - assert_raises_message, fixtures, eq_, expect_warnings, assert_raises +from sqlalchemy.testing import ( + AssertsCompiledSQL, + assert_raises_message, + fixtures, + eq_, + expect_warnings, + assert_raises, +) from sqlalchemy.sql import crud class _InsertTestBase(object): - @classmethod def define_tables(cls, metadata): - Table('mytable', metadata, - Column('myid', Integer), - Column('name', String(30)), - Column('description', String(30))) - Table('myothertable', metadata, - Column('otherid', Integer, primary_key=True), - Column('othername', String(30))) - Table('table_w_defaults', metadata, - Column('id', Integer, primary_key=True), - Column('x', Integer, default=10), - Column('y', Integer, server_default=text('5')), - Column('z', Integer, default=lambda: 10)) + Table( + "mytable", + metadata, + Column("myid", Integer), + Column("name", String(30)), + Column("description", String(30)), + ) + Table( + "myothertable", + metadata, + Column("otherid", Integer, primary_key=True), + Column("othername", String(30)), + ) + Table( + "table_w_defaults", + metadata, + Column("id", Integer, primary_key=True), + Column("x", Integer, default=10), + Column("y", Integer, server_default=text("5")), + Column("z", Integer, default=lambda: 10), + ) class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_binds_that_match_columns(self): """test bind params named after column names replace the normal SET/VALUES generation.""" - t = table('foo', column('x'), column('y')) + t = table("foo", column("x"), column("y")) - i = t.insert().values(x=3 + bindparam('x')) - self.assert_compile(i, - "INSERT INTO foo (x) VALUES ((:param_1 + :x))") + 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}) + params={"x": 1, "y": 2}, + ) - i = t.insert().values(x=bindparam('y')) + i = t.insert().values(x=bindparam("y")) self.assert_compile(i, "INSERT INTO foo (x) VALUES (:y)") - i = t.insert().values(x=bindparam('y'), y=5) + i = t.insert().values(x=bindparam("y"), y=5) assert_raises(exc.CompileError, i.compile) - i = t.insert().values(x=3 + bindparam('y'), y=5) + i = t.insert().values(x=3 + bindparam("y"), y=5) assert_raises(exc.CompileError, i.compile) - i = t.insert().values(x=3 + bindparam('x2')) - self.assert_compile(i, - "INSERT INTO foo (x) VALUES ((:param_1 + :x2))") + 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={}) + 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}) + params={"x": 1, "y": 2}, + ) self.assert_compile( i, "INSERT INTO foo (x, y) VALUES ((:param_1 + :x2), :y)", - params={ - 'x2': 1, - 'y': 2}) + params={"x2": 1, "y": 2}, + ) def test_insert_literal_binds(self): table1 = self.tables.mytable - stmt = table1.insert().values(myid=3, name='jack') + stmt = table1.insert().values(myid=3, name="jack") self.assert_compile( stmt, "INSERT INTO mytable (myid, name) VALUES (3, 'jack')", - literal_binds=True) + literal_binds=True, + ) def test_insert_literal_binds_sequence_notimplemented(self): - table = Table('x', MetaData(), Column('y', Integer, Sequence('y_seq'))) + table = Table("x", MetaData(), Column("y", Integer, Sequence("y_seq"))) dialect = default.DefaultDialect() dialect.supports_sequences = True - stmt = table.insert().values(myid=3, name='jack') + stmt = table.insert().values(myid=3, name="jack") assert_raises( NotImplementedError, stmt.compile, - compile_kwargs=dict(literal_binds=True), dialect=dialect + compile_kwargs=dict(literal_binds=True), + dialect=dialect, ) def test_inline_defaults(self): m = MetaData() - foo = Table('foo', m, - Column('id', Integer)) + foo = Table("foo", m, 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))])), - ) + t = Table( + "test", + m, + 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={}), + t.insert(inline=True, values={}), "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " - "foo))") + "foo))", + ) def test_generic_insert_bind_params_all_columns(self): table1 = self.tables.mytable - self.assert_compile(insert(table1), - 'INSERT INTO mytable (myid, name, description) ' - 'VALUES (:myid, :name, :description)') + self.assert_compile( + insert(table1), + "INSERT INTO mytable (myid, name, description) " + "VALUES (:myid, :name, :description)", + ) def test_insert_with_values_dict(self): table1 = self.tables.mytable - checkparams = { - 'myid': 3, - 'name': 'jack' - } + checkparams = {"myid": 3, "name": "jack"} self.assert_compile( - insert( - table1, - dict( - myid=3, - name='jack')), - 'INSERT INTO mytable (myid, name) VALUES (:myid, :name)', - checkparams=checkparams) + insert(table1, dict(myid=3, name="jack")), + "INSERT INTO mytable (myid, name) VALUES (:myid, :name)", + checkparams=checkparams, + ) def test_unconsumed_names_kwargs(self): t = table("t", column("x"), column("y")) @@ -151,136 +174,133 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def test_bindparam_name_no_consume_error(self): t = table("t", column("x"), column("y")) # bindparam names don't get counted - i = t.insert().values(x=3 + bindparam('x2')) - self.assert_compile( - i, - "INSERT INTO t (x) VALUES ((:param_1 + :x2))" - ) + i = t.insert().values(x=3 + bindparam("x2")) + self.assert_compile(i, "INSERT INTO t (x) VALUES ((:param_1 + :x2))") # even if in the params list - i = t.insert().values(x=3 + bindparam('x2')) + i = t.insert().values(x=3 + bindparam("x2")) self.assert_compile( - i, - "INSERT INTO t (x) VALUES ((:param_1 + :x2))", - params={"x2": 1} + i, "INSERT INTO t (x) VALUES ((:param_1 + :x2))", params={"x2": 1} ) def test_unconsumed_names_values_dict(self): table1 = self.tables.mytable - checkparams = { - 'myid': 3, - 'name': 'jack', - 'unknowncol': 'oops' - } + checkparams = {"myid": 3, "name": "jack", "unknowncol": "oops"} stmt = insert(table1, values=checkparams) assert_raises_message( exc.CompileError, - 'Unconsumed column names: unknowncol', + "Unconsumed column names: unknowncol", stmt.compile, - dialect=postgresql.dialect() + dialect=postgresql.dialect(), ) def test_unconsumed_names_multi_values_dict(self): table1 = self.tables.mytable - checkparams = [{ - 'myid': 3, - 'name': 'jack', - 'unknowncol': 'oops' - }, { - 'myid': 4, - 'name': 'someone', - 'unknowncol': 'oops' - }] + checkparams = [ + {"myid": 3, "name": "jack", "unknowncol": "oops"}, + {"myid": 4, "name": "someone", "unknowncol": "oops"}, + ] stmt = insert(table1, values=checkparams) assert_raises_message( exc.CompileError, - 'Unconsumed column names: unknowncol', + "Unconsumed column names: unknowncol", stmt.compile, - dialect=postgresql.dialect() + dialect=postgresql.dialect(), ) def test_insert_with_values_tuple(self): table1 = self.tables.mytable checkparams = { - 'myid': 3, - 'name': 'jack', - 'description': 'mydescription' + "myid": 3, + "name": "jack", + "description": "mydescription", } - self.assert_compile(insert(table1, (3, 'jack', 'mydescription')), - 'INSERT INTO mytable (myid, name, description) ' - 'VALUES (:myid, :name, :description)', - checkparams=checkparams) + self.assert_compile( + insert(table1, (3, "jack", "mydescription")), + "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())') + self.assert_compile( + insert(table1, values=dict(myid=func.lala())), + "INSERT INTO mytable (myid) VALUES (lala())", + ) def test_insert_with_user_supplied_bind_params(self): table1 = self.tables.mytable values = { - table1.c.myid: bindparam('userid'), - table1.c.name: bindparam('username') + table1.c.myid: bindparam("userid"), + table1.c.name: bindparam("username"), } self.assert_compile( - insert( - table1, - values), - 'INSERT INTO mytable (myid, name) VALUES (:userid, :username)') + insert(table1, values), + "INSERT INTO mytable (myid, name) VALUES (:userid, :username)", + ) def test_insert_values(self): table1 = self.tables.mytable - values1 = {table1.c.myid: bindparam('userid')} - values2 = {table1.c.name: bindparam('username')} + values1 = {table1.c.myid: bindparam("userid")} + values2 = {table1.c.name: bindparam("username")} self.assert_compile( - insert( - table1, - values=values1).values(values2), - 'INSERT INTO mytable (myid, name) VALUES (:userid, :username)') + insert(table1, values=values1).values(values2), + "INSERT INTO mytable (myid, name) VALUES (:userid, :username)", + ) def test_prefix_with(self): table1 = self.tables.mytable - stmt = table1.insert().\ - prefix_with('A', 'B', dialect='mysql').\ - prefix_with('C', 'D') + stmt = ( + table1.insert() + .prefix_with("A", "B", dialect="mysql") + .prefix_with("C", "D") + ) self.assert_compile( stmt, - 'INSERT C D INTO mytable (myid, name, description) ' - 'VALUES (:myid, :name, :description)') + "INSERT C D INTO mytable (myid, name, description) " + "VALUES (:myid, :name, :description)", + ) self.assert_compile( stmt, - 'INSERT A B C D INTO mytable (myid, name, description) ' - 'VALUES (%s, %s, %s)', - dialect=mysql.dialect()) + "INSERT A B C D INTO mytable (myid, name, description) " + "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())) + table = Table( + "sometable", + metadata, + 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())') + self.assert_compile( + table.insert(values={}, inline=True), + "INSERT INTO sometable (foo) VALUES (foobar())", + ) self.assert_compile( - table.insert( - inline=True), - 'INSERT INTO sometable (foo) VALUES (foobar())', - params={}) + table.insert(inline=True), + "INSERT INTO sometable (foo) VALUES (foobar())", + params={}, + ) def test_insert_returning_not_in_default(self): table1 = self.tables.mytable @@ -290,68 +310,75 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): exc.CompileError, "RETURNING is not supported by this dialect's statement compiler.", stmt.compile, - dialect=default.DefaultDialect() + dialect=default.DefaultDialect(), ) def test_insert_from_select_returning(self): table1 = self.tables.mytable sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == 'foo') - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel).returning( - self.tables.myothertable.c.otherid - ) + table1.c.name == "foo" + ) + ins = ( + self.tables.myothertable.insert() + .from_select(("otherid", "othername"), sel) + .returning(self.tables.myothertable.c.otherid) + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable " "WHERE mytable.name = %(name_1)s RETURNING myothertable.otherid", checkparams={"name_1": "foo"}, - dialect="postgresql" + dialect="postgresql", ) def test_insert_from_select_select(self): table1 = self.tables.mytable sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == 'foo') - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + table1.c.name == "foo" + ) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), sel + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable " "WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_from_select_seq(self): m = MetaData() t1 = Table( - 't', m, - Column('id', Integer, Sequence('id_seq'), primary_key=True), - Column('data', String) + "t", + m, + Column("id", Integer, Sequence("id_seq"), primary_key=True), + Column("data", String), ) - stmt = t1.insert().from_select(('data', ), select([t1.c.data])) + stmt = t1.insert().from_select(("data",), select([t1.c.data])) self.assert_compile( stmt, "INSERT INTO t (data, id) SELECT t.data, " "nextval('id_seq') AS next_value_1 FROM t", - dialect=postgresql.dialect() + dialect=postgresql.dialect(), ) def test_insert_from_select_cte_one(self): table1 = self.tables.mytable - cte = select([table1.c.name]).where(table1.c.name == 'bar').cte() + cte = select([table1.c.name]).where(table1.c.name == "bar").cte() sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == cte.c.name) + table1.c.name == cte.c.name + ) - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), sel + ) self.assert_compile( ins, "WITH anon_1 AS " @@ -360,7 +387,7 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable, anon_1 " "WHERE mytable.name = anon_1.name", - checkparams={"name_1": "bar"} + checkparams={"name_1": "bar"}, ) def test_insert_from_select_cte_follows_insert_one(self): @@ -369,13 +396,15 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1 = self.tables.mytable - cte = select([table1.c.name]).where(table1.c.name == 'bar').cte() + cte = select([table1.c.name]).where(table1.c.name == "bar").cte() sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == cte.c.name) + table1.c.name == cte.c.name + ) - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), sel + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " @@ -385,7 +414,7 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "SELECT mytable.myid, mytable.name FROM mytable, anon_1 " "WHERE mytable.name = anon_1.name", checkparams={"name_1": "bar"}, - dialect=dialect + dialect=dialect, ) def test_insert_from_select_cte_two(self): @@ -400,7 +429,7 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "WITH c AS (SELECT mytable.myid AS myid, mytable.name AS name, " "mytable.description AS description FROM mytable) " "INSERT INTO mytable (myid, name, description) " - "SELECT c.myid, c.name, c.description FROM c" + "SELECT c.myid, c.name, c.description FROM c", ) def test_insert_from_select_cte_follows_insert_two(self): @@ -418,91 +447,101 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "WITH c AS (SELECT mytable.myid AS myid, mytable.name AS name, " "mytable.description AS description FROM mytable) " "SELECT c.myid, c.name, c.description FROM c", - dialect=dialect + dialect=dialect, ) 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') - ins = self.tables.myothertable.insert().\ - from_select(("othername", "otherid"), sel) + table1.c.name == "foo" + ) + ins = self.tables.myothertable.insert().from_select( + ("othername", "otherid"), sel + ) self.assert_compile( ins, "INSERT INTO myothertable (othername, otherid) " "SELECT mytable.name, mytable.myid FROM mytable " "WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_from_select_no_defaults(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=func.foobar())) + table = Table( + "sometable", + metadata, + 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, include_defaults=False) + sel = select([table1.c.myid]).where(table1.c.name == "foo") + ins = table.insert().from_select(["id"], sel, include_defaults=False) self.assert_compile( ins, "INSERT INTO sometable (id) SELECT mytable.myid " "FROM mytable WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_from_select_with_sql_defaults(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=func.foobar())) + table = Table( + "sometable", + metadata, + 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) + sel = select([table1.c.myid]).where(table1.c.name == "foo") + ins = table.insert().from_select(["id"], sel) self.assert_compile( ins, "INSERT INTO sometable (id, foo) SELECT " "mytable.myid, foobar() AS foobar_1 " "FROM mytable WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_from_select_with_python_defaults(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=12)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("foo", Integer, default=12), + ) table1 = self.tables.mytable - sel = select([table1.c.myid]).where(table1.c.name == 'foo') - ins = table.insert().\ - from_select(["id"], sel) + sel = select([table1.c.myid]).where(table1.c.name == "foo") + ins = table.insert().from_select(["id"], sel) self.assert_compile( ins, "INSERT INTO sometable (id, foo) SELECT " "mytable.myid, :foo AS anon_1 " "FROM mytable WHERE mytable.name = :name_1", # value filled in at execution time - checkparams={"name_1": "foo", "foo": None} + checkparams={"name_1": "foo", "foo": None}, ) def test_insert_from_select_override_defaults(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=12)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("foo", Integer, default=12), + ) table1 = self.tables.mytable - sel = select( - [table1.c.myid, table1.c.myid.label('q')]).where( - table1.c.name == 'foo') - ins = table.insert().\ - from_select(["id", "foo"], sel) + sel = select([table1.c.myid, table1.c.myid.label("q")]).where( + table1.c.name == "foo" + ) + ins = table.insert().from_select(["id", "foo"], sel) self.assert_compile( ins, "INSERT INTO sometable (id, foo) SELECT " "mytable.myid, mytable.myid AS q " "FROM mytable WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_from_select_fn_defaults(self): @@ -511,159 +550,171 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): def foo(ctx): return 12 - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('foo', Integer, default=foo)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("foo", Integer, default=foo), + ) table1 = self.tables.mytable - sel = select( - [table1.c.myid]).where( - table1.c.name == 'foo') - ins = table.insert().\ - from_select(["id"], sel) + sel = select([table1.c.myid]).where(table1.c.name == "foo") + ins = table.insert().from_select(["id"], sel) self.assert_compile( ins, "INSERT INTO sometable (id, foo) SELECT " "mytable.myid, :foo AS anon_1 " "FROM mytable WHERE mytable.name = :name_1", # value filled in at execution time - checkparams={"name_1": "foo", "foo": None} + checkparams={"name_1": "foo", "foo": None}, ) def test_insert_from_select_dont_mutate_raw_columns(self): # test [ticket:3603] from sqlalchemy import table + table_ = table( - 'mytable', - Column('foo', String), - Column('bar', String, default='baz'), + "mytable", + Column("foo", String), + Column("bar", String, default="baz"), ) stmt = select([table_.c.foo]) - insert = table_.insert().from_select(['foo'], stmt) + insert = table_.insert().from_select(["foo"], stmt) self.assert_compile(stmt, "SELECT mytable.foo FROM mytable") self.assert_compile( insert, "INSERT INTO mytable (foo, bar) " - "SELECT mytable.foo, :bar AS anon_1 FROM mytable" + "SELECT mytable.foo, :bar AS anon_1 FROM mytable", ) self.assert_compile(stmt, "SELECT mytable.foo FROM mytable") self.assert_compile( insert, "INSERT INTO mytable (foo, bar) " - "SELECT mytable.foo, :bar AS anon_1 FROM mytable" + "SELECT mytable.foo, :bar AS anon_1 FROM mytable", ) 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') - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + table1.c.name == "foo" + ) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), sel + ) assert_raises_message( exc.InvalidRequestError, "This construct already inserts from a SELECT", - ins.values, othername="5" + ins.values, + othername="5", ) 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') + table1.c.name == "foo" + ) ins = self.tables.myothertable.insert().values(othername="5") assert_raises_message( exc.InvalidRequestError, "This construct already inserts value expressions", - ins.from_select, ("otherid", "othername"), sel + ins.from_select, + ("otherid", "othername"), + sel, ) def test_insert_from_select_table(self): table1 = self.tables.mytable - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), table1) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), table1 + ) # note we aren't checking the number of columns right now self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name, mytable.description " "FROM mytable", - checkparams={} + checkparams={}, ) def test_insert_from_select_union(self): mytable = self.tables.mytable - name = column('name') - description = column('desc') - sel = select( - [name, mytable.c.description], - ).union( + name = column("name") + description = column("desc") + sel = select([name, mytable.c.description]).union( select([name, description]) ) - ins = mytable.insert().\ - from_select( - [mytable.c.name, mytable.c.description], sel) + ins = mytable.insert().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"' + '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') - ins = table2.insert().\ - from_select((table2.c.otherid, table2.c.othername), sel) + table1.c.name == "foo" + ) + ins = table2.insert().from_select( + (table2.c.otherid, table2.c.othername), sel + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable " "WHERE mytable.name = :name_1", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_anticipate_no_pk_composite_pk(self): t = Table( - 't', MetaData(), Column('x', Integer, primary_key=True), - Column('y', Integer, primary_key=True) + "t", + MetaData(), + Column("x", Integer, primary_key=True), + Column("y", Integer, primary_key=True), ) with expect_warnings( "Column 't.y' is marked as a member.*" - "Note that as of SQLAlchemy 1.1,", + "Note that as of SQLAlchemy 1.1," ): self.assert_compile( - t.insert(), - "INSERT INTO t (x) VALUES (:x)", - params={'x': 5}, + t.insert(), "INSERT INTO t (x) VALUES (:x)", params={"x": 5} ) def test_anticipate_no_pk_composite_pk_implicit_returning(self): t = Table( - 't', MetaData(), Column('x', Integer, primary_key=True), - Column('y', Integer, primary_key=True) + "t", + MetaData(), + Column("x", Integer, primary_key=True), + Column("y", Integer, primary_key=True), ) d = postgresql.dialect() d.implicit_returning = True with expect_warnings( "Column 't.y' is marked as a member.*" - "Note that as of SQLAlchemy 1.1,", + "Note that as of SQLAlchemy 1.1," ): self.assert_compile( t.insert(), "INSERT INTO t (x) VALUES (%(x)s)", params={"x": 5}, - dialect=d + dialect=d, ) def test_anticipate_no_pk_composite_pk_prefetch(self): t = Table( - 't', MetaData(), Column('x', Integer, primary_key=True), - Column('y', Integer, primary_key=True) + "t", + MetaData(), + Column("x", Integer, primary_key=True), + Column("y", Integer, primary_key=True), ) d = postgresql.dialect() d.implicit_returning = False @@ -674,202 +725,193 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( t.insert(), "INSERT INTO t (x) VALUES (%(x)s)", - params={'x': 5}, - dialect=d + params={"x": 5}, + dialect=d, ) def test_anticipate_nullable_composite_pk(self): t = Table( - 't', MetaData(), Column('x', Integer, primary_key=True), - Column('y', Integer, primary_key=True, nullable=True) + "t", + MetaData(), + Column("x", Integer, primary_key=True), + Column("y", Integer, primary_key=True, nullable=True), ) self.assert_compile( - t.insert(), - "INSERT INTO t (x) VALUES (:x)", - params={'x': 5}, + t.insert(), "INSERT INTO t (x) VALUES (:x)", params={"x": 5} ) def test_anticipate_no_pk_non_composite_pk(self): t = Table( - 't', MetaData(), - Column('x', Integer, primary_key=True, autoincrement=False), - Column('q', Integer) + "t", + MetaData(), + Column("x", Integer, primary_key=True, autoincrement=False), + Column("q", Integer), ) with expect_warnings( - "Column 't.x' is marked as a member.*" - "may not store NULL.$" + "Column 't.x' is marked as a member.*" "may not store NULL.$" ): self.assert_compile( - t.insert(), - "INSERT INTO t (q) VALUES (:q)", - params={"q": 5} + t.insert(), "INSERT INTO t (q) VALUES (:q)", params={"q": 5} ) def test_anticipate_no_pk_non_composite_pk_implicit_returning(self): t = Table( - 't', MetaData(), - Column('x', Integer, primary_key=True, autoincrement=False), - Column('q', Integer) + "t", + MetaData(), + Column("x", Integer, primary_key=True, autoincrement=False), + Column("q", Integer), ) d = postgresql.dialect() d.implicit_returning = True with expect_warnings( - "Column 't.x' is marked as a member.*" - "may not store NULL.$", + "Column 't.x' is marked as a member.*" "may not store NULL.$" ): self.assert_compile( t.insert(), "INSERT INTO t (q) VALUES (%(q)s)", params={"q": 5}, - dialect=d + dialect=d, ) def test_anticipate_no_pk_non_composite_pk_prefetch(self): t = Table( - 't', MetaData(), - Column('x', Integer, primary_key=True, autoincrement=False), - Column('q', Integer) + "t", + MetaData(), + Column("x", Integer, primary_key=True, autoincrement=False), + Column("q", Integer), ) d = postgresql.dialect() d.implicit_returning = False with expect_warnings( - "Column 't.x' is marked as a member.*" - "may not store NULL.$" + "Column 't.x' is marked as a member.*" "may not store NULL.$" ): self.assert_compile( t.insert(), "INSERT INTO t (q) VALUES (%(q)s)", params={"q": 5}, - dialect=d + dialect=d, ) def test_anticipate_no_pk_lower_case_table(self): t = table( - 't', - Column( - 'id', Integer, primary_key=True, autoincrement=False), - Column('notpk', String(10), nullable=True) + "t", + Column("id", Integer, primary_key=True, autoincrement=False), + Column("notpk", String(10), nullable=True), ) with expect_warnings( - "Column 't.id' is marked as a member.*" - "may not store NULL.$" + "Column 't.id' is marked as a member.*" "may not store NULL.$" ): self.assert_compile( - t.insert(), - "INSERT INTO t () VALUES ()", - params={} + t.insert(), "INSERT INTO t () VALUES ()", params={} ) class InsertImplicitReturningTest( - _InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): + _InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL +): __dialect__ = postgresql.dialect(implicit_returning=True) def test_insert_select(self): table1 = self.tables.mytable sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == 'foo') - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel) + table1.c.name == "foo" + ) + ins = self.tables.myothertable.insert().from_select( + ("otherid", "othername"), sel + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable " "WHERE mytable.name = %(name_1)s", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_select_return_defaults(self): table1 = self.tables.mytable sel = select([table1.c.myid, table1.c.name]).where( - table1.c.name == 'foo') - ins = self.tables.myothertable.insert().\ - from_select(("otherid", "othername"), sel).\ - return_defaults(self.tables.myothertable.c.otherid) + table1.c.name == "foo" + ) + ins = ( + self.tables.myothertable.insert() + .from_select(("otherid", "othername"), sel) + .return_defaults(self.tables.myothertable.c.otherid) + ) self.assert_compile( ins, "INSERT INTO myothertable (otherid, othername) " "SELECT mytable.myid, mytable.name FROM mytable " "WHERE mytable.name = %(name_1)s", - checkparams={"name_1": "foo"} + checkparams={"name_1": "foo"}, ) def test_insert_multiple_values(self): - ins = self.tables.myothertable.insert().values([ - {"othername": "foo"}, - {"othername": "bar"}, - ]) + ins = self.tables.myothertable.insert().values( + [{"othername": "foo"}, {"othername": "bar"}] + ) self.assert_compile( ins, "INSERT INTO myothertable (othername) " "VALUES (%(othername_m0)s), " "(%(othername_m1)s)", - checkparams={ - 'othername_m1': 'bar', - 'othername_m0': 'foo'} + checkparams={"othername_m1": "bar", "othername_m0": "foo"}, ) def test_insert_multiple_values_literal_binds(self): - ins = self.tables.myothertable.insert().values([ - {"othername": "foo"}, - {"othername": "bar"}, - ]) + ins = self.tables.myothertable.insert().values( + [{"othername": "foo"}, {"othername": "bar"}] + ) self.assert_compile( ins, "INSERT INTO myothertable (othername) VALUES ('foo'), ('bar')", checkparams={}, - literal_binds=True + literal_binds=True, ) def test_insert_multiple_values_return_defaults(self): # TODO: not sure if this should raise an # error or what - ins = self.tables.myothertable.insert().values([ - {"othername": "foo"}, - {"othername": "bar"}, - ]).return_defaults(self.tables.myothertable.c.otherid) + ins = ( + self.tables.myothertable.insert() + .values([{"othername": "foo"}, {"othername": "bar"}]) + .return_defaults(self.tables.myothertable.c.otherid) + ) self.assert_compile( ins, "INSERT INTO myothertable (othername) " "VALUES (%(othername_m0)s), " "(%(othername_m1)s)", - checkparams={ - 'othername_m1': 'bar', - 'othername_m0': 'foo'} + checkparams={"othername_m1": "bar", "othername_m0": "foo"}, ) def test_insert_single_list_values(self): - ins = self.tables.myothertable.insert().values([ - {"othername": "foo"}, - ]) + ins = self.tables.myothertable.insert().values([{"othername": "foo"}]) self.assert_compile( ins, "INSERT INTO myothertable (othername) " "VALUES (%(othername_m0)s)", - checkparams={'othername_m0': 'foo'} + checkparams={"othername_m0": "foo"}, ) def test_insert_single_element_values(self): - ins = self.tables.myothertable.insert().values( - {"othername": "foo"}, - ) + ins = self.tables.myothertable.insert().values({"othername": "foo"}) self.assert_compile( ins, "INSERT INTO myothertable (othername) " "VALUES (%(othername)s) RETURNING myothertable.otherid", - checkparams={'othername': 'foo'} + checkparams={"othername": "foo"}, ) class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_empty_insert_default(self): table1 = self.tables.mytable stmt = table1.insert().values({}) # hide from 2to3 - self.assert_compile(stmt, 'INSERT INTO mytable () VALUES ()') + self.assert_compile(stmt, "INSERT INTO mytable () VALUES ()") def test_supports_empty_insert_true(self): table1 = self.tables.mytable @@ -878,9 +920,9 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): dialect.supports_empty_insert = dialect.supports_default_values = True stmt = table1.insert().values({}) # hide from 2to3 - self.assert_compile(stmt, - 'INSERT INTO mytable DEFAULT VALUES', - dialect=dialect) + self.assert_compile( + stmt, "INSERT INTO mytable DEFAULT VALUES", dialect=dialect + ) def test_supports_empty_insert_false(self): table1 = self.tables.mytable @@ -894,21 +936,24 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "The 'default' dialect with current database version " "settings does not support empty inserts.", stmt.compile, - dialect=dialect) + dialect=dialect, + ) def _test_insert_with_empty_collection_values(self, collection): table1 = self.tables.mytable ins = table1.insert().values(collection) - self.assert_compile(ins, - 'INSERT INTO mytable () VALUES ()', - checkparams={}) + self.assert_compile( + ins, "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}) + self.assert_compile( + ins.values(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([]) @@ -921,38 +966,40 @@ class EmptyTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_not_supported(self): table1 = self.tables.mytable dialect = default.DefaultDialect() - stmt = table1.insert().values([{'myid': 1}, {'myid': 2}]) + stmt = table1.insert().values([{"myid": 1}, {"myid": 2}]) assert_raises_message( exc.CompileError, "The 'default' dialect with current database version settings " "does not support in-place multirow inserts.", - stmt.compile, dialect=dialect) + stmt.compile, + dialect=dialect, + ) def test_named(self): table1 = self.tables.mytable values = [ - {'myid': 1, 'name': 'a', 'description': 'b'}, - {'myid': 2, 'name': 'c', 'description': 'd'}, - {'myid': 3, 'name': 'e', 'description': 'f'} + {"myid": 1, "name": "a", "description": "b"}, + {"myid": 2, "name": "c", "description": "d"}, + {"myid": 3, "name": "e", "description": "f"}, ] checkparams = { - 'myid_m0': 1, - 'myid_m1': 2, - 'myid_m2': 3, - 'name_m0': 'a', - 'name_m1': 'c', - 'name_m2': 'e', - 'description_m0': 'b', - 'description_m1': 'd', - 'description_m2': 'f', + "myid_m0": 1, + "myid_m1": 2, + "myid_m2": 3, + "name_m0": "a", + "name_m1": "c", + "name_m2": "e", + "description_m0": "b", + "description_m1": "d", + "description_m2": "f", } dialect = default.DefaultDialect() @@ -960,32 +1007,33 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( table1.insert().values(values), - 'INSERT INTO mytable (myid, name, description) VALUES ' - '(:myid_m0, :name_m0, :description_m0), ' - '(:myid_m1, :name_m1, :description_m1), ' - '(:myid_m2, :name_m2, :description_m2)', + "INSERT INTO mytable (myid, name, description) VALUES " + "(:myid_m0, :name_m0, :description_m0), " + "(:myid_m1, :name_m1, :description_m1), " + "(:myid_m2, :name_m2, :description_m2)", checkparams=checkparams, - dialect=dialect) + dialect=dialect, + ) def test_named_with_column_objects(self): table1 = self.tables.mytable values = [ - {table1.c.myid: 1, table1.c.name: 'a', table1.c.description: 'b'}, - {table1.c.myid: 2, table1.c.name: 'c', table1.c.description: 'd'}, - {table1.c.myid: 3, table1.c.name: 'e', table1.c.description: 'f'}, + {table1.c.myid: 1, table1.c.name: "a", table1.c.description: "b"}, + {table1.c.myid: 2, table1.c.name: "c", table1.c.description: "d"}, + {table1.c.myid: 3, table1.c.name: "e", table1.c.description: "f"}, ] checkparams = { - 'myid_m0': 1, - 'myid_m1': 2, - 'myid_m2': 3, - 'name_m0': 'a', - 'name_m1': 'c', - 'name_m2': 'e', - 'description_m0': 'b', - 'description_m1': 'd', - 'description_m2': 'f', + "myid_m0": 1, + "myid_m1": 2, + "myid_m2": 3, + "name_m0": "a", + "name_m1": "c", + "name_m2": "e", + "description_m0": "b", + "description_m1": "d", + "description_m2": "f", } dialect = default.DefaultDialect() @@ -993,50 +1041,48 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): self.assert_compile( table1.insert().values(values), - 'INSERT INTO mytable (myid, name, description) VALUES ' - '(:myid_m0, :name_m0, :description_m0), ' - '(:myid_m1, :name_m1, :description_m1), ' - '(:myid_m2, :name_m2, :description_m2)', + "INSERT INTO mytable (myid, name, description) VALUES " + "(:myid_m0, :name_m0, :description_m0), " + "(:myid_m1, :name_m1, :description_m1), " + "(:myid_m2, :name_m2, :description_m2)", checkparams=checkparams, - dialect=dialect) + dialect=dialect, + ) def test_positional(self): table1 = self.tables.mytable values = [ - {'myid': 1, 'name': 'a', 'description': 'b'}, - {'myid': 2, 'name': 'c', 'description': 'd'}, - {'myid': 3, 'name': 'e', 'description': 'f'} + {"myid": 1, "name": "a", "description": "b"}, + {"myid": 2, "name": "c", "description": "d"}, + {"myid": 3, "name": "e", "description": "f"}, ] - checkpositional = (1, 'a', 'b', 2, 'c', 'd', 3, 'e', 'f') + checkpositional = (1, "a", "b", 2, "c", "d", 3, "e", "f") dialect = default.DefaultDialect() dialect.supports_multivalues_insert = True - dialect.paramstyle = 'format' + dialect.paramstyle = "format" dialect.positional = True self.assert_compile( table1.insert().values(values), - 'INSERT INTO mytable (myid, name, description) VALUES ' - '(%s, %s, %s), (%s, %s, %s), (%s, %s, %s)', + "INSERT INTO mytable (myid, name, description) VALUES " + "(%s, %s, %s), (%s, %s, %s), (%s, %s, %s)", checkpositional=checkpositional, - dialect=dialect) + dialect=dialect, + ) def test_positional_w_defaults(self): table1 = self.tables.table_w_defaults - values = [ - {'id': 1}, - {'id': 2}, - {'id': 3} - ] + values = [{"id": 1}, {"id": 2}, {"id": 3}] checkpositional = (1, None, None, 2, None, None, 3, None, None) dialect = default.DefaultDialect() dialect.supports_multivalues_insert = True - dialect.paramstyle = 'format' + dialect.paramstyle = "format" dialect.positional = True self.assert_compile( @@ -1045,128 +1091,163 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "(%s, %s, %s), (%s, %s, %s), (%s, %s, %s)", checkpositional=checkpositional, check_prefetch=[ - table1.c.x, table1.c.z, + table1.c.x, + table1.c.z, crud._multiparam_column(table1.c.x, 0), crud._multiparam_column(table1.c.z, 0), crud._multiparam_column(table1.c.x, 1), - crud._multiparam_column(table1.c.z, 1) + crud._multiparam_column(table1.c.z, 1), ], - dialect=dialect) + 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())) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer, default=func.foobar()), + ) values = [ - {'id': 1, 'data': 'data1'}, - {'id': 2, 'data': 'data2', 'foo': 'plainfoo'}, - {'id': 3, 'data': 'data3'}, + {"id": 1, "data": "data1"}, + {"id": 2, "data": "data2", "foo": "plainfoo"}, + {"id": 3, "data": "data3"}, ] checkparams = { - 'id_m0': 1, - 'id_m1': 2, - 'id_m2': 3, - 'data_m0': 'data1', - 'data_m1': 'data2', - 'data_m2': 'data3', - 'foo_m1': 'plainfoo', + "id_m0": 1, + "id_m1": 2, + "id_m2": 3, + "data_m0": "data1", + "data_m1": "data2", + "data_m2": "data3", + "foo_m1": "plainfoo", } self.assert_compile( table.insert().values(values), - 'INSERT INTO sometable (id, data, foo) VALUES ' - '(%(id_m0)s, %(data_m0)s, foobar()), ' - '(%(id_m1)s, %(data_m1)s, %(foo_m1)s), ' - '(%(id_m2)s, %(data_m2)s, foobar())', + "INSERT INTO sometable (id, data, foo) VALUES " + "(%(id_m0)s, %(data_m0)s, foobar()), " + "(%(id_m1)s, %(data_m1)s, %(foo_m1)s), " + "(%(id_m2)s, %(data_m2)s, foobar())", checkparams=checkparams, - dialect=postgresql.dialect()) + dialect=postgresql.dialect(), + ) def test_python_scalar_default(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer, default=10)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer, default=10), + ) values = [ - {'id': 1, 'data': 'data1'}, - {'id': 2, 'data': 'data2', 'foo': 15}, - {'id': 3, 'data': 'data3'}, + {"id": 1, "data": "data1"}, + {"id": 2, "data": "data2", "foo": 15}, + {"id": 3, "data": "data3"}, ] checkparams = { - 'id_m0': 1, - 'id_m1': 2, - 'id_m2': 3, - 'data_m0': 'data1', - 'data_m1': 'data2', - 'data_m2': 'data3', - 'foo': None, # evaluated later - 'foo_m1': 15, - 'foo_m2': None # evaluated later + "id_m0": 1, + "id_m1": 2, + "id_m2": 3, + "data_m0": "data1", + "data_m1": "data2", + "data_m2": "data3", + "foo": None, # evaluated later + "foo_m1": 15, + "foo_m2": None, # evaluated later } stmt = table.insert().values(values) eq_( - dict([ - (k, v.type._type_affinity) - for (k, v) in - stmt.compile(dialect=postgresql.dialect()).binds.items()]), + dict( + [ + (k, v.type._type_affinity) + for (k, v) in stmt.compile( + dialect=postgresql.dialect() + ).binds.items() + ] + ), { - 'foo': Integer, 'data_m2': String, 'id_m0': Integer, - 'id_m2': Integer, 'foo_m1': Integer, 'data_m1': String, - 'id_m1': Integer, 'foo_m2': Integer, 'data_m0': String} + "foo": Integer, + "data_m2": String, + "id_m0": Integer, + "id_m2": Integer, + "foo_m1": Integer, + "data_m1": String, + "id_m1": Integer, + "foo_m2": Integer, + "data_m0": String, + }, ) self.assert_compile( stmt, - 'INSERT INTO sometable (id, data, foo) VALUES ' - '(%(id_m0)s, %(data_m0)s, %(foo)s), ' - '(%(id_m1)s, %(data_m1)s, %(foo_m1)s), ' - '(%(id_m2)s, %(data_m2)s, %(foo_m2)s)', + "INSERT INTO sometable (id, data, foo) VALUES " + "(%(id_m0)s, %(data_m0)s, %(foo)s), " + "(%(id_m1)s, %(data_m1)s, %(foo_m1)s), " + "(%(id_m2)s, %(data_m2)s, %(foo_m2)s)", checkparams=checkparams, - dialect=postgresql.dialect()) + dialect=postgresql.dialect(), + ) def test_python_fn_default(self): metadata = MetaData() - table = Table('sometable', metadata, - Column('id', Integer, primary_key=True), - Column('data', String), - Column('foo', Integer, default=lambda: 10)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer, default=lambda: 10), + ) values = [ - {'id': 1, 'data': 'data1'}, - {'id': 2, 'data': 'data2', 'foo': 15}, - {'id': 3, 'data': 'data3'}, + {"id": 1, "data": "data1"}, + {"id": 2, "data": "data2", "foo": 15}, + {"id": 3, "data": "data3"}, ] checkparams = { - 'id_m0': 1, - 'id_m1': 2, - 'id_m2': 3, - 'data_m0': 'data1', - 'data_m1': 'data2', - 'data_m2': 'data3', - 'foo': None, # evaluated later - 'foo_m1': 15, - 'foo_m2': None, # evaluated later + "id_m0": 1, + "id_m1": 2, + "id_m2": 3, + "data_m0": "data1", + "data_m1": "data2", + "data_m2": "data3", + "foo": None, # evaluated later + "foo_m1": 15, + "foo_m2": None, # evaluated later } stmt = table.insert().values(values) eq_( - dict([ - (k, v.type._type_affinity) - for (k, v) in - stmt.compile(dialect=postgresql.dialect()).binds.items()]), + dict( + [ + (k, v.type._type_affinity) + for (k, v) in stmt.compile( + dialect=postgresql.dialect() + ).binds.items() + ] + ), { - 'foo': Integer, 'data_m2': String, 'id_m0': Integer, - 'id_m2': Integer, 'foo_m1': Integer, 'data_m1': String, - 'id_m1': Integer, 'foo_m2': Integer, 'data_m0': String} + "foo": Integer, + "data_m2": String, + "id_m0": Integer, + "id_m2": Integer, + "foo_m1": Integer, + "data_m1": String, + "id_m1": Integer, + "foo_m2": Integer, + "data_m0": String, + }, ) self.assert_compile( @@ -1176,14 +1257,18 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "(%(id_m1)s, %(data_m1)s, %(foo_m1)s), " "(%(id_m2)s, %(data_m2)s, %(foo_m2)s)", checkparams=checkparams, - dialect=postgresql.dialect()) + 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)) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer), + ) values = [ {"id": 1, "data": "foo", "foo": func.foob()}, @@ -1193,21 +1278,17 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): {"id": 5, "data": "bar", "foo": func.foob()}, ] checkparams = { - 'id_m0': 1, - 'data_m0': 'foo', - - 'id_m1': 2, - 'data_m1': 'bar', - - 'id_m2': 3, - 'data_m2': 'bar', - - 'id_m3': 4, - 'data_m3': 'bar', - 'foo_m3': 15, - - 'id_m4': 5, - 'data_m4': 'bar' + "id_m0": 1, + "data_m0": "foo", + "id_m1": 2, + "data_m1": "bar", + "id_m2": 3, + "data_m2": "bar", + "id_m3": 4, + "data_m3": "bar", + "foo_m3": 15, + "id_m4": 5, + "data_m4": "bar", } self.assert_compile( @@ -1219,50 +1300,58 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "(%(id_m3)s, %(data_m3)s, %(foo_m3)s), " "(%(id_m4)s, %(data_m4)s, foob())", checkparams=checkparams, - dialect=postgresql.dialect()) + 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())) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer, server_default=func.foobar()), + ) values = [ - {'id': 1, 'data': 'data1'}, - {'id': 2, 'data': 'data2', 'foo': 'plainfoo'}, - {'id': 3, 'data': 'data3'}, + {"id": 1, "data": "data1"}, + {"id": 2, "data": "data2", "foo": "plainfoo"}, + {"id": 3, "data": "data3"}, ] checkparams = { - 'id_m0': 1, - 'id_m1': 2, - 'id_m2': 3, - 'data_m0': 'data1', - 'data_m1': 'data2', - 'data_m2': 'data3', + "id_m0": 1, + "id_m1": 2, + "id_m2": 3, + "data_m0": "data1", + "data_m1": "data2", + "data_m2": "data3", } self.assert_compile( table.insert().values(values), - 'INSERT INTO sometable (id, data) VALUES ' - '(%(id_m0)s, %(data_m0)s), ' - '(%(id_m1)s, %(data_m1)s), ' - '(%(id_m2)s, %(data_m2)s)', + "INSERT INTO sometable (id, data) VALUES " + "(%(id_m0)s, %(data_m0)s), " + "(%(id_m1)s, %(data_m1)s), " + "(%(id_m2)s, %(data_m2)s)", checkparams=checkparams, - dialect=postgresql.dialect()) + 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())) + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String), + Column("foo", Integer, server_default=func.foobar()), + ) values = [ - {'id': 1, 'data': 'data1', 'foo': 'plainfoo'}, - {'id': 2, 'data': 'data2'}, - {'id': 3, 'data': 'data3', 'foo': 'otherfoo'}, + {"id": 1, "data": "data1", "foo": "plainfoo"}, + {"id": 2, "data": "data2"}, + {"id": 3, "data": "data3", "foo": "otherfoo"}, ] assert_raises_message( @@ -1270,5 +1359,5 @@ class MultirowTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): "INSERT value for column sometable.foo is explicitly rendered " "as a boundparameter in the VALUES clause; a Python-side value or " "SQL expression is required", - table.insert().values(values).compile + table.insert().values(values).compile, ) diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py index 502ef6912..7803de75e 100644 --- a/test/sql/test_insert_exec.py +++ b/test/sql/test_insert_exec.py @@ -2,8 +2,18 @@ from sqlalchemy.testing import eq_, assert_raises_message, is_ from sqlalchemy import testing from sqlalchemy.testing import fixtures, engines from sqlalchemy import ( - exc, sql, String, Integer, MetaData, and_, ForeignKey, - VARCHAR, INT, Sequence, func) + exc, + sql, + String, + Integer, + MetaData, + and_, + ForeignKey, + VARCHAR, + INT, + Sequence, + func, +) from sqlalchemy.testing.schema import Table, Column @@ -13,12 +23,13 @@ class InsertExecTest(fixtures.TablesTest): @classmethod def define_tables(cls, metadata): Table( - 'users', metadata, + "users", + metadata, Column( - 'user_id', INT, primary_key=True, - test_needs_autoincrement=True), - Column('user_name', VARCHAR(20)), - test_needs_acid=True + "user_id", INT, primary_key=True, test_needs_autoincrement=True + ), + Column("user_name", VARCHAR(20)), + test_needs_acid=True, ) @testing.requires.multivalues_inserts @@ -26,15 +37,17 @@ class InsertExecTest(fixtures.TablesTest): users = self.tables.users users.insert( values=[ - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}]).execute() + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + ] + ).execute() rows = users.select().order_by(users.c.user_id).execute().fetchall() - eq_(rows[0], (7, 'jack')) - eq_(rows[1], (8, 'ed')) - users.insert(values=[(9, 'jack'), (10, 'ed')]).execute() + eq_(rows[0], (7, "jack")) + eq_(rows[1], (8, "ed")) + users.insert(values=[(9, "jack"), (10, "ed")]).execute() rows = users.select().order_by(users.c.user_id).execute().fetchall() - eq_(rows[2], (9, 'jack')) - eq_(rows[3], (10, 'ed')) + eq_(rows[2], (9, "jack")) + eq_(rows[3], (10, "ed")) def test_insert_heterogeneous_params(self): """test that executemany parameters are asserted to match the @@ -48,17 +61,15 @@ class InsertExecTest(fixtures.TablesTest): "parameter group 2 " r"\[SQL: u?'INSERT INTO users", users.insert().execute, - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9} + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9}, ) # this succeeds however. We aren't yet doing # a length check on all subsequent parameters. users.insert().execute( - {'user_id': 7}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9} + {"user_id": 7}, {"user_id": 8, "user_name": "ed"}, {"user_id": 9} ) def _test_lastrow_accessor(self, table_, values, assertvalues): @@ -76,33 +87,39 @@ class InsertExecTest(fixtures.TablesTest): ins = table_.insert() comp = ins.compile(engine, column_keys=list(values)) if not set(values).issuperset( - c.key for c in table_.primary_key): + c.key for c in table_.primary_key + ): is_(bool(comp.returning), True) result = engine.execute(table_.insert(), **values) ret = values.copy() for col, id in zip( - table_.primary_key, result.inserted_primary_key): + table_.primary_key, result.inserted_primary_key + ): ret[col.key] = id if result.lastrow_has_defaults(): criterion = and_( *[ - col == id for col, id in - zip(table_.primary_key, result.inserted_primary_key)]) + col == id + for col, id in zip( + table_.primary_key, result.inserted_primary_key + ) + ] + ) row = engine.execute(table_.select(criterion)).first() for c in table_.c: ret[c.key] = row[c] return ret - if testing.against('firebird', 'postgresql', 'oracle', 'mssql'): + if testing.against("firebird", "postgresql", "oracle", "mssql"): assert testing.db.dialect.implicit_returning if testing.db.dialect.implicit_returning: test_engines = [ - engines.testing_engine(options={'implicit_returning': False}), - engines.testing_engine(options={'implicit_returning': True}), + engines.testing_engine(options={"implicit_returning": False}), + engines.testing_engine(options={"implicit_returning": True}), ] else: test_engines = [testing.db] @@ -115,47 +132,57 @@ class InsertExecTest(fixtures.TablesTest): finally: table_.drop(bind=engine) - @testing.skip_if('sqlite') + @testing.skip_if("sqlite") def test_lastrow_accessor_one(self): metadata = MetaData() self._test_lastrow_accessor( Table( - "t1", metadata, + "t1", + metadata, Column( - 'id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('foo', String(30), primary_key=True)), - {'foo': 'hi'}, - {'id': 1, 'foo': 'hi'} + "id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("foo", String(30), primary_key=True), + ), + {"foo": "hi"}, + {"id": 1, "foo": "hi"}, ) - @testing.skip_if('sqlite') + @testing.skip_if("sqlite") def test_lastrow_accessor_two(self): metadata = MetaData() self._test_lastrow_accessor( Table( - "t2", metadata, + "t2", + metadata, Column( - 'id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('foo', String(30), primary_key=True), - Column('bar', String(30), server_default='hi') + "id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("foo", String(30), primary_key=True), + Column("bar", String(30), server_default="hi"), ), - {'foo': 'hi'}, - {'id': 1, 'foo': 'hi', 'bar': 'hi'} + {"foo": "hi"}, + {"id": 1, "foo": "hi", "bar": "hi"}, ) def test_lastrow_accessor_three(self): metadata = MetaData() self._test_lastrow_accessor( Table( - "t3", metadata, + "t3", + metadata, Column("id", String(40), primary_key=True), - Column('foo', String(30), primary_key=True), - Column("bar", String(30)) + Column("foo", String(30), primary_key=True), + Column("bar", String(30)), ), - {'id': 'hi', 'foo': 'thisisfoo', 'bar': "thisisbar"}, - {'id': 'hi', 'foo': 'thisisfoo', 'bar': "thisisbar"} + {"id": "hi", "foo": "thisisfoo", "bar": "thisisbar"}, + {"id": "hi", "foo": "thisisfoo", "bar": "thisisbar"}, ) @testing.requires.sequences @@ -163,84 +190,105 @@ class InsertExecTest(fixtures.TablesTest): metadata = MetaData() self._test_lastrow_accessor( Table( - "t4", metadata, + "t4", + metadata, Column( - 'id', Integer, - Sequence('t4_id_seq', optional=True), - primary_key=True), - Column('foo', String(30), primary_key=True), - Column('bar', String(30), server_default='hi') + "id", + Integer, + Sequence("t4_id_seq", optional=True), + primary_key=True, + ), + Column("foo", String(30), primary_key=True), + Column("bar", String(30), server_default="hi"), ), - {'foo': 'hi', 'id': 1}, - {'id': 1, 'foo': 'hi', 'bar': 'hi'} + {"foo": "hi", "id": 1}, + {"id": 1, "foo": "hi", "bar": "hi"}, ) def test_lastrow_accessor_five(self): metadata = MetaData() self._test_lastrow_accessor( Table( - "t5", metadata, - Column('id', String(10), primary_key=True), - Column('bar', String(30), server_default='hi') + "t5", + metadata, + Column("id", String(10), primary_key=True), + Column("bar", String(30), server_default="hi"), ), - {'id': 'id1'}, - {'id': 'id1', 'bar': 'hi'}, + {"id": "id1"}, + {"id": "id1", "bar": "hi"}, ) - @testing.skip_if('sqlite') + @testing.skip_if("sqlite") def test_lastrow_accessor_six(self): metadata = MetaData() self._test_lastrow_accessor( Table( - "t6", metadata, + "t6", + metadata, Column( - 'id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('bar', Integer, primary_key=True) + "id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("bar", Integer, primary_key=True), ), - {'bar': 0}, - {'id': 1, 'bar': 0}, + {"bar": 0}, + {"id": 1, "bar": 0}, ) # TODO: why not in the sqlite suite? - @testing.only_on('sqlite+pysqlite') + @testing.only_on("sqlite+pysqlite") @testing.provide_metadata def test_lastrowid_zero(self): from sqlalchemy.dialects import sqlite + eng = engines.testing_engine() class ExcCtx(sqlite.base.SQLiteExecutionContext): - def get_lastrowid(self): return 0 + eng.dialect.execution_ctx_cls = ExcCtx t = Table( - 't', self.metadata, Column('x', Integer, primary_key=True), - Column('y', Integer)) + "t", + self.metadata, + Column("x", Integer, primary_key=True), + Column("y", Integer), + ) t.create(eng) r = eng.execute(t.insert().values(y=5)) eq_(r.inserted_primary_key, [0]) @testing.fails_on( - 'sqlite', "sqlite autoincremnt doesn't work with composite pks") + "sqlite", "sqlite autoincremnt doesn't work with composite pks" + ) @testing.provide_metadata def test_misordered_lastrow(self): metadata = self.metadata related = Table( - 'related', metadata, - Column('id', Integer, primary_key=True), - mysql_engine='MyISAM' + "related", + metadata, + Column("id", Integer, primary_key=True), + mysql_engine="MyISAM", ) t6 = Table( - "t6", metadata, + "t6", + metadata, Column( - 'manual_id', Integer, ForeignKey('related.id'), - primary_key=True), + "manual_id", + Integer, + ForeignKey("related.id"), + primary_key=True, + ), Column( - 'auto_id', Integer, primary_key=True, - test_needs_autoincrement=True), - mysql_engine='MyISAM' + "auto_id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + mysql_engine="MyISAM", ) metadata.create_all() @@ -255,7 +303,8 @@ class InsertExecTest(fixtures.TablesTest): users = self.tables.users stmt = users.insert().from_select( (users.c.user_id, users.c.user_name), - users.select().where(users.c.user_id == 20)) + users.select().where(users.c.user_id == 20), + ) testing.db.execute(stmt) @@ -263,7 +312,8 @@ class InsertExecTest(fixtures.TablesTest): users = self.tables.users stmt = users.insert().from_select( ["user_id", "user_name"], - users.select().where(users.c.user_id == 20)) + users.select().where(users.c.user_id == 20), + ) testing.db.execute(stmt) @@ -271,12 +321,15 @@ class InsertExecTest(fixtures.TablesTest): @testing.requires.returning def test_no_inserted_pk_on_returning(self): users = self.tables.users - result = testing.db.execute(users.insert().returning( - users.c.user_id, users.c.user_name)) + result = testing.db.execute( + users.insert().returning(users.c.user_id, users.c.user_name) + ) assert_raises_message( exc.InvalidRequestError, r"Can't call inserted_primary_key when returning\(\) is used.", - getattr, result, 'inserted_primary_key' + getattr, + result, + "inserted_primary_key", ) @@ -286,27 +339,32 @@ class TableInsertTest(fixtures.TablesTest): regarding the inline=True flag, lower-case 't' tables. """ - run_create_tables = 'each' + + run_create_tables = "each" __backend__ = True @classmethod def define_tables(cls, metadata): Table( - 'foo', metadata, - Column('id', Integer, Sequence('t_id_seq'), primary_key=True), - Column('data', String(50)), - Column('x', Integer) + "foo", + metadata, + Column("id", Integer, Sequence("t_id_seq"), primary_key=True), + Column("data", String(50)), + Column("x", Integer), ) def _fixture(self, types=True): if types: t = sql.table( - 'foo', sql.column('id', Integer), - sql.column('data', String), - sql.column('x', Integer)) + "foo", + sql.column("id", Integer), + sql.column("data", String), + sql.column("x", Integer), + ) else: t = sql.table( - 'foo', sql.column('id'), sql.column('data'), sql.column('x')) + "foo", sql.column("id"), sql.column("data"), sql.column("x") + ) return t def _test(self, stmt, row, returning=None, inserted_primary_key=False): @@ -324,99 +382,104 @@ class TableInsertTest(fixtures.TablesTest): testing.db.execute(stmt, rows) eq_( testing.db.execute( - self.tables.foo.select(). - order_by(self.tables.foo.c.id)).fetchall(), - data) + self.tables.foo.select().order_by(self.tables.foo.c.id) + ).fetchall(), + data, + ) @testing.requires.sequences def test_explicit_sequence(self): t = self._fixture() self._test( t.insert().values( - id=func.next_value(Sequence('t_id_seq')), data='data', x=5), - (1, 'data', 5) + id=func.next_value(Sequence("t_id_seq")), data="data", x=5 + ), + (1, "data", 5), ) def test_uppercase(self): t = self.tables.foo self._test( - t.insert().values(id=1, data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[1] + t.insert().values(id=1, data="data", x=5), + (1, "data", 5), + inserted_primary_key=[1], ) def test_uppercase_inline(self): t = self.tables.foo self._test( - t.insert(inline=True).values(id=1, data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[1] + t.insert(inline=True).values(id=1, data="data", x=5), + (1, "data", 5), + inserted_primary_key=[1], ) @testing.crashes( "mssql+pyodbc", - "Pyodbc + SQL Server + Py3K, some decimal handling issue") + "Pyodbc + SQL Server + Py3K, some decimal handling issue", + ) def test_uppercase_inline_implicit(self): t = self.tables.foo self._test( - t.insert(inline=True).values(data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[None] + t.insert(inline=True).values(data="data", x=5), + (1, "data", 5), + inserted_primary_key=[None], ) def test_uppercase_implicit(self): t = self.tables.foo self._test( - t.insert().values(data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[1] + t.insert().values(data="data", x=5), + (1, "data", 5), + inserted_primary_key=[1], ) def test_uppercase_direct_params(self): t = self.tables.foo self._test( - t.insert().values(id=1, data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[1] + t.insert().values(id=1, data="data", x=5), + (1, "data", 5), + inserted_primary_key=[1], ) @testing.requires.returning def test_uppercase_direct_params_returning(self): t = self.tables.foo self._test( - t.insert().values(id=1, data='data', x=5).returning(t.c.id, t.c.x), - (1, 'data', 5), - returning=(1, 5) + t.insert().values(id=1, data="data", x=5).returning(t.c.id, t.c.x), + (1, "data", 5), + returning=(1, 5), ) @testing.fails_on( - 'mssql', "lowercase table doesn't support identity insert disable") + "mssql", "lowercase table doesn't support identity insert disable" + ) def test_direct_params(self): t = self._fixture() self._test( - t.insert().values(id=1, data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[] + t.insert().values(id=1, data="data", x=5), + (1, "data", 5), + inserted_primary_key=[], ) @testing.fails_on( - 'mssql', "lowercase table doesn't support identity insert disable") + "mssql", "lowercase table doesn't support identity insert disable" + ) @testing.requires.returning def test_direct_params_returning(self): t = self._fixture() self._test( - t.insert().values(id=1, data='data', x=5).returning(t.c.id, t.c.x), - (1, 'data', 5), - returning=(1, 5) + t.insert().values(id=1, data="data", x=5).returning(t.c.id, t.c.x), + (1, "data", 5), + returning=(1, 5), ) @testing.requires.emulated_lastrowid def test_implicit_pk(self): t = self._fixture() self._test( - t.insert().values(data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[] + t.insert().values(data="data", x=5), + (1, "data", 5), + inserted_primary_key=[], ) @testing.requires.emulated_lastrowid @@ -425,22 +488,18 @@ class TableInsertTest(fixtures.TablesTest): self._test_multi( t.insert(), [ - {'data': 'd1', 'x': 5}, - {'data': 'd2', 'x': 6}, - {'data': 'd3', 'x': 7}, - ], - [ - (1, 'd1', 5), - (2, 'd2', 6), - (3, 'd3', 7) + {"data": "d1", "x": 5}, + {"data": "d2", "x": 6}, + {"data": "d3", "x": 7}, ], + [(1, "d1", 5), (2, "d2", 6), (3, "d3", 7)], ) @testing.requires.emulated_lastrowid def test_implicit_pk_inline(self): t = self._fixture() self._test( - t.insert(inline=True).values(data='data', x=5), - (1, 'data', 5), - inserted_primary_key=[] + t.insert(inline=True).values(data="data", x=5), + (1, "data", 5), + inserted_primary_key=[], ) diff --git a/test/sql/test_inspect.py b/test/sql/test_inspect.py index 7178bc58a..0e78c06c8 100644 --- a/test/sql/test_inspect.py +++ b/test/sql/test_inspect.py @@ -7,20 +7,15 @@ from sqlalchemy.testing import is_ class TestCoreInspection(fixtures.TestBase): - def test_table(self): - t = Table('t', MetaData(), - Column('x', Integer) - ) + t = Table("t", MetaData(), Column("x", Integer)) is_(inspect(t), t) assert t.is_selectable is_(t.selectable, t) def test_select(self): - t = Table('t', MetaData(), - Column('x', Integer) - ) + t = Table("t", MetaData(), Column("x", Integer)) s = t.select() is_(inspect(s), s) @@ -28,10 +23,10 @@ class TestCoreInspection(fixtures.TestBase): is_(s.selectable, s) def test_column_expr(self): - c = Column('x', Integer) + c = Column("x", Integer) is_(inspect(c), c) assert not c.is_selectable - assert not hasattr(c, 'selectable') + assert not hasattr(c, "selectable") def test_no_clause_element_on_clauseelement(self): # re [ticket:3802], there are in the wild examples @@ -39,5 +34,5 @@ class TestCoreInspection(fixtures.TestBase): # absence of __clause_element__ as a test for "this is the clause # element" must be maintained - x = Column('foo', Integer) - assert not hasattr(x, '__clause_element__') + x = Column("foo", Integer) + assert not hasattr(x, "__clause_element__") diff --git a/test/sql/test_join_rewriting.py b/test/sql/test_join_rewriting.py index c699a5c97..dd74406fd 100644 --- a/test/sql/test_join_rewriting.py +++ b/test/sql/test_join_rewriting.py @@ -3,8 +3,16 @@ to support SQLite's lack of right-nested joins. SQlite as of version 3.7.16 no longer has this limitation. """ -from sqlalchemy import Table, Column, Integer, MetaData, ForeignKey, \ - select, exists, union +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 @@ -14,70 +22,74 @@ from sqlalchemy import testing m = MetaData() -a = Table('a', m, - Column('id', Integer, primary_key=True) - ) - -b = Table('b', m, - 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), - ) - -b1 = Table('b1', m, - 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')) - ) - -a_to_b = Table('a_to_b', m, - 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')) - ) - -d = Table('d', m, - Column('id', Integer, primary_key=True), - Column('c_id', Integer, ForeignKey('c.id')) - ) - -e = Table('e', m, - Column('id', Integer, primary_key=True) - ) - -f = Table('f', m, - 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'), - ) - -a_to_b_key = Table('a_to_b_key', m, - Column('aid', Integer, ForeignKey('a.id')), - Column('bid', Integer, ForeignKey('b_key.bid')), - ) +a = Table("a", m, Column("id", Integer, primary_key=True)) + +b = Table( + "b", + m, + 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)) + +b1 = Table( + "b1", + m, + 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")), +) + +a_to_b = Table( + "a_to_b", + m, + 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")), +) + +d = Table( + "d", + m, + Column("id", Integer, primary_key=True), + Column("c_id", Integer, ForeignKey("c.id")), +) + +e = Table("e", m, Column("id", Integer, primary_key=True)) + +f = Table( + "f", + m, + 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")) + +a_to_b_key = Table( + "a_to_b_key", + m, + 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, - assert_ - ) + self.assert_compile(s, assert_) compiled = s.compile(dialect=self.__dialect__) @@ -107,10 +119,13 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): # TODO: do this test also with individual cols, things change # lots based on how you go with this - s = select([a, b, c], use_labels=True).\ - select_from(j2).\ - where(b.c.id == 2).\ - where(c.c.id == 3).order_by(a.c.id, b.c.id, c.c.id) + s = ( + select([a, b, c], use_labels=True) + .select_from(j2) + .where(b.c.id == 2) + .where(c.c.id == 3) + .order_by(a.c.id, b.c.id, c.c.id) + ) self._test(s, self._a_bc) @@ -118,8 +133,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j1 = b_key.join(a_to_b_key) j2 = a.join(j1) - s = select([a, b_key.c.bid], use_labels=True).\ - select_from(j2) + s = select([a, b_key.c.bid], use_labels=True).select_from(j2) self._test(s, self._a_bkeyassoc) @@ -130,8 +144,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j1 = bkey_alias.join(a_to_b_key_alias) j2 = a.join(j1) - s = select([a, bkey_alias.c.bid], use_labels=True).\ - select_from(j2) + s = select([a, bkey_alias.c.bid], use_labels=True).select_from(j2) self._test(s, self._a_bkeyassoc_aliased) @@ -140,18 +153,17 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): j2 = b.join(j1) j3 = a.join(j2) - s = select([a, b, c, d], use_labels=True).\ - select_from(j3).\ - 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) - - self._test( - s, - self._a__b_dc + s = ( + select([a, b, c, d], use_labels=True) + .select_from(j3) + .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) ) + self._test(s, self._a__b_dc) + def test_a_bc_comma_a1_selbc(self): # test here we're emulating is # test.orm.inheritance.test_polymorphic_rel: @@ -162,14 +174,15 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): a_a = a.alias() 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) - - self._test( - s, - self._a_bc_comma_a1_selbc + s = ( + select([a, a_a, b, c, j2], use_labels=True) + .select_from(j3) + .select_from(j4) + .order_by(j2.c.b_id) ) + self._test(s, self._a_bc_comma_a1_selbc) + def test_a_atobalias_balias_c_w_exists(self): a_to_b_alias = a_to_b.alias() b_alias = b.alias() @@ -179,19 +192,22 @@ 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) - - self._test( - s, - self._a_atobalias_balias_c_w_exists - ) + 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, self._a_atobalias_balias_c_w_exists) def test_a_atobalias_balias(self): a_to_b_alias = a_to_b.alias() @@ -202,10 +218,7 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): s = select([a, a_to_b_alias, b_alias], use_labels=True).select_from(j2) - self._test( - s, - self._a_atobalias_balias - ) + self._test(s, self._a_atobalias_balias) def test_b_ab1_union_b_ab2(self): j1 = a.join(b1) @@ -215,14 +228,10 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): b_j2 = b.join(j2) s = union( - select([b_j1], use_labels=True), - select([b_j2], use_labels=True) + select([b_j1], use_labels=True), select([b_j2], use_labels=True) ).select(use_labels=True) - self._test( - s, - self._b_ab1_union_c_ab2 - ) + self._test(s, self._b_ab1_union_c_ab2) def test_b_a_id_double_overlap_annotated(self): # test issue #3057 @@ -231,17 +240,14 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): annot = [ b.c.id._annotate({}), b.c.a_id._annotate({}), - b_a.c.id._annotate({}) + b_a.c.id._annotate({}), ] s = select(annot).select_from(j1).apply_labels().alias() s = select(list(s.c)).apply_labels() - self._test( - s, - self._b_a_id_double_overlap_annotated - ) + self._test(s, self._b_a_id_double_overlap_annotated) def test_f_b1a_where_in_b2a(self): # test issue #3130 @@ -251,20 +257,14 @@ class _JoinRewriteTestBase(AssertsCompiledSQL): s = select([f]).select_from(f.join(b1a)).where(b1.c.id.in_(subq)) s = s.apply_labels() - self._test( - s, - self._f_b1a_where_in_b2a - ) + self._test(s, self._f_b1a_where_in_b2a) def test_anon_scalar_subqueries(self): s1 = select([1]).as_scalar() s2 = select([2]).as_scalar() s = select([s1, s2]).apply_labels() - self._test( - s, - self._anon_scalar_subqueries - ) + self._test(s, self._anon_scalar_subqueries) class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): @@ -350,7 +350,8 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "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") + "ON a.id = anon_2.anon_1_aid" + ) _a_atobalias_balias_c_w_exists = ( "SELECT a.id AS a_id, " @@ -363,7 +364,8 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "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, " @@ -373,7 +375,8 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): "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" + ) _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, " @@ -412,6 +415,7 @@ class JoinRewriteTest(_JoinRewriteTestBase, fixtures.TestBase): class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): """test rendering of each join with normal nesting.""" + @util.classproperty def __dialect__(cls): dialect = default.DefaultDialect() @@ -480,7 +484,8 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): "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, " @@ -500,7 +505,8 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): "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, " @@ -522,7 +528,6 @@ class JoinPlainTest(_JoinRewriteTestBase, fixtures.TestBase): class JoinNoUseLabelsTest(_JoinRewriteTestBase, fixtures.TestBase): - @util.classproperty def __dialect__(cls): dialect = default.DefaultDialect() @@ -531,10 +536,7 @@ class JoinNoUseLabelsTest(_JoinRewriteTestBase, fixtures.TestBase): def _test(self, s, assert_): s.use_labels = False - self.assert_compile( - s, - assert_ - ) + self.assert_compile(s, assert_) _a_bkeyselect_bkey = ( "SELECT a.id, b_key.id FROM a JOIN ((SELECT a_to_b_key.aid AS aid, " @@ -639,11 +641,23 @@ class JoinExecTest(_JoinRewriteTestBase, fixtures.TestBase): __backend__ = True - _a_bc = _a_bc_comma_a1_selbc = _a__b_dc = _a_bkeyassoc = \ - _a_bkeyassoc_aliased = _a_atobalias_balias_c_w_exists = \ - _a_atobalias_balias = _b_ab1_union_c_ab2 = \ - _b_a_id_double_overlap_annotated = _f_b1a_where_in_b2a = \ - _anon_scalar_subqueries = None + _a_bc = ( + _a_bc_comma_a1_selbc + ) = ( + _a__b_dc + ) = ( + _a_bkeyassoc + ) = ( + _a_bkeyassoc_aliased + ) = ( + _a_atobalias_balias_c_w_exists + ) = ( + _a_atobalias_balias + ) = ( + _b_ab1_union_c_ab2 + ) = ( + _b_a_id_double_overlap_annotated + ) = _f_b1a_where_in_b2a = _anon_scalar_subqueries = None @classmethod def setup_class(cls): @@ -660,8 +674,9 @@ class JoinExecTest(_JoinRewriteTestBase, fixtures.TestBase): assert col in result._metadata._keymap @testing.skip_if("oracle", "oracle's cranky") - @testing.skip_if("mssql", "can't query EXISTS in the columns " - "clause w/o subquery") + @testing.skip_if( + "mssql", "can't query EXISTS in the columns " "clause w/o subquery" + ) def test_a_atobalias_balias_c_w_exists(self): super(JoinExecTest, self).test_a_atobalias_balias_c_w_exists() @@ -669,13 +684,13 @@ class JoinExecTest(_JoinRewriteTestBase, fixtures.TestBase): "sqlite", "non-standard aliasing rules used at the moment, " "possibly fix this or add another test that uses " - "cross-compatible aliasing") + "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) @@ -683,8 +698,7 @@ class DialectFlagTest(fixtures.TestBase, AssertsCompiledSQL): j1 = b.join(c) j2 = a.join(j1) - s = select([a, b, c], use_labels=True).\ - select_from(j2) + s = select([a, b, c], use_labels=True).select_from(j2) self.assert_compile( s, @@ -692,12 +706,16 @@ class DialectFlagTest(fixtures.TestBase, AssertsCompiledSQL): "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, " "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 0b279754f..8dfaa6859 100644 --- a/test/sql/test_labels.py +++ b/test/sql/test_labels.py @@ -1,33 +1,46 @@ -from sqlalchemy import exc as exceptions, select, MetaData, Integer, or_, \ - bindparam +from sqlalchemy import ( + exc as exceptions, + select, + MetaData, + Integer, + or_, + bindparam, +) from sqlalchemy.engine import default from sqlalchemy.sql import table, column from sqlalchemy.sql.elements import _truncated_label -from sqlalchemy.testing import AssertsCompiledSQL, assert_raises, engines,\ - fixtures, eq_ +from sqlalchemy.testing import ( + AssertsCompiledSQL, + assert_raises, + engines, + fixtures, + eq_, +) from sqlalchemy.testing.schema import Table, Column IDENT_LENGTH = 29 class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'DefaultDialect' + __dialect__ = "DefaultDialect" - table1 = table('some_large_named_table', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + table1 = table( + "some_large_named_table", + 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') - ) + table2 = table( + "table_with_exactly_29_characs", + column("this_is_the_primarykey_column"), + column("this_is_the_data_column"), + ) def _length_fixture(self, length=IDENT_LENGTH, positional=False): dialect = default.DefaultDialect() dialect.max_identifier_length = length if positional: - dialect.paramstyle = 'format' + dialect.paramstyle = "format" dialect.positional = True return dialect @@ -39,14 +52,14 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): def test_table_alias_1(self): 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 ' - 'FROM ' - 'table_with_exactly_29_characs ' - 'AS table_with_exactly_29_c_1', - dialect=self._length_fixture() + "SELECT " + "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 " + "AS table_with_exactly_29_c_1", + dialect=self._length_fixture(), ) def test_table_alias_2(self): @@ -55,32 +68,36 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): ta = table2.alias() 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'), - '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 ' - 'FROM ' - 'some_large_named_table ' - 'JOIN ' - 'table_with_exactly_29_characs ' - 'AS ' - '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 ' - 'WHERE ' - 'table_with_exactly_29_c_1.this_is_the_data_column = ' - ':this_is_the_data_column_1', - dialect=self._length_fixture() + select([table1, ta]) + .select_from(table1.join(ta, on)) + .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 " + "FROM " + "some_large_named_table " + "JOIN " + "table_with_exactly_29_characs " + "AS " + "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 " + "WHERE " + "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)) + t = Table( + "this_name_is_too_long_for_what_were_doing_in_this_test", + m, + Column("foo", Integer), + ) eng = self._engine_fixture() methods = (t.create, t.drop, m.create_all, m.drop_all) for meth in methods: @@ -91,29 +108,32 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): compiled = s.compile(dialect=self._length_fixture()) assert set( - compiled._create_result_map()['some_large_named_table__2'][1]).\ - issuperset( + compiled._create_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 + "some_large_named_table_this_is_the_data_column", + "some_large_named_table__2", + table1.c.this_is_the_data_column, ] ) assert set( - compiled._create_result_map()['some_large_named_table__1'][1]).\ - issuperset( + compiled._create_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 + "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) + s = ( + table1.select() + .apply_labels() + .order_by(table1.c.this_is_the_primarykey_column) + ) self._assert_labeled_table1_select(s) @@ -123,27 +143,30 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): # version) generate a subquery for limits/offsets. ensure that the # 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) + s = table1.select( + use_labels=True, 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') + s = table1.select(table1.c.this_is_the_primarykey_column == 4).alias( + "foo" + ) s2 = select([s]) compiled = s2.compile(dialect=self._length_fixture()) - assert \ - set(compiled._create_result_map()['this_is_the_data_column'][1]).\ - issuperset(['this_is_the_data_column', - s.c.this_is_the_data_column]) assert set( - compiled._create_result_map()['this_is_the_primarykey__1'][1]).\ - issuperset(['this_is_the_primarykey_column', - 'this_is_the_primarykey__1', - s.c.this_is_the_primarykey_column]) + compiled._create_result_map()["this_is_the_data_column"][1] + ).issuperset(["this_is_the_data_column", s.c.this_is_the_data_column]) + assert set( + compiled._create_result_map()["this_is_the_primarykey__1"][1] + ).issuperset( + [ + "this_is_the_primarykey_column", + "this_is_the_primarykey__1", + s.c.this_is_the_primarykey_column, + ] + ) def test_result_map_anon_alias(self): table1 = self.table1 @@ -169,24 +192,28 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): "some_large_named_table.this_is_the_primarykey_column " "= :this_is_the_primarykey__1" ") " - "AS anon_1", dialect=dialect) + "AS anon_1", + dialect=dialect, + ) compiled = s.compile(dialect=dialect) assert set( - compiled._create_result_map()['anon_1_this_is_the_data_3'][1]).\ - issuperset([ - 'anon_1_this_is_the_data_3', - q.corresponding_column( - table1.c.this_is_the_data_column) - ]) + compiled._create_result_map()["anon_1_this_is_the_data_3"][1] + ).issuperset( + [ + "anon_1_this_is_the_data_3", + q.corresponding_column(table1.c.this_is_the_data_column), + ] + ) assert set( - compiled._create_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) - ]) + compiled._create_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), + ] + ) def test_column_bind_labels_1(self): table1 = self.table1 @@ -199,8 +226,8 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): "FROM some_large_named_table WHERE " "some_large_named_table.this_is_the_primarykey_column = " ":this_is_the_primarykey__1", - checkparams={'this_is_the_primarykey__1': 4}, - dialect=self._length_fixture() + checkparams={"this_is_the_primarykey__1": 4}, + dialect=self._length_fixture(), ) self.assert_compile( @@ -210,18 +237,20 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): "FROM some_large_named_table WHERE " "some_large_named_table.this_is_the_primarykey_column = " "%s", - checkpositional=(4, ), - checkparams={'this_is_the_primarykey__1': 4}, - dialect=self._length_fixture(positional=True) + checkpositional=(4,), + checkparams={"this_is_the_primarykey__1": 4}, + dialect=self._length_fixture(positional=True), ) def test_column_bind_labels_2(self): table1 = self.table1 - s = table1.select(or_( - table1.c.this_is_the_primarykey_column == 4, - table1.c.this_is_the_primarykey_column == 2 - )) + s = table1.select( + or_( + table1.c.this_is_the_primarykey_column == 4, + table1.c.this_is_the_primarykey_column == 2, + ) + ) self.assert_compile( s, "SELECT some_large_named_table.this_is_the_primarykey_column, " @@ -232,10 +261,10 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): "some_large_named_table.this_is_the_primarykey_column = " ":this_is_the_primarykey__2", checkparams={ - 'this_is_the_primarykey__1': 4, - 'this_is_the_primarykey__2': 2 + "this_is_the_primarykey__1": 4, + "this_is_the_primarykey__2": 2, }, - dialect=self._length_fixture() + dialect=self._length_fixture(), ) self.assert_compile( s, @@ -247,140 +276,155 @@ class MaxIdentTest(fixtures.TestBase, AssertsCompiledSQL): "some_large_named_table.this_is_the_primarykey_column = " "%s", checkparams={ - 'this_is_the_primarykey__1': 4, - 'this_is_the_primarykey__2': 2 + "this_is_the_primarykey__1": 4, + "this_is_the_primarykey__2": 2, }, checkpositional=(4, 2), - dialect=self._length_fixture(positional=True) + dialect=self._length_fixture(positional=True), ) def test_bind_param_non_truncated(self): table1 = self.table1 stmt = table1.insert().values( this_is_the_data_column=bindparam( - "this_is_the_long_bindparam_name") + "this_is_the_long_bindparam_name" + ) ) compiled = stmt.compile(dialect=self._length_fixture(length=10)) eq_( compiled.construct_params( - params={"this_is_the_long_bindparam_name": 5}), - {'this_is_the_long_bindparam_name': 5} + params={"this_is_the_long_bindparam_name": 5} + ), + {"this_is_the_long_bindparam_name": 5}, ) def test_bind_param_truncated_named(self): table1 = self.table1 bp = bindparam(_truncated_label("this_is_the_long_bindparam_name")) - stmt = table1.insert().values( - this_is_the_data_column=bp - ) + stmt = table1.insert().values(this_is_the_data_column=bp) compiled = stmt.compile(dialect=self._length_fixture(length=10)) eq_( - compiled.construct_params(params={ - "this_is_the_long_bindparam_name": 5}), - {"this_1": 5} + compiled.construct_params( + params={"this_is_the_long_bindparam_name": 5} + ), + {"this_1": 5}, ) def test_bind_param_truncated_positional(self): table1 = self.table1 bp = bindparam(_truncated_label("this_is_the_long_bindparam_name")) - stmt = table1.insert().values( - this_is_the_data_column=bp - ) + stmt = table1.insert().values(this_is_the_data_column=bp) compiled = stmt.compile( - dialect=self._length_fixture(length=10, positional=True)) + dialect=self._length_fixture(length=10, positional=True) + ) eq_( - compiled.construct_params(params={ - "this_is_the_long_bindparam_name": 5}), - {"this_1": 5} + compiled.construct_params( + params={"this_is_the_long_bindparam_name": 5} + ), + {"this_1": 5}, ) class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'DefaultDialect' + __dialect__ = "DefaultDialect" - table1 = table('some_large_named_table', - column('this_is_the_primarykey_column'), - column('this_is_the_data_column') - ) + table1 = table( + "some_large_named_table", + 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') - ) + table2 = table( + "table_with_exactly_29_characs", + column("this_is_the_primarykey_column"), + column("this_is_the_data_column"), + ) def test_adjustable_1(self): table1 = self.table1 - q = table1.select( - table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select(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 ' - '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) + 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, + ) def test_adjustable_2(self): table1 = self.table1 - q = table1.select( - table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select(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 ' - '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) + 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, + ) def test_adjustable_3(self): table1 = self.table1 compile_dialect = default.DefaultDialect(label_length=4) - q = table1.select( - table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias( + "foo" + ) x = select([q]) 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) + 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, + ) def test_adjustable_4(self): table1 = self.table1 @@ -390,22 +434,25 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): 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 ' - '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) + 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, + ) def test_adjustable_5(self): table1 = self.table1 @@ -414,64 +461,80 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): compile_dialect = default.DefaultDialect(label_length=4) 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) + 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, + ) 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') + q = ( + table1.select(table1.c.this_is_the_primarykey_column == 4) + .apply_labels() + .alias("foo") + ) dialect = default.DefaultDialect(label_length=10) compiled = q.compile(dialect=dialect) - assert set(compiled._create_result_map()['some_2'][1]).issuperset([ - table1.c.this_is_the_data_column, - 'some_large_named_table_this_is_the_data_column', - 'some_2' - ]) + assert set(compiled._create_result_map()["some_2"][1]).issuperset( + [ + table1.c.this_is_the_data_column, + "some_large_named_table_this_is_the_data_column", + "some_2", + ] + ) - assert set(compiled._create_result_map()['some_1'][1]).issuperset([ - table1.c.this_is_the_primarykey_column, - 'some_large_named_table_this_is_the_primarykey_column', - 'some_1' - ]) + assert set(compiled._create_result_map()["some_1"][1]).issuperset( + [ + table1.c.this_is_the_primarykey_column, + "some_large_named_table_this_is_the_primarykey_column", + "some_1", + ] + ) def test_adjustable_result_schema_column_2(self): table1 = self.table1 - q = table1.select( - table1.c.this_is_the_primarykey_column == 4).alias('foo') + q = table1.select(table1.c.this_is_the_primarykey_column == 4).alias( + "foo" + ) x = select([q]) dialect = default.DefaultDialect(label_length=10) compiled = x.compile(dialect=dialect) - assert set(compiled._create_result_map()['this_2'][1]).issuperset([ - q.corresponding_column(table1.c.this_is_the_data_column), - 'this_is_the_data_column', - 'this_2']) + assert set(compiled._create_result_map()["this_2"][1]).issuperset( + [ + q.corresponding_column(table1.c.this_is_the_data_column), + "this_is_the_data_column", + "this_2", + ] + ) - assert set(compiled._create_result_map()['this_1'][1]).issuperset([ - q.corresponding_column(table1.c.this_is_the_primarykey_column), - 'this_is_the_primarykey_column', - 'this_1']) + assert set(compiled._create_result_map()["this_1"][1]).issuperset( + [ + q.corresponding_column(table1.c.this_is_the_primarykey_column), + "this_is_the_primarykey_column", + "this_1", + ] + ) def test_table_plus_column_exceeds_length(self): """test that the truncation only occurs when tablename + colname are @@ -480,78 +543,78 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): """ compile_dialect = default.DefaultDialect(label_length=30) - a_table = table( - 'thirty_characters_table_xxxxxx', - column('id') - ) + a_table = table("thirty_characters_table_xxxxxx", column("id")) other_table = table( - 'other_thirty_characters_table_', - column('id'), - column('thirty_characters_table_id') + "other_thirty_characters_table_", + column("id"), + column("thirty_characters_table_id"), ) anon = a_table.alias() j1 = other_table.outerjoin( - anon, - anon.c.id == other_table.c.thirty_characters_table_id) + anon, anon.c.id == other_table.c.thirty_characters_table_id + ) self.assert_compile( - select([other_table, anon]). - 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 ' - 'FROM ' - 'other_thirty_characters_table_ ' - 'LEFT OUTER JOIN ' - 'thirty_characters_table_xxxxxx AS thirty_characters_table__1 ' - 'ON thirty_characters_table__1.id = ' - 'other_thirty_characters_table_.thirty_characters_table_id', - dialect=compile_dialect) + select([other_table, anon]).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 " + "FROM " + "other_thirty_characters_table_ " + "LEFT OUTER JOIN " + "thirty_characters_table_xxxxxx AS thirty_characters_table__1 " + "ON thirty_characters_table__1.id = " + "other_thirty_characters_table_.thirty_characters_table_id", + dialect=compile_dialect, + ) def test_colnames_longer_than_labels_lowercase(self): - t1 = table('a', column('abcde')) + t1 = table("a", column("abcde")) self._test_colnames_longer_than_labels(t1) def test_colnames_longer_than_labels_uppercase(self): m = MetaData() - t1 = Table('a', m, Column('abcde', Integer)) + t1 = Table("a", m, Column("abcde", Integer)) self._test_colnames_longer_than_labels(t1) def _test_colnames_longer_than_labels(self, t1): dialect = default.DefaultDialect(label_length=4) - a1 = t1.alias(name='asdf') + a1 = t1.alias(name="asdf") # 'abcde' is longer than 4, but rendered as itself # needs to have all characters s = select([a1]) - self.assert_compile(select([a1]), - 'SELECT asdf.abcde FROM a AS asdf', - dialect=dialect) + self.assert_compile( + select([a1]), "SELECT asdf.abcde FROM a AS asdf", dialect=dialect + ) compiled = s.compile(dialect=dialect) - assert set(compiled._create_result_map()['abcde'][1]).issuperset([ - 'abcde', a1.c.abcde, 'abcde']) + assert set(compiled._create_result_map()["abcde"][1]).issuperset( + ["abcde", a1.c.abcde, "abcde"] + ) # 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) + self.assert_compile( + s, "SELECT asdf.abcde AS _1 FROM a AS asdf", dialect=dialect + ) compiled = s.compile(dialect=dialect) - assert set(compiled._create_result_map()['_1'][1]).issuperset([ - 'asdf_abcde', a1.c.abcde, '_1']) + assert set(compiled._create_result_map()["_1"][1]).issuperset( + ["asdf_abcde", a1.c.abcde, "_1"] + ) def test_label_overlap_unlabeled(self): """test that an anon col can't overlap with a fixed name, #3396""" table1 = table( - "tablename", column('columnname_one'), column('columnn_1')) + "tablename", column("columnname_one"), column("columnn_1") + ) stmt = select([table1]).apply_labels() @@ -560,10 +623,10 @@ class LabelLengthTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT tablename.columnname_one AS tablename_columnn_1, " "tablename.columnn_1 AS tablename_columnn_2 FROM tablename", - dialect=dialect + dialect=dialect, ) compiled = stmt.compile(dialect=dialect) eq_( set(compiled._create_result_map()), - set(['tablename_columnn_1', 'tablename_columnn_2']) + set(["tablename_columnn_1", "tablename_columnn_2"]), ) diff --git a/test/sql/test_lateral.py b/test/sql/test_lateral.py index 785dcd960..163f636f6 100644 --- a/test/sql/test_lateral.py +++ b/test/sql/test_lateral.py @@ -16,23 +16,33 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): @classmethod def define_tables(cls, metadata): - Table('people', metadata, - Column('people_id', Integer, primary_key=True), - Column('age', Integer), - Column('name', String(30))) - Table('bookcases', metadata, - Column('bookcase_id', Integer, primary_key=True), - Column( - 'bookcase_owner_id', - Integer, ForeignKey('people.people_id')), - Column('bookcase_shelves', Integer), - Column('bookcase_width', Integer)) - Table('books', metadata, - Column('book_id', Integer, primary_key=True), - Column( - 'bookcase_id', Integer, ForeignKey('bookcases.bookcase_id')), - Column('book_owner_id', Integer, ForeignKey('people.people_id')), - Column('book_weight', Integer)) + Table( + "people", + metadata, + Column("people_id", Integer, primary_key=True), + Column("age", Integer), + Column("name", String(30)), + ) + Table( + "bookcases", + metadata, + Column("bookcase_id", Integer, primary_key=True), + Column( + "bookcase_owner_id", Integer, ForeignKey("people.people_id") + ), + Column("bookcase_shelves", Integer), + Column("bookcase_width", Integer), + ) + Table( + "books", + metadata, + Column("book_id", Integer, primary_key=True), + Column( + "bookcase_id", Integer, ForeignKey("bookcases.bookcase_id") + ), + Column("book_owner_id", Integer, ForeignKey("people.people_id")), + Column("book_weight", Integer), + ) def test_standalone(self): table1 = self.tables.people @@ -42,12 +52,12 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): # in the context of a FROM clause self.assert_compile( lateral(subq, name="alias"), - 'LATERAL (SELECT people.people_id FROM people)' + "LATERAL (SELECT people.people_id FROM people)", ) self.assert_compile( subq.lateral(name="alias"), - 'LATERAL (SELECT people.people_id FROM people)' + "LATERAL (SELECT people.people_id FROM people)", ) def test_select_from(self): @@ -56,16 +66,17 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): # in a FROM context, now you get "AS alias" and column labeling self.assert_compile( - select([subq.lateral(name='alias')]), - 'SELECT alias.people_id FROM LATERAL ' - '(SELECT people.people_id AS people_id FROM people) AS alias' + select([subq.lateral(name="alias")]), + "SELECT alias.people_id FROM LATERAL " + "(SELECT people.people_id AS people_id FROM people) AS alias", ) def test_plain_join(self): table1 = self.tables.people table2 = self.tables.books - subq = select([table2.c.book_id]).\ - where(table2.c.book_owner_id == table1.c.people_id) + subq = select([table2.c.book_id]).where( + table2.c.book_owner_id == table1.c.people_id + ) # FROM books, people? isn't this wrong? No! Because # this is only a fragment, books isn't in any other FROM clause @@ -73,7 +84,7 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): join(table1, lateral(subq, name="alias"), true()), "people JOIN LATERAL (SELECT books.book_id AS book_id " "FROM books, people WHERE books.book_owner_id = people.people_id) " - "AS alias ON true" + "AS alias ON true", ) # put it in correct context, implicit correlation works fine @@ -84,7 +95,7 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): "SELECT people.people_id, people.age, people.name " "FROM people JOIN LATERAL (SELECT books.book_id AS book_id " "FROM books WHERE books.book_owner_id = people.people_id) " - "AS alias ON true" + "AS alias ON true", ) # explicit correlation @@ -96,25 +107,29 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): "SELECT people.people_id, people.age, people.name " "FROM people JOIN LATERAL (SELECT books.book_id AS book_id " "FROM books WHERE books.book_owner_id = people.people_id) " - "AS alias ON true" + "AS alias ON true", ) def test_join_lateral_w_select_subquery(self): table1 = self.tables.people table2 = self.tables.books - subq = select([table2.c.book_id]).\ - correlate(table1).\ - where(table1.c.people_id == table2.c.book_owner_id).lateral() - stmt = select([table1, subq.c.book_id]).\ - select_from(table1.join(subq, true())) + subq = ( + select([table2.c.book_id]) + .correlate(table1) + .where(table1.c.people_id == table2.c.book_owner_id) + .lateral() + ) + stmt = select([table1, subq.c.book_id]).select_from( + table1.join(subq, true()) + ) self.assert_compile( stmt, "SELECT people.people_id, people.age, people.name, anon_1.book_id " "FROM people JOIN LATERAL (SELECT books.book_id AS book_id " "FROM books " - "WHERE people.people_id = books.book_owner_id) AS anon_1 ON true" + "WHERE people.people_id = books.book_owner_id) AS anon_1 ON true", ) def test_from_function(self): @@ -127,5 +142,5 @@ class LateralTest(fixtures.TablesTest, AssertsCompiledSQL): "bookcases.bookcase_shelves, bookcases.bookcase_width " "FROM bookcases JOIN " "LATERAL generate_series(:generate_series_1, " - "bookcases.bookcase_shelves) AS anon_1 ON true" + "bookcases.bookcase_shelves) AS anon_1 ON true", ) diff --git a/test/sql/test_metadata.py b/test/sql/test_metadata.py index f030a7e77..9a28b0c7b 100644 --- a/test/sql/test_metadata.py +++ b/test/sql/test_metadata.py @@ -2,12 +2,33 @@ from sqlalchemy.testing import assert_raises from sqlalchemy.testing import assert_raises_message from sqlalchemy.testing import emits_warning import pickle -from sqlalchemy import Integer, String, UniqueConstraint, \ - CheckConstraint, ForeignKey, MetaData, Sequence, \ - ForeignKeyConstraint, PrimaryKeyConstraint, ColumnDefault, Index, event,\ - events, Unicode, types as sqltypes, bindparam, \ - Table, Column, Boolean, Enum, func, text, TypeDecorator, \ - BLANK_SCHEMA, ARRAY +from sqlalchemy import ( + Integer, + String, + UniqueConstraint, + CheckConstraint, + ForeignKey, + MetaData, + Sequence, + ForeignKeyConstraint, + PrimaryKeyConstraint, + ColumnDefault, + Index, + event, + events, + Unicode, + types as sqltypes, + bindparam, + Table, + Column, + Boolean, + Enum, + func, + text, + TypeDecorator, + BLANK_SCHEMA, + ARRAY, +) from sqlalchemy import schema, exc from sqlalchemy.engine import default from sqlalchemy.sql import elements, naming @@ -20,14 +41,14 @@ from contextlib import contextmanager from sqlalchemy import util from sqlalchemy.testing import engines -class MetaDataTest(fixtures.TestBase, ComparesTables): +class MetaDataTest(fixtures.TestBase, ComparesTables): def test_metadata_contains(self): metadata = MetaData() - t1 = Table('t1', metadata, Column('x', Integer)) - t2 = Table('t2', metadata, Column('x', Integer), schema='foo') - t3 = Table('t2', MetaData(), Column('x', Integer)) - t4 = Table('t1', MetaData(), Column('x', Integer), schema='foo') + t1 = Table("t1", metadata, Column("x", Integer)) + t2 = Table("t2", metadata, Column("x", Integer), schema="foo") + t3 = Table("t2", MetaData(), Column("x", Integer)) + t4 = Table("t1", MetaData(), Column("x", Integer), schema="foo") assert "t1" in metadata assert "foo.t2" in metadata @@ -40,50 +61,68 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_uninitialized_column_copy(self): for col in [ - Column('foo', String(), nullable=False), - Column('baz', String(), unique=True), + Column("foo", String(), nullable=False), + Column("baz", String(), unique=True), Column(Integer(), primary_key=True), - Column('bar', Integer(), Sequence('foo_seq'), primary_key=True, - key='bar'), - Column(Integer(), ForeignKey('bat.blah'), doc="this is a col"), - Column('bar', Integer(), ForeignKey('bat.blah'), primary_key=True, - key='bar'), - Column('bar', Integer(), info={'foo': 'bar'}), + Column( + "bar", + Integer(), + Sequence("foo_seq"), + primary_key=True, + key="bar", + ), + Column(Integer(), ForeignKey("bat.blah"), doc="this is a col"), + Column( + "bar", + Integer(), + ForeignKey("bat.blah"), + primary_key=True, + key="bar", + ), + Column("bar", Integer(), info={"foo": "bar"}), ]: c2 = col.copy() - for attr in ('name', 'type', 'nullable', - 'primary_key', 'key', 'unique', 'info', - 'doc'): + for attr in ( + "name", + "type", + "nullable", + "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: - eq_(c2.default.name, 'foo_seq') + eq_(c2.default.name, "foo_seq") for a1, a2 in zip(col.foreign_keys, c2.foreign_keys): assert a1 is not a2 - eq_(a2._colspec, 'bat.blah') + eq_(a2._colspec, "bat.blah") def test_col_subclass_copy(self): class MyColumn(schema.Column): - def __init__(self, *args, **kw): - self.widget = kw.pop('widget', None) + self.widget = kw.pop("widget", None) super(MyColumn, self).__init__(*args, **kw) def copy(self, *arg, **kw): c = super(MyColumn, self).copy(*arg, **kw) c.widget = self.widget return c - c1 = MyColumn('foo', Integer, widget='x') + + c1 = MyColumn("foo", Integer, widget="x") c2 = c1.copy() assert isinstance(c2, MyColumn) - eq_(c2.widget, 'x') + eq_(c2.widget, "x") 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()) + + c1 = Column("foo", String()) m = MetaData() for i in range(3): cx = c1.copy() @@ -91,39 +130,39 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): # that listeners will be re-established from the # natural construction of things. cx._on_table_attach(write) - Table('foo%d' % i, m, cx) - eq_(msgs, ['attach foo0.foo', 'attach foo1.foo', 'attach foo2.foo']) + Table("foo%d" % i, m, cx) + eq_(msgs, ["attach foo0.foo", "attach foo1.foo", "attach foo2.foo"]) def test_schema_collection_add(self): metadata = MetaData() - Table('t1', metadata, Column('x', Integer), schema='foo') - Table('t2', metadata, Column('x', Integer), schema='bar') - Table('t3', metadata, Column('x', Integer)) + Table("t1", metadata, Column("x", Integer), schema="foo") + Table("t2", metadata, Column("x", Integer), schema="bar") + Table("t3", metadata, Column("x", Integer)) - eq_(metadata._schemas, set(['foo', 'bar'])) + eq_(metadata._schemas, set(["foo", "bar"])) eq_(len(metadata.tables), 3) def test_schema_collection_remove(self): metadata = MetaData() - t1 = Table('t1', metadata, Column('x', Integer), schema='foo') - Table('t2', metadata, Column('x', Integer), schema='bar') - t3 = Table('t3', metadata, Column('x', Integer), schema='bar') + t1 = Table("t1", metadata, Column("x", Integer), schema="foo") + Table("t2", metadata, Column("x", Integer), schema="bar") + t3 = Table("t3", metadata, Column("x", Integer), schema="bar") metadata.remove(t3) - eq_(metadata._schemas, set(['foo', 'bar'])) + eq_(metadata._schemas, set(["foo", "bar"])) eq_(len(metadata.tables), 2) metadata.remove(t1) - eq_(metadata._schemas, set(['bar'])) + eq_(metadata._schemas, set(["bar"])) eq_(len(metadata.tables), 1) def test_schema_collection_remove_all(self): metadata = MetaData() - Table('t1', metadata, Column('x', Integer), schema='foo') - Table('t2', metadata, Column('x', Integer), schema='bar') + Table("t1", metadata, Column("x", Integer), schema="foo") + Table("t2", metadata, Column("x", Integer), schema="bar") metadata.clear() eq_(metadata._schemas, set()) @@ -132,46 +171,56 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_metadata_tables_immutable(self): metadata = MetaData() - Table('t1', metadata, Column('x', Integer)) - assert 't1' in metadata.tables + Table("t1", metadata, Column("x", Integer)) + assert "t1" in metadata.tables - assert_raises( - TypeError, - lambda: metadata.tables.pop('t1') - ) + assert_raises(TypeError, lambda: metadata.tables.pop("t1")) @testing.provide_metadata def test_dupe_tables(self): metadata = self.metadata - Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20))) + Table( + "table1", + metadata, + Column("col1", Integer, primary_key=True), + Column("col2", String(20)), + ) metadata.create_all() - Table('table1', metadata, autoload=True) + Table("table1", metadata, autoload=True) def go(): - Table('table1', metadata, - Column('col1', Integer, primary_key=True), - Column('col2', String(20))) + Table( + "table1", + metadata, + 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.", - go + go, ) def test_fk_copy(self): - c1 = Column('foo', Integer) - c2 = Column('bar', Integer) + c1 = Column("foo", Integer) + c2 = Column("bar", Integer) m = MetaData() - 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) + 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, + ) fk1 = ForeignKey(c1, **kw) fk2 = ForeignKeyConstraint((c1,), (c2,), **kw) @@ -185,14 +234,18 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): eq_(getattr(fk2c, k), kw[k]) def test_check_constraint_copy(self): - def r(x): return x - c = CheckConstraint("foo bar", - name='name', - initially=True, - deferrable=True, - _create_rule=r) + def r(x): + return x + + c = CheckConstraint( + "foo bar", + name="name", + initially=True, + deferrable=True, + _create_rule=r, + ) c2 = c.copy() - eq_(c2.name, 'name') + eq_(c2.name, "name") eq_(str(c2.sqltext), "foo bar") eq_(c2.initially, True) eq_(c2.deferrable, True) @@ -200,152 +253,157 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): def test_col_replace_w_constraint(self): m = MetaData() - a = Table('a', m, Column('id', Integer, primary_key=True)) + a = Table("a", m, Column("id", Integer, primary_key=True)) - aid = Column('a_id', ForeignKey('a.id')) - b = Table('b', m, aid) + aid = Column("a_id", ForeignKey("a.id")) + b = Table("b", m, aid) b.append_column(aid) assert b.c.a_id.references(a.c.id) eq_(len(b.constraints), 2) def test_fk_construct(self): - c1 = Column('foo', Integer) - c2 = Column('bar', Integer) + c1 = Column("foo", Integer) + c2 = Column("bar", Integer) m = MetaData() - t1 = Table('t', m, c1, c2) - fk1 = ForeignKeyConstraint(('foo', ), ('bar', ), table=t1) + t1 = Table("t", m, c1, c2) + fk1 = ForeignKeyConstraint(("foo",), ("bar",), table=t1) assert fk1 in t1.constraints def test_fk_constraint_col_collection_w_table(self): - c1 = Column('foo', Integer) - c2 = Column('bar', Integer) + c1 = Column("foo", Integer) + c2 = Column("bar", Integer) m = MetaData() - t1 = Table('t', m, c1, c2) - fk1 = ForeignKeyConstraint(('foo', ), ('bar', ), table=t1) + t1 = Table("t", m, c1, c2) + fk1 = ForeignKeyConstraint(("foo",), ("bar",), table=t1) eq_(dict(fk1.columns), {"foo": c1}) def test_fk_constraint_col_collection_no_table(self): - fk1 = ForeignKeyConstraint(('foo', 'bat'), ('bar', 'hoho')) + fk1 = ForeignKeyConstraint(("foo", "bat"), ("bar", "hoho")) eq_(dict(fk1.columns), {}) - eq_(fk1.column_keys, ['foo', 'bat']) - eq_(fk1._col_description, 'foo, bat') + eq_(fk1.column_keys, ["foo", "bat"]) + eq_(fk1._col_description, "foo, bat") eq_(fk1._elements, {"foo": fk1.elements[0], "bat": fk1.elements[1]}) def test_fk_constraint_col_collection_no_table_real_cols(self): - c1 = Column('foo', Integer) - c2 = Column('bar', Integer) - fk1 = ForeignKeyConstraint((c1, ), (c2, )) + c1 = Column("foo", Integer) + c2 = Column("bar", Integer) + fk1 = ForeignKeyConstraint((c1,), (c2,)) eq_(dict(fk1.columns), {}) - eq_(fk1.column_keys, ['foo']) - eq_(fk1._col_description, 'foo') + eq_(fk1.column_keys, ["foo"]) + eq_(fk1._col_description, "foo") eq_(fk1._elements, {"foo": fk1.elements[0]}) def test_fk_constraint_col_collection_added_to_table(self): - c1 = Column('foo', Integer) + c1 = Column("foo", Integer) m = MetaData() - fk1 = ForeignKeyConstraint(('foo', ), ('bar', )) - Table('t', m, c1, fk1) + fk1 = ForeignKeyConstraint(("foo",), ("bar",)) + Table("t", m, c1, fk1) eq_(dict(fk1.columns), {"foo": c1}) eq_(fk1._elements, {"foo": fk1.elements[0]}) def test_fk_constraint_col_collection_via_fk(self): - fk = ForeignKey('bar') - c1 = Column('foo', Integer, fk) + fk = ForeignKey("bar") + c1 = Column("foo", Integer, fk) m = MetaData() - t1 = Table('t', m, c1) + t1 = Table("t", m, c1) fk1 = fk.constraint - eq_(fk1.column_keys, ['foo']) + eq_(fk1.column_keys, ["foo"]) assert fk1 in t1.constraints - eq_(fk1.column_keys, ['foo']) + eq_(fk1.column_keys, ["foo"]) eq_(dict(fk1.columns), {"foo": c1}) eq_(fk1._elements, {"foo": fk}) def test_fk_no_such_parent_col_error(self): meta = MetaData() - a = Table('a', meta, Column('a', Integer)) - Table('b', meta, Column('b', Integer)) + a = Table("a", meta, Column("a", Integer)) + Table("b", meta, Column("b", Integer)) def go(): - a.append_constraint( - ForeignKeyConstraint(['x'], ['b.b']) - ) + a.append_constraint(ForeignKeyConstraint(["x"], ["b.b"])) + assert_raises_message( exc.ArgumentError, "Can't create ForeignKeyConstraint on " "table 'a': no column named 'x' is present.", - go + go, ) def test_fk_given_non_col(self): - not_a_col = bindparam('x') + not_a_col = bindparam("x") assert_raises_message( exc.ArgumentError, "String, Column, or Column-bound argument expected, got Bind", - ForeignKey, not_a_col + ForeignKey, + not_a_col, ) def test_fk_given_non_col_clauseelem(self): class Foo(object): - def __clause_element__(self): - return bindparam('x') + return bindparam("x") + assert_raises_message( exc.ArgumentError, "String, Column, or Column-bound argument expected, got Bind", - ForeignKey, Foo() + ForeignKey, + Foo(), ) def test_fk_given_col_non_table(self): - t = Table('t', MetaData(), Column('x', Integer)) + t = Table("t", MetaData(), Column("x", Integer)) xa = t.alias().c.x assert_raises_message( exc.ArgumentError, "ForeignKey received Column not bound to a Table, got: .*Alias", - ForeignKey, xa + ForeignKey, + xa, ) def test_fk_given_col_non_table_clauseelem(self): - t = Table('t', MetaData(), Column('x', Integer)) + t = Table("t", MetaData(), Column("x", Integer)) class Foo(object): - def __clause_element__(self): return t.alias().c.x assert_raises_message( exc.ArgumentError, "ForeignKey received Column not bound to a Table, got: .*Alias", - ForeignKey, Foo() + ForeignKey, + Foo(), ) def test_fk_no_such_target_col_error_upfront(self): meta = MetaData() - a = Table('a', meta, Column('a', Integer)) - Table('b', meta, Column('b', Integer)) + a = Table("a", meta, Column("a", Integer)) + Table("b", meta, Column("b", Integer)) - a.append_constraint(ForeignKeyConstraint(['a'], ['b.x'])) + a.append_constraint(ForeignKeyConstraint(["a"], ["b.x"])) assert_raises_message( exc.NoReferencedColumnError, "Could not initialize target column for ForeignKey 'b.x' on " "table 'a': table 'b' has no column named 'x'", - getattr, list(a.foreign_keys)[0], "column" + getattr, + list(a.foreign_keys)[0], + "column", ) def test_fk_no_such_target_col_error_delayed(self): meta = MetaData() - a = Table('a', meta, Column('a', Integer)) - a.append_constraint( - ForeignKeyConstraint(['a'], ['b.x'])) + a = Table("a", meta, Column("a", Integer)) + a.append_constraint(ForeignKeyConstraint(["a"], ["b.x"])) - b = Table('b', meta, Column('b', Integer)) + b = Table("b", meta, Column("b", Integer)) assert_raises_message( exc.NoReferencedColumnError, "Could not initialize target column for ForeignKey 'b.x' on " "table 'a': table 'b' has no column named 'x'", - getattr, list(a.foreign_keys)[0], "column" + getattr, + list(a.foreign_keys)[0], + "column", ) def test_fk_mismatched_local_remote_cols(self): @@ -354,177 +412,202 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): exc.ArgumentError, "ForeignKeyConstraint number of constrained columns must " "match the number of referenced columns.", - ForeignKeyConstraint, ['a'], ['b.a', 'b.b'] + ForeignKeyConstraint, + ["a"], + ["b.a", "b.b"], ) assert_raises_message( exc.ArgumentError, "ForeignKeyConstraint number of constrained columns " "must match the number of referenced columns.", - ForeignKeyConstraint, ['a', 'b'], ['b.a'] + ForeignKeyConstraint, + ["a", "b"], + ["b.a"], ) assert_raises_message( exc.ArgumentError, "ForeignKeyConstraint with duplicate source column " "references are not supported.", - ForeignKeyConstraint, ['a', 'a'], ['b.a', 'b.b'] + ForeignKeyConstraint, + ["a", "a"], + ["b.a", "b.b"], ) def test_pickle_metadata_sequence_restated(self): m1 = MetaData() - Table('a', m1, - Column('id', Integer, primary_key=True), - Column('x', Integer, Sequence("x_seq"))) + Table( + "a", + m1, + 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) + t2 = Table( + "a", + m2, + 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 + 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) - ) - assert m1._sequences['x_seq'] is s1 - - s2 = Sequence('x_seq') - Table('a', m1, - Column('x', Integer, s2), - extend_existing=True - ) + t = Table("a", m1, 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) assert t.c.x.default is s2 - assert m1._sequences['x_seq'] is s2 + assert m1._sequences["x_seq"] is s2 def test_sequence_attach_to_table(self): m1 = MetaData() s1 = Sequence("s") - t = Table('a', m1, Column('x', Integer, s1)) + t = Table("a", m1, Column("x", Integer, s1)) assert s1.metadata is m1 def test_sequence_attach_to_existing_table(self): m1 = MetaData() s1 = Sequence("s") - t = Table('a', m1, Column('x', Integer)) + t = Table("a", m1, Column("x", Integer)) t.c.x._init_items(s1) assert s1.metadata is m1 def test_pickle_metadata_sequence_implicit(self): m1 = MetaData() - Table('a', m1, - Column('id', Integer, primary_key=True), - Column('x', Integer, Sequence("x_seq"))) + Table( + "a", + m1, + Column("id", Integer, primary_key=True), + Column("x", Integer, Sequence("x_seq")), + ) m2 = pickle.loads(pickle.dumps(m1)) - t2 = Table('a', m2, extend_existing=True) + t2 = Table("a", m2, extend_existing=True) - eq_(m2._sequences, {'x_seq': t2.c.x.default}) + eq_(m2._sequences, {"x_seq": t2.c.x.default}) 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') + Table( + "a", + m1, + 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) + Table("a", m2, schema="y", extend_existing=True) eq_(m2._schemas, m1._schemas) def test_metadata_schema_arg(self): - m1 = MetaData(schema='sch1') - m2 = MetaData(schema='sch1', quote_schema=True) - m3 = MetaData(schema='sch1', quote_schema=False) + m1 = MetaData(schema="sch1") + m2 = MetaData(schema="sch1", quote_schema=True) + m3 = MetaData(schema="sch1", quote_schema=False) 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), - ('t5', m1, BLANK_SCHEMA, None, None, 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), - ('t5', m4, BLANK_SCHEMA, None, None, None), - ]): + 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), + ("t5", m1, BLANK_SCHEMA, None, None, 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), + ("t5", m4, BLANK_SCHEMA, None, None, None), + ] + ): kw = {} if schema is not None: - kw['schema'] = schema + kw["schema"] = schema if quote_schema is not None: - kw['quote_schema'] = quote_schema + kw["quote_schema"] = quote_schema 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, + eq_( + t.schema.quote if t.schema is not None else None, exp_quote_schema, - "test %d, table quote_schema" % i) + "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, + eq_( + seq.schema.quote if seq.schema is not None else None, exp_quote_schema, - "test %d, seq quote_schema" % i) + "test %d, seq quote_schema" % i, + ) def test_manual_dependencies(self): meta = MetaData() - a = Table('a', meta, Column('foo', Integer)) - b = Table('b', meta, Column('foo', Integer)) - c = Table('c', meta, Column('foo', Integer)) - d = Table('d', meta, Column('foo', Integer)) - e = Table('e', meta, Column('foo', Integer)) + a = Table("a", meta, Column("foo", Integer)) + b = Table("b", meta, Column("foo", Integer)) + c = Table("c", meta, Column("foo", Integer)) + d = Table("d", meta, Column("foo", Integer)) + e = Table("e", meta, Column("foo", Integer)) e.add_is_dependent_on(c) a.add_is_dependent_on(b) b.add_is_dependent_on(d) e.add_is_dependent_on(b) c.add_is_dependent_on(a) - eq_( - meta.sorted_tables, - [d, b, a, c, e] - ) + eq_(meta.sorted_tables, [d, b, a, c, e]) def test_deterministic_order(self): meta = MetaData() - a = Table('a', meta, Column('foo', Integer)) - b = Table('b', meta, Column('foo', Integer)) - c = Table('c', meta, Column('foo', Integer)) - d = Table('d', meta, Column('foo', Integer)) - e = Table('e', meta, Column('foo', Integer)) + a = Table("a", meta, Column("foo", Integer)) + b = Table("b", meta, Column("foo", Integer)) + c = Table("c", meta, Column("foo", Integer)) + d = Table("d", meta, Column("foo", Integer)) + e = Table("e", meta, Column("foo", Integer)) e.add_is_dependent_on(c) a.add_is_dependent_on(b) - eq_( - meta.sorted_tables, - [b, c, d, a, e] - ) + eq_(meta.sorted_tables, [b, c, d, a, e]) def test_nonexistent(self): - assert_raises(tsa.exc.NoSuchTableError, Table, - 'fake_table', - MetaData(testing.db), autoload=True) + assert_raises( + tsa.exc.NoSuchTableError, + Table, + "fake_table", + MetaData(testing.db), + autoload=True, + ) def test_assorted_repr(self): t1 = Table("foo", MetaData(), Column("x", Integer)) @@ -532,89 +615,74 @@ class MetaDataTest(fixtures.TestBase, ComparesTables): ck = schema.CheckConstraint("x > y", name="someconstraint") for const, exp in ( - (Sequence("my_seq"), - "Sequence('my_seq')"), - (Sequence("my_seq", start=5), - "Sequence('my_seq', start=5)"), - (Column("foo", Integer), - "Column('foo', Integer(), table=None)"), - (Table("bar", MetaData(), Column("x", String)), + (Sequence("my_seq"), "Sequence('my_seq')"), + (Sequence("my_seq", start=5), "Sequence('my_seq', start=5)"), + (Column("foo", Integer), "Column('foo', Integer(), table=None)"), + ( + Table("bar", MetaData(), Column("x", String)), "Table('bar', MetaData(bind=None), " - "Column('x', String(), table=<bar>), schema=None)"), - (schema.DefaultGenerator(for_update=True), - "DefaultGenerator(for_update=True)"), + "Column('x', String(), table=<bar>), schema=None)", + ), + ( + schema.DefaultGenerator(for_update=True), + "DefaultGenerator(for_update=True)", + ), (schema.Index("bar", "c"), "Index('bar', 'c')"), (i1, "Index('bar', Column('x', Integer(), table=<foo>))"), (schema.FetchedValue(), "FetchedValue()"), - (ck, - "CheckConstraint(" - "%s" - ", name='someconstraint')" % repr(ck.sqltext)), - (ColumnDefault(('foo', 'bar')), "ColumnDefault(('foo', 'bar'))") + ( + ck, + "CheckConstraint(" + "%s" + ", name='someconstraint')" % repr(ck.sqltext), + ), + (ColumnDefault(("foo", "bar")), "ColumnDefault(('foo', 'bar'))"), ): - eq_( - repr(const), - exp - ) + eq_(repr(const), exp) class ToMetaDataTest(fixtures.TestBase, ComparesTables): - @testing.requires.check_constraints def test_copy(self): from sqlalchemy.testing.schema import Table + meta = MetaData() table = Table( - 'mytable', + "mytable", meta, + Column("myid", Integer, Sequence("foo_id_seq"), primary_key=True), + Column("name", String(40), nullable=True), Column( - 'myid', - Integer, - Sequence('foo_id_seq'), - primary_key=True), - Column( - 'name', - String(40), - nullable=True), - Column( - 'foo', + "foo", String(40), nullable=False, - server_default='x', - server_onupdate='q'), + server_default="x", + server_onupdate="q", + ), Column( - 'bar', - String(40), - nullable=False, - default='y', - onupdate='z'), + "bar", String(40), nullable=False, default="y", onupdate="z" + ), Column( - 'description', - String(30), - CheckConstraint("description='hi'")), - UniqueConstraint('name'), - test_needs_fk=True) + "description", String(30), CheckConstraint("description='hi'") + ), + UniqueConstraint("name"), + test_needs_fk=True, + ) table2 = Table( - 'othertable', + "othertable", meta, - Column( - 'id', - Integer, - Sequence('foo_seq'), - primary_key=True), - Column( - 'myid', - Integer, - ForeignKey('mytable.myid'), - ), - test_needs_fk=True) + Column("id", Integer, Sequence("foo_seq"), primary_key=True), + Column("myid", Integer, ForeignKey("mytable.myid")), + test_needs_fk=True, + ) table3 = Table( - 'has_comments', meta, - Column('foo', Integer, comment='some column'), - comment='table comment' + "has_comments", + meta, + Column("foo", Integer, comment="some column"), + comment="table comment", ) def test_to_metadata(): @@ -630,47 +698,61 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): assert meta2.bind is None pickle.loads(pickle.dumps(meta2)) return ( - meta2.tables['mytable'], - meta2.tables['othertable'], meta2.tables['has_comments']) + meta2.tables["mytable"], + meta2.tables["othertable"], + meta2.tables["has_comments"], + ) def test_pickle_via_reflect(): # this is the most common use case, pickling the results of a # database reflection meta2 = MetaData(bind=testing.db) - t1 = Table('mytable', meta2, autoload=True) - Table('othertable', meta2, autoload=True) - Table('has_comments', meta2, autoload=True) + t1 = Table("mytable", meta2, autoload=True) + Table("othertable", meta2, autoload=True) + Table("has_comments", meta2, autoload=True) meta3 = pickle.loads(pickle.dumps(meta2)) assert meta3.bind is None - assert meta3.tables['mytable'] is not t1 + assert meta3.tables["mytable"] is not t1 return ( - meta3.tables['mytable'], meta3.tables['othertable'], - meta3.tables['has_comments'] + meta3.tables["mytable"], + meta3.tables["othertable"], + meta3.tables["has_comments"], ) meta.create_all(testing.db) try: - for test, has_constraints, reflect in \ - (test_to_metadata, True, False), \ - (test_pickle, True, False), \ - (test_pickle_via_reflect, False, True): + for test, has_constraints, reflect in ( + (test_to_metadata, True, False), + (test_pickle, True, False), + (test_pickle_via_reflect, False, True), + ): table_c, table2_c, table3_c = test() self.assert_tables_equal(table, table_c) self.assert_tables_equal(table2, table2_c) assert table is not table_c assert table.primary_key is not table_c.primary_key - assert list(table2_c.c.myid.foreign_keys)[0].column \ + assert ( + list(table2_c.c.myid.foreign_keys)[0].column is table_c.c.myid - assert list(table2_c.c.myid.foreign_keys)[0].column \ + ) + assert ( + list(table2_c.c.myid.foreign_keys)[0].column is not table.c.myid - assert 'x' in str(table_c.c.foo.server_default.arg) + ) + assert "x" in str(table_c.c.foo.server_default.arg) if not reflect: assert isinstance(table_c.c.myid.default, Sequence) - assert str(table_c.c.foo.server_onupdate.arg) == 'q' - assert str(table_c.c.bar.default.arg) == 'y' - assert getattr(table_c.c.bar.onupdate.arg, 'arg', - table_c.c.bar.onupdate.arg) == 'z' + assert str(table_c.c.foo.server_onupdate.arg) == "q" + assert str(table_c.c.bar.default.arg) == "y" + assert ( + getattr( + table_c.c.bar.onupdate.arg, + "arg", + table_c.c.bar.onupdate.arg, + ) + == "z" + ) assert isinstance(table2_c.c.id.default, Sequence) # constraints don't get reflected for any dialect right @@ -701,8 +783,8 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def test_col_key_fk_parent(self): # test #2643 m1 = MetaData() - a = Table('a', m1, Column('x', Integer)) - b = Table('b', m1, Column('x', Integer, ForeignKey('a.x'), key='y')) + a = Table("a", m1, Column("x", Integer)) + b = Table("b", m1, Column("x", Integer, ForeignKey("a.x"), key="y")) assert b.c.y.references(a.c.x) m2 = MetaData() @@ -713,120 +795,141 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): 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'), - ) + 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('mytable.myid')), - ) + table2 = Table( + "othertable", + meta, + 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') + 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)) - eq_(str(table_c.join(table2_c).onclause), - 'someschema.mytable.myid = someschema.othertable.myid') + eq_( + str(table_c.join(table2_c).onclause), + str(table_c.c.myid == table2_c.c.myid), + ) + eq_( + str(table_c.join(table2_c).onclause), + "someschema.mytable.myid = someschema.othertable.myid", + ) def test_retain_table_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'), - 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'") + ), + UniqueConstraint("name"), + schema="myschema", + ) table2 = Table( - 'othertable', + "othertable", meta, - Column( - 'id', - Integer, - primary_key=True), - Column( - 'myid', - Integer, - ForeignKey('myschema.mytable.myid')), - schema='myschema', + 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)) - eq_(str(table_c.join(table2_c).onclause), - 'myschema.mytable.myid = myschema.othertable.myid') + eq_( + str(table_c.join(table2_c).onclause), + str(table_c.c.myid == table2_c.c.myid), + ) + eq_( + str(table_c.join(table2_c).onclause), + "myschema.mytable.myid = myschema.othertable.myid", + ) def test_change_name_retain_metadata(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'), - 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'") + ), + UniqueConstraint("name"), + schema="myschema", + ) - table2 = table.tometadata(table.metadata, name='newtable') - table3 = table.tometadata(table.metadata, schema='newschema', - name='newtable') + table2 = table.tometadata(table.metadata, name="newtable") + table3 = table.tometadata( + table.metadata, schema="newschema", name="newtable" + ) assert table.metadata is table2.metadata assert table.metadata is table3.metadata - eq_((table.name, table2.name, table3.name), - ('mytable', 'newtable', 'newtable')) - eq_((table.key, table2.key, table3.key), - ('myschema.mytable', 'myschema.newtable', 'newschema.newtable')) + eq_( + (table.name, table2.name, table3.name), + ("mytable", "newtable", "newtable"), + ) + eq_( + (table.key, table2.key, table3.key), + ("myschema.mytable", "myschema.newtable", "newschema.newtable"), + ) def test_change_name_change_metadata(self): meta = MetaData() meta2 = 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'), - 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'") + ), + UniqueConstraint("name"), + schema="myschema", + ) - table2 = table.tometadata(meta2, name='newtable') + table2 = table.tometadata(meta2, name="newtable") assert table.metadata is not table2.metadata - eq_((table.name, table2.name), - ('mytable', 'newtable')) - eq_((table.key, table2.key), - ('myschema.mytable', 'myschema.newtable')) + eq_((table.name, table2.name), ("mytable", "newtable")) + eq_((table.key, table2.key), ("myschema.mytable", "myschema.newtable")) def test_change_name_selfref_fk_moves(self): meta = MetaData() - referenced = Table('ref', meta, - Column('id', Integer, primary_key=True), - ) - table = Table('mytable', meta, - Column('id', Integer, primary_key=True), - Column('parent_id', ForeignKey('mytable.id')), - Column('ref_id', ForeignKey('ref.id')) - ) + referenced = Table( + "ref", meta, Column("id", Integer, primary_key=True) + ) + table = Table( + "mytable", + meta, + Column("id", Integer, primary_key=True), + Column("parent_id", ForeignKey("mytable.id")), + Column("ref_id", ForeignKey("ref.id")), + ) - table2 = table.tometadata(table.metadata, name='newtable') + table2 = table.tometadata(table.metadata, name="newtable") assert table.metadata is table2.metadata assert table2.c.ref_id.references(referenced.c.id) assert table2.c.parent_id.references(table2.c.id) @@ -834,18 +937,21 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def test_change_name_selfref_fk_moves_w_schema(self): meta = MetaData() - referenced = Table('ref', meta, - Column('id', Integer, primary_key=True), - ) - table = Table('mytable', meta, - Column('id', Integer, primary_key=True), - Column('parent_id', ForeignKey('mytable.id')), - Column('ref_id', ForeignKey('ref.id')) - ) + referenced = Table( + "ref", meta, Column("id", Integer, primary_key=True) + ) + table = Table( + "mytable", + meta, + Column("id", Integer, primary_key=True), + Column("parent_id", ForeignKey("mytable.id")), + Column("ref_id", ForeignKey("ref.id")), + ) table2 = table.tometadata( - table.metadata, name='newtable', schema='newschema') - ref2 = referenced.tometadata(table.metadata, schema='newschema') + table.metadata, name="newtable", schema="newschema" + ) + ref2 = referenced.tometadata(table.metadata, schema="newschema") assert table.metadata is table2.metadata assert table2.c.ref_id.references(ref2.c.id) assert table2.c.parent_id.references(table2.c.id) @@ -854,8 +960,9 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): m2 = MetaData() existing_schema = t2.schema if schema: - t2c = t2.tometadata(m2, schema=schema, - referred_schema_fn=referred_schema_fn) + t2c = t2.tometadata( + m2, schema=schema, referred_schema_fn=referred_schema_fn + ) eq_(t2c.schema, schema) else: t2c = t2.tometadata(m2, referred_schema_fn=referred_schema_fn) @@ -865,151 +972,164 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def test_fk_has_schema_string_retain_schema(self): m = MetaData() - t2 = Table('t2', m, Column('y', Integer, ForeignKey('q.t1.x'))) + t2 = Table("t2", m, Column("y", Integer, ForeignKey("q.t1.x"))) self._assert_fk(t2, None, "q.t1.x") - Table('t1', m, Column('x', Integer), schema='q') + Table("t1", m, Column("x", Integer), schema="q") self._assert_fk(t2, None, "q.t1.x") def test_fk_has_schema_string_new_schema(self): m = MetaData() - t2 = Table('t2', m, Column('y', Integer, ForeignKey('q.t1.x'))) + t2 = Table("t2", m, Column("y", Integer, ForeignKey("q.t1.x"))) self._assert_fk(t2, "z", "q.t1.x") - Table('t1', m, Column('x', Integer), schema='q') + Table("t1", m, Column("x", Integer), schema="q") self._assert_fk(t2, "z", "q.t1.x") def test_fk_has_schema_col_retain_schema(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer), schema='q') - t2 = Table('t2', m, Column('y', Integer, ForeignKey(t1.c.x))) + t1 = Table("t1", m, Column("x", Integer), schema="q") + t2 = Table("t2", m, Column("y", Integer, ForeignKey(t1.c.x))) self._assert_fk(t2, "z", "q.t1.x") def test_fk_has_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))) + t1 = Table("t1", m, Column("x", Integer), schema="q") + t2 = Table("t2", m, Column("y", Integer, ForeignKey(t1.c.x))) self._assert_fk(t2, "z", "q.t1.x") def test_fk_and_referent_has_same_schema_string_retain_schema(self): m = MetaData() - t2 = Table('t2', m, Column('y', Integer, - ForeignKey('q.t1.x')), schema="q") + t2 = Table( + "t2", m, Column("y", Integer, ForeignKey("q.t1.x")), schema="q" + ) self._assert_fk(t2, None, "q.t1.x") - Table('t1', m, Column('x', Integer), schema='q') + Table("t1", m, Column("x", Integer), schema="q") self._assert_fk(t2, None, "q.t1.x") def test_fk_and_referent_has_same_schema_string_new_schema(self): m = MetaData() - t2 = Table('t2', m, Column('y', Integer, - ForeignKey('q.t1.x')), schema="q") + t2 = Table( + "t2", m, Column("y", Integer, ForeignKey("q.t1.x")), schema="q" + ) self._assert_fk(t2, "z", "z.t1.x") - Table('t1', m, Column('x', Integer), schema='q') + Table("t1", m, Column("x", Integer), schema="q") self._assert_fk(t2, "z", "z.t1.x") def test_fk_and_referent_has_same_schema_col_retain_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') + t1 = Table("t1", m, Column("x", Integer), schema="q") + t2 = Table( + "t2", m, Column("y", Integer, 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') - self._assert_fk(t2, 'z', "z.t1.x") + t1 = Table("t1", m, Column("x", Integer), schema="q") + t2 = Table( + "t2", m, Column("y", Integer, 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") + t2 = Table( + "t2", m, Column("y", Integer, ForeignKey("p.t1.x")), schema="q" + ) self._assert_fk(t2, None, "p.t1.x") - Table('t1', m, Column('x', Integer), schema='p') + Table("t1", m, Column("x", Integer), schema="p") self._assert_fk(t2, None, "p.t1.x") def test_fk_and_referent_has_diff_schema_string_new_schema(self): m = MetaData() - t2 = Table('t2', m, Column('y', Integer, - ForeignKey('p.t1.x')), schema="q") + t2 = Table( + "t2", m, Column("y", Integer, ForeignKey("p.t1.x")), schema="q" + ) self._assert_fk(t2, "z", "p.t1.x") - Table('t1', m, Column('x', Integer), schema='p') + Table("t1", m, Column("x", Integer), schema="p") self._assert_fk(t2, "z", "p.t1.x") def test_fk_and_referent_has_diff_schema_col_retain_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') + t1 = Table("t1", m, Column("x", Integer), schema="p") + t2 = Table( + "t2", m, Column("y", Integer, 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') - self._assert_fk(t2, 'z', "p.t1.x") + t1 = Table("t1", m, Column("x", Integer), schema="p") + t2 = Table( + "t2", m, Column("y", Integer, 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') + t2 = Table( + "t2", m, Column("y", Integer, ForeignKey("p.t1.x")), schema="q" + ) def ref_fn(table, to_schema, constraint, referred_schema): assert table is t2 eq_(to_schema, "z") eq_(referred_schema, "p") return "h" - self._assert_fk(t2, 'z', "h.t1.x", referred_schema_fn=ref_fn) + + self._assert_fk(t2, "z", "h.t1.x", referred_schema_fn=ref_fn) def test_copy_info(self): m = MetaData() - fk = ForeignKey('t2.id') - c = Column('c', Integer, fk) - ck = CheckConstraint('c > 5') - t = Table('t', m, c, ck) - - m.info['minfo'] = True - fk.info['fkinfo'] = True - c.info['cinfo'] = True - ck.info['ckinfo'] = True - t.info['tinfo'] = True - t.primary_key.info['pkinfo'] = True - fkc = [const for const in t.constraints if - isinstance(const, ForeignKeyConstraint)][0] - fkc.info['fkcinfo'] = True + fk = ForeignKey("t2.id") + c = Column("c", Integer, fk) + ck = CheckConstraint("c > 5") + t = Table("t", m, c, ck) + + m.info["minfo"] = True + fk.info["fkinfo"] = True + c.info["cinfo"] = True + ck.info["ckinfo"] = True + t.info["tinfo"] = True + t.primary_key.info["pkinfo"] = True + fkc = [ + const + for const in t.constraints + if isinstance(const, ForeignKeyConstraint) + ][0] + fkc.info["fkcinfo"] = True m2 = MetaData() t2 = t.tometadata(m2) - m.info['minfo'] = False - fk.info['fkinfo'] = False - c.info['cinfo'] = False - ck.info['ckinfo'] = False - t.primary_key.info['pkinfo'] = False - fkc.info['fkcinfo'] = False + m.info["minfo"] = False + fk.info["fkinfo"] = False + c.info["cinfo"] = False + ck.info["ckinfo"] = False + t.primary_key.info["pkinfo"] = False + fkc.info["fkcinfo"] = False eq_(m2.info, {}) eq_(t2.info, {"tinfo": True}) @@ -1017,21 +1137,29 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): eq_(list(t2.c.c.foreign_keys)[0].info, {"fkinfo": True}) eq_(t2.primary_key.info, {"pkinfo": True}) - fkc2 = [const for const in t2.constraints - if isinstance(const, ForeignKeyConstraint)][0] + fkc2 = [ + const + for const in t2.constraints + if isinstance(const, ForeignKeyConstraint) + ][0] eq_(fkc2.info, {"fkcinfo": True}) - ck2 = [const for const in - t2.constraints if isinstance(const, CheckConstraint)][0] + ck2 = [ + const + for const in 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', - ) + table = Table( + "mytable", + meta, + Column("myid", Integer, primary_key=True), + mysql_engine="InnoDB", + ) meta2 = MetaData() table_c = table.tometadata(meta2) @@ -1043,72 +1171,82 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): def test_indexes(self): meta = MetaData() - table = Table('mytable', meta, - Column('id', Integer, primary_key=True), - Column('data1', Integer, index=True), - Column('data2', Integer), - Index('text', text('data1 + 1')), - ) - Index('multi', table.c.data1, table.c.data2) - Index('func', func.abs(table.c.data1)) - Index('multi-func', table.c.data1, func.abs(table.c.data2)) + table = Table( + "mytable", + meta, + Column("id", Integer, primary_key=True), + Column("data1", Integer, index=True), + Column("data2", Integer), + Index("text", text("data1 + 1")), + ) + Index("multi", table.c.data1, table.c.data2) + Index("func", func.abs(table.c.data1)) + Index("multi-func", table.c.data1, func.abs(table.c.data2)) meta2 = MetaData() table_c = table.tometadata(meta2) def _get_key(i): - return [i.name, i.unique] + \ - sorted(i.kwargs.items()) + \ - [str(col) for col in i.expressions] + return ( + [i.name, i.unique] + + sorted(i.kwargs.items()) + + [str(col) for col in i.expressions] + ) eq_( sorted([_get_key(i) for i in table.indexes]), - sorted([_get_key(i) for i in table_c.indexes]) + sorted([_get_key(i) for i in table_c.indexes]), ) def test_indexes_with_col_redefine(self): meta = MetaData() - table = Table('mytable', meta, - Column('id', Integer, primary_key=True), - Column('data1', Integer), - Column('data2', Integer), - Index('text', text('data1 + 1')), - ) - Index('multi', table.c.data1, table.c.data2) - Index('func', func.abs(table.c.data1)) - Index('multi-func', table.c.data1, func.abs(table.c.data2)) - - table = Table('mytable', meta, - Column('data1', Integer), - Column('data2', Integer), - extend_existing=True - ) + table = Table( + "mytable", + meta, + Column("id", Integer, primary_key=True), + Column("data1", Integer), + Column("data2", Integer), + Index("text", text("data1 + 1")), + ) + Index("multi", table.c.data1, table.c.data2) + Index("func", func.abs(table.c.data1)) + Index("multi-func", table.c.data1, func.abs(table.c.data2)) + + table = Table( + "mytable", + meta, + Column("data1", Integer), + Column("data2", Integer), + extend_existing=True, + ) meta2 = MetaData() table_c = table.tometadata(meta2) def _get_key(i): - return [i.name, i.unique] + \ - sorted(i.kwargs.items()) + \ - [str(col) for col in i.expressions] + return ( + [i.name, i.unique] + + sorted(i.kwargs.items()) + + [str(col) for col in i.expressions] + ) eq_( sorted([_get_key(i) for i in table.indexes]), - sorted([_get_key(i) for i in table_c.indexes]) + sorted([_get_key(i) for i in table_c.indexes]), ) @emits_warning("Table '.+' already exists within the given MetaData") def test_already_exists(self): meta1 = MetaData() - table1 = Table('mytable', meta1, - Column('myid', Integer, primary_key=True), - ) + table1 = Table( + "mytable", meta1, Column("myid", Integer, primary_key=True) + ) meta2 = MetaData() - table2 = Table('mytable', meta2, - Column('yourid', Integer, primary_key=True), - ) + table2 = Table( + "mytable", meta2, Column("yourid", Integer, primary_key=True) + ) table_c = table1.tometadata(meta2) table_d = table2.tometadata(meta2) @@ -1117,86 +1255,97 @@ class ToMetaDataTest(fixtures.TestBase, ComparesTables): assert table_c is table_d def test_default_schema_metadata(self): - meta = MetaData(schema='myschema') + meta = MetaData(schema="myschema") table = Table( - 'mytable', + "mytable", meta, + Column("myid", Integer, primary_key=True), + Column("name", String(40), nullable=True), Column( - 'myid', - Integer, - primary_key=True), - Column( - 'name', - String(40), - nullable=True), - Column( - 'description', - String(30), - CheckConstraint("description='hi'")), - UniqueConstraint('name'), + "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')), ) + "othertable", + meta, + Column("id", Integer, primary_key=True), + Column("myid", Integer, ForeignKey("myschema.mytable.myid")), + ) - meta2 = MetaData(schema='someschema') + 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)) - eq_(str(table_c.join(table2_c).onclause), - "someschema.mytable.myid = someschema.othertable.myid") + eq_( + str(table_c.join(table2_c).onclause), + str(table_c.c.myid == table2_c.c.myid), + ) + eq_( + str(table_c.join(table2_c).onclause), + "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'), - ) + 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('mytable.myid')), - ) + table2 = Table( + "othertable", + meta, + 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)) - eq_(str(table_c.join(table2_c).onclause), - 'mytable.myid = othertable.myid') + eq_( + str(table_c.join(table2_c).onclause), + str(table_c.c.myid == table2_c.c.myid), + ) + eq_( + str(table_c.join(table2_c).onclause), + "mytable.myid = othertable.myid", + ) def test_unique_true_flag(self): meta = MetaData() - table = Table('mytable', meta, Column('x', Integer, unique=True)) + table = Table("mytable", meta, Column("x", Integer, unique=True)) m2 = MetaData() t2 = table.tometadata(m2) eq_( - len([ - const for const - in t2.constraints - if isinstance(const, UniqueConstraint)]), - 1 + len( + [ + const + for const in t2.constraints + if isinstance(const, UniqueConstraint) + ] + ), + 1, ) def test_index_true_flag(self): meta = MetaData() - table = Table('mytable', meta, Column('x', Integer, index=True)) + table = Table("mytable", meta, Column("x", Integer, index=True)) m2 = MetaData() @@ -1214,168 +1363,161 @@ class InfoTest(fixtures.TestBase): eq_(m1.info, {"foo": "bar"}) def test_foreignkey_constraint_info(self): - fkc = ForeignKeyConstraint(['a'], ['b'], name='bar') + fkc = ForeignKeyConstraint(["a"], ["b"], name="bar") eq_(fkc.info, {}) fkc = ForeignKeyConstraint( - ['a'], ['b'], name='bar', info={"foo": "bar"}) + ["a"], ["b"], name="bar", info={"foo": "bar"} + ) eq_(fkc.info, {"foo": "bar"}) def test_foreignkey_info(self): - fkc = ForeignKey('a') + fkc = ForeignKey("a") eq_(fkc.info, {}) - fkc = ForeignKey('a', info={"foo": "bar"}) + fkc = ForeignKey("a", info={"foo": "bar"}) eq_(fkc.info, {"foo": "bar"}) def test_primarykey_constraint_info(self): - pkc = PrimaryKeyConstraint('a', name='x') + pkc = PrimaryKeyConstraint("a", name="x") eq_(pkc.info, {}) - pkc = PrimaryKeyConstraint('a', name='x', info={'foo': 'bar'}) - eq_(pkc.info, {'foo': 'bar'}) + pkc = PrimaryKeyConstraint("a", name="x", info={"foo": "bar"}) + eq_(pkc.info, {"foo": "bar"}) def test_unique_constraint_info(self): - uc = UniqueConstraint('a', name='x') + uc = UniqueConstraint("a", name="x") eq_(uc.info, {}) - uc = UniqueConstraint('a', name='x', info={'foo': 'bar'}) - eq_(uc.info, {'foo': 'bar'}) + uc = UniqueConstraint("a", name="x", info={"foo": "bar"}) + eq_(uc.info, {"foo": "bar"}) def test_check_constraint_info(self): - cc = CheckConstraint('foo=bar', name='x') + cc = CheckConstraint("foo=bar", name="x") eq_(cc.info, {}) - cc = CheckConstraint('foo=bar', name='x', info={'foo': 'bar'}) - eq_(cc.info, {'foo': 'bar'}) + cc = CheckConstraint("foo=bar", name="x", info={"foo": "bar"}) + eq_(cc.info, {"foo": "bar"}) def test_index_info(self): - ix = Index('x', 'a') + ix = Index("x", "a") eq_(ix.info, {}) - ix = Index('x', 'a', info={'foo': 'bar'}) - eq_(ix.info, {'foo': 'bar'}) + ix = Index("x", "a", info={"foo": "bar"}) + eq_(ix.info, {"foo": "bar"}) def test_column_info(self): - c = Column('x', Integer) + c = Column("x", Integer) eq_(c.info, {}) - c = Column('x', Integer, info={'foo': 'bar'}) - eq_(c.info, {'foo': 'bar'}) + c = Column("x", Integer, info={"foo": "bar"}) + eq_(c.info, {"foo": "bar"}) def test_table_info(self): - t = Table('x', MetaData()) + t = Table("x", MetaData()) eq_(t.info, {}) - t = Table('x', MetaData(), info={'foo': 'bar'}) - eq_(t.info, {'foo': 'bar'}) + t = Table("x", MetaData(), info={"foo": "bar"}) + eq_(t.info, {"foo": "bar"}) class TableTest(fixtures.TestBase, AssertsCompiledSQL): - @testing.requires.temporary_tables - @testing.skip_if('mssql', 'different col format') + @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"]) + + table1 = Table( + "temporary_table_1", + MetaData(), + Column("col1", Integer), + prefixes=["TEMPORARY"], + ) self.assert_compile( schema.CreateTable(table1), - "CREATE TEMPORARY TABLE temporary_table_1 (col1 INTEGER)" + "CREATE TEMPORARY TABLE temporary_table_1 (col1 INTEGER)", ) - table2 = Table("temporary_table_2", MetaData(), - Column("col1", Integer), - prefixes=["VIRTUAL"]) + table2 = Table( + "temporary_table_2", + MetaData(), + Column("col1", Integer), + prefixes=["VIRTUAL"], + ) self.assert_compile( schema.CreateTable(table2), - "CREATE VIRTUAL TABLE temporary_table_2 (col1 INTEGER)" + "CREATE VIRTUAL TABLE temporary_table_2 (col1 INTEGER)", ) def test_table_info(self): metadata = MetaData() - t1 = Table('foo', metadata, info={'x': 'y'}) - t2 = Table('bar', metadata, info={}) - t3 = Table('bat', metadata) - assert t1.info == {'x': 'y'} + t1 = Table("foo", metadata, info={"x": "y"}) + t2 = Table("bar", metadata, info={}) + t3 = Table("bat", metadata) + assert t1.info == {"x": "y"} assert t2.info == {} assert t3.info == {} for t in (t1, t2, t3): - t.info['bar'] = 'zip' - assert t.info['bar'] == 'zip' + t.info["bar"] = "zip" + assert t.info["bar"] == "zip" def test_reset_exported_passes(self): m = MetaData() - t = Table('t', m, Column('foo', Integer)) - eq_( - list(t.c), [t.c.foo] - ) + t = Table("t", m, Column("foo", Integer)) + eq_(list(t.c), [t.c.foo]) t._reset_exported() - eq_( - list(t.c), [t.c.foo] - ) + eq_(list(t.c), [t.c.foo]) def test_foreign_key_constraints_collection(self): metadata = MetaData() - t1 = Table('foo', metadata, Column('a', Integer)) + t1 = Table("foo", metadata, Column("a", Integer)) eq_(t1.foreign_key_constraints, set()) - fk1 = ForeignKey('q.id') - fk2 = ForeignKey('j.id') - fk3 = ForeignKeyConstraint(['b', 'c'], ['r.x', 'r.y']) + fk1 = ForeignKey("q.id") + fk2 = ForeignKey("j.id") + fk3 = ForeignKeyConstraint(["b", "c"], ["r.x", "r.y"]) - t1.append_column(Column('b', Integer, fk1)) - eq_( - t1.foreign_key_constraints, - set([fk1.constraint])) + t1.append_column(Column("b", Integer, fk1)) + eq_(t1.foreign_key_constraints, set([fk1.constraint])) - t1.append_column(Column('c', Integer, fk2)) - eq_( - t1.foreign_key_constraints, - set([fk1.constraint, fk2.constraint])) + t1.append_column(Column("c", Integer, fk2)) + eq_(t1.foreign_key_constraints, set([fk1.constraint, fk2.constraint])) t1.append_constraint(fk3) eq_( t1.foreign_key_constraints, - set([fk1.constraint, fk2.constraint, fk3])) + set([fk1.constraint, fk2.constraint, fk3]), + ) def test_c_immutable(self): m = MetaData() - t1 = Table('t', m, Column('x', Integer), Column('y', Integer)) - assert_raises( - TypeError, - t1.c.extend, [Column('z', Integer)] - ) + t1 = Table("t", m, Column("x", Integer), Column("y", Integer)) + assert_raises(TypeError, t1.c.extend, [Column("z", Integer)]) def assign(): - t1.c['z'] = Column('z', Integer) - assert_raises( - TypeError, - assign - ) + t1.c["z"] = Column("z", Integer) + + assert_raises(TypeError, assign) def assign2(): - t1.c.z = Column('z', Integer) - assert_raises( - TypeError, - assign2 - ) + t1.c.z = Column("z", Integer) + + assert_raises(TypeError, assign2) def test_c_mutate_after_unpickle(self): m = MetaData() - y = Column('y', Integer) - t1 = Table('t', m, Column('x', Integer), y) + y = Column("y", Integer) + t1 = Table("t", m, Column("x", Integer), y) t2 = pickle.loads(pickle.dumps(t1)) - z = Column('z', Integer) - g = Column('g', Integer) + z = Column("z", Integer) + g = Column("g", Integer) t2.append_column(z) is_(t1.c.contains_column(y), True) @@ -1389,39 +1531,39 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): def test_autoincrement_replace(self): m = MetaData() - t = Table('t', m, - Column('id', Integer, primary_key=True) - ) + t = Table("t", m, 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 - ) + t = Table( + "t", + m, + 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) - ) - eq_( - list(t.primary_key), [t.c.x] - ) - eq_( - t.primary_key.dialect_kwargs, {"mssql_clustered": True} + t = Table( + "t", + m, + Column("x", Integer, primary_key=True), + PrimaryKeyConstraint(mssql_clustered=True), ) + eq_(list(t.primary_key), [t.c.x]) + eq_(t.primary_key.dialect_kwargs, {"mssql_clustered": True}) 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') - ) + t = Table( + "t", + m, + 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) @@ -1432,10 +1574,12 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): exc.SAWarning, "Table 't' specifies columns 'x' as primary_key=True, " "not matching locally specified columns 'q'", - Table, 't', m, - Column('x', Integer, primary_key=True), - Column('q', Integer), - PrimaryKeyConstraint('q') + Table, + "t", + m, + Column("x", Integer, primary_key=True), + Column("q", Integer), + PrimaryKeyConstraint("q"), ) def test_pk_col_mismatch_two(self): @@ -1444,40 +1588,46 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): exc.SAWarning, "Table 't' specifies columns 'a', 'b', 'c' as primary_key=True, " "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') + Table, + "t", + m, + 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') - ) + t = Table( + "t", + m, + 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') - ) + 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"), + ) eq_(list(t.primary_key), [t.c.b, t.c.c]) def test_pk_always_flips_nullable(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer), PrimaryKeyConstraint('x')) + t1 = Table("t1", m, Column("x", Integer), PrimaryKeyConstraint("x")) - t2 = Table('t2', m, Column('x', Integer, primary_key=True)) + t2 = Table("t2", m, Column("x", Integer, primary_key=True)) eq_(list(t1.primary_key), [t1.c.x]) @@ -1492,67 +1642,58 @@ class TableTest(fixtures.TestBase, AssertsCompiledSQL): class PKAutoIncrementTest(fixtures.TestBase): def test_multi_integer_no_autoinc(self): - pk = PrimaryKeyConstraint( - Column('a', Integer), - Column('b', Integer) - ) - t = Table('t', MetaData()) + pk = PrimaryKeyConstraint(Column("a", Integer), Column("b", Integer)) + t = Table("t", MetaData()) t.append_constraint(pk) is_(pk._autoincrement_column, None) def test_multi_integer_multi_autoinc(self): pk = PrimaryKeyConstraint( - Column('a', Integer, autoincrement=True), - Column('b', Integer, autoincrement=True) + Column("a", Integer, autoincrement=True), + Column("b", Integer, autoincrement=True), ) - t = Table('t', MetaData()) + t = Table("t", MetaData()) t.append_constraint(pk) assert_raises_message( exc.ArgumentError, "Only one Column may be marked", - lambda: pk._autoincrement_column + lambda: pk._autoincrement_column, ) def test_single_integer_no_autoinc(self): - pk = PrimaryKeyConstraint( - Column('a', Integer), - ) - t = Table('t', MetaData()) + pk = PrimaryKeyConstraint(Column("a", Integer)) + t = Table("t", MetaData()) t.append_constraint(pk) - is_(pk._autoincrement_column, pk.columns['a']) + is_(pk._autoincrement_column, pk.columns["a"]) def test_single_string_no_autoinc(self): - pk = PrimaryKeyConstraint( - Column('a', String), - ) - t = Table('t', MetaData()) + pk = PrimaryKeyConstraint(Column("a", String)) + t = Table("t", MetaData()) t.append_constraint(pk) is_(pk._autoincrement_column, None) def test_single_string_illegal_autoinc(self): - t = Table('t', MetaData(), Column('a', String, autoincrement=True)) - pk = PrimaryKeyConstraint( - t.c.a - ) + t = Table("t", MetaData(), Column("a", String, autoincrement=True)) + pk = PrimaryKeyConstraint(t.c.a) t.append_constraint(pk) assert_raises_message( exc.ArgumentError, "Column type VARCHAR on column 't.a'", - lambda: pk._autoincrement_column + lambda: pk._autoincrement_column, ) def test_single_integer_default(self): t = Table( - 't', MetaData(), - Column('a', Integer, autoincrement=True, default=lambda: 1)) - pk = PrimaryKeyConstraint( - t.c.a + "t", + MetaData(), + Column("a", Integer, autoincrement=True, default=lambda: 1), ) + pk = PrimaryKeyConstraint(t.c.a) t.append_constraint(pk) is_(pk._autoincrement_column, t.c.a) @@ -1562,47 +1703,45 @@ class PKAutoIncrementTest(fixtures.TestBase): # if the user puts autoincrement=True with a server_default, trust # them on it t = Table( - 't', MetaData(), - Column('a', Integer, - autoincrement=True, server_default=func.magic())) - pk = PrimaryKeyConstraint( - t.c.a + "t", + MetaData(), + Column( + "a", Integer, autoincrement=True, server_default=func.magic() + ), ) + pk = PrimaryKeyConstraint(t.c.a) t.append_constraint(pk) is_(pk._autoincrement_column, t.c.a) def test_implicit_autoinc_but_fks(self): m = MetaData() - Table('t1', m, Column('id', Integer, primary_key=True)) - t2 = Table( - 't2', MetaData(), - Column('a', Integer, ForeignKey('t1.id'))) - pk = PrimaryKeyConstraint( - t2.c.a - ) + Table("t1", m, Column("id", Integer, primary_key=True)) + t2 = Table("t2", MetaData(), Column("a", Integer, ForeignKey("t1.id"))) + pk = PrimaryKeyConstraint(t2.c.a) t2.append_constraint(pk) is_(pk._autoincrement_column, None) def test_explicit_autoinc_but_fks(self): m = MetaData() - Table('t1', m, Column('id', Integer, primary_key=True)) + Table("t1", m, Column("id", Integer, primary_key=True)) t2 = Table( - 't2', MetaData(), - Column('a', Integer, ForeignKey('t1.id'), autoincrement=True)) - pk = PrimaryKeyConstraint( - t2.c.a + "t2", + MetaData(), + Column("a", Integer, ForeignKey("t1.id"), autoincrement=True), ) + pk = PrimaryKeyConstraint(t2.c.a) t2.append_constraint(pk) is_(pk._autoincrement_column, t2.c.a) t3 = Table( - 't3', MetaData(), - Column('a', Integer, - ForeignKey('t1.id'), autoincrement='ignore_fk')) - pk = PrimaryKeyConstraint( - t3.c.a + "t3", + MetaData(), + Column( + "a", Integer, ForeignKey("t1.id"), autoincrement="ignore_fk" + ), ) + pk = PrimaryKeyConstraint(t3.c.a) t3.append_constraint(pk) is_(pk._autoincrement_column, t3.c.a) @@ -1622,12 +1761,14 @@ class SchemaTypeTest(fixtures.TestBase): def _on_table_create(self, target, bind, **kw): super(SchemaTypeTest.TrackEvents, self)._on_table_create( - target, bind, **kw) + target, bind, **kw + ) self.evt_targets += (target,) def _on_metadata_create(self, target, bind, **kw): super(SchemaTypeTest.TrackEvents, self)._on_metadata_create( - target, bind, **kw) + target, bind, **kw + ) self.evt_targets += (target,) # TODO: Enum and Boolean put TypeEngine first. Changing that here @@ -1644,7 +1785,6 @@ class SchemaTypeTest(fixtures.TestBase): pass class MyTypeWImpl(MyType): - def _gen_dialect_impl(self, dialect): return self.adapt(SchemaTypeTest.MyTypeImpl) @@ -1724,13 +1864,13 @@ class SchemaTypeTest(fixtures.TestBase): orig_set_parent_w_dispatch(parent) canary._set_parent_with_dispatch(parent) - with mock.patch.object(evt_target, '_set_parent', _set_parent): + with mock.patch.object(evt_target, "_set_parent", _set_parent): with mock.patch.object( - evt_target, '_set_parent_with_dispatch', - _set_parent_w_dispatch): + evt_target, "_set_parent_with_dispatch", _set_parent_w_dispatch + ): event.listen(evt_target, "before_parent_attach", canary.go) - c = Column('q', typ) + c = Column("q", typ) if double: # no clean way yet to fix this, inner schema type is called @@ -1741,8 +1881,8 @@ class SchemaTypeTest(fixtures.TestBase): mock.call._set_parent(c), mock.call.go(evt_target, c), mock.call._set_parent(c), - mock.call._set_parent_with_dispatch(c) - ] + mock.call._set_parent_with_dispatch(c), + ], ) else: eq_( @@ -1750,39 +1890,39 @@ class SchemaTypeTest(fixtures.TestBase): [ mock.call.go(evt_target, c), mock.call._set_parent(c), - mock.call._set_parent_with_dispatch(c) - ] + mock.call._set_parent_with_dispatch(c), + ], ) def test_independent_schema(self): m = MetaData() type_ = self.MyType(schema="q") - t1 = Table('x', m, Column("y", type_), schema="z") + t1 = Table("x", m, Column("y", type_), schema="z") eq_(t1.c.y.type.schema, "q") def test_inherit_schema(self): m = MetaData() type_ = self.MyType(schema="q", inherit_schema=True) - t1 = Table('x', m, Column("y", type_), schema="z") + t1 = Table("x", m, Column("y", type_), schema="z") eq_(t1.c.y.type.schema, "z") def test_independent_schema_enum(self): m = MetaData() type_ = sqltypes.Enum("a", schema="q") - t1 = Table('x', m, Column("y", type_), schema="z") + t1 = Table("x", m, Column("y", type_), schema="z") eq_(t1.c.y.type.schema, "q") def test_inherit_schema_enum(self): m = MetaData() type_ = sqltypes.Enum("a", "b", "c", schema="q", inherit_schema=True) - t1 = Table('x', m, Column("y", type_), schema="z") + t1 = Table("x", m, Column("y", type_), schema="z") eq_(t1.c.y.type.schema, "z") def test_tometadata_copy_type(self): m1 = MetaData() type_ = self.MyType() - t1 = Table('x', m1, Column("y", type_)) + t1 = Table("x", m1, Column("y", type_)) m2 = MetaData() t2 = t1.tometadata(m2) @@ -1794,14 +1934,13 @@ class SchemaTypeTest(fixtures.TestBase): is_(t2.c.y.type.table, t2) def test_tometadata_copy_decorated(self): - class MyDecorated(TypeDecorator): impl = self.MyType m1 = MetaData() type_ = MyDecorated(schema="z") - t1 = Table('x', m1, Column("y", type_)) + t1 = Table("x", m1, Column("y", type_)) m2 = MetaData() t2 = t1.tometadata(m2) @@ -1811,7 +1950,7 @@ class SchemaTypeTest(fixtures.TestBase): m1 = MetaData() type_ = self.MyType() - t1 = Table('x', m1, Column("y", type_)) + t1 = Table("x", m1, Column("y", type_)) m2 = MetaData() t2 = t1.tometadata(m2, schema="bar") @@ -1822,7 +1961,7 @@ class SchemaTypeTest(fixtures.TestBase): m1 = MetaData() type_ = self.MyType(inherit_schema=True) - t1 = Table('x', m1, Column("y", type_)) + t1 = Table("x", m1, Column("y", type_)) m2 = MetaData() t2 = t1.tometadata(m2, schema="bar") @@ -1834,7 +1973,7 @@ class SchemaTypeTest(fixtures.TestBase): m1 = MetaData() type_ = self.MyType() - t1 = Table('x', m1, Column("y", type_)) + t1 = Table("x", m1, Column("y", type_)) m2 = MetaData() t2 = t1.tometadata(m2) @@ -1851,17 +1990,17 @@ class SchemaTypeTest(fixtures.TestBase): def test_enum_column_copy_transfers_events(self): m = MetaData() - type_ = self.WrapEnum('a', 'b', 'c', name='foo') - y = Column('y', type_) + type_ = self.WrapEnum("a", "b", "c", name="foo") + y = Column("y", type_) y_copy = y.copy() - t1 = Table('x', m, y_copy) + t1 = Table("x", m, y_copy) is_true(y_copy.type._create_events) # for PostgreSQL, this will emit CREATE TYPE m.dispatch.before_create(t1, testing.db) try: - eq_(t1.c.y.type.evt_targets, (t1, )) + eq_(t1.c.y.type.evt_targets, (t1,)) finally: # do the drop so that PostgreSQL emits DROP TYPE m.dispatch.after_drop(t1, testing.db) @@ -1869,25 +2008,30 @@ class SchemaTypeTest(fixtures.TestBase): def test_enum_nonnative_column_copy_transfers_events(self): m = MetaData() - type_ = self.WrapEnum('a', 'b', 'c', name='foo', native_enum=False) - y = Column('y', type_) + type_ = self.WrapEnum("a", "b", "c", name="foo", native_enum=False) + y = Column("y", type_) y_copy = y.copy() - t1 = Table('x', m, y_copy) + t1 = Table("x", m, y_copy) is_true(y_copy.type._create_events) m.dispatch.before_create(t1, testing.db) - eq_(t1.c.y.type.evt_targets, (t1, )) + eq_(t1.c.y.type.evt_targets, (t1,)) def test_enum_nonnative_column_copy_transfers_constraintpref(self): m = MetaData() type_ = self.WrapEnum( - 'a', 'b', 'c', name='foo', - native_enum=False, create_constraint=False) - y = Column('y', type_) + "a", + "b", + "c", + name="foo", + native_enum=False, + create_constraint=False, + ) + y = Column("y", type_) y_copy = y.copy() - Table('x', m, y_copy) + Table("x", m, y_copy) is_false(y_copy.type.create_constraint) @@ -1895,9 +2039,9 @@ class SchemaTypeTest(fixtures.TestBase): m = MetaData() type_ = self.WrapBoolean() - y = Column('y', type_) + y = Column("y", type_) y_copy = y.copy() - t1 = Table('x', m, y_copy) + t1 = Table("x", m, y_copy) is_true(y_copy.type._create_events) @@ -1905,9 +2049,9 @@ class SchemaTypeTest(fixtures.TestBase): m = MetaData() type_ = self.WrapBoolean(create_constraint=False) - y = Column('y', type_) + y = Column("y", type_) y_copy = y.copy() - Table('x', m, y_copy) + Table("x", m, y_copy) is_false(y_copy.type.create_constraint) @@ -1915,7 +2059,7 @@ class SchemaTypeTest(fixtures.TestBase): m1 = MetaData() typ = self.MyType(metadata=m1) m1.dispatch.before_create(m1, testing.db) - eq_(typ.evt_targets, (m1, )) + eq_(typ.evt_targets, (m1,)) dialect_impl = typ.dialect_impl(testing.db.dialect) eq_(dialect_impl.evt_targets, ()) @@ -1924,24 +2068,24 @@ class SchemaTypeTest(fixtures.TestBase): m1 = MetaData() typ = self.MyTypeWImpl(metadata=m1) m1.dispatch.before_create(m1, testing.db) - eq_(typ.evt_targets, (m1, )) + eq_(typ.evt_targets, (m1,)) dialect_impl = typ.dialect_impl(testing.db.dialect) - eq_(dialect_impl.evt_targets, (m1, )) + eq_(dialect_impl.evt_targets, (m1,)) def test_table_dispatch_decorator_schematype(self): m1 = MetaData() typ = self.MyTypeDecAndSchema() - t1 = Table('t1', m1, Column('x', typ)) + t1 = Table("t1", m1, Column("x", typ)) m1.dispatch.before_create(t1, testing.db) - eq_(typ.evt_targets, (t1, )) + eq_(typ.evt_targets, (t1,)) def test_table_dispatch_no_new_impl(self): m1 = MetaData() typ = self.MyType() - t1 = Table('t1', m1, Column('x', typ)) + t1 = Table("t1", m1, Column("x", typ)) m1.dispatch.before_create(t1, testing.db) - eq_(typ.evt_targets, (t1, )) + eq_(typ.evt_targets, (t1,)) dialect_impl = typ.dialect_impl(testing.db.dialect) eq_(dialect_impl.evt_targets, ()) @@ -1949,12 +2093,12 @@ class SchemaTypeTest(fixtures.TestBase): def test_table_dispatch_new_impl(self): m1 = MetaData() typ = self.MyTypeWImpl() - t1 = Table('t1', m1, Column('x', typ)) + t1 = Table("t1", m1, Column("x", typ)) m1.dispatch.before_create(t1, testing.db) - eq_(typ.evt_targets, (t1, )) + eq_(typ.evt_targets, (t1,)) dialect_impl = typ.dialect_impl(testing.db.dialect) - eq_(dialect_impl.evt_targets, (t1, )) + eq_(dialect_impl.evt_targets, (t1,)) def test_create_metadata_bound_no_crash(self): m1 = MetaData() @@ -1965,127 +2109,103 @@ class SchemaTypeTest(fixtures.TestBase): def test_boolean_constraint_type_doesnt_double(self): m1 = MetaData() - t1 = Table('x', m1, Column("flag", Boolean())) + t1 = Table("x", m1, Column("flag", Boolean())) eq_( - len([ - c for c in t1.constraints - if isinstance(c, CheckConstraint)]), - 1 + len([c for c in t1.constraints if isinstance(c, CheckConstraint)]), + 1, ) m2 = MetaData() t2 = t1.tometadata(m2) eq_( - len([ - c for c in t2.constraints - if isinstance(c, CheckConstraint)]), - 1 + len([c for c in t2.constraints if isinstance(c, CheckConstraint)]), + 1, ) def test_enum_constraint_type_doesnt_double(self): m1 = MetaData() - t1 = Table('x', m1, Column("flag", Enum('a', 'b', 'c'))) + t1 = Table("x", m1, Column("flag", Enum("a", "b", "c"))) eq_( - len([ - c for c in t1.constraints - if isinstance(c, CheckConstraint)]), - 1 + len([c for c in t1.constraints if isinstance(c, CheckConstraint)]), + 1, ) m2 = MetaData() t2 = t1.tometadata(m2) eq_( - len([ - c for c in t2.constraints - if isinstance(c, CheckConstraint)]), - 1 + len([c for c in t2.constraints if isinstance(c, CheckConstraint)]), + 1, ) class SchemaTest(fixtures.TestBase, AssertsCompiledSQL): - def test_default_schema_metadata_fk(self): m = MetaData(schema="foo") - t1 = Table('t1', m, Column('x', Integer)) - t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x'))) + t1 = Table("t1", m, Column("x", Integer)) + t2 = Table("t2", m, Column("x", Integer, ForeignKey("t1.x"))) assert t2.c.x.references(t1.c.x) def test_ad_hoc_schema_equiv_fk(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer), schema="foo") + t1 = Table("t1", m, Column("x", Integer), schema="foo") t2 = Table( - 't2', - m, - Column( - 'x', - Integer, - ForeignKey('t1.x')), - schema="foo") + "t2", m, Column("x", Integer, ForeignKey("t1.x")), schema="foo" + ) assert_raises( - exc.NoReferencedTableError, - lambda: t2.c.x.references(t1.c.x) + exc.NoReferencedTableError, lambda: t2.c.x.references(t1.c.x) ) def test_default_schema_metadata_fk_alt_remote(self): m = MetaData(schema="foo") - t1 = Table('t1', m, Column('x', Integer)) - t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x')), - schema="bar") + t1 = Table("t1", m, Column("x", Integer)) + t2 = Table( + "t2", m, Column("x", Integer, ForeignKey("t1.x")), schema="bar" + ) assert t2.c.x.references(t1.c.x) def test_default_schema_metadata_fk_alt_local_raises(self): m = MetaData(schema="foo") - t1 = Table('t1', m, Column('x', Integer), schema="bar") - t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x'))) + t1 = Table("t1", m, Column("x", Integer), schema="bar") + t2 = Table("t2", m, Column("x", Integer, ForeignKey("t1.x"))) assert_raises( - exc.NoReferencedTableError, - lambda: t2.c.x.references(t1.c.x) + exc.NoReferencedTableError, lambda: t2.c.x.references(t1.c.x) ) def test_default_schema_metadata_fk_alt_local(self): m = MetaData(schema="foo") - t1 = Table('t1', m, Column('x', Integer), schema="bar") - t2 = Table('t2', m, Column('x', Integer, ForeignKey('bar.t1.x'))) + t1 = Table("t1", m, Column("x", Integer), schema="bar") + t2 = Table("t2", m, Column("x", Integer, ForeignKey("bar.t1.x"))) assert t2.c.x.references(t1.c.x) def test_create_drop_schema(self): self.assert_compile( - schema.CreateSchema("sa_schema"), - "CREATE SCHEMA sa_schema" + schema.CreateSchema("sa_schema"), "CREATE SCHEMA sa_schema" ) self.assert_compile( - schema.DropSchema("sa_schema"), - "DROP SCHEMA sa_schema" + schema.DropSchema("sa_schema"), "DROP SCHEMA sa_schema" ) self.assert_compile( schema.DropSchema("sa_schema", cascade=True), - "DROP SCHEMA sa_schema CASCADE" + "DROP SCHEMA sa_schema CASCADE", ) def test_iteration(self): metadata = MetaData() table1 = Table( - 'table1', + "table1", metadata, - Column( - 'col1', - Integer, - primary_key=True), - schema='someschema') + Column("col1", Integer, primary_key=True), + schema="someschema", + ) table2 = Table( - 'table2', + "table2", metadata, - Column( - 'col1', - Integer, - primary_key=True), - Column( - 'col2', - Integer, - ForeignKey('someschema.table1.col1')), - schema='someschema') + 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)) @@ -2098,16 +2218,18 @@ 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))) + Table( + "users", + metadata, + Column("id", Integer, primary_key=True), + Column("name", String(30)), + ) def _useexisting_fixture(self): meta2 = MetaData(testing.db) - Table('users', meta2, autoload=True) + Table("users", meta2, autoload=True) return meta2 def _notexisting_fixture(self): @@ -2117,21 +2239,23 @@ class UseExistingTest(fixtures.TablesTest): meta2 = self._useexisting_fixture() def go(): - Table('users', meta2, Column('name', - Unicode), autoload=True) + Table("users", meta2, Column("name", Unicode), autoload=True) + assert_raises_message( exc.InvalidRequestError, - "Table 'users' is already defined for this " - "MetaData instance.", - go + "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 + Table, + "users", + meta2, + keep_existing=True, + extend_existing=True, ) @testing.uses_deprecated() @@ -2139,118 +2263,152 @@ class UseExistingTest(fixtures.TablesTest): meta2 = self._useexisting_fixture() assert_raises( exc.ArgumentError, - Table, 'users', meta2, useexisting=True, - extend_existing=True + Table, + "users", + meta2, + useexisting=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 - ) - assert 'name' in users.c - assert 'id' in users.c + users = Table( + "users", + meta2, + 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 - ) + u2 = Table( + "users", + meta2, + 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 - ) - assert 'name' in users.c - assert 'id' in users.c + users = Table( + "users", + meta2, + 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 - ) + u2 = Table( + "users", + meta2, + Column("id", Integer), + Column("name", Unicode), + UniqueConstraint("name"), + extend_existing=True, + ) # constraint got duped eq_(len(u2.constraints), 3) def test_keep_existing_coltype(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - autoload=True, keep_existing=True) + users = Table( + "users", + meta2, + Column("name", Unicode), + autoload=True, + keep_existing=True, + ) assert not isinstance(users.c.name.type, Unicode) def test_keep_existing_quote(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, quote=True, autoload=True, - keep_existing=True) + users = Table( + "users", meta2, quote=True, autoload=True, keep_existing=True + ) assert not users.name.quote def test_keep_existing_add_column(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, - Column('foo', Integer), - autoload=True, - keep_existing=True) + users = Table( + "users", + meta2, + Column("foo", Integer), + autoload=True, + keep_existing=True, + ) assert "foo" not in users.c def test_keep_existing_coltype_no_orig(self): meta2 = self._notexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - autoload=True, keep_existing=True) + users = Table( + "users", + meta2, + Column("name", Unicode), + autoload=True, + keep_existing=True, + ) assert isinstance(users.c.name.type, Unicode) @testing.skip_if( lambda: testing.db.dialect.requires_name_normalize, - "test depends on lowercase as case insensitive") + "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, - keep_existing=True) + users = Table( + "users", meta2, quote=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, - keep_existing=True) + users = Table( + "users", + meta2, + Column("foo", Integer), + autoload=True, + keep_existing=True, + ) assert "foo" in users.c def test_keep_existing_coltype_no_reflection(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - keep_existing=True) + users = Table( + "users", meta2, Column("name", Unicode), keep_existing=True + ) assert not isinstance(users.c.name.type, Unicode) def test_keep_existing_quote_no_reflection(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, quote=True, - keep_existing=True) + users = Table("users", meta2, quote=True, keep_existing=True) assert not users.name.quote def test_keep_existing_add_column_no_reflection(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, - Column('foo', Integer), - keep_existing=True) + users = Table( + "users", meta2, Column("foo", Integer), keep_existing=True + ) assert "foo" not in users.c def test_extend_existing_coltype(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - autoload=True, extend_existing=True) + users = Table( + "users", + meta2, + Column("name", Unicode), + autoload=True, + extend_existing=True, + ) assert isinstance(users.c.name.type, Unicode) def test_extend_existing_quote(self): @@ -2258,46 +2416,63 @@ class UseExistingTest(fixtures.TablesTest): assert_raises_message( tsa.exc.ArgumentError, "Can't redefine 'quote' or 'quote_schema' arguments", - Table, 'users', meta2, quote=True, autoload=True, - extend_existing=True + Table, + "users", + meta2, + quote=True, + autoload=True, + extend_existing=True, ) def test_extend_existing_add_column(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, - Column('foo', Integer), - autoload=True, - extend_existing=True) + users = Table( + "users", + meta2, + Column("foo", Integer), + autoload=True, + extend_existing=True, + ) assert "foo" in users.c def test_extend_existing_coltype_no_orig(self): meta2 = self._notexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - autoload=True, extend_existing=True) + users = Table( + "users", + meta2, + Column("name", Unicode), + autoload=True, + extend_existing=True, + ) assert isinstance(users.c.name.type, Unicode) @testing.skip_if( lambda: testing.db.dialect.requires_name_normalize, - "test depends on lowercase as case insensitive") + "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, - extend_existing=True) + users = Table( + "users", meta2, quote=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, - extend_existing=True) + users = Table( + "users", + meta2, + Column("foo", Integer), + autoload=True, + extend_existing=True, + ) assert "foo" in users.c def test_extend_existing_coltype_no_reflection(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, Column('name', Unicode), - extend_existing=True) + users = Table( + "users", meta2, Column("name", Unicode), extend_existing=True + ) assert isinstance(users.c.name.type, Unicode) def test_extend_existing_quote_no_reflection(self): @@ -2305,35 +2480,30 @@ class UseExistingTest(fixtures.TablesTest): assert_raises_message( tsa.exc.ArgumentError, "Can't redefine 'quote' or 'quote_schema' arguments", - Table, 'users', meta2, quote=True, - extend_existing=True + Table, + "users", + meta2, + quote=True, + extend_existing=True, ) def test_extend_existing_add_column_no_reflection(self): meta2 = self._useexisting_fixture() - users = Table('users', meta2, - Column('foo', Integer), - extend_existing=True) + users = Table( + "users", meta2, Column("foo", Integer), extend_existing=True + ) assert "foo" in users.c class ConstraintTest(fixtures.TestBase): - def _single_fixture(self): m = MetaData() - t1 = Table('t1', m, - Column('a', Integer), - Column('b', Integer) - ) + t1 = Table("t1", m, Column("a", Integer), Column("b", Integer)) - t2 = Table('t2', m, - Column('a', Integer, ForeignKey('t1.a')) - ) + t2 = Table("t2", m, Column("a", Integer, ForeignKey("t1.a"))) - t3 = Table('t3', m, - Column('a', Integer) - ) + t3 = Table("t3", m, Column("a", Integer)) return t1, t2, t3 def _assert_index_col_x(self, t, i, columns=True): @@ -2346,106 +2516,108 @@ class ConstraintTest(fixtures.TestBase): def test_separate_decl_columns(self): m = MetaData() - t = Table('t', m, Column('x', Integer)) - i = Index('i', t.c.x) + t = Table("t", m, Column("x", Integer)) + i = Index("i", t.c.x) self._assert_index_col_x(t, i) def test_separate_decl_columns_functional(self): m = MetaData() - t = Table('t', m, Column('x', Integer)) - i = Index('i', func.foo(t.c.x)) + t = Table("t", m, Column("x", Integer)) + i = Index("i", func.foo(t.c.x)) self._assert_index_col_x(t, i) def test_index_no_cols_private_table_arg(self): m = MetaData() - t = Table('t', m, Column('x', Integer)) - i = Index('i', _table=t) + t = Table("t", m, Column("x", Integer)) + i = Index("i", _table=t) is_(i.table, t) eq_(list(i.columns), []) def test_index_w_cols_private_table_arg(self): m = MetaData() - t = Table('t', m, Column('x', Integer)) - i = Index('i', t.c.x, _table=t) + t = Table("t", m, Column("x", Integer)) + i = Index("i", t.c.x, _table=t) is_(i.table, t) eq_(i.columns, [t.c.x]) def test_inline_decl_columns(self): m = MetaData() - c = Column('x', Integer) - i = Index('i', c) - t = Table('t', m, c, i) + c = Column("x", Integer) + i = Index("i", c) + t = Table("t", m, c, i) self._assert_index_col_x(t, i) def test_inline_decl_columns_functional(self): m = MetaData() - c = Column('x', Integer) - i = Index('i', func.foo(c)) - t = Table('t', m, c, i) + c = Column("x", Integer) + i = Index("i", func.foo(c)) + t = Table("t", m, c, i) self._assert_index_col_x(t, i) def test_inline_decl_string(self): m = MetaData() - i = Index('i', "x") - t = Table('t', m, Column('x', Integer), i) + i = Index("i", "x") + t = Table("t", m, Column("x", Integer), i) self._assert_index_col_x(t, i) def test_inline_decl_textonly(self): m = MetaData() - i = Index('i', text("foobar(x)")) - t = Table('t', m, Column('x', Integer), i) + i = Index("i", text("foobar(x)")) + t = Table("t", m, Column("x", Integer), i) self._assert_index_col_x(t, i, columns=False) def test_separate_decl_textonly(self): m = MetaData() - i = Index('i', text("foobar(x)")) - t = Table('t', m, Column('x', Integer)) + i = Index("i", text("foobar(x)")) + t = Table("t", m, Column("x", Integer)) t.append_constraint(i) self._assert_index_col_x(t, i, columns=False) def test_unnamed_column_exception(self): # this can occur in some declarative situations c = Column(Integer) - idx = Index('q', c) + idx = Index("q", c) m = MetaData() - t = Table('t', m, Column('q')) + t = Table("t", m, Column("q")) assert_raises_message( exc.ArgumentError, "Can't add unnamed column to column collection", - t.append_constraint, idx + t.append_constraint, + idx, ) def test_column_associated_w_lowercase_table(self): from sqlalchemy import table - c = Column('x', Integer) - table('foo', c) - idx = Index('q', c) + + c = Column("x", Integer) + table("foo", c) + idx = Index("q", c) is_(idx.table, None) # lower-case-T table doesn't have indexes def test_clauseelement_extraction_one(self): - t = Table('t', MetaData(), Column('x', Integer), Column('y', Integer)) + t = Table("t", MetaData(), Column("x", Integer), Column("y", Integer)) class MyThing(object): def __clause_element__(self): return t.c.x + 5 - idx = Index('foo', MyThing()) + idx = Index("foo", MyThing()) self._assert_index_col_x(t, idx) def test_clauseelement_extraction_two(self): - t = Table('t', MetaData(), Column('x', Integer), Column('y', Integer)) + t = Table("t", MetaData(), Column("x", Integer), Column("y", Integer)) class MyThing(object): def __clause_element__(self): return t.c.x + 5 - idx = Index('bar', MyThing(), t.c.y) + idx = Index("bar", MyThing(), t.c.y) eq_(set(t.indexes), set([idx])) def test_clauseelement_extraction_three(self): - t = Table('t', MetaData(), Column('x', Integer), Column('y', Integer)) + t = Table("t", MetaData(), Column("x", Integer), Column("y", Integer)) expr1 = t.c.x + 5 @@ -2453,7 +2625,7 @@ class ConstraintTest(fixtures.TestBase): def __clause_element__(self): return expr1 - idx = Index('bar', MyThing(), t.c.y) + idx = Index("bar", MyThing(), t.c.y) is_(idx.expressions[0], expr1) is_(idx.expressions[1], t.c.y) @@ -2493,59 +2665,52 @@ class ConstraintTest(fixtures.TestBase): is_(fkc.referred_table, t1) def test_referred_table_accessor_not_available(self): - t1 = Table('t', MetaData(), Column('x', ForeignKey('q.id'))) + t1 = Table("t", MetaData(), Column("x", ForeignKey("q.id"))) fkc = list(t1.foreign_key_constraints)[0] assert_raises_message( exc.InvalidRequestError, "Foreign key associated with column 't.x' could not find " "table 'q' with which to generate a foreign key to target " "column 'id'", - getattr, fkc, "referred_table" + getattr, + fkc, + "referred_table", ) def test_related_column_not_present_atfirst_ok(self): m = MetaData() - base_table = Table("base", m, - Column("id", Integer, primary_key=True) - ) - fk = ForeignKey('base.q') - derived_table = Table("derived", m, - Column("id", None, fk, - primary_key=True), - ) - - base_table.append_column(Column('q', Integer)) + base_table = Table("base", m, Column("id", Integer, primary_key=True)) + fk = ForeignKey("base.q") + derived_table = Table( + "derived", m, Column("id", None, fk, primary_key=True) + ) + + base_table.append_column(Column("q", Integer)) assert fk.column is base_table.c.q assert isinstance(derived_table.c.id.type, Integer) def test_related_column_not_present_atfirst_ok_onname(self): m = MetaData() - base_table = Table("base", m, - Column("id", Integer, primary_key=True) - ) - fk = ForeignKey('base.q', link_to_name=True) - derived_table = Table("derived", m, - Column("id", None, fk, - primary_key=True), - ) - - base_table.append_column(Column('q', Integer, key='zz')) + base_table = Table("base", m, Column("id", Integer, primary_key=True)) + fk = ForeignKey("base.q", link_to_name=True) + derived_table = Table( + "derived", m, Column("id", None, fk, primary_key=True) + ) + + base_table.append_column(Column("q", Integer, key="zz")) assert fk.column is base_table.c.zz assert isinstance(derived_table.c.id.type, Integer) def test_related_column_not_present_atfirst_ok_linktoname_conflict(self): m = MetaData() - base_table = Table("base", m, - Column("id", Integer, primary_key=True) - ) - fk = ForeignKey('base.q', link_to_name=True) - derived_table = Table("derived", m, - Column("id", None, fk, - primary_key=True), - ) - - base_table.append_column(Column('zz', Integer, key='q')) - base_table.append_column(Column('q', Integer, key='zz')) + base_table = Table("base", m, Column("id", Integer, primary_key=True)) + fk = ForeignKey("base.q", link_to_name=True) + derived_table = Table( + "derived", m, Column("id", None, fk, primary_key=True) + ) + + base_table.append_column(Column("zz", Integer, key="q")) + base_table.append_column(Column("q", Integer, key="zz")) assert fk.column is base_table.c.zz assert isinstance(derived_table.c.id.type, Integer) @@ -2557,134 +2722,136 @@ class ConstraintTest(fixtures.TestBase): r"ForeignKeyConstraint on t1\(x, y\) refers to " "multiple remote tables: t2 and t3", Table, - 't1', m, Column('x', Integer), Column('y', Integer), - ForeignKeyConstraint(['x', 'y'], ['t2.x', 't3.y']) + "t1", + m, + Column("x", Integer), + Column("y", Integer), + ForeignKeyConstraint(["x", "y"], ["t2.x", "t3.y"]), ) def test_invalid_composite_fk_check_columns(self): m = MetaData() - t2 = Table('t2', m, Column('x', Integer)) - t3 = Table('t3', m, Column('y', Integer)) + t2 = Table("t2", m, Column("x", Integer)) + t3 = Table("t3", m, Column("y", Integer)) assert_raises_message( exc.ArgumentError, r"ForeignKeyConstraint on t1\(x, y\) refers to " "multiple remote tables: t2 and t3", Table, - 't1', m, Column('x', Integer), Column('y', Integer), - ForeignKeyConstraint(['x', 'y'], [t2.c.x, t3.c.y]) + "t1", + m, + Column("x", Integer), + Column("y", Integer), + ForeignKeyConstraint(["x", "y"], [t2.c.x, t3.c.y]), ) def test_invalid_composite_fk_check_columns_notattached(self): m = MetaData() - x = Column('x', Integer) - y = Column('y', Integer) + x = Column("x", Integer) + y = Column("y", Integer) # 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]) - ) + Table( + "t1", + m, + Column("x", Integer), + Column("y", Integer), + ForeignKeyConstraint(["x", "y"], [x, y]), + ) - Table('t2', m, x) - Table('t3', m, y) + Table("t2", m, x) + Table("t3", m, y) def test_constraint_copied_to_proxy_ok(self): m = MetaData() - Table('t1', m, Column('id', Integer, primary_key=True)) - t2 = Table('t2', m, Column('id', Integer, ForeignKey('t1.id'), - 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), + ) s = tsa.select([t2]) t2fk = list(t2.c.id.foreign_keys)[0] sfk = list(s.c.id.foreign_keys)[0] # the two FKs share the ForeignKeyConstraint - is_( - t2fk.constraint, - sfk.constraint - ) + is_(t2fk.constraint, sfk.constraint) # but the ForeignKeyConstraint isn't # aware of the select's FK - eq_( - t2fk.constraint.elements, - [t2fk] - ) + eq_(t2fk.constraint.elements, [t2fk]) def test_type_propagate_composite_fk_string(self): metadata = MetaData() Table( - 'a', metadata, - Column('key1', Integer, primary_key=True), - Column('key2', String(40), primary_key=True)) - - b = Table('b', metadata, - Column('a_key1', None), - Column('a_key2', None), - Column('id', Integer, primary_key=True), - ForeignKeyConstraint(['a_key1', 'a_key2'], - ['a.key1', 'a.key2']) - ) + "a", + metadata, + Column("key1", Integer, primary_key=True), + Column("key2", String(40), primary_key=True), + ) + + b = Table( + "b", + metadata, + Column("a_key1", None), + Column("a_key2", None), + Column("id", Integer, primary_key=True), + ForeignKeyConstraint(["a_key1", "a_key2"], ["a.key1", "a.key2"]), + ) assert isinstance(b.c.a_key1.type, Integer) assert isinstance(b.c.a_key2.type, String) def test_type_propagate_composite_fk_col(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True), - Column('key2', String(40), primary_key=True)) - - b = Table('b', metadata, - Column('a_key1', None), - Column('a_key2', None), - Column('id', Integer, primary_key=True), - ForeignKeyConstraint(['a_key1', 'a_key2'], - [a.c.key1, a.c.key2]) - ) + a = Table( + "a", + metadata, + Column("key1", Integer, primary_key=True), + Column("key2", String(40), primary_key=True), + ) + + b = Table( + "b", + metadata, + Column("a_key1", None), + Column("a_key2", None), + Column("id", Integer, primary_key=True), + ForeignKeyConstraint(["a_key1", "a_key2"], [a.c.key1, a.c.key2]), + ) assert isinstance(b.c.a_key1.type, Integer) assert isinstance(b.c.a_key2.type, String) def test_type_propagate_standalone_fk_string(self): metadata = MetaData() - 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")), - ) + b = Table("b", metadata, Column("a_key1", None, ForeignKey("a.key1"))) assert isinstance(b.c.a_key1.type, Integer) def test_type_propagate_standalone_fk_col(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True)) + a = Table("a", metadata, Column("key1", Integer, primary_key=True)) - b = Table('b', metadata, - Column('a_key1', None, ForeignKey(a.c.key1)), - ) + b = Table("b", metadata, Column("a_key1", None, ForeignKey(a.c.key1))) assert isinstance(b.c.a_key1.type, Integer) def test_type_propagate_chained_string_source_first(self): metadata = MetaData() - 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")), - ) + b = Table("b", metadata, Column("a_key1", None, ForeignKey("a.key1"))) - c = Table('c', metadata, - Column('b_key1', None, ForeignKey("b.a_key1")), - ) + c = Table( + "c", metadata, Column("b_key1", None, ForeignKey("b.a_key1")) + ) assert isinstance(b.c.a_key1.type, Integer) assert isinstance(c.c.b_key1.type, Integer) @@ -2692,17 +2859,13 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_chained_string_source_last(self): metadata = MetaData() - b = Table('b', metadata, - Column('a_key1', None, ForeignKey("a.key1")), - ) + b = Table("b", metadata, Column("a_key1", None, ForeignKey("a.key1"))) - c = Table('c', metadata, - Column('b_key1', None, ForeignKey("b.a_key1")), - ) + c = Table( + "c", metadata, Column("b_key1", None, ForeignKey("b.a_key1")) + ) - 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) @@ -2710,21 +2873,31 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_chained_string_source_last_onname(self): metadata = MetaData() - b = Table('b', metadata, - Column( - 'a_key1', None, - ForeignKey("a.key1", link_to_name=True), key="ak1"), - ) + b = Table( + "b", + metadata, + Column( + "a_key1", + None, + ForeignKey("a.key1", link_to_name=True), + key="ak1", + ), + ) - c = Table('c', metadata, - Column( - 'b_key1', None, - ForeignKey("b.a_key1", link_to_name=True), key="bk1"), - ) + c = Table( + "c", + metadata, + Column( + "b_key1", + None, + ForeignKey("b.a_key1", link_to_name=True), + key="bk1", + ), + ) Table( - 'a', metadata, - Column('key1', Integer, primary_key=True, key='ak1')) + "a", metadata, Column("key1", Integer, primary_key=True, key="ak1") + ) assert isinstance(b.c.ak1.type, Integer) assert isinstance(c.c.bk1.type, Integer) @@ -2732,34 +2905,41 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_chained_string_source_last_onname_conflict(self): metadata = MetaData() - b = Table('b', metadata, - # b.c.key1 -> a.c.key1 -> String - Column( - 'ak1', None, - ForeignKey("a.key1", link_to_name=False), key="key1"), - # b.c.ak1 -> a.c.ak1 -> Integer - Column( - 'a_key1', None, - ForeignKey("a.key1", link_to_name=True), key="ak1"), - ) - - c = Table('c', metadata, - # c.c.b_key1 -> b.c.ak1 -> Integer - Column( - 'b_key1', None, - ForeignKey("b.ak1", link_to_name=False)), - # c.c.b_ak1 -> b.c.ak1 - Column( - 'b_ak1', None, - ForeignKey("b.ak1", link_to_name=True)), - ) + b = Table( + "b", + metadata, + # b.c.key1 -> a.c.key1 -> String + Column( + "ak1", + None, + ForeignKey("a.key1", link_to_name=False), + key="key1", + ), + # b.c.ak1 -> a.c.ak1 -> Integer + Column( + "a_key1", + None, + ForeignKey("a.key1", link_to_name=True), + key="ak1", + ), + ) + + c = Table( + "c", + metadata, + # c.c.b_key1 -> b.c.ak1 -> Integer + Column("b_key1", None, ForeignKey("b.ak1", link_to_name=False)), + # c.c.b_ak1 -> b.c.ak1 + Column("b_ak1", None, ForeignKey("b.ak1", link_to_name=True)), + ) Table( - 'a', metadata, + "a", + metadata, # a.c.key1 - Column('ak1', String, key="key1"), + Column("ak1", String, key="key1"), # a.c.ak1 - Column('key1', Integer, primary_key=True, key='ak1'), + Column("key1", Integer, primary_key=True, key="ak1"), ) assert isinstance(b.c.key1.type, String) @@ -2770,30 +2950,26 @@ class ConstraintTest(fixtures.TestBase): def test_type_propagate_chained_col_orig_first(self): metadata = MetaData() - a = Table('a', metadata, - Column('key1', Integer, primary_key=True)) + a = Table("a", metadata, Column("key1", Integer, primary_key=True)) - b = Table('b', metadata, - Column('a_key1', None, ForeignKey(a.c.key1)), - ) + b = Table("b", metadata, Column("a_key1", None, ForeignKey(a.c.key1))) - c = Table('c', metadata, - Column('b_key1', None, ForeignKey(b.c.a_key1)), - ) + c = Table( + "c", metadata, Column("b_key1", None, ForeignKey(b.c.a_key1)) + ) assert isinstance(b.c.a_key1.type, Integer) assert isinstance(c.c.b_key1.type, Integer) def test_column_accessor_col(self): - c1 = Column('x', Integer) + c1 = Column("x", Integer) fk = ForeignKey(c1) is_(fk.column, c1) def test_column_accessor_clause_element(self): - c1 = Column('x', Integer) + c1 = Column("x", Integer) class CThing(object): - def __init__(self, c): self.c = c @@ -2809,50 +2985,58 @@ class ConstraintTest(fixtures.TestBase): exc.InvalidRequestError, "this ForeignKey object does not yet have a parent " "Column associated with it.", - getattr, fk, "column" + getattr, + fk, + "column", ) def test_column_accessor_string_no_parent_table(self): fk = ForeignKey("sometable.somecol") - Column('x', fk) + Column("x", fk) assert_raises_message( exc.InvalidRequestError, "this ForeignKey's parent column is not yet " "associated with a Table.", - getattr, fk, "column" + getattr, + fk, + "column", ) def test_column_accessor_string_no_target_table(self): fk = ForeignKey("sometable.somecol") - c1 = Column('x', fk) - Table('t', MetaData(), c1) + c1 = Column("x", fk) + Table("t", MetaData(), c1) assert_raises_message( exc.NoReferencedTableError, "Foreign key associated with column 't.x' could not find " "table 'sometable' with which to generate a " "foreign key to target column 'somecol'", - getattr, fk, "column" + getattr, + fk, + "column", ) def test_column_accessor_string_no_target_column(self): fk = ForeignKey("sometable.somecol") - c1 = Column('x', fk) + c1 = Column("x", fk) m = MetaData() - Table('t', m, c1) - 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 " "'sometable.somecol' on table 't': " "table 'sometable' has no column named 'somecol'", - getattr, fk, "column" + getattr, + fk, + "column", ) def test_remove_table_fk_bookkeeping(self): metadata = MetaData() - fk = ForeignKey('t1.x') - t2 = Table('t2', metadata, Column('y', Integer, fk)) - t3 = Table('t3', metadata, Column('y', Integer, ForeignKey('t1.x'))) + fk = ForeignKey("t1.x") + t2 = Table("t2", metadata, Column("y", Integer, fk)) + t3 = Table("t3", metadata, Column("y", Integer, ForeignKey("t1.x"))) assert t2.key in metadata.tables assert ("t1", "x") in metadata._fk_memos @@ -2869,13 +3053,15 @@ class ConstraintTest(fixtures.TestBase): assert fk not in metadata._fk_memos[("t1", "x")] # make the referenced table - t1 = Table('t1', metadata, Column('x', Integer)) + t1 = Table("t1", metadata, Column("x", Integer)) # t2 tells us exactly what's wrong assert_raises_message( exc.InvalidRequestError, "Table t2 is no longer associated with its parent MetaData", - getattr, fk, "column" + getattr, + fk, + "column", ) # t3 is unaffected @@ -2885,63 +3071,51 @@ class ConstraintTest(fixtures.TestBase): metadata.remove(t2) def test_double_fk_usage_raises(self): - f = ForeignKey('b.id') + f = ForeignKey("b.id") - Column('x', Integer, f) + Column("x", Integer, f) assert_raises(exc.InvalidRequestError, Column, "y", Integer, f) def test_auto_append_constraint(self): m = MetaData() - t = Table('tbl', m, - Column('a', Integer), - Column('b', Integer) - ) + t = Table("tbl", m, Column("a", Integer), Column("b", Integer)) - t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + t2 = Table("t2", m, Column("a", Integer), Column("b", Integer)) for c in ( UniqueConstraint(t.c.a), CheckConstraint(t.c.a > 5), ForeignKeyConstraint([t.c.a], [t2.c.a]), - PrimaryKeyConstraint(t.c.a) + PrimaryKeyConstraint(t.c.a), ): assert c in t.constraints t.append_constraint(c) assert c in t.constraints - c = Index('foo', t.c.a) + c = Index("foo", t.c.a) assert c in t.indexes def test_auto_append_lowercase_table(self): from sqlalchemy import table, column - t = table('t', column('a')) - t2 = table('t2', column('a')) + t = table("t", column("a")) + t2 = table("t2", column("a")) for c in ( UniqueConstraint(t.c.a), CheckConstraint(t.c.a > 5), ForeignKeyConstraint([t.c.a], [t2.c.a]), PrimaryKeyConstraint(t.c.a), - Index('foo', t.c.a) + Index("foo", t.c.a), ): assert True def test_tometadata_ok(self): m = MetaData() - t = Table('tbl', m, - Column('a', Integer), - Column('b', Integer) - ) + t = Table("tbl", m, Column("a", Integer), Column("b", Integer)) - t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + t2 = Table("t2", m, Column("a", Integer), Column("b", Integer)) UniqueConstraint(t.c.a) CheckConstraint(t.c.a > 5) @@ -2959,10 +3133,7 @@ class ConstraintTest(fixtures.TestBase): def test_check_constraint_copy(self): m = MetaData() - t = Table('tbl', m, - Column('a', Integer), - Column('b', Integer) - ) + t = Table("tbl", m, Column("a", Integer), Column("b", Integer)) ck = CheckConstraint(t.c.a > 5) ck2 = ck.copy() assert ck in t.constraints @@ -2971,15 +3142,9 @@ class ConstraintTest(fixtures.TestBase): def test_ambig_check_constraint_auto_append(self): m = MetaData() - t = Table('tbl', m, - Column('a', Integer), - Column('b', Integer) - ) + t = Table("tbl", m, Column("a", Integer), Column("b", Integer)) - t2 = Table('t2', m, - Column('a', Integer), - Column('b', Integer) - ) + t2 = Table("t2", m, 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 @@ -2987,22 +3152,22 @@ class ConstraintTest(fixtures.TestBase): def test_auto_append_ck_on_col_attach_one(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) + a = Column("a", Integer) + b = Column("b", Integer) ck = CheckConstraint(a > b) - t = Table('tbl', m, a, b) + t = Table("tbl", m, a, b) assert ck in t.constraints def test_auto_append_ck_on_col_attach_two(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) ck = CheckConstraint(a > b + c) - t = Table('tbl', m, a) + t = Table("tbl", m, a) assert ck not in t.constraints t.append_column(b) @@ -3014,18 +3179,18 @@ class ConstraintTest(fixtures.TestBase): def test_auto_append_ck_on_col_attach_three(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) ck = CheckConstraint(a > b + c) - t = Table('tbl', m, a) + t = Table("tbl", m, a) assert ck not in t.constraints t.append_column(b) assert ck not in t.constraints - t2 = Table('t2', m) + t2 = Table("t2", m) t2.append_column(c) # two different tables, so CheckConstraint does nothing. @@ -3034,22 +3199,22 @@ class ConstraintTest(fixtures.TestBase): def test_auto_append_uq_on_col_attach_one(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) + a = Column("a", Integer) + b = Column("b", Integer) uq = UniqueConstraint(a, b) - t = Table('tbl', m, a, b) + t = Table("tbl", m, a, b) assert uq in t.constraints def test_auto_append_uq_on_col_attach_two(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) uq = UniqueConstraint(a, b, c) - t = Table('tbl', m, a) + t = Table("tbl", m, a) assert uq not in t.constraints t.append_column(b) @@ -3061,24 +3226,25 @@ class ConstraintTest(fixtures.TestBase): def test_auto_append_uq_on_col_attach_three(self): m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) uq = UniqueConstraint(a, b, c) - t = Table('tbl', m, a) + t = Table("tbl", m, a) assert uq not in t.constraints t.append_column(b) assert uq not in t.constraints - t2 = Table('t2', m) + t2 = Table("t2", m) # two different tables, so UniqueConstraint raises assert_raises_message( exc.ArgumentError, r"Column\(s\) 't2\.c' are not part of table 'tbl'\.", - t2.append_column, c + t2.append_column, + c, ) def test_auto_append_uq_on_col_attach_four(self): @@ -3088,12 +3254,12 @@ class ConstraintTest(fixtures.TestBase): """ m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) - uq = UniqueConstraint(a, 'b', 'c') + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) + uq = UniqueConstraint(a, "b", "c") - t = Table('tbl', m, a) + t = Table("tbl", m, a) assert uq not in t.constraints t.append_column(b) @@ -3111,7 +3277,7 @@ class ConstraintTest(fixtures.TestBase): eq_( [cn for cn in t.constraints if isinstance(cn, UniqueConstraint)], - [uq] + [uq], ) def test_auto_append_uq_on_col_attach_five(self): @@ -3121,13 +3287,13 @@ class ConstraintTest(fixtures.TestBase): """ m = MetaData() - a = Column('a', Integer) - b = Column('b', Integer) - c = Column('c', Integer) + a = Column("a", Integer) + b = Column("b", Integer) + c = Column("c", Integer) - t = Table('tbl', m, a, c, b) + t = Table("tbl", m, a, c, b) - uq = UniqueConstraint(a, 'b', 'c') + uq = UniqueConstraint(a, "b", "c") assert uq in t.constraints @@ -3137,38 +3303,36 @@ class ConstraintTest(fixtures.TestBase): eq_( [cn for cn in t.constraints if isinstance(cn, UniqueConstraint)], - [uq] + [uq], ) def test_index_asserts_cols_standalone(self): metadata = MetaData() - t1 = Table('t1', metadata, - Column('x', Integer) - ) - t2 = Table('t2', metadata, - Column('y', Integer) - ) + t1 = Table("t1", metadata, Column("x", Integer)) + t2 = Table("t2", metadata, Column("y", Integer)) assert_raises_message( exc.ArgumentError, r"Column\(s\) 't2.y' are not part of table 't1'.", Index, - "bar", t1.c.x, t2.c.y + "bar", + t1.c.x, + t2.c.y, ) def test_index_asserts_cols_inline(self): metadata = MetaData() - t1 = Table('t1', metadata, - Column('x', Integer) - ) + t1 = Table("t1", metadata, 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) + Table, + "t2", + metadata, + Column("y", Integer), + Index("bar", t1.c.x), ) def test_raise_index_nonexistent_name(self): @@ -3176,28 +3340,25 @@ class ConstraintTest(fixtures.TestBase): # the KeyError isn't ideal here, a nicer message # perhaps assert_raises( - KeyError, - Table, 't', m, Column('x', Integer), Index("foo", "q") + KeyError, Table, "t", m, Column("x", Integer), Index("foo", "q") ) def test_raise_not_a_column(self): - assert_raises( - exc.ArgumentError, - Index, "foo", 5 - ) + assert_raises(exc.ArgumentError, Index, "foo", 5) def test_raise_expr_no_column(self): - idx = Index('foo', func.lower(5)) + idx = Index("foo", func.lower(5)) assert_raises_message( exc.CompileError, "Index 'foo' is not associated with any table.", - schema.CreateIndex(idx).compile, dialect=testing.db.dialect + schema.CreateIndex(idx).compile, + dialect=testing.db.dialect, ) assert_raises_message( exc.CompileError, "Index 'foo' is not associated with any table.", - schema.CreateIndex(idx).compile + schema.CreateIndex(idx).compile, ) def test_no_warning_w_no_columns(self): @@ -3206,26 +3367,29 @@ class ConstraintTest(fixtures.TestBase): assert_raises_message( exc.CompileError, "Index 'foo' is not associated with any table.", - schema.CreateIndex(idx).compile, dialect=testing.db.dialect + schema.CreateIndex(idx).compile, + dialect=testing.db.dialect, ) assert_raises_message( exc.CompileError, "Index 'foo' is not associated with any table.", - schema.CreateIndex(idx).compile + schema.CreateIndex(idx).compile, ) def test_raise_clauseelement_not_a_column(self): m = MetaData() - t2 = Table('t2', m, Column('x', Integer)) + t2 = Table("t2", m, Column("x", Integer)) class SomeClass(object): - def __clause_element__(self): return t2 + assert_raises_message( exc.ArgumentError, r"Element Table\('t2', .* is not a string name or column element", - Index, "foo", SomeClass() + Index, + "foo", + SomeClass(), ) @@ -3233,28 +3397,30 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): """Test Column() construction.""" - __dialect__ = 'default' + __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())] + 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()), + ] def test_basic(self): c = self.columns() - for i, v in ((0, 'a'), (2, 'c'), (5, 'f'), (6, 'g'), (8, 'i')): + for i, v in ((0, "a"), (2, "c"), (5, "f"), (6, "g"), (8, "i")): c[i].name = v c[i].key = v del i, v - tbl = Table('table', MetaData(), *c) + tbl = Table("table", MetaData(), *c) for i, col in enumerate(tbl.c): assert col.name == c[i].name @@ -3266,35 +3432,47 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): exc.ArgumentError, "Column must be constructed with a non-blank name or assign a " "non-blank .name ", - Table, 't', MetaData(), c) + Table, + "t", + MetaData(), + c, + ) def test_name_blank(self): - c = Column('', Integer) + c = Column("", Integer) assert_raises_message( exc.ArgumentError, "Column must be constructed with a non-blank name or assign a " "non-blank .name ", - Table, 't', MetaData(), c) + Table, + "t", + MetaData(), + c, + ) def test_dupe_column(self): - c = Column('x', Integer) - Table('t', MetaData(), c) + c = Column("x", Integer) + Table("t", MetaData(), c) assert_raises_message( exc.ArgumentError, "Column object 'x' already assigned to Table 't'", - Table, 'q', MetaData(), c) + Table, + "q", + MetaData(), + c, + ) def test_incomplete_key(self): c = Column(Integer) assert c.name is None assert c.key is None - c.name = 'named' - Table('t', MetaData(), c) + c.name = "named" + Table("t", MetaData(), c) - assert c.name == 'named' + assert c.name == "named" assert c.name == c.key def test_unique_index_flags_default_to_none(self): @@ -3302,28 +3480,29 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): eq_(c.unique, None) eq_(c.index, None) - c = Column('c', Integer, index=True) + c = Column("c", Integer, index=True) eq_(c.unique, None) eq_(c.index, True) - t = Table('t', MetaData(), c) + t = Table("t", MetaData(), c) eq_(list(t.indexes)[0].unique, False) c = Column(Integer, unique=True) eq_(c.unique, True) eq_(c.index, None) - c = Column('c', Integer, index=True, unique=True) + c = Column("c", Integer, index=True, unique=True) eq_(c.unique, True) eq_(c.index, True) - t = Table('t', MetaData(), c) + t = Table("t", MetaData(), c) eq_(list(t.indexes)[0].unique, True) def test_bogus(self): - assert_raises(exc.ArgumentError, Column, 'foo', name='bar') - assert_raises(exc.ArgumentError, Column, 'foo', Integer, - type_=Integer()) + assert_raises(exc.ArgumentError, Column, "foo", name="bar") + assert_raises( + exc.ArgumentError, Column, "foo", Integer, type_=Integer() + ) def test_custom_subclass_proxy(self): """test proxy generation of a Column subclass, can be compiled.""" @@ -3333,9 +3512,8 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): from sqlalchemy.sql import select class MyColumn(Column): - def _constructor(self, name, type, **kw): - kw['name'] = name + kw["name"] = name return MyColumn(type, **kw) def __init__(self, type, **kw): @@ -3350,13 +3528,10 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): return s + "-" id = MyColumn(Integer, primary_key=True) - id.name = 'id' + id.name = "id" name = MyColumn(String) - name.name = 'name' - t1 = Table('foo', MetaData(), - id, - name - ) + name.name = "name" + t1 = Table("foo", MetaData(), id, name) # goofy thing eq_(t1.c.name.my_goofy_thing(), "hi") @@ -3380,24 +3555,22 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): from sqlalchemy.sql import select class MyColumn(Column): - def __init__(self, type, **kw): Column.__init__(self, type, **kw) id = MyColumn(Integer, primary_key=True) - id.name = 'id' + id.name = "id" name = MyColumn(String) - name.name = 'name' - t1 = Table('foo', MetaData(), - id, - name - ) + name.name = "name" + t1 = Table("foo", MetaData(), id, name) assert_raises_message( TypeError, "Could not create a copy of this <class " "'test.sql.test_metadata..*MyColumn'> " "object. Ensure the class includes a _constructor()", - getattr, select([t1.select().alias()]), 'c' + getattr, + select([t1.select().alias()]), + "c", ) def test_custom_create(self): @@ -3412,7 +3585,7 @@ class ColumnDefinitionTest(AssertsCompiledSQL, fixtures.TestBase): text = "%s SPECIAL DIRECTIVE %s" % ( column.name, - compiler.type_compiler.process(column.type) + compiler.type_compiler.process(column.type), ) default = compiler.get_column_default_string(column) if default is not None: @@ -3423,23 +3596,23 @@ 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})) + "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))" + "z SPECIAL DIRECTIVE VARCHAR(20), PRIMARY KEY (x))", ) deregister(schema.CreateColumn) @@ -3450,127 +3623,126 @@ class ColumnDefaultsTest(fixtures.TestBase): """test assignment of default fixures to columns""" def _fixture(self, *arg, **kw): - return Column('x', Integer, *arg, **kw) + return Column("x", Integer, *arg, **kw) def test_server_default_positional(self): - target = schema.DefaultClause('y') + target = schema.DefaultClause("y") c = self._fixture(target) assert c.server_default is target assert target.column is c def test_onupdate_default_not_server_default_one(self): - target1 = schema.DefaultClause('y') - target2 = schema.DefaultClause('z') + target1 = schema.DefaultClause("y") + target2 = schema.DefaultClause("z") c = self._fixture(server_default=target1, server_onupdate=target2) - eq_(c.server_default.arg, 'y') - eq_(c.server_onupdate.arg, 'z') + eq_(c.server_default.arg, "y") + eq_(c.server_onupdate.arg, "z") def test_onupdate_default_not_server_default_two(self): - target1 = schema.DefaultClause('y', for_update=True) - target2 = schema.DefaultClause('z', for_update=True) + target1 = schema.DefaultClause("y", for_update=True) + target2 = schema.DefaultClause("z", for_update=True) c = self._fixture(server_default=target1, server_onupdate=target2) - eq_(c.server_default.arg, 'y') - eq_(c.server_onupdate.arg, 'z') + eq_(c.server_default.arg, "y") + eq_(c.server_onupdate.arg, "z") def test_onupdate_default_not_server_default_three(self): - target1 = schema.DefaultClause('y', for_update=False) - target2 = schema.DefaultClause('z', for_update=True) + target1 = schema.DefaultClause("y", for_update=False) + target2 = schema.DefaultClause("z", for_update=True) c = self._fixture(target1, target2) - eq_(c.server_default.arg, 'y') - eq_(c.server_onupdate.arg, 'z') + eq_(c.server_default.arg, "y") + eq_(c.server_onupdate.arg, "z") def test_onupdate_default_not_server_default_four(self): - target1 = schema.DefaultClause('y', for_update=False) + target1 = schema.DefaultClause("y", for_update=False) c = self._fixture(server_onupdate=target1) is_(c.server_default, None) - eq_(c.server_onupdate.arg, 'y') + eq_(c.server_onupdate.arg, "y") def test_server_default_keyword_as_schemaitem(self): - target = schema.DefaultClause('y') + target = schema.DefaultClause("y") c = self._fixture(server_default=target) assert c.server_default is target assert target.column is c def test_server_default_keyword_as_clause(self): - target = 'y' + target = "y" c = self._fixture(server_default=target) assert c.server_default.arg == target assert c.server_default.column is c def test_server_default_onupdate_positional(self): - target = schema.DefaultClause('y', for_update=True) + target = schema.DefaultClause("y", for_update=True) c = self._fixture(target) assert c.server_onupdate is target assert target.column is c def test_server_default_onupdate_keyword_as_schemaitem(self): - target = schema.DefaultClause('y', for_update=True) + target = schema.DefaultClause("y", for_update=True) c = self._fixture(server_onupdate=target) assert c.server_onupdate is target assert target.column is c def test_server_default_onupdate_keyword_as_clause(self): - target = 'y' + target = "y" c = self._fixture(server_onupdate=target) assert c.server_onupdate.arg == target assert c.server_onupdate.column is c def test_column_default_positional(self): - target = schema.ColumnDefault('y') + target = schema.ColumnDefault("y") c = self._fixture(target) assert c.default is target assert target.column is c def test_column_default_keyword_as_schemaitem(self): - target = schema.ColumnDefault('y') + target = schema.ColumnDefault("y") c = self._fixture(default=target) assert c.default is target assert target.column is c def test_column_default_keyword_as_clause(self): - target = 'y' + target = "y" c = self._fixture(default=target) assert c.default.arg == target assert c.default.column is c def test_column_default_onupdate_positional(self): - target = schema.ColumnDefault('y', for_update=True) + target = schema.ColumnDefault("y", for_update=True) c = self._fixture(target) assert c.onupdate is target assert target.column is c def test_column_default_onupdate_keyword_as_schemaitem(self): - target = schema.ColumnDefault('y', for_update=True) + target = schema.ColumnDefault("y", for_update=True) c = self._fixture(onupdate=target) assert c.onupdate is target assert target.column is c def test_column_default_onupdate_keyword_as_clause(self): - target = 'y' + target = "y" c = self._fixture(onupdate=target) assert c.onupdate.arg == target assert c.onupdate.column is c class ColumnOptionsTest(fixtures.TestBase): - def test_default_generators(self): - g1, g2 = Sequence('foo_id_seq'), ColumnDefault('f5') + g1, g2 = Sequence("foo_id_seq"), ColumnDefault("f5") assert Column(String, default=g1).default is g1 assert Column(String, onupdate=g1).onupdate is g1 assert Column(String, default=g2).default is g2 assert Column(String, onupdate=g2).onupdate is g2 def _null_type_error(self, col): - t = Table('t', MetaData(), col) + t = Table("t", MetaData(), col) assert_raises_message( exc.CompileError, r"\(in table 't', column 'foo'\): Can't generate DDL for NullType", - schema.CreateTable(t).compile + schema.CreateTable(t).compile, ) def _no_name_error(self, col): @@ -3578,13 +3750,16 @@ class ColumnOptionsTest(fixtures.TestBase): exc.ArgumentError, "Column must be constructed with a non-blank name or " "assign a non-blank .name", - Table, 't', MetaData(), col + Table, + "t", + MetaData(), + col, ) def _no_error(self, col): m = MetaData() - b = Table('bar', m, Column('id', Integer)) - t = Table('t', m, col) + b = Table("bar", m, Column("id", Integer)) + t = Table("t", m, col) schema.CreateTable(t).compile() def test_argument_signatures(self): @@ -3597,71 +3772,82 @@ class ColumnOptionsTest(fixtures.TestBase): self._null_type_error(Column("foo", Sequence("a"))) - self._no_name_error(Column(ForeignKey('bar.id'))) + self._no_name_error(Column(ForeignKey("bar.id"))) - self._no_error(Column("foo", ForeignKey('bar.id'))) + self._no_error(Column("foo", ForeignKey("bar.id"))) - self._no_name_error(Column(ForeignKey('bar.id'), default="foo")) + self._no_name_error(Column(ForeignKey("bar.id"), default="foo")) - self._no_name_error(Column(ForeignKey('bar.id'), Sequence("a"))) - self._no_error(Column("foo", ForeignKey('bar.id'), default="foo")) - self._no_error(Column("foo", ForeignKey('bar.id'), Sequence("a"))) + self._no_name_error(Column(ForeignKey("bar.id"), Sequence("a"))) + 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'}) - c2 = Column('bar', String, info={}) - c3 = Column('bat', String) - assert c1.info == {'x': 'y'} + c1 = Column("foo", String, info={"x": "y"}) + c2 = Column("bar", String, info={}) + c3 = Column("bat", String) + assert c1.info == {"x": "y"} assert c2.info == {} assert c3.info == {} for c in (c1, c2, c3): - c.info['bar'] = 'zip' - assert c.info['bar'] == 'zip' + 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__)) + canary.append( + "%s->%s" % (obj.__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) + schema.SchemaItem, "before_parent_attach", before_attach + ) self.event_listen( - schema.SchemaItem, - "after_parent_attach", - after_attach) + 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')) - ) - Table('t2', m, - Column('id', Integer, primary_key=True), - ) + Table( + "t1", + m, + Column("id", Integer, Sequence("foo_id"), primary_key=True), + Column("bar", String, ForeignKey("t2.id")), + ) + Table("t2", m, Column("id", Integer, primary_key=True)) eq_( canary, - ['Sequence->Column', 'Sequence->id', 'ForeignKey->Column', - 'ForeignKey->bar', 'Table->MetaData', - 'PrimaryKeyConstraint->Table', 'PrimaryKeyConstraint->t1', - 'Column->Table', 'Column->t1', 'Column->Table', - 'Column->t1', 'ForeignKeyConstraint->Table', - 'ForeignKeyConstraint->t1', 'Table->MetaData(bind=None)', - 'Table->MetaData', 'PrimaryKeyConstraint->Table', - 'PrimaryKeyConstraint->t2', 'Column->Table', 'Column->t2', - 'Table->MetaData(bind=None)'] + [ + "Sequence->Column", + "Sequence->id", + "ForeignKey->Column", + "ForeignKey->bar", + "Table->MetaData", + "PrimaryKeyConstraint->Table", + "PrimaryKeyConstraint->t1", + "Column->Table", + "Column->t1", + "Column->Table", + "Column->t1", + "ForeignKeyConstraint->Table", + "ForeignKeyConstraint->t1", + "Table->MetaData(bind=None)", + "Table->MetaData", + "PrimaryKeyConstraint->Table", + "PrimaryKeyConstraint->t2", + "Column->Table", + "Column->t2", + "Table->MetaData(bind=None)", + ], ) def test_events_per_constraint(self): @@ -3669,80 +3855,82 @@ class CatchAllEventsTest(fixtures.RemovesEvents, fixtures.TestBase): def evt(target): def before_attach(obj, parent): - canary.append("%s->%s" % (target.__name__, - parent.__class__.__name__)) + canary.append( + "%s->%s" % (target.__name__, parent.__class__.__name__) + ) def after_attach(obj, parent): - assert hasattr(obj, 'name') # so we can change it + assert hasattr(obj, "name") # so we can change it canary.append("%s->%s" % (target.__name__, parent)) + self.event_listen(target, "before_parent_attach", before_attach) self.event_listen(target, "after_parent_attach", after_attach) for target in [ - schema.ForeignKeyConstraint, schema.PrimaryKeyConstraint, + schema.ForeignKeyConstraint, + schema.PrimaryKeyConstraint, schema.UniqueConstraint, schema.CheckConstraint, - schema.Index + schema.Index, ]: evt(target) 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), - ) - 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') - ) + 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), + ) + 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"), + ) eq_( canary, [ - 'PrimaryKeyConstraint->Table', 'PrimaryKeyConstraint->t1', - 'Index->Table', 'Index->t1', - 'ForeignKeyConstraint->Table', 'ForeignKeyConstraint->t1', - 'UniqueConstraint->Table', 'UniqueConstraint->t1', - 'PrimaryKeyConstraint->Table', 'PrimaryKeyConstraint->t2', - 'CheckConstraint->Table', 'CheckConstraint->t2', - 'UniqueConstraint->Table', 'UniqueConstraint->t2', - 'Index->Table', 'Index->t2' - ] + "PrimaryKeyConstraint->Table", + "PrimaryKeyConstraint->t1", + "Index->Table", + "Index->t1", + "ForeignKeyConstraint->Table", + "ForeignKeyConstraint->t1", + "UniqueConstraint->Table", + "UniqueConstraint->t1", + "PrimaryKeyConstraint->Table", + "PrimaryKeyConstraint->t2", + "CheckConstraint->Table", + "CheckConstraint->t2", + "UniqueConstraint->Table", + "UniqueConstraint->t2", + "Index->Table", + "Index->t2", + ], ) class DialectKWArgTest(fixtures.TestBase): - @contextmanager def _fixture(self): from sqlalchemy.engine.default import DefaultDialect class ParticipatingDialect(DefaultDialect): construct_arguments = [ - (schema.Index, { - "x": 5, - "y": False, - "z_one": None - }), - (schema.ForeignKeyConstraint, { - "foobar": False - }) + (schema.Index, {"x": 5, "y": False, "z_one": None}), + (schema.ForeignKeyConstraint, {"foobar": False}), ] class ParticipatingDialect2(DefaultDialect): construct_arguments = [ - (schema.Index, { - "x": 9, - "y": True, - "pp": "default" - }), - (schema.Table, { - "*": None - }) + (schema.Index, {"x": 9, "y": True, "pp": "default"}), + (schema.Table, {"*": None}), ] class NonParticipatingDialect(DefaultDialect): @@ -3757,6 +3945,7 @@ class DialectKWArgTest(fixtures.TestBase): return NonParticipatingDialect else: raise exc.NoSuchModuleError("no dialect %r" % dialect_name) + with mock.patch("sqlalchemy.dialects.registry.load", load): yield @@ -3765,32 +3954,21 @@ class DialectKWArgTest(fixtures.TestBase): def test_participating(self): with self._fixture(): - idx = Index('a', 'b', 'c', participating_y=True) + idx = Index("a", "b", "c", participating_y=True) eq_( idx.dialect_options, - {"participating": {"x": 5, "y": True, "z_one": None}} - ) - eq_( - idx.dialect_kwargs, - { - 'participating_y': True, - } + {"participating": {"x": 5, "y": True, "z_one": None}}, ) + eq_(idx.dialect_kwargs, {"participating_y": True}) def test_nonparticipating(self): with self._fixture(): idx = Index( - 'a', - 'b', - 'c', - nonparticipating_y=True, - nonparticipating_q=5) + "a", "b", "c", nonparticipating_y=True, nonparticipating_q=5 + ) eq_( idx.dialect_kwargs, - { - 'nonparticipating_y': True, - 'nonparticipating_q': 5 - } + {"nonparticipating_y": True, "nonparticipating_q": 5}, ) def test_bad_kwarg_raise(self): @@ -3799,7 +3977,11 @@ class DialectKWArgTest(fixtures.TestBase): TypeError, "Additional arguments should be named " "<dialectname>_<argument>, got 'foobar'", - Index, 'a', 'b', 'c', foobar=True + Index, + "a", + "b", + "c", + foobar=True, ) def test_unknown_dialect_warning(self): @@ -3808,7 +3990,11 @@ class DialectKWArgTest(fixtures.TestBase): exc.SAWarning, "Can't validate argument 'unknown_y'; can't locate " "any SQLAlchemy dialect named 'unknown'", - Index, 'a', 'b', 'c', unknown_y=True + Index, + "a", + "b", + "c", + unknown_y=True, ) def test_participating_bad_kw(self): @@ -3818,7 +4004,11 @@ class DialectKWArgTest(fixtures.TestBase): "Argument 'participating_q_p_x' is not accepted by dialect " "'participating' on behalf of " "<class 'sqlalchemy.sql.schema.Index'>", - Index, 'a', 'b', 'c', participating_q_p_x=8 + Index, + "a", + "b", + "c", + participating_q_p_x=8, ) def test_participating_unknown_schema_item(self): @@ -3830,310 +4020,328 @@ class DialectKWArgTest(fixtures.TestBase): "Argument 'participating_q_p_x' is not accepted by dialect " "'participating' on behalf of " "<class 'sqlalchemy.sql.schema.UniqueConstraint'>", - UniqueConstraint, 'a', 'b', participating_q_p_x=8 + UniqueConstraint, + "a", + "b", + participating_q_p_x=8, ) @testing.emits_warning("Can't validate") def test_unknown_dialect_warning_still_populates(self): with self._fixture(): - idx = Index('a', 'b', 'c', unknown_y=True) + idx = Index("a", "b", "c", unknown_y=True) eq_(idx.dialect_kwargs, {"unknown_y": True}) # still populates @testing.emits_warning("Can't validate") 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) + idx = Index( + "a", + "b", + "c", + unknown_y=True, + unknown_z=5, + otherunknown_foo="bar", + participating_y=8, + ) eq_( idx.dialect_options, { - "unknown": {'y': True, 'z': 5, '*': None}, - "otherunknown": {'foo': 'bar', '*': None}, - "participating": {'x': 5, 'y': 8, 'z_one': None} - } + "unknown": {"y": True, "z": 5, "*": None}, + "otherunknown": {"foo": "bar", "*": None}, + "participating": {"x": 5, "y": 8, "z_one": None}, + }, ) - eq_(idx.dialect_kwargs, - {'unknown_z': 5, 'participating_y': 8, - 'unknown_y': True, - 'otherunknown_foo': 'bar'} - ) # still populates + eq_( + idx.dialect_kwargs, + { + "unknown_z": 5, + "participating_y": 8, + "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): + with mock.patch( + "sqlalchemy.util.safe_kwarg", lambda arg: "goofy_%s" % arg + ): with self._fixture(): - idx = Index('a', 'b') - idx.kwargs[util.u('participating_x')] = 7 + idx = Index("a", "b") + idx.kwargs[util.u("participating_x")] = 7 - eq_( - list(idx.dialect_kwargs), - ['goofy_participating_x'] - ) + eq_(list(idx.dialect_kwargs), ["goofy_participating_x"]) def test_combined(self): with self._fixture(): - idx = Index('a', 'b', 'c', participating_x=7, - nonparticipating_y=True) + idx = Index( + "a", "b", "c", participating_x=7, nonparticipating_y=True + ) eq_( idx.dialect_options, { - 'participating': {'y': False, 'x': 7, 'z_one': None}, - 'nonparticipating': {'y': True, '*': None} - } + "participating": {"y": False, "x": 7, "z_one": None}, + "nonparticipating": {"y": True, "*": None}, + }, ) eq_( idx.dialect_kwargs, - { - 'participating_x': 7, - 'nonparticipating_y': True, - } + {"participating_x": 7, "nonparticipating_y": True}, ) def test_multiple_participating(self): with self._fixture(): - idx = Index('a', 'b', 'c', - participating_x=7, - participating2_x=15, - participating2_y="lazy" - ) + idx = Index( + "a", + "b", + "c", + participating_x=7, + participating2_x=15, + participating2_y="lazy", + ) eq_( idx.dialect_options, { - "participating": {'x': 7, 'y': False, 'z_one': None}, - "participating2": {'x': 15, 'y': 'lazy', 'pp': 'default'}, - } + "participating": {"x": 7, "y": False, "z_one": None}, + "participating2": {"x": 15, "y": "lazy", "pp": "default"}, + }, ) eq_( idx.dialect_kwargs, { - 'participating_x': 7, - 'participating2_x': 15, - 'participating2_y': 'lazy' - } + "participating_x": 7, + "participating2_x": 15, + "participating2_y": "lazy", + }, ) def test_foreign_key_propagate(self): with self._fixture(): m = MetaData() - fk = ForeignKey('t2.id', participating_foobar=True) - t = Table('t', m, Column('id', Integer, fk)) + 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] - eq_( - fkc.dialect_kwargs, - {'participating_foobar': True} - ) + c for c in t.constraints if isinstance(c, ForeignKeyConstraint) + ][0] + eq_(fkc.dialect_kwargs, {"participating_foobar": True}) def test_foreign_key_propagate_exceptions_delayed(self): with self._fixture(): m = MetaData() - fk = ForeignKey('t2.id', participating_fake=True) - c1 = Column('id', Integer, fk) + fk = ForeignKey("t2.id", participating_fake=True) + c1 = Column("id", Integer, fk) assert_raises_message( exc.ArgumentError, "Argument 'participating_fake' is not accepted by " "dialect 'participating' on behalf of " "<class 'sqlalchemy.sql.schema.ForeignKeyConstraint'>", - Table, 't', m, c1 + Table, + "t", + m, + c1, ) def test_wildcard(self): with self._fixture(): m = MetaData() - t = Table('x', m, Column('x', Integer), - participating2_xyz='foo', - participating2_engine='InnoDB', - ) + t = Table( + "x", + m, + Column("x", Integer), + participating2_xyz="foo", + participating2_engine="InnoDB", + ) eq_( t.dialect_kwargs, { - 'participating2_xyz': 'foo', - 'participating2_engine': 'InnoDB' - } + "participating2_xyz": "foo", + "participating2_engine": "InnoDB", + }, ) def test_uninit_wildcard(self): with self._fixture(): m = MetaData() - t = Table('x', m, Column('x', Integer)) - eq_( - t.dialect_options['participating2'], {'*': None} - ) - eq_( - t.dialect_kwargs, {} - ) + t = Table("x", m, Column("x", Integer)) + eq_(t.dialect_options["participating2"], {"*": None}) + eq_(t.dialect_kwargs, {}) def test_not_contains_wildcard(self): with self._fixture(): m = MetaData() - t = Table('x', m, Column('x', Integer)) - assert 'foobar' not in t.dialect_options['participating2'] + t = Table("x", m, Column("x", Integer)) + assert "foobar" not in t.dialect_options["participating2"] def test_contains_wildcard(self): with self._fixture(): m = MetaData() - t = Table('x', m, Column('x', Integer), participating2_foobar=5) - assert 'foobar' in t.dialect_options['participating2'] + 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, - }) - idx._validate_dialect_kwargs({ - "participating_x": 25, - "participating_z_one": "default"}) - eq_(idx.dialect_options, { - "participating": {"x": 25, "y": False, "z_one": "default"} - }) - eq_(idx.dialect_kwargs, { - "participating_x": 25, - 'participating_z_one': "default" - }) - - idx._validate_dialect_kwargs({ - "participating_x": 25, - "participating_z_one": "default"}) - - eq_(idx.dialect_options, { - "participating": {"x": 25, "y": False, "z_one": "default"} - }) - eq_(idx.dialect_kwargs, { - "participating_x": 25, - 'participating_z_one': "default" - }) - - idx._validate_dialect_kwargs({ - "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} - }) - eq_(idx.dialect_kwargs, { - "participating_x": 25, - "participating_y": True, - 'participating2_y': "p2y", - "participating_z_one": "default"}) + idx = Index("a", "b", "c", participating_x=20) + eq_(idx.dialect_kwargs, {"participating_x": 20}) + idx._validate_dialect_kwargs( + {"participating_x": 25, "participating_z_one": "default"} + ) + eq_( + idx.dialect_options, + {"participating": {"x": 25, "y": False, "z_one": "default"}}, + ) + eq_( + idx.dialect_kwargs, + {"participating_x": 25, "participating_z_one": "default"}, + ) + + idx._validate_dialect_kwargs( + {"participating_x": 25, "participating_z_one": "default"} + ) + + eq_( + idx.dialect_options, + {"participating": {"x": 25, "y": False, "z_one": "default"}}, + ) + eq_( + idx.dialect_kwargs, + {"participating_x": 25, "participating_z_one": "default"}, + ) + + idx._validate_dialect_kwargs( + {"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}, + }, + ) + eq_( + idx.dialect_kwargs, + { + "participating_x": 25, + "participating_y": True, + "participating2_y": "p2y", + "participating_z_one": "default", + }, + ) def test_key_error_kwargs_no_dialect(self): with self._fixture(): - idx = Index('a', 'b', 'c') - assert_raises( - KeyError, - idx.kwargs.__getitem__, 'foo_bar' - ) + idx = Index("a", "b", "c") + assert_raises(KeyError, idx.kwargs.__getitem__, "foo_bar") def test_key_error_kwargs_no_underscore(self): with self._fixture(): - idx = Index('a', 'b', 'c') - assert_raises( - KeyError, - idx.kwargs.__getitem__, 'foobar' - ) + idx = Index("a", "b", "c") + assert_raises(KeyError, idx.kwargs.__getitem__, "foobar") def test_key_error_kwargs_no_argument(self): with self._fixture(): - idx = Index('a', 'b', 'c') + idx = Index("a", "b", "c") assert_raises( - KeyError, - idx.kwargs.__getitem__, 'participating_asdmfq34098' + KeyError, idx.kwargs.__getitem__, "participating_asdmfq34098" ) assert_raises( KeyError, - idx.kwargs.__getitem__, 'nonparticipating_asdmfq34098' + idx.kwargs.__getitem__, + "nonparticipating_asdmfq34098", ) def test_key_error_dialect_options(self): with self._fixture(): - idx = Index('a', 'b', 'c') + idx = Index("a", "b", "c") assert_raises( KeyError, - idx.dialect_options['participating'].__getitem__, 'asdfaso890' + idx.dialect_options["participating"].__getitem__, + "asdfaso890", ) 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(): - idx = Index('a', 'b', 'c') - idx.dialect_options['participating']['foobar'] = 5 + idx = Index("a", "b", "c") + idx.dialect_options["participating"]["foobar"] = 5 - eq_(idx.dialect_options['participating']['foobar'], 5) - eq_(idx.kwargs['participating_foobar'], 5) + eq_(idx.dialect_options["participating"]["foobar"], 5) + eq_(idx.kwargs["participating_foobar"], 5) def test_ad_hoc_nonparticipating_via_opt(self): with self._fixture(): - idx = Index('a', 'b', 'c') - idx.dialect_options['nonparticipating']['foobar'] = 5 + idx = Index("a", "b", "c") + idx.dialect_options["nonparticipating"]["foobar"] = 5 - eq_(idx.dialect_options['nonparticipating']['foobar'], 5) - eq_(idx.kwargs['nonparticipating_foobar'], 5) + eq_(idx.dialect_options["nonparticipating"]["foobar"], 5) + eq_(idx.kwargs["nonparticipating_foobar"], 5) def test_ad_hoc_participating_via_kwargs(self): with self._fixture(): - idx = Index('a', 'b', 'c') - idx.kwargs['participating_foobar'] = 5 + idx = Index("a", "b", "c") + idx.kwargs["participating_foobar"] = 5 - eq_(idx.dialect_options['participating']['foobar'], 5) - eq_(idx.kwargs['participating_foobar'], 5) + eq_(idx.dialect_options["participating"]["foobar"], 5) + eq_(idx.kwargs["participating_foobar"], 5) def test_ad_hoc_nonparticipating_via_kwargs(self): with self._fixture(): - idx = Index('a', 'b', 'c') - idx.kwargs['nonparticipating_foobar'] = 5 + idx = Index("a", "b", "c") + idx.kwargs["nonparticipating_foobar"] = 5 - eq_(idx.dialect_options['nonparticipating']['foobar'], 5) - eq_(idx.kwargs['nonparticipating_foobar'], 5) + eq_(idx.dialect_options["nonparticipating"]["foobar"], 5) + eq_(idx.kwargs["nonparticipating_foobar"], 5) def test_ad_hoc_via_kwargs_invalid_key(self): with self._fixture(): - idx = Index('a', 'b', 'c') + idx = Index("a", "b", "c") assert_raises_message( exc.ArgumentError, "Keys must be of the form <dialectname>_<argname>", - idx.kwargs.__setitem__, "foobar", 5 + idx.kwargs.__setitem__, + "foobar", + 5, ) def test_ad_hoc_via_kwargs_invalid_dialect(self): with self._fixture(): - idx = Index('a', 'b', 'c') + idx = Index("a", "b", "c") assert_raises_message( exc.ArgumentError, "no dialect 'nonexistent'", - idx.kwargs.__setitem__, "nonexistent_foobar", 5 + idx.kwargs.__setitem__, + "nonexistent_foobar", + 5, ) def test_add_new_arguments_participating(self): with self._fixture(): Index.argument_for("participating", "xyzqpr", False) - idx = Index('a', 'b', 'c', participating_xyzqpr=True) + idx = Index("a", "b", "c", participating_xyzqpr=True) - eq_(idx.kwargs['participating_xyzqpr'], True) + eq_(idx.kwargs["participating_xyzqpr"], True) - idx = Index('a', 'b', 'c') - eq_(idx.dialect_options['participating']['xyzqpr'], False) + idx = Index("a", "b", "c") + eq_(idx.dialect_options["participating"]["xyzqpr"], False) def test_add_new_arguments_participating_no_existing(self): with self._fixture(): PrimaryKeyConstraint.argument_for("participating", "xyzqpr", False) - pk = PrimaryKeyConstraint('a', 'b', 'c', participating_xyzqpr=True) + pk = PrimaryKeyConstraint("a", "b", "c", participating_xyzqpr=True) - eq_(pk.kwargs['participating_xyzqpr'], True) + eq_(pk.kwargs["participating_xyzqpr"], True) - pk = PrimaryKeyConstraint('a', 'b', 'c') - eq_(pk.dialect_options['participating']['xyzqpr'], False) + pk = PrimaryKeyConstraint("a", "b", "c") + eq_(pk.dialect_options["participating"]["xyzqpr"], False) def test_add_new_arguments_nonparticipating(self): with self._fixture(): @@ -4141,7 +4349,10 @@ class DialectKWArgTest(fixtures.TestBase): exc.ArgumentError, "Dialect 'nonparticipating' does have keyword-argument " "validation and defaults enabled configured", - Index.argument_for, "nonparticipating", "xyzqpr", False + Index.argument_for, + "nonparticipating", + "xyzqpr", + False, ) def test_add_new_arguments_invalid_dialect(self): @@ -4149,43 +4360,48 @@ class DialectKWArgTest(fixtures.TestBase): assert_raises_message( exc.ArgumentError, "no dialect 'nonexistent'", - Index.argument_for, "nonexistent", "foobar", 5 + Index.argument_for, + "nonexistent", + "foobar", + 5, ) class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def _fixture(self, naming_convention, table_schema=None): 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)), - Column('Data2', String(30), key="data2"), - Column('Data3', String(30), key="data3"), - schema=table_schema - ) + u1 = Table( + "user", + m1, + Column("id", Integer, primary_key=True), + Column("version", Integer, primary_key=True), + Column("data", String(30)), + Column("Data2", String(30), key="data2"), + Column("Data3", String(30), key="data3"), + schema=table_schema, + ) return u1 def test_uq_name(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_name)s"} + ) uq = UniqueConstraint(u1.c.data) eq_(uq.name, "uq_user_data") def test_uq_conv_name(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_name)s"} + ) uq = UniqueConstraint(u1.c.data, name=naming.conv("myname")) self.assert_compile( schema.AddConstraint(uq), 'ALTER TABLE "user" ADD CONSTRAINT myname UNIQUE (data)', - dialect="default" + dialect="default", ) def test_uq_defer_name_no_convention(self): @@ -4194,59 +4410,59 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( schema.AddConstraint(uq), 'ALTER TABLE "user" ADD CONSTRAINT myname UNIQUE (data)', - dialect="default" + dialect="default", ) def test_uq_defer_name_convention(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_name)s"} + ) uq = UniqueConstraint(u1.c.data, name=naming._defer_name("myname")) self.assert_compile( schema.AddConstraint(uq), 'ALTER TABLE "user" ADD CONSTRAINT uq_user_data UNIQUE (data)', - dialect="default" + dialect="default", ) def test_uq_key(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_key)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_key)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2) eq_(uq.name, "uq_user_data") def test_uq_label(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_label)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_label)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2) eq_(uq.name, "uq_user_user_data") def test_uq_allcols_underscore_name(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0_N_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0_N_name)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2, u1.c.data3) eq_(uq.name, "uq_user_data_Data2_Data3") def test_uq_allcols_merged_name(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0N_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0N_name)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2, u1.c.data3) eq_(uq.name, "uq_user_dataData2Data3") def test_uq_allcols_merged_key(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0N_key)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0N_key)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2, u1.c.data3) eq_(uq.name, "uq_user_datadata2data3") def test_uq_allcols_truncated_name(self): - u1 = self._fixture(naming_convention={ - "uq": "uq_%(table_name)s_%(column_0N_name)s" - }) + u1 = self._fixture( + naming_convention={"uq": "uq_%(table_name)s_%(column_0N_name)s"} + ) uq = UniqueConstraint(u1.c.data, u1.c.data2, u1.c.data3) dialect = default.DefaultDialect() @@ -4255,7 +4471,7 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'ALTER TABLE "user" ADD ' 'CONSTRAINT "uq_user_dataData2Data3" ' 'UNIQUE (data, "Data2", "Data3")', - dialect=dialect + dialect=dialect, ) dialect.max_identifier_length = 15 @@ -4263,188 +4479,222 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): schema.AddConstraint(uq), 'ALTER TABLE "user" ADD ' 'CONSTRAINT uq_user_2769 UNIQUE (data, "Data2", "Data3")', - dialect=dialect + dialect=dialect, ) def test_fk_allcols_underscore_name(self): - u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(column_0_N_name)s_" - "%(referred_table_name)s_%(referred_column_0_N_name)s"}) + u1 = self._fixture( + naming_convention={ + "fk": "fk_%(table_name)s_%(column_0_N_name)s_" + "%(referred_table_name)s_%(referred_column_0_N_name)s" + } + ) m1 = u1.metadata - a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('UserData', String(30), key="user_data"), - Column('UserData2', String(30), key="user_data2"), - Column('UserData3', String(30), key="user_data3") - ) - fk = ForeignKeyConstraint(['user_data', 'user_data2', 'user_data3'], - ['user.data', 'user.data2', 'user.data3']) + a1 = Table( + "address", + m1, + Column("id", Integer, primary_key=True), + Column("UserData", String(30), key="user_data"), + Column("UserData2", String(30), key="user_data2"), + Column("UserData3", String(30), key="user_data3"), + ) + fk = ForeignKeyConstraint( + ["user_data", "user_data2", "user_data3"], + ["user.data", "user.data2", "user.data3"], + ) a1.append_constraint(fk) self.assert_compile( schema.AddConstraint(fk), - 'ALTER TABLE address ADD CONSTRAINT ' + "ALTER TABLE address ADD CONSTRAINT " '"fk_address_UserData_UserData2_UserData3_user_data_Data2_Data3" ' 'FOREIGN KEY("UserData", "UserData2", "UserData3") ' 'REFERENCES "user" (data, "Data2", "Data3")', - dialect=default.DefaultDialect() + dialect=default.DefaultDialect(), ) def test_fk_allcols_merged_name(self): - u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(column_0N_name)s_" - "%(referred_table_name)s_%(referred_column_0N_name)s"}) + u1 = self._fixture( + naming_convention={ + "fk": "fk_%(table_name)s_%(column_0N_name)s_" + "%(referred_table_name)s_%(referred_column_0N_name)s" + } + ) m1 = u1.metadata - a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('UserData', String(30), key="user_data"), - Column('UserData2', String(30), key="user_data2"), - Column('UserData3', String(30), key="user_data3") - ) - fk = ForeignKeyConstraint(['user_data', 'user_data2', 'user_data3'], - ['user.data', 'user.data2', 'user.data3']) + a1 = Table( + "address", + m1, + Column("id", Integer, primary_key=True), + Column("UserData", String(30), key="user_data"), + Column("UserData2", String(30), key="user_data2"), + Column("UserData3", String(30), key="user_data3"), + ) + fk = ForeignKeyConstraint( + ["user_data", "user_data2", "user_data3"], + ["user.data", "user.data2", "user.data3"], + ) a1.append_constraint(fk) self.assert_compile( schema.AddConstraint(fk), - 'ALTER TABLE address ADD CONSTRAINT ' + "ALTER TABLE address ADD CONSTRAINT " '"fk_address_UserDataUserData2UserData3_user_dataData2Data3" ' 'FOREIGN KEY("UserData", "UserData2", "UserData3") ' 'REFERENCES "user" (data, "Data2", "Data3")', - dialect=default.DefaultDialect() + dialect=default.DefaultDialect(), ) def test_fk_allcols_truncated_name(self): - u1 = self._fixture(naming_convention={ - "fk": "fk_%(table_name)s_%(column_0N_name)s_" - "%(referred_table_name)s_%(referred_column_0N_name)s"}) + u1 = self._fixture( + naming_convention={ + "fk": "fk_%(table_name)s_%(column_0N_name)s_" + "%(referred_table_name)s_%(referred_column_0N_name)s" + } + ) m1 = u1.metadata - a1 = Table('address', m1, - Column('id', Integer, primary_key=True), - Column('UserData', String(30), key="user_data"), - Column('UserData2', String(30), key="user_data2"), - Column('UserData3', String(30), key="user_data3") - ) - fk = ForeignKeyConstraint(['user_data', 'user_data2', 'user_data3'], - ['user.data', 'user.data2', 'user.data3']) + a1 = Table( + "address", + m1, + Column("id", Integer, primary_key=True), + Column("UserData", String(30), key="user_data"), + Column("UserData2", String(30), key="user_data2"), + Column("UserData3", String(30), key="user_data3"), + ) + fk = ForeignKeyConstraint( + ["user_data", "user_data2", "user_data3"], + ["user.data", "user.data2", "user.data3"], + ) a1.append_constraint(fk) dialect = default.DefaultDialect() dialect.max_identifier_length = 15 self.assert_compile( schema.AddConstraint(fk), - 'ALTER TABLE address ADD CONSTRAINT ' - 'fk_addr_f9ff ' + "ALTER TABLE address ADD CONSTRAINT " + "fk_addr_f9ff " 'FOREIGN KEY("UserData", "UserData2", "UserData3") ' 'REFERENCES "user" (data, "Data2", "Data3")', - dialect=dialect + dialect=dialect, ) def test_ix_allcols_truncation(self): - u1 = self._fixture(naming_convention={ - "ix": "ix_%(table_name)s_%(column_0N_name)s" - }) + u1 = self._fixture( + naming_convention={"ix": "ix_%(table_name)s_%(column_0N_name)s"} + ) ix = Index(None, u1.c.data, u1.c.data2, u1.c.data3) dialect = default.DefaultDialect() dialect.max_identifier_length = 15 self.assert_compile( schema.CreateIndex(ix), - 'CREATE INDEX ix_user_2de9 ON ' - '"user" (data, "Data2", "Data3")', - dialect=dialect + "CREATE INDEX ix_user_2de9 ON " '"user" (data, "Data2", "Data3")', + dialect=dialect, ) def test_ix_name(self): - u1 = self._fixture(naming_convention={ - "ix": "ix_%(table_name)s_%(column_0_name)s" - }) + u1 = self._fixture( + naming_convention={"ix": "ix_%(table_name)s_%(column_0_name)s"} + ) ix = Index(None, u1.c.data) eq_(ix.name, "ix_user_data") def test_ck_name_required(self): - u1 = self._fixture(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) - ck = CheckConstraint(u1.c.data == 'x', name='mycheck') + u1 = self._fixture( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) + ck = CheckConstraint(u1.c.data == "x", name="mycheck") eq_(ck.name, "ck_user_mycheck") assert_raises_message( exc.InvalidRequestError, r"Naming convention including %\(constraint_name\)s token " "requires that constraint is explicitly named.", - CheckConstraint, u1.c.data == 'x' + CheckConstraint, + u1.c.data == "x", ) def test_ck_name_deferred_required(self): - u1 = self._fixture(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) - ck = CheckConstraint(u1.c.data == 'x', name=elements._defer_name(None)) + u1 = self._fixture( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) + ck = CheckConstraint(u1.c.data == "x", name=elements._defer_name(None)) assert_raises_message( exc.InvalidRequestError, r"Naming convention including %\(constraint_name\)s token " "requires that constraint is explicitly named.", - schema.AddConstraint(ck).compile + schema.AddConstraint(ck).compile, ) def test_column_attached_ck_name(self): - m = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) - ck = CheckConstraint('x > 5', name='x1') - Table('t', m, Column('x', ck)) + m = MetaData( + naming_convention={"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 = CheckConstraint('x > 5', name='x1') - Table('t', m, Column('x', Integer), ck) + m = MetaData( + naming_convention={"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") def test_uq_name_already_conv(self): - m = MetaData(naming_convention={ - "uq": "uq_%(constraint_name)s_%(column_0_name)s" - }) + m = MetaData( + naming_convention={ + "uq": "uq_%(constraint_name)s_%(column_0_name)s" + } + ) - t = Table('mytable', m) - uq = UniqueConstraint(name=naming.conv('my_special_key')) + t = Table("mytable", m) + uq = UniqueConstraint(name=naming.conv("my_special_key")) 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") + 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", + ) m1 = u1.metadata - a1 = Table('address', m1, - 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']) + a1 = Table( + "address", + m1, + 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"] + ) 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" - }) + u1 = self._fixture( + naming_convention={ + "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) - ) - fk = ForeignKeyConstraint(['user_id', 'user_version_id'], - ['user.id', 'user.version']) + a1 = Table( + "address", + m1, + 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"] + ) a1.append_constraint(fk) eq_(fk.name, "fk_address_user_id_user_id") @@ -4452,32 +4702,38 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 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 - }) + u1 = self._fixture( + naming_convention={ + "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) - ) - fk = ForeignKeyConstraint(['user_id', 'user_version_id'], - ['user.id', 'user.version']) + a1 = Table( + "address", + m1, + 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"] + ) 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"}) + m1 = MetaData( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) - u1 = Table('user', m1, - Column('x', Boolean(name='foo')) - ) + u1 = Table("user", m1, Column("x", Boolean(name="foo"))) # constraint is not hit eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "foo" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "foo", ) # but is hit at compile time self.assert_compile( @@ -4485,20 +4741,21 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'CREATE TABLE "user" (' "x BOOLEAN, " "CONSTRAINT ck_user_foo CHECK (x IN (0, 1))" - ")" + ")", ) def test_schematype_ck_name_boolean_not_on_name(self): - m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(column_0_name)s"}) + m1 = MetaData( + naming_convention={"ck": "ck_%(table_name)s_%(column_0_name)s"} + ) - u1 = Table('user', m1, - Column('x', Boolean()) - ) + u1 = Table("user", m1, Column("x", Boolean())) # constraint is not hit eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "_unnamed_" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "_unnamed_", ) # but is hit at compile time self.assert_compile( @@ -4506,19 +4763,20 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'CREATE TABLE "user" (' "x BOOLEAN, " "CONSTRAINT ck_user_x CHECK (x IN (0, 1))" - ")" + ")", ) def test_schematype_ck_name_enum(self): - m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s"}) + m1 = MetaData( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) - u1 = Table('user', m1, - Column('x', Enum('a', 'b', name='foo')) - ) + u1 = Table("user", m1, Column("x", Enum("a", "b", name="foo"))) eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "foo" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "foo", ) # but is hit at compile time self.assert_compile( @@ -4526,19 +4784,22 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'CREATE TABLE "user" (' "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"}) + m1 = MetaData( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) - u1 = Table('user', m1, - Column('x', Enum('a', 'b', name=naming.conv('foo'))) - ) + u1 = Table( + "user", m1, Column("x", Enum("a", "b", name=naming.conv("foo"))) + ) eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "foo" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "foo", ) # but is hit at compile time self.assert_compile( @@ -4546,62 +4807,60 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): 'CREATE TABLE "user" (' "x VARCHAR(1), " "CONSTRAINT foo CHECK (x IN ('a', 'b'))" - ")" + ")", ) def test_schematype_ck_name_boolean_no_name(self): - m1 = MetaData(naming_convention={ - "ck": "ck_%(table_name)s_%(constraint_name)s" - }) - - u1 = Table( - 'user', m1, - Column('x', Boolean()) + m1 = MetaData( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} ) + + u1 = Table("user", m1, Column("x", Boolean())) # constraint gets special _defer_none_name eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "_unnamed_" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "_unnamed_", ) # no issue with native boolean self.assert_compile( schema.CreateTable(u1), - 'CREATE TABLE "user" (' - "x BOOLEAN" - ")", - dialect='postgresql' + 'CREATE TABLE "user" (' "x BOOLEAN" ")", + dialect="postgresql", ) assert_raises_message( exc.InvalidRequestError, r"Naming convention including \%\(constraint_name\)s token " r"requires that constraint is explicitly named.", - schema.CreateTable(u1).compile, dialect=default.DefaultDialect() + schema.CreateTable(u1).compile, + dialect=default.DefaultDialect(), ) def test_schematype_no_ck_name_boolean_no_name(self): m1 = MetaData() # no naming convention - u1 = Table( - 'user', m1, - Column('x', Boolean()) - ) + u1 = Table("user", m1, Column("x", Boolean())) # constraint gets special _defer_none_name eq_( - [c for c in u1.constraints - if isinstance(c, CheckConstraint)][0].name, "_unnamed_" + [c for c in u1.constraints if isinstance(c, CheckConstraint)][ + 0 + ].name, + "_unnamed_", ) self.assert_compile( schema.CreateTable(u1), - 'CREATE TABLE "user" (x BOOLEAN, CHECK (x IN (0, 1)))' + '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"}) + u1 = self._fixture( + naming_convention={"ck": "ck_%(table_name)s_%(constraint_name)s"} + ) - ck1 = CheckConstraint(u1.c.version > 3, name='foo') + ck1 = CheckConstraint(u1.c.version > 3, name="foo") u1.append_constraint(ck1) u1.append_constraint(ck1) u1.append_constraint(ck1) @@ -4615,8 +4874,8 @@ class NamingConventionTest(fixtures.TestBase, AssertsCompiledSQL): eq_(m2.naming_convention, {"pk": "%(table_name)s_pk"}) - t2a = Table('t2', m, Column('id', Integer, primary_key=True)) - t2b = Table('t2', m2, Column('id', Integer, primary_key=True)) + t2a = Table("t2", m, Column("id", Integer, primary_key=True)) + t2b = Table("t2", m2, Column("id", Integer, primary_key=True)) eq_(t2a.primary_key.name, t2b.primary_key.name) eq_(t2b.primary_key.name, "t2_pk") diff --git a/test/sql/test_operators.py b/test/sql/test_operators.py index 00961a2e8..2ce842caf 100644 --- a/test/sql/test_operators.py +++ b/test/sql/test_operators.py @@ -2,12 +2,29 @@ from sqlalchemy.testing import fixtures, eq_, is_, is_not_ from sqlalchemy import testing from sqlalchemy.testing import assert_raises_message from sqlalchemy.testing import expect_warnings -from sqlalchemy.sql import column, desc, asc, literal, collate, null, \ - true, false, any_, all_ +from sqlalchemy.sql import ( + column, + desc, + asc, + literal, + collate, + null, + true, + false, + any_, + all_, +) from sqlalchemy.sql import sqltypes -from sqlalchemy.sql.expression import BinaryExpression, \ - ClauseList, Grouping, \ - UnaryExpression, select, union, func, tuple_ +from sqlalchemy.sql.expression import ( + BinaryExpression, + ClauseList, + Grouping, + UnaryExpression, + select, + union, + func, + tuple_, +) from sqlalchemy.sql import operators, table import operator from sqlalchemy import String, Integer, LargeBinary @@ -16,11 +33,26 @@ from sqlalchemy.engine import default from sqlalchemy.sql.elements import _literal_as_text, Label from sqlalchemy.schema import Column, Table, MetaData from sqlalchemy.sql import compiler -from sqlalchemy.types import TypeEngine, TypeDecorator, UserDefinedType, \ - Boolean, MatchType, Indexable, Concatenable, ARRAY, JSON, \ - DateTime -from sqlalchemy.dialects import mysql, firebird, postgresql, oracle, \ - sqlite, mssql +from sqlalchemy.types import ( + TypeEngine, + TypeDecorator, + UserDefinedType, + Boolean, + MatchType, + Indexable, + Concatenable, + ARRAY, + JSON, + DateTime, +) +from sqlalchemy.dialects import ( + mysql, + firebird, + postgresql, + oracle, + sqlite, + mssql, +) from sqlalchemy import util import datetime import collections @@ -29,53 +61,42 @@ from sqlalchemy import and_, not_, between, or_ class LoopOperate(operators.ColumnOperators): - def operate(self, op, *other, **kwargs): return op class DefaultColumnComparatorTest(fixtures.TestBase): - def _do_scalar_test(self, operator, compare_to): - left = column('left') - assert left.comparator.operate(operator).compare( - compare_to(left) - ) + left = column("left") + assert left.comparator.operate(operator).compare(compare_to(left)) self._loop_test(operator) - def _do_operate_test(self, operator, right=column('right')): - left = column('left') + def _do_operate_test(self, operator, right=column("right")): + left = column("left") - assert left.comparator.operate( - operator, - right).compare( + assert left.comparator.operate(operator, right).compare( BinaryExpression( - _literal_as_text(left), - _literal_as_text(right), - operator)) + _literal_as_text(left), _literal_as_text(right), operator + ) + ) - assert operator( - left, - right).compare( + assert operator(left, right).compare( BinaryExpression( - _literal_as_text(left), - _literal_as_text(right), - operator)) + _literal_as_text(left), _literal_as_text(right), operator + ) + ) self._loop_test(operator, right) if operators.is_comparison(operator): is_( left.comparator.operate(operator, right).type, - sqltypes.BOOLEANTYPE + sqltypes.BOOLEANTYPE, ) def _loop_test(self, operator, *arg): loop = LoopOperate() - is_( - operator(loop, *arg), - operator - ) + is_(operator(loop, *arg), operator) def test_desc(self): self._do_scalar_test(operators.desc_op, desc) @@ -153,77 +174,75 @@ class DefaultColumnComparatorTest(fixtures.TestBase): assert_raises_message( NotImplementedError, "Operator 'getitem' is not supported on this expression", - self._do_operate_test, operators.getitem + self._do_operate_test, + operators.getitem, ) assert_raises_message( NotImplementedError, "Operator 'getitem' is not supported on this expression", - lambda: column('left')[3] + lambda: column("left")[3], ) def test_in(self): - left = column('left') + 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 + 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') + 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 + 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): - left = column('left') + left = column("left") foo = ClauseList() assert_raises_message( exc.InvalidRequestError, r"in_\(\) accepts either a list of expressions, a selectable", - left.in_, [foo] + left.in_, + [foo], ) def test_in_no_accept_non_list_non_selectable(self): - left = column('left') - right = column('right') + left = column("left") + right = column("right") assert_raises_message( exc.InvalidRequestError, r"in_\(\) accepts either a list of expressions, a selectable", - left.in_, right + left.in_, + right, ) 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 - left = column('left') - right = column('right', HasGetitem) + left = column("left") + right = column("right", HasGetitem) assert_raises_message( exc.InvalidRequestError, r"in_\(\) accepts either a list of expressions, a selectable", - left.in_, right + left.in_, + right, ) def test_collate(self): - left = column('left') + left = column("left") right = "some collation" left.comparator.operate(operators.collate, right).compare( collate(left, right) @@ -239,10 +258,8 @@ class DefaultColumnComparatorTest(fixtures.TestBase): class TypeTwo(TypeEngine): pass - expr = column('x', TypeOne()) - column('y', TypeTwo()) - is_( - expr.type._type_affinity, TypeOne - ) + expr = column("x", TypeOne()) - column("y", TypeTwo()) + is_(expr.type._type_affinity, TypeOne) def test_concatenable_adapt(self): class TypeOne(Concatenable, TypeEngine): @@ -254,116 +271,89 @@ class DefaultColumnComparatorTest(fixtures.TestBase): class TypeThree(TypeEngine): pass - expr = column('x', TypeOne()) - column('y', TypeTwo()) - is_( - expr.type._type_affinity, TypeOne - ) - is_( - expr.operator, operator.sub - ) + expr = column("x", TypeOne()) - column("y", TypeTwo()) + is_(expr.type._type_affinity, TypeOne) + is_(expr.operator, operator.sub) - expr = column('x', TypeOne()) + column('y', TypeTwo()) - is_( - expr.type._type_affinity, TypeOne - ) - is_( - expr.operator, operators.concat_op - ) + expr = column("x", TypeOne()) + column("y", TypeTwo()) + is_(expr.type._type_affinity, TypeOne) + is_(expr.operator, operators.concat_op) - expr = column('x', TypeOne()) - column('y', TypeThree()) - is_( - expr.type._type_affinity, TypeOne - ) - is_( - expr.operator, operator.sub - ) + expr = column("x", TypeOne()) - column("y", TypeThree()) + is_(expr.type._type_affinity, TypeOne) + is_(expr.operator, operator.sub) - expr = column('x', TypeOne()) + column('y', TypeThree()) - is_( - expr.type._type_affinity, TypeOne - ) - is_( - expr.operator, operator.add - ) + expr = column("x", TypeOne()) + column("y", TypeThree()) + is_(expr.type._type_affinity, TypeOne) + is_(expr.operator, operator.add) def test_contains_override_raises(self): for col in [ - Column('x', String), - Column('x', Integer), - Column('x', DateTime) + Column("x", String), + Column("x", Integer), + Column("x", DateTime), ]: assert_raises_message( NotImplementedError, "Operator 'contains' is not supported on this expression", - lambda: 'foo' in col + lambda: "foo" in col, ) class CustomUnaryOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __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) + return UnaryExpression( + self.expr, + modifier=operators.custom_op("!"), + type_=MyInteger, + ) def factorial_prefix(self): - return UnaryExpression(self.expr, - operator=operators.custom_op("!!"), - type_=MyInteger) + return UnaryExpression( + self.expr, + operator=operators.custom_op("!!"), + type_=MyInteger, + ) def __invert__(self): - return UnaryExpression(self.expr, - operator=operators.custom_op("!!!"), - type_=MyInteger) + return UnaryExpression( + self.expr, + operator=operators.custom_op("!!!"), + type_=MyInteger, + ) return MyInteger def test_factorial(self): - col = column('somecol', self._factorial_fixture()) - self.assert_compile( - col.factorial(), - "somecol !" - ) + col = column("somecol", self._factorial_fixture()) + self.assert_compile(col.factorial(), "somecol !") def test_double_factorial(self): - col = column('somecol', self._factorial_fixture()) - self.assert_compile( - col.factorial().factorial(), - "somecol ! !" - ) + col = column("somecol", self._factorial_fixture()) + self.assert_compile(col.factorial().factorial(), "somecol ! !") def test_factorial_prefix(self): - col = column('somecol', self._factorial_fixture()) - self.assert_compile( - col.factorial_prefix(), - "!! somecol" - ) + col = column("somecol", self._factorial_fixture()) + self.assert_compile(col.factorial_prefix(), "!! somecol") def test_factorial_invert(self): - col = column('somecol', self._factorial_fixture()) - self.assert_compile( - ~col, - "!!! somecol" - ) + col = column("somecol", self._factorial_fixture()) + self.assert_compile(~col, "!!! somecol") def test_double_factorial_invert(self): - col = column('somecol', self._factorial_fixture()) - self.assert_compile( - ~(~col), - "!!! (!!! somecol)" - ) + col = column("somecol", self._factorial_fixture()) + self.assert_compile(~(~col), "!!! (!!! somecol)") def test_unary_no_ops(self): assert_raises_message( exc.CompileError, "Unary expression has no operator or modifier", - UnaryExpression(literal("x")).compile + UnaryExpression(literal("x")).compile, ) def test_unary_both_ops(self): @@ -371,83 +361,68 @@ class CustomUnaryOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): exc.CompileError, "Unary expression does not support operator and " "modifier simultaneously", - UnaryExpression(literal("x"), - operator=operators.custom_op("x"), - modifier=operators.custom_op("y")).compile + UnaryExpression( + literal("x"), + 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()) + 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()) - ) + t = Table("t", MetaData(), 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()) - ) + t = Table("t", MetaData(), Column("foo", self._add_override_factory())) proxied = t.alias().c.foo self._assert_add_override(proxied) self._assert_and_override(proxied) def test_binary_propagate(self): - c1 = Column('foo', self._add_override_factory()) + c1 = Column("foo", self._add_override_factory()) self._assert_add_override(c1 - 6) self._assert_and_override(c1 - 6) def test_reverse_binary_propagate(self): - c1 = Column('foo', self._add_override_factory()) + c1 = Column("foo", self._add_override_factory()) self._assert_add_override(6 - c1) self._assert_and_override(6 - c1) def test_binary_multi_propagate(self): - c1 = Column('foo', self._add_override_factory()) + c1 = Column("foo", self._add_override_factory()) self._assert_add_override((c1 - 6) + 5) self._assert_and_override((c1 - 6) + 5) def test_no_boolean_propagate(self): - c1 = Column('foo', self._add_override_factory()) + c1 = Column("foo", self._add_override_factory()) self._assert_not_add_override(c1 == 56) self._assert_not_and_override(c1 == 56) def _assert_and_override(self, expr): - assert (expr & text("5")).compare( - expr.op("goofy_and")(text("5")) - ) + assert (expr & text("5")).compare(expr.op("goofy_and")(text("5"))) def _assert_add_override(self, expr): - assert (expr + 5).compare( - expr.op("goofy")(5) - ) + assert (expr + 5).compare(expr.op("goofy")(5)) def _assert_not_add_override(self, expr): - assert not (expr + 5).compare( - expr.op("goofy")(5) - ) + assert not (expr + 5).compare(expr.op("goofy")(5)) def _assert_not_and_override(self, expr): - assert not (expr & text("5")).compare( - expr.op("goofy_and")(text("5")) - ) + assert not (expr & text("5")).compare(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): super(MyInteger.comparator_factory, self).__init__(expr) @@ -461,14 +436,11 @@ 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): super(MyInteger.comparator_factory, self).__init__(expr) @@ -482,15 +454,13 @@ class TypeDecoratorComparatorTest(_CustomComparatorTests, fixtures.TestBase): class TypeDecoratorTypeDecoratorComparatorTest( - _CustomComparatorTests, fixtures.TestBase): - + _CustomComparatorTests, fixtures.TestBase +): def _add_override_factory(self): - class MyIntegerOne(TypeDecorator): impl = Integer class comparator_factory(TypeDecorator.Comparator): - def __init__(self, expr): super(MyIntegerOne.comparator_factory, self).__init__(expr) @@ -507,19 +477,15 @@ class TypeDecoratorTypeDecoratorComparatorTest( class TypeDecoratorWVariantComparatorTest( - _CustomComparatorTests, - fixtures.TestBase): - + _CustomComparatorTests, fixtures.TestBase +): def _add_override_factory(self): - class SomeOtherInteger(Integer): - class comparator_factory(TypeEngine.Comparator): - def __init__(self, expr): - super( - SomeOtherInteger.comparator_factory, - self).__init__(expr) + super(SomeOtherInteger.comparator_factory, self).__init__( + expr + ) def __add__(self, other): return self.expr.op("not goofy")(other) @@ -531,7 +497,6 @@ class TypeDecoratorWVariantComparatorTest( impl = Integer class comparator_factory(TypeDecorator.Comparator): - def __init__(self, expr): super(MyInteger.comparator_factory, self).__init__(expr) @@ -545,14 +510,11 @@ class TypeDecoratorWVariantComparatorTest( class CustomEmbeddedinTypeDecoratorTest( - _CustomComparatorTests, - fixtures.TestBase): - + _CustomComparatorTests, fixtures.TestBase +): def _add_override_factory(self): class MyInteger(Integer): - class comparator_factory(TypeEngine.Comparator): - def __init__(self, expr): super(MyInteger.comparator_factory, self).__init__(expr) @@ -569,23 +531,19 @@ class CustomEmbeddedinTypeDecoratorTest( class NewOperatorTest(_CustomComparatorTests, fixtures.TestBase): - def _add_override_factory(self): class MyInteger(Integer): - class comparator_factory(TypeEngine.Comparator): - def __init__(self, expr): super(MyInteger.comparator_factory, self).__init__(expr) def foob(self, other): return self.expr.op("foob")(other) + return MyInteger def _assert_add_override(self, expr): - assert (expr.foob(5)).compare( - expr.op("foob")(5) - ) + assert (expr.foob(5)).compare(expr.op("foob")(5)) def _assert_not_add_override(self, expr): assert not hasattr(expr, "foob") @@ -598,71 +556,49 @@ class NewOperatorTest(_CustomComparatorTests, fixtures.TestBase): class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_contains(self): class MyType(UserDefinedType): - class comparator_factory(UserDefinedType.Comparator): - def contains(self, other, **kw): return self.op("->")(other) - self.assert_compile( - Column('x', MyType()).contains(5), - "x -> :x_1" - ) + self.assert_compile(Column("x", MyType()).contains(5), "x -> :x_1") def test_getitem(self): class MyType(UserDefinedType): - class comparator_factory(UserDefinedType.Comparator): - def __getitem__(self, index): return self.op("->")(index) - self.assert_compile( - Column('x', MyType())[5], - "x -> :x_1" - ) + self.assert_compile(Column("x", MyType())[5], "x -> :x_1") 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) - col = Column('x', MyType()) + col = Column("x", MyType()) assert not isinstance(col, util.collections_abc.Iterable) def test_lshift(self): class MyType(UserDefinedType): - class comparator_factory(UserDefinedType.Comparator): - def __lshift__(self, other): return self.op("->")(other) - self.assert_compile( - Column('x', MyType()) << 5, - "x -> :x_1" - ) + self.assert_compile(Column("x", MyType()) << 5, "x -> :x_1") def test_rshift(self): class MyType(UserDefinedType): - class comparator_factory(UserDefinedType.Comparator): - def __rshift__(self, other): return self.op("->")(other) - self.assert_compile( - Column('x', MyType()) >> 5, - "x -> :x_1" - ) + self.assert_compile(Column("x", MyType()) >> 5, "x -> :x_1") class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): @@ -675,14 +611,14 @@ class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): return "MYOTHERTYPE" class MyCompiler(compiler.SQLCompiler): - def visit_json_getitem_op_binary(self, binary, operator, **kw): return self._generate_generic_binary( binary, " -> ", eager_grouping=True, **kw ) def visit_json_path_getitem_op_binary( - self, binary, operator, **kw): + self, binary, operator, **kw + ): return self._generate_generic_binary( binary, " #> ", eager_grouping=True, **kw ) @@ -695,7 +631,7 @@ class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): type_compiler = MyTypeCompiler class MyType(JSON): - __visit_name__ = 'mytype' + __visit_name__ = "mytype" pass @@ -703,109 +639,83 @@ class JSONIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.__dialect__ = MyDialect() def test_setup_getitem(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) - is_( - col[5].type._type_affinity, JSON - ) - is_( - col[5]['foo'].type._type_affinity, JSON - ) - is_( - col[('a', 'b', 'c')].type._type_affinity, JSON - ) + is_(col[5].type._type_affinity, JSON) + is_(col[5]["foo"].type._type_affinity, JSON) + is_(col[("a", "b", "c")].type._type_affinity, JSON) def test_getindex_literal_integer(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) - self.assert_compile( - col[5], - "x -> :x_1", - checkparams={'x_1': 5} - ) + self.assert_compile(col[5], "x -> :x_1", checkparams={"x_1": 5}) def test_getindex_literal_string(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) self.assert_compile( - col['foo'], - "x -> :x_1", - checkparams={'x_1': 'foo'} + col["foo"], "x -> :x_1", checkparams={"x_1": "foo"} ) def test_path_getindex_literal(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) self.assert_compile( - col[('a', 'b', 3, 4, 'd')], + col[("a", "b", 3, 4, "d")], "x #> :x_1", - checkparams={'x_1': ('a', 'b', 3, 4, 'd')} + checkparams={"x_1": ("a", "b", 3, 4, "d")}, ) def test_getindex_sqlexpr(self): - col = Column('x', self.MyType()) - col2 = Column('y', Integer()) + col = Column("x", self.MyType()) + col2 = Column("y", Integer()) - self.assert_compile( - col[col2], - "x -> y", - checkparams={} - ) + self.assert_compile(col[col2], "x -> y", checkparams={}) def test_getindex_sqlexpr_right_grouping(self): - col = Column('x', self.MyType()) - col2 = Column('y', Integer()) + col = Column("x", self.MyType()) + col2 = Column("y", Integer()) self.assert_compile( - col[col2 + 8], - "x -> (y + :y_1)", - checkparams={'y_1': 8} + col[col2 + 8], "x -> (y + :y_1)", checkparams={"y_1": 8} ) def test_getindex_sqlexpr_left_grouping(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) - self.assert_compile( - col[8] != None, # noqa - "(x -> :x_1) IS NOT NULL" - ) + self.assert_compile(col[8] != None, "(x -> :x_1) IS NOT NULL") # noqa def test_getindex_sqlexpr_both_grouping(self): - col = Column('x', self.MyType()) - col2 = Column('y', Integer()) + col = Column("x", self.MyType()) + col2 = Column("y", Integer()) self.assert_compile( col[col2 + 8] != None, # noqa "(x -> (y + :y_1)) IS NOT NULL", - checkparams={'y_1': 8} + checkparams={"y_1": 8}, ) def test_override_operators(self): - special_index_op = operators.custom_op('$$>') + special_index_op = operators.custom_op("$$>") class MyOtherType(JSON, TypeEngine): - __visit_name__ = 'myothertype' + __visit_name__ = "myothertype" class Comparator(TypeEngine.Comparator): - def _adapt_expression(self, op, other_comparator): return special_index_op, MyOtherType() comparator_factory = Comparator - col = Column('x', MyOtherType()) - self.assert_compile( - col[5], - "x $$> :x_1", - checkparams={'x_1': 5} - ) + col = Column("x", MyOtherType()) + self.assert_compile(col[5], "x $$> :x_1", checkparams={"x_1": 5}) class ArrayIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): @@ -827,7 +737,7 @@ class ArrayIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): def visit_getitem_binary(self, binary, operator, **kw): return "%s[%s]" % ( self.process(binary.left, **kw), - self.process(binary.right, **kw) + self.process(binary.right, **kw), ) class MyDialect(default.DefaultDialect): @@ -835,7 +745,7 @@ class ArrayIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): type_compiler = MyTypeCompiler class MyType(ARRAY): - __visit_name__ = 'mytype' + __visit_name__ = "mytype" def __init__(self, zero_indexes=False, dimensions=1): if zero_indexes: @@ -850,148 +760,109 @@ class ArrayIndexOpTest(fixtures.TestBase, testing.AssertsCompiledSQL): """test the behavior of the _setup_getitem() method given a simple 'dimensions' scheme - this is identical to postgresql.ARRAY.""" - col = Column('x', self.MyType(dimensions=3)) + col = Column("x", self.MyType(dimensions=3)) - is_( - col[5].type._type_affinity, ARRAY - ) - eq_( - col[5].type.dimensions, 2 - ) - is_( - col[5][6].type._type_affinity, ARRAY - ) - eq_( - col[5][6].type.dimensions, 1 - ) - is_( - col[5][6][7].type._type_affinity, Integer - ) + is_(col[5].type._type_affinity, ARRAY) + eq_(col[5].type.dimensions, 2) + is_(col[5][6].type._type_affinity, ARRAY) + eq_(col[5][6].type.dimensions, 1) + is_(col[5][6][7].type._type_affinity, Integer) def test_getindex_literal(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) - self.assert_compile( - col[5], - "x[:x_1]", - checkparams={'x_1': 5} - ) + self.assert_compile(col[5], "x[:x_1]", checkparams={"x_1": 5}) def test_contains_override_raises(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) assert_raises_message( NotImplementedError, "Operator 'contains' is not supported on this expression", - lambda: 'foo' in col + lambda: "foo" in col, ) def test_getindex_sqlexpr(self): - col = Column('x', self.MyType()) - col2 = Column('y', Integer()) + col = Column("x", self.MyType()) + col2 = Column("y", Integer()) - self.assert_compile( - col[col2], - "x[y]", - checkparams={} - ) + self.assert_compile(col[col2], "x[y]", checkparams={}) self.assert_compile( - col[col2 + 8], - "x[(y + :y_1)]", - checkparams={'y_1': 8} + col[col2 + 8], "x[(y + :y_1)]", checkparams={"y_1": 8} ) def test_getslice_literal(self): - col = Column('x', self.MyType()) + col = Column("x", self.MyType()) self.assert_compile( - col[5:6], - "x[:x_1::x_2]", - checkparams={'x_1': 5, 'x_2': 6} + col[5:6], "x[:x_1::x_2]", checkparams={"x_1": 5, "x_2": 6} ) def test_getslice_sqlexpr(self): - col = Column('x', self.MyType()) - col2 = Column('y', Integer()) + col = Column("x", self.MyType()) + col2 = Column("y", Integer()) self.assert_compile( - col[col2:col2 + 5], - "x[y:y + :y_1]", - checkparams={'y_1': 5} + col[col2 : col2 + 5], "x[y:y + :y_1]", checkparams={"y_1": 5} ) def test_getindex_literal_zeroind(self): - col = Column('x', self.MyType(zero_indexes=True)) + col = Column("x", self.MyType(zero_indexes=True)) - self.assert_compile( - col[5], - "x[:x_1]", - checkparams={'x_1': 6} - ) + self.assert_compile(col[5], "x[:x_1]", checkparams={"x_1": 6}) def test_getindex_sqlexpr_zeroind(self): - col = Column('x', self.MyType(zero_indexes=True)) - col2 = Column('y', Integer()) + col = Column("x", self.MyType(zero_indexes=True)) + col2 = Column("y", Integer()) - self.assert_compile( - col[col2], - "x[(y + :y_1)]", - checkparams={'y_1': 1} - ) + self.assert_compile(col[col2], "x[(y + :y_1)]", checkparams={"y_1": 1}) self.assert_compile( col[col2 + 8], "x[(y + :y_1 + :param_1)]", - checkparams={'y_1': 8, 'param_1': 1} + checkparams={"y_1": 8, "param_1": 1}, ) def test_getslice_literal_zeroind(self): - col = Column('x', self.MyType(zero_indexes=True)) + col = Column("x", self.MyType(zero_indexes=True)) self.assert_compile( - col[5:6], - "x[:x_1::x_2]", - checkparams={'x_1': 6, 'x_2': 7} + col[5:6], "x[:x_1::x_2]", checkparams={"x_1": 6, "x_2": 7} ) def test_getslice_sqlexpr_zeroind(self): - col = Column('x', self.MyType(zero_indexes=True)) - col2 = Column('y', Integer()) + col = Column("x", self.MyType(zero_indexes=True)) + col2 = Column("y", Integer()) self.assert_compile( - col[col2:col2 + 5], + col[col2 : col2 + 5], "x[y + :y_1:y + :y_2 + :param_1]", - checkparams={'y_1': 1, 'y_2': 5, 'param_1': 1} + checkparams={"y_1": 1, "y_2": 5, "param_1": 1}, ) def test_override_operators(self): - special_index_op = operators.custom_op('->') + special_index_op = operators.custom_op("->") class MyOtherType(Indexable, TypeEngine): - __visit_name__ = 'myothertype' + __visit_name__ = "myothertype" class Comparator(TypeEngine.Comparator): - def _adapt_expression(self, op, other_comparator): return special_index_op, MyOtherType() comparator_factory = Comparator - col = Column('x', MyOtherType()) - self.assert_compile( - col[5], - "x -> :x_1", - checkparams={'x_1': 5} - ) + col = Column("x", MyOtherType()) + self.assert_compile(col[5], "x -> :x_1", checkparams={"x_1": 5}) class BooleanEvalTest(fixtures.TestBase, testing.AssertsCompiledSQL): @@ -1005,115 +876,101 @@ class BooleanEvalTest(fixtures.TestBase, testing.AssertsCompiledSQL): return d def test_one(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c]).where(c), "SELECT x WHERE x", - dialect=self._dialect(True) + dialect=self._dialect(True), ) def test_two_a(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c]).where(c), "SELECT x WHERE x = 1", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_two_b(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c], whereclause=c), "SELECT x WHERE x = 1", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_three_a(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c]).where(~c), "SELECT x WHERE x = 0", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_three_b(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c], whereclause=~c), "SELECT x WHERE x = 0", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_four(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c]).where(~c), "SELECT x WHERE NOT x", - dialect=self._dialect(True) + dialect=self._dialect(True), ) def test_five_a(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c]).having(c), "SELECT x HAVING x = 1", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_five_b(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( select([c], having=c), "SELECT x HAVING x = 1", - dialect=self._dialect(False) + dialect=self._dialect(False), ) def test_six(self): self.assert_compile( - or_(false(), true()), - "1 = 1", - dialect=self._dialect(False) + or_(false(), true()), "1 = 1", dialect=self._dialect(False) ) def test_eight(self): self.assert_compile( - and_(false(), true()), - "false", - dialect=self._dialect(True) + and_(false(), true()), "false", dialect=self._dialect(True) ) def test_nine(self): self.assert_compile( - and_(false(), true()), - "0 = 1", - dialect=self._dialect(False) + and_(false(), true()), "0 = 1", dialect=self._dialect(False) ) def test_ten(self): - c = column('x', Boolean) - self.assert_compile( - c == 1, - "x = :x_1", - dialect=self._dialect(False) - ) + c = column("x", Boolean) + self.assert_compile(c == 1, "x = :x_1", dialect=self._dialect(False)) def test_eleven(self): - c = column('x', Boolean) + c = column("x", Boolean) self.assert_compile( - c.is_(true()), - "x IS true", - dialect=self._dialect(True) + c.is_(true()), "x IS true", dialect=self._dialect(True) ) def test_twelve(self): - c = column('x', Boolean) + c = column("x", Boolean) # I don't have a solution for this one yet, # other than adding some heavy-handed conditionals # into compiler self.assert_compile( - c.is_(true()), - "x IS 1", - dialect=self._dialect(False) + c.is_(true()), "x IS 1", dialect=self._dialect(False) ) @@ -1121,6 +978,7 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): """test interaction of and_()/or_() with boolean , null constants """ + __dialect__ = default.DefaultDialect(supports_native_boolean=True) def test_one(self): @@ -1133,17 +991,14 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile(or_(and_()), "") def test_four(self): - x = column('x') + 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") - self.assert_compile( - and_(true()._ifnone(None), x == 7), - "x = :x_1" - ) + self.assert_compile(and_(true()._ifnone(None), x == 7), "x = :x_1") def test_six(self): x = column("x") @@ -1153,74 +1008,59 @@ 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") + self.assert_compile( + select([x]).where(or_(x == 7, true())), "SELECT x WHERE true" + ) self.assert_compile( - select( - [x]).where( - or_( - x == 7, - true())), + select([x]).where(or_(x == 7, true())), "SELECT x WHERE 1 = 1", - dialect=default.DefaultDialect( - supports_native_boolean=False)) + 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") - self.assert_compile( - and_(x == 7, x == 9, false(), x == 5), - "false" - ) - self.assert_compile( - ~and_(x == 7, x == 9, false(), x == 5), - "true" - ) + self.assert_compile(and_(x == 7, x == 9, false(), x == 5), "false") + self.assert_compile(~and_(x == 7, x == 9, false(), x == 5), "true") def test_ten(self): - self.assert_compile( - and_(None, None), - "NULL AND NULL" - ) + self.assert_compile(and_(None, None), "NULL AND NULL") def test_eleven(self): x = column("x") self.assert_compile( - select([x]).where(None).where(None), - "SELECT x WHERE NULL AND NULL" + select([x]).where(None).where(None), "SELECT x WHERE NULL AND NULL" ) def test_twelve(self): x = column("x") self.assert_compile( - select([x]).where(and_(None, None)), - "SELECT x WHERE NULL AND NULL" + select([x]).where(and_(None, None)), "SELECT x WHERE NULL AND NULL" ) def test_thirteen(self): x = column("x") self.assert_compile( select([x]).where(~and_(None, None)), - "SELECT x WHERE NOT (NULL AND NULL)" + "SELECT x WHERE NOT (NULL AND NULL)", ) def test_fourteen(self): x = column("x") self.assert_compile( - select([x]).where(~null()), - "SELECT x WHERE NOT NULL" + select([x]).where(~null()), "SELECT x WHERE NOT NULL" ) def test_constant_non_singleton(self): @@ -1230,537 +1070,560 @@ class ConjunctionTest(fixtures.TestBase, testing.AssertsCompiledSQL): def test_constant_render_distinct(self): self.assert_compile( - select([null(), null()]), - "SELECT NULL AS anon_1, NULL AS anon_2" + select([null(), null()]), "SELECT NULL AS anon_1, NULL AS anon_2" ) self.assert_compile( - select([true(), true()]), - "SELECT true AS anon_1, true AS anon_2" + select([true(), true()]), "SELECT true AS anon_1, true AS anon_2" ) self.assert_compile( select([false(), false()]), - "SELECT false AS anon_1, false AS anon_2" + "SELECT false AS anon_1, false AS anon_2", ) def test_is_true_literal(self): - c = column('x', Boolean) - self.assert_compile( - c.is_(True), - "x IS true" - ) + c = column("x", Boolean) + self.assert_compile(c.is_(True), "x IS true") def test_is_false_literal(self): - c = column('x', Boolean) - self.assert_compile( - c.is_(False), - "x IS false" - ) + c = column("x", Boolean) + self.assert_compile(c.is_(False), "x IS false") def test_and_false_literal_leading(self): - self.assert_compile( - and_(False, True), - "false" - ) + self.assert_compile(and_(False, True), "false") - self.assert_compile( - and_(False, False), - "false" - ) + self.assert_compile(and_(False, False), "false") def test_and_true_literal_leading(self): - self.assert_compile( - and_(True, True), - "true" - ) + self.assert_compile(and_(True, True), "true") - self.assert_compile( - and_(True, False), - "false" - ) + self.assert_compile(and_(True, False), "false") def test_or_false_literal_leading(self): - self.assert_compile( - or_(False, True), - "true" - ) + self.assert_compile(or_(False, True), "true") - self.assert_compile( - or_(False, False), - "false" - ) + self.assert_compile(or_(False, False), "false") def test_or_true_literal_leading(self): - self.assert_compile( - or_(True, True), - "true" - ) + self.assert_compile(or_(True, True), "true") - self.assert_compile( - or_(True, False), - "true" - ) + self.assert_compile(or_(True, False), "true") class OperatorPrecedenceTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), - ) + table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), + ) - table2 = table('op', column('field')) + table2 = table("op", column("field")) def test_operator_precedence_1(self): self.assert_compile( self.table2.select((self.table2.c.field == 5) == None), # noqa - "SELECT op.field FROM op WHERE (op.field = :field_1) IS NULL") + "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), - "SELECT op.field FROM op WHERE op.field + :field_1 = op.field") + (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), - "SELECT op.field FROM op WHERE (op.field + :field_1) * :param_1") + "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), - "SELECT op.field FROM op WHERE op.field * :field_1 + :param_1") + 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))") + 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))", + ) def test_operator_precedence_6(self): - self.assert_compile(self.table2.select( - (5 + self.table2.c.field).in_([5, 6])), + self.assert_compile( + self.table2.select((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))), + self.assert_compile( + self.table2.select( + 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)), - "SELECT op.field FROM op WHERE op.field != :field_1") + 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))), + self.assert_compile( + self.table2.select(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), - "SELECT op.field FROM op WHERE (NOT op.field) = :param_1") + 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.assert_compile( + self.table2.select( + (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)), + self.assert_compile( + self.table2.select( + 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)), - "SELECT op.field FROM op WHERE (op.field MATCH op.field) IS NULL") + 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): self.assert_compile( - self.table1.c.name == literal('foo').collate('utf-8'), - 'mytable.name = (:param_1 COLLATE "utf-8")' + self.table1.c.name == literal("foo").collate("utf-8"), + 'mytable.name = (:param_1 COLLATE "utf-8")', ) def test_operator_precedence_collate_2(self): self.assert_compile( - (self.table1.c.name == literal('foo')).collate('utf-8'), - 'mytable.name = :param_1 COLLATE "utf-8"' + (self.table1.c.name == literal("foo")).collate("utf-8"), + 'mytable.name = :param_1 COLLATE "utf-8"', ) def test_operator_precedence_collate_3(self): self.assert_compile( - self.table1.c.name.collate('utf-8') == 'foo', - '(mytable.name COLLATE "utf-8") = :param_1' + self.table1.c.name.collate("utf-8") == "foo", + '(mytable.name COLLATE "utf-8") = :param_1', ) def test_operator_precedence_collate_4(self): self.assert_compile( and_( - (self.table1.c.name == literal('foo')).collate('utf-8'), - (self.table2.c.field == literal('bar')).collate('utf-8'), + (self.table1.c.name == literal("foo")).collate("utf-8"), + (self.table2.c.field == literal("bar")).collate("utf-8"), ), 'mytable.name = :param_1 COLLATE "utf-8" ' - 'AND op.field = :param_2 COLLATE "utf-8"' + 'AND op.field = :param_2 COLLATE "utf-8"', ) 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' + 'ORDER BY mytable.name COLLATE "utf-8" DESC', ) 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' + 'ORDER BY mytable.name COLLATE "utf-8" DESC NULLS LAST', ) 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' + '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" + ":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), + 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): self.assert_compile( - func.foo(self.table1.c.myid.op('hoho')(12)), - "foo(mytable.myid hoho :myid_1)" + func.foo(self.table1.c.myid.op("hoho")(12)), + "foo(mytable.myid hoho :myid_1)", ) def test_op_operators_comparison_precedence(self): self.assert_compile( - self.table1.c.myid.op('hoho')(12) == 5, - "(mytable.myid hoho :myid_1) = :param_1" + self.table1.c.myid.op("hoho")(12) == 5, + "(mytable.myid hoho :myid_1) = :param_1", ) def test_op_operators_custom_precedence(self): - op1 = self.table1.c.myid.op('hoho', precedence=5) - op2 = op1(5).op('lala', precedence=4)(4) - op3 = op1(5).op('lala', precedence=6)(4) + op1 = self.table1.c.myid.op("hoho", precedence=5) + op2 = op1(5).op("lala", precedence=4)(4) + op3 = op1(5).op("lala", precedence=6)(4) self.assert_compile(op2, "mytable.myid hoho :myid_1 lala :param_1") self.assert_compile(op3, "(mytable.myid hoho :myid_1) lala :param_1") def test_is_eq_precedence_flat(self): self.assert_compile( - (self.table1.c.name == null()) != - (self.table1.c.description == null()), + (self.table1.c.name == null()) + != (self.table1.c.description == null()), "(mytable.name IS NULL) != (mytable.description IS NULL)", ) class OperatorAssociativityTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_associativity_1(self): - f = column('f') + f = column("f") self.assert_compile(f - f, "f - f") def test_associativity_2(self): - f = column('f') + f = column("f") self.assert_compile(f - f - f, "(f - f) - f") def test_associativity_3(self): - f = column('f') + f = column("f") self.assert_compile((f - f) - f, "(f - f) - f") def test_associativity_4(self): - f = column('f') - self.assert_compile((f - f).label('foo') - f, "(f - f) - f") + f = column("f") + self.assert_compile((f - f).label("foo") - f, "(f - f) - f") def test_associativity_5(self): - f = column('f') + f = column("f") self.assert_compile(f - (f - f), "f - (f - f)") def test_associativity_6(self): - f = column('f') - self.assert_compile(f - (f - f).label('foo'), "f - (f - f)") + f = column("f") + self.assert_compile(f - (f - f).label("foo"), "f - (f - f)") def test_associativity_7(self): - f = column('f') + f = column("f") # because - less precedent than / self.assert_compile(f / (f - f), "f / (f - f)") def test_associativity_8(self): - f = column('f') - self.assert_compile(f / (f - f).label('foo'), "f / (f - f)") + f = column("f") + self.assert_compile(f / (f - f).label("foo"), "f / (f - f)") def test_associativity_9(self): - f = column('f') + f = column("f") self.assert_compile(f / f - f, "f / f - f") def test_associativity_10(self): - f = column('f') + f = column("f") self.assert_compile((f / f) - f, "f / f - f") def test_associativity_11(self): - f = column('f') - self.assert_compile((f / f).label('foo') - f, "f / f - f") + f = column("f") + self.assert_compile((f / f).label("foo") - f, "f / f - f") def test_associativity_12(self): - f = column('f') + f = column("f") # because / more precedent than - self.assert_compile(f - (f / f), "f - f / f") def test_associativity_13(self): - f = column('f') - self.assert_compile(f - (f / f).label('foo'), "f - f / f") + f = column("f") + self.assert_compile(f - (f / f).label("foo"), "f - f / f") def test_associativity_14(self): - f = column('f') + f = column("f") self.assert_compile(f - f / f, "f - f / f") def test_associativity_15(self): - f = column('f') + f = column("f") self.assert_compile((f - f) / f, "(f - f) / f") def test_associativity_16(self): - f = column('f') + f = column("f") self.assert_compile(((f - f) / f) - f, "(f - f) / f - f") def test_associativity_17(self): - f = column('f') + f = column("f") # - lower precedence than / self.assert_compile((f - f) / (f - f), "(f - f) / (f - f)") def test_associativity_18(self): - f = column('f') + f = column("f") # / higher precedence than - self.assert_compile((f / f) - (f / f), "f / f - f / f") def test_associativity_19(self): - f = column('f') + f = column("f") self.assert_compile((f / f) - (f - f), "f / f - (f - f)") def test_associativity_20(self): - f = column('f') + f = column("f") self.assert_compile((f / f) / (f - f), "(f / f) / (f - f)") def test_associativity_21(self): - f = column('f') + f = column("f") self.assert_compile(f / (f / (f - f)), "f / (f / (f - f))") def test_associativity_22(self): - f = column('f') - self.assert_compile((f == f) == f, '(f = f) = f') + f = column("f") + self.assert_compile((f == f) == f, "(f = f) = f") def test_associativity_23(self): - f = column('f') - self.assert_compile((f != f) != f, '(f != f) != f') + f = column("f") + self.assert_compile((f != f) != f, "(f != f) != f") class IsDistinctFromTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - ) + table1 = table("mytable", column("myid", Integer)) def test_is_distinct_from(self): - self.assert_compile(self.table1.c.myid.is_distinct_from(1), - "mytable.myid IS DISTINCT FROM :myid_1") + self.assert_compile( + self.table1.c.myid.is_distinct_from(1), + "mytable.myid IS DISTINCT FROM :myid_1", + ) def test_is_distinct_from_sqlite(self): - self.assert_compile(self.table1.c.myid.is_distinct_from(1), - "mytable.myid IS NOT ?", - dialect=sqlite.dialect()) + self.assert_compile( + self.table1.c.myid.is_distinct_from(1), + "mytable.myid IS NOT ?", + dialect=sqlite.dialect(), + ) def test_is_distinct_from_postgresql(self): - self.assert_compile(self.table1.c.myid.is_distinct_from(1), - "mytable.myid IS DISTINCT FROM %(myid_1)s", - dialect=postgresql.dialect()) + self.assert_compile( + self.table1.c.myid.is_distinct_from(1), + "mytable.myid IS DISTINCT FROM %(myid_1)s", + dialect=postgresql.dialect(), + ) def test_not_is_distinct_from(self): - self.assert_compile(~self.table1.c.myid.is_distinct_from(1), - "mytable.myid IS NOT DISTINCT FROM :myid_1") + self.assert_compile( + ~self.table1.c.myid.is_distinct_from(1), + "mytable.myid IS NOT DISTINCT FROM :myid_1", + ) def test_not_is_distinct_from_postgresql(self): - self.assert_compile(~self.table1.c.myid.is_distinct_from(1), - "mytable.myid IS NOT DISTINCT FROM %(myid_1)s", - dialect=postgresql.dialect()) + self.assert_compile( + ~self.table1.c.myid.is_distinct_from(1), + "mytable.myid IS NOT DISTINCT FROM %(myid_1)s", + dialect=postgresql.dialect(), + ) def test_isnot_distinct_from(self): - self.assert_compile(self.table1.c.myid.isnot_distinct_from(1), - "mytable.myid IS NOT DISTINCT FROM :myid_1") + self.assert_compile( + self.table1.c.myid.isnot_distinct_from(1), + "mytable.myid IS NOT DISTINCT FROM :myid_1", + ) def test_isnot_distinct_from_sqlite(self): - self.assert_compile(self.table1.c.myid.isnot_distinct_from(1), - "mytable.myid IS ?", - dialect=sqlite.dialect()) + self.assert_compile( + self.table1.c.myid.isnot_distinct_from(1), + "mytable.myid IS ?", + dialect=sqlite.dialect(), + ) def test_isnot_distinct_from_postgresql(self): - self.assert_compile(self.table1.c.myid.isnot_distinct_from(1), - "mytable.myid IS NOT DISTINCT FROM %(myid_1)s", - dialect=postgresql.dialect()) + self.assert_compile( + self.table1.c.myid.isnot_distinct_from(1), + "mytable.myid IS NOT DISTINCT FROM %(myid_1)s", + dialect=postgresql.dialect(), + ) def test_not_isnot_distinct_from(self): - self.assert_compile(~self.table1.c.myid.isnot_distinct_from(1), - "mytable.myid IS DISTINCT FROM :myid_1") + self.assert_compile( + ~self.table1.c.myid.isnot_distinct_from(1), + "mytable.myid IS DISTINCT FROM :myid_1", + ) def test_not_isnot_distinct_from_postgresql(self): - self.assert_compile(~self.table1.c.myid.isnot_distinct_from(1), - "mytable.myid IS DISTINCT FROM %(myid_1)s", - dialect=postgresql.dialect()) + self.assert_compile( + ~self.table1.c.myid.isnot_distinct_from(1), + "mytable.myid IS DISTINCT FROM %(myid_1)s", + dialect=postgresql.dialect(), + ) class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - ) + table1 = table("mytable", column("myid", Integer)) table2 = table( - 'myothertable', - column('otherid', Integer), - column('othername', String) + "myothertable", column("otherid", Integer), column("othername", String) ) def _dialect(self, empty_in_strategy="static"): - return default.DefaultDialect( - empty_in_strategy=empty_in_strategy - ) + return default.DefaultDialect(empty_in_strategy=empty_in_strategy) def test_in_1(self): - self.assert_compile(self.table1.c.myid.in_(['a']), - "mytable.myid IN (:myid_1)") + self.assert_compile( + self.table1.c.myid.in_(["a"]), "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)") + self.assert_compile( + ~self.table1.c.myid.in_(["a"]), "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)") + self.assert_compile( + self.table1.c.myid.in_(["a", "b"]), + "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)") + self.assert_compile( + self.table1.c.myid.in_(iter(["a", "b"])), + "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)") + self.assert_compile( + self.table1.c.myid.in_([literal("a")]), + "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)") + self.assert_compile( + self.table1.c.myid.in_([literal("a"), "b"]), + "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)") + self.assert_compile( + self.table1.c.myid.in_(["a", literal("b")]), + "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)") + self.assert_compile( + self.table1.c.myid.in_([literal(1) + "a"]), + "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)") + self.assert_compile( + self.table1.c.myid.in_([literal("a") + "a", "b"]), + "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)") + [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)") + self.assert_compile( + self.table1.c.myid.in_([1, literal(3) + 4]), + "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)") + self.assert_compile( + self.table1.c.myid.in_([literal("a") < "b"]), + "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)") + self.assert_compile( + self.table1.c.myid.in_([self.table1.c.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)") + self.assert_compile( + self.table1.c.myid.in_(["a", self.table1.c.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.assert_compile( + self.table1.c.myid.in_([literal("a"), 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.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.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)") + self.assert_compile( + self.table1.c.myid.in_([1, 2, 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)") + self.assert_compile( + self.table1.c.myid.in_(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])), + self.assert_compile( + ~self.table1.c.myid.in_(select([self.table2.c.otherid])), "mytable.myid NOT IN " - "(SELECT myothertable.otherid FROM myothertable)") + "(SELECT myothertable.otherid FROM myothertable)", + ) def test_in_22(self): self.assert_compile( @@ -1768,49 +1631,64 @@ class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): text("SELECT myothertable.otherid FROM myothertable") ), "mytable.myid IN (SELECT myothertable.otherid " - "FROM myothertable)" + "FROM myothertable)", ) 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.table1.c.myid.in_( + 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), - ) - ), "mytable.myid IN (" + 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), + ) + ), + "mytable.myid IN (" "SELECT mytable.myid FROM mytable WHERE mytable.myid = :myid_1 " "UNION SELECT mytable.myid FROM mytable " - "WHERE mytable.myid = :myid_2)") + "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) - ), - from_obj=[self.table1.join( - self.table2, - self.table1.c.myid == self.table2.c.otherid)], - order_by=[self.table1.c.myid] + 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, + ) + ), + from_obj=[ + self.table1.join( + self.table2, + self.table1.c.myid == self.table2.c.otherid, + ) + ], + order_by=[self.table1.c.myid], ), "SELECT mytable.myid, " "myothertable.otherid, myothertable.othername FROM mytable " @@ -1818,115 +1696,127 @@ class InTest(fixtures.TestBase, testing.AssertsCompiledSQL): "WHERE myothertable.otherid IN (SELECT myothertable.otherid " "FROM myothertable ORDER BY myothertable.othername " "LIMIT :param_1) ORDER BY mytable.myid", - {'param_1': 10} + {"param_1": 10}, ) def test_in_28(self): self.assert_compile( - self.table1.c.myid.in_([None]), - "mytable.myid IN (NULL)" + self.table1.c.myid.in_([None]), "mytable.myid IN (NULL)" ) def test_empty_in_dynamic_1(self): - self.assert_compile(self.table1.c.myid.in_([]), - "mytable.myid != mytable.myid", - dialect=self._dialect("dynamic")) + self.assert_compile( + self.table1.c.myid.in_([]), + "mytable.myid != mytable.myid", + dialect=self._dialect("dynamic"), + ) def test_empty_in_dynamic_2(self): - self.assert_compile(self.table1.c.myid.notin_([]), - "mytable.myid = mytable.myid", - dialect=self._dialect("dynamic")) + self.assert_compile( + self.table1.c.myid.notin_([]), + "mytable.myid = mytable.myid", + dialect=self._dialect("dynamic"), + ) def test_empty_in_dynamic_3(self): - self.assert_compile(~self.table1.c.myid.in_([]), - "mytable.myid = mytable.myid", - dialect=self._dialect("dynamic")) + self.assert_compile( + ~self.table1.c.myid.in_([]), + "mytable.myid = mytable.myid", + dialect=self._dialect("dynamic"), + ) def test_empty_in_dynamic_warn_1(self): with testing.expect_warnings( - "The IN-predicate was invoked with an empty sequence."): - self.assert_compile(self.table1.c.myid.in_([]), - "mytable.myid != mytable.myid", - dialect=self._dialect("dynamic_warn")) + "The IN-predicate was invoked with an empty sequence." + ): + self.assert_compile( + self.table1.c.myid.in_([]), + "mytable.myid != mytable.myid", + dialect=self._dialect("dynamic_warn"), + ) def test_empty_in_dynamic_warn_2(self): with testing.expect_warnings( - "The IN-predicate was invoked with an empty sequence."): - self.assert_compile(self.table1.c.myid.notin_([]), - "mytable.myid = mytable.myid", - dialect=self._dialect("dynamic_warn")) + "The IN-predicate was invoked with an empty sequence." + ): + self.assert_compile( + self.table1.c.myid.notin_([]), + "mytable.myid = mytable.myid", + dialect=self._dialect("dynamic_warn"), + ) def test_empty_in_dynamic_warn_3(self): with testing.expect_warnings( - "The IN-predicate was invoked with an empty sequence."): - self.assert_compile(~self.table1.c.myid.in_([]), - "mytable.myid = mytable.myid", - dialect=self._dialect("dynamic_warn")) + "The IN-predicate was invoked with an empty sequence." + ): + self.assert_compile( + ~self.table1.c.myid.in_([]), + "mytable.myid = mytable.myid", + dialect=self._dialect("dynamic_warn"), + ) def test_empty_in_static_1(self): - self.assert_compile(self.table1.c.myid.in_([]), - "1 != 1") + self.assert_compile(self.table1.c.myid.in_([]), "1 != 1") def test_empty_in_static_2(self): - self.assert_compile(self.table1.c.myid.notin_([]), - "1 = 1") + self.assert_compile(self.table1.c.myid.notin_([]), "1 = 1") def test_empty_in_static_3(self): - self.assert_compile(~self.table1.c.myid.in_([]), - "1 = 1") + self.assert_compile(~self.table1.c.myid.in_([]), "1 = 1") class MathOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - ) + table1 = table("mytable", column("myid", Integer)) def _test_math_op(self, py_op, sql_op): for (lhs, rhs, res) in ( - (5, self.table1.c.myid, ':myid_1 %s mytable.myid'), - (5, literal(5), ':param_1 %s :param_2'), - (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'), - (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'), + (5, self.table1.c.myid, ":myid_1 %s mytable.myid"), + (5, literal(5), ":param_1 %s :param_2"), + (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", + ), + (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): - self._test_math_op(operator.add, '+') + self._test_math_op(operator.add, "+") def test_math_op_mul(self): - self._test_math_op(operator.mul, '*') + self._test_math_op(operator.mul, "*") def test_math_op_sub(self): - self._test_math_op(operator.sub, '-') + self._test_math_op(operator.sub, "-") def test_math_op_div(self): if util.py3k: - self._test_math_op(operator.truediv, '/') + self._test_math_op(operator.truediv, "/") else: - self._test_math_op(operator.div, '/') + self._test_math_op(operator.div, "/") def test_math_op_mod(self): - self._test_math_op(operator.mod, '%') + self._test_math_op(operator.mod, "%") class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - ) + table1 = table("mytable", 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') + clause = ( + (self.table1.c.myid == 12) + & 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): @@ -1936,17 +1826,21 @@ class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): def _test_comparison_op(self, py_op, fwd_op, rev_op): dt = datetime.datetime(2012, 5, 10, 15, 27, 18) for (lhs, rhs, l_sql, r_sql) in ( - ('a', self.table1.c.myid, ':myid_1', 'mytable.myid'), - ('a', literal('b'), ':param_2', ':param_1'), # note swap! - (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'), - (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'), + ("a", self.table1.c.myid, ":myid_1", "mytable.myid"), + ("a", literal("b"), ":param_2", ":param_1"), # note swap! + (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", + ), + (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.): @@ -1955,36 +1849,43 @@ class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL): fwd_sql = "%s %s %s" % (l_sql, fwd_op, r_sql) rev_sql = "%s %s %s" % (r_sql, rev_op, l_sql) - self.assert_(compiled == fwd_sql or compiled == rev_sql, - "\n'" + compiled + "'\n does not match\n'" + - fwd_sql + "'\n or\n'" + rev_sql + "'") + self.assert_( + compiled == fwd_sql or compiled == rev_sql, + "\n'" + + compiled + + "'\n does not match\n'" + + fwd_sql + + "'\n or\n'" + + rev_sql + + "'", + ) def test_comparison_operators_lt(self): - self._test_comparison_op(operator.lt, '<', '>'), + self._test_comparison_op(operator.lt, "<", ">"), def test_comparison_operators_gt(self): - self._test_comparison_op(operator.gt, '>', '<') + self._test_comparison_op(operator.gt, ">", "<") def test_comparison_operators_eq(self): - self._test_comparison_op(operator.eq, '=', '=') + self._test_comparison_op(operator.eq, "=", "=") def test_comparison_operators_ne(self): - self._test_comparison_op(operator.ne, '!=', '!=') + self._test_comparison_op(operator.ne, "!=", "!=") def test_comparison_operators_le(self): - self._test_comparison_op(operator.le, '<=', '>=') + self._test_comparison_op(operator.le, "<=", ">=") def test_comparison_operators_ge(self): - self._test_comparison_op(operator.ge, '>=', '<=') + self._test_comparison_op(operator.ge, ">=", "<=") class NonZeroTest(fixtures.TestBase): - def _raises(self, expr): assert_raises_message( TypeError, "Boolean value of this clause is not defined", - bool, expr + bool, + expr, ) def _assert_true(self, expr): @@ -1994,57 +1895,51 @@ class NonZeroTest(fixtures.TestBase): is_(bool(expr), False) def test_column_identity_eq(self): - c1 = column('c1') + c1 = column("c1") self._assert_true(c1 == c1) def test_column_identity_gt(self): - c1 = column('c1') + c1 = column("c1") self._raises(c1 > c1) def test_column_compare_eq(self): - c1, c2 = column('c1'), column('c2') + c1, c2 = column("c1"), column("c2") self._assert_false(c1 == c2) def test_column_compare_gt(self): - c1, c2 = column('c1'), column('c2') + c1, c2 = column("c1"), column("c2") self._raises(c1 > c2) def test_binary_identity_eq(self): - c1 = column('c1') + c1 = column("c1") expr = c1 > 5 self._assert_true(expr == expr) def test_labeled_binary_identity_eq(self): - c1 = column('c1') + c1 = column("c1") expr = (c1 > 5).label(None) self._assert_true(expr == expr) def test_annotated_binary_identity_eq(self): - c1 = column('c1') - expr1 = (c1 > 5) + c1 = column("c1") + expr1 = c1 > 5 expr2 = expr1._annotate({"foo": "bar"}) self._assert_true(expr1 == expr2) def test_labeled_binary_compare_gt(self): - c1 = column('c1') + c1 = column("c1") expr1 = (c1 > 5).label(None) expr2 = (c1 > 5).label(None) self._assert_false(expr1 == expr2) class NegationTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + table1 = table("mytable", column("myid", Integer), column("name", String)) def test_negate_operators_1(self): - for (py_op, op) in ( - (operator.neg, '-'), - (operator.inv, 'NOT '), - ): + for (py_op, op) in ((operator.neg, "-"), (operator.inv, "NOT ")): for expr, expected in ( (self.table1.c.myid, "mytable.myid"), (literal("foo"), ":param_1"), @@ -2053,72 +1948,80 @@ 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')), + 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" + "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'))), + 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" + "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')), + 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)" + "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), + (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") + "mytable WHERE mytable.myid != :myid_1 AND NOT mytable.name", + ) def test_negate_operator_type(self): - is_( - (-self.table1.c.myid).type, - self.table1.c.myid.type, - ) + is_((-self.table1.c.myid).type, self.table1.c.myid.type) def test_negate_operator_label(self): orig_expr = or_( - self.table1.c.myid == 1, self.table1.c.myid == 2).label('foo') + self.table1.c.myid == 1, self.table1.c.myid == 2 + ).label("foo") expr = not_(orig_expr) isinstance(expr, Label) - eq_(expr.name, 'foo') + eq_(expr.name, "foo") is_not_(expr, orig_expr) is_(expr._element.operator, operator.inv) # e.g. and not false_ self.assert_compile( expr, "NOT (mytable.myid = :myid_1 OR mytable.myid = :myid_2)", - dialect=default.DefaultDialect(supports_native_boolean=False) + dialect=default.DefaultDialect(supports_native_boolean=False), ) def test_negate_operator_self_group(self): orig_expr = or_( - self.table1.c.myid == 1, self.table1.c.myid == 2).self_group() + self.table1.c.myid == 1, self.table1.c.myid == 2 + ).self_group() expr = not_(orig_expr) is_not_(expr, orig_expr) self.assert_compile( expr, "NOT (mytable.myid = :myid_1 OR mytable.myid = :myid_2)", - dialect=default.DefaultDialect(supports_native_boolean=False) + dialect=default.DefaultDialect(supports_native_boolean=False), ) def test_implicitly_boolean(self): @@ -2127,569 +2030,585 @@ class NegationTest(fixtures.TestBase, testing.AssertsCompiledSQL): assert not self.table1.c.myid._is_implicitly_boolean assert (self.table1.c.myid == 5)._is_implicitly_boolean assert (self.table1.c.myid == 5).self_group()._is_implicitly_boolean - assert (self.table1.c.myid == 5).label('x')._is_implicitly_boolean + assert (self.table1.c.myid == 5).label("x")._is_implicitly_boolean assert not_(self.table1.c.myid == 5)._is_implicitly_boolean assert or_( self.table1.c.myid == 5, self.table1.c.myid == 7 )._is_implicitly_boolean - assert not column('x', Boolean)._is_implicitly_boolean + assert not column("x", Boolean)._is_implicitly_boolean assert not (self.table1.c.myid + 5)._is_implicitly_boolean - assert not not_(column('x', Boolean))._is_implicitly_boolean - assert not select([self.table1.c.myid]).\ - as_scalar()._is_implicitly_boolean + assert not not_(column("x", Boolean))._is_implicitly_boolean + assert ( + not select([self.table1.c.myid]).as_scalar()._is_implicitly_boolean + ) assert not text("x = y")._is_implicitly_boolean assert not literal_column("x = y")._is_implicitly_boolean class LikeTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + table1 = table("mytable", 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='\\'), + self.table1.c.myid.ilike("somstr", escape="\\"), "mytable.myid ILIKE %(myid_1)s ESCAPE '\\\\'", - dialect=postgresql.dialect()) + dialect=postgresql.dialect(), + ) def test_like_8(self): self.assert_compile( - ~self.table1.c.myid.ilike('somstr', escape='\\'), + ~self.table1.c.myid.ilike("somstr", escape="\\"), "mytable.myid NOT ILIKE %(myid_1)s ESCAPE '\\\\'", - dialect=postgresql.dialect()) + 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%'), + self.table1.c.name.ilike("%something%"), "mytable.name ILIKE %(name_1)s", - dialect=postgresql.dialect()) + 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%'), + ~self.table1.c.name.ilike("%something%"), "mytable.name NOT ILIKE %(name_1)s", - dialect=postgresql.dialect()) + dialect=postgresql.dialect(), + ) class BetweenTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + table1 = table("mytable", 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") + "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") + "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") + "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") + "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") + "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") + "mytable.myid NOT BETWEEN SYMMETRIC :myid_1 AND :myid_2", + ) class MatchTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" - table1 = table('mytable', - column('myid', Integer), - column('name', String), - ) + table1 = table("mytable", 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()) + self.assert_compile( + self.table1.c.myid.match("somstr"), + "mytable.myid MATCH ?", + dialect=sqlite.dialect(), + ) def test_match_2(self): self.assert_compile( - self.table1.c.myid.match('somstr'), + self.table1.c.myid.match("somstr"), "MATCH (mytable.myid) AGAINST (%s IN BOOLEAN MODE)", - dialect=mysql.dialect()) + 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()) + self.assert_compile( + self.table1.c.myid.match("somstr"), + "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()) + self.assert_compile( + self.table1.c.myid.match("somstr"), + "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()) + self.assert_compile( + self.table1.c.myid.match("somstr"), + "CONTAINS (mytable.myid, :myid_1)", + dialect=oracle.dialect(), + ) def test_match_is_now_matchtype(self): - expr = self.table1.c.myid.match('somstr') + expr = self.table1.c.myid.match("somstr") assert expr.type._type_affinity is MatchType()._type_affinity assert isinstance(expr.type, MatchType) def test_boolean_inversion_postgresql(self): self.assert_compile( - ~self.table1.c.myid.match('somstr'), + ~self.table1.c.myid.match("somstr"), "NOT mytable.myid @@ to_tsquery(%(myid_1)s)", - dialect=postgresql.dialect()) + dialect=postgresql.dialect(), + ) def test_boolean_inversion_mysql(self): # because mysql doesnt have native boolean self.assert_compile( - ~self.table1.c.myid.match('somstr'), + ~self.table1.c.myid.match("somstr"), "NOT MATCH (mytable.myid) AGAINST (%s IN BOOLEAN MODE)", - dialect=mysql.dialect()) + dialect=mysql.dialect(), + ) def test_boolean_inversion_mssql(self): # because mssql doesnt have native boolean self.assert_compile( - ~self.table1.c.myid.match('somstr'), + ~self.table1.c.myid.match("somstr"), "NOT CONTAINS (mytable.myid, :myid_1)", - dialect=mssql.dialect()) + dialect=mssql.dialect(), + ) class ComposedLikeOperatorsTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_contains(self): self.assert_compile( - column('x').contains('y'), + column("x").contains("y"), "x LIKE '%' || :x_1 || '%'", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_contains_escape(self): self.assert_compile( - column('x').contains('a%b_c', escape='\\'), + column("x").contains("a%b_c", escape="\\"), "x LIKE '%' || :x_1 || '%' ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_contains_autoescape(self): self.assert_compile( - column('x').contains('a%b_c/d', autoescape=True), + column("x").contains("a%b_c/d", autoescape=True), "x LIKE '%' || :x_1 || '%' ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_contains_literal(self): self.assert_compile( - column('x').contains(literal_column('y')), + column("x").contains(literal_column("y")), "x LIKE '%' || y || '%'", - checkparams={} + checkparams={}, ) def test_contains_text(self): self.assert_compile( - column('x').contains(text('y')), + column("x").contains(text("y")), "x LIKE '%' || y || '%'", - checkparams={} + checkparams={}, ) def test_not_contains(self): self.assert_compile( - ~column('x').contains('y'), + ~column("x").contains("y"), "x NOT LIKE '%' || :x_1 || '%'", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_not_contains_escape(self): self.assert_compile( - ~column('x').contains('a%b_c', escape='\\'), + ~column("x").contains("a%b_c", escape="\\"), "x NOT LIKE '%' || :x_1 || '%' ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_not_contains_autoescape(self): self.assert_compile( - ~column('x').contains('a%b_c/d', autoescape=True), + ~column("x").contains("a%b_c/d", autoescape=True), "x NOT LIKE '%' || :x_1 || '%' ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_contains_concat(self): self.assert_compile( - column('x').contains('y'), + column("x").contains("y"), "x LIKE concat(concat('%%', %s), '%%')", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_not_contains_concat(self): self.assert_compile( - ~column('x').contains('y'), + ~column("x").contains("y"), "x NOT LIKE concat(concat('%%', %s), '%%')", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_contains_literal_concat(self): self.assert_compile( - column('x').contains(literal_column('y')), + column("x").contains(literal_column("y")), "x LIKE concat(concat('%%', y), '%%')", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) def test_contains_text_concat(self): self.assert_compile( - column('x').contains(text('y')), + column("x").contains(text("y")), "x LIKE concat(concat('%%', y), '%%')", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) def test_like(self): self.assert_compile( - column('x').like('y'), - "x LIKE :x_1", - checkparams={'x_1': 'y'} + column("x").like("y"), "x LIKE :x_1", checkparams={"x_1": "y"} ) def test_like_escape(self): self.assert_compile( - column('x').like('a%b_c', escape='\\'), + column("x").like("a%b_c", escape="\\"), "x LIKE :x_1 ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_ilike(self): self.assert_compile( - column('x').ilike('y'), + column("x").ilike("y"), "lower(x) LIKE lower(:x_1)", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_ilike_escape(self): self.assert_compile( - column('x').ilike('a%b_c', escape='\\'), + column("x").ilike("a%b_c", escape="\\"), "lower(x) LIKE lower(:x_1) ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_notlike(self): self.assert_compile( - column('x').notlike('y'), + column("x").notlike("y"), "x NOT LIKE :x_1", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_notlike_escape(self): self.assert_compile( - column('x').notlike('a%b_c', escape='\\'), + column("x").notlike("a%b_c", escape="\\"), "x NOT LIKE :x_1 ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_notilike(self): self.assert_compile( - column('x').notilike('y'), + column("x").notilike("y"), "lower(x) NOT LIKE lower(:x_1)", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_notilike_escape(self): self.assert_compile( - column('x').notilike('a%b_c', escape='\\'), + column("x").notilike("a%b_c", escape="\\"), "lower(x) NOT LIKE lower(:x_1) ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_startswith(self): self.assert_compile( - column('x').startswith('y'), + column("x").startswith("y"), "x LIKE :x_1 || '%'", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_startswith_escape(self): self.assert_compile( - column('x').startswith('a%b_c', escape='\\'), + column("x").startswith("a%b_c", escape="\\"), "x LIKE :x_1 || '%' ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_startswith_autoescape(self): self.assert_compile( - column('x').startswith('a%b_c/d', autoescape=True), + column("x").startswith("a%b_c/d", autoescape=True), "x LIKE :x_1 || '%' ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_startswith_autoescape_custom_escape(self): self.assert_compile( - column('x').startswith('a%b_c/d^e', autoescape=True, escape='^'), + column("x").startswith("a%b_c/d^e", autoescape=True, escape="^"), "x LIKE :x_1 || '%' ESCAPE '^'", - checkparams={'x_1': 'a^%b^_c/d^^e'} + checkparams={"x_1": "a^%b^_c/d^^e"}, ) def test_not_startswith(self): self.assert_compile( - ~column('x').startswith('y'), + ~column("x").startswith("y"), "x NOT LIKE :x_1 || '%'", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_not_startswith_escape(self): self.assert_compile( - ~column('x').startswith('a%b_c', escape='\\'), + ~column("x").startswith("a%b_c", escape="\\"), "x NOT LIKE :x_1 || '%' ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_not_startswith_autoescape(self): self.assert_compile( - ~column('x').startswith('a%b_c/d', autoescape=True), + ~column("x").startswith("a%b_c/d", autoescape=True), "x NOT LIKE :x_1 || '%' ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_startswith_literal(self): self.assert_compile( - column('x').startswith(literal_column('y')), + column("x").startswith(literal_column("y")), "x LIKE y || '%'", - checkparams={} + checkparams={}, ) def test_startswith_text(self): self.assert_compile( - column('x').startswith(text('y')), + column("x").startswith(text("y")), "x LIKE y || '%'", - checkparams={} + checkparams={}, ) def test_startswith_concat(self): self.assert_compile( - column('x').startswith('y'), + column("x").startswith("y"), "x LIKE concat(%s, '%%')", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_not_startswith_concat(self): self.assert_compile( - ~column('x').startswith('y'), + ~column("x").startswith("y"), "x NOT LIKE concat(%s, '%%')", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_startswith_firebird(self): self.assert_compile( - column('x').startswith('y'), + column("x").startswith("y"), "x STARTING WITH :x_1", - checkparams={'x_1': 'y'}, - dialect=firebird.dialect() + checkparams={"x_1": "y"}, + dialect=firebird.dialect(), ) def test_not_startswith_firebird(self): self.assert_compile( - ~column('x').startswith('y'), + ~column("x").startswith("y"), "x NOT STARTING WITH :x_1", - checkparams={'x_1': 'y'}, - dialect=firebird.dialect() + checkparams={"x_1": "y"}, + dialect=firebird.dialect(), ) def test_startswith_literal_mysql(self): self.assert_compile( - column('x').startswith(literal_column('y')), + column("x").startswith(literal_column("y")), "x LIKE concat(y, '%%')", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) def test_startswith_text_mysql(self): self.assert_compile( - column('x').startswith(text('y')), + column("x").startswith(text("y")), "x LIKE concat(y, '%%')", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) def test_endswith(self): self.assert_compile( - column('x').endswith('y'), + column("x").endswith("y"), "x LIKE '%' || :x_1", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_endswith_escape(self): self.assert_compile( - column('x').endswith('a%b_c', escape='\\'), + column("x").endswith("a%b_c", escape="\\"), "x LIKE '%' || :x_1 ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_endswith_autoescape(self): self.assert_compile( - column('x').endswith('a%b_c/d', autoescape=True), + column("x").endswith("a%b_c/d", autoescape=True), "x LIKE '%' || :x_1 ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_endswith_autoescape_custom_escape(self): self.assert_compile( - column('x').endswith('a%b_c/d^e', autoescape=True, escape="^"), + column("x").endswith("a%b_c/d^e", autoescape=True, escape="^"), "x LIKE '%' || :x_1 ESCAPE '^'", - checkparams={'x_1': 'a^%b^_c/d^^e'} + checkparams={"x_1": "a^%b^_c/d^^e"}, ) def test_endswith_autoescape_warning(self): with expect_warnings("The autoescape parameter is now a simple"): self.assert_compile( - column('x').endswith('a%b_c/d', autoescape='P'), + column("x").endswith("a%b_c/d", autoescape="P"), "x LIKE '%' || :x_1 ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_endswith_autoescape_nosqlexpr(self): assert_raises_message( TypeError, "String value expected when autoescape=True", - column('x').endswith, - literal_column("'a%b_c/d'"), autoescape=True + column("x").endswith, + literal_column("'a%b_c/d'"), + autoescape=True, ) def test_not_endswith(self): self.assert_compile( - ~column('x').endswith('y'), + ~column("x").endswith("y"), "x NOT LIKE '%' || :x_1", - checkparams={'x_1': 'y'} + checkparams={"x_1": "y"}, ) def test_not_endswith_escape(self): self.assert_compile( - ~column('x').endswith('a%b_c', escape='\\'), + ~column("x").endswith("a%b_c", escape="\\"), "x NOT LIKE '%' || :x_1 ESCAPE '\\'", - checkparams={'x_1': 'a%b_c'} + checkparams={"x_1": "a%b_c"}, ) def test_not_endswith_autoescape(self): self.assert_compile( - ~column('x').endswith('a%b_c/d', autoescape=True), + ~column("x").endswith("a%b_c/d", autoescape=True), "x NOT LIKE '%' || :x_1 ESCAPE '/'", - checkparams={'x_1': 'a/%b/_c//d'} + checkparams={"x_1": "a/%b/_c//d"}, ) def test_endswith_literal(self): self.assert_compile( - column('x').endswith(literal_column('y')), + column("x").endswith(literal_column("y")), "x LIKE '%' || y", - checkparams={} + checkparams={}, ) def test_endswith_text(self): self.assert_compile( - column('x').endswith(text('y')), - "x LIKE '%' || y", - checkparams={} + column("x").endswith(text("y")), "x LIKE '%' || y", checkparams={} ) def test_endswith_mysql(self): self.assert_compile( - column('x').endswith('y'), + column("x").endswith("y"), "x LIKE concat('%%', %s)", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_not_endswith_mysql(self): self.assert_compile( - ~column('x').endswith('y'), + ~column("x").endswith("y"), "x NOT LIKE concat('%%', %s)", - checkparams={'x_1': 'y'}, - dialect=mysql.dialect() + checkparams={"x_1": "y"}, + dialect=mysql.dialect(), ) def test_endswith_literal_mysql(self): self.assert_compile( - column('x').endswith(literal_column('y')), + column("x").endswith(literal_column("y")), "x LIKE concat('%%', y)", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) def test_endswith_text_mysql(self): self.assert_compile( - column('x').endswith(text('y')), + column("x").endswith(text("y")), "x LIKE concat('%%', y)", checkparams={}, - dialect=mysql.dialect() + dialect=mysql.dialect(), ) class CustomOpTest(fixtures.TestBase): - def test_is_comparison(self): - c = column('x') - c2 = column('y') - op1 = c.op('$', is_comparison=True)(c2).operator - op2 = c.op('$', is_comparison=False)(c2).operator + c = column("x") + c2 = column("y") + op1 = c.op("$", is_comparison=True)(c2).operator + op2 = c.op("$", is_comparison=False)(c2).operator assert operators.is_comparison(op1) assert not operators.is_comparison(op2) @@ -2708,63 +2627,66 @@ class CustomOpTest(fixtures.TestBase): postgresql.ARRAY(Integer), sqltypes.Numeric(5, 2), ]: - c = column('x', typ) - expr = c.op('$', is_comparison=True)(None) + c = column("x", typ) + expr = c.op("$", is_comparison=True)(None) is_(expr.type, sqltypes.BOOLEANTYPE) - c = column('x', typ) - expr = c.bool_op('$')(None) + c = column("x", typ) + expr = c.bool_op("$")(None) is_(expr.type, sqltypes.BOOLEANTYPE) - expr = c.op('$')(None) + expr = c.op("$")(None) is_(expr.type, typ) - expr = c.op('$', return_type=some_return_type)(None) + expr = c.op("$", return_type=some_return_type)(None) is_(expr.type, some_return_type) - expr = c.op( - '$', is_comparison=True, return_type=some_return_type)(None) + expr = c.op("$", is_comparison=True, return_type=some_return_type)( + None + ) is_(expr.type, some_return_type) class TupleTypingTest(fixtures.TestBase): - def _assert_types(self, expr): eq_(expr.clauses[0].type._type_affinity, Integer) eq_(expr.clauses[1].type._type_affinity, String) 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') + 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')]) + expr = t1.in_([(3, "hi", "there"), (4, "Q", "P")]) eq_(len(expr.right.clauses), 2) for elem in expr.right.clauses: self._assert_types(elem) class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def _fixture(self): m = MetaData() t = Table( - 'tab1', m, - Column('arrval', ARRAY(Integer)), - Column('data', Integer) + "tab1", + m, + Column("arrval", ARRAY(Integer)), + Column("data", Integer), ) return t @@ -2774,7 +2696,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 == any_(t.c.arrval), ":param_1 = ANY (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_any_array_method(self): @@ -2783,7 +2705,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 == t.c.arrval.any_(), ":param_1 = ANY (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_all_array(self): @@ -2792,7 +2714,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 == all_(t.c.arrval), ":param_1 = ALL (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_all_array_method(self): @@ -2801,7 +2723,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 == t.c.arrval.all_(), ":param_1 = ALL (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_any_comparator_array(self): @@ -2810,7 +2732,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 > any_(t.c.arrval), ":param_1 > ANY (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_all_comparator_array(self): @@ -2819,7 +2741,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( 5 > all_(t.c.arrval), ":param_1 > ALL (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_any_comparator_array_wexpr(self): @@ -2828,7 +2750,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( t.c.data > any_(t.c.arrval), "tab1.data > ANY (tab1.arrval)", - checkparams={} + checkparams={}, ) def test_all_comparator_array_wexpr(self): @@ -2837,7 +2759,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( t.c.data > all_(t.c.arrval), "tab1.data > ALL (tab1.arrval)", - checkparams={} + checkparams={}, ) def test_illegal_ops(self): @@ -2846,7 +2768,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): assert_raises_message( exc.ArgumentError, "Only comparison operators may be used with ANY/ALL", - lambda: 5 + all_(t.c.arrval) + lambda: 5 + all_(t.c.arrval), ) # TODO: @@ -2854,8 +2776,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): # as the left-hand side just does its thing. Types # would need to reject their right-hand side. self.assert_compile( - t.c.data + all_(t.c.arrval), - "tab1.data + ALL (tab1.arrval)" + t.c.data + all_(t.c.arrval), "tab1.data + ALL (tab1.arrval)" ) def test_any_array_comparator_accessor(self): @@ -2864,7 +2785,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( t.c.arrval.any(5, operator.gt), ":param_1 > ANY (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_all_array_comparator_accessor(self): @@ -2873,7 +2794,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): self.assert_compile( t.c.arrval.all(5, operator.gt), ":param_1 > ALL (tab1.arrval)", - checkparams={"param_1": 5} + checkparams={"param_1": 5}, ) def test_any_array_expression(self): @@ -2884,9 +2805,13 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): "%(param_1)s = ANY (tab1.arrval[%(arrval_1)s:%(arrval_2)s] || " "ARRAY[%(param_2)s, %(param_3)s])", checkparams={ - 'arrval_2': 6, 'param_1': 5, 'param_3': 4, - 'arrval_1': 5, 'param_2': 3}, - dialect='postgresql' + "arrval_2": 6, + "param_1": 5, + "param_3": 4, + "arrval_1": 5, + "param_2": 3, + }, + dialect="postgresql", ) def test_all_array_expression(self): @@ -2897,9 +2822,13 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): "%(param_1)s = ALL (tab1.arrval[%(arrval_1)s:%(arrval_2)s] || " "ARRAY[%(param_2)s, %(param_3)s])", checkparams={ - 'arrval_2': 6, 'param_1': 5, 'param_3': 4, - 'arrval_1': 5, 'param_2': 3}, - dialect='postgresql' + "arrval_2": 6, + "param_1": 5, + "param_3": 4, + "arrval_1": 5, + "param_2": 3, + }, + dialect="postgresql", ) def test_any_subq(self): @@ -2909,7 +2838,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): 5 == any_(select([t.c.data]).where(t.c.data < 10)), ":param_1 = ANY (SELECT tab1.data " "FROM tab1 WHERE tab1.data < :data_1)", - checkparams={'data_1': 10, 'param_1': 5} + checkparams={"data_1": 10, "param_1": 5}, ) def test_any_subq_method(self): @@ -2919,7 +2848,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): 5 == select([t.c.data]).where(t.c.data < 10).as_scalar().any_(), ":param_1 = ANY (SELECT tab1.data " "FROM tab1 WHERE tab1.data < :data_1)", - checkparams={'data_1': 10, 'param_1': 5} + checkparams={"data_1": 10, "param_1": 5}, ) def test_all_subq(self): @@ -2929,7 +2858,7 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): 5 == all_(select([t.c.data]).where(t.c.data < 10)), ":param_1 = ALL (SELECT tab1.data " "FROM tab1 WHERE tab1.data < :data_1)", - checkparams={'data_1': 10, 'param_1': 5} + checkparams={"data_1": 10, "param_1": 5}, ) def test_all_subq_method(self): @@ -2939,5 +2868,5 @@ class AnyAllTest(fixtures.TestBase, testing.AssertsCompiledSQL): 5 == select([t.c.data]).where(t.c.data < 10).as_scalar().all_(), ":param_1 = ALL (SELECT tab1.data " "FROM tab1 WHERE tab1.data < :data_1)", - checkparams={'data_1': 10, 'param_1': 5} + checkparams={"data_1": 10, "param_1": 5}, ) diff --git a/test/sql/test_query.py b/test/sql/test_query.py index 175b69c4f..13f3b01ff 100644 --- a/test/sql/test_query.py +++ b/test/sql/test_query.py @@ -1,12 +1,41 @@ -from sqlalchemy.testing import eq_, assert_raises_message, assert_raises, \ - is_, in_, not_in_ +from sqlalchemy.testing import ( + eq_, + assert_raises_message, + assert_raises, + is_, + in_, + not_in_, +) from sqlalchemy import testing from sqlalchemy.testing import fixtures, engines from sqlalchemy import ( - exc, sql, func, select, String, Integer, MetaData, and_, ForeignKey, - union, intersect, except_, union_all, VARCHAR, INT, text, - bindparam, literal, not_, literal_column, desc, asc, - TypeDecorator, or_, cast, tuple_) + exc, + sql, + func, + select, + String, + Integer, + MetaData, + and_, + ForeignKey, + union, + intersect, + except_, + union_all, + VARCHAR, + INT, + text, + bindparam, + literal, + not_, + literal_column, + desc, + asc, + TypeDecorator, + or_, + cast, + tuple_, +) from sqlalchemy.engine import default from sqlalchemy.testing.schema import Table, Column @@ -25,28 +54,34 @@ class QueryTest(fixtures.TestBase): global users, users2, addresses, metadata metadata = MetaData(testing.db) users = Table( - 'query_users', metadata, + "query_users", + metadata, Column( - 'user_id', INT, primary_key=True, - test_needs_autoincrement=True), - Column('user_name', VARCHAR(20)), - test_needs_acid=True + "user_id", INT, primary_key=True, test_needs_autoincrement=True + ), + Column("user_name", VARCHAR(20)), + test_needs_acid=True, ) addresses = Table( - 'query_addresses', metadata, + "query_addresses", + metadata, Column( - 'address_id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('user_id', Integer, ForeignKey('query_users.user_id')), - Column('address', String(30)), - test_needs_acid=True + "address_id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("user_id", Integer, ForeignKey("query_users.user_id")), + Column("address", String(30)), + test_needs_acid=True, ) users2 = Table( - 'u2', metadata, - Column('user_id', INT, primary_key=True), - Column('user_name', VARCHAR(20)), - test_needs_acid=True + "u2", + metadata, + Column("user_id", INT, primary_key=True), + Column("user_name", VARCHAR(20)), + test_needs_acid=True, ) metadata.create_all() @@ -62,7 +97,8 @@ class QueryTest(fixtures.TestBase): metadata.drop_all() @testing.fails_on( - 'firebird', "kinterbasdb doesn't send full type information") + "firebird", "kinterbasdb doesn't send full type information" + ) def test_order_by_label(self): """test that a label within an ORDER BY works on each backend. @@ -73,41 +109,43 @@ class QueryTest(fixtures.TestBase): """ users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) - concat = ("test: " + users.c.user_name).label('thedata') + concat = ("test: " + users.c.user_name).label("thedata") eq_( select([concat]).order_by("thedata").execute().fetchall(), - [("test: ed",), ("test: fred",), ("test: jack",)] + [("test: ed",), ("test: fred",), ("test: jack",)], ) eq_( select([concat]).order_by("thedata").execute().fetchall(), - [("test: ed",), ("test: fred",), ("test: jack",)] + [("test: ed",), ("test: fred",), ("test: jack",)], ) - concat = ("test: " + users.c.user_name).label('thedata') + concat = ("test: " + users.c.user_name).label("thedata") eq_( - select([concat]).order_by(desc('thedata')).execute().fetchall(), - [("test: jack",), ("test: fred",), ("test: ed",)] + select([concat]).order_by(desc("thedata")).execute().fetchall(), + [("test: jack",), ("test: fred",), ("test: ed",)], ) @testing.requires.order_by_label_with_expression def test_order_by_label_compound(self): users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) - concat = ("test: " + users.c.user_name).label('thedata') + concat = ("test: " + users.c.user_name).label("thedata") eq_( - select([concat]).order_by(literal_column('thedata') + "x"). - execute().fetchall(), - [("test: ed",), ("test: fred",), ("test: jack",)] + select([concat]) + .order_by(literal_column("thedata") + "x") + .execute() + .fetchall(), + [("test: ed",), ("test: fred",), ("test: jack",)], ) @testing.requires.boolean_col_expressions @@ -120,93 +158,124 @@ class QueryTest(fixtures.TestBase): eq_(testing.db.execute(select([or_(false, false)])).scalar(), False) eq_( testing.db.execute(select([not_(or_(false, false))])).scalar(), - True) + True, + ) row = testing.db.execute( select( - [or_(false, false).label("x"), - and_(true, false).label("y")])).first() + [or_(false, false).label("x"), and_(true, false).label("y")] + ) + ).first() assert row.x == False # noqa assert row.y == False # noqa row = testing.db.execute( - select( - [or_(true, false).label("x"), - and_(true, false).label("y")])).first() + select([or_(true, false).label("x"), and_(true, false).label("y")]) + ).first() assert row.x == True # noqa assert row.y == False # noqa def test_like_ops(self): users.insert().execute( - {'user_id': 1, 'user_name': 'apples'}, - {'user_id': 2, 'user_name': 'oranges'}, - {'user_id': 3, 'user_name': 'bananas'}, - {'user_id': 4, 'user_name': 'legumes'}, - {'user_id': 5, 'user_name': 'hi % there'}, + {"user_id": 1, "user_name": "apples"}, + {"user_id": 2, "user_name": "oranges"}, + {"user_id": 3, "user_name": "bananas"}, + {"user_id": 4, "user_name": "legumes"}, + {"user_id": 5, "user_name": "hi % there"}, ) for expr, result in ( - (select([users.c.user_id]). - where(users.c.user_name.startswith('apple')), [(1,)]), - (select([users.c.user_id]). - where(users.c.user_name.contains('i % t')), [(5,)]), - (select([users.c.user_id]). - where(users.c.user_name.endswith('anas')), [(3,)]), - (select([users.c.user_id]). - where(users.c.user_name.contains('i % t', escape='&')), - [(5,)]), + ( + select([users.c.user_id]).where( + users.c.user_name.startswith("apple") + ), + [(1,)], + ), + ( + select([users.c.user_id]).where( + users.c.user_name.contains("i % t") + ), + [(5,)], + ), + ( + select([users.c.user_id]).where( + users.c.user_name.endswith("anas") + ), + [(3,)], + ), + ( + select([users.c.user_id]).where( + users.c.user_name.contains("i % t", escape="&") + ), + [(5,)], + ), ): eq_(expr.execute().fetchall(), result) @testing.requires.mod_operator_as_percent_sign - @testing.emits_warning('.*now automatically escapes.*') + @testing.emits_warning(".*now automatically escapes.*") def test_percents_in_text(self): for expr, result in ( (text("select 6 % 10"), 6), (text("select 17 % 10"), 7), - (text("select '%'"), '%'), - (text("select '%%'"), '%%'), - (text("select '%%%'"), '%%%'), - (text("select 'hello % world'"), "hello % world") + (text("select '%'"), "%"), + (text("select '%%'"), "%%"), + (text("select '%%%'"), "%%%"), + (text("select 'hello % world'"), "hello % world"), ): eq_(testing.db.scalar(expr), result) def test_ilike(self): users.insert().execute( - {'user_id': 1, 'user_name': 'one'}, - {'user_id': 2, 'user_name': 'TwO'}, - {'user_id': 3, 'user_name': 'ONE'}, - {'user_id': 4, 'user_name': 'OnE'}, + {"user_id": 1, "user_name": "one"}, + {"user_id": 2, "user_name": "TwO"}, + {"user_id": 3, "user_name": "ONE"}, + {"user_id": 4, "user_name": "OnE"}, ) eq_( - select([users.c.user_id]).where(users.c.user_name.ilike('one')). - execute().fetchall(), [(1, ), (3, ), (4, )]) + select([users.c.user_id]) + .where(users.c.user_name.ilike("one")) + .execute() + .fetchall(), + [(1,), (3,), (4,)], + ) eq_( - select([users.c.user_id]).where(users.c.user_name.ilike('TWO')). - execute().fetchall(), [(2, )]) + select([users.c.user_id]) + .where(users.c.user_name.ilike("TWO")) + .execute() + .fetchall(), + [(2,)], + ) - if testing.against('postgresql'): + if testing.against("postgresql"): eq_( - select([users.c.user_id]). - where(users.c.user_name.like('one')).execute().fetchall(), - [(1, )]) + select([users.c.user_id]) + .where(users.c.user_name.like("one")) + .execute() + .fetchall(), + [(1,)], + ) eq_( - select([users.c.user_id]). - where(users.c.user_name.like('TWO')).execute().fetchall(), []) + select([users.c.user_id]) + .where(users.c.user_name.like("TWO")) + .execute() + .fetchall(), + [], + ) def test_compiled_execute(self): - users.insert().execute(user_id=7, user_name='jack') - s = select([users], users.c.user_id == bindparam('id')).compile() + users.insert().execute(user_id=7, user_name="jack") + s = select([users], users.c.user_id == bindparam("id")).compile() c = testing.db.connect() - assert c.execute(s, id=7).fetchall()[0]['user_id'] == 7 + assert c.execute(s, id=7).fetchall()[0]["user_id"] == 7 def test_compiled_insert_execute(self): - users.insert().compile().execute(user_id=7, user_name='jack') - s = select([users], users.c.user_id == bindparam('id')).compile() + users.insert().compile().execute(user_id=7, user_name="jack") + s = select([users], users.c.user_id == bindparam("id")).compile() c = testing.db.connect() - assert c.execute(s, id=7).fetchall()[0]['user_id'] == 7 + assert c.execute(s, id=7).fetchall()[0]["user_id"] == 7 def test_repeated_bindparams(self): """Tests that a BindParam can be used more than once. @@ -215,18 +284,19 @@ class QueryTest(fixtures.TestBase): paramstyles. """ - users.insert().execute(user_id=7, user_name='jack') - users.insert().execute(user_id=8, user_name='fred') + users.insert().execute(user_id=7, user_name="jack") + users.insert().execute(user_id=8, user_name="fred") - u = bindparam('userid') + u = bindparam("userid") s = users.select(and_(users.c.user_name == u, users.c.user_name == u)) - r = s.execute(userid='fred').fetchall() + r = s.execute(userid="fred").fetchall() assert len(r) == 1 def test_bindparam_detection(self): - dialect = default.DefaultDialect(paramstyle='qmark') + dialect = default.DefaultDialect(paramstyle="qmark") - def prep(q): return str(sql.text(q).compile(dialect=dialect)) + def prep(q): + return str(sql.text(q).compile(dialect=dialect)) def a_eq(got, wanted): if got != wanted: @@ -234,7 +304,7 @@ class QueryTest(fixtures.TestBase): print("Received %s" % got) self.assert_(got == wanted, got) - a_eq(prep('select foo'), 'select foo') + a_eq(prep("select foo"), "select foo") a_eq(prep("time='12:30:00'"), "time='12:30:00'") a_eq(prep("time='12:30:00'"), "time='12:30:00'") a_eq(prep(":this:that"), ":this:that") @@ -249,7 +319,7 @@ class QueryTest(fixtures.TestBase): a_eq(prep("(:that$:other)"), "(:that$:other)") a_eq(prep(".:that$ :other."), ".? ?.") - a_eq(prep(r'select \foo'), r'select \foo') + a_eq(prep(r"select \foo"), r"select \foo") a_eq(prep(r"time='12\:30:00'"), r"time='12\:30:00'") a_eq(prep(r":this \:that"), "? :that") a_eq(prep(r"(\:that$other)"), "(:that$other)") @@ -271,12 +341,13 @@ class QueryTest(fixtures.TestBase): eq_( testing.db.scalar(select([cast("INT_5", type_=MyInteger)])), - "INT_5" + "INT_5", ) eq_( testing.db.scalar( - select([cast("INT_5", type_=MyInteger).label('foo')])), - "INT_5" + select([cast("INT_5", type_=MyInteger).label("foo")]) + ), + "INT_5", ) def test_order_by(self): @@ -285,61 +356,96 @@ class QueryTest(fixtures.TestBase): Tests simple, compound, aliased and DESC clauses. """ - users.insert().execute(user_id=1, user_name='c') - users.insert().execute(user_id=2, user_name='b') - users.insert().execute(user_id=3, user_name='a') + users.insert().execute(user_id=1, user_name="c") + users.insert().execute(user_id=2, user_name="b") + users.insert().execute(user_id=3, user_name="a") def a_eq(executable, wanted): got = list(executable.execute()) eq_(got, wanted) for labels in False, True: - a_eq(users.select(order_by=[users.c.user_id], - use_labels=labels), - [(1, 'c'), (2, 'b'), (3, 'a')]) - - a_eq(users.select(order_by=[users.c.user_name, users.c.user_id], - use_labels=labels), - [(3, 'a'), (2, 'b'), (1, 'c')]) - - a_eq(select([users.c.user_id.label('foo')], - use_labels=labels, - order_by=[users.c.user_id]), - [(1,), (2,), (3,)]) - - a_eq(select([users.c.user_id.label('foo'), users.c.user_name], - use_labels=labels, - order_by=[users.c.user_name, users.c.user_id]), - [(3, 'a'), (2, 'b'), (1, 'c')]) - - a_eq(users.select(distinct=True, - use_labels=labels, - order_by=[users.c.user_id]), - [(1, 'c'), (2, 'b'), (3, 'a')]) - - a_eq(select([users.c.user_id.label('foo')], - distinct=True, - use_labels=labels, - order_by=[users.c.user_id]), - [(1,), (2,), (3,)]) - - a_eq(select([users.c.user_id.label('a'), - users.c.user_id.label('b'), - users.c.user_name], - use_labels=labels, - order_by=[users.c.user_id]), - [(1, 1, 'c'), (2, 2, 'b'), (3, 3, 'a')]) - - a_eq(users.select(distinct=True, - use_labels=labels, - order_by=[desc(users.c.user_id)]), - [(3, 'a'), (2, 'b'), (1, 'c')]) - - a_eq(select([users.c.user_id.label('foo')], - distinct=True, - use_labels=labels, - order_by=[users.c.user_id.desc()]), - [(3,), (2,), (1,)]) + a_eq( + users.select(order_by=[users.c.user_id], use_labels=labels), + [(1, "c"), (2, "b"), (3, "a")], + ) + + a_eq( + users.select( + order_by=[users.c.user_name, users.c.user_id], + use_labels=labels, + ), + [(3, "a"), (2, "b"), (1, "c")], + ) + + a_eq( + select( + [users.c.user_id.label("foo")], + use_labels=labels, + order_by=[users.c.user_id], + ), + [(1,), (2,), (3,)], + ) + + a_eq( + select( + [users.c.user_id.label("foo"), users.c.user_name], + use_labels=labels, + order_by=[users.c.user_name, users.c.user_id], + ), + [(3, "a"), (2, "b"), (1, "c")], + ) + + a_eq( + users.select( + distinct=True, + use_labels=labels, + order_by=[users.c.user_id], + ), + [(1, "c"), (2, "b"), (3, "a")], + ) + + a_eq( + select( + [users.c.user_id.label("foo")], + distinct=True, + use_labels=labels, + order_by=[users.c.user_id], + ), + [(1,), (2,), (3,)], + ) + + a_eq( + select( + [ + users.c.user_id.label("a"), + users.c.user_id.label("b"), + users.c.user_name, + ], + use_labels=labels, + order_by=[users.c.user_id], + ), + [(1, 1, "c"), (2, 2, "b"), (3, 3, "a")], + ) + + a_eq( + users.select( + distinct=True, + use_labels=labels, + order_by=[desc(users.c.user_id)], + ), + [(3, "a"), (2, "b"), (1, "c")], + ) + + a_eq( + select( + [users.c.user_id.label("foo")], + distinct=True, + use_labels=labels, + order_by=[users.c.user_id.desc()], + ), + [(3,), (2,), (1,)], + ) @testing.requires.nullsordering def test_order_by_nulls(self): @@ -349,67 +455,98 @@ class QueryTest(fixtures.TestBase): """ users.insert().execute(user_id=1) - users.insert().execute(user_id=2, user_name='b') - users.insert().execute(user_id=3, user_name='a') + users.insert().execute(user_id=2, user_name="b") + users.insert().execute(user_id=3, user_name="a") def a_eq(executable, wanted): got = list(executable.execute()) eq_(got, wanted) for labels in False, True: - a_eq(users.select(order_by=[users.c.user_name.nullsfirst()], - use_labels=labels), - [(1, None), (3, 'a'), (2, 'b')]) + a_eq( + users.select( + order_by=[users.c.user_name.nullsfirst()], + use_labels=labels, + ), + [(1, None), (3, "a"), (2, "b")], + ) - a_eq(users.select(order_by=[users.c.user_name.nullslast()], - use_labels=labels), - [(3, 'a'), (2, 'b'), (1, None)]) + a_eq( + users.select( + order_by=[users.c.user_name.nullslast()], use_labels=labels + ), + [(3, "a"), (2, "b"), (1, None)], + ) - a_eq(users.select(order_by=[asc(users.c.user_name).nullsfirst()], - use_labels=labels), - [(1, None), (3, 'a'), (2, 'b')]) + a_eq( + users.select( + order_by=[asc(users.c.user_name).nullsfirst()], + use_labels=labels, + ), + [(1, None), (3, "a"), (2, "b")], + ) - a_eq(users.select(order_by=[asc(users.c.user_name).nullslast()], - use_labels=labels), - [(3, 'a'), (2, 'b'), (1, None)]) + a_eq( + users.select( + order_by=[asc(users.c.user_name).nullslast()], + use_labels=labels, + ), + [(3, "a"), (2, "b"), (1, None)], + ) - a_eq(users.select(order_by=[users.c.user_name.desc().nullsfirst()], - use_labels=labels), - [(1, None), (2, 'b'), (3, 'a')]) + a_eq( + users.select( + order_by=[users.c.user_name.desc().nullsfirst()], + use_labels=labels, + ), + [(1, None), (2, "b"), (3, "a")], + ) a_eq( users.select( order_by=[users.c.user_name.desc().nullslast()], - use_labels=labels), - [(2, 'b'), (3, 'a'), (1, None)]) + use_labels=labels, + ), + [(2, "b"), (3, "a"), (1, None)], + ) a_eq( users.select( order_by=[desc(users.c.user_name).nullsfirst()], - use_labels=labels), - [(1, None), (2, 'b'), (3, 'a')]) + use_labels=labels, + ), + [(1, None), (2, "b"), (3, "a")], + ) - a_eq(users.select(order_by=[desc(users.c.user_name).nullslast()], - use_labels=labels), - [(2, 'b'), (3, 'a'), (1, None)]) + a_eq( + users.select( + order_by=[desc(users.c.user_name).nullslast()], + use_labels=labels, + ), + [(2, "b"), (3, "a"), (1, None)], + ) a_eq( users.select( order_by=[users.c.user_name.nullsfirst(), users.c.user_id], - use_labels=labels), - [(1, None), (3, 'a'), (2, 'b')]) + use_labels=labels, + ), + [(1, None), (3, "a"), (2, "b")], + ) a_eq( users.select( order_by=[users.c.user_name.nullslast(), users.c.user_id], - use_labels=labels), - [(3, 'a'), (2, 'b'), (1, None)]) + use_labels=labels, + ), + [(3, "a"), (2, "b"), (1, None)], + ) def test_in_filtering(self): """test the behavior of the in_() function.""" - users.insert().execute(user_id=7, user_name='jack') - users.insert().execute(user_id=8, user_name='fred') + users.insert().execute(user_id=7, user_name="jack") + users.insert().execute(user_id=8, user_name="fred") users.insert().execute(user_id=9, user_name=None) s = users.select(users.c.user_name.in_([])) @@ -421,11 +558,11 @@ class QueryTest(fixtures.TestBase): r = s.execute().fetchall() assert len(r) == 3 - s = users.select(users.c.user_name.in_(['jack', 'fred'])) + s = users.select(users.c.user_name.in_(["jack", "fred"])) r = s.execute().fetchall() assert len(r) == 2 - s = users.select(not_(users.c.user_name.in_(['jack', 'fred']))) + s = users.select(not_(users.c.user_name.in_(["jack", "fred"]))) r = s.execute().fetchall() # Null values are not outside any set assert len(r) == 0 @@ -434,39 +571,41 @@ class QueryTest(fixtures.TestBase): testing.db.execute( users.insert(), [ - dict(user_id=7, user_name='jack'), - dict(user_id=8, user_name='fred'), - dict(user_id=9, user_name=None) - ] + dict(user_id=7, user_name="jack"), + dict(user_id=8, user_name="fred"), + dict(user_id=9, user_name=None), + ], ) with testing.db.connect() as conn: - stmt = select([users]).where( - users.c.user_name.in_(bindparam('uname', expanding=True)) - ).order_by(users.c.user_id) - - eq_( - conn.execute(stmt, {"uname": ['jack']}).fetchall(), - [(7, 'jack')] + stmt = ( + select([users]) + .where( + users.c.user_name.in_(bindparam("uname", expanding=True)) + ) + .order_by(users.c.user_id) ) eq_( - conn.execute(stmt, {"uname": ['jack', 'fred']}).fetchall(), - [(7, 'jack'), (8, 'fred')] + conn.execute(stmt, {"uname": ["jack"]}).fetchall(), + [(7, "jack")], ) eq_( - conn.execute(stmt, {"uname": []}).fetchall(), - [] + conn.execute(stmt, {"uname": ["jack", "fred"]}).fetchall(), + [(7, "jack"), (8, "fred")], ) + eq_(conn.execute(stmt, {"uname": []}).fetchall(), []) + assert_raises_message( exc.StatementError, "'expanding' parameters can't be used with executemany()", conn.execute, users.update().where( - users.c.user_name.in_(bindparam('uname', expanding=True)) - ), [{"uname": ['fred']}, {"uname": ['ed']}] + users.c.user_name.in_(bindparam("uname", expanding=True)) + ), + [{"uname": ["fred"]}, {"uname": ["ed"]}], ) @testing.requires.no_quoting_special_bind_names @@ -474,94 +613,113 @@ class QueryTest(fixtures.TestBase): testing.db.execute( users.insert(), [ - dict(user_id=7, user_name='jack'), - dict(user_id=8, user_name='fred'), - ] + dict(user_id=7, user_name="jack"), + dict(user_id=8, user_name="fred"), + ], ) with testing.db.connect() as conn: - stmt = select([users]).where( - users.c.user_name.in_(bindparam('u35', expanding=True)) - ).where( - users.c.user_id == bindparam("u46") - ).order_by(users.c.user_id) + stmt = ( + select([users]) + .where(users.c.user_name.in_(bindparam("u35", expanding=True))) + .where(users.c.user_id == bindparam("u46")) + .order_by(users.c.user_id) + ) eq_( conn.execute( - stmt, {"u35": ['jack', 'fred'], "u46": 7}).fetchall(), - [(7, 'jack')] + stmt, {"u35": ["jack", "fred"], "u46": 7} + ).fetchall(), + [(7, "jack")], ) - stmt = select([users]).where( - users.c.user_name.in_(bindparam('u.35', expanding=True)) - ).where( - users.c.user_id == bindparam("u.46") - ).order_by(users.c.user_id) + stmt = ( + select([users]) + .where( + users.c.user_name.in_(bindparam("u.35", expanding=True)) + ) + .where(users.c.user_id == bindparam("u.46")) + .order_by(users.c.user_id) + ) eq_( conn.execute( - stmt, {"u.35": ['jack', 'fred'], "u.46": 7}).fetchall(), - [(7, 'jack')] + stmt, {"u.35": ["jack", "fred"], "u.46": 7} + ).fetchall(), + [(7, "jack")], ) def test_expanding_in_multiple(self): testing.db.execute( users.insert(), [ - dict(user_id=7, user_name='jack'), - dict(user_id=8, user_name='fred'), - dict(user_id=9, user_name='ed') - ] + dict(user_id=7, user_name="jack"), + dict(user_id=8, user_name="fred"), + dict(user_id=9, user_name="ed"), + ], ) with testing.db.connect() as conn: - stmt = select([users]).where( - users.c.user_name.in_(bindparam('uname', expanding=True)) - ).where( - users.c.user_id.in_(bindparam('userid', expanding=True)) - ).order_by(users.c.user_id) + stmt = ( + select([users]) + .where( + users.c.user_name.in_(bindparam("uname", expanding=True)) + ) + .where( + users.c.user_id.in_(bindparam("userid", expanding=True)) + ) + .order_by(users.c.user_id) + ) eq_( conn.execute( - stmt, - {"uname": ['jack', 'fred', 'ed'], "userid": [8, 9]} + stmt, {"uname": ["jack", "fred", "ed"], "userid": [8, 9]} ).fetchall(), - [(8, 'fred'), (9, 'ed')] + [(8, "fred"), (9, "ed")], ) def test_expanding_in_repeated(self): testing.db.execute( users.insert(), [ - dict(user_id=7, user_name='jack'), - dict(user_id=8, user_name='fred'), - dict(user_id=9, user_name='ed') - ] + dict(user_id=7, user_name="jack"), + dict(user_id=8, user_name="fred"), + dict(user_id=9, user_name="ed"), + ], ) with testing.db.connect() as conn: - stmt = select([users]).where( - users.c.user_name.in_( - bindparam('uname', expanding=True) - ) | users.c.user_name.in_(bindparam('uname2', expanding=True)) - ).where(users.c.user_id == 8) + stmt = ( + select([users]) + .where( + users.c.user_name.in_(bindparam("uname", expanding=True)) + | users.c.user_name.in_( + bindparam("uname2", expanding=True) + ) + ) + .where(users.c.user_id == 8) + ) stmt = stmt.union( - select([users]).where( - users.c.user_name.in_( - bindparam('uname', expanding=True) - ) | users.c.user_name.in_( - bindparam('uname2', expanding=True)) - ).where(users.c.user_id == 9) + select([users]) + .where( + users.c.user_name.in_(bindparam("uname", expanding=True)) + | users.c.user_name.in_( + bindparam("uname2", expanding=True) + ) + ) + .where(users.c.user_id == 9) ).order_by(stmt.c.user_id) eq_( conn.execute( stmt, { - "uname": ['jack', 'fred'], - "uname2": ['ed'], "userid": [8, 9]} + "uname": ["jack", "fred"], + "uname2": ["ed"], + "userid": [8, 9], + }, ).fetchall(), - [(8, 'fred'), (9, 'ed')] + [(8, "fred"), (9, "ed")], ) @testing.requires.tuple_in @@ -569,34 +727,38 @@ class QueryTest(fixtures.TestBase): testing.db.execute( users.insert(), [ - dict(user_id=7, user_name='jack'), - dict(user_id=8, user_name='fred'), - dict(user_id=9, user_name=None) - ] + dict(user_id=7, user_name="jack"), + dict(user_id=8, user_name="fred"), + dict(user_id=9, user_name=None), + ], ) with testing.db.connect() as conn: - stmt = select([users]).where( - tuple_( - users.c.user_id, - users.c.user_name - ).in_(bindparam('uname', expanding=True)) - ).order_by(users.c.user_id) + stmt = ( + select([users]) + .where( + tuple_(users.c.user_id, users.c.user_name).in_( + bindparam("uname", expanding=True) + ) + ) + .order_by(users.c.user_id) + ) eq_( - conn.execute(stmt, {"uname": [(7, 'jack')]}).fetchall(), - [(7, 'jack')] + conn.execute(stmt, {"uname": [(7, "jack")]}).fetchall(), + [(7, "jack")], ) eq_( - conn.execute(stmt, {"uname": [(7, 'jack'), (8, 'fred')]}).fetchall(), - [(7, 'jack'), (8, 'fred')] + conn.execute( + stmt, {"uname": [(7, "jack"), (8, "fred")]} + ).fetchall(), + [(7, "jack"), (8, "fred")], ) - - @testing.fails_on('firebird', "uses sql-92 rules") - @testing.fails_on('sybase', "uses sql-92 rules") - @testing.skip_if(['mssql']) + @testing.fails_on("firebird", "uses sql-92 rules") + @testing.fails_on("sybase", "uses sql-92 rules") + @testing.skip_if(["mssql"]) def test_bind_in(self): """test calling IN against a bind parameter. @@ -605,24 +767,24 @@ class QueryTest(fixtures.TestBase): """ - users.insert().execute(user_id=7, user_name='jack') - users.insert().execute(user_id=8, user_name='fred') + users.insert().execute(user_id=7, user_name="jack") + users.insert().execute(user_id=8, user_name="fred") users.insert().execute(user_id=9, user_name=None) - u = bindparam('search_key') + u = bindparam("search_key") s = users.select(not_(u.in_([]))) - r = s.execute(search_key='john').fetchall() + r = s.execute(search_key="john").fetchall() assert len(r) == 3 r = s.execute(search_key=None).fetchall() assert len(r) == 3 - @testing.emits_warning('.*empty sequence.*') + @testing.emits_warning(".*empty sequence.*") def test_literal_in(self): """similar to test_bind_in but use a bind with a value.""" - users.insert().execute(user_id=7, user_name='jack') - users.insert().execute(user_id=8, user_name='fred') + users.insert().execute(user_id=7, user_name="jack") + users.insert().execute(user_id=8, user_name="fred") users.insert().execute(user_id=9, user_name=None) s = users.select(not_(literal("john").in_([]))) @@ -641,10 +803,10 @@ class QueryTest(fixtures.TestBase): conn.execute( users.insert(), [ - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': None} - ] + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": None}, + ], ) s = users.select(users.c.user_name.in_([]) == True) # noqa @@ -666,7 +828,8 @@ class QueryTest(fixtures.TestBase): """ engine = engines.testing_engine( - options={"empty_in_strategy": "dynamic"}) + options={"empty_in_strategy": "dynamic"} + ) with engine.connect() as conn: users.create(engine, checkfirst=True) @@ -674,10 +837,10 @@ class QueryTest(fixtures.TestBase): conn.execute( users.insert(), [ - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': None} - ] + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": None}, + ], ) s = users.select(users.c.user_name.in_([]) == True) # noqa @@ -698,57 +861,65 @@ class RequiredBindTest(fixtures.TablesTest): @classmethod def define_tables(cls, metadata): Table( - 'foo', metadata, - Column('id', Integer, primary_key=True), - Column('data', String(50)), - Column('x', Integer) + "foo", + metadata, + Column("id", Integer, primary_key=True), + Column("data", String(50)), + Column("x", Integer), ) def _assert_raises(self, stmt, params): assert_raises_message( exc.StatementError, "A value is required for bind parameter 'x'", - testing.db.execute, stmt, **params) + testing.db.execute, + stmt, + **params + ) assert_raises_message( exc.StatementError, "A value is required for bind parameter 'x'", - testing.db.execute, stmt, params) + testing.db.execute, + stmt, + params, + ) def test_insert(self): stmt = self.tables.foo.insert().values( - x=bindparam('x'), data=bindparam('data')) - self._assert_raises(stmt, {'data': 'data'}) + x=bindparam("x"), data=bindparam("data") + ) + self._assert_raises(stmt, {"data": "data"}) def test_select_where(self): - stmt = select([self.tables.foo]). \ - where(self.tables.foo.c.data == bindparam('data')). \ - where(self.tables.foo.c.x == bindparam('x')) - self._assert_raises(stmt, {'data': 'data'}) + stmt = ( + select([self.tables.foo]) + .where(self.tables.foo.c.data == bindparam("data")) + .where(self.tables.foo.c.x == bindparam("x")) + ) + self._assert_raises(stmt, {"data": "data"}) @testing.requires.standalone_binds def test_select_columns(self): - stmt = select([bindparam('data'), bindparam('x')]) - self._assert_raises( - stmt, {'data': 'data'} - ) + stmt = select([bindparam("data"), bindparam("x")]) + self._assert_raises(stmt, {"data": "data"}) def test_text(self): stmt = text("select * from foo where x=:x and data=:data1") - self._assert_raises( - stmt, {'data1': 'data'} - ) + self._assert_raises(stmt, {"data1": "data"}) def test_required_flag(self): - is_(bindparam('foo').required, True) - is_(bindparam('foo', required=False).required, False) - is_(bindparam('foo', 'bar').required, False) - is_(bindparam('foo', 'bar', required=True).required, True) + is_(bindparam("foo").required, True) + is_(bindparam("foo", required=False).required, False) + is_(bindparam("foo", "bar").required, False) + is_(bindparam("foo", "bar", required=True).required, True) - def c(): return None - is_(bindparam('foo', callable_=c, required=True).required, True) - is_(bindparam('foo', callable_=c).required, False) - is_(bindparam('foo', callable_=c, required=False).required, False) + def c(): + return None + + is_(bindparam("foo", callable_=c, required=True).required, True) + is_(bindparam("foo", callable_=c).required, False) + is_(bindparam("foo", callable_=c, required=False).required, False) class LimitTest(fixtures.TestBase): @@ -759,70 +930,97 @@ class LimitTest(fixtures.TestBase): global users, addresses, metadata metadata = MetaData(testing.db) users = Table( - 'query_users', metadata, - Column('user_id', INT, primary_key=True), - Column('user_name', VARCHAR(20)), + "query_users", + metadata, + Column("user_id", INT, primary_key=True), + Column("user_name", VARCHAR(20)), ) addresses = Table( - 'query_addresses', metadata, - Column('address_id', Integer, primary_key=True), - Column('user_id', Integer, ForeignKey('query_users.user_id')), - Column('address', String(30))) + "query_addresses", + metadata, + Column("address_id", Integer, primary_key=True), + Column("user_id", Integer, ForeignKey("query_users.user_id")), + Column("address", String(30)), + ) metadata.create_all() - users.insert().execute(user_id=1, user_name='john') - addresses.insert().execute(address_id=1, user_id=1, address='addr1') - users.insert().execute(user_id=2, user_name='jack') - addresses.insert().execute(address_id=2, user_id=2, address='addr1') - users.insert().execute(user_id=3, user_name='ed') - addresses.insert().execute(address_id=3, user_id=3, address='addr2') - users.insert().execute(user_id=4, user_name='wendy') - addresses.insert().execute(address_id=4, user_id=4, address='addr3') - users.insert().execute(user_id=5, user_name='laura') - addresses.insert().execute(address_id=5, user_id=5, address='addr4') - users.insert().execute(user_id=6, user_name='ralph') - addresses.insert().execute(address_id=6, user_id=6, address='addr5') - users.insert().execute(user_id=7, user_name='fido') - addresses.insert().execute(address_id=7, user_id=7, address='addr5') + users.insert().execute(user_id=1, user_name="john") + addresses.insert().execute(address_id=1, user_id=1, address="addr1") + users.insert().execute(user_id=2, user_name="jack") + addresses.insert().execute(address_id=2, user_id=2, address="addr1") + users.insert().execute(user_id=3, user_name="ed") + addresses.insert().execute(address_id=3, user_id=3, address="addr2") + users.insert().execute(user_id=4, user_name="wendy") + addresses.insert().execute(address_id=4, user_id=4, address="addr3") + users.insert().execute(user_id=5, user_name="laura") + addresses.insert().execute(address_id=5, user_id=5, address="addr4") + users.insert().execute(user_id=6, user_name="ralph") + addresses.insert().execute(address_id=6, user_id=6, address="addr5") + users.insert().execute(user_id=7, user_name="fido") + addresses.insert().execute(address_id=7, user_id=7, address="addr5") @classmethod def teardown_class(cls): metadata.drop_all() def test_select_limit(self): - r = users.select(limit=3, order_by=[users.c.user_id]).execute(). \ - fetchall() - self.assert_(r == [(1, 'john'), (2, 'jack'), (3, 'ed')], repr(r)) + r = ( + users.select(limit=3, order_by=[users.c.user_id]) + .execute() + .fetchall() + ) + self.assert_(r == [(1, "john"), (2, "jack"), (3, "ed")], repr(r)) @testing.requires.offset def test_select_limit_offset(self): """Test the interaction between limit and offset""" - r = users.select(limit=3, offset=2, order_by=[users.c.user_id]). \ - execute().fetchall() - self.assert_(r == [(3, 'ed'), (4, 'wendy'), (5, 'laura')]) - r = users.select(offset=5, order_by=[users.c.user_id]).execute(). \ - fetchall() - self.assert_(r == [(6, 'ralph'), (7, 'fido')]) + r = ( + users.select(limit=3, offset=2, order_by=[users.c.user_id]) + .execute() + .fetchall() + ) + self.assert_(r == [(3, "ed"), (4, "wendy"), (5, "laura")]) + r = ( + users.select(offset=5, order_by=[users.c.user_id]) + .execute() + .fetchall() + ) + self.assert_(r == [(6, "ralph"), (7, "fido")]) def test_select_distinct_limit(self): """Test the interaction between limit and distinct""" r = sorted( - [x[0] for x in select([addresses.c.address]).distinct(). - limit(3).order_by(addresses.c.address).execute().fetchall()]) + [ + x[0] + for x in select([addresses.c.address]) + .distinct() + .limit(3) + .order_by(addresses.c.address) + .execute() + .fetchall() + ] + ) self.assert_(len(r) == 3, repr(r)) self.assert_(r[0] != r[1] and r[1] != r[2], repr(r)) @testing.requires.offset - @testing.fails_on('mssql', 'FIXME: unknown') + @testing.fails_on("mssql", "FIXME: unknown") def test_select_distinct_offset(self): """Test the interaction between distinct and offset""" r = sorted( - [x[0] for x in select([addresses.c.address]).distinct(). - offset(1).order_by(addresses.c.address). - execute().fetchall()]) + [ + x[0] + for x in select([addresses.c.address]) + .distinct() + .offset(1) + .order_by(addresses.c.address) + .execute() + .fetchall() + ] + ) eq_(len(r), 4) self.assert_(r[0] != r[1] and r[1] != r[2] and r[2] != [3], repr(r)) @@ -830,8 +1028,15 @@ class LimitTest(fixtures.TestBase): def test_select_distinct_limit_offset(self): """Test the interaction between limit and limit/offset""" - r = select([addresses.c.address]).order_by(addresses.c.address). \ - distinct().offset(2).limit(3).execute().fetchall() + r = ( + select([addresses.c.address]) + .order_by(addresses.c.address) + .distinct() + .offset(2) + .limit(3) + .execute() + .fetchall() + ) self.assert_(len(r) == 3, repr(r)) self.assert_(r[0] != r[1] and r[1] != r[2], repr(r)) @@ -848,46 +1053,67 @@ class CompoundTest(fixtures.TestBase): global metadata, t1, t2, t3 metadata = MetaData(testing.db) t1 = Table( - 't1', metadata, + "t1", + metadata, Column( - 'col1', Integer, test_needs_autoincrement=True, - primary_key=True), - Column('col2', String(30)), - Column('col3', String(40)), - Column('col4', String(30))) + "col1", + Integer, + test_needs_autoincrement=True, + primary_key=True, + ), + Column("col2", String(30)), + Column("col3", String(40)), + Column("col4", String(30)), + ) t2 = Table( - 't2', metadata, + "t2", + metadata, Column( - 'col1', Integer, test_needs_autoincrement=True, - primary_key=True), - Column('col2', String(30)), - Column('col3', String(40)), - Column('col4', String(30))) + "col1", + Integer, + test_needs_autoincrement=True, + primary_key=True, + ), + Column("col2", String(30)), + Column("col3", String(40)), + Column("col4", String(30)), + ) t3 = Table( - 't3', metadata, + "t3", + metadata, Column( - 'col1', Integer, test_needs_autoincrement=True, - primary_key=True), - Column('col2', String(30)), - Column('col3', String(40)), - Column('col4', String(30))) + "col1", + Integer, + test_needs_autoincrement=True, + primary_key=True, + ), + Column("col2", String(30)), + Column("col3", String(40)), + Column("col4", String(30)), + ) metadata.create_all() - t1.insert().execute([ - dict(col2="t1col2r1", col3="aaa", col4="aaa"), - dict(col2="t1col2r2", col3="bbb", col4="bbb"), - dict(col2="t1col2r3", col3="ccc", col4="ccc"), - ]) - t2.insert().execute([ - dict(col2="t2col2r1", col3="aaa", col4="bbb"), - dict(col2="t2col2r2", col3="bbb", col4="ccc"), - dict(col2="t2col2r3", col3="ccc", col4="aaa"), - ]) - t3.insert().execute([ - dict(col2="t3col2r1", col3="aaa", col4="ccc"), - dict(col2="t3col2r2", col3="bbb", col4="aaa"), - dict(col2="t3col2r3", col3="ccc", col4="bbb"), - ]) + t1.insert().execute( + [ + dict(col2="t1col2r1", col3="aaa", col4="aaa"), + dict(col2="t1col2r2", col3="bbb", col4="bbb"), + dict(col2="t1col2r3", col3="ccc", col4="ccc"), + ] + ) + t2.insert().execute( + [ + dict(col2="t2col2r1", col3="aaa", col4="bbb"), + dict(col2="t2col2r2", col3="bbb", col4="ccc"), + dict(col2="t2col2r3", col3="ccc", col4="aaa"), + ] + ) + t3.insert().execute( + [ + dict(col2="t3col2r1", col3="aaa", col4="ccc"), + dict(col2="t3col2r2", col3="bbb", col4="aaa"), + dict(col2="t3col2r3", col3="ccc", col4="bbb"), + ] + ) @engines.close_first def teardown(self): @@ -903,70 +1129,92 @@ class CompoundTest(fixtures.TestBase): @testing.requires.subqueries def test_union(self): (s1, s2) = ( - select([t1.c.col3.label('col3'), t1.c.col4.label('col4')], - t1.c.col2.in_(["t1col2r1", "t1col2r2"])), - select([t2.c.col3.label('col3'), t2.c.col4.label('col4')], - t2.c.col2.in_(["t2col2r2", "t2col2r3"])) + select( + [t1.c.col3.label("col3"), t1.c.col4.label("col4")], + t1.c.col2.in_(["t1col2r1", "t1col2r2"]), + ), + select( + [t2.c.col3.label("col3"), t2.c.col4.label("col4")], + t2.c.col2.in_(["t2col2r2", "t2col2r3"]), + ), ) u = union(s1, s2) - wanted = [('aaa', 'aaa'), ('bbb', 'bbb'), ('bbb', 'ccc'), - ('ccc', 'aaa')] + wanted = [ + ("aaa", "aaa"), + ("bbb", "bbb"), + ("bbb", "ccc"), + ("ccc", "aaa"), + ] found1 = self._fetchall_sorted(u.execute()) eq_(found1, wanted) - found2 = self._fetchall_sorted(u.alias('bar').select().execute()) + found2 = self._fetchall_sorted(u.alias("bar").select().execute()) eq_(found2, wanted) - @testing.fails_on('firebird', "doesn't like ORDER BY with UNIONs") + @testing.fails_on("firebird", "doesn't like ORDER BY with UNIONs") def test_union_ordered(self): (s1, s2) = ( - select([t1.c.col3.label('col3'), t1.c.col4.label('col4')], - t1.c.col2.in_(["t1col2r1", "t1col2r2"])), - select([t2.c.col3.label('col3'), t2.c.col4.label('col4')], - t2.c.col2.in_(["t2col2r2", "t2col2r3"])) + select( + [t1.c.col3.label("col3"), t1.c.col4.label("col4")], + t1.c.col2.in_(["t1col2r1", "t1col2r2"]), + ), + select( + [t2.c.col3.label("col3"), t2.c.col4.label("col4")], + t2.c.col2.in_(["t2col2r2", "t2col2r3"]), + ), ) - u = union(s1, s2, order_by=['col3', 'col4']) - - wanted = [('aaa', 'aaa'), ('bbb', 'bbb'), ('bbb', 'ccc'), - ('ccc', 'aaa')] + u = union(s1, s2, order_by=["col3", "col4"]) + + wanted = [ + ("aaa", "aaa"), + ("bbb", "bbb"), + ("bbb", "ccc"), + ("ccc", "aaa"), + ] eq_(u.execute().fetchall(), wanted) - @testing.fails_on('firebird', "doesn't like ORDER BY with UNIONs") + @testing.fails_on("firebird", "doesn't like ORDER BY with UNIONs") @testing.requires.subqueries def test_union_ordered_alias(self): (s1, s2) = ( - select([t1.c.col3.label('col3'), t1.c.col4.label('col4')], - t1.c.col2.in_(["t1col2r1", "t1col2r2"])), - select([t2.c.col3.label('col3'), t2.c.col4.label('col4')], - t2.c.col2.in_(["t2col2r2", "t2col2r3"])) + select( + [t1.c.col3.label("col3"), t1.c.col4.label("col4")], + t1.c.col2.in_(["t1col2r1", "t1col2r2"]), + ), + select( + [t2.c.col3.label("col3"), t2.c.col4.label("col4")], + t2.c.col2.in_(["t2col2r2", "t2col2r3"]), + ), ) - u = union(s1, s2, order_by=['col3', 'col4']) + u = union(s1, s2, order_by=["col3", "col4"]) - wanted = [('aaa', 'aaa'), ('bbb', 'bbb'), ('bbb', 'ccc'), - ('ccc', 'aaa')] - eq_(u.alias('bar').select().execute().fetchall(), wanted) + wanted = [ + ("aaa", "aaa"), + ("bbb", "bbb"), + ("bbb", "ccc"), + ("ccc", "aaa"), + ] + eq_(u.alias("bar").select().execute().fetchall(), wanted) - @testing.crashes('oracle', 'FIXME: unknown, verify not fails_on') + @testing.crashes("oracle", "FIXME: unknown, verify not fails_on") @testing.fails_on( - 'firebird', - "has trouble extracting anonymous column from union subquery") - @testing.fails_on('mysql', 'FIXME: unknown') - @testing.fails_on('sqlite', 'FIXME: unknown') + "firebird", + "has trouble extracting anonymous column from union subquery", + ) + @testing.fails_on("mysql", "FIXME: unknown") + @testing.fails_on("sqlite", "FIXME: unknown") def test_union_all(self): e = union_all( select([t1.c.col3]), - union( - select([t1.c.col3]), - select([t1.c.col3]), - ) + union(select([t1.c.col3]), select([t1.c.col3])), ) - wanted = [('aaa',), ('aaa',), ('bbb',), ('bbb',), ('ccc',), ('ccc',)] + wanted = [("aaa",), ("aaa",), ("bbb",), ("bbb",), ("ccc",), ("ccc",)] found1 = self._fetchall_sorted(e.execute()) eq_(found1, wanted) - found2 = self._fetchall_sorted(e.alias('foo').select().execute()) + found2 = self._fetchall_sorted(e.alias("foo").select().execute()) eq_(found2, wanted) def test_union_all_lightweight(self): @@ -976,49 +1224,52 @@ class CompoundTest(fixtures.TestBase): """ - u = union( - select([t1.c.col3]), - select([t1.c.col3]), - ).alias() + u = union(select([t1.c.col3]), select([t1.c.col3])).alias() - e = union_all( - select([t1.c.col3]), - select([u.c.col3]) - ) + e = union_all(select([t1.c.col3]), select([u.c.col3])) - wanted = [('aaa',), ('aaa',), ('bbb',), ('bbb',), ('ccc',), ('ccc',)] + wanted = [("aaa",), ("aaa",), ("bbb",), ("bbb",), ("ccc",), ("ccc",)] found1 = self._fetchall_sorted(e.execute()) eq_(found1, wanted) - found2 = self._fetchall_sorted(e.alias('foo').select().execute()) + found2 = self._fetchall_sorted(e.alias("foo").select().execute()) eq_(found2, wanted) @testing.requires.intersect def test_intersect(self): i = intersect( select([t2.c.col3, t2.c.col4]), - select([t2.c.col3, t2.c.col4], t2.c.col4 == t3.c.col3) + select([t2.c.col3, t2.c.col4], t2.c.col4 == t3.c.col3), ) - wanted = [('aaa', 'bbb'), ('bbb', 'ccc'), ('ccc', 'aaa')] + wanted = [("aaa", "bbb"), ("bbb", "ccc"), ("ccc", "aaa")] found1 = self._fetchall_sorted(i.execute()) eq_(found1, wanted) - found2 = self._fetchall_sorted(i.alias('bar').select().execute()) + found2 = self._fetchall_sorted(i.alias("bar").select().execute()) eq_(found2, wanted) @testing.requires.except_ - @testing.fails_on('sqlite', "Can't handle this style of nesting") + @testing.fails_on("sqlite", "Can't handle this style of nesting") def test_except_style1(self): - e = except_(union( - select([t1.c.col3, t1.c.col4]), + e = except_( + union( + select([t1.c.col3, t1.c.col4]), + select([t2.c.col3, t2.c.col4]), + select([t3.c.col3, t3.c.col4]), + ), select([t2.c.col3, t2.c.col4]), - select([t3.c.col3, t3.c.col4]), - ), select([t2.c.col3, t2.c.col4])) + ) - wanted = [('aaa', 'aaa'), ('aaa', 'ccc'), ('bbb', 'aaa'), - ('bbb', 'bbb'), ('ccc', 'bbb'), ('ccc', 'ccc')] + wanted = [ + ("aaa", "aaa"), + ("aaa", "ccc"), + ("bbb", "aaa"), + ("bbb", "bbb"), + ("ccc", "bbb"), + ("ccc", "ccc"), + ] found = self._fetchall_sorted(e.alias().select().execute()) eq_(found, wanted) @@ -1028,14 +1279,25 @@ class CompoundTest(fixtures.TestBase): # same as style1, but add alias().select() to the except_(). # sqlite can handle it now. - e = except_(union( - select([t1.c.col3, t1.c.col4]), + e = except_( + union( + select([t1.c.col3, t1.c.col4]), + select([t2.c.col3, t2.c.col4]), + select([t3.c.col3, t3.c.col4]), + ) + .alias() + .select(), select([t2.c.col3, t2.c.col4]), - select([t3.c.col3, t3.c.col4]), - ).alias().select(), select([t2.c.col3, t2.c.col4])) + ) - wanted = [('aaa', 'aaa'), ('aaa', 'ccc'), ('bbb', 'aaa'), - ('bbb', 'bbb'), ('ccc', 'bbb'), ('ccc', 'ccc')] + wanted = [ + ("aaa", "aaa"), + ("aaa", "ccc"), + ("bbb", "aaa"), + ("bbb", "bbb"), + ("ccc", "bbb"), + ("ccc", "ccc"), + ] found1 = self._fetchall_sorted(e.execute()) eq_(found1, wanted) @@ -1044,7 +1306,8 @@ class CompoundTest(fixtures.TestBase): eq_(found2, wanted) @testing.fails_on( - ['sqlite', 'mysql'], "Can't handle this style of nesting") + ["sqlite", "mysql"], "Can't handle this style of nesting" + ) @testing.requires.except_ def test_except_style3(self): # aaa, bbb, ccc - (aaa, bbb, ccc - (ccc)) = ccc @@ -1052,11 +1315,11 @@ class CompoundTest(fixtures.TestBase): select([t1.c.col3]), # aaa, bbb, ccc except_( select([t2.c.col3]), # aaa, bbb, ccc - select([t3.c.col3], t3.c.col3 == 'ccc'), # ccc - ) + select([t3.c.col3], t3.c.col3 == "ccc"), # ccc + ), ) - eq_(e.execute().fetchall(), [('ccc',)]) - eq_(e.alias('foo').select().execute().fetchall(), [('ccc',)]) + eq_(e.execute().fetchall(), [("ccc",)]) + eq_(e.alias("foo").select().execute().fetchall(), [("ccc",)]) @testing.requires.except_ def test_except_style4(self): @@ -1065,31 +1328,31 @@ class CompoundTest(fixtures.TestBase): select([t1.c.col3]), # aaa, bbb, ccc except_( select([t2.c.col3]), # aaa, bbb, ccc - select([t3.c.col3], t3.c.col3 == 'ccc'), # ccc - ).alias().select() + select([t3.c.col3], t3.c.col3 == "ccc"), # ccc + ) + .alias() + .select(), ) - eq_(e.execute().fetchall(), [('ccc',)]) - eq_( - e.alias().select().execute().fetchall(), - [('ccc',)] - ) + eq_(e.execute().fetchall(), [("ccc",)]) + eq_(e.alias().select().execute().fetchall(), [("ccc",)]) @testing.requires.intersect - @testing.fails_on(['sqlite', 'mysql'], - "sqlite can't handle leading parenthesis") + @testing.fails_on( + ["sqlite", "mysql"], "sqlite can't handle leading parenthesis" + ) def test_intersect_unions(self): u = intersect( union( - select([t1.c.col3, t1.c.col4]), - select([t3.c.col3, t3.c.col4]), + select([t1.c.col3, t1.c.col4]), select([t3.c.col3, t3.c.col4]) ), union( - select([t2.c.col3, t2.c.col4]), - select([t3.c.col3, t3.c.col4]), - ).alias().select() + select([t2.c.col3, t2.c.col4]), select([t3.c.col3, t3.c.col4]) + ) + .alias() + .select(), ) - wanted = [('aaa', 'ccc'), ('bbb', 'aaa'), ('ccc', 'bbb')] + wanted = [("aaa", "ccc"), ("bbb", "aaa"), ("ccc", "bbb")] found = self._fetchall_sorted(u.execute()) eq_(found, wanted) @@ -1098,15 +1361,17 @@ class CompoundTest(fixtures.TestBase): def test_intersect_unions_2(self): u = intersect( union( - select([t1.c.col3, t1.c.col4]), - select([t3.c.col3, t3.c.col4]), - ).alias().select(), + select([t1.c.col3, t1.c.col4]), select([t3.c.col3, t3.c.col4]) + ) + .alias() + .select(), union( - select([t2.c.col3, t2.c.col4]), - select([t3.c.col3, t3.c.col4]), - ).alias().select() + select([t2.c.col3, t2.c.col4]), select([t3.c.col3, t3.c.col4]) + ) + .alias() + .select(), ) - wanted = [('aaa', 'ccc'), ('bbb', 'aaa'), ('ccc', 'bbb')] + wanted = [("aaa", "ccc"), ("bbb", "aaa"), ("ccc", "bbb")] found = self._fetchall_sorted(u.execute()) eq_(found, wanted) @@ -1119,9 +1384,11 @@ class CompoundTest(fixtures.TestBase): select([t1.c.col3, t1.c.col4]), select([t2.c.col3, t2.c.col4]), select([t3.c.col3, t3.c.col4]), - ).alias().select() + ) + .alias() + .select(), ) - wanted = [('aaa', 'bbb'), ('bbb', 'ccc'), ('ccc', 'aaa')] + wanted = [("aaa", "bbb"), ("bbb", "ccc"), ("ccc", "aaa")] found = self._fetchall_sorted(u.execute()) eq_(found, wanted) @@ -1134,10 +1401,12 @@ class CompoundTest(fixtures.TestBase): select([t1.c.col3, t1.c.col4]), select([t2.c.col3, t2.c.col4]), select([t3.c.col3, t3.c.col4]), - ).alias().select() + ) + .alias() + .select(), ).alias() - wanted = [('aaa', 'bbb'), ('bbb', 'ccc'), ('ccc', 'aaa')] + wanted = [("aaa", "bbb"), ("bbb", "ccc"), ("ccc", "aaa")] found = self._fetchall_sorted(ua.select().execute()) eq_(found, wanted) @@ -1155,6 +1424,7 @@ class JoinTest(fixtures.TestBase): `JOIN rhs ON lhs.col=rhs.col` vs `rhs.col=lhs.col`. At least one database seems to be sensitive to this. """ + __backend__ = True @classmethod @@ -1163,29 +1433,42 @@ class JoinTest(fixtures.TestBase): global t1, t2, t3 metadata = MetaData(testing.db) - t1 = Table('t1', metadata, - Column('t1_id', Integer, primary_key=True), - Column('name', String(32))) - t2 = Table('t2', metadata, - Column('t2_id', Integer, primary_key=True), - Column('t1_id', Integer, ForeignKey('t1.t1_id')), - Column('name', String(32))) - t3 = Table('t3', metadata, - Column('t3_id', Integer, primary_key=True), - Column('t2_id', Integer, ForeignKey('t2.t2_id')), - Column('name', String(32))) + t1 = Table( + "t1", + metadata, + Column("t1_id", Integer, primary_key=True), + Column("name", String(32)), + ) + t2 = Table( + "t2", + metadata, + Column("t2_id", Integer, primary_key=True), + Column("t1_id", Integer, ForeignKey("t1.t1_id")), + Column("name", String(32)), + ) + t3 = Table( + "t3", + metadata, + Column("t3_id", Integer, primary_key=True), + Column("t2_id", Integer, ForeignKey("t2.t2_id")), + Column("name", String(32)), + ) metadata.drop_all() metadata.create_all() # t1.10 -> t2.20 -> t3.30 # t1.11 -> t2.21 # t1.12 - t1.insert().execute({'t1_id': 10, 'name': 't1 #10'}, - {'t1_id': 11, 'name': 't1 #11'}, - {'t1_id': 12, 'name': 't1 #12'}) - t2.insert().execute({'t2_id': 20, 't1_id': 10, 'name': 't2 #20'}, - {'t2_id': 21, 't1_id': 11, 'name': 't2 #21'}) - t3.insert().execute({'t3_id': 30, 't2_id': 20, 'name': 't3 #30'}) + t1.insert().execute( + {"t1_id": 10, "name": "t1 #10"}, + {"t1_id": 11, "name": "t1 #11"}, + {"t1_id": 12, "name": "t1 #12"}, + ) + t2.insert().execute( + {"t2_id": 20, "t1_id": 10, "name": "t2 #20"}, + {"t2_id": 21, "t1_id": 11, "name": "t2 #21"}, + ) + t3.insert().execute({"t3_id": 30, "t2_id": 20, "name": "t3 #30"}) @classmethod def teardown_class(cls): @@ -1194,8 +1477,7 @@ class JoinTest(fixtures.TestBase): def assertRows(self, statement, expected): """Execute a statement and assert that rows returned equal expected.""" - found = sorted([tuple(row) - for row in statement.execute().fetchall()]) + found = sorted([tuple(row) for row in statement.execute().fetchall()]) eq_(found, sorted(expected)) @@ -1204,8 +1486,8 @@ class JoinTest(fixtures.TestBase): for criteria in (t1.c.t1_id == t2.c.t1_id, t2.c.t1_id == t1.c.t1_id): expr = select( - [t1.c.t1_id, t2.c.t2_id], - from_obj=[t1.join(t2, criteria)]) + [t1.c.t1_id, t2.c.t2_id], from_obj=[t1.join(t2, criteria)] + ) self.assertRows(expr, [(10, 20), (11, 21)]) def test_join_x2(self): @@ -1213,8 +1495,8 @@ class JoinTest(fixtures.TestBase): for criteria in (t1.c.t1_id == t2.c.t1_id, t2.c.t1_id == t1.c.t1_id): expr = select( - [t1.c.t1_id, t2.c.t2_id], - from_obj=[t1.join(t2, criteria)]) + [t1.c.t1_id, t2.c.t2_id], from_obj=[t1.join(t2, criteria)] + ) self.assertRows(expr, [(10, 20), (11, 21)]) def test_outerjoin_x1(self): @@ -1223,7 +1505,8 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id], - from_obj=[t1.join(t2).join(t3, criteria)]) + from_obj=[t1.join(t2).join(t3, criteria)], + ) self.assertRows(expr, [(10, 20)]) def test_outerjoin_x2(self): @@ -1232,10 +1515,15 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - from_obj=[t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria)]) + from_obj=[ + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ], + ) self.assertRows( - expr, [(10, 20, 30), (11, 21, None), (12, None, None)]) + expr, [(10, 20, 30), (11, 21, None), (12, None, None)] + ) def test_outerjoin_where_x2_t1(self): """Outer joins t1->t2,t3, where on t1.""" @@ -1243,16 +1531,28 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t1.c.name == 't1 #10', - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + t1.c.name == "t1 #10", + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], t1.c.t1_id < 12, - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30), (11, 21, None)]) def test_outerjoin_where_x2_t2(self): @@ -1261,16 +1561,28 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t2.c.name == 't2 #20', - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + t2.c.name == "t2 #20", + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], t2.c.t2_id < 29, - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30), (11, 21, None)]) def test_outerjoin_where_x2_t3(self): @@ -1279,16 +1591,28 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t3.c.name == 't3 #30', - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + t3.c.name == "t3 #30", + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], t3.c.t3_id < 39, - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) def test_outerjoin_where_x2_t1t3(self): @@ -1297,16 +1621,28 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t1.c.name == 't1 #10', t3.c.name == 't3 #30'), - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + and_(t1.c.name == "t1 #10", t3.c.name == "t3 #30"), + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], and_(t1.c.t1_id < 19, t3.c.t3_id < 39), - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) def test_outerjoin_where_x2_t1t2(self): @@ -1315,16 +1651,28 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t1.c.name == 't1 #10', t2.c.name == 't2 #20'), - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + and_(t1.c.name == "t1 #10", t2.c.name == "t2 #20"), + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], and_(t1.c.t1_id < 12, t2.c.t2_id < 39), - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30), (11, 21, None)]) def test_outerjoin_where_x2_t1t2t3(self): @@ -1333,19 +1681,32 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t1.c.name == 't1 #10', - t2.c.name == 't2 #20', - t3.c.name == 't3 #30'), - from_obj=[(t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + and_( + t1.c.name == "t1 #10", + t2.c.name == "t2 #20", + t3.c.name == "t3 #30", + ), + from_obj=[ + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], and_(t1.c.t1_id < 19, t2.c.t2_id < 29, t3.c.t3_id < 39), from_obj=[ - (t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id). - outerjoin(t3, criteria))]) + ( + t1.outerjoin(t2, t1.c.t1_id == t2.c.t1_id).outerjoin( + t3, criteria + ) + ) + ], + ) self.assertRows(expr, [(10, 20, 30)]) def test_mixed(self): @@ -1354,7 +1715,8 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) print(expr) self.assertRows(expr, [(10, 20, 30), (11, 21, None)]) @@ -1364,40 +1726,48 @@ class JoinTest(fixtures.TestBase): for criteria in (t2.c.t2_id == t3.c.t2_id, t3.c.t2_id == t2.c.t2_id): expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t1.c.name == 't1 #10', - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + t1.c.name == "t1 #10", + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t2.c.name == 't2 #20', - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + t2.c.name == "t2 #20", + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - t3.c.name == 't3 #30', - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + t3.c.name == "t3 #30", + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t1.c.name == 't1 #10', t2.c.name == 't2 #20'), - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + and_(t1.c.name == "t1 #10", t2.c.name == "t2 #20"), + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t2.c.name == 't2 #20', t3.c.name == 't3 #30'), - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + and_(t2.c.name == "t2 #20", t3.c.name == "t3 #30"), + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) expr = select( [t1.c.t1_id, t2.c.t2_id, t3.c.t3_id], - and_(t1.c.name == 't1 #10', - t2.c.name == 't2 #20', - t3.c.name == 't3 #30'), - from_obj=[(t1.join(t2).outerjoin(t3, criteria))]) + and_( + t1.c.name == "t1 #10", + t2.c.name == "t2 #20", + t3.c.name == "t3 #30", + ), + from_obj=[(t1.join(t2).outerjoin(t3, criteria))], + ) self.assertRows(expr, [(10, 20, 30)]) @@ -1412,19 +1782,22 @@ class OperatorTest(fixtures.TestBase): global metadata, flds metadata = MetaData(testing.db) flds = Table( - 'flds', metadata, + "flds", + metadata, Column( - 'idcol', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('intcol', Integer), - Column('strcol', String(50)), + "idcol", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("intcol", Integer), + Column("strcol", String(50)), ) metadata.create_all() - flds.insert().execute([ - dict(intcol=5, strcol='foo'), - dict(intcol=13, strcol='bar') - ]) + flds.insert().execute( + [dict(intcol=5, strcol="foo"), dict(intcol=13, strcol="bar")] + ) @classmethod def teardown_class(cls): @@ -1433,16 +1806,19 @@ class OperatorTest(fixtures.TestBase): # TODO: seems like more tests warranted for this setup. def test_modulo(self): eq_( - select([flds.c.intcol % 3], - order_by=flds.c.idcol).execute().fetchall(), - [(2,), (1,)] + select([flds.c.intcol % 3], order_by=flds.c.idcol) + .execute() + .fetchall(), + [(2,), (1,)], ) @testing.requires.window_functions def test_over(self): eq_( - select([ - flds.c.intcol, func.row_number().over(order_by=flds.c.strcol) - ]).execute().fetchall(), - [(13, 1), (5, 2)] + select( + [flds.c.intcol, func.row_number().over(order_by=flds.c.strcol)] + ) + .execute() + .fetchall(), + [(13, 1), (5, 2)], ) diff --git a/test/sql/test_quote.py b/test/sql/test_quote.py index a51e14244..4cc185298 100644 --- a/test/sql/test_quote.py +++ b/test/sql/test_quote.py @@ -1,5 +1,15 @@ -from sqlalchemy import MetaData, Table, Column, Integer, select, \ - ForeignKey, Index, CheckConstraint, inspect, column +from sqlalchemy import ( + MetaData, + Table, + Column, + Integer, + select, + ForeignKey, + Index, + CheckConstraint, + inspect, + column, +) from sqlalchemy import sql, schema, types as sqltypes from sqlalchemy.sql import compiler from sqlalchemy.testing import fixtures, AssertsCompiledSQL, eq_ @@ -21,15 +31,21 @@ class QuoteExecTest(fixtures.TestBase): global table1, table2 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')) - table2 = Table('WorstCase2', metadata, - Column('desc', Integer, primary_key=True, key='d123'), - Column('Union', Integer, key='u123'), - Column('MixedCase', Integer)) + table1 = Table( + "WorstCase1", + metadata, + 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), + ) table1.create() table2.create() @@ -45,8 +61,8 @@ class QuoteExecTest(fixtures.TestBase): def test_reflect(self): meta2 = MetaData(testing.db) - t2 = Table('WorstCase1', meta2, autoload=True, quote=True) - assert 'lowercase' in t2.c + t2 = Table("WorstCase1", meta2, autoload=True, quote=True) + assert "lowercase" in t2.c # indicates the DB returns unquoted names as # UPPERCASE, which we then assume are unquoted and go to @@ -54,16 +70,16 @@ class QuoteExecTest(fixtures.TestBase): # names from a "name normalize" backend, as they cannot be # distinguished from case-insensitive/unquoted names. if testing.db.dialect.requires_name_normalize: - assert 'uppercase' in t2.c + assert "uppercase" in t2.c else: - assert 'UPPERCASE' in t2.c + assert "UPPERCASE" in t2.c # ASC OTOH is a reserved word, which is always quoted, so # with that name we keep the quotes on and it stays uppercase # regardless. Seems a little weird, though. - assert 'ASC' in t2.c + assert "ASC" in t2.c - assert 'MixedCase' in t2.c + assert "MixedCase" in t2.c @testing.provide_metadata def test_has_table_case_sensitive(self): @@ -72,97 +88,101 @@ class QuoteExecTest(fixtures.TestBase): testing.db.execute("CREATE TABLE TAB1 (id INTEGER)") else: testing.db.execute("CREATE TABLE tab1 (id INTEGER)") - testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("tab2")) - testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("TAB3")) - testing.db.execute('CREATE TABLE %s (id INTEGER)' % - preparer.quote_identifier("TAB4")) - - t1 = Table('tab1', self.metadata, - Column('id', Integer, primary_key=True), - ) - t2 = Table('tab2', self.metadata, - Column('id', Integer, primary_key=True), - quote=True - ) - t3 = Table('TAB3', self.metadata, - Column('id', Integer, primary_key=True), - ) - t4 = Table('TAB4', self.metadata, - Column('id', Integer, primary_key=True), - quote=True) + testing.db.execute( + "CREATE TABLE %s (id INTEGER)" % preparer.quote_identifier("tab2") + ) + testing.db.execute( + "CREATE TABLE %s (id INTEGER)" % preparer.quote_identifier("TAB3") + ) + testing.db.execute( + "CREATE TABLE %s (id INTEGER)" % preparer.quote_identifier("TAB4") + ) + + t1 = Table( + "tab1", self.metadata, Column("id", Integer, primary_key=True) + ) + t2 = Table( + "tab2", + self.metadata, + Column("id", Integer, primary_key=True), + quote=True, + ) + t3 = Table( + "TAB3", self.metadata, Column("id", Integer, primary_key=True) + ) + t4 = Table( + "TAB4", + self.metadata, + Column("id", Integer, primary_key=True), + quote=True, + ) insp = inspect(testing.db) assert testing.db.has_table(t1.name) - eq_([c['name'] for c in insp.get_columns(t1.name)], ['id']) + eq_([c["name"] for c in insp.get_columns(t1.name)], ["id"]) assert testing.db.has_table(t2.name) - eq_([c['name'] for c in insp.get_columns(t2.name)], ['id']) + eq_([c["name"] for c in insp.get_columns(t2.name)], ["id"]) assert testing.db.has_table(t3.name) - eq_([c['name'] for c in insp.get_columns(t3.name)], ['id']) + eq_([c["name"] for c in insp.get_columns(t3.name)], ["id"]) assert testing.db.has_table(t4.name) - eq_([c['name'] for c in insp.get_columns(t4.name)], ['id']) + 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}, - {'lowercase': 2, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4}, - {'lowercase': 4, 'UPPERCASE': 3, 'MixedCase': 2, 'a123': 1}) + {"lowercase": 1, "UPPERCASE": 2, "MixedCase": 3, "a123": 4}, + {"lowercase": 2, "UPPERCASE": 2, "MixedCase": 3, "a123": 4}, + {"lowercase": 4, "UPPERCASE": 3, "MixedCase": 2, "a123": 1}, + ) table2.insert().execute( - {'d123': 1, 'u123': 2, 'MixedCase': 3}, - {'d123': 2, 'u123': 2, 'MixedCase': 3}, - {'d123': 4, 'u123': 3, 'MixedCase': 2}) + {"d123": 1, "u123": 2, "MixedCase": 3}, + {"d123": 2, "u123": 2, "MixedCase": 3}, + {"d123": 4, "u123": 3, "MixedCase": 2}, + ) columns = [ table1.c.lowercase, table1.c.UPPERCASE, table1.c.MixedCase, - table1.c.a123 + table1.c.a123, ] result = select(columns).execute().fetchall() - assert(result == [(1, 2, 3, 4), (2, 2, 3, 4), (4, 3, 2, 1)]) + assert result == [(1, 2, 3, 4), (2, 2, 3, 4), (4, 3, 2, 1)] - columns = [ - table2.c.d123, - table2.c.u123, - table2.c.MixedCase - ] + columns = [table2.c.d123, table2.c.u123, table2.c.MixedCase] result = select(columns).execute().fetchall() - assert(result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)]) + assert result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)] def test_use_labels(self): table1.insert().execute( - {'lowercase': 1, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4}, - {'lowercase': 2, 'UPPERCASE': 2, 'MixedCase': 3, 'a123': 4}, - {'lowercase': 4, 'UPPERCASE': 3, 'MixedCase': 2, 'a123': 1}) + {"lowercase": 1, "UPPERCASE": 2, "MixedCase": 3, "a123": 4}, + {"lowercase": 2, "UPPERCASE": 2, "MixedCase": 3, "a123": 4}, + {"lowercase": 4, "UPPERCASE": 3, "MixedCase": 2, "a123": 1}, + ) table2.insert().execute( - {'d123': 1, 'u123': 2, 'MixedCase': 3}, - {'d123': 2, 'u123': 2, 'MixedCase': 3}, - {'d123': 4, 'u123': 3, 'MixedCase': 2}) + {"d123": 1, "u123": 2, "MixedCase": 3}, + {"d123": 2, "u123": 2, "MixedCase": 3}, + {"d123": 4, "u123": 3, "MixedCase": 2}, + ) columns = [ table1.c.lowercase, table1.c.UPPERCASE, table1.c.MixedCase, - table1.c.a123 + table1.c.a123, ] result = select(columns, use_labels=True).execute().fetchall() - assert(result == [(1, 2, 3, 4), (2, 2, 3, 4), (4, 3, 2, 1)]) + assert result == [(1, 2, 3, 4), (2, 2, 3, 4), (4, 3, 2, 1)] - columns = [ - table2.c.d123, - table2.c.u123, - table2.c.MixedCase - ] + columns = [table2.c.d123, table2.c.u123, table2.c.MixedCase] result = select(columns, use_labels=True).execute().fetchall() - assert(result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)]) + assert result == [(1, 2, 3), (2, 2, 3), (4, 3, 2)] class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @classmethod def setup_class(cls): @@ -173,17 +193,23 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): global table1, table2 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')) - table2 = Table('WorstCase2', metadata, - 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') + table1 = Table( + "WorstCase1", + metadata, + 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), + ) + + @testing.crashes("oracle", "FIXME: unknown, verify not fails_on") @testing.requires.subqueries def test_labels(self): """test the quoting of labels. @@ -206,38 +232,41 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): """ self.assert_compile( - table1.select(distinct=True).alias('LaLa').select(), - 'SELECT ' + table1.select(distinct=True).alias("LaLa").select(), + "SELECT " '"LaLa".lowercase, ' '"LaLa"."UPPERCASE", ' '"LaLa"."MixedCase", ' '"LaLa"."ASC" ' - 'FROM (' - 'SELECT DISTINCT ' + "FROM (" + "SELECT DISTINCT " '"WorstCase1".lowercase AS lowercase, ' '"WorstCase1"."UPPERCASE" AS "UPPERCASE", ' '"WorstCase1"."MixedCase" AS "MixedCase", ' '"WorstCase1"."ASC" AS "ASC" ' 'FROM "WorstCase1"' - ') AS "LaLa"' + ') AS "LaLa"', ) def test_lower_case_names(self): # Create table with quote defaults metadata = MetaData() - t1 = Table('t1', metadata, - Column('col1', Integer), - schema='foo') + t1 = Table("t1", metadata, 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)' + result = "CREATE TABLE foo.t1 (col1 INTEGER)" self.assert_compile(schema.CreateTable(t1), result) # 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) + t1 = Table( + "t1", + metadata, + 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)' @@ -246,9 +275,7 @@ class QuoteTest(fixtures.TestBase, AssertsCompiledSQL): def test_upper_case_names(self): # Create table with quote defaults metadata = MetaData() - t1 = Table('TABLE1', metadata, - Column('COL1', Integer), - schema='FOO') + t1 = Table("TABLE1", metadata, 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)' @@ -256,20 +283,23 @@ 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) + t1 = Table( + "TABLE1", + metadata, + 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)' + result = "CREATE TABLE FOO.TABLE1 (COL1 INTEGER)" self.assert_compile(schema.CreateTable(t1), result) def test_mixed_case_names(self): # Create table with quote defaults metadata = MetaData() - t1 = Table('Table1', metadata, - Column('Col1', Integer), - schema='Foo') + t1 = Table("Table1", metadata, 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)' @@ -277,20 +307,25 @@ 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) + t1 = Table( + "Table1", + metadata, + 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)' + result = "CREATE TABLE Foo.Table1 (Col1 INTEGER)" self.assert_compile(schema.CreateTable(t1), result) def test_numeric_initial_char(self): # Create table with quote defaults metadata = MetaData() - t1 = Table('35table', metadata, - Column('25column', Integer), - schema='45schema') + t1 = Table( + "35table", metadata, Column("25column", Integer), schema="45schema" + ) # Note that the names are quoted b/c the initial # character is in ['$','0', '1' ... '9'] @@ -299,20 +334,25 @@ 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) + t1 = Table( + "35table", + metadata, + 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)' + result = "CREATE TABLE 45schema.35table (25column INTEGER)" self.assert_compile(schema.CreateTable(t1), result) def test_illegal_initial_char(self): # Create table with quote defaults metadata = MetaData() - t1 = Table('$table', metadata, - Column('$column', Integer), - schema='$schema') + t1 = Table( + "$table", metadata, Column("$column", Integer), schema="$schema" + ) # Note that the names are quoted b/c the initial # character is in ['$','0', '1' ... '9'] @@ -321,384 +361,400 @@ 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) + t1 = Table( + "$table", + metadata, + 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)' + result = "CREATE TABLE $schema.$table ($column INTEGER)" self.assert_compile(schema.CreateTable(t1), result) def test_reserved_words(self): # Create table with quote defaults metadata = MetaData() - table = Table('foreign', metadata, - Column('col1', Integer), - Column('from', Integer), - Column('order', Integer), - schema='create') + table = Table( + "foreign", + metadata, + 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"' - ) + 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"', + ) # 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) + table = Table( + "foreign", + metadata, + 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' - ) + 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", + ) def test_subquery_one(self): # Lower case names, should not quote metadata = MetaData() - t1 = Table('t1', metadata, - Column('col1', Integer), - schema='foo') - a = t1.select().alias('anon') + t1 = Table("t1", metadata, 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' - ) + self.assert_compile( + b, + "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) - a = t1.select().alias('anon') + t1 = Table( + "t1", + metadata, + 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' - ) + self.assert_compile( + b, + "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') - a = t1.select().alias('Anon') + t1 = Table("T1", metadata, 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' - ) + self.assert_compile( + b, + "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) - a = t1.select().alias('Anon') + t1 = Table( + "T1", + metadata, + 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' - ) + self.assert_compile( + b, + "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() - t1 = Table('t1', m, Column('col1', Integer)) - cl = t1.c.col1.label('ShouldQuote') + t1 = Table("t1", m, Column("col1", Integer)) + cl = t1.c.col1.label("ShouldQuote") self.assert_compile( select([cl]).order_by(cl), - 'SELECT t1.col1 AS "ShouldQuote" FROM t1 ORDER BY "ShouldQuote"' + 'SELECT t1.col1 AS "ShouldQuote" FROM t1 ORDER BY "ShouldQuote"', ) def test_collate(self): - self.assert_compile( - column('foo').collate('utf8'), - "foo COLLATE utf8" - ) + self.assert_compile(column("foo").collate("utf8"), "foo COLLATE utf8") self.assert_compile( - column('foo').collate('fr_FR'), + column("foo").collate("fr_FR"), 'foo COLLATE "fr_FR"', - dialect="postgresql" + dialect="postgresql", ) self.assert_compile( - column('foo').collate('utf8_GERMAN_ci'), - 'foo COLLATE `utf8_GERMAN_ci`', - dialect="mysql" + column("foo").collate("utf8_GERMAN_ci"), + "foo COLLATE `utf8_GERMAN_ci`", + dialect="mysql", ) self.assert_compile( - column('foo').collate('SQL_Latin1_General_CP1_CI_AS'), - 'foo COLLATE SQL_Latin1_General_CP1_CI_AS', - dialect="mssql" + column("foo").collate("SQL_Latin1_General_CP1_CI_AS"), + "foo COLLATE SQL_Latin1_General_CP1_CI_AS", + dialect="mssql", ) def test_join(self): # Lower case names, should not quote metadata = MetaData() - t1 = Table('t1', metadata, - Column('col1', Integer)) - t2 = Table('t2', metadata, - 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' - ) + t1 = Table("t1", metadata, Column("col1", Integer)) + t2 = Table( + "t2", + metadata, + 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", + ) # Lower case names, quotes on, should quote metadata = MetaData() - t1 = Table('t1', metadata, - Column('col1', Integer, quote=True), - quote=True) + t1 = Table( + "t1", metadata, Column("col1", Integer, quote=True), quote=True + ) t2 = Table( - 't2', + "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"' - ) + 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"', + ) # Not lower case names, should quote metadata = MetaData() - t1 = Table('T1', metadata, - Column('Col1', Integer)) - t2 = Table('T2', metadata, - 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"' - ) + t1 = Table("T1", metadata, Column("Col1", Integer)) + t2 = Table( + "T2", + metadata, + 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"', + ) # Not lower case names, quotes off, should not quote metadata = MetaData() - t1 = Table('T1', metadata, - Column('Col1', Integer, quote=False), - quote=False) + t1 = Table( + "T1", metadata, Column("Col1", Integer, quote=False), quote=False + ) t2 = Table( - 'T2', + "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' - ) + 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", + ) def test_label_and_alias(self): # Lower case names, should not quote metadata = MetaData() - table = Table('t1', metadata, - 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' - ) + table = Table("t1", metadata, 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", + ) # Not lower case names, should quote metadata = MetaData() - table = Table('T1', metadata, - 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"' - ) + table = Table("T1", metadata, 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"', + ) def test_literal_column_already_with_quotes(self): # Lower case names metadata = MetaData() - table = Table('t1', metadata, - Column('col1', Integer)) + table = Table("t1", metadata, 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') + 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' - ) + self.assert_compile( + x, + "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)) + table = Table("T1", metadata, 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') + 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"' - ) + self.assert_compile( + x, + "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') + t1 = Table("T1", metadata, Column("Col1", Integer), schema="Foo") - self.assert_compile(t1.select().apply_labels(), - 'SELECT ' - '"Foo"."T1"."Col1" AS "Foo_T1_Col1" ' - 'FROM ' - '"Foo"."T1"' - ) + self.assert_compile( + t1.select().apply_labels(), + "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) + t1 = Table( + "T1", + metadata, + 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' - ) + self.assert_compile( + t1.select().apply_labels(), + "SELECT " "Foo.T1.Col1 AS Foo_T1_Col1 " "FROM " "Foo.T1", + ) def test_quote_flag_propagate_check_constraint(self): m = MetaData() - t = Table('t', m, Column('x', Integer, quote=True)) + t = Table("t", m, Column("x", Integer, quote=True)) CheckConstraint(t.c.x > 5) self.assert_compile( schema.CreateTable(t), - "CREATE TABLE t (" - '"x" INTEGER, ' - 'CHECK ("x" > 5)' - ")" + "CREATE TABLE t (" '"x" INTEGER, ' 'CHECK ("x" > 5)' ")", ) def test_quote_flag_propagate_index(self): m = MetaData() - t = Table('t', m, Column('x', Integer, quote=True)) + t = Table("t", m, Column("x", Integer, quote=True)) idx = Index("foo", t.c.x) self.assert_compile( - schema.CreateIndex(idx), - 'CREATE INDEX foo ON t ("x")' + schema.CreateIndex(idx), 'CREATE INDEX foo ON t ("x")' ) def test_quote_flag_propagate_anon_label(self): m = MetaData() - t = Table('t', m, Column('x', Integer, quote=True)) + t = Table("t", m, Column("x", Integer, quote=True)) self.assert_compile( select([t.alias()]).apply_labels(), - 'SELECT t_1."x" AS "t_1_x" FROM t AS t_1' + 'SELECT t_1."x" AS "t_1_x" FROM t AS t_1', ) - t2 = Table('t2', m, Column('x', Integer), quote=True) + t2 = Table("t2", m, Column("x", Integer), quote=True) self.assert_compile( select([t2.c.x]).apply_labels(), - 'SELECT "t2".x AS "t2_x" FROM "t2"' + 'SELECT "t2".x AS "t2_x" FROM "t2"', ) @@ -716,28 +772,27 @@ class PreparerTest(fixtures.TestBase): print("Received %s" % have) self.assert_(have == want) - a_eq(unformat('foo'), ['foo']) - a_eq(unformat('"foo"'), ['foo']) + a_eq(unformat("foo"), ["foo"]) + a_eq(unformat('"foo"'), ["foo"]) a_eq(unformat("'foo'"), ["'foo'"]) - a_eq(unformat('foo.bar'), ['foo', 'bar']) - a_eq(unformat('"foo"."bar"'), ['foo', 'bar']) - a_eq(unformat('foo."bar"'), ['foo', 'bar']) - a_eq(unformat('"foo".bar'), ['foo', 'bar']) - a_eq(unformat('"foo"."b""a""r"."baz"'), ['foo', 'b"a"r', 'baz']) + a_eq(unformat("foo.bar"), ["foo", "bar"]) + a_eq(unformat('"foo"."bar"'), ["foo", "bar"]) + a_eq(unformat('foo."bar"'), ["foo", "bar"]) + a_eq(unformat('"foo".bar'), ["foo", "bar"]) + a_eq(unformat('"foo"."b""a""r"."baz"'), ["foo", 'b"a"r', "baz"]) def test_unformat_custom(self): - class Custom(compiler.IdentifierPreparer): - def __init__(self, dialect): super(Custom, self).__init__( - dialect, initial_quote='`', final_quote='`') + dialect, initial_quote="`", final_quote="`" + ) def _escape_identifier(self, value): - return value.replace('`', '``') + return value.replace("`", "``") def _unescape_identifier(self, value): - return value.replace('``', '`') + return value.replace("``", "`") prep = Custom(default.DefaultDialect()) unformat = prep.unformat_identifiers @@ -748,18 +803,17 @@ class PreparerTest(fixtures.TestBase): print("Received %s" % have) self.assert_(have == want) - a_eq(unformat('foo'), ['foo']) - a_eq(unformat('`foo`'), ['foo']) - a_eq(unformat(repr('foo')), ["'foo'"]) - a_eq(unformat('foo.bar'), ['foo', 'bar']) - a_eq(unformat('`foo`.`bar`'), ['foo', 'bar']) - a_eq(unformat('foo.`bar`'), ['foo', 'bar']) - a_eq(unformat('`foo`.bar'), ['foo', 'bar']) - a_eq(unformat('`foo`.`b``a``r`.`baz`'), ['foo', 'b`a`r', 'baz']) + a_eq(unformat("foo"), ["foo"]) + a_eq(unformat("`foo`"), ["foo"]) + a_eq(unformat(repr("foo")), ["'foo'"]) + a_eq(unformat("foo.bar"), ["foo", "bar"]) + a_eq(unformat("`foo`.`bar`"), ["foo", "bar"]) + a_eq(unformat("foo.`bar`"), ["foo", "bar"]) + 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) @@ -819,13 +873,13 @@ class QuotedIdentTest(fixtures.TestBase): def test_apply_map_quoted(self): q1 = _anonymous_label(quoted_name("x%s", True)) - q2 = q1.apply_map(('bar')) + q2 = q1.apply_map(("bar")) eq_(q2, "xbar") eq_(q2.quote, True) def test_apply_map_plain(self): q1 = _anonymous_label(quoted_name("x%s", None)) - q2 = q1.apply_map(('bar')) + q2 = q1.apply_map(("bar")) eq_(q2, "xbar") self._assert_not_quoted(q2) diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py index 8e6279708..c5e1efef6 100644 --- a/test/sql/test_resultset.py +++ b/test/sql/test_resultset.py @@ -1,12 +1,36 @@ -from sqlalchemy.testing import eq_, assert_raises_message, assert_raises, \ - in_, not_in_, is_, ne_, le_ +from sqlalchemy.testing import ( + eq_, + assert_raises_message, + assert_raises, + in_, + not_in_, + is_, + ne_, + le_, +) from sqlalchemy import testing from sqlalchemy.testing import fixtures, engines from sqlalchemy import util from sqlalchemy import ( - exc, sql, func, select, String, Integer, MetaData, ForeignKey, - VARCHAR, INT, CHAR, text, type_coerce, literal_column, - TypeDecorator, table, column, literal) + exc, + sql, + func, + select, + String, + Integer, + MetaData, + ForeignKey, + VARCHAR, + INT, + CHAR, + text, + type_coerce, + literal_column, + TypeDecorator, + table, + column, + literal, +) from sqlalchemy.engine import result as _result from sqlalchemy.testing.schema import Table, Column import operator @@ -23,37 +47,43 @@ class ResultProxyTest(fixtures.TablesTest): @classmethod def define_tables(cls, metadata): Table( - 'users', metadata, + "users", + metadata, Column( - 'user_id', INT, primary_key=True, - test_needs_autoincrement=True), - Column('user_name', VARCHAR(20)), - test_needs_acid=True + "user_id", INT, primary_key=True, test_needs_autoincrement=True + ), + Column("user_name", VARCHAR(20)), + test_needs_acid=True, ) Table( - 'addresses', metadata, + "addresses", + metadata, Column( - 'address_id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('user_id', Integer, ForeignKey('users.user_id')), - Column('address', String(30)), - test_needs_acid=True + "address_id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("user_id", Integer, ForeignKey("users.user_id")), + Column("address", String(30)), + test_needs_acid=True, ) Table( - 'users2', metadata, - Column('user_id', INT, primary_key=True), - Column('user_name', VARCHAR(20)), - test_needs_acid=True + "users2", + metadata, + Column("user_id", INT, primary_key=True), + Column("user_name", VARCHAR(20)), + test_needs_acid=True, ) def test_row_iteration(self): users = self.tables.users users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) r = users.select().execute() rows = [] @@ -65,15 +95,15 @@ class ResultProxyTest(fixtures.TablesTest): users = self.tables.users users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) r = users.select().execute() rows = [] while True: - row = next(r, 'foo') - if row == 'foo': + row = next(r, "foo") + if row == "foo": break rows.append(row) eq_(len(rows), 3) @@ -83,27 +113,30 @@ class ResultProxyTest(fixtures.TablesTest): users = self.tables.users users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) - sel = select([users.c.user_id]).where(users.c.user_name == 'jack'). \ - as_scalar() + sel = ( + select([users.c.user_id]) + .where(users.c.user_name == "jack") + .as_scalar() + ) for row in select([sel + 1, sel + 3], bind=users.bind).execute(): - eq_(row['anon_1'], 8) - eq_(row['anon_2'], 10) + eq_(row["anon_1"], 8) + eq_(row["anon_2"], 10) def test_row_comparison(self): users = self.tables.users - users.insert().execute(user_id=7, user_name='jack') + users.insert().execute(user_id=7, user_name="jack") rp = users.select().execute().first() eq_(rp, rp) - is_(not(rp != rp), True) + is_(not (rp != rp), True) - equal = (7, 'jack') + equal = (7, "jack") eq_(rp, equal) eq_(equal, rp) @@ -113,15 +146,20 @@ class ResultProxyTest(fixtures.TablesTest): def endless(): while True: yield 1 + ne_(rp, endless()) ne_(endless(), rp) # test that everything compares the same # as it would against a tuple - for compare in [False, 8, endless(), 'xyz', (7, 'jack')]: + for compare in [False, 8, endless(), "xyz", (7, "jack")]: for op in [ - operator.eq, operator.ne, operator.gt, - operator.lt, operator.ge, operator.le + operator.eq, + operator.ne, + operator.gt, + operator.lt, + operator.ge, + operator.le, ]: try: @@ -142,94 +180,94 @@ class ResultProxyTest(fixtures.TablesTest): @testing.provide_metadata def test_column_label_overlap_fallback(self): - content = Table( - 'content', self.metadata, - Column('type', String(30)), - ) - bar = Table( - 'bar', self.metadata, - Column('content_type', String(30)) - ) + content = Table("content", self.metadata, Column("type", String(30))) + bar = Table("bar", self.metadata, Column("content_type", String(30))) self.metadata.create_all(testing.db) testing.db.execute(content.insert().values(type="t1")) row = testing.db.execute(content.select(use_labels=True)).first() in_(content.c.type, row) not_in_(bar.c.content_type, row) - in_(sql.column('content_type'), row) + in_(sql.column("content_type"), row) row = testing.db.execute( - select([content.c.type.label("content_type")])).first() + select([content.c.type.label("content_type")]) + ).first() in_(content.c.type, row) not_in_(bar.c.content_type, row) - in_(sql.column('content_type'), row) + in_(sql.column("content_type"), row) - row = testing.db.execute(select([func.now().label("content_type")])). \ - first() + row = testing.db.execute( + select([func.now().label("content_type")]) + ).first() not_in_(content.c.type, row) not_in_(bar.c.content_type, row) - in_(sql.column('content_type'), row) + in_(sql.column("content_type"), row) def test_pickled_rows(self): users = self.tables.users addresses = self.tables.addresses users.insert().execute( - {'user_id': 7, 'user_name': 'jack'}, - {'user_id': 8, 'user_name': 'ed'}, - {'user_id': 9, 'user_name': 'fred'}, + {"user_id": 7, "user_name": "jack"}, + {"user_id": 8, "user_name": "ed"}, + {"user_id": 9, "user_name": "fred"}, ) for pickle in False, True: for use_labels in False, True: - result = users.select(use_labels=use_labels).order_by( - users.c.user_id).execute().fetchall() + result = ( + users.select(use_labels=use_labels) + .order_by(users.c.user_id) + .execute() + .fetchall() + ) if pickle: result = util.pickle.loads(util.pickle.dumps(result)) - eq_( - result, - [(7, "jack"), (8, "ed"), (9, "fred")] - ) + eq_(result, [(7, "jack"), (8, "ed"), (9, "fred")]) if use_labels: - eq_(result[0]['users_user_id'], 7) + eq_(result[0]["users_user_id"], 7) eq_( list(result[0].keys()), - ["users_user_id", "users_user_name"]) + ["users_user_id", "users_user_name"], + ) else: - eq_(result[0]['user_id'], 7) + eq_(result[0]["user_id"], 7) eq_(list(result[0].keys()), ["user_id", "user_name"]) eq_(result[0][0], 7) eq_(result[0][users.c.user_id], 7) - eq_(result[0][users.c.user_name], 'jack') + eq_(result[0][users.c.user_name], "jack") if not pickle or use_labels: assert_raises( exc.NoSuchColumnError, - lambda: result[0][addresses.c.user_id]) + lambda: result[0][addresses.c.user_id], + ) else: # test with a different table. name resolution is # causing 'user_id' to match when use_labels wasn't used. eq_(result[0][addresses.c.user_id], 7) assert_raises( - exc.NoSuchColumnError, lambda: result[0]['fake key']) + exc.NoSuchColumnError, lambda: result[0]["fake key"] + ) assert_raises( exc.NoSuchColumnError, - lambda: result[0][addresses.c.address_id]) + lambda: result[0][addresses.c.address_id], + ) def test_column_error_printing(self): result = testing.db.execute(select([1])) row = result.first() class unprintable(object): - def __str__(self): raise ValueError("nope") @@ -242,25 +280,21 @@ class ResultProxyTest(fixtures.TablesTest): (unprintable(), "unprintable element.*"), ]: assert_raises_message( - exc.NoSuchColumnError, - msg % repl, - result._getter, accessor + exc.NoSuchColumnError, msg % repl, result._getter, accessor ) is_(result._getter(accessor, False), None) assert_raises_message( - exc.NoSuchColumnError, - msg % repl, - lambda: row[accessor] + exc.NoSuchColumnError, msg % repl, lambda: row[accessor] ) def test_fetchmany(self): users = self.tables.users - users.insert().execute(user_id=7, user_name='jack') - users.insert().execute(user_id=8, user_name='ed') - users.insert().execute(user_id=9, user_name='fred') + users.insert().execute(user_id=7, user_name="jack") + users.insert().execute(user_id=8, user_name="ed") + users.insert().execute(user_id=9, user_name="fred") r = users.select().execute() rows = [] for row in r.fetchmany(size=2): @@ -271,82 +305,80 @@ class ResultProxyTest(fixtures.TablesTest): users = self.tables.users addresses = self.tables.addresses - users.insert().execute(user_id=1, user_name='john') - users.insert().execute(user_id=2, user_name='jack') + users.insert().execute(user_id=1, user_name="john") + users.insert().execute(user_id=2, user_name="jack") addresses.insert().execute( - address_id=1, user_id=2, address='foo@bar.com') + address_id=1, user_id=2, address="foo@bar.com" + ) - r = text( - "select * from addresses", bind=testing.db).execute().first() + r = text("select * from addresses", bind=testing.db).execute().first() eq_(r[0:1], (1,)) - eq_(r[1:], (2, 'foo@bar.com')) + eq_(r[1:], (2, "foo@bar.com")) eq_(r[:-1], (1, 2)) def test_column_accessor_basic_compiled(self): users = self.tables.users users.insert().execute( - dict(user_id=1, user_name='john'), - dict(user_id=2, user_name='jack') + dict(user_id=1, user_name="john"), + dict(user_id=2, user_name="jack"), ) r = users.select(users.c.user_id == 2).execute().first() eq_(r.user_id, 2) - eq_(r['user_id'], 2) + eq_(r["user_id"], 2) eq_(r[users.c.user_id], 2) - eq_(r.user_name, 'jack') - eq_(r['user_name'], 'jack') - eq_(r[users.c.user_name], 'jack') + eq_(r.user_name, "jack") + eq_(r["user_name"], "jack") + eq_(r[users.c.user_name], "jack") def test_column_accessor_basic_text(self): users = self.tables.users users.insert().execute( - dict(user_id=1, user_name='john'), - dict(user_id=2, user_name='jack') + dict(user_id=1, user_name="john"), + dict(user_id=2, user_name="jack"), ) r = testing.db.execute( - text("select * from users where user_id=2")).first() + text("select * from users where user_id=2") + ).first() eq_(r.user_id, 2) - eq_(r['user_id'], 2) + eq_(r["user_id"], 2) eq_(r[users.c.user_id], 2) - eq_(r.user_name, 'jack') - eq_(r['user_name'], 'jack') - eq_(r[users.c.user_name], 'jack') + eq_(r.user_name, "jack") + eq_(r["user_name"], "jack") + eq_(r[users.c.user_name], "jack") def test_column_accessor_textual_select(self): users = self.tables.users users.insert().execute( - dict(user_id=1, user_name='john'), - dict(user_id=2, user_name='jack') + dict(user_id=1, user_name="john"), + dict(user_id=2, user_name="jack"), ) # this will create column() objects inside # the select(), these need to match on name anyway r = testing.db.execute( - select([ - column('user_id'), column('user_name') - ]).select_from(table('users')). - where(text('user_id=2')) + select([column("user_id"), column("user_name")]) + .select_from(table("users")) + .where(text("user_id=2")) ).first() eq_(r.user_id, 2) - eq_(r['user_id'], 2) + eq_(r["user_id"], 2) eq_(r[users.c.user_id], 2) - eq_(r.user_name, 'jack') - eq_(r['user_name'], 'jack') - eq_(r[users.c.user_name], 'jack') + eq_(r.user_name, "jack") + eq_(r["user_name"], "jack") + eq_(r[users.c.user_name], "jack") def test_column_accessor_dotted_union(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) # test a little sqlite < 3.10.0 weirdness - with the UNION, # cols come back as "users.user_id" in cursor.description @@ -358,106 +390,120 @@ class ResultProxyTest(fixtures.TablesTest): "users.user_name from users" ) ).first() - eq_(r['user_id'], 1) - eq_(r['user_name'], "john") + eq_(r["user_id"], 1) + eq_(r["user_name"], "john") eq_(list(r.keys()), ["user_id", "user_name"]) def test_column_accessor_sqlite_raw(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) - r = text( - "select users.user_id, users.user_name " - "from users " - "UNION select users.user_id, " - "users.user_name from users", - bind=testing.db).execution_options(sqlite_raw_colnames=True). \ - execute().first() + r = ( + text( + "select users.user_id, users.user_name " + "from users " + "UNION select users.user_id, " + "users.user_name from users", + bind=testing.db, + ) + .execution_options(sqlite_raw_colnames=True) + .execute() + .first() + ) if testing.against("sqlite < 3.10.0"): - not_in_('user_id', r) - not_in_('user_name', r) - eq_(r['users.user_id'], 1) - eq_(r['users.user_name'], "john") + not_in_("user_id", r) + not_in_("user_name", r) + eq_(r["users.user_id"], 1) + eq_(r["users.user_name"], "john") eq_(list(r.keys()), ["users.user_id", "users.user_name"]) else: - not_in_('users.user_id', r) - not_in_('users.user_name', r) - eq_(r['user_id'], 1) - eq_(r['user_name'], "john") + not_in_("users.user_id", r) + not_in_("users.user_name", r) + eq_(r["user_id"], 1) + eq_(r["user_name"], "john") eq_(list(r.keys()), ["user_id", "user_name"]) def test_column_accessor_sqlite_translated(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) - r = text( - "select users.user_id, users.user_name " - "from users " - "UNION select users.user_id, " - "users.user_name from users", - bind=testing.db).execute().first() - eq_(r['user_id'], 1) - eq_(r['user_name'], "john") + r = ( + text( + "select users.user_id, users.user_name " + "from users " + "UNION select users.user_id, " + "users.user_name from users", + bind=testing.db, + ) + .execute() + .first() + ) + eq_(r["user_id"], 1) + eq_(r["user_name"], "john") if testing.against("sqlite < 3.10.0"): - eq_(r['users.user_id'], 1) - eq_(r['users.user_name'], "john") + eq_(r["users.user_id"], 1) + eq_(r["users.user_name"], "john") else: - not_in_('users.user_id', r) - not_in_('users.user_name', r) + not_in_("users.user_id", r) + not_in_("users.user_name", r) eq_(list(r.keys()), ["user_id", "user_name"]) def test_column_accessor_labels_w_dots(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) # test using literal tablename.colname - r = text( - 'select users.user_id AS "users.user_id", ' - 'users.user_name AS "users.user_name" ' - 'from users', bind=testing.db).\ - execution_options(sqlite_raw_colnames=True).execute().first() - eq_(r['users.user_id'], 1) - eq_(r['users.user_name'], "john") + r = ( + text( + 'select users.user_id AS "users.user_id", ' + 'users.user_name AS "users.user_name" ' + "from users", + bind=testing.db, + ) + .execution_options(sqlite_raw_colnames=True) + .execute() + .first() + ) + eq_(r["users.user_id"], 1) + eq_(r["users.user_name"], "john") not_in_("user_name", r) eq_(list(r.keys()), ["users.user_id", "users.user_name"]) def test_column_accessor_unary(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) # unary expressions - r = select([users.c.user_name.distinct()]).order_by( - users.c.user_name).execute().first() - eq_(r[users.c.user_name], 'john') - eq_(r.user_name, 'john') + r = ( + select([users.c.user_name.distinct()]) + .order_by(users.c.user_name) + .execute() + .first() + ) + eq_(r[users.c.user_name], "john") + eq_(r.user_name, "john") def test_column_accessor_err(self): r = testing.db.execute(select([1])).first() assert_raises_message( AttributeError, "Could not locate column in row for column 'foo'", - getattr, r, "foo" + getattr, + r, + "foo", ) assert_raises_message( KeyError, "Could not locate column in row for column 'foo'", - lambda: r['foo'] + lambda: r["foo"], ) def test_graceful_fetch_on_non_rows(self): @@ -481,8 +527,8 @@ class ResultProxyTest(fixtures.TablesTest): lambda r: r.first(), lambda r: r.scalar(), lambda r: r.fetchmany(), - lambda r: r._getter('user'), - lambda r: r._has_key('user'), + lambda r: r._getter("user"), + lambda r: r._has_key("user"), ]: trans = conn.begin() result = conn.execute(users.insert(), user_id=1) @@ -490,7 +536,8 @@ class ResultProxyTest(fixtures.TablesTest): exc.ResourceClosedError, "This result object does not return rows. " "It has been closed automatically.", - meth, result, + meth, + result, ) trans.rollback() @@ -503,19 +550,17 @@ class ResultProxyTest(fixtures.TablesTest): assert_raises_message( exc.ResourceClosedError, "This result object is closed.", - result.fetchone + result.fetchone, ) def test_connectionless_autoclose_rows_exhausted(self): users = self.tables.users - users.insert().execute( - dict(user_id=1, user_name='john'), - ) + users.insert().execute(dict(user_id=1, user_name="john")) result = testing.db.execute("select * from users") connection = result.connection assert not connection.closed - eq_(result.fetchone(), (1, 'john')) + eq_(result.fetchone(), (1, "john")) assert not connection.closed eq_(result.fetchone(), None) assert connection.closed @@ -523,12 +568,15 @@ class ResultProxyTest(fixtures.TablesTest): @testing.requires.returning def test_connectionless_autoclose_crud_rows_exhausted(self): users = self.tables.users - stmt = users.insert().values(user_id=1, user_name='john').\ - returning(users.c.user_id) + stmt = ( + users.insert() + .values(user_id=1, user_name="john") + .returning(users.c.user_id) + ) result = testing.db.execute(stmt) connection = result.connection assert not connection.closed - eq_(result.fetchone(), (1, )) + eq_(result.fetchone(), (1,)) assert not connection.closed eq_(result.fetchone(), None) assert connection.closed @@ -548,15 +596,17 @@ class ResultProxyTest(fixtures.TablesTest): assert_raises_message( exc.ResourceClosedError, "This result object does not return rows.", - result.fetchone + result.fetchone, ) def test_row_case_sensitive(self): row = testing.db.execute( - select([ - literal_column("1").label("case_insensitive"), - literal_column("2").label("CaseSensitive") - ]) + select( + [ + literal_column("1").label("case_insensitive"), + literal_column("2").label("CaseSensitive"), + ] + ) ).first() eq_(list(row.keys()), ["case_insensitive", "CaseSensitive"]) @@ -568,28 +618,25 @@ class ResultProxyTest(fixtures.TablesTest): eq_(row["case_insensitive"], 1) eq_(row["CaseSensitive"], 2) - assert_raises( - KeyError, - lambda: row["Case_insensitive"] - ) - assert_raises( - KeyError, - lambda: row["casesensitive"] - ) + assert_raises(KeyError, lambda: row["Case_insensitive"]) + assert_raises(KeyError, lambda: row["casesensitive"]) def test_row_case_sensitive_unoptimized(self): ins_db = engines.testing_engine(options={"case_sensitive": True}) row = ins_db.execute( - select([ - literal_column("1").label("case_insensitive"), - literal_column("2").label("CaseSensitive"), - text("3 AS screw_up_the_cols") - ]) + select( + [ + literal_column("1").label("case_insensitive"), + literal_column("2").label("CaseSensitive"), + text("3 AS screw_up_the_cols"), + ] + ) ).first() eq_( list(row.keys()), - ["case_insensitive", "CaseSensitive", "screw_up_the_cols"]) + ["case_insensitive", "CaseSensitive", "screw_up_the_cols"], + ) in_("case_insensitive", row._keymap) in_("CaseSensitive", row._keymap) @@ -606,10 +653,12 @@ class ResultProxyTest(fixtures.TablesTest): def test_row_case_insensitive(self): ins_db = engines.testing_engine(options={"case_sensitive": False}) row = ins_db.execute( - select([ - literal_column("1").label("case_insensitive"), - literal_column("2").label("CaseSensitive") - ]) + select( + [ + literal_column("1").label("case_insensitive"), + literal_column("2").label("CaseSensitive"), + ] + ) ).first() eq_(list(row.keys()), ["case_insensitive", "CaseSensitive"]) @@ -626,16 +675,19 @@ class ResultProxyTest(fixtures.TablesTest): def test_row_case_insensitive_unoptimized(self): ins_db = engines.testing_engine(options={"case_sensitive": False}) row = ins_db.execute( - select([ - literal_column("1").label("case_insensitive"), - literal_column("2").label("CaseSensitive"), - text("3 AS screw_up_the_cols") - ]) + select( + [ + literal_column("1").label("case_insensitive"), + literal_column("2").label("CaseSensitive"), + text("3 AS screw_up_the_cols"), + ] + ) ).first() eq_( list(row.keys()), - ["case_insensitive", "CaseSensitive", "screw_up_the_cols"]) + ["case_insensitive", "CaseSensitive", "screw_up_the_cols"], + ) in_("case_insensitive", row._keymap) in_("CaseSensitive", row._keymap) @@ -651,24 +703,27 @@ class ResultProxyTest(fixtures.TablesTest): def test_row_as_args(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='john') + users.insert().execute(user_id=1, user_name="john") r = users.select(users.c.user_id == 1).execute().first() users.delete().execute() users.insert().execute(r) - eq_(users.select().execute().fetchall(), [(1, 'john')]) + eq_(users.select().execute().fetchall(), [(1, "john")]) def test_result_as_args(self): users = self.tables.users users2 = self.tables.users2 - users.insert().execute([ - dict(user_id=1, user_name='john'), - dict(user_id=2, user_name='ed')]) + users.insert().execute( + [ + dict(user_id=1, user_name="john"), + dict(user_id=2, user_name="ed"), + ] + ) r = users.select().execute() users2.insert().execute(list(r)) eq_( users2.select().order_by(users2.c.user_id).execute().fetchall(), - [(1, 'john'), (2, 'ed')] + [(1, "john"), (2, "ed")], ) users2.delete().execute() @@ -676,7 +731,7 @@ class ResultProxyTest(fixtures.TablesTest): users2.insert().execute(*list(r)) eq_( users2.select().order_by(users2.c.user_id).execute().fetchall(), - [(1, 'john'), (2, 'ed')] + [(1, "john"), (2, "ed")], ) @testing.requires.duplicate_names_in_cursor_description @@ -684,14 +739,14 @@ class ResultProxyTest(fixtures.TablesTest): users = self.tables.users addresses = self.tables.addresses - users.insert().execute(user_id=1, user_name='john') + users.insert().execute(user_id=1, user_name="john") result = users.outerjoin(addresses).select().execute() r = result.first() assert_raises_message( exc.InvalidRequestError, "Ambiguous column name", - lambda: r['user_id'] + lambda: r["user_id"], ) # pure positional targeting; users.c.user_id @@ -702,18 +757,18 @@ class ResultProxyTest(fixtures.TablesTest): # try to trick it - fake_table isn't in the result! # we get the correct error - fake_table = Table('fake', MetaData(), Column('user_id', Integer)) + fake_table = Table("fake", MetaData(), Column("user_id", Integer)) assert_raises_message( exc.InvalidRequestError, "Could not locate column in row for column 'fake.user_id'", - lambda: r[fake_table.c.user_id] + lambda: r[fake_table.c.user_id], ) r = util.pickle.loads(util.pickle.dumps(r)) assert_raises_message( exc.InvalidRequestError, "Ambiguous column name", - lambda: r['user_id'] + lambda: r["user_id"], ) result = users.outerjoin(addresses).select().execute() @@ -723,14 +778,14 @@ class ResultProxyTest(fixtures.TablesTest): assert_raises_message( exc.InvalidRequestError, "Ambiguous column name", - lambda: r['user_id'] + lambda: r["user_id"], ) @testing.requires.duplicate_names_in_cursor_description def test_ambiguous_column_by_col(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='john') + users.insert().execute(user_id=1, user_name="john") ua = users.alias() u2 = users.alias() result = select([users.c.user_id, ua.c.user_id]).execute() @@ -747,22 +802,26 @@ class ResultProxyTest(fixtures.TablesTest): assert_raises_message( exc.InvalidRequestError, "Could not locate column in row", - lambda: row[u2.c.user_id] + lambda: row[u2.c.user_id], ) @testing.requires.duplicate_names_in_cursor_description def test_ambiguous_column_case_sensitive(self): eng = engines.testing_engine(options=dict(case_sensitive=False)) - row = eng.execute(select([ - literal_column('1').label('SOMECOL'), - literal_column('1').label('SOMECOL'), - ])).first() + row = eng.execute( + select( + [ + literal_column("1").label("SOMECOL"), + literal_column("1").label("SOMECOL"), + ] + ) + ).first() assert_raises_message( exc.InvalidRequestError, "Ambiguous column name", - lambda: row['somecol'] + lambda: row["somecol"], ) @testing.requires.duplicate_names_in_cursor_description @@ -773,47 +832,45 @@ class ResultProxyTest(fixtures.TablesTest): # ticket 2702. in 0.7 we'd get True, False. # in 0.8, both columns are present so it's True; # but when they're fetched you'll get the ambiguous error. - users.insert().execute(user_id=1, user_name='john') - result = select([users.c.user_id, addresses.c.user_id]).\ - select_from(users.outerjoin(addresses)).execute() + users.insert().execute(user_id=1, user_name="john") + result = ( + select([users.c.user_id, addresses.c.user_id]) + .select_from(users.outerjoin(addresses)) + .execute() + ) row = result.first() eq_( set([users.c.user_id in row, addresses.c.user_id in row]), - set([True]) + set([True]), ) def test_ambiguous_column_by_col_plus_label(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='john') + users.insert().execute(user_id=1, user_name="john") result = select( - [users.c.user_id, - type_coerce(users.c.user_id, Integer).label('foo')]).execute() + [ + users.c.user_id, + type_coerce(users.c.user_id, Integer).label("foo"), + ] + ).execute() row = result.first() - eq_( - row[users.c.user_id], 1 - ) - eq_( - row[1], 1 - ) + eq_(row[users.c.user_id], 1) + eq_(row[1], 1) def test_fetch_partial_result_map(self): users = self.tables.users - users.insert().execute(user_id=7, user_name='ed') + users.insert().execute(user_id=7, user_name="ed") - t = text("select * from users").columns( - user_name=String() - ) - eq_( - testing.db.execute(t).fetchall(), [(7, 'ed')] - ) + t = text("select * from users").columns(user_name=String()) + eq_(testing.db.execute(t).fetchall(), [(7, "ed")]) def test_fetch_unordered_result_map(self): users = self.tables.users - users.insert().execute(user_id=7, user_name='ed') + users.insert().execute(user_id=7, user_name="ed") class Goofy1(TypeDecorator): impl = String @@ -835,166 +892,155 @@ class ResultProxyTest(fixtures.TablesTest): t = text( "select user_name as a, user_name as b, " - "user_name as c from users").columns( - a=Goofy1(), b=Goofy2(), c=Goofy3() - ) - eq_( - testing.db.execute(t).fetchall(), [ - ('eda', 'edb', 'edc') - ] - ) + "user_name as c from users" + ).columns(a=Goofy1(), b=Goofy2(), c=Goofy3()) + eq_(testing.db.execute(t).fetchall(), [("eda", "edb", "edc")]) @testing.requires.subqueries def test_column_label_targeting(self): users = self.tables.users - users.insert().execute(user_id=7, user_name='ed') + users.insert().execute(user_id=7, user_name="ed") for s in ( - users.select().alias('foo'), + users.select().alias("foo"), users.select().alias(users.name), ): row = s.select(use_labels=True).execute().first() eq_(row[s.c.user_id], 7) - eq_(row[s.c.user_name], 'ed') + eq_(row[s.c.user_name], "ed") def test_keys(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') + users.insert().execute(user_id=1, user_name="foo") result = users.select().execute() - eq_( - result.keys(), - ['user_id', 'user_name'] - ) + eq_(result.keys(), ["user_id", "user_name"]) row = result.first() - eq_( - row.keys(), - ['user_id', 'user_name'] - ) + eq_(row.keys(), ["user_id", "user_name"]) def test_keys_anon_labels(self): """test [ticket:3483]""" users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') + users.insert().execute(user_id=1, user_name="foo") result = testing.db.execute( - select([ - users.c.user_id, - users.c.user_name.label(None), - func.count(literal_column('1'))]). - group_by(users.c.user_id, users.c.user_name) + select( + [ + users.c.user_id, + users.c.user_name.label(None), + func.count(literal_column("1")), + ] + ).group_by(users.c.user_id, users.c.user_name) ) - eq_( - result.keys(), - ['user_id', 'user_name_1', 'count_1'] - ) + eq_(result.keys(), ["user_id", "user_name_1", "count_1"]) row = result.first() - eq_( - row.keys(), - ['user_id', 'user_name_1', 'count_1'] - ) + eq_(row.keys(), ["user_id", "user_name_1", "count_1"]) def test_items(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') + users.insert().execute(user_id=1, user_name="foo") r = users.select().execute().first() eq_( [(x[0].lower(), x[1]) for x in list(r.items())], - [('user_id', 1), ('user_name', 'foo')]) + [("user_id", 1), ("user_name", "foo")], + ) def test_len(self): users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') + users.insert().execute(user_id=1, user_name="foo") r = users.select().execute().first() eq_(len(r), 2) - r = testing.db.execute('select user_name, user_id from users'). \ - first() + r = testing.db.execute("select user_name, user_id from users").first() eq_(len(r), 2) - r = testing.db.execute('select user_name from users').first() + r = testing.db.execute("select user_name from users").first() eq_(len(r), 1) def test_sorting_in_python(self): users = self.tables.users users.insert().execute( - dict(user_id=1, user_name='foo'), - dict(user_id=2, user_name='bar'), - dict(user_id=3, user_name='def'), + dict(user_id=1, user_name="foo"), + dict(user_id=2, user_name="bar"), + dict(user_id=3, user_name="def"), ) rows = users.select().order_by(users.c.user_name).execute().fetchall() - eq_(rows, [(2, 'bar'), (3, 'def'), (1, 'foo')]) + eq_(rows, [(2, "bar"), (3, "def"), (1, "foo")]) - eq_(sorted(rows), [(1, 'foo'), (2, 'bar'), (3, 'def')]) + eq_(sorted(rows), [(1, "foo"), (2, "bar"), (3, "def")]) def test_column_order_with_simple_query(self): # should return values in column definition order users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') + users.insert().execute(user_id=1, user_name="foo") r = users.select(users.c.user_id == 1).execute().first() eq_(r[0], 1) - eq_(r[1], 'foo') - eq_([x.lower() for x in list(r.keys())], ['user_id', 'user_name']) - eq_(list(r.values()), [1, 'foo']) + eq_(r[1], "foo") + eq_([x.lower() for x in list(r.keys())], ["user_id", "user_name"]) + eq_(list(r.values()), [1, "foo"]) def test_column_order_with_text_query(self): # should return values in query order users = self.tables.users - users.insert().execute(user_id=1, user_name='foo') - r = testing.db.execute('select user_name, user_id from users'). \ - first() - eq_(r[0], 'foo') + users.insert().execute(user_id=1, user_name="foo") + r = testing.db.execute("select user_name, user_id from users").first() + eq_(r[0], "foo") eq_(r[1], 1) - eq_([x.lower() for x in list(r.keys())], ['user_name', 'user_id']) - eq_(list(r.values()), ['foo', 1]) + eq_([x.lower() for x in list(r.keys())], ["user_name", "user_id"]) + eq_(list(r.values()), ["foo", 1]) - @testing.crashes('oracle', 'FIXME: unknown, varify not fails_on()') - @testing.crashes('firebird', 'An identifier must begin with a letter') + @testing.crashes("oracle", "FIXME: unknown, varify not fails_on()") + @testing.crashes("firebird", "An identifier must begin with a letter") @testing.provide_metadata def test_column_accessor_shadow(self): shadowed = Table( - 'test_shadowed', self.metadata, - Column('shadow_id', INT, primary_key=True), - Column('shadow_name', VARCHAR(20)), - Column('parent', VARCHAR(20)), - Column('row', VARCHAR(40)), - Column('_parent', VARCHAR(20)), - Column('_row', VARCHAR(20)), + "test_shadowed", + self.metadata, + Column("shadow_id", INT, primary_key=True), + Column("shadow_name", VARCHAR(20)), + Column("parent", VARCHAR(20)), + Column("row", VARCHAR(40)), + Column("_parent", VARCHAR(20)), + Column("_row", VARCHAR(20)), ) self.metadata.create_all() shadowed.insert().execute( - shadow_id=1, shadow_name='The Shadow', parent='The Light', - row='Without light there is no shadow', - _parent='Hidden parent', _row='Hidden row') + shadow_id=1, + shadow_name="The Shadow", + parent="The Light", + row="Without light there is no shadow", + _parent="Hidden parent", + _row="Hidden row", + ) r = shadowed.select(shadowed.c.shadow_id == 1).execute().first() eq_(r.shadow_id, 1) - eq_(r['shadow_id'], 1) + eq_(r["shadow_id"], 1) eq_(r[shadowed.c.shadow_id], 1) - eq_(r.shadow_name, 'The Shadow') - eq_(r['shadow_name'], 'The Shadow') - eq_(r[shadowed.c.shadow_name], 'The Shadow') + eq_(r.shadow_name, "The Shadow") + eq_(r["shadow_name"], "The Shadow") + eq_(r[shadowed.c.shadow_name], "The Shadow") - eq_(r.parent, 'The Light') - eq_(r['parent'], 'The Light') - eq_(r[shadowed.c.parent], 'The Light') + eq_(r.parent, "The Light") + eq_(r["parent"], "The Light") + eq_(r[shadowed.c.parent], "The Light") - eq_(r.row, 'Without light there is no shadow') - eq_(r['row'], 'Without light there is no shadow') - eq_(r[shadowed.c.row], 'Without light there is no shadow') + eq_(r.row, "Without light there is no shadow") + eq_(r["row"], "Without light there is no shadow") + eq_(r[shadowed.c.row], "Without light there is no shadow") - eq_(r['_parent'], 'Hidden parent') - eq_(r['_row'], 'Hidden row') + eq_(r["_parent"], "Hidden parent") + eq_(r["_row"], "Hidden row") def test_nontuple_row(self): """ensure the C version of BaseRowProxy handles @@ -1003,7 +1049,6 @@ class ResultProxyTest(fixtures.TablesTest): from sqlalchemy.engine import RowProxy class MyList(object): - def __init__(self, data): self.internal_list = data @@ -1013,11 +1058,15 @@ class ResultProxyTest(fixtures.TablesTest): def __getitem__(self, i): return list.__getitem__(self.internal_list, i) - proxy = RowProxy(object(), MyList(['value']), [None], { - 'key': (None, None, 0), 0: (None, None, 0)}) - eq_(list(proxy), ['value']) - eq_(proxy[0], 'value') - eq_(proxy['key'], 'value') + proxy = RowProxy( + object(), + MyList(["value"]), + [None], + {"key": (None, None, 0), 0: (None, None, 0)}, + ) + eq_(list(proxy), ["value"]) + eq_(proxy[0], "value") + eq_(proxy["key"], "value") @testing.provide_metadata def test_no_rowcount_on_selects_inserts(self): @@ -1033,28 +1082,26 @@ class ResultProxyTest(fixtures.TablesTest): engine = engines.testing_engine() - t = Table('t1', metadata, - Column('data', String(10)) - ) + t = Table("t1", metadata, Column("data", String(10))) metadata.create_all(engine) with patch.object( - engine.dialect.execution_ctx_cls, "rowcount") as mock_rowcount: + engine.dialect.execution_ctx_cls, "rowcount" + ) as mock_rowcount: mock_rowcount.__get__ = Mock() - engine.execute(t.insert(), - {'data': 'd1'}, - {'data': 'd2'}, - {'data': 'd3'}) + engine.execute( + t.insert(), {"data": "d1"}, {"data": "d2"}, {"data": "d3"} + ) eq_(len(mock_rowcount.__get__.mock_calls), 0) eq_( engine.execute(t.select()).fetchall(), - [('d1', ), ('d2', ), ('d3', )] + [("d1",), ("d2",), ("d3",)], ) eq_(len(mock_rowcount.__get__.mock_calls), 0) - engine.execute(t.update(), {'data': 'd4'}) + engine.execute(t.update(), {"data": "d4"}) eq_(len(mock_rowcount.__get__.mock_calls), 1) @@ -1066,58 +1113,66 @@ class ResultProxyTest(fixtures.TablesTest): from sqlalchemy.engine import RowProxy row = RowProxy( - object(), ['value'], [None], - {'key': (None, None, 0), 0: (None, None, 0)}) + object(), + ["value"], + [None], + {"key": (None, None, 0), 0: (None, None, 0)}, + ) assert isinstance(row, collections_abc.Sequence) @testing.provide_metadata def test_rowproxy_getitem_indexes_compiled(self): - values = Table('rp', self.metadata, - Column('key', String(10), primary_key=True), - Column('value', String(10))) + values = Table( + "rp", + self.metadata, + Column("key", String(10), primary_key=True), + Column("value", String(10)), + ) values.create() - testing.db.execute(values.insert(), dict(key='One', value='Uno')) + testing.db.execute(values.insert(), dict(key="One", value="Uno")) row = testing.db.execute(values.select()).first() - eq_(row['key'], 'One') - eq_(row['value'], 'Uno') - eq_(row[0], 'One') - eq_(row[1], 'Uno') - eq_(row[-2], 'One') - eq_(row[-1], 'Uno') - eq_(row[1:0:-1], ('Uno',)) + eq_(row["key"], "One") + eq_(row["value"], "Uno") + eq_(row[0], "One") + eq_(row[1], "Uno") + eq_(row[-2], "One") + eq_(row[-1], "Uno") + eq_(row[1:0:-1], ("Uno",)) @testing.only_on("sqlite") def test_rowproxy_getitem_indexes_raw(self): row = testing.db.execute("select 'One' as key, 'Uno' as value").first() - eq_(row['key'], 'One') - eq_(row['value'], 'Uno') - eq_(row[0], 'One') - eq_(row[1], 'Uno') - eq_(row[-2], 'One') - eq_(row[-1], 'Uno') - eq_(row[1:0:-1], ('Uno',)) + eq_(row["key"], "One") + eq_(row["value"], "Uno") + eq_(row[0], "One") + eq_(row[1], "Uno") + eq_(row[-2], "One") + eq_(row[-1], "Uno") + eq_(row[1:0:-1], ("Uno",)) @testing.requires.cextensions def test_row_c_sequence_check(self): import csv metadata = MetaData() - metadata.bind = 'sqlite://' - users = Table('users', metadata, - Column('id', Integer, primary_key=True), - Column('name', String(40)), - ) + metadata.bind = "sqlite://" + users = Table( + "users", + metadata, + Column("id", Integer, primary_key=True), + Column("name", String(40)), + ) users.create() - users.insert().execute(name='Test') + users.insert().execute(name="Test") row = users.select().execute().fetchone() s = util.StringIO() writer = csv.writer(s) # csv performs PySequenceCheck call writer.writerow(row) - assert s.getvalue().strip() == '1,Test' + assert s.getvalue().strip() == "1,Test" @testing.requires.selectone def test_empty_accessors(self): @@ -1129,33 +1184,28 @@ class ResultProxyTest(fixtures.TablesTest): lambda r: r.last_updated_params(), lambda r: r.prefetch_cols(), lambda r: r.postfetch_cols(), - lambda r: r.inserted_primary_key + lambda r: r.inserted_primary_key, ], - "Statement is not a compiled expression construct." + "Statement is not a compiled expression construct.", ), ( select([1]), [ lambda r: r.last_inserted_params(), - lambda r: r.inserted_primary_key + lambda r: r.inserted_primary_key, ], - r"Statement is not an insert\(\) expression construct." + r"Statement is not an insert\(\) expression construct.", ), ( select([1]), - [ - lambda r: r.last_updated_params(), - ], - r"Statement is not an update\(\) expression construct." + [lambda r: r.last_updated_params()], + r"Statement is not an update\(\) expression construct.", ), ( select([1]), - [ - lambda r: r.prefetch_cols(), - lambda r: r.postfetch_cols() - ], + [lambda r: r.prefetch_cols(), lambda r: r.postfetch_cols()], r"Statement is not an insert\(\) " - r"or update\(\) expression construct." + r"or update\(\) expression construct.", ), ] @@ -1164,9 +1214,7 @@ class ResultProxyTest(fixtures.TablesTest): try: for meth in meths: assert_raises_message( - sa_exc.InvalidRequestError, - msg, - meth, r + sa_exc.InvalidRequestError, msg, meth, r ) finally: @@ -1174,28 +1222,31 @@ class ResultProxyTest(fixtures.TablesTest): class KeyTargetingTest(fixtures.TablesTest): - run_inserts = 'once' + run_inserts = "once" run_deletes = None __backend__ = True @classmethod def define_tables(cls, metadata): Table( - 'keyed1', metadata, Column("a", CHAR(2), key="b"), - Column("c", CHAR(2), key="q") + "keyed1", + metadata, + Column("a", CHAR(2), key="b"), + Column("c", CHAR(2), key="q"), ) - Table('keyed2', metadata, Column("a", CHAR(2)), Column("b", CHAR(2))) - Table('keyed3', metadata, Column("a", CHAR(2)), Column("d", CHAR(2))) - Table('keyed4', metadata, Column("b", CHAR(2)), Column("q", CHAR(2))) - Table('content', metadata, Column('t', String(30), key="type")) - Table('bar', metadata, Column('ctype', String(30), key="content_type")) + Table("keyed2", metadata, Column("a", CHAR(2)), Column("b", CHAR(2))) + Table("keyed3", metadata, Column("a", CHAR(2)), Column("d", CHAR(2))) + Table("keyed4", metadata, Column("b", CHAR(2)), Column("q", CHAR(2))) + Table("content", metadata, Column("t", String(30), key="type")) + Table("bar", metadata, Column("ctype", String(30), key="content_type")) if testing.requires.schemas.enabled: Table( - 'wschema', metadata, + "wschema", + metadata, Column("a", CHAR(2), key="b"), Column("c", CHAR(2), key="q"), - schema=testing.config.test_schema + schema=testing.config.test_schema, ) @classmethod @@ -1208,12 +1259,12 @@ class KeyTargetingTest(fixtures.TablesTest): if testing.requires.schemas.enabled: cls.tables[ - '%s.wschema' % testing.config.test_schema].insert().execute( - dict(b="a1", q="c1")) + "%s.wschema" % testing.config.test_schema + ].insert().execute(dict(b="a1", q="c1")) @testing.requires.schemas def test_keyed_accessor_wschema(self): - keyed1 = self.tables['%s.wschema' % testing.config.test_schema] + keyed1 = self.tables["%s.wschema" % testing.config.test_schema] row = testing.db.execute(keyed1.select()).first() eq_(row.b, "a1") @@ -1249,9 +1300,7 @@ class KeyTargetingTest(fixtures.TablesTest): eq_(row.b, "b2") # row.a is ambiguous assert_raises_message( - exc.InvalidRequestError, - "Ambig", - getattr, row, "a" + exc.InvalidRequestError, "Ambig", getattr, row, "a" ) def test_keyed_accessor_composite_names_precedent(self): @@ -1274,12 +1323,16 @@ class KeyTargetingTest(fixtures.TablesTest): assert_raises_message( exc.InvalidRequestError, "Ambiguous column name 'a'", - getattr, row, "b" + getattr, + row, + "b", ) assert_raises_message( exc.InvalidRequestError, "Ambiguous column name 'a'", - getattr, row, "a" + getattr, + row, + "a", ) eq_(row.d, "d3") @@ -1287,39 +1340,42 @@ class KeyTargetingTest(fixtures.TablesTest): keyed1 = self.tables.keyed1 keyed2 = self.tables.keyed2 - row = testing.db.execute(select([keyed1, keyed2]).apply_labels()). \ - first() + row = testing.db.execute( + select([keyed1, keyed2]).apply_labels() + ).first() eq_(row.keyed1_b, "a1") eq_(row.keyed1_a, "a1") eq_(row.keyed1_q, "c1") eq_(row.keyed1_c, "c1") eq_(row.keyed2_a, "a2") eq_(row.keyed2_b, "b2") - assert_raises(KeyError, lambda: row['keyed2_c']) - assert_raises(KeyError, lambda: row['keyed2_q']) + assert_raises(KeyError, lambda: row["keyed2_c"]) + assert_raises(KeyError, lambda: row["keyed2_q"]) def test_column_label_overlap_fallback(self): content, bar = self.tables.content, self.tables.bar row = testing.db.execute( - select([content.c.type.label("content_type")])).first() + select([content.c.type.label("content_type")]) + ).first() not_in_(content.c.type, row) not_in_(bar.c.content_type, row) - in_(sql.column('content_type'), row) + in_(sql.column("content_type"), row) - row = testing.db.execute(select([func.now().label("content_type")])). \ - first() + row = testing.db.execute( + select([func.now().label("content_type")]) + ).first() not_in_(content.c.type, row) not_in_(bar.c.content_type, row) - in_(sql.column('content_type'), row) + in_(sql.column("content_type"), row) def test_column_label_overlap_fallback_2(self): content, bar = self.tables.content, self.tables.bar row = testing.db.execute(content.select(use_labels=True)).first() in_(content.c.type, row) not_in_(bar.c.content_type, row) - not_in_(sql.column('content_type'), row) + not_in_(sql.column("content_type"), row) def test_columnclause_schema_column_one(self): keyed2 = self.tables.keyed2 @@ -1328,7 +1384,7 @@ class KeyTargetingTest(fixtures.TablesTest): # ColumnClause._compare_name_for_result allows the # columns which the statement is against to be lightweight # cols, which results in a more liberal comparison scheme - a, b = sql.column('a'), sql.column('b') + a, b = sql.column("a"), sql.column("b") stmt = select([a, b]).select_from(table("keyed2")) row = testing.db.execute(stmt).first() @@ -1340,7 +1396,7 @@ class KeyTargetingTest(fixtures.TablesTest): def test_columnclause_schema_column_two(self): keyed2 = self.tables.keyed2 - a, b = sql.column('a'), sql.column('b') + a, b = sql.column("a"), sql.column("b") stmt = select([keyed2.c.a, keyed2.c.b]) row = testing.db.execute(stmt).first() @@ -1354,7 +1410,7 @@ class KeyTargetingTest(fixtures.TablesTest): # this is also addressed by [ticket:2932] - a, b = sql.column('a'), sql.column('b') + a, b = sql.column("a"), sql.column("b") stmt = text("select a, b from keyed2").columns(a=CHAR, b=CHAR) row = testing.db.execute(stmt).first() @@ -1370,9 +1426,10 @@ class KeyTargetingTest(fixtures.TablesTest): # this is also addressed by [ticket:2932] - a, b = sql.column('keyed2_a'), sql.column('keyed2_b') + a, b = sql.column("keyed2_a"), sql.column("keyed2_b") stmt = text("select a AS keyed2_a, b AS keyed2_b from keyed2").columns( - a, b) + a, b + ) row = testing.db.execute(stmt).first() in_(keyed2.c.a, row) @@ -1388,7 +1445,8 @@ class KeyTargetingTest(fixtures.TablesTest): # this is also addressed by [ticket:2932] stmt = text("select a AS keyed2_a, b AS keyed2_b from keyed2").columns( - keyed2_a=CHAR, keyed2_b=CHAR) + keyed2_a=CHAR, keyed2_b=CHAR + ) row = testing.db.execute(stmt).first() in_(keyed2.c.a, row) @@ -1398,29 +1456,29 @@ class KeyTargetingTest(fixtures.TablesTest): class PositionalTextTest(fixtures.TablesTest): - run_inserts = 'once' + run_inserts = "once" run_deletes = None __backend__ = True @classmethod def define_tables(cls, metadata): Table( - 'text1', + "text1", metadata, Column("a", CHAR(2)), Column("b", CHAR(2)), Column("c", CHAR(2)), - Column("d", CHAR(2)) + Column("d", CHAR(2)), ) @classmethod def insert_data(cls): - cls.tables.text1.insert().execute([ - dict(a="a1", b="b1", c="c1", d="d1"), - ]) + cls.tables.text1.insert().execute( + [dict(a="a1", b="b1", c="c1", d="d1")] + ) def test_via_column(self): - c1, c2, c3, c4 = column('q'), column('p'), column('r'), column('d') + c1, c2, c3, c4 = column("q"), column("p"), column("r"), column("d") stmt = text("select a, b, c, d from text1").columns(c1, c2, c3, c4) result = testing.db.execute(stmt) @@ -1435,7 +1493,7 @@ class PositionalTextTest(fixtures.TablesTest): eq_(row["d"], "d1") def test_fewer_cols_than_sql_positional(self): - c1, c2 = column('q'), column('p') + c1, c2 = column("q"), column("p") stmt = text("select a, b, c, d from text1").columns(c1, c2) # no warning as this can be similar for non-positional @@ -1446,7 +1504,7 @@ class PositionalTextTest(fixtures.TablesTest): eq_(row["c"], "c1") def test_fewer_cols_than_sql_non_positional(self): - c1, c2 = column('a'), column('p') + c1, c2 = column("a"), column("p") stmt = text("select a, b, c, d from text1").columns(c2, c1, d=CHAR) # no warning as this can be similar for non-positional @@ -1459,38 +1517,36 @@ class PositionalTextTest(fixtures.TablesTest): # c2 name does not match, doesn't locate assert_raises_message( - exc.NoSuchColumnError, - "in row for column 'p'", - lambda: row[c2] + exc.NoSuchColumnError, "in row for column 'p'", lambda: row[c2] ) def test_more_cols_than_sql(self): - c1, c2, c3, c4 = column('q'), column('p'), column('r'), column('d') + c1, c2, c3, c4 = column("q"), column("p"), column("r"), column("d") stmt = text("select a, b from text1").columns(c1, c2, c3, c4) with assertions.expect_warnings( - r"Number of columns in textual SQL \(4\) is " - r"smaller than number of columns requested \(2\)"): + r"Number of columns in textual SQL \(4\) is " + r"smaller than number of columns requested \(2\)" + ): result = testing.db.execute(stmt) row = result.first() eq_(row[c2], "b1") assert_raises_message( - exc.NoSuchColumnError, - "in row for column 'r'", - lambda: row[c3] + exc.NoSuchColumnError, "in row for column 'r'", lambda: row[c3] ) def test_dupe_col_obj(self): - c1, c2, c3 = column('q'), column('p'), column('r') + c1, c2, c3 = column("q"), column("p"), column("r") stmt = text("select a, b, c, d from text1").columns(c1, c2, c3, c2) assert_raises_message( exc.InvalidRequestError, "Duplicate column expression requested in " "textual SQL: <.*.ColumnClause.*; p>", - testing.db.execute, stmt + testing.db.execute, + stmt, ) def test_anon_aliased_unique(self): @@ -1523,7 +1579,7 @@ class PositionalTextTest(fixtures.TablesTest): assert_raises_message( exc.NoSuchColumnError, "Could not locate column in row for column 'text1.b'", - lambda: row[text1.c.b] + lambda: row[text1.c.b], ) def test_anon_aliased_overlapping(self): @@ -1558,7 +1614,8 @@ class PositionalTextTest(fixtures.TablesTest): # all cols are named "a". if we are positional, we don't care. # this is new logic in 1.1 stmt = text("select a, b as a, c as a, d as a from text1").columns( - c1, c2, c3, c4) + c1, c2, c3, c4 + ) result = testing.db.execute(stmt) row = result.first() @@ -1572,42 +1629,45 @@ class PositionalTextTest(fixtures.TablesTest): assert_raises_message( exc.NoSuchColumnError, "Could not locate column in row for column 'text1.a'", - lambda: row[text1.c.a] + lambda: row[text1.c.a], ) class AlternateResultProxyTest(fixtures.TablesTest): - __requires__ = ('sqlite', ) + __requires__ = ("sqlite",) @classmethod def setup_bind(cls): - cls.engine = engine = engines.testing_engine('sqlite://') + cls.engine = engine = engines.testing_engine("sqlite://") return engine @classmethod def define_tables(cls, metadata): Table( - 'test', metadata, - Column('x', Integer, primary_key=True), - Column('y', String(50, convert_unicode='force')) + "test", + metadata, + Column("x", Integer, primary_key=True), + Column("y", String(50, convert_unicode="force")), ) @classmethod def insert_data(cls): - cls.engine.execute(cls.tables.test.insert(), [ - {'x': i, 'y': "t_%d" % i} for i in range(1, 12) - ]) + cls.engine.execute( + cls.tables.test.insert(), + [{"x": i, "y": "t_%d" % i} for i in range(1, 12)], + ) @contextmanager def _proxy_fixture(self, cls): self.table = self.tables.test class ExcCtx(default.DefaultExecutionContext): - def get_result_proxy(self): return cls(self) + self.patcher = patch.object( - self.engine.dialect, "execution_ctx_cls", ExcCtx) + self.engine.dialect, "execution_ctx_cls", ExcCtx + ) with self.patcher: yield @@ -1664,21 +1724,15 @@ class AlternateResultProxyTest(fixtures.TablesTest): def _assert_result_closed(self, r): assert_raises_message( - sa_exc.ResourceClosedError, - "object is closed", - r.fetchone + sa_exc.ResourceClosedError, "object is closed", r.fetchone ) assert_raises_message( - sa_exc.ResourceClosedError, - "object is closed", - r.fetchmany, 2 + sa_exc.ResourceClosedError, "object is closed", r.fetchmany, 2 ) assert_raises_message( - sa_exc.ResourceClosedError, - "object is closed", - r.fetchall + sa_exc.ResourceClosedError, "object is closed", r.fetchall ) def test_basic_plain(self): @@ -1738,35 +1792,28 @@ class AlternateResultProxyTest(fixtures.TablesTest): def test_buffered_row_growth(self): with self._proxy_fixture(_result.BufferedRowResultProxy): with self.engine.connect() as conn: - conn.execute(self.table.insert(), [ - {'x': i, 'y': "t_%d" % i} for i in range(15, 1200) - ]) + conn.execute( + self.table.insert(), + [{"x": i, "y": "t_%d" % i} for i in range(15, 1200)], + ) result = conn.execute(self.table.select()) - checks = { - 0: 5, 1: 10, 9: 20, 135: 250, 274: 500, - 1351: 1000 - } + checks = {0: 5, 1: 10, 9: 20, 135: 250, 274: 500, 1351: 1000} for idx, row in enumerate(result, 0): if idx in checks: eq_(result._bufsize, checks[idx]) - le_( - len(result._BufferedRowResultProxy__rowbuffer), - 1000 - ) + le_(len(result._BufferedRowResultProxy__rowbuffer), 1000) def test_max_row_buffer_option(self): with self._proxy_fixture(_result.BufferedRowResultProxy): with self.engine.connect() as conn: - conn.execute(self.table.insert(), [ - {'x': i, 'y': "t_%d" % i} for i in range(15, 1200) - ]) + conn.execute( + self.table.insert(), + [{"x": i, "y": "t_%d" % i} for i in range(15, 1200)], + ) result = conn.execution_options(max_row_buffer=27).execute( self.table.select() ) for idx, row in enumerate(result, 0): if idx in (16, 70, 150, 250): eq_(result._bufsize, 27) - le_( - len(result._BufferedRowResultProxy__rowbuffer), - 27 - ) + le_(len(result._BufferedRowResultProxy__rowbuffer), 27) diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py index f8d183b71..e298a2d55 100644 --- a/test/sql/test_returning.py +++ b/test/sql/test_returning.py @@ -2,18 +2,29 @@ from sqlalchemy.testing import eq_ 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 +from sqlalchemy.testing import ( + fixtures, + AssertsExecutionResults, + engines, + assert_raises_message, +) from sqlalchemy import exc as sa_exc -from sqlalchemy import MetaData, String, Integer, Boolean, func, select, \ - Sequence +from sqlalchemy import ( + MetaData, + String, + Integer, + Boolean, + func, + select, + Sequence, +) import itertools table = GoofyType = seq = None class ReturningTest(fixtures.TestBase, AssertsExecutionResults): - __requires__ = 'returning', + __requires__ = ("returning",) __backend__ = True def setup(self): @@ -34,106 +45,134 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults): return value + "BAR" table = Table( - 'tables', meta, + "tables", + meta, Column( - 'id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('persons', Integer), - Column('full', Boolean), - Column('goofy', GoofyType(50))) + "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'] - assert row['full'] is False - - result = table.insert().values( - persons=5, full=True, goofy="somegoofy").\ - returning(table.c.persons, table.c.full, table.c.goofy).execute() + assert row[table.c.id] == row["id"] == 1 + assert row[table.c.full] == row["full"] + assert row["full"] is False + + result = ( + table.insert() + .values(persons=5, full=True, goofy="somegoofy") + .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'] + assert row[table.c.persons] == row["persons"] == 5 + assert row[table.c.full] == row["full"] - eq_(row[table.c.goofy], row['goofy']) - eq_(row['goofy'], "FOOsomegoofyBAR") + eq_(row[table.c.goofy], row["goofy"]) + eq_(row["goofy"], "FOOsomegoofyBAR") - @testing.fails_on('firebird', "fb can't handle returning x AS y") + @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() + result = ( + table.insert() + .values(persons=6) + .returning(table.c.persons.label("lala")) + .execute() + ) row = result.first() - assert row['lala'] == 6 + assert row["lala"] == 6 @testing.fails_on( - 'firebird', - "fb/kintersbasdb can't handle the bind params") - @testing.fails_on('oracle+zxjdbc', "JDBC driver bug") + "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() + result = ( + table.insert() + .values(goofy="someOTHERgoofy") + .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() + result = ( + table.insert() + .values(persons=12) + .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}]) + [{"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}, - ] + ins = ( + table.insert() + .returning(table.c.id, table.c.persons) + .values( + [ + {"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)] - ) + eq_(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, r"Can't call inserted_primary_key when returning\(\) is used.", - getattr, result, "inserted_primary_key" + getattr, + result, + "inserted_primary_key", ) - @testing.fails_on_everything_except('postgresql', 'firebird') + @testing.fails_on_everything_except("postgresql", "firebird") def test_literal_returning(self): if testing.against("postgresql"): literal_true = "true" @@ -142,26 +181,28 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults): 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}]) + "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}]) + [{"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 CompositeStatementTest(fixtures.TestBase): - __requires__ = 'returning', + __requires__ = ("returning",) __backend__ = True @testing.provide_metadata @@ -172,47 +213,46 @@ class CompositeStatementTest(fixtures.TestBase): def process_result_value(self, value, dialect): raise Exception("I have not been selected") - t1 = Table( - 't1', self.metadata, - Column('x', MyType()) - ) + t1 = Table("t1", self.metadata, Column("x", MyType())) - t2 = Table( - 't2', self.metadata, - Column('x', Integer) - ) + t2 = Table("t2", self.metadata, Column("x", Integer)) self.metadata.create_all(testing.db) with testing.db.connect() as conn: conn.execute(t1.insert().values(x=5)) - stmt = t2.insert().values( - x=select([t1.c.x]).as_scalar()).returning(t2.c.x) + stmt = ( + t2.insert() + .values(x=select([t1.c.x]).as_scalar()) + .returning(t2.c.x) + ) result = conn.execute(stmt) eq_(result.scalar(), 5) class SequenceReturningTest(fixtures.TestBase): - __requires__ = 'returning', 'sequences' + __requires__ = "returning", "sequences" __backend__ = True def setup(self): meta = MetaData(testing.db) global table, seq - seq = Sequence('tid_seq') - table = Table('tables', meta, - Column('id', Integer, seq, primary_key=True), - Column('data', String(50)) - ) + seq = Sequence("tid_seq") + table = Table( + "tables", + meta, + Column("id", Integer, seq, primary_key=True), + Column("data", String(50)), + ) table.create(checkfirst=True) def teardown(self): table.drop() def test_insert(self): - r = table.insert().values(data='hi').returning(table.c.id).execute() - assert r.first() == (1, ) + r = table.insert().values(data="hi").returning(table.c.id).execute() + assert r.first() == (1,) assert seq.execute() == 2 @@ -220,7 +260,7 @@ class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults): """test returning() works with columns that define 'key'.""" - __requires__ = 'returning', + __requires__ = ("returning",) __backend__ = True def setup(self): @@ -228,39 +268,38 @@ class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults): global table table = Table( - 'tables', + "tables", meta, Column( - 'id', + "id", Integer, primary_key=True, - key='foo_id', - test_needs_autoincrement=True), - Column( - 'data', - String(20)), + key="foo_id", + test_needs_autoincrement=True, + ), + Column("data", String(20)), ) table.create(checkfirst=True) def teardown(self): table.drop() - @testing.exclude('firebird', '<', (2, 0), '2.0+ feature') - @testing.exclude('postgresql', '<', (8, 2), '8.2+ feature') + @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 + assert row[table.c.foo_id] == row["id"] == 1 result = table.select().execute().first() - assert row[table.c.foo_id] == row['id'] == 1 + assert row[table.c.foo_id] == row["id"] == 1 class ReturnDefaultsTest(fixtures.TablesTest): - __requires__ = ('returning', ) - run_define_tables = 'each' + __requires__ = ("returning",) + run_define_tables = "each" __backend__ = True @classmethod @@ -278,13 +317,15 @@ class ReturnDefaultsTest(fixtures.TablesTest): return str(next(counter)) Table( - "t1", metadata, + "t1", + metadata, Column( - "id", Integer, primary_key=True, - test_needs_autoincrement=True), + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), Column("data", String(50)), Column("insdef", Integer, default=IncDefault()), - Column("upddef", Integer, onupdate=IncDefault())) + Column("upddef", Integer, onupdate=IncDefault()), + ) def test_chained_insert_pk(self): t1 = self.tables.t1 @@ -293,7 +334,7 @@ class ReturnDefaultsTest(fixtures.TablesTest): ) eq_( [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)], - [1, 0] + [1, 0], ) def test_arg_insert_pk(self): @@ -303,32 +344,24 @@ class ReturnDefaultsTest(fixtures.TablesTest): ) eq_( [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)], - [1, 0] + [1, 0], ) def test_chained_update_pk(self): t1 = self.tables.t1 - testing.db.execute( - t1.insert().values(upddef=1) - ) - result = testing.db.execute(t1.update().values(data='d1'). - return_defaults(t1.c.upddef)) - eq_( - [result.returned_defaults[k] for k in (t1.c.upddef,)], - [1] + testing.db.execute(t1.insert().values(upddef=1)) + result = testing.db.execute( + t1.update().values(data="d1").return_defaults(t1.c.upddef) ) + eq_([result.returned_defaults[k] for k in (t1.c.upddef,)], [1]) def test_arg_update_pk(self): t1 = self.tables.t1 - testing.db.execute( - t1.insert().values(upddef=1) - ) - result = testing.db.execute(t1.update(return_defaults=[t1.c.upddef]). - values(data='d1')) - eq_( - [result.returned_defaults[k] for k in (t1.c.upddef,)], - [1] + testing.db.execute(t1.insert().values(upddef=1)) + result = testing.db.execute( + t1.update(return_defaults=[t1.c.upddef]).values(data="d1") ) + eq_([result.returned_defaults[k] for k in (t1.c.upddef,)], [1]) def test_insert_non_default(self): """test that a column not marked at all as a @@ -339,8 +372,8 @@ class ReturnDefaultsTest(fixtures.TablesTest): 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] + [result.returned_defaults[k] for k in (t1.c.id, t1.c.data)], + [1, None], ) def test_update_non_default(self): @@ -348,42 +381,33 @@ class ReturnDefaultsTest(fixtures.TablesTest): default works with this feature.""" t1 = self.tables.t1 - testing.db.execute( - t1.insert().values(upddef=1) - ) + testing.db.execute(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] + t1.update().values(upddef=2).return_defaults(t1.c.data) ) + eq_([result.returned_defaults[k] for k in (t1.c.data,)], [None]) 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} + {"id": 1, "data": None, "insdef": 0}, ) def test_update_non_default_plus_default(self): t1 = self.tables.t1 - testing.db.execute( - t1.insert().values(upddef=1) - ) + testing.db.execute(t1.insert().values(upddef=1)) result = testing.db.execute( - t1.update(). - values(insdef=2).return_defaults( - t1.c.data, t1.c.upddef)) - eq_( - dict(result.returned_defaults), - {"data": None, 'upddef': 1} + t1.update() + .values(insdef=2) + .return_defaults(t1.c.data, t1.c.upddef) ) + eq_(dict(result.returned_defaults), {"data": None, "upddef": 1}) def test_insert_all(self): t1 = self.tables.t1 @@ -392,36 +416,30 @@ class ReturnDefaultsTest(fixtures.TablesTest): ) eq_( dict(result.returned_defaults), - {"id": 1, "data": None, "insdef": 0} + {"id": 1, "data": None, "insdef": 0}, ) def test_update_all(self): t1 = self.tables.t1 - testing.db.execute( - t1.insert().values(upddef=1) - ) + testing.db.execute(t1.insert().values(upddef=1)) result = testing.db.execute( - t1.update(). - values(insdef=2).return_defaults() - ) - eq_( - dict(result.returned_defaults), - {'upddef': 1} + t1.update().values(insdef=2).return_defaults() ) + eq_(dict(result.returned_defaults), {"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() c.close() 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() c.close() @@ -432,6 +450,7 @@ class ImplicitReturningFlag(fixtures.TestBase): def go(): supports[0] = True + testing.requires.returning(go)() e = engines.testing_engine() diff --git a/test/sql/test_rowcount.py b/test/sql/test_rowcount.py index ea29bcf7e..126e1f0cd 100644 --- a/test/sql/test_rowcount.py +++ b/test/sql/test_rowcount.py @@ -8,7 +8,7 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): """tests rowcount functionality""" - __requires__ = ('sane_rowcount', ) + __requires__ = ("sane_rowcount",) __backend__ = True @classmethod @@ -17,28 +17,35 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): metadata = MetaData(testing.db) employees_table = Table( - 'employees', metadata, + "employees", + metadata, Column( - 'employee_id', Integer, - Sequence('employee_id_seq', optional=True), primary_key=True), - Column('name', String(50)), - Column('department', String(1))) + "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() @@ -56,23 +63,26 @@ 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") 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") assert r.rowcount == 3 @testing.skip_if( - testing.requires.oracle5x, - "unknown DBAPI error fixed in later version") + testing.requires.oracle5x, "unknown DBAPI error fixed in later version" + ) @testing.requires.sane_rowcount_w_returning def test_update_rowcount_return_defaults(self): department = employees_table.c.department - stmt = employees_table.update(department == 'C').values( - name=employees_table.c.department + 'Z').return_defaults() + stmt = ( + employees_table.update(department == "C") + .values(name=employees_table.c.department + "Z") + .return_defaults() + ) r = stmt.execute() assert r.rowcount == 3 @@ -81,7 +91,8 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): # test issue #3622, make sure eager rowcount is called for text with testing.db.connect() as conn: result = conn.execute( - "update employees set department='Z' where department='C'") + "update employees set department='Z' where department='C'" + ) eq_(result.rowcount, 3) def test_text_rowcount(self): @@ -90,43 +101,49 @@ class FoundRowsTest(fixtures.TestBase, AssertsExecutionResults): result = conn.execute( text( "update employees set department='Z' " - "where department='C'")) + "where department='C'" + ) + ) eq_(result.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() assert r.rowcount == 3 @testing.requires.sane_multi_rowcount def test_multi_update_rowcount(self): - stmt = employees_table.update().\ - where(employees_table.c.name == bindparam('emp_name')).\ - values(department="C") + stmt = ( + employees_table.update() + .where(employees_table.c.name == bindparam("emp_name")) + .values(department="C") + ) r = testing.db.execute( stmt, - [{"emp_name": "Bob"}, {"emp_name": "Cynthia"}, - {"emp_name": "nonexistent"}] + [ + {"emp_name": "Bob"}, + {"emp_name": "Cynthia"}, + {"emp_name": "nonexistent"}, + ], ) - eq_( - r.rowcount, 2 - ) + eq_(r.rowcount, 2) @testing.requires.sane_multi_rowcount def test_multi_delete_rowcount(self): - stmt = employees_table.delete().\ - where(employees_table.c.name == bindparam('emp_name')) + stmt = employees_table.delete().where( + employees_table.c.name == bindparam("emp_name") + ) r = testing.db.execute( stmt, - [{"emp_name": "Bob"}, {"emp_name": "Cynthia"}, - {"emp_name": "nonexistent"}] - ) - - eq_( - r.rowcount, 2 + [ + {"emp_name": "Bob"}, + {"emp_name": "Cynthia"}, + {"emp_name": "nonexistent"}, + ], ) + eq_(r.rowcount, 2) diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py index 4b92e3e3e..023a0bc61 100644 --- a/test/sql/test_selectable.py +++ b/test/sql/test_selectable.py @@ -1,10 +1,12 @@ """Test various algorithmic properties of selectables.""" -from sqlalchemy.testing import eq_, assert_raises, \ - assert_raises_message, is_ +from sqlalchemy.testing import eq_, assert_raises, assert_raises_message, is_ from sqlalchemy import * -from sqlalchemy.testing import fixtures, AssertsCompiledSQL, \ - AssertsExecutionResults +from sqlalchemy.testing import ( + fixtures, + AssertsCompiledSQL, + AssertsExecutionResults, +) from sqlalchemy.sql import elements from sqlalchemy import testing from sqlalchemy.sql import util as sql_util, visitors, expression @@ -14,33 +16,37 @@ from sqlalchemy import util 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), - - ) - -table2 = Table('table2', metadata, - 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), - ) +table1 = Table( + "table1", + metadata, + 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), +) + +keyed = Table( + "keyed", + metadata, + Column("x", Integer, key="colx"), + Column("y", Integer, key="coly"), + Column("z", Integer), +) class SelectableTest( - fixtures.TestBase, - AssertsExecutionResults, - AssertsCompiledSQL): - __dialect__ = 'default' + fixtures.TestBase, AssertsExecutionResults, AssertsCompiledSQL +): + __dialect__ = "default" def test_indirect_correspondence_on_labels(self): # this test depends upon 'distance' to @@ -48,8 +54,13 @@ class SelectableTest( # same column three times - s = select([table1.c.col1.label('c2'), table1.c.col1, - table1.c.col1.label('c1')]) + s = select( + [ + table1.c.col1.label("c2"), + table1.c.col1, + table1.c.col1.label("c1"), + ] + ) # this tests the same thing as # test_direct_correspondence_on_labels below - @@ -60,25 +71,25 @@ class SelectableTest( assert s.corresponding_column(s.c.c1) is s.c.c1 def test_labeled_subquery_twice(self): - scalar_select = select([table1.c.col1]).label('foo') + scalar_select = select([table1.c.col1]).label("foo") s1 = select([scalar_select]) s2 = select([scalar_select, scalar_select]) eq_( s1.c.foo.proxy_set, - set([s1.c.foo, scalar_select, scalar_select.element]) + set([s1.c.foo, scalar_select, scalar_select.element]), ) eq_( s2.c.foo.proxy_set, - set([s2.c.foo, scalar_select, scalar_select.element]) + set([s2.c.foo, scalar_select, scalar_select.element]), ) assert s1.corresponding_column(scalar_select) is s1.c.foo assert s2.corresponding_column(scalar_select) is s2.c.foo def test_label_grouped_still_corresponds(self): - label = select([table1.c.col1]).label('foo') + label = select([table1.c.col1]).label("foo") label2 = label.self_group() s1 = select([label]) @@ -90,14 +101,14 @@ class SelectableTest( # this test depends on labels being part # of the proxy set to get the right result - l1, l2 = table1.c.col1.label('foo'), table1.c.col1.label('bar') + l1, l2 = table1.c.col1.label("foo"), table1.c.col1.label("bar") sel = select([l1, l2]) sel2 = sel.alias() assert sel2.corresponding_column(l1) is sel2.c.foo assert sel2.corresponding_column(l2) is sel2.c.bar - sel2 = select([table1.c.col1.label('foo'), table1.c.col2.label('bar')]) + sel2 = select([table1.c.col1.label("foo"), table1.c.col2.label("bar")]) sel3 = sel.union(sel2).alias() assert sel3.corresponding_column(l1) is sel3.c.foo @@ -105,9 +116,9 @@ class SelectableTest( def test_keyed_gen(self): s = select([keyed]) - eq_(s.c.colx.key, 'colx') + eq_(s.c.colx.key, "colx") - eq_(s.c.colx.name, 'x') + eq_(s.c.colx.name, "x") assert s.corresponding_column(keyed.c.colx) is s.c.colx assert s.corresponding_column(keyed.c.coly) is s.c.coly @@ -131,26 +142,26 @@ class SelectableTest( assert sel2.corresponding_column(keyed.c.z) is sel2.c.keyed_z def test_keyed_c_collection_upper(self): - c = Column('foo', Integer, key='bar') - t = Table('t', MetaData(), c) + c = Column("foo", Integer, key="bar") + t = Table("t", MetaData(), c) is_(t.c.bar, c) def test_keyed_c_collection_lower(self): - c = column('foo') - c.key = 'bar' - t = table('t', c) + c = column("foo") + c.key = "bar" + t = table("t", c) is_(t.c.bar, c) def test_clone_c_proxy_key_upper(self): - c = Column('foo', Integer, key='bar') - t = Table('t', MetaData(), c) + c = Column("foo", Integer, key="bar") + t = Table("t", MetaData(), c) s = select([t])._clone() assert c in s.c.bar.proxy_set def test_clone_c_proxy_key_lower(self): - c = column('foo') - c.key = 'bar' - t = table('t', c) + c = column("foo") + c.key = "bar" + t = table("t", c) s = select([t])._clone() assert c in s.c.bar.proxy_set @@ -160,19 +171,16 @@ class SelectableTest( def myop(x, y): pass - t = table('t', column('x'), column('y')) + t = table("t", column("x"), column("y")) expr = BinaryExpression(t.c.x, t.c.y, myop) s = select([t, expr]) - eq_( - s.c.keys(), - ['x', 'y', expr.anon_label] - ) + eq_(s.c.keys(), ["x", "y", expr.anon_label]) def test_cloned_intersection(self): - t1 = table('t1', column('x')) - t2 = table('t2', column('x')) + t1 = table("t1", column("x")) + t2 = table("t2", column("x")) s1 = t1.select() s2 = t2.select() @@ -184,15 +192,13 @@ class SelectableTest( s3c1 = s3._clone() eq_( - expression._cloned_intersection( - [s1c1, s3c1], [s2c1, s1c2] - ), - set([s1c1]) + expression._cloned_intersection([s1c1, s3c1], [s2c1, s1c2]), + set([s1c1]), ) def test_cloned_difference(self): - t1 = table('t1', column('x')) - t2 = table('t2', column('x')) + t1 = table("t1", column("x")) + t2 = table("t2", column("x")) s1 = t1.select() s2 = t2.select() @@ -205,75 +211,70 @@ class SelectableTest( s3c1 = s3._clone() eq_( - expression._cloned_difference( - [s1c1, s2c1, s3c1], [s2c1, s1c2] - ), - set([s3c1]) + expression._cloned_difference([s1c1, s2c1, s3c1], [s2c1, s1c2]), + set([s3c1]), ) def test_distance_on_aliases(self): - a1 = table1.alias('a1') - for s in (select([a1, table1], use_labels=True), - select([table1, a1], use_labels=True)): - assert s.corresponding_column(table1.c.col1) \ - is s.c.table1_col1 + a1 = table1.alias("a1") + for s in ( + select([a1, table1], use_labels=True), + select([table1, a1], use_labels=True), + ): + assert s.corresponding_column(table1.c.col1) is s.c.table1_col1 assert s.corresponding_column(a1.c.col1) is s.c.a1_col1 def test_join_against_self(self): - jj = select([table1.c.col1.label('bar_col1')]) + jj = select([table1.c.col1.label("bar_col1")]) jjj = join(table1, jj, table1.c.col1 == jj.c.bar_col1) # test column directly against itself - assert jjj.corresponding_column(jjj.c.table1_col1) \ - is jjj.c.table1_col1 + assert jjj.corresponding_column(jjj.c.table1_col1) is jjj.c.table1_col1 assert jjj.corresponding_column(jj.c.bar_col1) is jjj.c.bar_col1 # test alias of the join - j2 = jjj.alias('foo') - assert j2.corresponding_column(table1.c.col1) \ - is j2.c.table1_col1 + j2 = jjj.alias("foo") + assert j2.corresponding_column(table1.c.col1) is j2.c.table1_col1 def test_clone_append_column(self): - sel = select([literal_column('1').label('a')]) - eq_(list(sel.c.keys()), ['a']) + sel = select([literal_column("1").label("a")]) + eq_(list(sel.c.keys()), ["a"]) cloned = visitors.ReplacingCloningVisitor().traverse(sel) - cloned.append_column(literal_column('2').label('b')) + cloned.append_column(literal_column("2").label("b")) cloned.append_column(func.foo()) - eq_(list(cloned.c.keys()), ['a', 'b', 'foo()']) + eq_(list(cloned.c.keys()), ["a", "b", "foo()"]) def test_append_column_after_replace_selectable(self): - basesel = select([literal_column('1').label('a')]) - tojoin = select([ - literal_column('1').label('a'), - literal_column('2').label('b') - ]) - basefrom = basesel.alias('basefrom') - joinfrom = tojoin.alias('joinfrom') + basesel = select([literal_column("1").label("a")]) + 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]) replaced = sel.replace_selectable( - basefrom, - basefrom.join(joinfrom, basefrom.c.a == joinfrom.c.a) + basefrom, basefrom.join(joinfrom, basefrom.c.a == joinfrom.c.a) ) self.assert_compile( replaced, "SELECT basefrom.a FROM (SELECT 1 AS a) AS basefrom " "JOIN (SELECT 1 AS a, 2 AS b) AS joinfrom " - "ON basefrom.a = joinfrom.a" + "ON basefrom.a = joinfrom.a", ) replaced.append_column(joinfrom.c.b) self.assert_compile( replaced, "SELECT basefrom.a, joinfrom.b FROM (SELECT 1 AS a) AS basefrom " "JOIN (SELECT 1 AS a, 2 AS b) AS joinfrom " - "ON basefrom.a = joinfrom.a" + "ON basefrom.a = joinfrom.a", ) def test_against_cloned_non_table(self): # test that corresponding column digs across # clone boundaries with anonymous labeled elements - col = func.count().label('foo') + col = func.count().label("foo") sel = select([col]) sel2 = visitors.ReplacingCloningVisitor().traverse(sel) @@ -287,14 +288,14 @@ class SelectableTest( self.assert_compile( s1.with_only_columns([s1]), "SELECT (SELECT table1.col1, table1.col2, " - "table1.col3, table1.colx FROM table1) AS anon_1" + "table1.col3, table1.colx FROM table1) AS anon_1", ) def test_type_coerce_preserve_subq(self): class MyType(TypeDecorator): impl = Integer - stmt = select([type_coerce(column('x'), MyType).label('foo')]) + stmt = select([type_coerce(column("x"), MyType).label("foo")]) stmt2 = stmt.select() assert isinstance(stmt._raw_columns[0].type, MyType) assert isinstance(stmt.c.foo.type, MyType) @@ -303,30 +304,32 @@ class SelectableTest( def test_select_on_table(self): sel = select([table1, table2], use_labels=True) - assert sel.corresponding_column(table1.c.col1) \ + 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 + ) + 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 + ) def test_join_against_join(self): j = outerjoin(table1, table2, table1.c.col1 == table2.c.col2) - jj = select([table1.c.col1.label('bar_col1')], - from_obj=[j]).alias('foo') + jj = select([table1.c.col1.label("bar_col1")], from_obj=[j]).alias( + "foo" + ) jjj = join(table1, jj, table1.c.col1 == jj.c.bar_col1) - assert jjj.corresponding_column(jjj.c.table1_col1) \ - is jjj.c.table1_col1 - j2 = jjj.alias('foo') - assert j2.corresponding_column(jjj.c.table1_col1) \ - is j2.c.table1_col1 + assert jjj.corresponding_column(jjj.c.table1_col1) is jjj.c.table1_col1 + j2 = jjj.alias("foo") + assert j2.corresponding_column(jjj.c.table1_col1) is j2.c.table1_col1 assert jjj.corresponding_column(jj.c.bar_col1) is jj.c.bar_col1 def test_table_alias(self): - a = table1.alias('a') + a = table1.alias("a") j = join(a, table2) @@ -338,13 +341,13 @@ class SelectableTest( # prominent w/ PostgreSQL's tuple functions stmt = select([table1.c.col1, table1.c.col2]) - a = stmt.alias('a') + a = stmt.alias("a") self.assert_compile( select([func.foo(a)]), "SELECT foo(SELECT table1.col1, table1.col2 FROM table1) " "AS foo_1 FROM " "(SELECT table1.col1 AS col1, table1.col2 AS col2 FROM table1) " - "AS a" + "AS a", ) def test_union(self): @@ -353,15 +356,25 @@ class SelectableTest( # 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) @@ -388,8 +401,10 @@ class SelectableTest( 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 @@ -399,14 +414,29 @@ class SelectableTest( # same as testunion, except its an alias of the union - u = select([table1.c.col1, + 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') + 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 @@ -429,7 +459,8 @@ class SelectableTest( 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 @@ -445,8 +476,10 @@ class SelectableTest( 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 @@ -462,8 +495,10 @@ class SelectableTest( 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 @@ -477,13 +512,18 @@ class SelectableTest( @testing.emits_warning("Column 'col1'") def test_union_alias_dupe_keys_grouped(self): - s1 = select([table1.c.col1, table1.c.col2, table2.c.col1]).\ - limit(1).alias() + s1 = ( + select([table1.c.col1, table1.c.col2, table2.c.col1]) + .limit(1) + .alias() + ) s2 = select([table2.c.col1, table2.c.col2, table2.c.col3]).limit(1) 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 @@ -499,14 +539,29 @@ class SelectableTest( # like testaliasunion, but off a Select off the union. - u = select([table1.c.col1, + 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') + 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) @@ -517,14 +572,29 @@ class SelectableTest( # same as testunion, except its an alias of the union - u = select([table1.c.col1, + 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') + 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 @@ -532,14 +602,14 @@ class SelectableTest( def test_join(self): a = join(table1, table2) print(str(a.select(use_labels=True))) - b = table2.alias('b') + b = table2.alias("b") j = join(a, b) print(str(j)) criterion = a.c.table1_col1 == b.c.col2 self.assert_(criterion.compare(j.onclause)) def test_select_alias(self): - a = table1.select().alias('a') + a = table1.select().alias("a") j = join(a, table2) criterion = a.c.col1 == table2.c.col2 @@ -562,15 +632,19 @@ class SelectableTest( is_(expr2.left, sel2) def test_column_labels(self): - a = select([table1.c.col1.label('acol1'), - table1.c.col2.label('acol2'), - table1.c.col3.label('acol3')]) + a = select( + [ + table1.c.col1.label("acol1"), + 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)) def test_labeled_select_correspoinding(self): - l1 = select([func.max(table1.c.col1)]).label('foo') + l1 = select([func.max(table1.c.col1)]).label("foo") s = select([l1]) eq_(s.corresponding_column(l1), s.c.foo) @@ -579,7 +653,7 @@ class SelectableTest( eq_(s.corresponding_column(l1), s.c.foo) def test_select_alias_labels(self): - a = table2.select(use_labels=True).alias('a') + a = table2.select(use_labels=True).alias("a") j = join(a, table1) criterion = table1.c.col1 == a.c.table2_col2 @@ -587,14 +661,13 @@ class SelectableTest( def test_table_joined_to_select_of_table(self): metadata = MetaData() - a = Table('a', metadata, - Column('id', Integer, primary_key=True)) + a = Table("a", metadata, Column("id", Integer, primary_key=True)) - j2 = select([a.c.id.label('aid')]).alias('bar') + j2 = select([a.c.id.label("aid")]).alias("bar") j3 = a.join(j2, j2.c.aid == a.c.id) - j4 = select([j3]).alias('foo') + j4 = select([j3]).alias("foo") assert j4.corresponding_column(j2.c.aid) is j4.c.aid assert j4.corresponding_column(a.c.id) is j4.c.id @@ -602,9 +675,9 @@ class SelectableTest( m = MetaData() m2 = MetaData() - t1 = Table('t1', m, Column('id', Integer), Column('id2', Integer)) - t2 = Table('t2', m, Column('id', Integer, ForeignKey('t1.id'))) - t3 = Table('t3', m2, Column('id', Integer, ForeignKey('t1.id2'))) + t1 = Table("t1", m, Column("id", Integer), Column("id2", Integer)) + t2 = Table("t2", m, Column("id", Integer, ForeignKey("t1.id"))) + t3 = Table("t3", m2, Column("id", Integer, ForeignKey("t1.id2"))) s = select([t2, t3], use_labels=True) @@ -612,24 +685,24 @@ class SelectableTest( def test_multi_label_chain_naming_col(self): # See [ticket:2167] for this one. - l1 = table1.c.col1.label('a') - l2 = select([l1]).label('b') + l1 = table1.c.col1.label("a") + l2 = select([l1]).label("b") s = select([l2]) assert s.c.b is not None self.assert_compile( s.select(), - "SELECT b FROM (SELECT (SELECT table1.col1 AS a FROM table1) AS b)" + "SELECT b FROM (SELECT (SELECT table1.col1 AS a FROM table1) AS b)", ) - s2 = select([s.label('c')]) + s2 = select([s.label("c")]) self.assert_compile( s2.select(), "SELECT c FROM (SELECT (SELECT (" - "SELECT table1.col1 AS a FROM table1) AS b) AS c)" + "SELECT table1.col1 AS a FROM table1) AS b) AS c)", ) def test_self_referential_select_raises(self): - t = table('t', column('x')) + t = table("t", column("x")) s = select([t]) @@ -637,140 +710,110 @@ class SelectableTest( assert_raises_message( exc.InvalidRequestError, r"select\(\) construct refers to itself as a FROM", - s.compile + s.compile, ) def test_unusual_column_elements_text(self): """test that .c excludes text().""" s = select([table1.c.col1, text("foo")]) - eq_( - list(s.c), - [s.c.col1] - ) + eq_(list(s.c), [s.c.col1]) def test_unusual_column_elements_clauselist(self): """Test that raw ClauseList is expanded into .c.""" from sqlalchemy.sql.expression import ClauseList + s = select([table1.c.col1, ClauseList(table1.c.col2, table1.c.col3)]) - eq_( - list(s.c), - [s.c.col1, s.c.col2, s.c.col3] - ) + eq_(list(s.c), [s.c.col1, s.c.col2, s.c.col3]) def test_unusual_column_elements_boolean_clauselist(self): """test that BooleanClauseList is placed as single element in .c.""" c2 = and_(table1.c.col2 == 5, table1.c.col3 == 4) s = select([table1.c.col1, c2]) - eq_( - list(s.c), - [s.c.col1, s.corresponding_column(c2)] - ) + eq_(list(s.c), [s.c.col1, s.corresponding_column(c2)]) def test_from_list_deferred_constructor(self): - c1 = Column('c1', Integer) - c2 = Column('c2', Integer) + c1 = Column("c1", Integer) + c2 = Column("c2", Integer) s = select([c1]) - t = Table('t', MetaData(), c1, c2) + t = Table("t", MetaData(), c1, c2) eq_(c1._from_objects, [t]) eq_(c2._from_objects, [t]) - self.assert_compile(select([c1]), - "SELECT t.c1 FROM t") - self.assert_compile(select([c2]), - "SELECT t.c2 FROM t") + self.assert_compile(select([c1]), "SELECT t.c1 FROM t") + self.assert_compile(select([c2]), "SELECT t.c2 FROM t") def test_from_list_deferred_whereclause(self): - c1 = Column('c1', Integer) - c2 = Column('c2', Integer) + c1 = Column("c1", Integer) + c2 = Column("c2", Integer) s = select([c1]).where(c1 == 5) - t = Table('t', MetaData(), c1, c2) + t = Table("t", MetaData(), c1, c2) eq_(c1._from_objects, [t]) eq_(c2._from_objects, [t]) - self.assert_compile(select([c1]), - "SELECT t.c1 FROM t") - self.assert_compile(select([c2]), - "SELECT t.c2 FROM t") + self.assert_compile(select([c1]), "SELECT t.c1 FROM t") + self.assert_compile(select([c2]), "SELECT t.c2 FROM t") def test_from_list_deferred_fromlist(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer)) + t1 = Table("t1", m, Column("x", Integer)) - c1 = Column('c1', Integer) + c1 = Column("c1", Integer) s = select([c1]).where(c1 == 5).select_from(t1) - t2 = Table('t2', MetaData(), c1) + t2 = Table("t2", MetaData(), c1) eq_(c1._from_objects, [t2]) - self.assert_compile(select([c1]), - "SELECT t2.c1 FROM t2") + self.assert_compile(select([c1]), "SELECT t2.c1 FROM t2") def test_from_list_deferred_cloning(self): - c1 = Column('c1', Integer) - c2 = Column('c2', Integer) + c1 = Column("c1", Integer) + c2 = Column("c2", Integer) s = select([c1]) s2 = select([c2]) s3 = sql_util.ClauseAdapter(s).traverse(s2) - Table('t', MetaData(), c1, c2) + Table("t", MetaData(), c1, c2) - self.assert_compile( - s3, - "SELECT t.c2 FROM t" - ) + self.assert_compile(s3, "SELECT t.c2 FROM t") def test_from_list_with_columns(self): - table1 = table('t1', column('a')) - table2 = table('t2', column('b')) + table1 = table("t1", column("a")) + 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" - ) + self.assert_compile(s1, "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" - ) + self.assert_compile(s2, "SELECT t2.b FROM t2") s3 = sql_util.ClauseAdapter(table1).traverse(s1) - self.assert_compile(s3, - "SELECT t1.a, t2.b FROM t1, t2" - ) + self.assert_compile(s3, "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" - ) + self.assert_compile(s4, "SELECT t2.b FROM t2") def test_from_list_warning_against_existing(self): - c1 = Column('c1', Integer) + c1 = Column("c1", Integer) s = select([c1]) # force a compile. - self.assert_compile( - s, - "SELECT c1" - ) + self.assert_compile(s, "SELECT c1") - Table('t', MetaData(), c1) + Table("t", MetaData(), c1) - self.assert_compile( - s, - "SELECT t.c1 FROM t" - ) + self.assert_compile(s, "SELECT t.c1 FROM t") def test_from_list_recovers_after_warning(self): - c1 = Column('c1', Integer) - c2 = Column('c2', Integer) + c1 = Column("c1", Integer) + c2 = Column("c2", Integer) s = select([c1]) @@ -779,7 +822,8 @@ class SelectableTest( @testing.emits_warning() def go(): - return Table('t', MetaData(), c1, c2) + return Table("t", MetaData(), c1, c2) + t = go() eq_(c1._from_objects, [t]) @@ -793,175 +837,175 @@ class SelectableTest( self.assert_compile(select([c2]), "SELECT t.c2 FROM t") def test_label_gen_resets_on_table(self): - c1 = Column('c1', Integer) + c1 = Column("c1", Integer) eq_(c1._label, "c1") - Table('t1', MetaData(), c1) + Table("t1", MetaData(), c1) eq_(c1._label, "t1_c1") class RefreshForNewColTest(fixtures.TestBase): - def test_join_uninit(self): - a = table('a', column('x')) - b = table('b', column('y')) + a = table("a", column("x")) + b = table("b", column("y")) j = a.join(b, a.c.x == b.c.y) - q = column('q') + q = column("q") b.append_column(q) j._refresh_for_new_column(q) assert j.c.b_q is q def test_join_init(self): - a = table('a', column('x')) - b = table('b', column('y')) + a = table("a", column("x")) + b = table("b", column("y")) j = a.join(b, a.c.x == b.c.y) j.c - q = column('q') + q = column("q") b.append_column(q) 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')) + a = table("a", column("x")) + b = table("b", column("y")) j = a.join(b, a.c.x == b.c.y) j.c - q = column('x') + q = column("x") b.append_column(q) j._refresh_for_new_column(q) assert j.c.b_x is q def test_select_samename_init(self): - a = table('a', column('x')) - b = table('b', column('y')) + a = table("a", column("x")) + b = table("b", column("y")) s = select([a, b]).apply_labels() s.c - q = column('x') + q = column("x") b.append_column(q) s._refresh_for_new_column(q) assert q in s.c.b_x.proxy_set def test_aliased_select_samename_uninit(self): - a = table('a', column('x')) - b = table('b', column('y')) + a = table("a", column("x")) + b = table("b", column("y")) s = select([a, b]).apply_labels().alias() - q = column('x') + q = column("x") b.append_column(q) s._refresh_for_new_column(q) assert q in s.c.b_x.proxy_set def test_aliased_select_samename_init(self): - a = table('a', column('x')) - b = table('b', column('y')) + a = table("a", column("x")) + b = table("b", column("y")) s = select([a, b]).apply_labels().alias() s.c - q = column('x') + q = column("x") b.append_column(q) s._refresh_for_new_column(q) assert q in s.c.b_x.proxy_set def test_aliased_select_irrelevant(self): - a = table('a', column('x')) - b = table('b', column('y')) - c = table('c', column('z')) + a = table("a", column("x")) + b = table("b", column("y")) + c = table("c", column("z")) s = select([a, b]).apply_labels().alias() s.c - q = column('x') + q = column("x") c.append_column(q) s._refresh_for_new_column(q) - assert 'c_x' not in s.c + assert "c_x" not in s.c def test_aliased_select_no_cols_clause(self): - a = table('a', column('x')) + a = table("a", column("x")) s = select([a.c.x]).apply_labels().alias() s.c - q = column('q') + q = column("q") a.append_column(q) s._refresh_for_new_column(q) - assert 'a_q' not in s.c + assert "a_q" not in s.c def test_union_uninit(self): - a = table('a', column('x')) + a = table("a", column("x")) s1 = select([a]) s2 = select([a]) s3 = s1.union(s2) - q = column('q') + q = column("q") a.append_column(q) s3._refresh_for_new_column(q) assert a.c.q in s3.c.q.proxy_set def test_union_init_raises(self): - a = table('a', column('x')) + a = table("a", column("x")) s1 = select([a]) s2 = select([a]) s3 = s1.union(s2) s3.c - q = column('q') + 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 + s3._refresh_for_new_column, + q, ) def test_nested_join_uninit(self): - a = table('a', column('x')) - b = table('b', column('y')) - c = table('c', column('z')) + a = table("a", column("x")) + b = table("b", column("y")) + c = table("c", column("z")) j = a.join(b, a.c.x == b.c.y).join(c, b.c.y == c.c.z) - q = column('q') + q = column("q") b.append_column(q) j._refresh_for_new_column(q) assert j.c.b_q is q def test_nested_join_init(self): - a = table('a', column('x')) - b = table('b', column('y')) - c = table('c', column('z')) + a = table("a", column("x")) + b = table("b", column("y")) + c = table("c", column("z")) j = a.join(b, a.c.x == b.c.y).join(c, b.c.y == c.c.z) j.c - q = column('q') + q = column("q") b.append_column(q) j._refresh_for_new_column(q) assert j.c.b_q is q def test_fk_table(self): m = MetaData() - fk = ForeignKey('x.id') - Table('x', m, Column('id', Integer)) - a = Table('a', m, Column('x', Integer, fk)) + fk = ForeignKey("x.id") + Table("x", m, Column("id", Integer)) + a = Table("a", m, Column("x", Integer, fk)) a.c - q = Column('q', Integer) + q = Column("q", Integer) a.append_column(q) a._refresh_for_new_column(q) eq_(a.foreign_keys, set([fk])) - fk2 = ForeignKey('g.id') - p = Column('p', Integer, fk2) + fk2 = ForeignKey("g.id") + p = Column("p", Integer, fk2) a.append_column(p) a._refresh_for_new_column(p) eq_(a.foreign_keys, set([fk, fk2])) def test_fk_join(self): m = MetaData() - fk = ForeignKey('x.id') - Table('x', m, Column('id', Integer)) - a = Table('a', m, Column('x', Integer, fk)) - b = Table('b', m, Column('y', Integer)) + fk = ForeignKey("x.id") + Table("x", m, Column("id", Integer)) + a = Table("a", m, Column("x", Integer, fk)) + b = Table("b", m, Column("y", Integer)) j = a.join(b, a.c.x == b.c.y) j.c - q = Column('q', Integer) + q = Column("q", Integer) b.append_column(q) j._refresh_for_new_column(q) eq_(j.foreign_keys, set([fk])) - fk2 = ForeignKey('g.id') - p = Column('p', Integer, fk2) + fk2 = ForeignKey("g.id") + p = Column("p", Integer, fk2) b.append_column(p) j._refresh_for_new_column(p) eq_(j.foreign_keys, set([fk, fk2])) @@ -972,18 +1016,18 @@ class AnonLabelTest(fixtures.TestBase): """Test behaviors fixed by [ticket:2168].""" def test_anon_labels_named_column(self): - c1 = column('x') + c1 = column("x") assert c1.label(None) is not c1 eq_(str(select([c1.label(None)])), "SELECT x AS x_1") def test_anon_labels_literal_column(self): - c1 = literal_column('x') + c1 = literal_column("x") assert c1.label(None) is not c1 eq_(str(select([c1.label(None)])), "SELECT x AS x_1") def test_anon_labels_func(self): - c1 = func.count('*') + c1 = func.count("*") assert c1.label(None) is not c1 eq_(str(select([c1])), "SELECT count(:count_2) AS count_1") @@ -992,76 +1036,76 @@ class AnonLabelTest(fixtures.TestBase): eq_(str(select([c1.label(None)])), "SELECT count(:count_2) AS count_1") def test_named_labels_named_column(self): - c1 = column('x') - eq_(str(select([c1.label('y')])), "SELECT x AS y") + c1 = column("x") + eq_(str(select([c1.label("y")])), "SELECT x AS y") def test_named_labels_literal_column(self): - c1 = literal_column('x') - eq_(str(select([c1.label('y')])), "SELECT x AS y") + c1 = literal_column("x") + eq_(str(select([c1.label("y")])), "SELECT x AS y") class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_flat_ok_on_non_join(self): - a = table('a', column('a')) + a = table("a", column("a")) s = a.select() self.assert_compile( s.alias(flat=True).select(), - "SELECT anon_1.a FROM (SELECT a.a AS a FROM a) AS anon_1" + "SELECT anon_1.a FROM (SELECT a.a AS a FROM a) AS anon_1", ) def test_join_alias(self): - a = table('a', column('a')) - b = table('b', column('b')) + a = table("a", column("a")) + b = table("b", column("b")) self.assert_compile( a.join(b, a.c.a == b.c.b).alias(), - "SELECT a.a AS a_a, b.b AS b_b FROM a JOIN b ON a.a = b.b" + "SELECT a.a AS a_a, b.b AS b_b FROM a JOIN b ON a.a = b.b", ) def test_join_standalone_alias(self): - a = table('a', column('a')) - b = table('b', column('b')) + a = table("a", column("a")) + b = table("b", column("b")) self.assert_compile( alias(a.join(b, a.c.a == b.c.b)), - "SELECT a.a AS a_a, b.b AS b_b FROM a JOIN b ON a.a = b.b" + "SELECT a.a AS a_a, b.b AS b_b FROM a JOIN b ON a.a = b.b", ) def test_join_alias_flat(self): - a = table('a', column('a')) - b = table('b', column('b')) + a = table("a", column("a")) + b = table("b", column("b")) self.assert_compile( a.join(b, a.c.a == b.c.b).alias(flat=True), - "a AS a_1 JOIN b AS b_1 ON a_1.a = b_1.b" + "a AS a_1 JOIN b AS b_1 ON a_1.a = b_1.b", ) def test_join_standalone_alias_flat(self): - a = table('a', column('a')) - b = table('b', column('b')) + a = table("a", column("a")) + b = table("b", column("b")) self.assert_compile( alias(a.join(b, a.c.a == b.c.b), flat=True), - "a AS a_1 JOIN b AS b_1 ON a_1.a = b_1.b" + "a AS a_1 JOIN b AS b_1 ON a_1.a = b_1.b", ) def test_composed_join_alias_flat(self): - a = table('a', column('a')) - b = table('b', column('b')) - c = table('c', column('c')) - d = table('d', column('d')) + a = table("a", column("a")) + b = table("b", column("b")) + c = table("c", column("c")) + d = table("d", column("d")) j1 = a.join(b, a.c.a == b.c.b) j2 = c.join(d, c.c.c == d.c.d) self.assert_compile( j1.join(j2, b.c.b == c.c.c).alias(flat=True), "a AS a_1 JOIN b AS b_1 ON a_1.a = b_1.b JOIN " - "(c AS c_1 JOIN d AS d_1 ON c_1.c = d_1.d) ON b_1.b = c_1.c" + "(c AS c_1 JOIN d AS d_1 ON c_1.c = d_1.d) ON b_1.b = c_1.c", ) def test_composed_join_alias(self): - a = table('a', column('a')) - b = table('b', column('b')) - c = table('c', column('c')) - d = table('d', column('d')) + a = table("a", column("a")) + b = table("b", column("b")) + c = table("c", column("c")) + d = table("d", column("d")) j1 = a.join(b, a.c.a == b.c.b) j2 = c.join(d, c.c.c == d.c.d) @@ -1070,29 +1114,35 @@ class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL): "SELECT anon_1.a_a, anon_1.b_b, anon_1.c_c, anon_1.d_d " "FROM (SELECT a.a AS a_a, b.b AS b_b, c.c AS c_c, d.d AS d_d " "FROM a JOIN b ON a.a = b.b " - "JOIN (c JOIN d ON c.c = d.d) ON b.b = c.c) AS anon_1" + "JOIN (c JOIN d ON c.c = d.d) ON b.b = c.c) AS anon_1", ) class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_join_condition(self): m = MetaData() - t1 = Table('t1', m, Column('id', Integer)) - t2 = Table('t2', m, - 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'))) - t4 = Table('t4', m, Column('id', Integer), - Column('t2id', ForeignKey('t2.id'))) - t5 = Table('t5', m, - Column('t1id1', ForeignKey('t1.id')), - Column('t1id2', ForeignKey('t1.id')), - ) + t1 = Table("t1", m, Column("id", Integer)) + t2 = Table( + "t2", m, 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")), + ) + t4 = Table( + "t4", m, Column("id", Integer), Column("t2id", ForeignKey("t2.id")) + ) + t5 = Table( + "t5", + m, + Column("t1id1", ForeignKey("t1.id")), + Column("t1id2", ForeignKey("t1.id")), + ) t1t2 = t1.join(t2) t2t3 = t2.join(t3) @@ -1108,10 +1158,8 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): (t1t2, t2t3, t2, t1t2.c.t2_id == t2t3.c.t3_t2id), ]: assert expected.compare( - sql_util.join_condition( - left, - right, - a_subset=a_subset)) + sql_util.join_condition(left, right, a_subset=a_subset) + ) # these are ambiguous, or have no joins for left, right, a_subset in [ @@ -1120,12 +1168,14 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): (t1, t4, None), (t1t2, t2t3, None), (t5, t1, None), - (t5.select(use_labels=True), t1, None) + (t5.select(use_labels=True), t1, None), ]: assert_raises( exc.ArgumentError, sql_util.join_condition, - left, right, a_subset=a_subset + left, + right, + a_subset=a_subset, ) als = t2t3.alias() @@ -1138,41 +1188,38 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): (t2t3, t4, t2t3.c.t2_id == t4.c.t2id), (t2t3.join(t1), t4, t2t3.c.t2_id == t4.c.t2id), (t2t3.join(t1), t4, t2t3.c.t2_id == t4.c.t2id), - (t1t2, als, t1t2.c.t2_id == als.c.t3_t2id) + (t1t2, als, t1t2.c.t2_id == als.c.t3_t2id), ]: - assert expected.compare( - left.join(right).onclause - ) + assert expected.compare(left.join(right).onclause) # 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") + 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 " + 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") + "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) - ) + t1 = Table("t1", m, Column("id", Integer, primary_key=True)) t2 = Table( - 't2', + "t2", m, - Column( - 't1id', - Integer, - ForeignKey('t1.id'), - ForeignKey('t1.id'))) + Column("t1id", Integer, ForeignKey("t1.id"), ForeignKey("t1.id")), + ) assert sql_util.join_condition(t1, t2).compare(t1.c.id == t2.c.t1id) @@ -1181,35 +1228,43 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): # bounding the "good" column with two "bad" ones is so to # 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')), - ) - t2 = Table('t2', m, Column('id', Integer)) + t1 = Table( + "t1", + m, + 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) 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'))) - t2 = Table('t2', m, Column('id', Integer)) - Table('t3', m, Column('id', Integer)) + t1 = Table( + "t1", + m, + Column("x", Integer, ForeignKey("t2.id")), + 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) assert sql_util.join_condition(t2, t1).compare(t1.c.x == t2.c.id) def test_join_cond_no_such_related_table(self): m1 = MetaData() m2 = MetaData() - t1 = Table('t1', m1, Column('x', Integer, ForeignKey('t2.id'))) - t2 = Table('t2', m2, Column('id', Integer)) + t1 = Table("t1", m1, Column("x", Integer, ForeignKey("t2.id"))) + t2 = Table("t2", m2, Column("id", Integer)) assert_raises_message( exc.NoReferencedTableError, "Foreign key associated with column 't1.x' could not find " "table 't2' with which to generate a foreign key to " "target column 'id'", - sql_util.join_condition, t1, t2 + sql_util.join_condition, + t1, + t2, ) assert_raises_message( @@ -1217,19 +1272,23 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): "Foreign key associated with column 't1.x' could not find " "table 't2' with which to generate a foreign key to " "target column 'id'", - sql_util.join_condition, t2, t1 + sql_util.join_condition, + t2, + t1, ) def test_join_cond_no_such_related_column(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer, ForeignKey('t2.q'))) - t2 = Table('t2', m, Column('id', Integer)) + t1 = Table("t1", m, Column("x", Integer, ForeignKey("t2.q"))) + t2 = Table("t2", m, Column("id", Integer)) assert_raises_message( exc.NoReferencedColumnError, "Could not initialize target column for " "ForeignKey 't2.q' on table 't1': " "table 't2' has no column named 'q'", - sql_util.join_condition, t1, t2 + sql_util.join_condition, + t1, + t2, ) assert_raises_message( @@ -1237,25 +1296,35 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL): "Could not initialize target column for " "ForeignKey 't2.q' on table 't1': " "table 't2' has no column named 'q'", - sql_util.join_condition, t2, t1 + sql_util.join_condition, + t2, + t1, ) class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): - def test_join_pk_collapse_implicit(self): """test that redundant columns in a join get 'collapsed' into a minimal primary key, which is the root column along a chain of foreign key relationships.""" 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)) - c = Table('c', meta, Column('id', Integer, ForeignKey('b.id'), - primary_key=True)) - d = Table('d', meta, Column('id', Integer, ForeignKey('c.id'), - primary_key=True)) + a = Table("a", meta, Column("id", Integer, primary_key=True)) + b = Table( + "b", + meta, + Column("id", Integer, ForeignKey("a.id"), primary_key=True), + ) + c = Table( + "c", + meta, + Column("id", Integer, ForeignKey("b.id"), primary_key=True), + ) + d = Table( + "d", + meta, + Column("id", Integer, ForeignKey("c.id"), 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] @@ -1271,43 +1340,60 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): explicit join conditions.""" meta = MetaData() - 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)) - c = Table('c', meta, Column('id', Integer, ForeignKey('b.id'), - primary_key=True), Column('x', Integer)) - d = Table('d', meta, Column('id', Integer, ForeignKey('c.id'), - primary_key=True), Column('x', Integer)) + 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), + ) + c = Table( + "c", + meta, + Column("id", Integer, ForeignKey("b.id"), primary_key=True), + Column("x", Integer), + ) + d = Table( + "d", + meta, + Column("id", Integer, ForeignKey("c.id"), 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] - assert list(a.join(b).join(c, c.c.id == b.c.x).primary_key) \ - == [a.c.id] - assert list(b.join(c, c.c.x == b.c.id).join(d).primary_key) \ - == [b.c.id] - assert list(b.join(c, c.c.id == b.c.x).join(d).primary_key) \ - == [b.c.id] + assert list(a.join(b).join(c, c.c.id == b.c.x).primary_key) == [a.c.id] + assert list(b.join(c, c.c.x == b.c.id).join(d).primary_key) == [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] - assert list(a.join(b, and_(a.c.id == b.c.id, a.c.x - == b.c.id)).primary_key) == [a.c.id] + a.join(b).join(c, c.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] def test_init_doesnt_blowitaway(self): meta = MetaData() - 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)) + 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), + ) j = a.join(b) assert list(j.primary_key) == [a.c.id] @@ -1317,12 +1403,18 @@ 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)) - b = Table('b', meta, - Column('id', Integer, ForeignKey('a.id'), primary_key=True), - Column('x', Integer, primary_key=True)) + 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), + ) 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) @@ -1331,123 +1423,156 @@ class PrimaryKeyTest(fixtures.TestBase, AssertsExecutionResults): def test_onclause_direction(self): metadata = MetaData() - employee = Table('Employee', metadata, - Column('name', String(100)), - Column('id', Integer, primary_key=True), - ) + employee = Table( + "Employee", + metadata, + Column("name", String(100)), + Column("id", Integer, primary_key=True), + ) - engineer = Table('Engineer', metadata, - Column('id', Integer, - ForeignKey('Employee.id'), primary_key=True)) + engineer = Table( + "Engineer", + metadata, + Column("id", Integer, ForeignKey("Employee.id"), primary_key=True), + ) - eq_(util.column_set(employee.join(engineer, employee.c.id - == 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), - util.column_set([employee.c.id])) + eq_( + util.column_set( + employee.join( + engineer, employee.c.id == 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 + ), + 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))) + t1 = Table( + "t1", + meta, + Column("t1id", Integer, primary_key=True), + Column("t1data", String(30)), + ) t2 = Table( - 't2', + "t2", meta, - Column( - 't2id', - Integer, - ForeignKey('t1.t1id'), - primary_key=True), - Column( - 't2data', - String(30))) + Column("t2id", Integer, ForeignKey("t1.t1id"), primary_key=True), + Column("t2data", String(30)), + ) t3 = Table( - 't3', + "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, - t1.c.t1data, - t2.c.t2id, - t2.c.t2data, - t3.c.t3id, - t3.c.t3data, - ])), util.column_set([t1.c.t1id, t1.c.t1data, t2.c.t2data, - t3.c.t3data])) + Column("t3id", Integer, ForeignKey("t2.t2id"), primary_key=True), + Column("t3data", String(30)), + ) + + eq_( + util.column_set( + sql_util.reduce_columns( + [ + t1.c.t1id, + t1.c.t1data, + t2.c.t2id, + t2.c.t2data, + t3.c.t3id, + 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_name', String(50))) - managers = Table('managers', metadata, - 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) - 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])) + engineers = Table( + "engineers", + metadata, + 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_name", String(50)), + ) + s = select([engineers, 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] + ), + ) def test_reduce_generation(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer, primary_key=True), - Column('y', Integer)) - t2 = Table('t2', m, Column('z', Integer, ForeignKey('t1.x')), - Column('q', Integer)) + t1 = Table( + "t1", + m, + Column("x", Integer, primary_key=True), + Column("y", Integer), + ) + t2 = Table( + "t2", + m, + Column("z", Integer, ForeignKey("t1.x")), + Column("q", Integer), + ) s1 = select([t1, t2]) s2 = s1.reduce_columns(only_synonyms=False) - eq_( - set(s2.inner_columns), - set([t1.c.x, t1.c.y, t2.c.q]) - ) + eq_(set(s2.inner_columns), set([t1.c.x, t1.c.y, t2.c.q])) s2 = s1.reduce_columns() - eq_( - set(s2.inner_columns), - set([t1.c.x, t1.c.y, t2.c.z, t2.c.q]) - ) + eq_(set(s2.inner_columns), 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)) - t2 = Table('t2', m, Column('x', Integer, ForeignKey('t1.x')), - Column('q', Integer, ForeignKey('t1.y'))) + t1 = Table( + "t1", + m, + Column("x", Integer, primary_key=True), + Column("y", Integer), + ) + t2 = Table( + "t2", + m, + Column("x", Integer, ForeignKey("t1.x")), + Column("q", Integer, ForeignKey("t1.y")), + ) s1 = select([t1, t2]) s1 = s1.reduce_columns(only_synonyms=True) - eq_( - set(s1.c), - set([s1.c.x, s1.c.y, s1.c.q]) - ) + eq_(set(s1.c), set([s1.c.x, s1.c.y, s1.c.q])) 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) - ) + t1 = Table( + "t1", + m, + Column("x", Integer, primary_key=True), + 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([t1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]), ) # reverse order, s1.c.x wins @@ -1455,91 +1580,129 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): 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([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", + 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', + "engineers", metadata, - Column('person_id', Integer, ForeignKey('people.person_id' - ), primary_key=True), - Column('status', String(30)), - Column('engineer_name', String(50)), - Column('primary_language', String(50)), + Column( + "person_id", + Integer, + ForeignKey("people.person_id"), + 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))) - 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])), - util.column_set([pjoin.c.people_person_id])) + "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, + ] + ) + ), + util.column_set([pjoin.c.people_person_id]), + ) def test_reduce_aliased_union(self): metadata = MetaData() item_table = Table( - 'item', + "item", metadata, Column( - 'id', - Integer, - ForeignKey('base_item.id'), - primary_key=True), - Column( - 'dummy', - Integer, - default=0)) + "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)) + "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'), - 'Item': base_item_table.join(item_table)}, - 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 = polymorphic_union( + { + "BaseItem": base_item_table.select( + base_item_table.c.child_name == "BaseItem" + ), + "Item": base_item_table.join(item_table), + }, + 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] + ), + ) def test_reduce_aliased_union_2(self): metadata = MetaData() - page_table = Table('page', metadata, Column('id', Integer, - primary_key=True)) - magazine_page_table = Table('magazine_page', metadata, - Column('page_id', Integer, - ForeignKey('page.id'), - primary_key=True)) + page_table = Table( + "page", metadata, Column("id", Integer, 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', + "classified_page", metadata, Column( - 'magazine_page_id', + "magazine_page_id", Integer, - ForeignKey('magazine_page.page_id'), - primary_key=True)) + 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 @@ -1549,25 +1712,33 @@ 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. @@ -1576,45 +1747,70 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults): # currently makes the external column look like that of the # 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])) + 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]), + ) class DerivedTest(fixtures.TestBase, AssertsExecutionResults): - def test_table(self): meta = MetaData() - t1 = Table('t1', meta, Column('c1', Integer, primary_key=True), - Column('c2', String(30))) - t2 = Table('t2', meta, Column('c1', Integer, primary_key=True), - Column('c2', String(30))) + t1 = Table( + "t1", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) + t2 = Table( + "t2", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) 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), - Column('c2', String(30))) - t2 = Table('t2', meta, Column('c1', Integer, primary_key=True), - Column('c2', String(30))) + t1 = Table( + "t1", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) + t2 = Table( + "t2", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) assert t1.alias().is_derived_from(t1) assert not t2.alias().is_derived_from(t1) @@ -1624,44 +1820,43 @@ class DerivedTest(fixtures.TestBase, AssertsExecutionResults): def test_select(self): meta = MetaData() - t1 = Table('t1', meta, Column('c1', Integer, primary_key=True), - Column('c2', String(30))) - t2 = Table('t2', meta, Column('c1', Integer, primary_key=True), - Column('c2', String(30))) + t1 = Table( + "t1", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) + t2 = Table( + "t2", + meta, + Column("c1", Integer, primary_key=True), + Column("c2", String(30)), + ) assert t1.select().is_derived_from(t1) assert not t2.select().is_derived_from(t1) assert select([t1, t2]).is_derived_from(t1) - assert t1.select().alias('foo').is_derived_from(t1) - assert select([t1, t2]).alias('foo').is_derived_from(t1) - assert not t2.select().alias('foo').is_derived_from(t1) + assert t1.select().alias("foo").is_derived_from(t1) + 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): - t = table('t', column('x')) + t = table("t", column("x")) a = t.alias() s = t.select() s2 = a.select() - for obj in [ - t, - t.c.x, - a, - s, - s2, - t.c.x > 1, - (t.c.x > 1).label(None) - ]: + for obj in [t, t.c.x, a, s, s2, t.c.x > 1, (t.c.x > 1).label(None)]: annot = obj._annotate({}) eq_(set([obj]), set([annot])) def test_compare(self): - t = table('t', column('x'), column('y')) + t = table("t", column("x"), column("y")) x_a = t.c.x._annotate({}) assert t.c.x.compare(x_a) assert x_a.compare(t.c.x) @@ -1681,40 +1876,44 @@ class AnnotationsTest(fixtures.TestBase): def test_late_name_add(self): from sqlalchemy.schema import Column + c1 = Column(Integer) c1_a = c1._annotate({"foo": "bar"}) - c1.name = 'somename' - eq_(c1_a.name, 'somename') + c1.name = "somename" + eq_(c1_a.name, "somename") def test_late_table_add(self): c1 = Column("foo", Integer) c1_a = c1._annotate({"foo": "bar"}) - t = Table('t', MetaData(), c1) + t = Table("t", MetaData(), c1) is_(c1_a.table, t) def test_basic_attrs(self): - t = Table('t', MetaData(), - Column('x', Integer, info={'q': 'p'}), - Column('y', Integer, key='q')) + t = Table( + "t", + MetaData(), + 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' + t.c.x.info["z"] = "h" - eq_(y_a.key, 'q') + eq_(y_a.key, "q") is_(x_a.table, t) - eq_(x_a.info, {'q': 'p', 'z': 'h'}) + eq_(x_a.info, {"q": "p", "z": "h"}) eq_(t.c.x.anon_label, x_a.anon_label) def test_custom_constructions(self): from sqlalchemy.schema import Column class MyColumn(Column): - def __init__(self): - Column.__init__(self, 'foo', Integer) + Column.__init__(self, "foo", Integer) + _constructor = Column - t1 = Table('t1', MetaData(), MyColumn()) + t1 = Table("t1", MetaData(), MyColumn()) s1 = t1.select() assert isinstance(t1.c.foo, MyColumn) assert isinstance(s1.c.foo, Column) @@ -1734,8 +1933,9 @@ class AnnotationsTest(fixtures.TestBase): 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] @@ -1744,14 +1944,14 @@ class AnnotationsTest(fixtures.TestBase): class MyColumn(Column): pass - col = MyColumn('x', Integer) + col = MyColumn("x", Integer) binary_1 = col == 5 - col_anno = MyColumn('x', Integer)._annotate({"foo": "bar"}) + col_anno = MyColumn("x", Integer)._annotate({"foo": "bar"}) binary_2 = col_anno == 5 eq_(binary_2.left._annotations, {"foo": "bar"}) def test_annotated_corresponding_column(self): - table1 = table('table1', column("col1")) + table1 = table("table1", column("col1")) s1 = select([table1.c.col1]) t1 = s1._annotate({}) @@ -1766,93 +1966,107 @@ 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")) + table1 = table("table1", column("col1"), column("col2")) - bin = table1.c.col1 == bindparam('foo', value=None) + 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}) + b2 = visitors.cloned_traverse(bin, {}, {"binary": visit_binary}) assert str(b2) == "table1.col1 = table1.col2" - b3 = visitors.cloned_traverse(bin._annotate({}), {}, {'binary': - visit_binary}) - assert str(b3) == 'table1.col1 = table1.col2' + b3 = visitors.cloned_traverse( + bin._annotate({}), {}, {"binary": visit_binary} + ) + assert str(b3) == "table1.col1 = table1.col2" def visit_binary(b): - b.left = bindparam('bar') + b.left = bindparam("bar") - b4 = visitors.cloned_traverse(b2, {}, {'binary': visit_binary}) + b4 = visitors.cloned_traverse(b2, {}, {"binary": visit_binary}) assert str(b4) == ":bar = table1.col2" - b5 = visitors.cloned_traverse(b3, {}, {'binary': visit_binary}) + b5 = visitors.cloned_traverse(b3, {}, {"binary": visit_binary}) assert str(b5) == ":bar = table1.col2" def test_label_accessors(self): - t1 = table('t1', column('c1')) + t1 = table("t1", column("c1")) l1 = t1.c.c1.label(None) is_(l1._order_by_label_element, l1) l1a = l1._annotate({"foo": "bar"}) is_(l1a._order_by_label_element, l1a) def test_annotate_aliased(self): - t1 = table('t1', column('c1')) - s = select([(t1.c.c1 + 3).label('bat')]) + t1 = table("t1", column("c1")) + s = select([(t1.c.c1 + 3).label("bat")]) a = s.alias() - a = sql_util._deep_annotate(a, {'foo': 'bar'}) - eq_(a._annotations['foo'], 'bar') - eq_(a.element._annotations['foo'], 'bar') + a = sql_util._deep_annotate(a, {"foo": "bar"}) + eq_(a._annotations["foo"], "bar") + eq_(a.element._annotations["foo"], "bar") def test_annotate_expressions(self): - 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.c.col1.in_([2, 3, 4]), - 'table1.col1 IN (:col1_1, :col1_2, ' - ':col1_3)')]: + 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.c.col1.in_([2, 3, 4]), + "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")) + table1 = table("table1", column("col1"), column("col2")) - bin = table1.c.col1 == bindparam('foo', value=None) + bin = table1.c.col1 == bindparam("foo", value=None) - b2 = sql_util._deep_annotate(bin, {'_orm_adapt': True}) + b2 = sql_util._deep_annotate(bin, {"_orm_adapt": True}) b3 = sql_util._deep_deannotate(b2) b4 = sql_util._deep_deannotate(bin) for elem in (b2._annotations, b2.left._annotations): - assert '_orm_adapt' in elem + assert "_orm_adapt" in elem - for elem in b3._annotations, b3.left._annotations, \ - b4._annotations, b4.left._annotations: + for elem in ( + b3._annotations, + b3.left._annotations, + b4._annotations, + b4.left._annotations, + ): assert elem == {} assert b2.left is not bin.left assert b3.left is not b2.left and b2.left is not bin.left assert b4.left is bin.left # since column is immutable # deannotate copies the element - assert bin.right is not b2.right and b2.right is not b3.right \ + assert ( + bin.right is not b2.right + and b2.right is not b3.right and b3.right is not b4.right + ) def test_annotate_unique_traversal(self): """test that items are copied only once during @@ -1864,16 +2078,14 @@ class AnnotationsTest(fixtures.TestBase): case now, as deannotate is making clones again in some cases. """ - table1 = table('table1', column('x')) - table2 = table('table2', column('y')) + table1 = table("table1", column("x")) + table2 = table("table2", column("y")) a1 = table1.alias() - s = select([a1.c.x]).select_from( - a1.join(table2, a1.c.x == table2.c.y) - ) + s = select([a1.c.x]).select_from(a1.join(table2, a1.c.x == table2.c.y)) for sel in ( sql_util._deep_deannotate(s), visitors.cloned_traverse(s, {}, {}), - visitors.replacement_traverse(s, {}, lambda x: None) + visitors.replacement_traverse(s, {}, lambda x: None), ): # the columns clause isn't changed at all assert sel._raw_columns[0].table is a1 @@ -1886,7 +2098,7 @@ class AnnotationsTest(fixtures.TestBase): # when encountered. for sel in ( sql_util._deep_deannotate(s, {"foo": "bar"}), - sql_util._deep_annotate(s, {'foo': 'bar'}), + sql_util._deep_annotate(s, {"foo": "bar"}), ): assert sel._froms[0] is not sel._froms[1].left @@ -1899,7 +2111,7 @@ class AnnotationsTest(fixtures.TestBase): preserving them when deep_annotate is run on them. """ - t1 = table('table1', column("col1"), column("col2")) + t1 = table("table1", column("col1"), column("col2")) s = select([t1.c.col1._annotate({"foo": "bar"})]) s2 = select([t1.c.col1._annotate({"bat": "hoho"})]) s3 = s.union(s2) @@ -1907,42 +2119,40 @@ class AnnotationsTest(fixtures.TestBase): eq_( sel.selects[0]._raw_columns[0]._annotations, - {"foo": "bar", "new": "thing"} + {"foo": "bar", "new": "thing"}, ) eq_( sel.selects[1]._raw_columns[0]._annotations, - {"bat": "hoho", "new": "thing"} + {"bat": "hoho", "new": "thing"}, ) 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 = table("table1", column("col1"), column("col2")) + j = table1.c.col1._annotate( + {"remote": True} + ) == table1.c.col2._annotate({"local": True}) j2 = sql_util._deep_deannotate(j) - eq_( - j.left._annotations, {"remote": True} - ) - eq_( - j2.left._annotations, {} - ) + eq_(j.left._annotations, {"remote": True}) + eq_(j2.left._annotations, {}) def test_deannotate_3(self): - table1 = table('table1', column("col1"), column("col2"), - column("col3"), column("col4")) + table1 = table( + "table1", + column("col1"), + column("col2"), + 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_( - j.clauses[0].left._annotations, {"remote": True} - ) - eq_( - j2.clauses[0].left._annotations, {} - ) + eq_(j.clauses[0].left._annotations, {"remote": True}) + eq_(j2.clauses[0].left._annotations, {}) def test_annotate_fromlist_preservation(self): """test the FROM list in select still works @@ -1952,37 +2162,34 @@ class AnnotationsTest(fixtures.TestBase): #2453, continued """ - table1 = table('table1', column('x')) - table2 = table('table2', column('y')) + table1 = table("table1", column("x")) + table2 = table("table2", column("y")) a1 = table1.alias() - s = select([a1.c.x]).select_from( - a1.join(table2, a1.c.x == table2.c.y) - ) + s = select([a1.c.x]).select_from(a1.join(table2, a1.c.x == table2.c.y)) assert_s = select([select([s])]) for fn in ( sql_util._deep_deannotate, - lambda s: sql_util._deep_annotate(s, {'foo': 'bar'}), + lambda s: sql_util._deep_annotate(s, {"foo": "bar"}), lambda s: visitors.cloned_traverse(s, {}, {}), - lambda s: visitors.replacement_traverse(s, {}, lambda x: None) + lambda s: visitors.replacement_traverse(s, {}, lambda x: None), ): 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')) + table("t", column("a"), column("b")) b = bindparam("bind", value="x", unique=True) # the annotation of "b" should render the # same. The "unique" test in compiler should # also pass, [ticket:2425] - eq_(str(or_(b, b._annotate({"foo": "bar"}))), - ":bind_1 OR :bind_1") + eq_(str(or_(b, b._annotate({"foo": "bar"}))), ":bind_1 OR :bind_1") def test_comparators_cleaned_out_construction(self): - c = column('a') + c = column("a") comp1 = c.comparator @@ -1991,7 +2198,7 @@ class AnnotationsTest(fixtures.TestBase): assert comp1 is not comp2 def test_comparators_cleaned_out_reannotate(self): - c = column('a') + c = column("a") c1 = c._annotate({"foo": "bar"}) comp1 = c1.comparator @@ -2002,7 +2209,7 @@ class AnnotationsTest(fixtures.TestBase): assert comp1 is not comp2 def test_comparator_cleanout_integration(self): - c = column('a') + c = column("a") c1 = c._annotate({"foo": "bar"}) comp1 = c1.comparator @@ -2018,8 +2225,8 @@ class ReprTest(fixtures.TestBase): for obj in [ elements.Cast(1, 2), elements.TypeClause(String()), - elements.ColumnClause('x'), - elements.BindParameter('q'), + elements.ColumnClause("x"), + elements.BindParameter("q"), elements.Null(), elements.True_(), elements.False_(), @@ -2027,22 +2234,21 @@ class ReprTest(fixtures.TestBase): elements.BooleanClauseList.and_(), elements.Tuple(), elements.Case([]), - elements.Extract('foo', column('x')), - elements.UnaryExpression(column('x')), - elements.Grouping(column('x')), + elements.Extract("foo", column("x")), + elements.UnaryExpression(column("x")), + elements.Grouping(column("x")), elements.Over(func.foo()), - elements.Label('q', column('x')), + elements.Label("q", column("x")), ]: repr(obj) class WithLabelsTest(fixtures.TestBase): - def _assert_labels_warning(self, s): assert_raises_message( exc.SAWarning, r"replaced by Column.*, which has the same key", - lambda: s.c + lambda: s.c, ) def _assert_result_keys(self, s, keys): @@ -2055,147 +2261,128 @@ class WithLabelsTest(fixtures.TestBase): def _names_overlap(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer)) - t2 = Table('t2', m, Column('x', Integer)) + t1 = Table("t1", m, Column("x", Integer)) + t2 = Table("t2", m, Column("x", Integer)) return select([t1, t2]) def test_names_overlap_nolabel(self): sel = self._names_overlap() self._assert_labels_warning(sel) - self._assert_result_keys(sel, ['x']) + self._assert_result_keys(sel, ["x"]) def test_names_overlap_label(self): sel = self._names_overlap().apply_labels() - eq_( - list(sel.c.keys()), - ['t1_x', 't2_x'] - ) - self._assert_result_keys(sel, ['t1_x', 't2_x']) + eq_(list(sel.c.keys()), ["t1_x", "t2_x"]) + self._assert_result_keys(sel, ["t1_x", "t2_x"]) def _names_overlap_keys_dont(self): m = MetaData() - t1 = Table('t1', m, Column('x', Integer, key='a')) - t2 = Table('t2', m, Column('x', Integer, key='b')) + t1 = Table("t1", m, Column("x", Integer, key="a")) + t2 = Table("t2", m, Column("x", Integer, key="b")) return select([t1, t2]) def test_names_overlap_keys_dont_nolabel(self): sel = self._names_overlap_keys_dont() - eq_( - list(sel.c.keys()), - ['a', 'b'] - ) - self._assert_result_keys(sel, ['x']) + eq_(list(sel.c.keys()), ["a", "b"]) + self._assert_result_keys(sel, ["x"]) def test_names_overlap_keys_dont_label(self): sel = self._names_overlap_keys_dont().apply_labels() - eq_( - list(sel.c.keys()), - ['t1_a', 't2_b'] - ) - self._assert_result_keys(sel, ['t1_x', 't2_x']) + eq_(list(sel.c.keys()), ["t1_a", "t2_b"]) + self._assert_result_keys(sel, ["t1_x", "t2_x"]) def _labels_overlap(self): m = MetaData() - t1 = Table('t', m, Column('x_id', Integer)) - t2 = Table('t_x', m, Column('id', Integer)) + t1 = Table("t", m, Column("x_id", Integer)) + t2 = Table("t_x", m, Column("id", Integer)) return select([t1, t2]) def test_labels_overlap_nolabel(self): sel = self._labels_overlap() - eq_( - list(sel.c.keys()), - ['x_id', 'id'] - ) - self._assert_result_keys(sel, ['x_id', 'id']) + eq_(list(sel.c.keys()), ["x_id", "id"]) + self._assert_result_keys(sel, ["x_id", "id"]) def test_labels_overlap_label(self): sel = self._labels_overlap().apply_labels() t2 = sel.froms[1] - eq_( - list(sel.c.keys()), - ['t_x_id', t2.c.id.anon_label] - ) - self._assert_result_keys(sel, ['t_x_id', 'id_1']) - self._assert_subq_result_keys(sel, ['t_x_id', 'id_1']) + eq_(list(sel.c.keys()), ["t_x_id", t2.c.id.anon_label]) + self._assert_result_keys(sel, ["t_x_id", "id_1"]) + self._assert_subq_result_keys(sel, ["t_x_id", "id_1"]) def _labels_overlap_keylabels_dont(self): m = MetaData() - t1 = Table('t', m, Column('x_id', Integer, key='a')) - t2 = Table('t_x', m, Column('id', Integer, key='b')) + t1 = Table("t", m, Column("x_id", Integer, key="a")) + t2 = Table("t_x", m, Column("id", Integer, key="b")) return select([t1, t2]) def test_labels_overlap_keylabels_dont_nolabel(self): sel = self._labels_overlap_keylabels_dont() - eq_(list(sel.c.keys()), ['a', 'b']) - self._assert_result_keys(sel, ['x_id', 'id']) + eq_(list(sel.c.keys()), ["a", "b"]) + self._assert_result_keys(sel, ["x_id", "id"]) def test_labels_overlap_keylabels_dont_label(self): sel = self._labels_overlap_keylabels_dont().apply_labels() - eq_(list(sel.c.keys()), ['t_a', 't_x_b']) - self._assert_result_keys(sel, ['t_x_id', 'id_1']) + eq_(list(sel.c.keys()), ["t_a", "t_x_b"]) + self._assert_result_keys(sel, ["t_x_id", "id_1"]) def _keylabels_overlap_labels_dont(self): m = MetaData() - t1 = Table('t', m, Column('a', Integer, key='x_id')) - t2 = Table('t_x', m, Column('b', Integer, key='id')) + t1 = Table("t", m, Column("a", Integer, key="x_id")) + t2 = Table("t_x", m, Column("b", Integer, key="id")) return select([t1, t2]) def test_keylabels_overlap_labels_dont_nolabel(self): sel = self._keylabels_overlap_labels_dont() - eq_(list(sel.c.keys()), ['x_id', 'id']) - self._assert_result_keys(sel, ['a', 'b']) + eq_(list(sel.c.keys()), ["x_id", "id"]) + self._assert_result_keys(sel, ["a", "b"]) def test_keylabels_overlap_labels_dont_label(self): sel = self._keylabels_overlap_labels_dont().apply_labels() t2 = sel.froms[1] - eq_(list(sel.c.keys()), ['t_x_id', t2.c.id.anon_label]) - self._assert_result_keys(sel, ['t_a', 't_x_b']) - self._assert_subq_result_keys(sel, ['t_a', 't_x_b']) + eq_(list(sel.c.keys()), ["t_x_id", t2.c.id.anon_label]) + self._assert_result_keys(sel, ["t_a", "t_x_b"]) + self._assert_subq_result_keys(sel, ["t_a", "t_x_b"]) def _keylabels_overlap_labels_overlap(self): m = MetaData() - t1 = Table('t', m, Column('x_id', Integer, key='x_a')) - t2 = Table('t_x', m, Column('id', Integer, key='a')) + t1 = Table("t", m, Column("x_id", Integer, key="x_a")) + t2 = Table("t_x", m, Column("id", Integer, key="a")) return select([t1, t2]) def test_keylabels_overlap_labels_overlap_nolabel(self): sel = self._keylabels_overlap_labels_overlap() - eq_(list(sel.c.keys()), ['x_a', 'a']) - self._assert_result_keys(sel, ['x_id', 'id']) - self._assert_subq_result_keys(sel, ['x_id', 'id']) + eq_(list(sel.c.keys()), ["x_a", "a"]) + self._assert_result_keys(sel, ["x_id", "id"]) + self._assert_subq_result_keys(sel, ["x_id", "id"]) def test_keylabels_overlap_labels_overlap_label(self): sel = self._keylabels_overlap_labels_overlap().apply_labels() t2 = sel.froms[1] - eq_(list(sel.c.keys()), ['t_x_a', t2.c.a.anon_label]) - self._assert_result_keys(sel, ['t_x_id', 'id_1']) - self._assert_subq_result_keys(sel, ['t_x_id', 'id_1']) + eq_(list(sel.c.keys()), ["t_x_a", t2.c.a.anon_label]) + self._assert_result_keys(sel, ["t_x_id", "id_1"]) + self._assert_subq_result_keys(sel, ["t_x_id", "id_1"]) def _keys_overlap_names_dont(self): m = MetaData() - t1 = Table('t1', m, Column('a', Integer, key='x')) - t2 = Table('t2', m, Column('b', Integer, key='x')) + t1 = Table("t1", m, Column("a", Integer, key="x")) + t2 = Table("t2", m, Column("b", Integer, key="x")) return select([t1, t2]) def test_keys_overlap_names_dont_nolabel(self): sel = self._keys_overlap_names_dont() self._assert_labels_warning(sel) - self._assert_result_keys(sel, ['a', 'b']) + self._assert_result_keys(sel, ["a", "b"]) def test_keys_overlap_names_dont_label(self): sel = self._keys_overlap_names_dont().apply_labels() - eq_( - list(sel.c.keys()), - ['t1_x', 't2_x'] - ) - self._assert_result_keys(sel, ['t1_a', 't2_b']) + eq_(list(sel.c.keys()), ["t1_x", "t2_x"]) + self._assert_result_keys(sel, ["t1_a", "t2_b"]) class ResultMapTest(fixtures.TestBase): - def _fixture(self): m = MetaData() - t = Table('t', m, Column('x', Integer), Column('y', Integer)) + t = Table("t", m, Column("x", Integer), Column("y", Integer)) return t def _mapping(self, stmt): @@ -2208,7 +2395,7 @@ class ResultMapTest(fixtures.TestBase): def test_select_label_alt_name(self): t = self._fixture() - l1, l2 = t.c.x.label('a'), t.c.y.label('b') + l1, l2 = t.c.x.label("a"), t.c.y.label("b") s = select([l1, l2]) mapping = self._mapping(s) assert l1 in mapping @@ -2217,7 +2404,7 @@ class ResultMapTest(fixtures.TestBase): def test_select_alias_label_alt_name(self): t = self._fixture() - l1, l2 = t.c.x.label('a'), t.c.y.label('b') + l1, l2 = t.c.x.label("a"), t.c.y.label("b") s = select([l1, l2]).alias() mapping = self._mapping(s) assert l1 in mapping @@ -2253,7 +2440,7 @@ class ResultMapTest(fixtures.TestBase): x, y = t.c.x, t.c.y ta = t.alias() - l1, l2 = ta.c.x.label('a'), ta.c.y.label('b') + l1, l2 = ta.c.x.label("a"), ta.c.y.label("b") s = select([l1, l2]) mapping = self._mapping(s) @@ -2268,34 +2455,40 @@ class ResultMapTest(fixtures.TestBase): assert t.c.x not in mapping eq_( [type(entry[-1]) for entry in s.compile()._result_columns], - [Boolean] + [Boolean], ) def test_plain_exists(self): expr = exists([1]) eq_(type(expr.type), Boolean) eq_( - [type(entry[-1]) for - entry in select([expr]).compile()._result_columns], - [Boolean] + [ + type(entry[-1]) + for entry in select([expr]).compile()._result_columns + ], + [Boolean], ) def test_plain_exists_negate(self): expr = ~exists([1]) eq_(type(expr.type), Boolean) eq_( - [type(entry[-1]) for - entry in select([expr]).compile()._result_columns], - [Boolean] + [ + type(entry[-1]) + for entry in select([expr]).compile()._result_columns + ], + [Boolean], ) def test_plain_exists_double_negate(self): expr = ~(~exists([1])) eq_(type(expr.type), Boolean) eq_( - [type(entry[-1]) for - entry in select([expr]).compile()._result_columns], - [Boolean] + [ + type(entry[-1]) + for entry in select([expr]).compile()._result_columns + ], + [Boolean], ) def test_column_subquery_plain(self): @@ -2307,7 +2500,7 @@ class ResultMapTest(fixtures.TestBase): assert s1 in mapping eq_( [type(entry[-1]) for entry in s2.compile()._result_columns], - [Integer] + [Integer], ) def test_unary_boolean(self): @@ -2315,7 +2508,7 @@ class ResultMapTest(fixtures.TestBase): s1 = select([not_(True)], use_labels=True) eq_( [type(entry[-1]) for entry in s1.compile()._result_columns], - [Boolean] + [Boolean], ) @@ -2323,19 +2516,15 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL): __dialect__ = "default" def _assert_legacy(self, leg, read=False, nowait=False): - t = table('t', column('c')) + t = table("t", column("c")) s1 = select([t], for_update=leg) if leg is False: assert s1._for_update_arg is None assert s1.for_update is None else: - eq_( - s1._for_update_arg.read, read - ) - eq_( - s1._for_update_arg.nowait, nowait - ) + eq_(s1._for_update_arg.read, read) + eq_(s1._for_update_arg.nowait, nowait) eq_(s1.for_update, leg) def test_false_legacy(self): @@ -2354,28 +2543,30 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL): self._assert_legacy("read_nowait", read=True, nowait=True) def test_legacy_setter(self): - t = table('t', column('c')) + t = table("t", column("c")) s = select([t]) - s.for_update = 'nowait' + s.for_update = "nowait" eq_(s._for_update_arg.nowait, True) def test_basic_clone(self): - t = table('t', column('c')) + t = table("t", column("c")) s = select([t]).with_for_update(read=True, of=t.c.c) s2 = visitors.ReplacingCloningVisitor().traverse(s) assert s2._for_update_arg is not s._for_update_arg 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") + self.assert_compile( + s2, "SELECT t.c FROM t FOR SHARE OF t", dialect="postgresql" + ) def test_adapt(self): - t = table('t', column('c')) + t = table("t", column("c")) s = select([t]).with_for_update(read=True, of=t.c.c) a = t.alias() 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") + self.assert_compile( + s2, + "SELECT t_1.c FROM t AS t_1 FOR SHARE OF t_1", + dialect="postgresql", + ) diff --git a/test/sql/test_tablesample.py b/test/sql/test_tablesample.py index 879e83182..712450d9f 100644 --- a/test/sql/test_tablesample.py +++ b/test/sql/test_tablesample.py @@ -16,10 +16,13 @@ class TableSampleTest(fixtures.TablesTest, AssertsCompiledSQL): @classmethod def define_tables(cls, metadata): - Table('people', metadata, - Column('people_id', Integer, primary_key=True), - Column('age', Integer), - Column('name', String(30))) + Table( + "people", + metadata, + Column("people_id", Integer, primary_key=True), + Column("age", Integer), + Column("name", String(30)), + ) def test_standalone(self): table1 = self.tables.people @@ -27,27 +30,28 @@ class TableSampleTest(fixtures.TablesTest, AssertsCompiledSQL): # no special alias handling even though clause is not in the # context of a FROM clause self.assert_compile( - tablesample(table1, 1, name='alias'), - 'people AS alias TABLESAMPLE system(:system_1)' + tablesample(table1, 1, name="alias"), + "people AS alias TABLESAMPLE system(:system_1)", ) self.assert_compile( - table1.tablesample(1, name='alias'), - 'people AS alias TABLESAMPLE system(:system_1)' + table1.tablesample(1, name="alias"), + "people AS alias TABLESAMPLE system(:system_1)", ) self.assert_compile( - tablesample(table1, func.bernoulli(1), name='alias', - seed=func.random()), - 'people AS alias TABLESAMPLE bernoulli(:bernoulli_1) ' - 'REPEATABLE (random())' + tablesample( + table1, func.bernoulli(1), name="alias", seed=func.random() + ), + "people AS alias TABLESAMPLE bernoulli(:bernoulli_1) " + "REPEATABLE (random())", ) def test_select_from(self): table1 = self.tables.people self.assert_compile( - select([table1.tablesample(text('1'), name='alias').c.people_id]), - 'SELECT alias.people_id FROM ' - 'people AS alias TABLESAMPLE system(1)' + select([table1.tablesample(text("1"), name="alias").c.people_id]), + "SELECT alias.people_id FROM " + "people AS alias TABLESAMPLE system(1)", ) diff --git a/test/sql/test_text.py b/test/sql/test_text.py index c31c22853..34415600e 100644 --- a/test/sql/test_text.py +++ b/test/sql/test_text.py @@ -1,34 +1,56 @@ """Test the TextClause and related constructs.""" -from sqlalchemy.testing import fixtures, AssertsCompiledSQL, eq_, \ - assert_raises_message, expect_warnings, assert_warnings -from sqlalchemy import text, select, Integer, String, Float, \ - bindparam, and_, func, literal_column, exc, MetaData, Table, Column,\ - asc, func, desc, union, literal +from sqlalchemy.testing import ( + fixtures, + AssertsCompiledSQL, + eq_, + assert_raises_message, + expect_warnings, + assert_warnings, +) +from sqlalchemy import ( + text, + select, + Integer, + String, + Float, + bindparam, + and_, + func, + literal_column, + exc, + MetaData, + Table, + Column, + asc, + func, + desc, + union, + literal, +) from sqlalchemy.types import NullType from sqlalchemy.sql import table, column, util as sql_util from sqlalchemy import util -table1 = table('mytable', - column('myid', Integer), - column('name', String), - column('description', String), - ) +table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), +) table2 = table( - 'myothertable', - column('otherid', Integer), - column('othername', String), + "myothertable", column("otherid", Integer), column("othername", String) ) class CompileTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_basic(self): self.assert_compile( text("select * from foo where lala = bar"), - "select * from foo where lala = bar" + "select * from foo where lala = bar", ) @@ -37,21 +59,24 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): """test the usage of text() implicit within the select() construct when strings are passed.""" - __dialect__ = 'default' + __dialect__ = "default" def test_select_composition_one(self): - self.assert_compile(select( - [ - literal_column("foobar(a)"), - literal_column("pk_foo_bar(syslaal)") - ], - text("a = 12"), - from_obj=[ - text("foobar left outer join lala on foobar.foo = lala.foo") - ] - ), + self.assert_compile( + select( + [ + literal_column("foobar(a)"), + literal_column("pk_foo_bar(syslaal)"), + ], + text("a = 12"), + from_obj=[ + text( + "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" + "left outer join lala on foobar.foo = lala.foo WHERE a = 12", ) def test_select_composition_two(self): @@ -62,40 +87,54 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): s.append_whereclause(text("column2=19")) s = s.order_by("column1") s.append_from(text("table1")) - self.assert_compile(s, "SELECT column1, column2 FROM table1 WHERE " - "column1=12 AND column2=19 ORDER BY column1") + self.assert_compile( + s, + "SELECT column1, column2 FROM table1 WHERE " + "column1=12 AND column2=19 ORDER BY column1", + ) def test_select_composition_three(self): self.assert_compile( - select([column("column1"), column("column2")], - from_obj=table1).alias('somealias').select(), + select([column("column1"), column("column2")], from_obj=table1) + .alias("somealias") + .select(), "SELECT somealias.column1, somealias.column2 FROM " - "(SELECT column1, column2 FROM mytable) AS somealias" + "(SELECT column1, column2 FROM mytable) AS somealias", ) def test_select_composition_four(self): # test that use_labels doesn't interfere with literal columns self.assert_compile( - select([ - text("column1"), column("column2"), - column("column3").label("bar"), table1.c.myid], + select( + [ + text("column1"), + column("column2"), + column("column3").label("bar"), + table1.c.myid, + ], from_obj=table1, - use_labels=True), + use_labels=True, + ), "SELECT column1, column2, column3 AS bar, " "mytable.myid AS mytable_myid " - "FROM mytable" + "FROM mytable", ) def test_select_composition_five(self): # test that use_labels doesn't interfere # with literal columns that have textual labels self.assert_compile( - select([ - text("column1 AS foobar"), text("column2 AS hoho"), - table1.c.myid], - from_obj=table1, use_labels=True), + select( + [ + text("column1 AS foobar"), + text("column2 AS hoho"), + table1.c.myid, + ], + from_obj=table1, + use_labels=True, + ), "SELECT column1 AS foobar, column2 AS hoho, " - "mytable.myid AS mytable_myid FROM mytable" + "mytable.myid AS mytable_myid FROM mytable", ) def test_select_composition_six(self): @@ -103,70 +142,84 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL): # doesn't interfere with literal columns, # exported columns don't get quoted self.assert_compile( - select([ - literal_column("column1 AS foobar"), - literal_column("column2 AS hoho"), table1.c.myid], - from_obj=[table1]).select(), + select( + [ + literal_column("column1 AS foobar"), + literal_column("column2 AS hoho"), + table1.c.myid, + ], + 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): self.assert_compile( - select([ - literal_column('col1'), - literal_column('col2') - ], from_obj=table('tablename')).alias('myalias'), - "SELECT col1, col2 FROM tablename" + select( + [literal_column("col1"), literal_column("col2")], + from_obj=table("tablename"), + ).alias("myalias"), + "SELECT col1, col2 FROM tablename", ) def test_select_composition_eight(self): - self.assert_compile(select( - [table1.alias('t'), text("foo.f")], - text("foo.f = t.id"), - from_obj=[text("(select f from bar where lala=heyhey) foo")] - ), + self.assert_compile( + select( + [table1.alias("t"), text("foo.f")], + text("foo.f = t.id"), + from_obj=[text("(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 f from bar where lala=heyhey) foo WHERE foo.f = t.id", + ) def test_select_bundle_columns(self): - self.assert_compile(select( - [table1, table2.c.otherid, - text("sysdate()"), text("foo, bar, lala")], - and_( - text("foo.id = foofoo(lala)"), - text("datetime(foo) = Today"), - table1.c.myid == table2.c.otherid, - ) - ), + self.assert_compile( + select( + [ + table1, + table2.c.otherid, + text("sysdate()"), + text("foo, bar, lala"), + ], + and_( + text("foo.id = foofoo(lala)"), + text("datetime(foo) = Today"), + 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") + "datetime(foo) = Today AND mytable.myid = myothertable.otherid", + ) class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_legacy(self): - t = text("select * from foo where lala=:bar and hoho=:whee", - bindparams=[bindparam('bar', 4), bindparam('whee', 7)]) + t = text( + "select * from foo where lala=:bar and hoho=:whee", + bindparams=[bindparam("bar", 4), bindparam("whee", 7)], + ) self.assert_compile( t, "select * from foo where lala=:bar and hoho=:whee", - checkparams={'bar': 4, 'whee': 7}, + checkparams={"bar": 4, "whee": 7}, ) def test_positional(self): t = text("select * from foo where lala=:bar and hoho=:whee") - t = t.bindparams(bindparam('bar', 4), bindparam('whee', 7)) + t = t.bindparams(bindparam("bar", 4), bindparam("whee", 7)) self.assert_compile( t, "select * from foo where lala=:bar and hoho=:whee", - checkparams={'bar': 4, 'whee': 7}, + checkparams={"bar": 4, "whee": 7}, ) def test_kw(self): @@ -176,78 +229,78 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( t, "select * from foo where lala=:bar and hoho=:whee", - checkparams={'bar': 4, 'whee': 7}, + checkparams={"bar": 4, "whee": 7}, ) def test_positional_plus_kw(self): t = text("select * from foo where lala=:bar and hoho=:whee") - t = t.bindparams(bindparam('bar', 4), whee=7) + t = t.bindparams(bindparam("bar", 4), whee=7) self.assert_compile( t, "select * from foo where lala=:bar and hoho=:whee", - checkparams={'bar': 4, 'whee': 7}, + checkparams={"bar": 4, "whee": 7}, ) def test_literal_binds(self): t = text("select * from foo where lala=:bar and hoho=:whee") - t = t.bindparams(bindparam('bar', 4), whee='whee') + t = t.bindparams(bindparam("bar", 4), whee="whee") self.assert_compile( t, "select * from foo where lala=4 and hoho='whee'", checkparams={}, - literal_binds=True + literal_binds=True, ) def _assert_type_map(self, t, compare): - map_ = dict( - (b.key, b.type) for b in t._bindparams.values() - ) + map_ = dict((b.key, b.type) for b in t._bindparams.values()) for k in compare: assert compare[k]._type_affinity is map_[k]._type_affinity def test_typing_construction(self): t = text("select * from table :foo :bar :bat") - self._assert_type_map(t, {"foo": NullType(), - "bar": NullType(), - "bat": NullType()}) + self._assert_type_map( + t, {"foo": NullType(), "bar": NullType(), "bat": NullType()} + ) - t = t.bindparams(bindparam('foo', type_=String)) + t = t.bindparams(bindparam("foo", type_=String)) - self._assert_type_map(t, {"foo": String(), - "bar": NullType(), - "bat": NullType()}) + self._assert_type_map( + t, {"foo": String(), "bar": NullType(), "bat": NullType()} + ) - t = t.bindparams(bindparam('bar', type_=Integer)) + t = t.bindparams(bindparam("bar", type_=Integer)) - self._assert_type_map(t, {"foo": String(), - "bar": Integer(), - "bat": NullType()}) + self._assert_type_map( + t, {"foo": String(), "bar": Integer(), "bat": NullType()} + ) t = t.bindparams(bat=45.564) - self._assert_type_map(t, {"foo": String(), - "bar": Integer(), - "bat": Float()}) + self._assert_type_map( + t, {"foo": String(), "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), + 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" + 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), + 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" + checkparams={"bar": 4, "whee": 7}, + dialect="sqlite", ) def test_missing_bind_kw(self): @@ -257,7 +310,8 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): r"a bound parameter named 'bar'", text(":foo").bindparams, foo=5, - bar=7) + bar=7, + ) def test_missing_bind_posn(self): assert_raises_message( @@ -265,70 +319,66 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): r"This text\(\) construct doesn't define " r"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(r"select * from foo where clock='05:06:07' " - r"and mork='\:mindy'"), + text( + r"select * from foo where clock='05:06:07' " + r"and mork='\:mindy'" + ), "select * from foo where clock='05:06:07' and mork=':mindy'", checkparams={}, params={}, - dialect="postgresql" + dialect="postgresql", ) def test_escaping_double_colons(self): self.assert_compile( text( r"SELECT * FROM pg_attribute WHERE " - r"attrelid = :tab\:\:regclass"), - "SELECT * FROM pg_attribute WHERE " - "attrelid = %(tab)s::regclass", - params={'tab': None}, - dialect="postgresql" + r"attrelid = :tab\:\:regclass" + ), + "SELECT * FROM pg_attribute WHERE " "attrelid = %(tab)s::regclass", + params={"tab": None}, + 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) + generate_series = text( + "generate_series(:x, :y, :z) as s(a)" + ).bindparams(x=None, y=None, z=None) - s = select([ - (func.current_date() + literal_column("s.a")).label("dates") - ]).select_from(generate_series) + s = select( + [(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} + 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} + checkparams={"y": 6, "x": 5, "z": 7}, ) def test_escaping_percent_signs(self): stmt = text("select '%' where foo like '%bar%'") self.assert_compile( - stmt, - "select '%' where foo like '%bar%'", - dialect="sqlite" + stmt, "select '%' where foo like '%bar%'", dialect="sqlite" ) self.assert_compile( - stmt, - "select '%%' where foo like '%%bar%%'", - dialect="mysql" + stmt, "select '%%' where foo like '%%bar%%'", dialect="mysql" ) def test_percent_signs_literal_binds(self): @@ -337,88 +387,90 @@ class BindParamTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT 'percent % signs %%' AS anon_1", dialect="sqlite", - literal_binds=True + literal_binds=True, ) self.assert_compile( stmt, "SELECT 'percent %% signs %%%%' AS anon_1", dialect="mysql", - literal_binds=True + literal_binds=True, ) class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __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._create_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._create_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._create_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._create_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._create_result_map(), { - "myid": ("myid", - (table1.c.myid, "myid", "myid"), table1.c.myid.type), - } + "myid": ( + "myid", + (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')) - eq_(t.c.keys(), ['a', 'b', 'c']) + t = text("select a, b, c from foo").columns( + column("a"), 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) - eq_(t.c.keys(), ['a', 'b', 'c']) + 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)) + t = Table("t", m, Column("x", Integer), Column("y", Integer)) return t def _mapping(self, stmt): @@ -431,7 +483,7 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): def test_select_label_alt_name(self): t = self._xy_table_fixture() - l1, l2 = t.c.x.label('a'), t.c.y.label('b') + l1, l2 = t.c.x.label("a"), t.c.y.label("b") s = text("select x AS a, y AS b FROM t").columns(l1, l2) mapping = self._mapping(s) assert l1 in mapping @@ -440,7 +492,7 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): def test_select_alias_label_alt_name(self): t = self._xy_table_fixture() - l1, l2 = t.c.x.label('a'), t.c.y.label('b') + l1, l2 = t.c.x.label("a"), t.c.y.label("b") s = text("select x AS a, y AS b FROM t").columns(l1, l2).alias() mapping = self._mapping(s) assert l1 in mapping @@ -475,7 +527,7 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): x, y = t.c.x, t.c.y ta = t.alias() - l1, l2 = ta.c.x.label('a'), ta.c.y.label('b') + l1, l2 = ta.c.x.label("a"), ta.c.y.label("b") s = text("SELECT ta.x AS a, ta.y AS b FROM t AS ta").columns(l1, l2) mapping = self._mapping(s) @@ -484,29 +536,33 @@ 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( s, "WITH t AS (select id, name from user) " "SELECT mytable.myid, mytable.name, mytable.description " - "FROM mytable, t WHERE mytable.myid = t.id" + "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( s, "SELECT mytable.myid, mytable.name, mytable.description " "FROM mytable, (select id, name from user) AS t " - "WHERE mytable.myid = t.id" + "WHERE mytable.myid = t.id", ) def test_scalar_subquery(self): @@ -519,7 +575,7 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( s, "SELECT mytable.myid, (select id from user) AS anon_1 " - "FROM mytable WHERE mytable.myid = (select id from user)" + "FROM mytable WHERE mytable.myid = (select id from user)", ) def test_build_bindparams(self): @@ -527,16 +583,13 @@ class AsFromTest(fixtures.TestBase, AssertsCompiledSQL): t = t.bindparams(bindparam("foo", type_=Integer)) t = t.columns(id=Integer) t = t.bindparams(bar=String) - t = t.bindparams(bindparam('bat', value='bat')) + t = t.bindparams(bindparam("bat", value="bat")) - eq_( - set(t.element._bindparams), - set(["bat", "foo", "bar"]) - ) + eq_(set(t.element._bindparams), set(["bat", "foo", "bar"])) class TextWarningsTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def _test(self, fn, arg, offending_clause, expected): with expect_warnings("Textual "): @@ -546,75 +599,74 @@ class TextWarningsTest(fixtures.TestBase, AssertsCompiledSQL): assert_raises_message( exc.SAWarning, r"Textual (?:SQL|column|SQL FROM) expression %(stmt)r should be " - r"explicitly declared (?:with|as) text\(%(stmt)r\)" % { - "stmt": util.ellipses_string(offending_clause), - }, - fn, arg + r"explicitly declared (?:with|as) text\(%(stmt)r\)" + % {"stmt": util.ellipses_string(offending_clause)}, + fn, + arg, ) def test_where(self): self._test( - select([table1.c.myid]).where, "myid == 5", "myid == 5", - "SELECT mytable.myid FROM mytable WHERE myid == 5" + select([table1.c.myid]).where, + "myid == 5", + "myid == 5", + "SELECT mytable.myid FROM mytable WHERE myid == 5", ) def test_column(self): - self._test( - select, ["myid"], "myid", - "SELECT myid" - ) + self._test(select, ["myid"], "myid", "SELECT myid") def test_having(self): self._test( - select([table1.c.myid]).having, "myid == 5", "myid == 5", - "SELECT mytable.myid FROM mytable HAVING myid == 5" + select([table1.c.myid]).having, + "myid == 5", + "myid == 5", + "SELECT mytable.myid FROM mytable HAVING myid == 5", ) def test_from(self): self._test( - select([table1.c.myid]).select_from, "mytable", "mytable", - "SELECT mytable.myid FROM mytable, mytable" # two FROMs + select([table1.c.myid]).select_from, + "mytable", + "mytable", + "SELECT mytable.myid FROM mytable, mytable", # two FROMs ) class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def _test_warning(self, stmt, offending_clause, expected): with expect_warnings( - "Can't resolve label reference %r;" % offending_clause): - self.assert_compile( - stmt, - expected - ) + "Can't resolve label reference %r;" % offending_clause + ): + self.assert_compile(stmt, expected) assert_raises_message( exc.SAWarning, - "Can't resolve label reference %r; converting to text" % - offending_clause, - stmt.compile + "Can't resolve label reference %r; converting to text" + % offending_clause, + stmt.compile, ) def test_order_by_label(self): - stmt = select([table1.c.myid.label('foo')]).order_by('foo') + stmt = select([table1.c.myid.label("foo")]).order_by("foo") self.assert_compile( - stmt, - "SELECT mytable.myid AS foo FROM mytable ORDER BY foo" + stmt, "SELECT mytable.myid AS foo FROM mytable ORDER BY foo" ) def test_order_by_colname(self): - stmt = select([table1.c.myid]).order_by('name') + stmt = select([table1.c.myid]).order_by("name") self.assert_compile( - stmt, - "SELECT mytable.myid FROM mytable ORDER BY mytable.name" + stmt, "SELECT mytable.myid FROM mytable ORDER BY mytable.name" ) def test_order_by_alias_colname(self): t1 = table1.alias() - stmt = select([t1.c.myid]).apply_labels().order_by('name') + stmt = select([t1.c.myid]).apply_labels().order_by("name") self.assert_compile( stmt, "SELECT mytable_1.myid AS mytable_1_myid " - "FROM mytable AS mytable_1 ORDER BY mytable_1.name" + "FROM mytable AS mytable_1 ORDER BY mytable_1.name", ) def test_order_by_named_label_from_anon_label(self): @@ -623,7 +675,7 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( stmt, "SELECT mytable.myid AS foo, mytable.name " - "FROM mytable ORDER BY foo" + "FROM mytable ORDER BY foo", ) def test_order_by_outermost_label(self): @@ -637,43 +689,39 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT anon_1.name, bar() AS foo FROM " "(SELECT mytable.myid AS foo, mytable.name AS name " - "FROM mytable) AS anon_1 ORDER BY foo" + "FROM mytable) AS anon_1 ORDER BY foo", ) def test_unresolvable_warning_order_by(self): - stmt = select([table1.c.myid]).order_by('foobar') + stmt = select([table1.c.myid]).order_by("foobar") self._test_warning( - stmt, "foobar", - "SELECT mytable.myid FROM mytable ORDER BY foobar" + stmt, "foobar", "SELECT mytable.myid FROM mytable ORDER BY foobar" ) def test_group_by_label(self): - stmt = select([table1.c.myid.label('foo')]).group_by('foo') + stmt = select([table1.c.myid.label("foo")]).group_by("foo") self.assert_compile( - stmt, - "SELECT mytable.myid AS foo FROM mytable GROUP BY foo" + stmt, "SELECT mytable.myid AS foo FROM mytable GROUP BY foo" ) def test_group_by_colname(self): - stmt = select([table1.c.myid]).group_by('name') + stmt = select([table1.c.myid]).group_by("name") self.assert_compile( - stmt, - "SELECT mytable.myid FROM mytable GROUP BY mytable.name" + stmt, "SELECT mytable.myid FROM mytable GROUP BY mytable.name" ) def test_unresolvable_warning_group_by(self): - stmt = select([table1.c.myid]).group_by('foobar') + stmt = select([table1.c.myid]).group_by("foobar") self._test_warning( - stmt, "foobar", - "SELECT mytable.myid FROM mytable GROUP BY foobar" + stmt, "foobar", "SELECT mytable.myid FROM mytable GROUP BY foobar" ) def test_asc(self): - stmt = select([table1.c.myid]).order_by(asc('name'), 'description') + stmt = select([table1.c.myid]).order_by(asc("name"), "description") self.assert_compile( stmt, "SELECT mytable.myid FROM mytable " - "ORDER BY mytable.name ASC, mytable.description" + "ORDER BY mytable.name ASC, mytable.description", ) def test_group_by_subquery(self): @@ -685,39 +733,39 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): "anon_1.description AS anon_1_description FROM " "(SELECT mytable.myid AS myid, mytable.name AS name, " "mytable.description AS description FROM mytable) AS anon_1 " - "GROUP BY anon_1.myid" + "GROUP BY anon_1.myid", ) def test_order_by_func_label_desc(self): - stmt = select([func.foo('bar').label('fb'), table1]).\ - order_by(desc('fb')) + stmt = select([func.foo("bar").label("fb"), table1]).order_by( + desc("fb") + ) self.assert_compile( stmt, "SELECT foo(:foo_1) AS fb, mytable.myid, mytable.name, " - "mytable.description FROM mytable ORDER BY fb DESC" + "mytable.description FROM mytable ORDER BY fb DESC", ) def test_pg_distinct(self): - stmt = select([table1]).distinct('name') + stmt = select([table1]).distinct("name") self.assert_compile( stmt, "SELECT DISTINCT ON (mytable.name) mytable.myid, " "mytable.name, mytable.description FROM mytable", - dialect="postgresql" + dialect="postgresql", ) def test_over(self): stmt = select([column("foo"), column("bar")]) stmt = select( - [func.row_number(). - over(order_by='foo', partition_by='bar')] + [func.row_number().over(order_by="foo", partition_by="bar")] ).select_from(stmt) self.assert_compile( stmt, "SELECT row_number() OVER (PARTITION BY bar ORDER BY foo) " - "AS anon_1 FROM (SELECT foo, bar)" + "AS anon_1 FROM (SELECT foo, bar)", ) def test_union_column(self): @@ -728,23 +776,20 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): stmt, "SELECT mytable.myid, mytable.name, mytable.description FROM " "mytable UNION SELECT mytable.myid, mytable.name, " - "mytable.description FROM mytable ORDER BY name" + "mytable.description FROM mytable ORDER BY name", ) def test_union_label(self): - s1 = select([func.foo("hoho").label('x')]) - s2 = select([func.foo("Bar").label('y')]) + s1 = select([func.foo("hoho").label("x")]) + s2 = select([func.foo("Bar").label("y")]) stmt = union(s1, s2).order_by("x") self.assert_compile( stmt, - "SELECT foo(:foo_1) AS x UNION SELECT foo(:foo_2) AS y ORDER BY x" + "SELECT foo(:foo_1) AS x UNION SELECT foo(:foo_2) AS y ORDER BY x", ) def test_standalone_units_stringable(self): - self.assert_compile( - desc("somelabel"), - "somelabel DESC" - ) + self.assert_compile(desc("somelabel"), "somelabel DESC") def test_columnadapter_anonymized(self): """test issue #3148 @@ -755,14 +800,18 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): """ exprs = [ table1.c.myid, - table1.c.name.label('t1name'), - func.foo("hoho").label('x')] + table1.c.name.label("t1name"), + func.foo("hoho").label("x"), + ] ta = table1.alias() adapter = sql_util.ColumnAdapter(ta, anonymize_labels=True) - s1 = select([adapter.columns[expr] for expr in exprs]).\ - apply_labels().order_by("myid", "t1name", "x") + s1 = ( + select([adapter.columns[expr] for expr in exprs]) + .apply_labels() + .order_by("myid", "t1name", "x") + ) def go(): # the labels here are anonymized, so label naming @@ -771,13 +820,17 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): s1, "SELECT mytable_1.myid AS mytable_1_myid, " "mytable_1.name AS name_1, foo(:foo_2) AS foo_1 " - "FROM mytable AS mytable_1 ORDER BY mytable_1.myid, t1name, x" + "FROM mytable AS mytable_1 ORDER BY mytable_1.myid, t1name, x", ) assert_warnings( go, - ["Can't resolve label reference 't1name'", - "Can't resolve label reference 'x'"], regex=True) + [ + "Can't resolve label reference 't1name'", + "Can't resolve label reference 'x'", + ], + regex=True, + ) def test_columnadapter_non_anonymized(self): """test issue #3148 @@ -788,19 +841,23 @@ class OrderByLabelResolutionTest(fixtures.TestBase, AssertsCompiledSQL): """ exprs = [ table1.c.myid, - table1.c.name.label('t1name'), - func.foo("hoho").label('x')] + table1.c.name.label("t1name"), + func.foo("hoho").label("x"), + ] ta = table1.alias() adapter = sql_util.ColumnAdapter(ta) - s1 = select([adapter.columns[expr] for expr in exprs]).\ - apply_labels().order_by("myid", "t1name", "x") + s1 = ( + select([adapter.columns[expr] for expr in exprs]) + .apply_labels() + .order_by("myid", "t1name", "x") + ) # labels are maintained self.assert_compile( s1, "SELECT mytable_1.myid AS mytable_1_myid, " "mytable_1.name AS t1name, foo(:foo_1) AS x " - "FROM mytable AS mytable_1 ORDER BY mytable_1.myid, t1name, x" + "FROM mytable AS mytable_1 ORDER BY mytable_1.myid, t1name, x", ) diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py index 71229bfae..8c5fb1f07 100644 --- a/test/sql/test_type_expressions.py +++ b/test/sql/test_type_expressions.py @@ -1,22 +1,22 @@ -from sqlalchemy import (Table, - Column, - String, - func, - MetaData, - select, - TypeDecorator, - cast) +from sqlalchemy import ( + Table, + Column, + String, + func, + MetaData, + select, + TypeDecorator, + cast, +) from sqlalchemy.testing import fixtures, AssertsCompiledSQL from sqlalchemy import testing from sqlalchemy.testing import eq_ class _ExprFixture(object): - def _test_table(self, type_): test_table = Table( - 'test_table', - MetaData(), Column('x', String), Column('y', type_) + "test_table", MetaData(), Column("x", String), Column("y", type_) ) return test_table @@ -92,7 +92,6 @@ class _ExprFixture(object): return self._test_table(variant) def _dialect_level_fixture(self): - class ImplString(String): def bind_expression(self, bindvalue): return func.dialect_bind(bindvalue) @@ -101,27 +100,28 @@ class _ExprFixture(object): return func.dialect_colexpr(col) from sqlalchemy.engine import default + dialect = default.DefaultDialect() dialect.colspecs = {String: ImplString} return dialect class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_select_cols(self): table = self._fixture() self.assert_compile( select([table]), - "SELECT test_table.x, lower(test_table.y) AS y FROM test_table" + "SELECT test_table.x, lower(test_table.y) AS y FROM test_table", ) def test_anonymous_expr(self): table = self._fixture() self.assert_compile( select([cast(table.c.y, String)]), - "SELECT CAST(test_table.y AS VARCHAR) AS anon_1 FROM test_table" + "SELECT CAST(test_table.y AS VARCHAR) AS anon_1 FROM test_table", ) def test_select_cols_use_labels(self): @@ -130,28 +130,27 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table]).apply_labels(), "SELECT test_table.x AS test_table_x, " - "lower(test_table.y) AS test_table_y FROM test_table" + "lower(test_table.y) AS test_table_y FROM test_table", ) def test_select_cols_use_labels_result_map_targeting(self): table = self._fixture() compiled = select([table]).apply_labels().compile() - assert table.c.y in compiled._create_result_map()['test_table_y'][1] - assert table.c.x in compiled._create_result_map()['test_table_x'][1] + assert table.c.y in compiled._create_result_map()["test_table_y"][1] + assert table.c.x in compiled._create_result_map()["test_table_x"][1] # the lower() function goes into the result_map, we don't really # need this but it's fine self.assert_compile( - compiled._create_result_map()['test_table_y'][1][3], - "lower(test_table.y)" + compiled._create_result_map()["test_table_y"][1][3], + "lower(test_table.y)", ) # then the original column gets put in there as well. # as of 1.1 it's important that it is first as this is # taken as significant by the result processor. self.assert_compile( - compiled._create_result_map()['test_table_y'][1][0], - "test_table.y" + compiled._create_result_map()["test_table_y"][1][0], "test_table.y" ) def test_insert_binds(self): @@ -159,12 +158,12 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( table.insert(), - "INSERT INTO test_table (x, y) VALUES (:x, lower(:y))" + "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))" + "INSERT INTO test_table (y) VALUES (lower(:y))", ) def test_select_binds(self): @@ -172,7 +171,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table]).where(table.c.y == "hi"), "SELECT test_table.x, lower(test_table.y) AS y FROM " - "test_table WHERE test_table.y = lower(:y_1)" + "test_table WHERE test_table.y = lower(:y_1)", ) def test_dialect(self): @@ -184,7 +183,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): select([table.c.x]).where(table.c.x == "hi"), "SELECT dialect_colexpr(test_table.x) AS x " "FROM test_table WHERE test_table.x = dialect_bind(:x_1)", - dialect=dialect + dialect=dialect, ) def test_type_decorator_inner(self): @@ -193,7 +192,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table]).where(table.c.y == "hi"), "SELECT test_table.x, inside_colexpr(test_table.y) AS y " - "FROM test_table WHERE test_table.y = inside_bind(:y_1)" + "FROM test_table WHERE test_table.y = inside_bind(:y_1)", ) def test_type_decorator_inner_plus_dialect(self): @@ -209,7 +208,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "SELECT dialect_colexpr(test_table.x) AS x, " "dialect_colexpr(test_table.y) AS y FROM test_table " "WHERE test_table.y = dialect_bind(:y_1)", - dialect=dialect + dialect=dialect, ) def test_type_decorator_outer(self): @@ -218,7 +217,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): self.assert_compile( select([table]).where(table.c.y == "hi"), "SELECT test_table.x, outside_colexpr(test_table.y) AS y " - "FROM test_table WHERE test_table.y = outside_bind(:y_1)" + "FROM test_table WHERE test_table.y = outside_bind(:y_1)", ) def test_type_decorator_outer_plus_dialect(self): @@ -232,7 +231,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "SELECT dialect_colexpr(test_table.x) AS x, " "outside_colexpr(test_table.y) AS y " "FROM test_table WHERE test_table.y = outside_bind(:y_1)", - dialect=dialect + dialect=dialect, ) def test_type_decorator_both(self): @@ -243,7 +242,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "SELECT test_table.x, " "outside_colexpr(inside_colexpr(test_table.y)) AS y " "FROM test_table WHERE " - "test_table.y = outside_bind(inside_bind(:y_1))" + "test_table.y = outside_bind(inside_bind(:y_1))", ) def test_type_decorator_both_plus_dialect(self): @@ -260,7 +259,7 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "outside_colexpr(dialect_colexpr(test_table.y)) AS y " "FROM test_table WHERE " "test_table.y = outside_bind(dialect_bind(:y_1))", - dialect=dialect + dialect=dialect, ) def test_type_decorator_both_w_variant(self): @@ -271,19 +270,19 @@ class SelectTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): "SELECT test_table.x, " "outside_colexpr(inside_colexpr(test_table.y)) AS y " "FROM test_table WHERE " - "test_table.y = outside_bind(inside_bind(:y_1))" + "test_table.y = outside_bind(inside_bind(:y_1))", ) class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" def test_select_from_select(self): table = self._fixture() 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): @@ -292,7 +291,7 @@ class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): 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" + "FROM test_table) AS anon_1", ) def test_select_from_aliased_join(self): @@ -302,16 +301,17 @@ class DerivedTest(_ExprFixture, fixtures.TestBase, AssertsCompiledSQL): 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, " + 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(), @@ -323,83 +323,63 @@ class RoundTripTestBase(object): # test insert coercion alone eq_( testing.db.execute( - "select * from test_table order by y").fetchall(), - [ - ("X1", "y1"), - ("X2", "y2"), - ("X3", "y3"), - ] + "select * from test_table order by y" + ).fetchall(), + [("X1", "y1"), ("X2", "y2"), ("X3", "y3")], ) # conversion back to upper eq_( testing.db.execute( - select([self.tables.test_table]). - order_by(self.tables.test_table.c.y) + select([self.tables.test_table]).order_by( + self.tables.test_table.c.y + ) ).fetchall(), - [ - ("X1", "Y1"), - ("X2", "Y2"), - ("X3", "Y3"), - ] + [("X1", "Y1"), ("X2", "Y2"), ("X3", "Y3")], ) def test_targeting_no_labels(self): testing.db.execute( - self.tables.test_table.insert(), - {"x": "X1", "y": "Y1"}, + self.tables.test_table.insert(), {"x": "X1", "y": "Y1"} ) row = testing.db.execute(select([self.tables.test_table])).first() - eq_( - row[self.tables.test_table.c.y], - "Y1" - ) + eq_(row[self.tables.test_table.c.y], "Y1") def test_targeting_by_string(self): testing.db.execute( - self.tables.test_table.insert(), - {"x": "X1", "y": "Y1"}, + self.tables.test_table.insert(), {"x": "X1", "y": "Y1"} ) row = testing.db.execute(select([self.tables.test_table])).first() - eq_( - row["y"], - "Y1" - ) + eq_(row["y"], "Y1") def test_targeting_apply_labels(self): testing.db.execute( - self.tables.test_table.insert(), - {"x": "X1", "y": "Y1"}, - ) - row = testing.db.execute(select([self.tables.test_table]). - apply_labels()).first() - eq_( - row[self.tables.test_table.c.y], - "Y1" + self.tables.test_table.insert(), {"x": "X1", "y": "Y1"} ) + row = testing.db.execute( + select([self.tables.test_table]).apply_labels() + ).first() + eq_(row[self.tables.test_table.c.y], "Y1") def test_targeting_individual_labels(self): testing.db.execute( - self.tables.test_table.insert(), - {"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() - eq_( - row[self.tables.test_table.c.y], - "Y1" + self.tables.test_table.insert(), {"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() + 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) @@ -407,16 +387,14 @@ class StringRoundTripTest(fixtures.TablesTest, RoundTripTestBase): return func.upper(col) Table( - 'test_table', + "test_table", metadata, - Column('x', String(50)), - Column('y', MyString(50) - ) + Column("x", String(50)), + Column("y", MyString(50)), ) class TypeDecRoundTripTest(fixtures.TablesTest, RoundTripTestBase): - @classmethod def define_tables(cls, metadata): class MyString(TypeDecorator): @@ -429,38 +407,33 @@ class TypeDecRoundTripTest(fixtures.TablesTest, RoundTripTestBase): return func.upper(col) Table( - 'test_table', + "test_table", metadata, - Column('x', String(50)), - Column('y', MyString(50) - ) + Column("x", String(50)), + Column("y", MyString(50)), ) class ReturningTest(fixtures.TablesTest): - __requires__ = 'returning', + __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"} - ) - eq_( - result.first(), - ("yvalue",) + 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 7b464f8c0..179f1050c 100644 --- a/test/sql/test_types.py +++ b/test/sql/test_types.py @@ -1,16 +1,63 @@ # coding: utf-8 -from sqlalchemy.testing import eq_, is_, is_not_, assert_raises, \ - assert_raises_message, expect_warnings +from sqlalchemy.testing import ( + eq_, + is_, + is_not_, + assert_raises, + assert_raises_message, + expect_warnings, +) import decimal import datetime import os from sqlalchemy import ( - Unicode, MetaData, PickleType, Boolean, TypeDecorator, Integer, - Interval, Float, Numeric, Text, CHAR, String, distinct, select, bindparam, - and_, func, Date, LargeBinary, literal, cast, text, Enum, - type_coerce, VARCHAR, Time, DateTime, BigInteger, SmallInteger, BOOLEAN, - BLOB, NCHAR, NVARCHAR, CLOB, TIME, DATE, DATETIME, TIMESTAMP, SMALLINT, - INTEGER, DECIMAL, NUMERIC, FLOAT, REAL, ARRAY, JSON) + Unicode, + MetaData, + PickleType, + Boolean, + TypeDecorator, + Integer, + Interval, + Float, + Numeric, + Text, + CHAR, + String, + distinct, + select, + bindparam, + and_, + func, + Date, + LargeBinary, + literal, + cast, + text, + Enum, + type_coerce, + VARCHAR, + Time, + DateTime, + BigInteger, + SmallInteger, + BOOLEAN, + BLOB, + NCHAR, + NVARCHAR, + CLOB, + TIME, + DATE, + DATETIME, + TIMESTAMP, + SMALLINT, + INTEGER, + DECIMAL, + NUMERIC, + FLOAT, + REAL, + ARRAY, + JSON, +) from sqlalchemy.sql import ddl from sqlalchemy.sql import visitors from sqlalchemy import inspection @@ -21,8 +68,12 @@ from sqlalchemy.schema import CheckConstraint, AddConstraint from sqlalchemy.engine import default from sqlalchemy.testing.schema import Table, Column from sqlalchemy import testing -from sqlalchemy.testing import AssertsCompiledSQL, AssertsExecutionResults, \ - engines, pickleable +from sqlalchemy.testing import ( + AssertsCompiledSQL, + AssertsExecutionResults, + engines, + pickleable, +) from sqlalchemy.testing.util import picklers from sqlalchemy.testing.util import round_decimal from sqlalchemy.testing import fixtures @@ -33,22 +84,22 @@ import importlib class AdaptTest(fixtures.TestBase): - def _all_dialect_modules(self): return [ importlib.import_module("sqlalchemy.dialects.%s" % d) - for d in dialects.__all__ if not d.startswith("_") + for d in dialects.__all__ + if not d.startswith("_") ] def _all_dialects(self): - return [d.base.dialect() for d in - self._all_dialect_modules()] + return [d.base.dialect() for d in self._all_dialect_modules()] def _types_for_mod(self, mod): for key in dir(mod): typ = getattr(mod, key) - if not isinstance(typ, type) or \ - not issubclass(typ, types.TypeEngine): + if not isinstance(typ, type) or not issubclass( + typ, types.TypeEngine + ): continue yield typ @@ -61,6 +112,7 @@ class AdaptTest(fixtures.TestBase): def test_uppercase_importable(self): import sqlalchemy as sa + for typ in self._types_for_mod(types): if typ.__name__ == typ.__name__.upper(): assert getattr(sa, typ.__name__) is typ @@ -91,29 +143,34 @@ class AdaptTest(fixtures.TestBase): (TIME, ("TIME", "TIME WITHOUT TIME ZONE")), (CLOB, "CLOB"), (VARCHAR(10), ("VARCHAR(10)", "VARCHAR(10 CHAR)")), - (NVARCHAR(10), ( - "NVARCHAR(10)", "NATIONAL VARCHAR(10)", "NVARCHAR2(10)")), + ( + NVARCHAR(10), + ("NVARCHAR(10)", "NATIONAL VARCHAR(10)", "NVARCHAR2(10)"), + ), (CHAR, "CHAR"), (NCHAR, ("NCHAR", "NATIONAL CHAR")), (BLOB, ("BLOB", "BLOB SUB_TYPE 0")), - (BOOLEAN, ("BOOLEAN", "BOOL", "INTEGER")) + (BOOLEAN, ("BOOLEAN", "BOOL", "INTEGER")), ): if isinstance(expected, str): - expected = (expected, ) + expected = (expected,) try: - compiled = types.to_instance(type_).\ - compile(dialect=dialect) + compiled = types.to_instance(type_).compile( + dialect=dialect + ) except NotImplementedError: continue - assert compiled in expected, \ - "%r matches none of %r for dialect %s" % \ - (compiled, expected, dialect.name) + assert compiled in expected, ( + "%r matches none of %r for dialect %s" + % (compiled, expected, dialect.name) + ) - assert str(types.to_instance(type_)) in expected, \ - "default str() of type %r not expected, %r" % \ - (type_, expected) + assert str(types.to_instance(type_)) in expected, ( + "default str() of type %r not expected, %r" + % (type_, expected) + ) @testing.uses_deprecated() def test_adapt_method(self): @@ -134,11 +191,15 @@ class AdaptTest(fixtures.TestBase): up_adaptions = [typ] + typ.__subclasses__() yield False, typ, up_adaptions for subcl in typ.__subclasses__(): - if subcl is not typ and typ is not TypeDecorator and \ - "sqlalchemy" in subcl.__module__: + if ( + subcl is not typ + and typ is not TypeDecorator + and "sqlalchemy" in subcl.__module__ + ): yield True, subcl, [typ] from sqlalchemy.sql import sqltypes + for is_down_adaption, typ, target_adaptions in adaptions(): if typ in (types.TypeDecorator, types.TypeEngine, types.Variant): continue @@ -148,10 +209,9 @@ class AdaptTest(fixtures.TestBase): t1 = typ() for cls in target_adaptions: if ( - (is_down_adaption and - issubclass(typ, sqltypes.Emulated)) or - (not is_down_adaption and - issubclass(cls, sqltypes.Emulated)) + is_down_adaption and issubclass(typ, sqltypes.Emulated) + ) or ( + not is_down_adaption and issubclass(cls, sqltypes.Emulated) ): continue @@ -167,18 +227,24 @@ class AdaptTest(fixtures.TestBase): for k in t1.__dict__: if k in ( - 'impl', '_is_oracle_number', - '_create_events', 'create_constraint', - 'inherit_schema', 'schema', 'metadata', - 'name', ): + "impl", + "_is_oracle_number", + "_create_events", + "create_constraint", + "inherit_schema", + "schema", + "metadata", + "name", + ): continue # assert each value was copied, or that # the adapted type has a more specific # value than the original (i.e. SQL Server # applies precision=24 for REAL) - assert \ - getattr(t2, k) == t1.__dict__[k] or \ - t1.__dict__[k] is None + assert ( + getattr(t2, k) == t1.__dict__[k] + or t1.__dict__[k] is None + ) def test_python_type(self): eq_(types.Integer().python_type, int) @@ -192,11 +258,10 @@ class AdaptTest(fixtures.TestBase): eq_(types.String().python_type, str) eq_(types.Unicode().python_type, util.text_type) eq_(types.String(convert_unicode=True).python_type, util.text_type) - eq_(types.Enum('one', 'two', 'three').python_type, str) + eq_(types.Enum("one", "two", "three").python_type, str) assert_raises( - NotImplementedError, - lambda: types.TypeEngine().python_type + NotImplementedError, lambda: types.TypeEngine().python_type ) @testing.uses_deprecated() @@ -219,22 +284,17 @@ class AdaptTest(fixtures.TestBase): """ t1 = String(length=50, convert_unicode=False) t2 = t1.adapt(Text, convert_unicode=True) - eq_( - t2.length, 50 - ) - eq_( - t2.convert_unicode, True - ) + eq_(t2.length, 50) + eq_(t2.convert_unicode, True) class TypeAffinityTest(fixtures.TestBase): - def test_type_affinity(self): for type_, affin in [ (String(), String), (VARCHAR(), String), (Date(), Date), - (LargeBinary(), types._Binary) + (LargeBinary(), types._Binary), ]: eq_(type_._type_affinity, affin) @@ -258,7 +318,7 @@ class TypeAffinityTest(fixtures.TestBase): impl = CHAR def load_dialect_impl(self, dialect): - if dialect.name == 'postgresql': + if dialect.name == "postgresql": return dialect.type_descriptor(postgresql.UUID()) else: return dialect.type_descriptor(CHAR(32)) @@ -270,29 +330,28 @@ class TypeAffinityTest(fixtures.TestBase): class PickleTypesTest(fixtures.TestBase): - def test_pickle_types(self): for loads, dumps in picklers(): column_types = [ - Column('Boo', Boolean()), - Column('Str', String()), - Column('Tex', Text()), - Column('Uni', Unicode()), - Column('Int', Integer()), - Column('Sma', SmallInteger()), - Column('Big', BigInteger()), - Column('Num', Numeric()), - Column('Flo', Float()), - Column('Dat', DateTime()), - Column('Dat', Date()), - Column('Tim', Time()), - Column('Lar', LargeBinary()), - Column('Pic', PickleType()), - Column('Int', Interval()), + Column("Boo", Boolean()), + Column("Str", String()), + Column("Tex", Text()), + Column("Uni", Unicode()), + Column("Int", Integer()), + Column("Sma", SmallInteger()), + Column("Big", BigInteger()), + Column("Num", Numeric()), + Column("Flo", Float()), + Column("Dat", DateTime()), + Column("Dat", Date()), + Column("Tim", Time()), + Column("Lar", LargeBinary()), + Column("Pic", PickleType()), + Column("Int", Interval()), ] for column_type in column_types: meta = MetaData() - Table('foo', meta, column_type) + Table("foo", meta, column_type) loads(dumps(column_type)) loads(dumps(meta)) @@ -301,18 +360,19 @@ class _UserDefinedTypeFixture(object): @classmethod def define_tables(cls, metadata): class MyType(types.UserDefinedType): - def get_col_spec(self): return "VARCHAR(100)" def bind_processor(self, dialect): def process(value): return "BIND_IN" + value + return process def result_processor(self, dialect, coltype): def process(value): return value + "BIND_OUT" + return process def adapt(self, typeobj): @@ -322,19 +382,23 @@ class _UserDefinedTypeFixture(object): impl = String def bind_processor(self, dialect): - impl_processor = super(MyDecoratedType, self).\ - bind_processor(dialect) or (lambda value: value) + impl_processor = super(MyDecoratedType, self).bind_processor( + dialect + ) or (lambda value: value) def process(value): return "BIND_IN" + impl_processor(value) + return process def result_processor(self, dialect, coltype): - impl_processor = super(MyDecoratedType, self).\ - result_processor(dialect, coltype) or (lambda value: value) + impl_processor = super(MyDecoratedType, self).result_processor( + dialect, coltype + ) or (lambda value: value) def process(value): return impl_processor(value) + "BIND_OUT" + return process def copy(self): @@ -365,7 +429,6 @@ class _UserDefinedTypeFixture(object): return MyNewIntType() class MyNewIntSubClass(MyNewIntType): - def process_result_value(self, value, dialect): return value * 15 @@ -376,54 +439,85 @@ class _UserDefinedTypeFixture(object): impl = Unicode def bind_processor(self, dialect): - impl_processor = super(MyUnicodeType, self).\ - bind_processor(dialect) or (lambda value: value) + impl_processor = super(MyUnicodeType, self).bind_processor( + dialect + ) or (lambda value: value) def process(value): return "BIND_IN" + impl_processor(value) + return process def result_processor(self, dialect, coltype): - impl_processor = super(MyUnicodeType, self).\ - result_processor(dialect, coltype) or (lambda value: value) + impl_processor = super(MyUnicodeType, self).result_processor( + dialect, coltype + ) or (lambda value: value) def process(value): return impl_processor(value) + "BIND_OUT" + return process def copy(self): return MyUnicodeType(self.impl.length) Table( - 'users', metadata, - Column('user_id', Integer, primary_key=True), + "users", + metadata, + Column("user_id", Integer, primary_key=True), # totall custom type - Column('goofy', MyType, nullable=False), - + Column("goofy", MyType, nullable=False), # decorated type with an argument, so its a String - Column('goofy2', MyDecoratedType(50), nullable=False), - - Column('goofy4', MyUnicodeType(50), nullable=False), - Column('goofy7', MyNewUnicodeType(50), nullable=False), - Column('goofy8', MyNewIntType, nullable=False), - Column('goofy9', MyNewIntSubClass, nullable=False), + Column("goofy2", MyDecoratedType(50), nullable=False), + Column("goofy4", MyUnicodeType(50), nullable=False), + Column("goofy7", MyNewUnicodeType(50), nullable=False), + Column("goofy8", MyNewIntType, nullable=False), + Column("goofy9", MyNewIntSubClass, nullable=False), ) + class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest): __backend__ = True def _data_fixture(self): users = self.tables.users with testing.db.connect() as conn: - conn.execute(users.insert(), dict( - user_id=2, goofy='jack', goofy2='jack', goofy4=util.u('jack'), - goofy7=util.u('jack'), goofy8=12, goofy9=12)) - conn.execute(users.insert(), dict( - user_id=3, goofy='lala', goofy2='lala', goofy4=util.u('lala'), - goofy7=util.u('lala'), goofy8=15, goofy9=15)) - conn.execute(users.insert(), dict( - user_id=4, goofy='fred', goofy2='fred', goofy4=util.u('fred'), - goofy7=util.u('fred'), goofy8=9, goofy9=9)) + conn.execute( + users.insert(), + dict( + user_id=2, + goofy="jack", + goofy2="jack", + goofy4=util.u("jack"), + goofy7=util.u("jack"), + goofy8=12, + goofy9=12, + ), + ) + conn.execute( + users.insert(), + dict( + user_id=3, + goofy="lala", + goofy2="lala", + goofy4=util.u("lala"), + goofy7=util.u("lala"), + goofy8=15, + goofy9=15, + ), + ) + conn.execute( + users.insert(), + dict( + user_id=4, + goofy="fred", + goofy2="fred", + goofy4=util.u("fred"), + goofy7=util.u("fred"), + goofy8=9, + goofy9=9, + ), + ) def test_processing(self): users = self.tables.users @@ -432,11 +526,13 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest): result = users.select().order_by(users.c.user_id).execute().fetchall() for assertstr, assertint, assertint2, row in zip( [ - "BIND_INjackBIND_OUT", "BIND_INlalaBIND_OUT", - "BIND_INfredBIND_OUT"], + "BIND_INjackBIND_OUT", + "BIND_INlalaBIND_OUT", + "BIND_INfredBIND_OUT", + ], [1200, 1500, 900], [1800, 2250, 1350], - result + result, ): for col in list(row)[1:5]: eq_(col, assertstr) @@ -449,9 +545,11 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest): users = self.tables.users self._data_fixture() - stmt = select([users.c.user_id, users.c.goofy8]).where( - users.c.goofy8.in_([15, 9]) - ).order_by(users.c.user_id) + stmt = ( + select([users.c.user_id, users.c.goofy8]) + .where(users.c.goofy8.in_([15, 9])) + .order_by(users.c.user_id) + ) result = testing.db.execute(stmt, {"goofy": [15, 9]}) eq_(result.fetchall(), [(3, 1500), (4, 900)]) @@ -459,15 +557,18 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest): users = self.tables.users self._data_fixture() - stmt = select([users.c.user_id, users.c.goofy8]).where( - users.c.goofy8.in_(bindparam("goofy", expanding=True)) - ).order_by(users.c.user_id) + stmt = ( + select([users.c.user_id, users.c.goofy8]) + .where(users.c.goofy8.in_(bindparam("goofy", expanding=True))) + .order_by(users.c.user_id) + ) result = testing.db.execute(stmt, {"goofy": [15, 9]}) eq_(result.fetchall(), [(3, 1500), (4, 900)]) class UserDefinedTest( - _UserDefinedTypeFixture, fixtures.TablesTest, AssertsCompiledSQL): + _UserDefinedTypeFixture, fixtures.TablesTest, AssertsCompiledSQL +): run_create_tables = None run_inserts = None @@ -485,32 +586,25 @@ class UserDefinedTest( self.assert_compile( select([literal("test", MyType)]), "SELECT 'HI->test<-THERE' AS anon_1", - dialect='default', - literal_binds=True + dialect="default", + literal_binds=True, ) def test_kw_colspec(self): class MyType(types.UserDefinedType): def get_col_spec(self, **kw): - return "FOOB %s" % kw['type_expression'].name + return "FOOB %s" % kw["type_expression"].name class MyOtherType(types.UserDefinedType): def get_col_spec(self): return "BAR" - t = Table('t', MetaData(), Column('bar', MyType, nullable=False)) + t = Table("t", MetaData(), Column("bar", MyType, nullable=False)) - self.assert_compile( - ddl.CreateColumn(t.c.bar), - "bar FOOB bar NOT NULL" - ) + self.assert_compile(ddl.CreateColumn(t.c.bar), "bar FOOB bar NOT NULL") - t = Table('t', MetaData(), - Column('bar', MyOtherType, nullable=False)) - self.assert_compile( - ddl.CreateColumn(t.c.bar), - "bar BAR NOT NULL" - ) + t = Table("t", MetaData(), Column("bar", MyOtherType, nullable=False)) + self.assert_compile(ddl.CreateColumn(t.c.bar), "bar BAR NOT NULL") def test_typedecorator_literal_render_fallback_bound(self): # fall back to process_bind_param for literal @@ -524,19 +618,22 @@ class UserDefinedTest( self.assert_compile( select([literal("test", MyType)]), "SELECT 'HI->test<-THERE' AS anon_1", - dialect='default', - literal_binds=True + dialect="default", + literal_binds=True, ) def test_typedecorator_impl(self): for impl_, exp, kw in [ (Float, "FLOAT", {}), - (Float, "FLOAT(2)", {'precision': 2}), - (Float(2), "FLOAT(2)", {'precision': 4}), + (Float, "FLOAT(2)", {"precision": 2}), + (Float(2), "FLOAT(2)", {"precision": 4}), (Numeric(19, 2), "NUMERIC(19, 2)", {}), ]: for dialect_ in ( - dialects.postgresql, dialects.mssql, dialects.mysql): + dialects.postgresql, + dialects.mssql, + dialects.mysql, + ): dialect_ = dialect_.dialect() raw_impl = types.to_instance(impl_, **kw) @@ -552,21 +649,17 @@ class UserDefinedTest( dec_dialect_impl = dec_type.dialect_impl(dialect_) eq_(dec_dialect_impl.__class__, MyType) eq_( - raw_dialect_impl.__class__, - dec_dialect_impl.impl.__class__) - - self.assert_compile( - MyType(**kw), - exp, - dialect=dialect_ + raw_dialect_impl.__class__, dec_dialect_impl.impl.__class__ ) + self.assert_compile(MyType(**kw), exp, dialect=dialect_) + def test_user_defined_typedec_impl(self): class MyType(types.TypeDecorator): impl = Float def load_dialect_impl(self, dialect): - if dialect.name == 'sqlite': + if dialect.name == "sqlite": return String(50) else: return super(MyType, self).load_dialect_impl(dialect) @@ -578,11 +671,11 @@ class UserDefinedTest( self.assert_compile(t, "FLOAT", dialect=pg) eq_( t.dialect_impl(dialect=sl).impl.__class__, - String().dialect_impl(dialect=sl).__class__ + String().dialect_impl(dialect=sl).__class__, ) eq_( t.dialect_impl(dialect=pg).impl.__class__, - Float().dialect_impl(pg).__class__ + Float().dialect_impl(pg).__class__, ) def test_type_decorator_repr(self): @@ -593,60 +686,54 @@ class UserDefinedTest( 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" + return go class MyType(types.TypeDecorator): impl = TypeOne def load_dialect_impl(self, dialect): - if dialect.name == 'sqlite': + if dialect.name == "sqlite": return TypeOne() else: return TypeTwo() def process_bind_param(self, value, dialect): return "MYTYPE " + value + sl = dialects.sqlite.dialect() pg = dialects.postgresql.dialect() t = MyType() - eq_( - t._cached_bind_processor(sl)('foo'), - "MYTYPE foo ONE" - ) - eq_( - t._cached_bind_processor(pg)('foo'), - "MYTYPE foo TWO" - ) + eq_(t._cached_bind_processor(sl)("foo"), "MYTYPE foo ONE") + eq_(t._cached_bind_processor(pg)("foo"), "MYTYPE foo TWO") def test_user_defined_dialect_specific_args(self): class MyType(types.UserDefinedType): - - def __init__(self, foo='foo', **kwargs): + def __init__(self, foo="foo", **kwargs): super(MyType, self).__init__() self.foo = foo self.dialect_specific_args = kwargs def adapt(self, cls): return cls(foo=self.foo, **self.dialect_specific_args) - t = MyType(bar='bar') + + t = MyType(bar="bar") a = t.dialect_impl(testing.db.dialect) - eq_(a.foo, 'foo') - eq_(a.dialect_specific_args['bar'], 'bar') + eq_(a.foo, "foo") + eq_(a.dialect_specific_args["bar"], "bar") class TypeCoerceCastTest(fixtures.TablesTest): - @classmethod def define_tables(cls, metadata): class MyType(types.TypeDecorator): @@ -660,12 +747,12 @@ class TypeCoerceCastTest(fixtures.TablesTest): cls.MyType = MyType - Table('t', metadata, Column('data', String(50))) + Table("t", metadata, Column("data", String(50))) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_insert_round_trip_cast(self): self._test_insert_round_trip(cast) @@ -676,18 +763,19 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() eq_( select([coerce_fn(t.c.data, MyType)]).execute().fetchall(), - [('BIND_INd1BIND_OUT', )] + [("BIND_INd1BIND_OUT",)], ) @testing.fails_on( - "oracle", "ORA-00906: missing left parenthesis - " - "seems to be CAST(:param AS type)") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", + "ORA-00906: missing left parenthesis - " + "seems to be CAST(:param AS type)", + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_coerce_from_nulltype_cast(self): self._test_coerce_from_nulltype(cast) @@ -700,7 +788,6 @@ 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" @@ -710,13 +797,13 @@ class TypeCoerceCastTest(fixtures.TablesTest): eq_( select([coerce_fn(t.c.data, MyType)]).execute().fetchall(), - [('BIND_INTHISISMYOBJBIND_OUT',)] + [("BIND_INTHISISMYOBJBIND_OUT",)], ) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_vs_non_coerced_cast(self): self._test_vs_non_coerced(cast) @@ -727,18 +814,19 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() eq_( - select( - [t.c.data, coerce_fn(t.c.data, MyType)]).execute().fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .execute() + .fetchall(), + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_vs_non_coerced_alias_cast(self): self._test_vs_non_coerced_alias(cast) @@ -749,18 +837,21 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() eq_( - select([t.c.data, coerce_fn(t.c.data, MyType)]). - alias().select().execute().fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .alias() + .select() + .execute() + .fetchall(), + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_vs_non_coerced_where_cast(self): self._test_vs_non_coerced_where(cast) @@ -771,26 +862,30 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() # coerce on left side eq_( - select([t.c.data, coerce_fn(t.c.data, MyType)]). - where(coerce_fn(t.c.data, MyType) == 'd1').execute().fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .where(coerce_fn(t.c.data, MyType) == "d1") + .execute() + .fetchall(), + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) # coerce on right side eq_( - select([t.c.data, coerce_fn(t.c.data, MyType)]). - where(t.c.data == coerce_fn('d1', MyType)).execute().fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .where(t.c.data == coerce_fn("d1", MyType)) + .execute() + .fetchall(), + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_coerce_none_cast(self): self._test_coerce_none(cast) @@ -801,24 +896,27 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() eq_( - select([t.c.data, coerce_fn(t.c.data, MyType)]). - where(t.c.data == coerce_fn(None, MyType)).execute().fetchall(), - [] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .where(t.c.data == coerce_fn(None, MyType)) + .execute() + .fetchall(), + [], ) eq_( - select([t.c.data, coerce_fn(t.c.data, MyType)]). - where(coerce_fn(t.c.data, MyType) == None). # noqa - execute().fetchall(), - [] + select([t.c.data, coerce_fn(t.c.data, MyType)]) + .where(coerce_fn(t.c.data, MyType) == None) + .execute() # noqa + .fetchall(), + [], ) @testing.fails_on( - "oracle", "oracle doesn't like CAST in the VALUES of an INSERT") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", "oracle doesn't like CAST in the VALUES of an INSERT" + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_resolve_clause_element_cast(self): self._test_resolve_clause_element(cast) @@ -829,10 +927,9 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() class MyFoob(object): - def __clause_element__(self): return t.c.data @@ -840,7 +937,7 @@ class TypeCoerceCastTest(fixtures.TablesTest): testing.db.execute( select([t.c.data, coerce_fn(MyFoob(), MyType)]) ).fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) def test_cast_replace_col_w_bind(self): @@ -853,7 +950,7 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() stmt = select([t.c.data, coerce_fn(t.c.data, MyType)]) @@ -871,15 +968,16 @@ class TypeCoerceCastTest(fixtures.TablesTest): # original statement eq_( testing.db.execute(stmt).fetchall(), - [('BIND_INd1', 'BIND_INd1BIND_OUT')] + [("BIND_INd1", "BIND_INd1BIND_OUT")], ) # replaced with binds; CAST can't affect the bound parameter # on the way in here eq_( testing.db.execute(new_stmt).fetchall(), - [('x', 'BIND_INxBIND_OUT')] if coerce_fn is type_coerce - else [('x', 'xBIND_OUT')] + [("x", "BIND_INxBIND_OUT")] + if coerce_fn is type_coerce + else [("x", "xBIND_OUT")], ) def test_cast_bind(self): @@ -892,24 +990,30 @@ class TypeCoerceCastTest(fixtures.TablesTest): MyType = self.MyType t = self.tables.t - t.insert().values(data=coerce_fn('d1', MyType)).execute() + t.insert().values(data=coerce_fn("d1", MyType)).execute() - stmt = select([ - bindparam(None, "x", String(50), unique=True), - coerce_fn(bindparam(None, "x", String(50), unique=True), MyType) - ]) + stmt = select( + [ + bindparam(None, "x", String(50), unique=True), + coerce_fn( + bindparam(None, "x", String(50), unique=True), MyType + ), + ] + ) eq_( testing.db.execute(stmt).fetchall(), - [('x', 'BIND_INxBIND_OUT')] if coerce_fn is type_coerce - else [('x', 'xBIND_OUT')] + [("x", "BIND_INxBIND_OUT")] + if coerce_fn is type_coerce + else [("x", "xBIND_OUT")], ) @testing.fails_on( - "oracle", "ORA-00906: missing left parenthesis - " - "seems to be CAST(:param AS type)") - @testing.fails_on( - "mysql", "mysql dialect warns on skipped CAST") + "oracle", + "ORA-00906: missing left parenthesis - " + "seems to be CAST(:param AS type)", + ) + @testing.fails_on("mysql", "mysql dialect warns on skipped CAST") def test_cast_existing_typed(self): MyType = self.MyType coerce_fn = cast @@ -917,10 +1021,8 @@ class TypeCoerceCastTest(fixtures.TablesTest): # when cast() is given an already typed value, # the type does not take effect on the value itself. eq_( - testing.db.scalar( - select([coerce_fn(literal('d1'), MyType)]) - ), - 'd1BIND_OUT' + testing.db.scalar(select([coerce_fn(literal("d1"), MyType)])), + "d1BIND_OUT", ) def test_type_coerce_existing_typed(self): @@ -931,38 +1033,37 @@ class TypeCoerceCastTest(fixtures.TablesTest): # type_coerce does upgrade the given expression to the # given type. - t.insert().values(data=coerce_fn(literal('d1'), MyType)).execute() + t.insert().values(data=coerce_fn(literal("d1"), MyType)).execute() eq_( select([coerce_fn(t.c.data, MyType)]).execute().fetchall(), - [('BIND_INd1BIND_OUT', )]) + [("BIND_INd1BIND_OUT",)], + ) class VariantTest(fixtures.TestBase, AssertsCompiledSQL): - def setup(self): class UTypeOne(types.UserDefinedType): - def get_col_spec(self): return "UTYPEONE" def bind_processor(self, dialect): def process(value): return value + "UONE" + return process class UTypeTwo(types.UserDefinedType): - def get_col_spec(self): return "UTYPETWO" def bind_processor(self, dialect): def process(value): return value + "UTWO" + return process class UTypeThree(types.UserDefinedType): - def get_col_spec(self): return "UTYPETHREE" @@ -970,142 +1071,127 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL): self.UTypeTwo = UTypeTwo self.UTypeThree = UTypeThree self.variant = self.UTypeOne().with_variant( - self.UTypeTwo(), 'postgresql') - self.composite = self.variant.with_variant(self.UTypeThree(), 'mysql') + self.UTypeTwo(), "postgresql" + ) + self.composite = self.variant.with_variant(self.UTypeThree(), "mysql") def test_illegal_dupe(self): - v = self.UTypeOne().with_variant( - self.UTypeTwo(), 'postgresql' - ) + v = self.UTypeOne().with_variant(self.UTypeTwo(), "postgresql") assert_raises_message( exc.ArgumentError, "Dialect 'postgresql' is already present " "in the mapping for this Variant", - lambda: v.with_variant(self.UTypeThree(), 'postgresql') + lambda: v.with_variant(self.UTypeThree(), "postgresql"), ) def test_compile(self): + self.assert_compile(self.variant, "UTYPEONE", use_default_dialect=True) self.assert_compile( - self.variant, - "UTYPEONE", - use_default_dialect=True + self.variant, "UTYPEONE", dialect=dialects.mysql.dialect() ) self.assert_compile( - self.variant, - "UTYPEONE", - dialect=dialects.mysql.dialect() - ) - self.assert_compile( - self.variant, - "UTYPETWO", - dialect=dialects.postgresql.dialect() + self.variant, "UTYPETWO", dialect=dialects.postgresql.dialect() ) def test_to_instance(self): self.assert_compile( self.UTypeOne().with_variant(self.UTypeTwo, "postgresql"), "UTYPETWO", - dialect=dialects.postgresql.dialect() + dialect=dialects.postgresql.dialect(), ) def test_compile_composite(self): self.assert_compile( - self.composite, - "UTYPEONE", - use_default_dialect=True + self.composite, "UTYPEONE", use_default_dialect=True ) self.assert_compile( - self.composite, - "UTYPETHREE", - dialect=dialects.mysql.dialect() + self.composite, "UTYPETHREE", dialect=dialects.mysql.dialect() ) self.assert_compile( - self.composite, - "UTYPETWO", - dialect=dialects.postgresql.dialect() + self.composite, "UTYPETWO", dialect=dialects.postgresql.dialect() ) def test_bind_process(self): eq_( - self.variant._cached_bind_processor( - dialects.mysql.dialect())('foo'), - 'fooUONE' + self.variant._cached_bind_processor(dialects.mysql.dialect())( + "foo" + ), + "fooUONE", ) eq_( - self.variant._cached_bind_processor( - default.DefaultDialect())('foo'), - 'fooUONE' + self.variant._cached_bind_processor(default.DefaultDialect())( + "foo" + ), + "fooUONE", ) eq_( - self.variant._cached_bind_processor( - dialects.postgresql.dialect())('foo'), - 'fooUTWO' + self.variant._cached_bind_processor(dialects.postgresql.dialect())( + "foo" + ), + "fooUTWO", ) def test_bind_process_composite(self): - assert self.composite._cached_bind_processor( - dialects.mysql.dialect()) is None + assert ( + self.composite._cached_bind_processor(dialects.mysql.dialect()) + is None + ) eq_( - self.composite._cached_bind_processor( - default.DefaultDialect())('foo'), - 'fooUONE' + self.composite._cached_bind_processor(default.DefaultDialect())( + "foo" + ), + "fooUONE", ) eq_( self.composite._cached_bind_processor( - dialects.postgresql.dialect())('foo'), - 'fooUTWO' + dialects.postgresql.dialect() + )("foo"), + "fooUTWO", ) def test_comparator_variant(self): - expr = column('x', self.variant) == "bar" - is_( - expr.right.type, self.variant - ) + expr = column("x", self.variant) == "bar" + is_(expr.right.type, self.variant) @testing.only_on("sqlite") @testing.provide_metadata def test_round_trip(self): - variant = self.UTypeOne().with_variant( - self.UTypeTwo(), 'sqlite') + variant = self.UTypeOne().with_variant(self.UTypeTwo(), "sqlite") - t = Table('t', self.metadata, - Column('x', variant) - ) + t = Table("t", self.metadata, Column("x", variant)) with testing.db.connect() as conn: t.create(conn) - conn.execute( - t.insert(), - x='foo' - ) + conn.execute(t.insert(), x="foo") - eq_( - conn.scalar(select([t.c.x]).where(t.c.x == 'foo')), - 'fooUTWO' - ) + eq_(conn.scalar(select([t.c.x]).where(t.c.x == "foo")), "fooUTWO") @testing.only_on("sqlite") @testing.provide_metadata def test_round_trip_sqlite_datetime(self): variant = DateTime().with_variant( - dialects.sqlite.DATETIME(truncate_microseconds=True), 'sqlite') - - t = Table('t', self.metadata, - Column('x', variant) + dialects.sqlite.DATETIME(truncate_microseconds=True), "sqlite" ) + + t = Table("t", self.metadata, Column("x", variant)) with testing.db.connect() as conn: t.create(conn) conn.execute( - t.insert(), - x=datetime.datetime(2015, 4, 18, 10, 15, 17, 4839) + t.insert(), x=datetime.datetime(2015, 4, 18, 10, 15, 17, 4839) ) eq_( - conn.scalar(select([t.c.x]).where(t.c.x == datetime.datetime(2015, 4, 18, 10, 15, 17, 1059))), - datetime.datetime(2015, 4, 18, 10, 15, 17) + conn.scalar( + select([t.c.x]).where( + t.c.x + == datetime.datetime(2015, 4, 18, 10, 15, 17, 1059) + ) + ), + datetime.datetime(2015, 4, 18, 10, 15, 17), ) + class UnicodeTest(fixtures.TestBase): """Exercise the Unicode and related types. @@ -1114,12 +1200,14 @@ class UnicodeTest(fixtures.TestBase): sqlalchemy/testing/suite/test_types.py. """ + __backend__ = True data = util.u( "Alors vous imaginez ma surprise, au lever du jour, quand " "une drôle de petite voix m’a réveillé. " - "Elle disait: « S’il vous plaît… dessine-moi un mouton! »") + "Elle disait: « S’il vous plaît… dessine-moi un mouton! »" + ) def test_unicode_warnings_typelevel_native_unicode(self): @@ -1129,10 +1217,10 @@ class UnicodeTest(fixtures.TestBase): dialect.supports_unicode_binds = True uni = u.dialect_impl(dialect).bind_processor(dialect) if util.py3k: - assert_raises(exc.SAWarning, uni, b'x') + assert_raises(exc.SAWarning, uni, b"x") assert isinstance(uni(unicodedata), str) else: - assert_raises(exc.SAWarning, uni, 'x') + assert_raises(exc.SAWarning, uni, "x") assert isinstance(uni(unicodedata), unicode) # noqa def test_unicode_warnings_typelevel_sqla_unicode(self): @@ -1141,10 +1229,10 @@ class UnicodeTest(fixtures.TestBase): dialect = default.DefaultDialect() dialect.supports_unicode_binds = False uni = u.dialect_impl(dialect).bind_processor(dialect) - assert_raises(exc.SAWarning, uni, util.b('x')) + assert_raises(exc.SAWarning, uni, util.b("x")) assert isinstance(uni(unicodedata), util.binary_type) - eq_(uni(unicodedata), unicodedata.encode('utf-8')) + eq_(uni(unicodedata), unicodedata.encode("utf-8")) def test_unicode_warnings_totally_wrong_type(self): u = Unicode() @@ -1152,7 +1240,8 @@ class UnicodeTest(fixtures.TestBase): dialect.supports_unicode_binds = False uni = u.dialect_impl(dialect).bind_processor(dialect) with expect_warnings( - "Unicode type received non-unicode bind param value 5."): + "Unicode type received non-unicode bind param value 5." + ): eq_(uni(5), 5) def test_unicode_warnings_dialectlevel(self): @@ -1165,10 +1254,10 @@ class UnicodeTest(fixtures.TestBase): s = String() uni = s.dialect_impl(dialect).bind_processor(dialect) - uni(util.b('x')) + uni(util.b("x")) assert isinstance(uni(unicodedata), util.binary_type) - eq_(uni(unicodedata), unicodedata.encode('utf-8')) + eq_(uni(unicodedata), unicodedata.encode("utf-8")) def test_ignoring_unicode_error(self): """checks String(unicode_error='ignore') is passed to @@ -1176,15 +1265,12 @@ class UnicodeTest(fixtures.TestBase): unicodedata = self.data - type_ = String(248, convert_unicode='force', unicode_error='ignore') - dialect = default.DefaultDialect(encoding='ascii') + type_ = String(248, convert_unicode="force", unicode_error="ignore") + dialect = default.DefaultDialect(encoding="ascii") proc = type_.result_processor(dialect, 10) - utfdata = unicodedata.encode('utf8') - eq_( - proc(utfdata), - unicodedata.encode('ascii', 'ignore').decode() - ) + utfdata = unicodedata.encode("utf8") + eq_(proc(utfdata), unicodedata.encode("ascii", "ignore").decode()) class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): @@ -1206,17 +1292,17 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): class SomeOtherEnum(SomeEnum): __members__ = OrderedDict() - one = SomeEnum('one', 1) - two = SomeEnum('two', 2) - three = SomeEnum('three', 3, 'four') - a_member = SomeEnum('AMember', 'a') - b_member = SomeEnum('BMember', 'b') + one = SomeEnum("one", 1) + two = SomeEnum("two", 2) + three = SomeEnum("three", 3, "four") + a_member = SomeEnum("AMember", "a") + b_member = SomeEnum("BMember", "b") - other_one = SomeOtherEnum('one', 1) - other_two = SomeOtherEnum('two', 2) - other_three = SomeOtherEnum('three', 3) - other_a_member = SomeOtherEnum('AMember', 'a') - other_b_member = SomeOtherEnum('BMember', 'b') + other_one = SomeOtherEnum("one", 1) + other_two = SomeOtherEnum("two", 2) + other_three = SomeOtherEnum("three", 3) + other_a_member = SomeOtherEnum("AMember", "a") + other_b_member = SomeOtherEnum("BMember", "b") @staticmethod def get_enum_string_values(some_enum): @@ -1225,32 +1311,48 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): @classmethod def define_tables(cls, metadata): Table( - 'enum_table', metadata, Column("id", Integer, primary_key=True), - Column('someenum', Enum('one', 'two', 'three', name='myenum')) + "enum_table", + metadata, + Column("id", Integer, primary_key=True), + Column("someenum", Enum("one", "two", "three", name="myenum")), ) Table( - 'non_native_enum_table', metadata, + "non_native_enum_table", + metadata, Column("id", Integer, primary_key=True, autoincrement=False), - Column('someenum', Enum('one', 'two', 'three', native_enum=False)), - Column('someotherenum', - Enum('one', 'two', 'three', - create_constraint=False, native_enum=False, - validate_strings=True)), + Column("someenum", Enum("one", "two", "three", native_enum=False)), + Column( + "someotherenum", + Enum( + "one", + "two", + "three", + create_constraint=False, + native_enum=False, + validate_strings=True, + ), + ), ) Table( - 'stdlib_enum_table', metadata, + "stdlib_enum_table", + metadata, Column("id", Integer, primary_key=True), - Column('someenum', Enum(cls.SomeEnum)) + Column("someenum", Enum(cls.SomeEnum)), ) Table( - 'stdlib_enum_table2', metadata, + "stdlib_enum_table2", + metadata, Column("id", Integer, primary_key=True), - Column('someotherenum', - Enum(cls.SomeOtherEnum, - values_callable=EnumTest.get_enum_string_values)) + Column( + "someotherenum", + Enum( + cls.SomeOtherEnum, + values_callable=EnumTest.get_enum_string_values, + ), + ), ) def test_python_type(self): @@ -1261,12 +1363,12 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): SomeEnum = self.SomeEnum for loads, dumps in picklers(): column_types = [ - Column('Enu', Enum('x', 'y', 'z', name="somename")), - Column('En2', Enum(self.SomeEnum)), + Column("Enu", Enum("x", "y", "z", name="somename")), + Column("En2", Enum(self.SomeEnum)), ] for column_type in column_types: meta = MetaData() - Table('foo', meta, column_type) + Table("foo", meta, column_type) loads(dumps(column_type)) loads(dumps(meta)) @@ -1276,34 +1378,39 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): bind_processor = type_.bind_processor(testing.db.dialect) bind_processor_validates = validate_type.bind_processor( - testing.db.dialect) - eq_(bind_processor('one'), "one") + testing.db.dialect + ) + eq_(bind_processor("one"), "one") eq_(bind_processor(self.one), "one") eq_(bind_processor("foo"), "foo") assert_raises_message( LookupError, '"5" is not among the defined enum values', - bind_processor, 5 + bind_processor, + 5, ) assert_raises_message( LookupError, '"foo" is not among the defined enum values', - bind_processor_validates, "foo" + bind_processor_validates, + "foo", ) result_processor = type_.result_processor(testing.db.dialect, None) - eq_(result_processor('one'), self.one) + eq_(result_processor("one"), self.one) assert_raises_message( LookupError, '"foo" is not among the defined enum values', - result_processor, "foo" + result_processor, + "foo", ) literal_processor = type_.literal_processor(testing.db.dialect) validate_literal_processor = validate_type.literal_processor( - testing.db.dialect) + testing.db.dialect + ) eq_(literal_processor("one"), "'one'") eq_(literal_processor("foo"), "'foo'") @@ -1311,13 +1418,15 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): assert_raises_message( LookupError, '"5" is not among the defined enum values', - literal_processor, 5 + literal_processor, + 5, ) assert_raises_message( LookupError, '"foo" is not among the defined enum values', - validate_literal_processor, "foo" + validate_literal_processor, + "foo", ) def test_validators_plain(self): @@ -1326,105 +1435,112 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): bind_processor = type_.bind_processor(testing.db.dialect) bind_processor_validates = validate_type.bind_processor( - testing.db.dialect) - eq_(bind_processor('one'), "one") - eq_(bind_processor('foo'), "foo") + testing.db.dialect + ) + eq_(bind_processor("one"), "one") + eq_(bind_processor("foo"), "foo") assert_raises_message( LookupError, '"5" is not among the defined enum values', - bind_processor, 5 + bind_processor, + 5, ) assert_raises_message( LookupError, '"foo" is not among the defined enum values', - bind_processor_validates, "foo" + bind_processor_validates, + "foo", ) result_processor = type_.result_processor(testing.db.dialect, None) - eq_(result_processor('one'), "one") + eq_(result_processor("one"), "one") assert_raises_message( LookupError, '"foo" is not among the defined enum values', - result_processor, "foo" + result_processor, + "foo", ) literal_processor = type_.literal_processor(testing.db.dialect) validate_literal_processor = validate_type.literal_processor( - testing.db.dialect) + testing.db.dialect + ) eq_(literal_processor("one"), "'one'") eq_(literal_processor("foo"), "'foo'") assert_raises_message( LookupError, '"5" is not among the defined enum values', - literal_processor, 5 + literal_processor, + 5, ) assert_raises_message( LookupError, '"foo" is not among the defined enum values', - validate_literal_processor, "foo" + validate_literal_processor, + "foo", ) def test_validators_not_in_like_roundtrip(self): - enum_table = self.tables['non_native_enum_table'] - - enum_table.insert().execute([ - {'id': 1, 'someenum': 'two'}, - {'id': 2, 'someenum': 'two'}, - {'id': 3, 'someenum': 'one'}, - ]) + enum_table = self.tables["non_native_enum_table"] - eq_( - enum_table.select(). - where(enum_table.c.someenum.like('%wo%')). - order_by(enum_table.c.id).execute().fetchall(), + enum_table.insert().execute( [ - (1, 'two', None), - (2, 'two', None), + {"id": 1, "someenum": "two"}, + {"id": 2, "someenum": "two"}, + {"id": 3, "someenum": "one"}, ] ) - def test_validators_not_in_concatenate_roundtrip(self): - enum_table = self.tables['non_native_enum_table'] + eq_( + enum_table.select() + .where(enum_table.c.someenum.like("%wo%")) + .order_by(enum_table.c.id) + .execute() + .fetchall(), + [(1, "two", None), (2, "two", None)], + ) - enum_table.insert().execute([ - {'id': 1, 'someenum': 'two'}, - {'id': 2, 'someenum': 'two'}, - {'id': 3, 'someenum': 'one'}, - ]) + def test_validators_not_in_concatenate_roundtrip(self): + enum_table = self.tables["non_native_enum_table"] - eq_( - select(['foo' + enum_table.c.someenum]). - order_by(enum_table.c.id).execute().fetchall(), + enum_table.insert().execute( [ - ('footwo', ), - ('footwo', ), - ('fooone', ) + {"id": 1, "someenum": "two"}, + {"id": 2, "someenum": "two"}, + {"id": 3, "someenum": "one"}, ] ) + eq_( + select(["foo" + enum_table.c.someenum]) + .order_by(enum_table.c.id) + .execute() + .fetchall(), + [("footwo",), ("footwo",), ("fooone",)], + ) + @testing.fails_on( - 'postgresql+zxjdbc', + "postgresql+zxjdbc", 'zxjdbc fails on ENUM: column "XXX" is of type XXX ' - 'but expression is of type character varying') + "but expression is of type character varying", + ) def test_round_trip(self): - enum_table = self.tables['enum_table'] + enum_table = self.tables["enum_table"] - enum_table.insert().execute([ - {'id': 1, 'someenum': 'two'}, - {'id': 2, 'someenum': 'two'}, - {'id': 3, 'someenum': 'one'}, - ]) + enum_table.insert().execute( + [ + {"id": 1, "someenum": "two"}, + {"id": 2, "someenum": "two"}, + {"id": 3, "someenum": "one"}, + ] + ) eq_( enum_table.select().order_by(enum_table.c.id).execute().fetchall(), - [ - (1, 'two'), - (2, 'two'), - (3, 'one'), - ] + [(1, "two"), (2, "two"), (3, "one")], ) def test_null_round_trip(self): @@ -1437,50 +1553,57 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): with testing.db.connect() as conn: conn.execute( - non_native_enum_table.insert(), {"id": 1, "someenum": None}) + non_native_enum_table.insert(), {"id": 1, "someenum": None} + ) eq_(conn.scalar(select([non_native_enum_table.c.someenum])), None) @testing.requires.enforces_check_constraints def test_check_constraint(self): assert_raises( ( - exc.IntegrityError, exc.ProgrammingError, + exc.IntegrityError, + exc.ProgrammingError, exc.OperationalError, # PyMySQL raising InternalError until # https://github.com/PyMySQL/PyMySQL/issues/607 is resolved - exc.InternalError), + exc.InternalError, + ), testing.db.execute, "insert into non_native_enum_table " - "(id, someenum) values(1, 'four')") + "(id, someenum) values(1, 'four')", + ) @testing.requires.enforces_check_constraints @testing.provide_metadata def test_variant_we_are_default(self): # test that the "variant" does not create a constraint t = Table( - 'my_table', self.metadata, + "my_table", + self.metadata, Column( - 'data', Enum("one", "two", "three", - native_enum=False, name="e1").with_variant( - Enum("four", "five", "six", native_enum=False, - name="e2"), "some_other_db" - ) + "data", + Enum( + "one", "two", "three", native_enum=False, name="e1" + ).with_variant( + Enum("four", "five", "six", native_enum=False, name="e2"), + "some_other_db", + ), ), - mysql_engine='InnoDB' + mysql_engine="InnoDB", ) eq_( len([c for c in t.constraints if isinstance(c, CheckConstraint)]), - 2 + 2, ) with testing.db.connect() as conn: self.metadata.create_all(conn) assert_raises( - (exc.DBAPIError, ), + (exc.DBAPIError,), conn.execute, - "insert into my_table " - "(data) values('four')") + "insert into my_table " "(data) values('four')", + ) conn.execute("insert into my_table (data) values ('two')") @testing.requires.enforces_check_constraints @@ -1488,29 +1611,32 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): def test_variant_we_are_not_default(self): # test that the "variant" does not create a constraint t = Table( - 'my_table', self.metadata, + "my_table", + self.metadata, Column( - 'data', Enum("one", "two", "three", native_enum=False, - name="e1").with_variant( + "data", + Enum( + "one", "two", "three", native_enum=False, name="e1" + ).with_variant( Enum("four", "five", "six", native_enum=False, name="e2"), - testing.db.dialect.name - ) - ) + testing.db.dialect.name, + ), + ), ) # ensure Variant isn't exploding the constraints eq_( len([c for c in t.constraints if isinstance(c, CheckConstraint)]), - 2 + 2, ) with testing.db.connect() as conn: self.metadata.create_all(conn) assert_raises( - (exc.DBAPIError, ), + (exc.DBAPIError,), conn.execute, - "insert into my_table " - "(data) values('two')") + "insert into my_table " "(data) values('two')", + ) conn.execute("insert into my_table (data) values ('four')") def test_skip_check_constraint(self): @@ -1521,51 +1647,56 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): ) eq_( conn.scalar("select someotherenum from non_native_enum_table"), - "four") + "four", + ) assert_raises_message( LookupError, '"four" is not among the defined enum values', conn.scalar, - select([self.tables.non_native_enum_table.c.someotherenum]) + select([self.tables.non_native_enum_table.c.someotherenum]), ) def test_non_native_round_trip(self): - non_native_enum_table = self.tables['non_native_enum_table'] + non_native_enum_table = self.tables["non_native_enum_table"] - non_native_enum_table.insert().execute([ - {'id': 1, 'someenum': 'two'}, - {'id': 2, 'someenum': 'two'}, - {'id': 3, 'someenum': 'one'}, - ]) - - eq_( - select([ - non_native_enum_table.c.id, - non_native_enum_table.c.someenum]). - order_by(non_native_enum_table.c.id).execute().fetchall(), + non_native_enum_table.insert().execute( [ - (1, 'two'), - (2, 'two'), - (3, 'one'), + {"id": 1, "someenum": "two"}, + {"id": 2, "someenum": "two"}, + {"id": 3, "someenum": "one"}, ] ) + eq_( + select( + [non_native_enum_table.c.id, non_native_enum_table.c.someenum] + ) + .order_by(non_native_enum_table.c.id) + .execute() + .fetchall(), + [(1, "two"), (2, "two"), (3, "one")], + ) + def test_pep435_enum_round_trip(self): - stdlib_enum_table = self.tables['stdlib_enum_table'] - - stdlib_enum_table.insert().execute([ - {'id': 1, 'someenum': self.SomeEnum.two}, - {'id': 2, 'someenum': self.SomeEnum.two}, - {'id': 3, 'someenum': self.SomeEnum.one}, - {'id': 4, 'someenum': self.SomeEnum.three}, - {'id': 5, 'someenum': self.SomeEnum.four}, - {'id': 6, 'someenum': 'three'}, - {'id': 7, 'someenum': 'four'}, - ]) + stdlib_enum_table = self.tables["stdlib_enum_table"] + + stdlib_enum_table.insert().execute( + [ + {"id": 1, "someenum": self.SomeEnum.two}, + {"id": 2, "someenum": self.SomeEnum.two}, + {"id": 3, "someenum": self.SomeEnum.one}, + {"id": 4, "someenum": self.SomeEnum.three}, + {"id": 5, "someenum": self.SomeEnum.four}, + {"id": 6, "someenum": "three"}, + {"id": 7, "someenum": "four"}, + ] + ) eq_( - stdlib_enum_table.select(). - order_by(stdlib_enum_table.c.id).execute().fetchall(), + stdlib_enum_table.select() + .order_by(stdlib_enum_table.c.id) + .execute() + .fetchall(), [ (1, self.SomeEnum.two), (2, self.SomeEnum.two), @@ -1574,108 +1705,118 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): (5, self.SomeEnum.three), (6, self.SomeEnum.three), (7, self.SomeEnum.three), - ] + ], ) def test_pep435_enum_values_callable_round_trip(self): - stdlib_enum_table_custom_values =\ - self.tables['stdlib_enum_table2'] + stdlib_enum_table_custom_values = self.tables["stdlib_enum_table2"] - stdlib_enum_table_custom_values.insert().execute([ - {'id': 1, 'someotherenum': self.SomeOtherEnum.AMember}, - {'id': 2, 'someotherenum': self.SomeOtherEnum.BMember}, - {'id': 3, 'someotherenum': self.SomeOtherEnum.AMember} - ]) + stdlib_enum_table_custom_values.insert().execute( + [ + {"id": 1, "someotherenum": self.SomeOtherEnum.AMember}, + {"id": 2, "someotherenum": self.SomeOtherEnum.BMember}, + {"id": 3, "someotherenum": self.SomeOtherEnum.AMember}, + ] + ) eq_( - stdlib_enum_table_custom_values.select(). - order_by(stdlib_enum_table_custom_values.c.id).execute(). - fetchall(), + stdlib_enum_table_custom_values.select() + .order_by(stdlib_enum_table_custom_values.c.id) + .execute() + .fetchall(), [ (1, self.SomeOtherEnum.AMember), (2, self.SomeOtherEnum.BMember), - (3, self.SomeOtherEnum.AMember) - ] + (3, self.SomeOtherEnum.AMember), + ], ) def test_pep435_enum_expanding_in(self): - stdlib_enum_table_custom_values =\ - self.tables['stdlib_enum_table2'] - - stdlib_enum_table_custom_values.insert().execute([ - {'id': 1, 'someotherenum': self.SomeOtherEnum.one}, - {'id': 2, 'someotherenum': self.SomeOtherEnum.two}, - {'id': 3, 'someotherenum': self.SomeOtherEnum.three} - ]) - - stmt = stdlib_enum_table_custom_values.select().where( - stdlib_enum_table_custom_values.c.someotherenum.in_( - bindparam("member", expanding=True) + stdlib_enum_table_custom_values = self.tables["stdlib_enum_table2"] + + stdlib_enum_table_custom_values.insert().execute( + [ + {"id": 1, "someotherenum": self.SomeOtherEnum.one}, + {"id": 2, "someotherenum": self.SomeOtherEnum.two}, + {"id": 3, "someotherenum": self.SomeOtherEnum.three}, + ] + ) + + stmt = ( + stdlib_enum_table_custom_values.select() + .where( + stdlib_enum_table_custom_values.c.someotherenum.in_( + bindparam("member", expanding=True) + ) ) - ).order_by(stdlib_enum_table_custom_values.c.id) + .order_by(stdlib_enum_table_custom_values.c.id) + ) eq_( testing.db.execute( stmt, - {"member": [ - self.SomeOtherEnum.one, - self.SomeOtherEnum.three]} + {"member": [self.SomeOtherEnum.one, self.SomeOtherEnum.three]}, ).fetchall(), - [ - (1, self.SomeOtherEnum.one), - (3, self.SomeOtherEnum.three) - ] + [(1, self.SomeOtherEnum.one), (3, self.SomeOtherEnum.three)], ) def test_adapt(self): from sqlalchemy.dialects.postgresql import ENUM - e1 = Enum('one', 'two', 'three', native_enum=False) + + e1 = Enum("one", "two", "three", native_enum=False) false_adapt = e1.adapt(ENUM) eq_(false_adapt.native_enum, False) assert not isinstance(false_adapt, ENUM) - e1 = Enum('one', 'two', 'three', native_enum=True) + e1 = Enum("one", "two", "three", native_enum=True) true_adapt = e1.adapt(ENUM) eq_(true_adapt.native_enum, True) assert isinstance(true_adapt, ENUM) - e1 = Enum('one', 'two', 'three', name='foo', - schema='bar', metadata=MetaData()) - eq_(e1.adapt(ENUM).name, 'foo') - eq_(e1.adapt(ENUM).schema, 'bar') + e1 = Enum( + "one", + "two", + "three", + name="foo", + schema="bar", + metadata=MetaData(), + ) + eq_(e1.adapt(ENUM).name, "foo") + eq_(e1.adapt(ENUM).schema, "bar") is_(e1.adapt(ENUM).metadata, e1.metadata) - eq_(e1.adapt(Enum).name, 'foo') - eq_(e1.adapt(Enum).schema, 'bar') + eq_(e1.adapt(Enum).name, "foo") + eq_(e1.adapt(Enum).schema, "bar") is_(e1.adapt(Enum).metadata, e1.metadata) e1 = Enum(self.SomeEnum) - eq_(e1.adapt(ENUM).name, 'someenum') - eq_(e1.adapt(ENUM).enums, - ['one', 'two', 'three', 'four', 'AMember', 'BMember']) + eq_(e1.adapt(ENUM).name, "someenum") + eq_( + e1.adapt(ENUM).enums, + ["one", "two", "three", "four", "AMember", "BMember"], + ) - e1_vc = Enum(self.SomeOtherEnum, - values_callable=EnumTest.get_enum_string_values) - eq_(e1_vc.adapt(ENUM).name, 'someotherenum') - eq_(e1_vc.adapt(ENUM).enums, ['1', '2', '3', 'a', 'b']) + e1_vc = Enum( + self.SomeOtherEnum, values_callable=EnumTest.get_enum_string_values + ) + eq_(e1_vc.adapt(ENUM).name, "someotherenum") + eq_(e1_vc.adapt(ENUM).enums, ["1", "2", "3", "a", "b"]) @testing.provide_metadata def test_create_metadata_bound_no_crash(self): m1 = self.metadata - Enum('a', 'b', 'c', metadata=m1, name='ncenum') + Enum("a", "b", "c", metadata=m1, name="ncenum") m1.create_all(testing.db) def test_non_native_constraint_custom_type(self): class Foob(object): - def __init__(self, name): self.name = name class MyEnum(TypeDecorator): - def __init__(self, values): self.impl = Enum( - *[v.name for v in values], name="myenum", - native_enum=False) + *[v.name for v in values], name="myenum", native_enum=False + ) # future method def process_literal_param(self, value, dialect): @@ -1685,21 +1826,22 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): return value.name m = MetaData() - t1 = Table('t', m, Column('x', MyEnum([Foob('a'), Foob('b')]))) - const = [ - c for c in t1.constraints if isinstance(c, CheckConstraint)][0] + t1 = Table("t", m, Column("x", MyEnum([Foob("a"), Foob("b")]))) + const = [c for c in t1.constraints if isinstance(c, CheckConstraint)][ + 0 + ] self.assert_compile( AddConstraint(const), "ALTER TABLE t ADD CONSTRAINT myenum CHECK (x IN ('a', 'b'))", - dialect="default" + dialect="default", ) def test_lookup_failure(self): assert_raises( exc.StatementError, - self.tables['non_native_enum_table'].insert().execute, - {'id': 4, 'someotherenum': 'four'} + self.tables["non_native_enum_table"].insert().execute, + {"id": 4, "someotherenum": "four"}, ) def test_mock_engine_no_prob(self): @@ -1707,7 +1849,7 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): are created with checkfirst=False""" e = engines.mock_engine() - t = Table('t1', MetaData(), Column('x', Enum("x", "y", name="pge"))) + t = Table("t1", MetaData(), Column("x", Enum("x", "y", name="pge"))) t.create(e, checkfirst=False) # basically looking for the start of # the constraint, or the ENUM def itself, @@ -1716,12 +1858,19 @@ class EnumTest(AssertsCompiledSQL, fixtures.TablesTest): def test_repr(self): e = Enum( - "x", "y", name="somename", convert_unicode=True, quote=True, - inherit_schema=True, native_enum=False) + "x", + "y", + name="somename", + convert_unicode=True, + quote=True, + inherit_schema=True, + native_enum=False, + ) eq_( repr(e), "Enum('x', 'y', name='somename', " - "inherit_schema=True, native_enum=False)") + "inherit_schema=True, native_enum=False)", + ) binary_table = MyPickleType = metadata = None @@ -1739,25 +1888,29 @@ class BinaryTest(fixtures.TestBase, AssertsExecutionResults): def process_bind_param(self, value, dialect): if value: - value.stuff = 'this is modified stuff' + value.stuff = "this is modified stuff" return value def process_result_value(self, value, dialect): if value: - value.stuff = 'this is the right stuff' + value.stuff = "this is the right stuff" return value metadata = MetaData(testing.db) binary_table = Table( - 'binary_table', metadata, + "binary_table", + metadata, Column( - 'primary_id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('data', LargeBinary), - Column('data_slice', LargeBinary(100)), - Column('misc', String(30)), - Column('pickled', PickleType), - Column('mypickle', MyPickleType) + "primary_id", + Integer, + primary_key=True, + test_needs_autoincrement=True, + ), + Column("data", LargeBinary), + Column("data_slice", LargeBinary(100)), + Column("misc", String(30)), + Column("pickled", PickleType), + Column("mypickle", MyPickleType), ) metadata.create_all() @@ -1771,57 +1924,79 @@ class BinaryTest(fixtures.TestBase, AssertsExecutionResults): @testing.requires.non_broken_binary def test_round_trip(self): - testobj1 = pickleable.Foo('im foo 1') - testobj2 = pickleable.Foo('im foo 2') - testobj3 = pickleable.Foo('im foo 3') + testobj1 = pickleable.Foo("im foo 1") + testobj2 = pickleable.Foo("im foo 2") + testobj3 = pickleable.Foo("im foo 3") - stream1 = self.load_stream('binary_data_one.dat') - stream2 = self.load_stream('binary_data_two.dat') + stream1 = self.load_stream("binary_data_one.dat") + stream2 = self.load_stream("binary_data_two.dat") binary_table.insert().execute( - primary_id=1, misc='binary_data_one.dat', data=stream1, - data_slice=stream1[0:100], pickled=testobj1, mypickle=testobj3) + primary_id=1, + misc="binary_data_one.dat", + data=stream1, + data_slice=stream1[0:100], + pickled=testobj1, + mypickle=testobj3, + ) binary_table.insert().execute( - primary_id=2, misc='binary_data_two.dat', data=stream2, - data_slice=stream2[0:99], pickled=testobj2) + primary_id=2, + misc="binary_data_two.dat", + data=stream2, + data_slice=stream2[0:99], + pickled=testobj2, + ) binary_table.insert().execute( - primary_id=3, misc='binary_data_two.dat', data=None, - data_slice=stream2[0:99], pickled=None) + primary_id=3, + misc="binary_data_two.dat", + data=None, + data_slice=stream2[0:99], + pickled=None, + ) for stmt in ( binary_table.select(order_by=binary_table.c.primary_id), text( "select * from binary_table order by binary_table.primary_id", typemap={ - 'pickled': PickleType, 'mypickle': MyPickleType, - 'data': LargeBinary, 'data_slice': LargeBinary}, - bind=testing.db) + "pickled": PickleType, + "mypickle": MyPickleType, + "data": LargeBinary, + "data_slice": LargeBinary, + }, + bind=testing.db, + ), ): result = stmt.execute().fetchall() - eq_(stream1, result[0]['data']) - eq_(stream1[0:100], result[0]['data_slice']) - eq_(stream2, result[1]['data']) - eq_(testobj1, result[0]['pickled']) - eq_(testobj2, result[1]['pickled']) - eq_(testobj3.moredata, result[0]['mypickle'].moredata) - eq_(result[0]['mypickle'].stuff, 'this is the right stuff') + eq_(stream1, result[0]["data"]) + eq_(stream1[0:100], result[0]["data_slice"]) + eq_(stream2, result[1]["data"]) + eq_(testobj1, result[0]["pickled"]) + eq_(testobj2, result[1]["pickled"]) + eq_(testobj3.moredata, result[0]["mypickle"].moredata) + eq_(result[0]["mypickle"].stuff, "this is the right stuff") @testing.requires.binary_comparisons def test_comparison(self): """test that type coercion occurs on comparison for binary""" - expr = binary_table.c.data == 'foo' + expr = binary_table.c.data == "foo" assert isinstance(expr.right.type, LargeBinary) data = os.urandom(32) binary_table.insert().execute(data=data) eq_( - select([func.count('*')]).select_from(binary_table). - where(binary_table.c.data == data).scalar(), 1) + select([func.count("*")]) + .select_from(binary_table) + .where(binary_table.c.data == data) + .scalar(), + 1, + ) @testing.requires.binary_literals def test_literal_roundtrip(self): compiled = select([cast(literal(util.b("foo")), LargeBinary)]).compile( - dialect=testing.db.dialect, compile_kwargs={"literal_binds": True}) + dialect=testing.db.dialect, compile_kwargs={"literal_binds": True} + ) result = testing.db.execute(compiled) eq_(result.scalar(), util.b("foo")) @@ -1831,18 +2006,19 @@ class BinaryTest(fixtures.TestBase, AssertsExecutionResults): def load_stream(self, name): f = os.path.join(os.path.dirname(__file__), "..", name) - with open(f, mode='rb') as o: + with open(f, mode="rb") as o: return o.read() class JSONTest(fixtures.TestBase): - def setup(self): metadata = MetaData() - self.test_table = Table('test_table', metadata, - Column('id', Integer, primary_key=True), - Column('test_column', JSON), - ) + self.test_table = Table( + "test_table", + metadata, + Column("id", Integer, primary_key=True), + Column("test_column", JSON), + ) self.jsoncol = self.test_table.c.test_column self.dialect = default.DefaultDialect() @@ -1851,63 +2027,50 @@ class JSONTest(fixtures.TestBase): def test_bind_serialize_default(self): proc = self.test_table.c.test_column.type._cached_bind_processor( - self.dialect) + self.dialect + ) eq_( proc({"A": [1, 2, 3, True, False]}), - '{"A": [1, 2, 3, true, false]}' + '{"A": [1, 2, 3, true, false]}', ) def test_bind_serialize_None(self): proc = self.test_table.c.test_column.type._cached_bind_processor( - self.dialect) - eq_( - proc(None), - 'null' + self.dialect ) + eq_(proc(None), "null") def test_bind_serialize_none_as_null(self): - proc = JSON(none_as_null=True)._cached_bind_processor( - self.dialect) - eq_( - proc(None), - None - ) - eq_( - proc(null()), - None - ) + proc = JSON(none_as_null=True)._cached_bind_processor(self.dialect) + eq_(proc(None), None) + eq_(proc(null()), None) def test_bind_serialize_null(self): proc = self.test_table.c.test_column.type._cached_bind_processor( - self.dialect) - eq_( - proc(null()), - None + self.dialect ) + eq_(proc(null()), None) def test_result_deserialize_default(self): proc = self.test_table.c.test_column.type._cached_result_processor( - self.dialect, None) + self.dialect, None + ) eq_( proc('{"A": [1, 2, 3, true, false]}'), - {"A": [1, 2, 3, True, False]} + {"A": [1, 2, 3, True, False]}, ) def test_result_deserialize_null(self): proc = self.test_table.c.test_column.type._cached_result_processor( - self.dialect, None) - eq_( - proc('null'), - None + self.dialect, None ) + eq_(proc("null"), None) def test_result_deserialize_None(self): proc = self.test_table.c.test_column.type._cached_result_processor( - self.dialect, None) - eq_( - proc(None), - None + self.dialect, None ) + eq_(proc(None), None) def _dialect_index_fixture(self, int_processor, str_processor): class MyInt(Integer): @@ -1958,19 +2121,19 @@ class JSONTest(fixtures.TestBase): eq_(bindproc(expr.right.value), "5") def test_index_bind_proc_str(self): - expr = self.test_table.c.test_column['five'] + expr = self.test_table.c.test_column["five"] str_dialect = self._dialect_index_fixture(True, True) non_str_dialect = self._dialect_index_fixture(False, False) bindproc = expr.right.type._cached_bind_processor(str_dialect) - eq_(bindproc(expr.right.value), 'five10') + eq_(bindproc(expr.right.value), "five10") bindproc = expr.right.type._cached_bind_processor(non_str_dialect) - eq_(bindproc(expr.right.value), 'five') + eq_(bindproc(expr.right.value), "five") def test_index_literal_proc_str(self): - expr = self.test_table.c.test_column['five'] + expr = self.test_table.c.test_column["five"] str_dialect = self._dialect_index_fixture(True, True) non_str_dialect = self._dialect_index_fixture(False, False) @@ -1983,36 +2146,27 @@ class JSONTest(fixtures.TestBase): class ArrayTest(fixtures.TestBase): - def _myarray_fixture(self): class MyArray(ARRAY): pass + return MyArray def test_array_index_map_dimensions(self): - col = column('x', ARRAY(Integer, dimensions=3)) - is_( - col[5].type._type_affinity, ARRAY - ) - eq_( - col[5].type.dimensions, 2 - ) - is_( - col[5][6].type._type_affinity, ARRAY - ) - eq_( - col[5][6].type.dimensions, 1 - ) - is_( - col[5][6][7].type._type_affinity, Integer - ) + col = column("x", ARRAY(Integer, dimensions=3)) + is_(col[5].type._type_affinity, ARRAY) + eq_(col[5].type.dimensions, 2) + is_(col[5][6].type._type_affinity, ARRAY) + eq_(col[5][6].type.dimensions, 1) + is_(col[5][6][7].type._type_affinity, Integer) def test_array_getitem_single_type(self): m = MetaData() arrtable = Table( - 'arrtable', m, - Column('intarr', ARRAY(Integer)), - Column('strarr', ARRAY(String)), + "arrtable", + m, + Column("intarr", ARRAY(Integer)), + Column("strarr", ARRAY(String)), ) is_(arrtable.c.intarr[1].type._type_affinity, Integer) is_(arrtable.c.strarr[1].type._type_affinity, String) @@ -2020,9 +2174,10 @@ class ArrayTest(fixtures.TestBase): def test_array_getitem_slice_type(self): m = MetaData() arrtable = Table( - 'arrtable', m, - Column('intarr', ARRAY(Integer)), - Column('strarr', ARRAY(String)), + "arrtable", + m, + Column("intarr", ARRAY(Integer)), + Column("strarr", ARRAY(String)), ) is_(arrtable.c.intarr[1:3].type._type_affinity, ARRAY) is_(arrtable.c.strarr[1:3].type._type_affinity, ARRAY) @@ -2031,9 +2186,10 @@ class ArrayTest(fixtures.TestBase): MyArray = self._myarray_fixture() m = MetaData() arrtable = Table( - 'arrtable', m, - Column('intarr', MyArray(Integer)), - Column('strarr', MyArray(String)), + "arrtable", + m, + Column("intarr", MyArray(Integer)), + Column("strarr", MyArray(String)), ) is_(arrtable.c.intarr[1:3].type._type_affinity, ARRAY) is_(arrtable.c.strarr[1:3].type._type_affinity, ARRAY) @@ -2047,34 +2203,36 @@ test_table = meta = MyCustomType = MyTypeDec = None class ExpressionTest( - fixtures.TestBase, AssertsExecutionResults, AssertsCompiledSQL): - __dialect__ = 'default' + fixtures.TestBase, AssertsExecutionResults, AssertsCompiledSQL +): + __dialect__ = "default" @classmethod def setup_class(cls): global test_table, meta, MyCustomType, MyTypeDec class MyCustomType(types.UserDefinedType): - def get_col_spec(self): return "INT" def bind_processor(self, dialect): def process(value): return value * 10 + return process def result_processor(self, dialect, coltype): def process(value): return value / 10 + return process class MyOldCustomType(MyCustomType): - def adapt_operator(self, op): return { operators.add: operators.sub, - operators.sub: operators.add}.get(op, op) + operators.sub: operators.add, + }.get(op, op) class MyTypeDec(types.TypeDecorator): impl = String @@ -2087,20 +2245,26 @@ class ExpressionTest( meta = MetaData(testing.db) test_table = Table( - 'test', meta, - Column('id', Integer, primary_key=True), - Column('data', String(30)), - Column('atimestamp', Date), - Column('avalue', MyCustomType), - Column('bvalue', MyTypeDec(50)), + "test", + meta, + Column("id", Integer, primary_key=True), + Column("data", String(30)), + Column("atimestamp", Date), + Column("avalue", MyCustomType), + Column("bvalue", MyTypeDec(50)), ) meta.create_all() - test_table.insert().execute({ - 'id': 1, 'data': 'somedata', - 'atimestamp': datetime.date(2007, 10, 15), 'avalue': 25, - 'bvalue': 'foo'}) + test_table.insert().execute( + { + "id": 1, + "data": "somedata", + "atimestamp": datetime.date(2007, 10, 15), + "avalue": 25, + "bvalue": "foo", + } + ) @classmethod def teardown_class(cls): @@ -2111,8 +2275,15 @@ class ExpressionTest( eq_( test_table.select().execute().fetchall(), - [(1, 'somedata', datetime.date(2007, 10, 15), 25, - 'BIND_INfooBIND_OUT')] + [ + ( + 1, + "somedata", + datetime.date(2007, 10, 15), + 25, + "BIND_INfooBIND_OUT", + ) + ], ) def test_bind_adapt(self): @@ -2122,11 +2293,16 @@ class ExpressionTest( eq_( testing.db.execute( - select([ - test_table.c.id, test_table.c.data, - test_table.c.atimestamp]).where(expr), - {"thedate": datetime.date(2007, 10, 15)}).fetchall(), [ - (1, 'somedata', datetime.date(2007, 10, 15))] + select( + [ + test_table.c.id, + test_table.c.data, + test_table.c.atimestamp, + ] + ).where(expr), + {"thedate": datetime.date(2007, 10, 15)}, + ).fetchall(), + [(1, "somedata", datetime.date(2007, 10, 15))], ) expr = test_table.c.avalue == bindparam("somevalue") @@ -2134,10 +2310,17 @@ class ExpressionTest( eq_( testing.db.execute( - test_table.select().where(expr), {'somevalue': 25} - ).fetchall(), [( - 1, 'somedata', datetime.date(2007, 10, 15), 25, - 'BIND_INfooBIND_OUT')] + test_table.select().where(expr), {"somevalue": 25} + ).fetchall(), + [ + ( + 1, + "somedata", + datetime.date(2007, 10, 15), + 25, + "BIND_INfooBIND_OUT", + ) + ], ) expr = test_table.c.bvalue == bindparam("somevalue") @@ -2146,9 +2329,16 @@ class ExpressionTest( eq_( testing.db.execute( test_table.select().where(expr), {"somevalue": "foo"} - ).fetchall(), [( - 1, 'somedata', datetime.date(2007, 10, 15), 25, - 'BIND_INfooBIND_OUT')] + ).fetchall(), + [ + ( + 1, + "somedata", + datetime.date(2007, 10, 15), + 25, + "BIND_INfooBIND_OUT", + ) + ], ) def test_bind_adapt_update(self): @@ -2156,14 +2346,14 @@ class ExpressionTest( stmt = test_table.update().values(avalue=bp) compiled = stmt.compile() eq_(bp.type._type_affinity, types.NullType) - eq_(compiled.binds['somevalue'].type._type_affinity, MyCustomType) + eq_(compiled.binds["somevalue"].type._type_affinity, MyCustomType) def test_bind_adapt_insert(self): bp = bindparam("somevalue") stmt = test_table.insert().values(avalue=bp) compiled = stmt.compile() eq_(bp.type._type_affinity, types.NullType) - eq_(compiled.binds['somevalue'].type._type_affinity, MyCustomType) + eq_(compiled.binds["somevalue"].type._type_affinity, MyCustomType) def test_bind_adapt_expression(self): bp = bindparam("somevalue") @@ -2175,16 +2365,16 @@ class ExpressionTest( # literals get typed based on the types dictionary, unless # compatible with the left side type - expr = column('foo', String) == 5 + expr = column("foo", String) == 5 eq_(expr.right.type._type_affinity, Integer) - expr = column('foo', String) == "asdf" + expr = column("foo", String) == "asdf" eq_(expr.right.type._type_affinity, String) - expr = column('foo', CHAR) == 5 + expr = column("foo", CHAR) == 5 eq_(expr.right.type._type_affinity, Integer) - expr = column('foo', CHAR) == "asdf" + expr = column("foo", CHAR) == "asdf" eq_(expr.right.type.__class__, CHAR) def test_actual_literal_adapters(self): @@ -2197,12 +2387,9 @@ class ExpressionTest( (datetime.time(10, 15, 20), Time), (datetime.datetime(2015, 7, 20, 10, 15, 20), DateTime), (datetime.timedelta(seconds=5), Interval), - (None, types.NullType) + (None, types.NullType), ]: - is_( - literal(data).type.__class__, - expected - ) + is_(literal(data).type.__class__, expected) def test_typedec_operator_adapt(self): expr = test_table.c.bvalue + "hi" @@ -2211,8 +2398,8 @@ class ExpressionTest( assert expr.right.type.__class__ is MyTypeDec eq_( - testing.db.execute(select([expr.label('foo')])).scalar(), - "BIND_INfooBIND_INhiBIND_OUT" + testing.db.execute(select([expr.label("foo")])).scalar(), + "BIND_INfooBIND_INhiBIND_OUT", ) def test_typedec_is_adapt(self): @@ -2221,35 +2408,35 @@ class ExpressionTest( impl = Integer class CoerceBool(TypeDecorator): - coerce_to_is_types = (bool, ) + coerce_to_is_types = (bool,) impl = Boolean class CoerceNone(TypeDecorator): coerce_to_is_types = (type(None),) impl = Integer - c1 = column('x', CoerceNothing()) - c2 = column('x', CoerceBool()) - c3 = column('x', CoerceNone()) + c1 = column("x", CoerceNothing()) + c2 = column("x", CoerceBool()) + c3 = column("x", CoerceNone()) self.assert_compile( and_(c1 == None, c2 == None, c3 == None), # noqa - "x = :x_1 AND x = :x_2 AND x IS NULL" + "x = :x_1 AND x = :x_2 AND x IS NULL", ) self.assert_compile( and_(c1 == True, c2 == True, c3 == True), # noqa "x = :x_1 AND x = true AND x = :x_2", - dialect=default.DefaultDialect(supports_native_boolean=True) + dialect=default.DefaultDialect(supports_native_boolean=True), ) self.assert_compile( and_(c1 == 3, c2 == 3, c3 == 3), "x = :x_1 AND x = :x_2 AND x = :x_3", - dialect=default.DefaultDialect(supports_native_boolean=True) + dialect=default.DefaultDialect(supports_native_boolean=True), ) self.assert_compile( and_(c1.is_(True), c2.is_(True), c3.is_(True)), "x IS :x_1 AND x IS true AND x IS :x_2", - dialect=default.DefaultDialect(supports_native_boolean=True) + dialect=default.DefaultDialect(supports_native_boolean=True), ) def test_typedec_righthand_coercion(self): @@ -2262,21 +2449,19 @@ class ExpressionTest( def process_result_value(self, value, dialect): return value + "BIND_OUT" - tab = table('test', column('bvalue', MyTypeDec)) + tab = table("test", column("bvalue", MyTypeDec)) expr = tab.c.bvalue + 6 self.assert_compile( - expr, - "test.bvalue || :bvalue_1", - use_default_dialect=True + expr, "test.bvalue || :bvalue_1", use_default_dialect=True ) is_(expr.right.type.__class__, MyTypeDec) is_(expr.type.__class__, MyTypeDec) eq_( - testing.db.execute(select([expr.label('foo')])).scalar(), - "BIND_INfooBIND_IN6BIND_OUT" + testing.db.execute(select([expr.label("foo")])).scalar(), + "BIND_INfooBIND_IN6BIND_OUT", ) def test_variant_righthand_coercion_honors_wrapped(self): @@ -2284,16 +2469,16 @@ class ExpressionTest( my_json_variant = JSON().with_variant(String(), "sqlite") tab = table( - 'test', - column('avalue', my_json_normal), - column('bvalue', my_json_variant) + "test", + column("avalue", my_json_normal), + column("bvalue", my_json_variant), ) - expr = tab.c.avalue['foo'] == 'bar' + expr = tab.c.avalue["foo"] == "bar" is_(expr.right.type._type_affinity, String) is_not_(expr.right.type, my_json_normal) - expr = tab.c.bvalue['foo'] == 'bar' + expr = tab.c.bvalue["foo"] == "bar" is_(expr.right.type._type_affinity, String) is_not_(expr.right.type, my_json_variant) @@ -2301,12 +2486,13 @@ class ExpressionTest( def test_variant_righthand_coercion_returns_self(self): my_datetime_normal = DateTime() my_datetime_variant = DateTime().with_variant( - dialects.sqlite.DATETIME(truncate_microseconds=False), "sqlite") + dialects.sqlite.DATETIME(truncate_microseconds=False), "sqlite" + ) tab = table( - 'test', - column('avalue', my_datetime_normal), - column('bvalue', my_datetime_variant) + "test", + column("avalue", my_datetime_normal), + column("bvalue", my_datetime_variant), ) expr = tab.c.avalue == datetime.datetime(2015, 10, 14, 15, 17, 18) @@ -2353,72 +2539,69 @@ class ExpressionTest( assert expr.right.type._type_affinity is MyFoobarType def test_date_coercion(self): - expr = column('bar', types.NULLTYPE) - column('foo', types.TIMESTAMP) + expr = column("bar", types.NULLTYPE) - column("foo", types.TIMESTAMP) eq_(expr.type._type_affinity, types.NullType) - expr = func.sysdate() - column('foo', types.TIMESTAMP) + expr = func.sysdate() - column("foo", types.TIMESTAMP) eq_(expr.type._type_affinity, types.Interval) - expr = func.current_date() - column('foo', types.TIMESTAMP) + expr = func.current_date() - column("foo", types.TIMESTAMP) eq_(expr.type._type_affinity, types.Interval) def test_interval_coercion(self): - expr = column('bar', types.Interval) + column('foo', types.Date) + expr = column("bar", types.Interval) + column("foo", types.Date) eq_(expr.type._type_affinity, types.DateTime) - expr = column('bar', types.Interval) * column('foo', types.Numeric) + expr = column("bar", types.Interval) * column("foo", types.Numeric) eq_(expr.type._type_affinity, types.Interval) - def test_numerics_coercion(self): for op in (operator.add, operator.mul, operator.truediv, operator.sub): for other in (Numeric(10, 2), Integer): expr = op( - column('bar', types.Numeric(10, 2)), - column('foo', other) + column("bar", types.Numeric(10, 2)), column("foo", other) ) assert isinstance(expr.type, types.Numeric) expr = op( - column('foo', other), - column('bar', types.Numeric(10, 2)) + column("foo", other), column("bar", types.Numeric(10, 2)) ) assert isinstance(expr.type, types.Numeric) def test_asdecimal_int_to_numeric(self): - expr = column('a', Integer) * column('b', Numeric(asdecimal=False)) + expr = column("a", Integer) * column("b", Numeric(asdecimal=False)) is_(expr.type.asdecimal, False) - expr = column('a', Integer) * column('b', Numeric()) + expr = column("a", Integer) * column("b", Numeric()) is_(expr.type.asdecimal, True) - expr = column('a', Integer) * column('b', Float()) + expr = column("a", Integer) * column("b", Float()) is_(expr.type.asdecimal, False) assert isinstance(expr.type, Float) def test_asdecimal_numeric_to_int(self): - expr = column('a', Numeric(asdecimal=False)) * column('b', Integer) + expr = column("a", Numeric(asdecimal=False)) * column("b", Integer) is_(expr.type.asdecimal, False) - expr = column('a', Numeric()) * column('b', Integer) + expr = column("a", Numeric()) * column("b", Integer) is_(expr.type.asdecimal, True) - expr = column('a', Float()) * column('b', Integer) + expr = column("a", Float()) * column("b", Integer) is_(expr.type.asdecimal, False) assert isinstance(expr.type, Float) def test_null_comparison(self): eq_( - str(column('a', types.NullType()) + column('b', types.NullType())), - "a + b" + str(column("a", types.NullType()) + column("b", types.NullType())), + "a + b", ) def test_expression_typing(self): - expr = column('bar', Integer) - 3 + expr = column("bar", Integer) - 3 eq_(expr.type._type_affinity, Integer) - expr = bindparam('bar') + bindparam('foo') + expr = bindparam("bar") + bindparam("foo") eq_(expr.type, types.NULLTYPE) def test_distinct(self): @@ -2443,24 +2626,18 @@ class ExpressionTest( assert_raises_message( exc.ArgumentError, r"Object some_sqla_thing\(\) is not legal as a SQL literal value", - lambda: column('a', String) == SomeSQLAThing() + lambda: column("a", String) == SomeSQLAThing(), ) - is_( - bindparam('x', SomeOtherThing()).type, - types.NULLTYPE - ) + is_(bindparam("x", SomeOtherThing()).type, types.NULLTYPE) def test_detect_coercion_not_fooled_by_mock(self): m1 = mock.Mock() - is_( - bindparam('x', m1).type, - types.NULLTYPE - ) + is_(bindparam("x", m1).type, types.NULLTYPE) class CompileTest(fixtures.TestBase, AssertsCompiledSQL): - __dialect__ = 'default' + __dialect__ = "default" @testing.requires.unbounded_varchar def test_string_plain(self): @@ -2471,7 +2648,8 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def test_string_collation(self): self.assert_compile( - String(50, collation="FOO"), 'VARCHAR(50) COLLATE "FOO"') + String(50, collation="FOO"), 'VARCHAR(50) COLLATE "FOO"' + ) def test_char_plain(self): self.assert_compile(CHAR(), "CHAR") @@ -2481,7 +2659,8 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): def test_char_collation(self): self.assert_compile( - CHAR(50, collation="FOO"), 'CHAR(50) COLLATE "FOO"') + CHAR(50, collation="FOO"), 'CHAR(50) COLLATE "FOO"' + ) def test_text_plain(self): self.assert_compile(Text(), "TEXT") @@ -2490,39 +2669,42 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): self.assert_compile(Text(50), "TEXT(50)") def test_text_collation(self): - self.assert_compile( - Text(collation="FOO"), 'TEXT COLLATE "FOO"') + self.assert_compile(Text(collation="FOO"), 'TEXT COLLATE "FOO"') def test_default_compile_pg_inet(self): self.assert_compile( - dialects.postgresql.INET(), "INET", allow_dialect_select=True) + dialects.postgresql.INET(), "INET", allow_dialect_select=True + ) def test_default_compile_pg_float(self): self.assert_compile( - dialects.postgresql.FLOAT(), "FLOAT", allow_dialect_select=True) + dialects.postgresql.FLOAT(), "FLOAT", allow_dialect_select=True + ) def test_default_compile_mysql_integer(self): self.assert_compile( - dialects.mysql.INTEGER(display_width=5), "INTEGER(5)", - allow_dialect_select=True) + dialects.mysql.INTEGER(display_width=5), + "INTEGER(5)", + allow_dialect_select=True, + ) def test_numeric_plain(self): - self.assert_compile(types.NUMERIC(), 'NUMERIC') + self.assert_compile(types.NUMERIC(), "NUMERIC") def test_numeric_precision(self): - self.assert_compile(types.NUMERIC(2), 'NUMERIC(2)') + self.assert_compile(types.NUMERIC(2), "NUMERIC(2)") def test_numeric_scale(self): - self.assert_compile(types.NUMERIC(2, 4), 'NUMERIC(2, 4)') + self.assert_compile(types.NUMERIC(2, 4), "NUMERIC(2, 4)") def test_decimal_plain(self): - self.assert_compile(types.DECIMAL(), 'DECIMAL') + self.assert_compile(types.DECIMAL(), "DECIMAL") def test_decimal_precision(self): - self.assert_compile(types.DECIMAL(2), 'DECIMAL(2)') + self.assert_compile(types.DECIMAL(2), "DECIMAL(2)") def test_decimal_scale(self): - self.assert_compile(types.DECIMAL(2, 4), 'DECIMAL(2, 4)') + self.assert_compile(types.DECIMAL(2, 4), "DECIMAL(2, 4)") def test_kwarg_legacy_typecompiler(self): from sqlalchemy.sql import compiler @@ -2534,19 +2716,19 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): # not affected def visit_INTEGER(self, type_, **kw): - return "MYINTEGER %s" % kw['type_expression'].name + return "MYINTEGER %s" % kw["type_expression"].name dialect = default.DefaultDialect() dialect.type_compiler = SomeTypeCompiler(dialect) self.assert_compile( - ddl.CreateColumn(Column('bar', VARCHAR(50))), + ddl.CreateColumn(Column("bar", VARCHAR(50))), "bar MYVARCHAR", - dialect=dialect + dialect=dialect, ) self.assert_compile( - ddl.CreateColumn(Column('bar', INTEGER)), + ddl.CreateColumn(Column("bar", INTEGER)), "bar MYINTEGER bar", - dialect=dialect + dialect=dialect, ) @@ -2558,14 +2740,11 @@ class TestKWArgPassThru(AssertsCompiledSQL, fixtures.TestBase): class MyType(types.UserDefinedType): def get_col_spec(self, **kw): - return "FOOB %s" % kw['type_expression'].name + return "FOOB %s" % kw["type_expression"].name m = MetaData() - t = Table('t', m, Column('bar', MyType, nullable=False)) - self.assert_compile( - ddl.CreateColumn(t.c.bar), - "bar FOOB bar NOT NULL" - ) + t = Table("t", m, Column("bar", MyType, nullable=False)) + self.assert_compile(ddl.CreateColumn(t.c.bar), "bar FOOB bar NOT NULL") class NumericRawSQLTest(fixtures.TestBase): @@ -2576,11 +2755,11 @@ class NumericRawSQLTest(fixtures.TestBase): """ def _fixture(self, metadata, type, data): - t = Table('t', metadata, Column("val", type)) + t = Table("t", metadata, Column("val", type)) metadata.create_all() t.insert().execute(val=data) - @testing.fails_on('sqlite', "Doesn't provide Decimal results natively") + @testing.fails_on("sqlite", "Doesn't provide Decimal results natively") @testing.provide_metadata def test_decimal_fp(self): metadata = self.metadata @@ -2589,7 +2768,7 @@ class NumericRawSQLTest(fixtures.TestBase): assert isinstance(val, decimal.Decimal) eq_(val, decimal.Decimal("45.5")) - @testing.fails_on('sqlite', "Doesn't provide Decimal results natively") + @testing.fails_on("sqlite", "Doesn't provide Decimal results natively") @testing.provide_metadata def test_decimal_int(self): metadata = self.metadata @@ -2614,7 +2793,7 @@ class NumericRawSQLTest(fixtures.TestBase): assert isinstance(val, float) # some DBAPIs have unusual float handling - if testing.against('oracle+cx_oracle', 'mysql+oursql', 'firebird'): + if testing.against("oracle+cx_oracle", "mysql+oursql", "firebird"): eq_(round_decimal(val, 3), 46.583) else: eq_(val, 46.583) @@ -2624,22 +2803,22 @@ interval_table = metadata = None class IntervalTest(fixtures.TestBase, AssertsExecutionResults): - @classmethod def setup_class(cls): global interval_table, metadata metadata = MetaData(testing.db) interval_table = Table( - "intervaltable", metadata, + "intervaltable", + metadata, Column( - "id", Integer, primary_key=True, - test_needs_autoincrement=True), + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), Column("native_interval", Interval()), Column( "native_interval_args", - Interval(day_precision=3, second_precision=6)), - Column( - "non_native_interval", Interval(native=False)), + Interval(day_precision=3, second_precision=6), + ), + Column("non_native_interval", Interval(native=False)), ) metadata.create_all() @@ -2662,59 +2841,66 @@ class IntervalTest(fixtures.TestBase, AssertsExecutionResults): small_delta = datetime.timedelta(days=15, seconds=5874) delta = datetime.timedelta(414) interval_table.insert().execute( - native_interval=small_delta, native_interval_args=delta, - non_native_interval=delta) + native_interval=small_delta, + native_interval_args=delta, + non_native_interval=delta, + ) row = interval_table.select().execute().first() - eq_(row['native_interval'], small_delta) - eq_(row['native_interval_args'], delta) - eq_(row['non_native_interval'], delta) + eq_(row["native_interval"], small_delta) + eq_(row["native_interval_args"], delta) + eq_(row["non_native_interval"], delta) def test_null(self): interval_table.insert().execute( - id=1, native_inverval=None, non_native_interval=None) + id=1, native_inverval=None, non_native_interval=None + ) row = interval_table.select().execute().first() - eq_(row['native_interval'], None) - eq_(row['native_interval_args'], None) - eq_(row['non_native_interval'], None) + eq_(row["native_interval"], None) + eq_(row["native_interval_args"], None) + eq_(row["non_native_interval"], None) class BooleanTest( - fixtures.TablesTest, AssertsExecutionResults, AssertsCompiledSQL): + fixtures.TablesTest, AssertsExecutionResults, AssertsCompiledSQL +): """test edge cases for booleans. Note that the main boolean test suite is now in testing/suite/test_types.py """ + @classmethod def define_tables(cls, metadata): Table( - 'boolean_table', metadata, - Column('id', Integer, primary_key=True, autoincrement=False), - Column('value', Boolean), - Column('unconstrained_value', Boolean(create_constraint=False)), + "boolean_table", + metadata, + Column("id", Integer, primary_key=True, autoincrement=False), + Column("value", Boolean), + Column("unconstrained_value", Boolean(create_constraint=False)), ) @testing.fails_on( - 'mysql', - "The CHECK clause is parsed but ignored by all storage engines.") - @testing.fails_on( - 'mssql', "FIXME: MS-SQL 2005 doesn't honor CHECK ?!?") + "mysql", + "The CHECK clause is parsed but ignored by all storage engines.", + ) + @testing.fails_on("mssql", "FIXME: MS-SQL 2005 doesn't honor CHECK ?!?") @testing.skip_if(lambda: testing.db.dialect.supports_native_boolean) def test_constraint(self): assert_raises( (exc.IntegrityError, exc.ProgrammingError), testing.db.execute, - "insert into boolean_table (id, value) values(1, 5)") + "insert into boolean_table (id, value) values(1, 5)", + ) @testing.skip_if(lambda: testing.db.dialect.supports_native_boolean) def test_unconstrained(self): testing.db.execute( "insert into boolean_table (id, unconstrained_value)" - "values (1, 5)") + "values (1, 5)" + ) def test_non_native_constraint_custom_type(self): class Foob(object): - def __init__(self, value): self.value = value @@ -2729,14 +2915,15 @@ class BooleanTest( return value.value m = MetaData() - t1 = Table('t', m, Column('x', MyBool())) - const = [ - c for c in t1.constraints if isinstance(c, CheckConstraint)][0] + t1 = Table("t", m, Column("x", MyBool())) + const = [c for c in t1.constraints if isinstance(c, CheckConstraint)][ + 0 + ] self.assert_compile( AddConstraint(const), "ALTER TABLE t ADD CHECK (x IN (0, 1))", - dialect="sqlite" + dialect="sqlite", ) @testing.skip_if(lambda: testing.db.dialect.supports_native_boolean) @@ -2748,10 +2935,9 @@ class BooleanTest( "Value 5 is not None, True, or False", conn.execute, boolean_table.insert(), - {"id": 1, "unconstrained_value": 5} + {"id": 1, "unconstrained_value": 5}, ) - @testing.requires.non_native_boolean_unconstrained def test_nonnative_processor_coerces_integer_to_boolean(self): boolean_table = self.tables.boolean_table @@ -2762,194 +2948,204 @@ class BooleanTest( ) eq_( - conn.scalar("select unconstrained_value from boolean_table"), - 5 + conn.scalar("select unconstrained_value from boolean_table"), 5 ) eq_( conn.scalar(select([boolean_table.c.unconstrained_value])), - True + True, ) def test_bind_processor_coercion_native_true(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) is_(proc(True), True) def test_bind_processor_coercion_native_false(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) is_(proc(False), False) def test_bind_processor_coercion_native_none(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) is_(proc(None), None) def test_bind_processor_coercion_native_0(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) is_(proc(0), False) def test_bind_processor_coercion_native_1(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) is_(proc(1), True) def test_bind_processor_coercion_native_str(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) assert_raises_message( - TypeError, - "Not a boolean value: 'foo'", - proc, "foo" + TypeError, "Not a boolean value: 'foo'", proc, "foo" ) def test_bind_processor_coercion_native_int_out_of_range(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=True)) + mock.Mock(supports_native_boolean=True) + ) assert_raises_message( - ValueError, - "Value 15 is not None, True, or False", - proc, 15 + ValueError, "Value 15 is not None, True, or False", proc, 15 ) def test_bind_processor_coercion_nonnative_true(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) eq_(proc(True), 1) def test_bind_processor_coercion_nonnative_false(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) eq_(proc(False), 0) def test_bind_processor_coercion_nonnative_none(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) is_(proc(None), None) def test_bind_processor_coercion_nonnative_0(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) eq_(proc(0), 0) def test_bind_processor_coercion_nonnative_1(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) eq_(proc(1), 1) def test_bind_processor_coercion_nonnative_str(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) assert_raises_message( - TypeError, - "Not a boolean value: 'foo'", - proc, "foo" + TypeError, "Not a boolean value: 'foo'", proc, "foo" ) def test_bind_processor_coercion_nonnative_int_out_of_range(self): proc = Boolean().bind_processor( - mock.Mock(supports_native_boolean=False)) + mock.Mock(supports_native_boolean=False) + ) assert_raises_message( - ValueError, - "Value 15 is not None, True, or False", - proc, 15 + ValueError, "Value 15 is not None, True, or False", proc, 15 ) def test_literal_processor_coercion_native_true(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) eq_(proc(True), "true") def test_literal_processor_coercion_native_false(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) eq_(proc(False), "false") def test_literal_processor_coercion_native_1(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) eq_(proc(1), "true") def test_literal_processor_coercion_native_0(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) eq_(proc(0), "false") def test_literal_processor_coercion_native_str(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) assert_raises_message( - TypeError, - "Not a boolean value: 'foo'", - proc, "foo" + TypeError, "Not a boolean value: 'foo'", proc, "foo" ) def test_literal_processor_coercion_native_int_out_of_range(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=True)) + default.DefaultDialect(supports_native_boolean=True) + ) assert_raises_message( - ValueError, - "Value 15 is not None, True, or False", - proc, 15 + ValueError, "Value 15 is not None, True, or False", proc, 15 ) def test_literal_processor_coercion_nonnative_true(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=False)) + default.DefaultDialect(supports_native_boolean=False) + ) eq_(proc(True), "1") def test_literal_processor_coercion_nonnative_false(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=False)) + default.DefaultDialect(supports_native_boolean=False) + ) eq_(proc(False), "0") def test_literal_processor_coercion_nonnative_1(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=False)) + default.DefaultDialect(supports_native_boolean=False) + ) eq_(proc(1), "1") def test_literal_processor_coercion_nonnative_0(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=False)) + default.DefaultDialect(supports_native_boolean=False) + ) eq_(proc(0), "0") def test_literal_processor_coercion_nonnative_str(self): proc = Boolean().literal_processor( - default.DefaultDialect(supports_native_boolean=False)) + default.DefaultDialect(supports_native_boolean=False) + ) assert_raises_message( - TypeError, - "Not a boolean value: 'foo'", - proc, "foo" + TypeError, "Not a boolean value: 'foo'", proc, "foo" ) - class PickleTest(fixtures.TestBase): - def test_eq_comparison(self): p1 = PickleType() for obj in ( - {'1': '2'}, + {"1": "2"}, pickleable.Bar(5, 6), - pickleable.OldSchool(10, 11) + pickleable.OldSchool(10, 11), ): assert p1.compare_values(p1.copy_value(obj), obj) assert_raises( - NotImplementedError, p1.compare_values, - pickleable.BrokenComparable('foo'), - pickleable.BrokenComparable('foo')) + NotImplementedError, + p1.compare_values, + pickleable.BrokenComparable("foo"), + pickleable.BrokenComparable("foo"), + ) def test_nonmutable_comparison(self): p1 = PickleType() for obj in ( - {'1': '2'}, + {"1": "2"}, pickleable.Bar(5, 6), - pickleable.OldSchool(10, 11) + pickleable.OldSchool(10, 11), ): assert p1.compare_values(p1.copy_value(obj), obj) @@ -2958,7 +3154,6 @@ meta = None class CallableTest(fixtures.TestBase): - @classmethod def setup_class(cls): global meta @@ -2971,9 +3166,7 @@ class CallableTest(fixtures.TestBase): def test_callable_as_arg(self): ucode = util.partial(Unicode) - thing_table = Table( - 'thing', meta, Column('name', ucode(20)) - ) + thing_table = Table("thing", meta, Column("name", ucode(20))) assert isinstance(thing_table.c.name.type, Unicode) thing_table.create() @@ -2981,7 +3174,7 @@ class CallableTest(fixtures.TestBase): ucode = util.partial(Unicode) thang_table = Table( - 'thang', meta, Column('name', type_=ucode(20), primary_key=True) + "thang", meta, Column("name", type_=ucode(20), primary_key=True) ) assert isinstance(thang_table.c.name.type, Unicode) thang_table.create() diff --git a/test/sql/test_unicode.py b/test/sql/test_unicode.py index e29aea54f..fafdb03a3 100644 --- a/test/sql/test_unicode.py +++ b/test/sql/test_unicode.py @@ -9,7 +9,7 @@ from sqlalchemy.util import u, ue class UnicodeSchemaTest(fixtures.TestBase): - __requires__ = ('unicode_ddl',) + __requires__ = ("unicode_ddl",) __backend__ = True @classmethod @@ -17,53 +17,67 @@ class UnicodeSchemaTest(fixtures.TestBase): global metadata, t1, t2, t3 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, - ) + 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'), + u("Unitéble2"), metadata, + Column(u("méil"), Integer, primary_key=True, key="a"), Column( - u('méil'), - Integer, - primary_key=True, - key="a"), - Column( - ue('\u6e2c\u8a66'), + ue("\u6e2c\u8a66"), Integer, - ForeignKey( - u('unitable1.méil')), - key="b"), + ForeignKey(u("unitable1.méil")), + key="b", + ), test_needs_fk=True, ) # Few DBs support Unicode foreign keys - if testing.against('sqlite'): - t3 = Table(ue('\u6e2c\u8a66'), metadata, - Column(ue('\u6e2c\u8a66_id'), Integer, primary_key=True, - autoincrement=False), - Column(ue('unitable1_\u6e2c\u8a66'), Integer, - ForeignKey(ue('unitable1.\u6e2c\u8a66')) - ), - Column(u('Unitéble2_b'), Integer, - ForeignKey(u('Unitéble2.b')) - ), - Column(ue('\u6e2c\u8a66_self'), Integer, - ForeignKey(ue('\u6e2c\u8a66.\u6e2c\u8a66_id')) - ), - test_needs_fk=True, - ) + if testing.against("sqlite"): + t3 = Table( + ue("\u6e2c\u8a66"), + metadata, + Column( + ue("\u6e2c\u8a66_id"), + Integer, + primary_key=True, + autoincrement=False, + ), + Column( + ue("unitable1_\u6e2c\u8a66"), + Integer, + ForeignKey(ue("unitable1.\u6e2c\u8a66")), + ), + Column( + u("Unitéble2_b"), Integer, ForeignKey(u("Unitéble2.b")) + ), + Column( + ue("\u6e2c\u8a66_self"), + Integer, + ForeignKey(ue("\u6e2c\u8a66.\u6e2c\u8a66_id")), + ), + test_needs_fk=True, + ) else: - t3 = Table(ue('\u6e2c\u8a66'), metadata, - Column(ue('\u6e2c\u8a66_id'), Integer, primary_key=True, - autoincrement=False), - Column(ue('unitable1_\u6e2c\u8a66'), Integer), - Column(u('Unitéble2_b'), Integer), - Column(ue('\u6e2c\u8a66_self'), Integer), - test_needs_fk=True, - ) + t3 = Table( + ue("\u6e2c\u8a66"), + metadata, + Column( + ue("\u6e2c\u8a66_id"), + Integer, + primary_key=True, + autoincrement=False, + ), + Column(ue("unitable1_\u6e2c\u8a66"), Integer), + Column(u("Unitéble2_b"), Integer), + Column(ue("\u6e2c\u8a66_self"), Integer), + test_needs_fk=True, + ) metadata.create_all() @engines.close_first @@ -78,86 +92,104 @@ 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}) - t3.insert().execute({ue('\u6e2c\u8a66_id'): 1, - ue('unitable1_\u6e2c\u8a66'): 5, - u('Unitéble2_b'): 1, - ue('\u6e2c\u8a66_self'): 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, + ue("\u6e2c\u8a66_self"): 1, + } + ) assert t1.select().execute().fetchall() == [(1, 5)] assert t2.select().execute().fetchall() == [(1, 1)] assert t3.select().execute().fetchall() == [(1, 5, 1, 1)] def test_col_targeting(self): - 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, - ue('\u6e2c\u8a66_self'): 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, + ue("\u6e2c\u8a66_self"): 1, + } + ) row = t1.select().execute().first() - eq_(row[t1.c[u('méil')]], 1) - eq_(row[t1.c[ue('\u6e2c\u8a66')]], 5) + eq_(row[t1.c[u("méil")]], 1) + eq_(row[t1.c[ue("\u6e2c\u8a66")]], 5) row = t2.select().execute().first() - eq_(row[t2.c[u('a')]], 1) - eq_(row[t2.c[u('b')]], 1) + eq_(row[t2.c[u("a")]], 1) + eq_(row[t2.c[u("b")]], 1) row = t3.select().execute().first() - eq_(row[t3.c[ue('\u6e2c\u8a66_id')]], 1) - eq_(row[t3.c[ue('unitable1_\u6e2c\u8a66')]], 5) - eq_(row[t3.c[u('Unitéble2_b')]], 1) - eq_(row[t3.c[ue('\u6e2c\u8a66_self')]], 1) + eq_(row[t3.c[ue("\u6e2c\u8a66_id")]], 1) + eq_(row[t3.c[ue("unitable1_\u6e2c\u8a66")]], 5) + eq_(row[t3.c[u("Unitéble2_b")]], 1) + eq_(row[t3.c[ue("\u6e2c\u8a66_self")]], 1) def test_reflect(self): - t1.insert().execute({u('méil'): 2, ue('\u6e2c\u8a66'): 7}) - t2.insert().execute({u('a'): 2, u('b'): 2}) - t3.insert().execute({ue('\u6e2c\u8a66_id'): 2, - ue('unitable1_\u6e2c\u8a66'): 7, - u('Unitéble2_b'): 2, - ue('\u6e2c\u8a66_self'): 2}) + t1.insert().execute({u("méil"): 2, ue("\u6e2c\u8a66"): 7}) + t2.insert().execute({u("a"): 2, u("b"): 2}) + t3.insert().execute( + { + ue("\u6e2c\u8a66_id"): 2, + ue("unitable1_\u6e2c\u8a66"): 7, + u("Unitéble2_b"): 2, + ue("\u6e2c\u8a66_self"): 2, + } + ) meta = MetaData(testing.db) tt1 = Table(t1.name, meta, autoload=True) tt2 = Table(t2.name, meta, autoload=True) tt3 = Table(t3.name, meta, autoload=True) - tt1.insert().execute({u('méil'): 1, ue('\u6e2c\u8a66'): 5}) - tt2.insert().execute({u('méil'): 1, ue('\u6e2c\u8a66'): 1}) - tt3.insert().execute({ue('\u6e2c\u8a66_id'): 1, - ue('unitable1_\u6e2c\u8a66'): 5, - u('Unitéble2_b'): 1, - ue('\u6e2c\u8a66_self'): 1}) + tt1.insert().execute({u("méil"): 1, ue("\u6e2c\u8a66"): 5}) + tt2.insert().execute({u("méil"): 1, ue("\u6e2c\u8a66"): 1}) + tt3.insert().execute( + { + ue("\u6e2c\u8a66_id"): 1, + ue("unitable1_\u6e2c\u8a66"): 5, + 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)]) + 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_( - 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)]) + tt3.select(order_by=desc(ue("\u6e2c\u8a66_id"))) + .execute() + .fetchall() + == [(2, 7, 2, 2), (1, 5, 1, 1)] + ) def test_repr(self): m = MetaData() t = Table( - ue('\u6e2c\u8a66'), - m, - Column( - ue('\u6e2c\u8a66_id'), - Integer)) + 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 56d12d927..191ecb4d6 100644 --- a/test/sql/test_update.py +++ b/test/sql/test_update.py @@ -1,88 +1,130 @@ -from sqlalchemy import Integer, String, ForeignKey, and_, or_, func, \ - literal, update, table, bindparam, column, select, exc, exists, text, \ - MetaData +from sqlalchemy import ( + Integer, + String, + ForeignKey, + and_, + or_, + func, + literal, + update, + table, + bindparam, + column, + select, + exc, + exists, + text, + MetaData, +) from sqlalchemy import testing from sqlalchemy.dialects import mysql from sqlalchemy.engine import default -from sqlalchemy.testing import AssertsCompiledSQL, eq_, fixtures, \ - assert_raises_message, assert_raises +from sqlalchemy.testing import ( + AssertsCompiledSQL, + eq_, + fixtures, + assert_raises_message, + assert_raises, +) from sqlalchemy.testing.schema import Table, Column from sqlalchemy import util class _UpdateFromTestBase(object): - @classmethod def define_tables(cls, metadata): - Table('mytable', metadata, - Column('myid', Integer), - Column('name', String(30)), - Column('description', String(50))) - Table('myothertable', metadata, - Column('otherid', Integer), - Column('othername', String(30))) - Table('users', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('name', String(30), nullable=False)) - Table('addresses', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('user_id', None, ForeignKey('users.id')), - Column('name', String(30), nullable=False), - Column('email_address', String(50), nullable=False)) - Table('dingalings', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('address_id', None, ForeignKey('addresses.id')), - Column('data', String(30))) - Table('update_w_default', metadata, - Column('id', Integer, primary_key=True), - Column('x', Integer), - Column('ycol', Integer, key='y'), - Column('data', String(30), onupdate=lambda: "hi")) + Table( + "mytable", + metadata, + Column("myid", Integer), + Column("name", String(30)), + Column("description", String(50)), + ) + Table( + "myothertable", + metadata, + Column("otherid", Integer), + Column("othername", String(30)), + ) + Table( + "users", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("name", String(30), nullable=False), + ) + Table( + "addresses", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("user_id", None, ForeignKey("users.id")), + Column("name", String(30), nullable=False), + Column("email_address", String(50), nullable=False), + ) + Table( + "dingalings", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("address_id", None, ForeignKey("addresses.id")), + Column("data", String(30)), + ) + Table( + "update_w_default", + metadata, + Column("id", Integer, primary_key=True), + Column("x", Integer), + Column("ycol", Integer, key="y"), + Column("data", String(30), onupdate=lambda: "hi"), + ) @classmethod def fixtures(cls): return dict( users=( - ('id', 'name'), - (7, 'jack'), - (8, 'ed'), - (9, 'fred'), - (10, 'chuck') + ("id", "name"), + (7, "jack"), + (8, "ed"), + (9, "fred"), + (10, "chuck"), ), addresses=( - ('id', 'user_id', 'name', 'email_address'), - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'ed@wood.com'), - (3, 8, 'x', 'ed@bettyboop.com'), - (4, 8, 'x', 'ed@lala.com'), - (5, 9, 'x', 'fred@fred.com') + ("id", "user_id", "name", "email_address"), + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "ed@wood.com"), + (3, 8, "x", "ed@bettyboop.com"), + (4, 8, "x", "ed@lala.com"), + (5, 9, "x", "fred@fred.com"), ), dingalings=( - ('id', 'address_id', 'data'), - (1, 2, 'ding 1/2'), - (2, 5, 'ding 2/5') + ("id", "address_id", "data"), + (1, 2, "ding 1/2"), + (2, 5, "ding 2/5"), ), ) class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): - __dialect__ = 'default_enhanced' + __dialect__ = "default_enhanced" def test_update_literal_binds(self): table1 = self.tables.mytable table1 = self.tables.mytable - stmt = table1.update().values(name='jack').\ - where(table1.c.name == 'jill') + stmt = ( + table1.update().values(name="jack").where(table1.c.name == "jill") + ) self.assert_compile( stmt, "UPDATE mytable SET name='jack' WHERE mytable.name = 'jill'", - literal_binds=True) + literal_binds=True, + ) def test_correlated_update_one(self): table1 = self.tables.mytable @@ -91,27 +133,33 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): u = update( table1, values={ - table1.c.name: - text("(select name from mytable where id=mytable.id)") - } + 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)") + "where id=mytable.id)", + ) def test_correlated_update_two(self): table1 = self.tables.mytable mt = table1.alias() - u = update(table1, values={ - table1.c.name: - select([mt.c.name], mt.c.myid == table1.c.myid) - }) + 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 " + u, + "UPDATE mytable SET name=(SELECT mytable_1.name FROM " "mytable AS mytable_1 WHERE " - "mytable_1.myid = mytable.myid)") + "mytable_1.myid = mytable.myid)", + ) def test_correlated_update_three(self): table1 = self.tables.mytable @@ -119,12 +167,14 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # 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}) + u = update(table1, table1.c.name == "jack", values={table1.c.name: s}) self.assert_compile( - u, "UPDATE mytable SET name=(SELECT myothertable.otherid, " + u, + "UPDATE mytable SET name=(SELECT myothertable.otherid, " "myothertable.othername FROM myothertable WHERE " "myothertable.otherid = mytable.myid) " - "WHERE mytable.name = :name_1") + "WHERE mytable.name = :name_1", + ) def test_correlated_update_four(self): table1 = self.tables.mytable @@ -133,11 +183,13 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # 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)") + 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)", + ) def test_correlated_update_five(self): table1 = self.tables.mytable @@ -146,44 +198,56 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # 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)") + 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)", + ) def test_correlated_update_six(self): table1 = self.tables.mytable table2 = self.tables.myothertable # test correlated FROM implicit in WHERE and SET clauses - u = table1.update().values(name=table2.c.othername)\ - .where(table2.c.otherid == table1.c.myid) + 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") + u, + "UPDATE mytable SET name=myothertable.othername " + "FROM myothertable WHERE myothertable.otherid = mytable.myid", + ) def test_correlated_update_seven(self): table1 = self.tables.mytable table2 = self.tables.myothertable - u = table1.update().values(name='foo')\ - .where(table2.c.otherid == table1.c.myid) + u = ( + table1.update() + .values(name="foo") + .where(table2.c.otherid == table1.c.myid) + ) # this is the "default_enhanced" compiler. there's no UPDATE FROM # in the base compiler. # See also test/dialect/mssql/test_compiler->test_update_from(). self.assert_compile( - u, "UPDATE mytable SET name=:name " - "FROM myothertable WHERE myothertable.otherid = mytable.myid") + u, + "UPDATE mytable SET name=:name " + "FROM myothertable WHERE myothertable.otherid = mytable.myid", + ) def test_binds_that_match_columns(self): """test bind params named after column names replace the normal SET/VALUES generation.""" - t = table('foo', column('x'), column('y')) + t = table("foo", column("x"), column("y")) - u = t.update().where(t.c.x == bindparam('x')) + u = t.update().where(t.c.x == bindparam("x")) assert_raises(exc.CompileError, u.compile) @@ -191,186 +255,205 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, 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") + self.assert_compile( + u.values(y=7), "UPDATE foo SET y=:y WHERE foo.x = :x" + ) - assert_raises(exc.CompileError, - u.values(x=7).compile, column_keys=['x', 'y']) - assert_raises(exc.CompileError, u.compile, column_keys=['x', 'y']) + assert_raises( + exc.CompileError, 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") + 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')), + u.values(x=3 + bindparam("x")), "UPDATE foo SET x=(:param_1 + :x) WHERE foo.x = :x", - params={ - 'x': 1}) + params={"x": 1}, + ) self.assert_compile( - u.values( - x=3 + - bindparam('x')), + u.values(x=3 + bindparam("x")), "UPDATE foo SET x=(:param_1 + :x), y=:y WHERE foo.x = :x", - params={ - 'x': 1, - 'y': 2}) + params={"x": 1, "y": 2}, + ) def test_labels_no_collision(self): - t = table('foo', column('id'), column('foo_id')) + t = table("foo", column("id"), column("foo_id")) self.assert_compile( t.update().where(t.c.id == 5), - "UPDATE foo SET id=:id, foo_id=:foo_id WHERE foo.id = :id_1" + "UPDATE foo SET id=:id, foo_id=:foo_id WHERE foo.id = :id_1", ) self.assert_compile( t.update().where(t.c.id == bindparam(key=t.c.id._label)), - "UPDATE foo SET id=:id, foo_id=:foo_id WHERE foo.id = :foo_id_1" + "UPDATE foo SET id=:id, foo_id=:foo_id WHERE foo.id = :foo_id_1", ) def test_inline_defaults(self): m = MetaData() - foo = Table('foo', m, - 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)) - ) + foo = Table("foo", m, 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)), + ) - 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") + 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", + ) def test_update_1(self): table1 = self.tables.mytable self.assert_compile( update(table1, table1.c.myid == 7), - 'UPDATE mytable SET name=:name WHERE mytable.myid = :myid_1', - params={table1.c.name: 'fred'}) + "UPDATE mytable SET name=:name WHERE mytable.myid = :myid_1", + params={table1.c.name: "fred"}, + ) def test_update_2(self): table1 = self.tables.mytable self.assert_compile( - table1.update(). - 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}) + table1.update() + .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}, + ) def test_update_3(self): table1 = self.tables.mytable self.assert_compile( update(table1, table1.c.myid == 7), - 'UPDATE mytable SET name=:name WHERE mytable.myid = :myid_1', - params={'name': 'fred'}) + "UPDATE mytable SET name=:name WHERE mytable.myid = :myid_1", + params={"name": "fred"}, + ) def test_update_4(self): table1 = self.tables.mytable self.assert_compile( update(table1, values={table1.c.name: table1.c.myid}), - 'UPDATE mytable SET name=mytable.myid') + "UPDATE mytable SET name=mytable.myid", + ) def test_update_5(self): table1 = self.tables.mytable self.assert_compile( - update(table1, - whereclause=table1.c.name == bindparam('crit'), - values={table1.c.name: 'hi'}), - 'UPDATE mytable SET name=:name WHERE mytable.name = :crit', - params={'crit': 'notthere'}, - checkparams={'crit': 'notthere', 'name': 'hi'}) + update( + table1, + whereclause=table1.c.name == bindparam("crit"), + values={table1.c.name: "hi"}, + ), + "UPDATE mytable SET name=:name WHERE mytable.name = :crit", + params={"crit": "notthere"}, + checkparams={"crit": "notthere", "name": "hi"}, + ) def test_update_6(self): table1 = self.tables.mytable self.assert_compile( - update(table1, - table1.c.myid == 12, - values={table1.c.name: table1.c.myid}), - 'UPDATE mytable ' - 'SET name=mytable.myid, description=:description ' - 'WHERE mytable.myid = :myid_1', - params={'description': 'test'}, - checkparams={'description': 'test', 'myid_1': 12}) + update( + table1, + table1.c.myid == 12, + values={table1.c.name: table1.c.myid}, + ), + "UPDATE mytable " + "SET name=mytable.myid, description=:description " + "WHERE mytable.myid = :myid_1", + params={"description": "test"}, + checkparams={"description": "test", "myid_1": 12}, + ) def test_update_7(self): table1 = self.tables.mytable self.assert_compile( update(table1, table1.c.myid == 12, values={table1.c.myid: 9}), - 'UPDATE mytable ' - 'SET myid=:myid, description=:description ' - 'WHERE mytable.myid = :myid_1', - params={'myid_1': 12, 'myid': 9, 'description': 'test'}) + "UPDATE mytable " + "SET myid=:myid, description=:description " + "WHERE mytable.myid = :myid_1", + params={"myid_1": 12, "myid": 9, "description": "test"}, + ) def test_update_8(self): table1 = self.tables.mytable self.assert_compile( update(table1, table1.c.myid == 12), - 'UPDATE mytable SET myid=:myid WHERE mytable.myid = :myid_1', - params={'myid': 18}, checkparams={'myid': 18, 'myid_1': 12}) + "UPDATE mytable SET myid=:myid WHERE mytable.myid = :myid_1", + params={"myid": 18}, + checkparams={"myid": 18, "myid_1": 12}, + ) def test_update_9(self): table1 = self.tables.mytable - s = table1.update(table1.c.myid == 12, values={table1.c.name: 'lala'}) - c = s.compile(column_keys=['id', 'name']) + s = table1.update(table1.c.myid == 12, values={table1.c.name: "lala"}) + c = s.compile(column_keys=["id", "name"]) eq_(str(s), str(c)) def test_update_10(self): table1 = self.tables.mytable v1 = {table1.c.name: table1.c.myid} - v2 = {table1.c.name: table1.c.name + 'foo'} + v2 = {table1.c.name: table1.c.name + "foo"} self.assert_compile( update(table1, table1.c.myid == 12, values=v1).values(v2), - 'UPDATE mytable ' - 'SET ' - 'name=(mytable.name || :name_1), ' - 'description=:description ' - 'WHERE mytable.myid = :myid_1', - params={'description': 'test'}) + "UPDATE mytable " + "SET " + "name=(mytable.name || :name_1), " + "description=:description " + "WHERE mytable.myid = :myid_1", + params={"description": "test"}, + ) def test_update_11(self): table1 = self.tables.mytable values = { - table1.c.name: table1.c.name + 'lala', - table1.c.myid: func.do_stuff(table1.c.myid, literal('hoho')) + 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), - 'UPDATE mytable ' - 'SET ' - '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') + (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) " + "WHERE " + "mytable.myid = hoho(:hoho_1) AND " + "mytable.name = :param_2 || mytable.name || :param_3", + ) def test_unconsumed_names_kwargs(self): t = table("t", column("x"), column("y")) @@ -388,8 +471,11 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): assert_raises_message( 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, + t.update() + .values(x=5, j=7) + .values({t2.c.z: 5}) + .where(t.c.x == t2.c.q) + .compile, ) def test_unconsumed_names_kwargs_w_keys(self): @@ -399,7 +485,7 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): exc.CompileError, "Unconsumed column names: j", t.update().values(x=5, j=7).compile, - column_keys=['j'] + column_keys=["j"], ) def test_update_ordered_parameters_1(self): @@ -408,25 +494,28 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # Confirm that we can pass values as list value pairs # note these are ordered *differently* from table.c values = [ - (table1.c.name, table1.c.name + 'lala'), - (table1.c.myid, func.do_stuff(table1.c.myid, literal('hoho'))), + (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')), + (table1.c.myid == func.hoho(4)) + & ( + table1.c.name + == literal("foo") + table1.c.name + literal("lala") + ), preserve_parameter_order=True, - values=values), - 'UPDATE mytable ' - 'SET ' - 'name=(mytable.name || :name_1), ' - 'myid=do_stuff(mytable.myid, :param_1) ' - 'WHERE ' - 'mytable.myid = hoho(:hoho_1) AND ' - 'mytable.name = :param_2 || mytable.name || :param_3') + values=values, + ), + "UPDATE mytable " + "SET " + "name=(mytable.name || :name_1), " + "myid=do_stuff(mytable.myid, :param_1) " + "WHERE " + "mytable.myid = hoho(:hoho_1) AND " + "mytable.name = :param_2 || mytable.name || :param_3", + ) def test_update_ordered_parameters_2(self): table1 = self.tables.mytable @@ -434,39 +523,39 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # Confirm that we can pass values as list value pairs # note these are ordered *differently* from table.c values = [ - (table1.c.name, table1.c.name + 'lala'), - ('description', 'some desc'), - (table1.c.myid, func.do_stuff(table1.c.myid, literal('hoho'))) + (table1.c.name, table1.c.name + "lala"), + ("description", "some desc"), + (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')), - preserve_parameter_order=True).values(values), - 'UPDATE mytable ' - 'SET ' - 'name=(mytable.name || :name_1), ' - 'description=:description, ' - 'myid=do_stuff(mytable.myid, :param_1) ' - 'WHERE ' - 'mytable.myid = hoho(:hoho_1) AND ' - 'mytable.name = :param_2 || mytable.name || :param_3') + (table1.c.myid == func.hoho(4)) + & ( + table1.c.name + == literal("foo") + table1.c.name + literal("lala") + ), + preserve_parameter_order=True, + ).values(values), + "UPDATE mytable " + "SET " + "name=(mytable.name || :name_1), " + "description=:description, " + "myid=do_stuff(mytable.myid, :param_1) " + "WHERE " + "mytable.myid = hoho(:hoho_1) AND " + "mytable.name = :param_2 || mytable.name || :param_3", + ) def test_update_ordered_parameters_fire_onupdate(self): table = self.tables.update_w_default - values = [ - (table.c.y, table.c.x + 5), - ('x', 10) - ] + values = [(table.c.y, table.c.x + 5), ("x", 10)] self.assert_compile( table.update(preserve_parameter_order=True).values(values), "UPDATE update_w_default SET ycol=(update_w_default.x + :x_1), " - "x=:x, data=:data" + "x=:x, data=:data", ) def test_update_ordered_parameters_override_onupdate(self): @@ -475,13 +564,13 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): values = [ (table.c.y, table.c.x + 5), (table.c.data, table.c.x + 10), - ('x', 10) + ("x", 10), ] self.assert_compile( table.update(preserve_parameter_order=True).values(values), "UPDATE update_w_default SET ycol=(update_w_default.x + :x_1), " - "data=(update_w_default.x + :x_2), x=:x" + "data=(update_w_default.x + :x_2), x=:x", ) def test_update_preserve_order_reqs_listtups(self): @@ -491,7 +580,7 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): r"When preserve_parameter_order is True, values\(\) " r"only accepts a list of 2-tuples", table1.update(preserve_parameter_order=True).values, - {"description": "foo", "name": "bar"} + {"description": "foo", "name": "bar"}, ) def test_update_ordereddict(self): @@ -499,53 +588,65 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): # Confirm that ordered dicts are treated as normal dicts, # columns sorted in table order - values = util.OrderedDict(( - (table1.c.name, table1.c.name + 'lala'), - (table1.c.myid, func.do_stuff(table1.c.myid, literal('hoho'))))) + values = util.OrderedDict( + ( + (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), - 'UPDATE mytable ' - 'SET ' - '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') + (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) " + "WHERE " + "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") + "description=:description", + ) self.assert_compile( - table1.update().where( - or_()), + table1.update().where(or_()), "UPDATE mytable SET myid=:myid, name=:name, " - "description=:description") + "description=:description", + ) def test_prefix_with(self): table1 = self.tables.mytable - stmt = table1.update().\ - prefix_with('A', 'B', dialect='mysql').\ - prefix_with('C', 'D') + stmt = ( + table1.update() + .prefix_with("A", "B", dialect="mysql") + .prefix_with("C", "D") + ) - self.assert_compile(stmt, - 'UPDATE C D mytable SET myid=:myid, name=:name, ' - 'description=:description') + self.assert_compile( + stmt, + "UPDATE C D mytable SET myid=:myid, name=:name, " + "description=:description", + ) self.assert_compile( stmt, - 'UPDATE A B C D mytable SET myid=%s, name=%s, description=%s', - dialect=mysql.dialect()) + "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. @@ -558,8 +659,10 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1 = self.tables.mytable 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') + self.assert_compile( + table1.update().values({expr: "bar"}), + "UPDATE mytable SET foo(myid)=:param_1", + ) def test_update_bound_ordering(self): """test that bound parameters between the UPDATE and FROM clauses @@ -569,9 +672,11 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): table1 = self.tables.mytable 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') + upd = ( + table1.update() + .where(table1.c.name == sel.c.othername) + .values(name="foo") + ) dialect = default.StrCompileDialect() dialect.positional = True @@ -583,8 +688,8 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): "FROM myothertable " "WHERE myothertable.otherid = :otherid_1) AS anon_1 " "WHERE mytable.name = anon_1.othername", - checkpositional=('foo', 5), - dialect=dialect + checkpositional=("foo", 5), + dialect=dialect, ) self.assert_compile( @@ -594,73 +699,79 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): "FROM myothertable " "WHERE myothertable.otherid = %s) AS anon_1 SET mytable.name=%s " "WHERE mytable.name = anon_1.othername", - checkpositional=(5, 'foo'), - dialect=mysql.dialect() + checkpositional=(5, "foo"), + dialect=mysql.dialect(), ) -class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, - AssertsCompiledSQL): - __dialect__ = 'default_enhanced' +class UpdateFromCompileTest( + _UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL +): + __dialect__ = "default_enhanced" run_create_tables = run_inserts = run_deletes = None def test_alias_one(self): table1 = self.tables.mytable - talias1 = table1.alias('t1') + talias1 = table1.alias("t1") # this case is nonsensical. the UPDATE is entirely # against the alias, but we name the table-bound column # in values. The behavior here isn't really defined self.assert_compile( - update(talias1, talias1.c.myid == 7). - values({table1.c.name: "fred"}), - 'UPDATE mytable AS t1 ' - 'SET name=:name ' - 'WHERE t1.myid = :myid_1') + update(talias1, talias1.c.myid == 7).values( + {table1.c.name: "fred"} + ), + "UPDATE mytable AS t1 " + "SET name=:name " + "WHERE t1.myid = :myid_1", + ) def test_alias_two(self): table1 = self.tables.mytable - talias1 = table1.alias('t1') + talias1 = table1.alias("t1") # Here, compared to # test_alias_one(), here we actually have UPDATE..FROM, # which is causing the "table1.c.name" param to be handled # 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'}), - 'UPDATE mytable AS t1 ' - 'SET name=:mytable_name ' - 'FROM mytable ' - 'WHERE mytable.myid = :myid_1', - checkparams={'mytable_name': 'fred', 'myid_1': 7}, + update(talias1, table1.c.myid == 7).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 - talias1 = table1.alias('t1') + talias1 = table1.alias("t1") self.assert_compile( - update(talias1, table1.c.myid == 7). - values({table1.c.name: 'fred'}), + update(talias1, table1.c.myid == 7).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}, - dialect='mysql') + checkparams={"mytable_name": "fred", "myid_1": 7}, + dialect="mysql", + ) def test_update_from_multitable_same_name_mysql(self): users, addresses = self.tables.users, self.tables.addresses self.assert_compile( - users.update(). - values(name='newname'). - values({addresses.c.name: "new address"}). - where(users.c.id == addresses.c.user_id), + users.update() + .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", - checkparams={'addresses_name': 'new address', 'name': 'newname'}, - dialect='mysql' + checkparams={"addresses_name": "new address", "name": "newname"}, + dialect="mysql", ) def test_update_from_join_mysql(self): @@ -668,120 +779,117 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, j = users.join(addresses) self.assert_compile( - update(j). - values(name='newname'). - where(addresses.c.email_address == 'e1'), + update(j) + .values(name="newname") + .where(addresses.c.email_address == "e1"), "" - 'UPDATE users ' - 'INNER JOIN addresses ON users.id = addresses.user_id ' - 'SET users.name=%s ' - 'WHERE ' - 'addresses.email_address = %s', - checkparams={'email_address_1': 'e1', 'name': 'newname'}, - dialect=mysql.dialect()) + "UPDATE users " + "INNER JOIN addresses ON users.id = addresses.user_id " + "SET users.name=%s " + "WHERE " + "addresses.email_address = %s", + checkparams={"email_address_1": "e1", "name": "newname"}, + dialect=mysql.dialect(), + ) def test_render_table(self): users, addresses = self.tables.users, self.tables.addresses self.assert_compile( - users.update(). - 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', - checkparams={'email_address_1': 'e1', 'name': 'newname'}) + users.update() + .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", + checkparams={"email_address_1": "e1", "name": "newname"}, + ) def test_render_multi_table(self): users = self.tables.users addresses = self.tables.addresses dingalings = self.tables.dingalings - checkparams = { - 'email_address_1': 'e1', - 'id_1': 2, - 'name': 'newname' - } + checkparams = {"email_address_1": "e1", "id_1": 2, "name": "newname"} 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), - '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', - checkparams=checkparams) + 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), + "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", + checkparams=checkparams, + ) def test_render_table_mysql(self): users, addresses = self.tables.users, self.tables.addresses self.assert_compile( - users.update(). - 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', - checkparams={'email_address_1': 'e1', 'name': 'newname'}, - dialect=mysql.dialect()) + users.update() + .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", + checkparams={"email_address_1": "e1", "name": "newname"}, + dialect=mysql.dialect(), + ) def test_render_subquery(self): users, addresses = self.tables.users, self.tables.addresses - checkparams = { - 'email_address_1': 'e1', - 'id_1': 7, - 'name': 'newname' - } + checkparams = {"email_address_1": "e1", "id_1": 7, "name": "newname"} - cols = [ - addresses.c.id, - addresses.c.user_id, - addresses.c.email_address - ] + cols = [addresses.c.id, addresses.c.user_id, addresses.c.email_address] 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'), - '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' - ') AS anon_1 ' - 'WHERE users.id = anon_1.user_id ' - 'AND anon_1.email_address = :email_address_1', - checkparams=checkparams) + users.update() + .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" + ") AS anon_1 " + "WHERE users.id = anon_1.user_id " + "AND anon_1.email_address = :email_address_1", + checkparams=checkparams, + ) def test_correlation_to_extra(self): users, addresses = self.tables.users, self.tables.addresses - stmt = users.update().values(name="newname").where( - users.c.id == addresses.c.user_id - ).where( - ~exists().where( - addresses.c.user_id == users.c.id - ).where(addresses.c.email_address == 'foo').correlate(addresses) + stmt = ( + users.update() + .values(name="newname") + .where(users.c.id == addresses.c.user_id) + .where( + ~exists() + .where(addresses.c.user_id == users.c.id) + .where(addresses.c.email_address == "foo") + .correlate(addresses) + ) ) self.assert_compile( @@ -789,18 +897,22 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, "UPDATE users SET name=:name FROM addresses WHERE " "users.id = addresses.user_id AND NOT " "(EXISTS (SELECT * FROM users WHERE addresses.user_id = users.id " - "AND addresses.email_address = :email_address_1))" + "AND addresses.email_address = :email_address_1))", ) def test_dont_correlate_to_extra(self): users, addresses = self.tables.users, self.tables.addresses - stmt = users.update().values(name="newname").where( - users.c.id == addresses.c.user_id - ).where( - ~exists().where( - addresses.c.user_id == users.c.id - ).where(addresses.c.email_address == 'foo').correlate() + stmt = ( + users.update() + .values(name="newname") + .where(users.c.id == addresses.c.user_id) + .where( + ~exists() + .where(addresses.c.user_id == users.c.id) + .where(addresses.c.email_address == "foo") + .correlate() + ) ) self.assert_compile( @@ -809,24 +921,28 @@ class UpdateFromCompileTest(_UpdateFromTestBase, fixtures.TablesTest, "users.id = addresses.user_id AND NOT " "(EXISTS (SELECT * FROM addresses, users " "WHERE addresses.user_id = users.id " - "AND addresses.email_address = :email_address_1))" + "AND addresses.email_address = :email_address_1))", ) def test_autocorrelate_error(self): users, addresses = self.tables.users, self.tables.addresses - stmt = users.update().values(name="newname").where( - users.c.id == addresses.c.user_id - ).where( - ~exists().where( - addresses.c.user_id == users.c.id - ).where(addresses.c.email_address == 'foo') + stmt = ( + users.update() + .values(name="newname") + .where(users.c.id == addresses.c.user_id) + .where( + ~exists() + .where(addresses.c.user_id == users.c.id) + .where(addresses.c.email_address == "foo") + ) ) assert_raises_message( exc.InvalidRequestError, ".*returned no FROM clauses due to auto-correlation.*", - stmt.compile, dialect=default.StrCompileDialect() + stmt.compile, + dialect=default.StrCompileDialect(), ) @@ -838,17 +954,19 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): users, addresses = self.tables.users, self.tables.addresses testing.db.execute( - addresses.update(). - values(email_address=users.c.name). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + addresses.update() + .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'), - (2, 8, 'x', 'ed'), - (3, 8, 'x', 'ed'), - (4, 8, 'x', 'ed'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "ed"), + (3, 8, "x", "ed"), + (4, 8, "x", "ed"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) @testing.requires.update_from @@ -857,19 +975,20 @@ 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) + 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) ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'ed'), - (3, 8, 'x', 'ed'), - (4, 8, 'x', 'ed'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "ed"), + (3, 8, "x", "ed"), + (4, 8, "x", "ed"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) @testing.requires.update_from @@ -879,108 +998,95 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): dingalings = self.tables.dingalings 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)) + 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) + ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'ed'), - (3, 8, 'x', 'ed@bettyboop.com'), - (4, 8, 'x', 'ed@lala.com'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "ed"), + (3, 8, "x", "ed@bettyboop.com"), + (4, 8, "x", "ed@lala.com"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_exec_multitable(self): users, addresses = self.tables.users, self.tables.addresses - values = { - addresses.c.email_address: 'updated', - users.c.name: 'ed2' - } + values = {addresses.c.email_address: "updated", users.c.name: "ed2"} testing.db.execute( - addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + addresses.update() + .values(values) + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'updated'), - (3, 8, 'x', 'updated'), - (4, 8, 'x', 'updated'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "updated"), + (3, 8, "x", "updated"), + (4, 8, "x", "updated"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) - expected = [ - (7, 'jack'), - (8, 'ed2'), - (9, 'fred'), - (10, 'chuck')] + expected = [(7, "jack"), (8, "ed2"), (9, "fred"), (10, "chuck")] self._assert_users(users, expected) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_exec_join_multitable(self): users, addresses = self.tables.users, self.tables.addresses - values = { - addresses.c.email_address: 'updated', - users.c.name: 'ed2' - } + values = {addresses.c.email_address: "updated", users.c.name: "ed2"} testing.db.execute( - update(users.join(addresses)). - values(values). - where(users.c.name == 'ed')) + update(users.join(addresses)) + .values(values) + .where(users.c.name == "ed") + ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'x', 'updated'), - (3, 8, 'x', 'updated'), - (4, 8, 'x', 'updated'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "x", "updated"), + (3, 8, "x", "updated"), + (4, 8, "x", "updated"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) - expected = [ - (7, 'jack'), - (8, 'ed2'), - (9, 'fred'), - (10, 'chuck')] + expected = [(7, "jack"), (8, "ed2"), (9, "fred"), (10, "chuck")] self._assert_users(users, expected) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_exec_multitable_same_name(self): users, addresses = self.tables.users, self.tables.addresses - values = { - addresses.c.name: 'ad_ed2', - users.c.name: 'ed2' - } + values = {addresses.c.name: "ad_ed2", users.c.name: "ed2"} testing.db.execute( - addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + addresses.update() + .values(values) + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + ) expected = [ - (1, 7, 'x', 'jack@bean.com'), - (2, 8, 'ad_ed2', 'ed@wood.com'), - (3, 8, 'ad_ed2', 'ed@bettyboop.com'), - (4, 8, 'ad_ed2', 'ed@lala.com'), - (5, 9, 'x', 'fred@fred.com')] + (1, 7, "x", "jack@bean.com"), + (2, 8, "ad_ed2", "ed@wood.com"), + (3, 8, "ad_ed2", "ed@bettyboop.com"), + (4, 8, "ad_ed2", "ed@lala.com"), + (5, 9, "x", "fred@fred.com"), + ] self._assert_addresses(addresses, expected) - expected = [ - (7, 'jack'), - (8, 'ed2'), - (9, 'fred'), - (10, 'chuck')] + expected = [(7, "jack"), (8, "ed2"), (9, "fred"), (10, "chuck")] self._assert_users(users, expected) def _assert_addresses(self, addresses, expected): @@ -992,136 +1098,137 @@ class UpdateFromRoundTripTest(_UpdateFromTestBase, fixtures.TablesTest): eq_(testing.db.execute(stmt).fetchall(), expected) -class UpdateFromMultiTableUpdateDefaultsTest(_UpdateFromTestBase, - fixtures.TablesTest): +class UpdateFromMultiTableUpdateDefaultsTest( + _UpdateFromTestBase, fixtures.TablesTest +): __backend__ = True @classmethod def define_tables(cls, metadata): - Table('users', metadata, - Column('id', Integer, primary_key=True, - test_needs_autoincrement=True), - Column('name', String(30), nullable=False), - Column('some_update', String(30), onupdate='im the update')) - - Table('addresses', metadata, - Column('id', Integer, primary_key=True, - 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, - test_needs_autoincrement=True), - Column('user_id', None, ForeignKey('users.id')), - Column('data', String(30)), - Column('some_update', String(30), onupdate='im the other update') - ) + Table( + "users", + metadata, + Column( + "id", Integer, primary_key=True, test_needs_autoincrement=True + ), + Column("name", String(30), nullable=False), + Column("some_update", String(30), onupdate="im the update"), + ) + + Table( + "addresses", + metadata, + Column( + "id", Integer, primary_key=True, 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, test_needs_autoincrement=True + ), + 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): return dict( users=( - ('id', 'name', 'some_update'), - (8, 'ed', 'value'), - (9, 'fred', 'value'), + ("id", "name", "some_update"), + (8, "ed", "value"), + (9, "fred", "value"), ), addresses=( - ('id', 'user_id', 'email_address'), - (2, 8, 'ed@wood.com'), - (3, 8, 'ed@bettyboop.com'), - (4, 9, 'fred@fred.com') + ("id", "user_id", "email_address"), + (2, 8, "ed@wood.com"), + (3, 8, "ed@bettyboop.com"), + (4, 9, "fred@fred.com"), ), foobar=( - ('id', 'user_id', 'data'), - (2, 8, 'd1'), - (3, 8, 'd2'), - (4, 9, 'd3') - ) + ("id", "user_id", "data"), + (2, 8, "d1"), + (3, 8, "d2"), + (4, 9, "d3"), + ), ) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_defaults_second_table(self): users, addresses = self.tables.users, self.tables.addresses - values = { - addresses.c.email_address: 'updated', - users.c.name: 'ed2' - } + values = {addresses.c.email_address: "updated", users.c.name: "ed2"} ret = testing.db.execute( - addresses.update(). - values(values). - where(users.c.id == addresses.c.user_id). - where(users.c.name == 'ed')) + addresses.update() + .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])) expected = [ - (2, 8, 'updated'), - (3, 8, 'updated'), - (4, 9, 'fred@fred.com')] + (2, 8, "updated"), + (3, 8, "updated"), + (4, 9, "fred@fred.com"), + ] self._assert_addresses(addresses, expected) - expected = [ - (8, 'ed2', 'im the update'), - (9, 'fred', 'value')] + expected = [(8, "ed2", "im the update"), (9, "fred", "value")] self._assert_users(users, expected) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_defaults_second_table_same_name(self): users, foobar = self.tables.users, self.tables.foobar - values = { - foobar.c.data: foobar.c.data + 'a', - users.c.name: 'ed2' - } + values = {foobar.c.data: foobar.c.data + "a", users.c.name: "ed2"} ret = testing.db.execute( - users.update(). - values(values). - where(users.c.id == foobar.c.user_id). - where(users.c.name == 'ed')) + users.update() + .values(values) + .where(users.c.id == foobar.c.user_id) + .where(users.c.name == "ed") + ) eq_( set(ret.prefetch_cols()), - set([users.c.some_update, foobar.c.some_update]) + set([users.c.some_update, foobar.c.some_update]), ) expected = [ - (2, 8, 'd1a', 'im the other update'), - (3, 8, 'd2a', 'im the other update'), - (4, 9, 'd3', None)] + (2, 8, "d1a", "im the other update"), + (3, 8, "d2a", "im the other update"), + (4, 9, "d3", None), + ] self._assert_foobar(foobar, expected) - expected = [ - (8, 'ed2', 'im the update'), - (9, 'fred', 'value')] + expected = [(8, "ed2", "im the update"), (9, "fred", "value")] self._assert_users(users, expected) - @testing.only_on('mysql', 'Multi table update') + @testing.only_on("mysql", "Multi table update") def test_no_defaults_second_table(self): users, addresses = self.tables.users, self.tables.addresses 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')) + addresses.update() + .values({"email_address": users.c.name}) + .where(users.c.id == addresses.c.user_id) + .where(users.c.name == "ed") + ) eq_(ret.prefetch_cols(), []) - expected = [ - (2, 8, 'ed'), - (3, 8, 'ed'), - (4, 9, 'fred@fred.com')] + expected = [(2, 8, "ed"), (3, 8, "ed"), (4, 9, "fred@fred.com")] self._assert_addresses(addresses, expected) # users table not actually updated, so no onupdate - expected = [ - (8, 'ed', 'value'), - (9, 'fred', 'value')] + expected = [(8, "ed", "value"), (9, "fred", "value")] self._assert_users(users, expected) def _assert_foobar(self, foobar, expected): diff --git a/test/sql/test_utils.py b/test/sql/test_utils.py index bd8368cd2..bc124ada9 100644 --- a/test/sql/test_utils.py +++ b/test/sql/test_utils.py @@ -9,34 +9,17 @@ from sqlalchemy.sql import util as sql_util class CompareClausesTest(fixtures.TestBase): def setup(self): m = MetaData() - self.a = Table( - 'a', m, - Column('x', Integer), - Column('y', Integer) - ) + self.a = Table("a", m, Column("x", Integer), Column("y", Integer)) - self.b = Table( - 'b', m, - Column('y', Integer), - Column('z', Integer) - ) + self.b = Table("b", m, Column("y", Integer), Column("z", Integer)) def test_compare_clauselist_associative(self): - l1 = and_( - self.a.c.x == self.b.c.y, - self.a.c.y == self.b.c.z - ) + l1 = and_(self.a.c.x == self.b.c.y, self.a.c.y == self.b.c.z) - l2 = and_( - self.a.c.y == self.b.c.z, - self.a.c.x == self.b.c.y, - ) + l2 = and_(self.a.c.y == self.b.c.z, self.a.c.x == self.b.c.y) - l3 = and_( - self.a.c.x == self.b.c.z, - self.a.c.y == self.b.c.y - ) + l3 = and_(self.a.c.x == self.b.c.z, self.a.c.y == self.b.c.y) is_true(l1.compare(l1)) is_true(l1.compare(l2)) @@ -45,35 +28,33 @@ class CompareClausesTest(fixtures.TestBase): def test_compare_clauselist_not_associative(self): l1 = ClauseList( - self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.sub) + self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.sub + ) l2 = ClauseList( - self.b.c.y, self.a.c.x, self.a.c.y, operator=operators.sub) + self.b.c.y, self.a.c.x, self.a.c.y, operator=operators.sub + ) is_true(l1.compare(l1)) is_false(l1.compare(l2)) def test_compare_clauselist_assoc_different_operator(self): - l1 = and_( - self.a.c.x == self.b.c.y, - self.a.c.y == self.b.c.z - ) + l1 = and_(self.a.c.x == self.b.c.y, self.a.c.y == self.b.c.z) - l2 = or_( - self.a.c.y == self.b.c.z, - self.a.c.x == self.b.c.y, - ) + l2 = or_(self.a.c.y == self.b.c.z, self.a.c.x == self.b.c.y) is_false(l1.compare(l2)) def test_compare_clauselist_not_assoc_different_operator(self): l1 = ClauseList( - self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.sub) + self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.sub + ) l2 = ClauseList( - self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.div) + self.a.c.x, self.a.c.y, self.b.c.y, operator=operators.div + ) is_false(l1.compare(l2)) @@ -83,9 +64,11 @@ class CompareClausesTest(fixtures.TestBase): b3 = bindparam("bar", type_=Integer()) b4 = bindparam("foo", type_=String()) - def c1(): return 5 + def c1(): + return 5 - def c2(): return 6 + def c2(): + return 6 b5 = bindparam("foo", type_=Integer(), callable_=c1) b6 = bindparam("foo", type_=Integer(), callable_=c2) @@ -114,7 +97,4 @@ class MiscTest(fixtures.TestBase): class MyElement(ColumnElement): pass - eq_( - sql_util.find_tables(MyElement(), check_columns=True), - [] - ) + eq_(sql_util.find_tables(MyElement(), check_columns=True), []) |