summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CHANGES4
-rw-r--r--doc/build/content/ormtutorial.txt6
-rw-r--r--doc/build/content/tutorial.txt2
-rw-r--r--lib/sqlalchemy/sql/expression.py30
-rwxr-xr-xtest/dialect/mssql.py4
-rw-r--r--test/engine/transaction.py2
-rw-r--r--test/orm/cascade.py16
-rw-r--r--test/orm/dynamic.py2
-rw-r--r--test/orm/eager_relations.py2
-rw-r--r--test/orm/inheritance/poly_linked_list.py2
-rw-r--r--test/orm/inheritance/polymorph2.py2
-rw-r--r--test/orm/mapper.py2
-rw-r--r--test/orm/query.py10
-rw-r--r--test/orm/sharding/shard.py2
-rw-r--r--test/orm/unitofwork.py20
-rw-r--r--test/perf/ormsession.py4
-rw-r--r--test/profiling/zoomark.py4
-rw-r--r--test/sql/query.py30
-rw-r--r--test/sql/select.py69
19 files changed, 119 insertions, 94 deletions
diff --git a/CHANGES b/CHANGES
index ced5428e2..d40df7be6 100644
--- a/CHANGES
+++ b/CHANGES
@@ -91,6 +91,10 @@ CHANGES
- Added Float and Time types to Firebird (FBFloat and FBTime). Fixed
BLOB SUB_TYPE for TEXT and Binary types.
+- Changed the API for the in_ operator. in_() now accepts a single argument
+ that is a sequence of values or a selectable. The old API of passing in
+ values as varargs still works but is deprecated.
+
0.4.0beta6
----------
diff --git a/doc/build/content/ormtutorial.txt b/doc/build/content/ormtutorial.txt
index 4ef853f91..1a8de8265 100644
--- a/doc/build/content/ormtutorial.txt
+++ b/doc/build/content/ormtutorial.txt
@@ -861,7 +861,7 @@ So far, so good. How about Jack's `Address` objects ?
{python}
{sql}>>> session.query(Address).filter(
- ... Address.email_address.in_('jack@google.com', 'j25@yahoo.com')
+ ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com'])
... ).count()
SELECT count(addresses.id)
FROM addresses
@@ -913,7 +913,7 @@ Now when we load Jack, removing an address from his `addresses` collection will
# only one address remains
{sql}>>> session.query(Address).filter(
- ... Address.email_address.in_('jack@google.com', 'j25@yahoo.com')
+ ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com'])
... ).count()
DELETE FROM addresses WHERE addresses.id = ?
[2]
@@ -945,7 +945,7 @@ Deleting Jack will delete both Jack and his remaining `Address`:
{stop}0
{sql}>>> session.query(Address).filter(
- ... Address.email_address.in_('jack@google.com', 'j25@yahoo.com')
+ ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com'])
... ).count()
SELECT count(addresses.id)
FROM addresses
diff --git a/doc/build/content/tutorial.txt b/doc/build/content/tutorial.txt
index 702cf859a..57e85eb4a 100644
--- a/doc/build/content/tutorial.txt
+++ b/doc/build/content/tutorial.txt
@@ -505,7 +505,7 @@ Below, we create a session with `autoflush=True`, which implies that it's transa
>>> metadata.bind.echo = False
>>> session = create_session(autoflush=True)
>>> (ed, harry, mary) = session.query(User).filter(
- ... User.c.user_name.in_('Ed', 'Harry', 'Mary')
+ ... User.c.user_name.in_(['Ed', 'Harry', 'Mary'])
... ).order_by(User.c.user_name).all() # doctest: +NORMALIZE_WHITESPACE
>>> del mary.addresses[1]
>>> harry_address = Address('harry2@gmail.com')
diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index 90c670ce3..73e23cc92 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -1222,24 +1222,30 @@ class _CompareMixin(ColumnOperators):
return self._in_impl(operators.in_op, operators.notin_op, *other)
def _in_impl(self, op, negate_op, *other):
- if len(other) == 0:
- return _Grouping(case([(self.__eq__(None), text('NULL'))], else_=text('0')).__eq__(text('1')))
- elif len(other) == 1:
- o = other[0]
- if _is_literal(o) or isinstance( o, _CompareMixin):
- return self.__eq__( o) #single item -> ==
- else:
- assert isinstance(o, Selectable)
- return self.__compare( op, o, negate=negate_op) #single selectable
-
+ # Handle old style *args argument passing
+ if len(other) != 1 or not isinstance(other[0], Selectable) and (not hasattr(other[0], '__iter__') or isinstance(other[0], basestring)):
+ util.warn_deprecated('passing in_ arguments as varargs is deprecated, in_ takes a single argument that is a sequence or a selectable')
+ seq_or_selectable = other
+ else:
+ seq_or_selectable = other[0]
+
+ if isinstance(seq_or_selectable, Selectable):
+ return self.__compare( op, seq_or_selectable, negate=negate_op)
+
+ # Handle non selectable arguments as sequences
args = []
- for o in other:
+ for o in seq_or_selectable:
if not _is_literal(o):
if not isinstance( o, _CompareMixin):
- raise exceptions.InvalidRequestError( "in() function accepts either non-selectable values, or a single selectable: "+repr(o) )
+ raise exceptions.InvalidRequestError( "in() function accepts either a list of non-selectable values, or a selectable: "+repr(o) )
else:
o = self._bind_param(o)
args.append(o)
+
+ if len(args) == 0:
+ # Special case handling for empty IN's
+ return _Grouping(case([(self.__eq__(None), text('NULL'))], else_=text('0')).__eq__(text('1')))
+
return self.__compare(op, ClauseList(*args).self_group(against=op), negate=negate_op)
def startswith(self, other):
diff --git a/test/dialect/mssql.py b/test/dialect/mssql.py
index eeadde2ff..b750e8ecd 100755
--- a/test/dialect/mssql.py
+++ b/test/dialect/mssql.py
@@ -36,8 +36,8 @@ class CompileTest(SQLCompileTest):
column('col4'))
(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'])
self.assert_compile(u, "SELECT t1.col3 AS col3, t1.col4 AS col4 FROM t1 WHERE t1.col2 IN (:t1_col2, :t1_col2_1) UNION SELECT t2.col3 AS col3, t2.col4 AS col4 FROM t2 WHERE t2.col2 IN (:t2_col2, :t2_col2_1) ORDER BY col3, col4")
diff --git a/test/engine/transaction.py b/test/engine/transaction.py
index 6a5383b8c..4c7c5ec04 100644
--- a/test/engine/transaction.py
+++ b/test/engine/transaction.py
@@ -670,7 +670,7 @@ class ForUpdateTest(PersistTest):
def overlap(self, ids, errors, update_style):
sel = counters.select(for_update=update_style,
- whereclause=counters.c.counter_id.in_(*ids))
+ whereclause=counters.c.counter_id.in_(ids))
con = testbase.db.connect()
trans = con.begin()
try:
diff --git a/test/orm/cascade.py b/test/orm/cascade.py
index d703642b7..8ab27c2b2 100644
--- a/test/orm/cascade.py
+++ b/test/orm/cascade.py
@@ -123,10 +123,10 @@ class O2MCascadeTest(AssertMixin):
sess.delete(l[2])
sess.flush()
- assert tables.orders.count(tables.orders.c.user_id.in_(*ids)).scalar() == 0
- assert tables.orderitems.count(tables.orders.c.user_id.in_(*ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 0
- assert tables.addresses.count(tables.addresses.c.user_id.in_(*ids)).scalar() == 0
- assert tables.users.count(tables.users.c.user_id.in_(*ids)).scalar() == 0
+ assert tables.orders.count(tables.orders.c.user_id.in_(ids)).scalar() == 0
+ assert tables.orderitems.count(tables.orders.c.user_id.in_(ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 0
+ assert tables.addresses.count(tables.addresses.c.user_id.in_(ids)).scalar() == 0
+ assert tables.users.count(tables.users.c.user_id.in_(ids)).scalar() == 0
def testdelete2(self):
"""test that unloaded collections are still included in a delete-cascade by default."""
@@ -166,13 +166,13 @@ class O2MCascadeTest(AssertMixin):
jack.orders[:] = []
ids = [jack.user_id]
- self.assert_(tables.orders.count(tables.orders.c.user_id.in_(*ids)).scalar() == 1)
- self.assert_(tables.orderitems.count(tables.orders.c.user_id.in_(*ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 2)
+ self.assert_(tables.orders.count(tables.orders.c.user_id.in_(ids)).scalar() == 1)
+ self.assert_(tables.orderitems.count(tables.orders.c.user_id.in_(ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 2)
sess.flush()
- self.assert_(tables.orders.count(tables.orders.c.user_id.in_(*ids)).scalar() == 0)
- self.assert_(tables.orderitems.count(tables.orders.c.user_id.in_(*ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 0)
+ self.assert_(tables.orders.count(tables.orders.c.user_id.in_(ids)).scalar() == 0)
+ self.assert_(tables.orderitems.count(tables.orders.c.user_id.in_(ids) &(tables.orderitems.c.order_id==tables.orders.c.order_id)).scalar() == 0)
class M2OCascadeTest(AssertMixin):
diff --git a/test/orm/dynamic.py b/test/orm/dynamic.py
index cd20ef005..1c294f4fc 100644
--- a/test/orm/dynamic.py
+++ b/test/orm/dynamic.py
@@ -102,7 +102,7 @@ class FlushTest(FixtureTest):
except TypeError, e:
assert "doesn't support item deletion" in str(e), str(e)
- for a in u.addresses.filter(Address.email_address.in_('c', 'e', 'f')):
+ for a in u.addresses.filter(Address.email_address.in_(['c', 'e', 'f'])):
u.addresses.remove(a)
assert [Address(email_address='a'), Address(email_address='b'), Address(email_address='d')] == list(u.addresses)
diff --git a/test/orm/eager_relations.py b/test/orm/eager_relations.py
index c1aa0e9ef..7ecae957e 100644
--- a/test/orm/eager_relations.py
+++ b/test/orm/eager_relations.py
@@ -442,7 +442,7 @@ class EagerTest(QueryTest):
Order(id=4, user=User(id=9))
] == q.all()
- q = q.select_from(s.join(order_items).join(items)).filter(~Item.id.in_(1, 2, 5))
+ q = q.select_from(s.join(order_items).join(items)).filter(~Item.id.in_([1, 2, 5]))
assert [
Order(id=3, user=User(id=7)),
] == q.all()
diff --git a/test/orm/inheritance/poly_linked_list.py b/test/orm/inheritance/poly_linked_list.py
index 7297002f5..a7f15d3bc 100644
--- a/test/orm/inheritance/poly_linked_list.py
+++ b/test/orm/inheritance/poly_linked_list.py
@@ -33,7 +33,7 @@ class PolymorphicCircularTest(ORMTest):
# {
# 'table3' : table1.join(table3),
# 'table2' : table1.join(table2),
- # 'table1' : table1.select(table1.c.type.in_('table1', 'table1b')),
+ # 'table1' : table1.select(table1.c.type.in_(['table1', 'table1b'])),
# }, None, 'pjoin')
join = table1.outerjoin(table2).outerjoin(table3).alias('pjoin')
diff --git a/test/orm/inheritance/polymorph2.py b/test/orm/inheritance/polymorph2.py
index a58800c56..6acb75dd9 100644
--- a/test/orm/inheritance/polymorph2.py
+++ b/test/orm/inheritance/polymorph2.py
@@ -730,7 +730,7 @@ class GenerativeTest(AssertMixin):
for x in range(0, 2):
r = session.query(Person).filter(people.c.name.like('%2')).join('status').filter_by(name="active")
assert str(list(r)) == "[Manager M2, category YYYYYYYYY, status Status active, Engineer E2, field X, status Status active]"
- r = session.query(Engineer).join('status').filter(people.c.name.in_('E2', 'E3', 'E4', 'M4', 'M2', 'M1') & (status.c.name=="active"))
+ r = session.query(Engineer).join('status').filter(people.c.name.in_(['E2', 'E3', 'E4', 'M4', 'M2', 'M1']) & (status.c.name=="active"))
assert str(list(r)) == "[Engineer E2, field X, status Status active, Engineer E3, field X, status Status active]"
# this test embeds the original polymorphic union (employee_join) fully
# into the WHERE criterion, using a correlated select. ticket #577 tracks
diff --git a/test/orm/mapper.py b/test/orm/mapper.py
index e723f968d..ad32c9d31 100644
--- a/test/orm/mapper.py
+++ b/test/orm/mapper.py
@@ -424,7 +424,7 @@ class MapperTest(MapperSuperTest):
mapper(User, users)
q = create_session().query(User)
self.assert_(q.count()==3)
- self.assert_(q.count(users.c.user_id.in_(8,9))==2)
+ self.assert_(q.count(users.c.user_id.in_([8,9]))==2)
self.assert_(q.count_by(user_name='fred')==1)
def testmanytomany_count(self):
diff --git a/test/orm/query.py b/test/orm/query.py
index 547c7ce88..f96d6fc43 100644
--- a/test/orm/query.py
+++ b/test/orm/query.py
@@ -208,7 +208,7 @@ class OperatorTest(QueryTest):
fwd_sql + "'\n or\n'" + rev_sql + "'")
def test_in(self):
- self._test(User.id.in_('a', 'b'),
+ self._test(User.id.in_(['a', 'b']),
"users.id IN (:users_id, :users_id_1)")
def test_between(self):
@@ -333,12 +333,12 @@ class FilterTest(QueryTest):
class AggregateTest(QueryTest):
def test_sum(self):
sess = create_session()
- orders = sess.query(Order).filter(Order.id.in_(2, 3, 4))
+ orders = sess.query(Order).filter(Order.id.in_([2, 3, 4]))
assert orders.sum(Order.user_id * Order.address_id) == 79
def test_apply(self):
sess = create_session()
- assert sess.query(Order).apply_sum(Order.user_id * Order.address_id).filter(Order.id.in_(2, 3, 4)).one() == 79
+ assert sess.query(Order).apply_sum(Order.user_id * Order.address_id).filter(Order.id.in_([2, 3, 4])).one() == 79
class CountTest(QueryTest):
@@ -428,10 +428,10 @@ class JoinTest(QueryTest):
def test_overlap_with_aliases(self):
oalias = orders.alias('oalias')
- result = create_session().query(User).select_from(users.join(oalias)).filter(oalias.c.description.in_("order 1", "order 2", "order 3")).join(['orders', 'items']).all()
+ result = create_session().query(User).select_from(users.join(oalias)).filter(oalias.c.description.in_(["order 1", "order 2", "order 3"])).join(['orders', 'items']).all()
assert [User(id=7, name='jack'), User(id=9, name='fred')] == result
- result = create_session().query(User).select_from(users.join(oalias)).filter(oalias.c.description.in_("order 1", "order 2", "order 3")).join(['orders', 'items']).filter_by(id=4).all()
+ result = create_session().query(User).select_from(users.join(oalias)).filter(oalias.c.description.in_(["order 1", "order 2", "order 3"])).join(['orders', 'items']).filter_by(id=4).all()
assert [User(id=7, name='jack')] == result
def test_aliased(self):
diff --git a/test/orm/sharding/shard.py b/test/orm/sharding/shard.py
index c63a29e80..7255155fa 100644
--- a/test/orm/sharding/shard.py
+++ b/test/orm/sharding/shard.py
@@ -152,7 +152,7 @@ class ShardTest(PersistTest):
north_american_cities = sess.query(WeatherLocation).filter(WeatherLocation.continent == 'North America')
assert set([c.city for c in north_american_cities]) == set(['New York', 'Toronto'])
- asia_and_europe = sess.query(WeatherLocation).filter(WeatherLocation.continent.in_('Europe', 'Asia'))
+ asia_and_europe = sess.query(WeatherLocation).filter(WeatherLocation.continent.in_(['Europe', 'Asia']))
assert set([c.city for c in asia_and_europe]) == set(['Tokyo', 'London', 'Dublin'])
diff --git a/test/orm/unitofwork.py b/test/orm/unitofwork.py
index d1011068b..8adf1a980 100644
--- a/test/orm/unitofwork.py
+++ b/test/orm/unitofwork.py
@@ -804,9 +804,9 @@ class OneToManyTest(ORMTest):
print repr(u.addresses)
Session.commit()
- usertable = users.select(users.c.user_id.in_(u.user_id)).execute().fetchall()
+ usertable = users.select(users.c.user_id.in_([u.user_id])).execute().fetchall()
self.assertEqual(usertable[0].values(), [u.user_id, 'one2manytester'])
- addresstable = addresses.select(addresses.c.address_id.in_(a.address_id, a2.address_id), order_by=[addresses.c.email_address]).execute().fetchall()
+ addresstable = addresses.select(addresses.c.address_id.in_([a.address_id, a2.address_id]), order_by=[addresses.c.email_address]).execute().fetchall()
self.assertEqual(addresstable[0].values(), [a2.address_id, u.user_id, 'lala@test.org'])
self.assertEqual(addresstable[1].values(), [a.address_id, u.user_id, 'one2many@test.org'])
@@ -1034,7 +1034,7 @@ class SaveTest(ORMTest):
# select both
#Session.close()
- userlist = User.query.filter(users.c.user_id.in_(u.user_id, u2.user_id)).order_by([users.c.user_name]).all()
+ userlist = User.query.filter(users.c.user_id.in_([u.user_id, u2.user_id])).order_by([users.c.user_name]).all()
print repr(u.user_id), repr(userlist[0].user_id), repr(userlist[0].user_name)
self.assert_(u.user_id == userlist[0].user_id and userlist[0].user_name == 'modifiedname')
self.assert_(u2.user_id == userlist[1].user_id and userlist[1].user_name == 'savetester2')
@@ -1126,18 +1126,18 @@ class SaveTest(ORMTest):
u = Session.get(User, id)
assert u.user_name == 'multitester'
- usertable = users.select(users.c.user_id.in_(u.foo_id)).execute().fetchall()
+ usertable = users.select(users.c.user_id.in_([u.foo_id])).execute().fetchall()
self.assertEqual(usertable[0].values(), [u.foo_id, 'multitester'])
- addresstable = addresses.select(addresses.c.address_id.in_(u.address_id)).execute().fetchall()
+ addresstable = addresses.select(addresses.c.address_id.in_([u.address_id])).execute().fetchall()
self.assertEqual(addresstable[0].values(), [u.address_id, u.foo_id, 'multi@test.org'])
u.email = 'lala@hey.com'
u.user_name = 'imnew'
Session.commit()
- usertable = users.select(users.c.user_id.in_(u.foo_id)).execute().fetchall()
+ usertable = users.select(users.c.user_id.in_([u.foo_id])).execute().fetchall()
self.assertEqual(usertable[0].values(), [u.foo_id, 'imnew'])
- addresstable = addresses.select(addresses.c.address_id.in_(u.address_id)).execute().fetchall()
+ addresstable = addresses.select(addresses.c.address_id.in_([u.address_id])).execute().fetchall()
self.assertEqual(addresstable[0].values(), [u.address_id, u.foo_id, 'lala@hey.com'])
Session.close()
@@ -1390,7 +1390,7 @@ class ManyToManyTest(ORMTest):
item.item_name = elem['item_name']
item.keywords = []
if elem['keywords'][1]:
- klist = Session.query(keywordmapper).select(keywords.c.name.in_(*[e['name'] for e in elem['keywords'][1]]))
+ klist = Session.query(keywordmapper).select(keywords.c.name.in_([e['name'] for e in elem['keywords'][1]]))
else:
klist = []
khash = {}
@@ -1406,7 +1406,7 @@ class ManyToManyTest(ORMTest):
Session.commit()
- l = Session.query(m).select(items.c.item_name.in_(*[e['item_name'] for e in data[1:]]), order_by=[items.c.item_name])
+ l = Session.query(m).select(items.c.item_name.in_([e['item_name'] for e in data[1:]]), order_by=[items.c.item_name])
self.assert_result(l, *data)
objects[4].item_name = 'item4updated'
@@ -1588,7 +1588,7 @@ class ManyToManyTest(ORMTest):
Session.commit()
Session.close()
- l = Item.query.filter(items.c.item_name.in_(*[e['item_name'] for e in data[1:]])).order_by(items.c.item_name).all()
+ l = Item.query.filter(items.c.item_name.in_([e['item_name'] for e in data[1:]])).order_by(items.c.item_name).all()
self.assert_result(l, *data)
class SaveTest2(ORMTest):
diff --git a/test/perf/ormsession.py b/test/perf/ormsession.py
index a9d310ef6..3cd21ea98 100644
--- a/test/perf/ormsession.py
+++ b/test/perf/ormsession.py
@@ -174,7 +174,7 @@ def run_queries():
order_by=[desc(func.count(_item_id)), _item_id],
limit=20)
ids = [r.id for r in top_20_q.execute().fetchall()]
- q2 = session.query(Item).filter(Item.id.in_(*ids))
+ q2 = session.query(Item).filter(Item.id.in_(ids))
for num, item in enumerate(q2):
report.append("number %s: %s" % (num + 1, item.name))
@@ -189,7 +189,7 @@ def create_purchase():
session.begin()
customer = session.query(Customer).get(customer_id)
- items = session.query(Item).filter(Item.id.in_(*item_ids))
+ items = session.query(Item).filter(Item.id.in_(item_ids))
purchase = Purchase()
purchase.customer = customer
diff --git a/test/profiling/zoomark.py b/test/profiling/zoomark.py
index 4d73e92b6..5c22fd9d8 100644
--- a/test/profiling/zoomark.py
+++ b/test/profiling/zoomark.py
@@ -176,13 +176,13 @@ class ZooMarkTest(testing.AssertMixin):
# In operator (containedby)
assert len(fulltable(Animal.select(Animal.c.Species.like('%pede%')))) == 2
- assert len(fulltable(Animal.select(Animal.c.Species.in_('Lion', 'Tiger', 'Bear')))) == 3
+ assert len(fulltable(Animal.select(Animal.c.Species.in_(['Lion', 'Tiger', 'Bear'])))) == 3
# Try In with cell references
class thing(object): pass
pet, pet2 = thing(), thing()
pet.Name, pet2.Name = 'Slug', 'Ostrich'
- assert len(fulltable(Animal.select(Animal.c.Species.in_(pet.Name, pet2.Name)))) == 2
+ assert len(fulltable(Animal.select(Animal.c.Species.in_([pet.Name, pet2.Name])))) == 2
# logic and other functions
assert len(fulltable(Animal.select(Animal.c.Species.like('Slug')))) == 1
diff --git a/test/sql/query.py b/test/sql/query.py
index 77e1421a5..ba29d6a8f 100644
--- a/test/sql/query.py
+++ b/test/sql/query.py
@@ -597,46 +597,46 @@ class QueryTest(PersistTest):
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_())
+ s = users.select(users.c.user_name.in_([]))
r = s.execute().fetchall()
# No username is in empty set
assert len(r) == 0
- s = users.select(not_(users.c.user_name.in_()))
+ s = users.select(not_(users.c.user_name.in_([])))
r = s.execute().fetchall()
# All usernames with a value are outside an empty set
assert len(r) == 2
- 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
u = bindparam('search_key')
- s = users.select(u.in_())
+ s = users.select(u.in_([]))
r = s.execute(search_key='john').fetchall()
assert len(r) == 0
r = s.execute(search_key=None).fetchall()
assert len(r) == 0
- s = users.select(not_(u.in_()))
+ s = users.select(not_(u.in_([])))
r = s.execute(search_key='john').fetchall()
assert len(r) == 3
r = s.execute(search_key=None).fetchall()
assert len(r) == 0
- s = users.select(users.c.user_name.in_() == True)
+ s = users.select(users.c.user_name.in_([]) == True)
r = s.execute().fetchall()
assert len(r) == 0
- s = users.select(users.c.user_name.in_() == False)
+ s = users.select(users.c.user_name.in_([]) == False)
r = s.execute().fetchall()
assert len(r) == 2
- s = users.select(users.c.user_name.in_() == None)
+ s = users.select(users.c.user_name.in_([]) == None)
r = s.execute().fetchall()
assert len(r) == 1
@@ -690,9 +690,9 @@ class CompoundTest(PersistTest):
def test_union(self):
(s1, s2) = (
select([t1.c.col3.label('col3'), t1.c.col4.label('col4')],
- t1.c.col2.in_("t1col2r1", "t1col2r2")),
+ t1.c.col2.in_(["t1col2r1", "t1col2r2"])),
select([t2.c.col3.label('col3'), t2.c.col4.label('col4')],
- t2.c.col2.in_("t2col2r2", "t2col2r3"))
+ t2.c.col2.in_(["t2col2r2", "t2col2r3"]))
)
u = union(s1, s2)
@@ -707,9 +707,9 @@ class CompoundTest(PersistTest):
def test_union_ordered(self):
(s1, s2) = (
select([t1.c.col3.label('col3'), t1.c.col4.label('col4')],
- t1.c.col2.in_("t1col2r1", "t1col2r2")),
+ t1.c.col2.in_(["t1col2r1", "t1col2r2"])),
select([t2.c.col3.label('col3'), t2.c.col4.label('col4')],
- t2.c.col2.in_("t2col2r2", "t2col2r3"))
+ t2.c.col2.in_(["t2col2r2", "t2col2r3"]))
)
u = union(s1, s2, order_by=['col3', 'col4'])
@@ -720,9 +720,9 @@ class CompoundTest(PersistTest):
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")),
+ t1.c.col2.in_(["t1col2r1", "t1col2r2"])),
select([t2.c.col3.label('col3'), t2.c.col4.label('col4')],
- t2.c.col2.in_("t2col2r2", "t2col2r3"))
+ t2.c.col2.in_(["t2col2r2", "t2col2r3"]))
)
u = union(s1, s2, order_by=['col3', 'col4'])
diff --git a/test/sql/select.py b/test/sql/select.py
index 8096b0c97..5c8b570d7 100644
--- a/test/sql/select.py
+++ b/test/sql/select.py
@@ -946,58 +946,61 @@ EXISTS (select yay from foo where boo = lar)",
assert [str(c) for c in s.c] == ["id", "hoho"]
def testin(self):
- self.assert_compile(select([table1], table1.c.myid.in_('a')),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :mytable_myid")
+ self.assert_compile(select([table1], table1.c.myid.in_(['a'])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid)")
- self.assert_compile(select([table1], ~table1.c.myid.in_('a')),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid != :mytable_myid")
+ self.assert_compile(select([table1], ~table1.c.myid.in_(['a'])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid NOT IN (:mytable_myid)")
- self.assert_compile(select([table1], table1.c.myid.in_('a', 'b')),
+ self.assert_compile(select([table1], table1.c.myid.in_(['a', 'b'])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :mytable_myid_1)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a'))),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :literal")
+ self.assert_compile(select([table1], table1.c.myid.in_(iter(['a', 'b']))),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :mytable_myid_1)")
+
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a')])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a'), 'b')),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a'), 'b'])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal, :mytable_myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a'), literal('b'))),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a'), literal('b')])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal, :literal_1)")
- self.assert_compile(select([table1], table1.c.myid.in_('a', literal('b'))),
+ self.assert_compile(select([table1], table1.c.myid.in_(['a', literal('b')])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :literal)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal(1) + 'a')),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = :literal + :literal_1")
+ self.assert_compile(select([table1], table1.c.myid.in_([literal(1) + 'a'])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal + :literal_1)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a') +'a', 'b')),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a') +'a', 'b'])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal || :literal_1, :mytable_myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a') + literal('a'), literal('b'))),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a') + literal('a'), literal('b')])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal || :literal_1, :literal_2)")
- self.assert_compile(select([table1], table1.c.myid.in_(1, literal(3) + 4)),
+ self.assert_compile(select([table1], table1.c.myid.in_([1, literal(3) + 4])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :literal + :literal_1)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a') < 'b')),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = (:literal < :literal_1)")
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a') < 'b'])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal < :literal_1)")
- self.assert_compile(select([table1], table1.c.myid.in_(table1.c.myid)),
- "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid = mytable.myid")
+ self.assert_compile(select([table1], table1.c.myid.in_([table1.c.myid])),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (mytable.myid)")
- self.assert_compile(select([table1], table1.c.myid.in_('a', table1.c.myid)),
+ self.assert_compile(select([table1], table1.c.myid.in_(['a', table1.c.myid])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, mytable.myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a'), table1.c.myid)),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a'), table1.c.myid])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal, mytable.myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal('a'), table1.c.myid +'a')),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal('a'), table1.c.myid +'a'])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal, mytable.myid + :mytable_myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(literal(1), 'a' + table1.c.myid)),
+ self.assert_compile(select([table1], table1.c.myid.in_([literal(1), 'a' + table1.c.myid])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:literal, :mytable_myid + mytable.myid)")
- self.assert_compile(select([table1], table1.c.myid.in_(1, 2, 3)),
+ self.assert_compile(select([table1], table1.c.myid.in_([1, 2, 3])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :mytable_myid_1, :mytable_myid_2)")
self.assert_compile(select([table1], table1.c.myid.in_(select([table2.c.otherid]))),
@@ -1028,9 +1031,21 @@ UNION SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE
)
# test empty in clause
- self.assert_compile(select([table1], table1.c.myid.in_()),
+ self.assert_compile(select([table1], table1.c.myid.in_([])),
"SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE (CASE WHEN (mytable.myid IS NULL) THEN NULL ELSE 0 END = 1)")
+ def test_in_deprecated_api(self):
+ self.assert_compile(select([table1], table1.c.myid.in_('abc')),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid)")
+
+ self.assert_compile(select([table1], table1.c.myid.in_(1)),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid)")
+
+ self.assert_compile(select([table1], table1.c.myid.in_(1,2)),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE mytable.myid IN (:mytable_myid, :mytable_myid_1)")
+
+ self.assert_compile(select([table1], table1.c.myid.in_()),
+ "SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE (CASE WHEN (mytable.myid IS NULL) THEN NULL ELSE 0 END = 1)")
def testcast(self):
tbl = table('casttest',
@@ -1081,9 +1096,9 @@ UNION SELECT mytable.myid, mytable.name, mytable.description FROM mytable WHERE
"SELECT op.field FROM op WHERE (op.field + :op_field) * :literal")
self.assert_compile(table.select((table.c.field * 5) + 6),
"SELECT op.field FROM op WHERE op.field * :op_field + :literal")
- self.assert_compile(table.select(5 + table.c.field.in_(5,6)),
+ self.assert_compile(table.select(5 + table.c.field.in_([5,6])),
"SELECT op.field FROM op WHERE :literal + (op.field IN (:op_field, :op_field_1))")
- self.assert_compile(table.select((5 + table.c.field).in_(5,6)),
+ self.assert_compile(table.select((5 + table.c.field).in_([5,6])),
"SELECT op.field FROM op WHERE :op_field + op.field IN (:literal, :literal_1)")
self.assert_compile(table.select(not_(and_(table.c.field == 5, table.c.field == 7))),
"SELECT op.field FROM op WHERE NOT (op.field = :op_field AND op.field = :op_field_1)")
View Lorry Controller Status