the string "field" argument was getting treated as a
ClauseElement, causing various errors within more
complex SQL transformations.
+
+ - Unary expressions such as DISTINCT propagate their
+ type handling to result sets, allowing conversions like
+ unicode and such to take place. [ticket:1420]
+
- ext
- The collection proxies produced by associationproxy are now
pickleable. A user-defined proxy_factory however
else:
return text
- def visit_unary(self, unary, **kwargs):
- s = self.process(unary.element)
+ def visit_unary(self, unary, **kw):
+ s = self.process(unary.element, **kw)
if unary.operator:
s = self.operator_string(unary.operator) + " " + s
if unary.modifier:
def distinct(expr):
"""Return a ``DISTINCT`` clause."""
-
- return _UnaryExpression(expr, operator=operators.distinct_op)
+ expr = _literal_as_binds(expr)
+ return _UnaryExpression(expr, operator=operators.distinct_op, type_=expr.type)
def between(ctest, cleft, cright):
"""Return a ``BETWEEN`` predicate clause.
def distinct(self):
"""Produce a DISTINCT clause, i.e. ``DISTINCT <columnname>``"""
-
- return _UnaryExpression(self, operator=operators.distinct_op)
+ return _UnaryExpression(self, operator=operators.distinct_op, type_=self.type)
def between(self, cleft, cright):
"""Produce a BETWEEN clause, i.e. ``<column> BETWEEN <cleft> AND <cright>``"""
self.assert_(r['query_users.user_id']) == 1
self.assert_(r['query_users.user_name']) == "john"
+ # unary experssions
+ r = select([users.c.user_name.distinct()]).order_by(users.c.user_name).execute().fetchone()
+ eq_(r[users.c.user_name], 'jack')
+ eq_(r.user_name, 'jack')
+ r.close()
+
+
def test_row_as_args(self):
users.insert().execute(user_id=1, user_name='john')
r = users.select(users.c.user_id==1).execute().fetchone()
# this one relies upon anonymous labeling to assemble result
# processing rules on the column.
assert testing.db.execute(select([expr])).scalar() == -15
+
+ def test_distinct(self):
+ s = select([distinct(test_table.c.avalue)])
+ eq_(testing.db.execute(s).scalar(), 25)
+
+ s = select([test_table.c.avalue.distinct()])
+ eq_(testing.db.execute(s).scalar(), 25)
+
+ assert distinct(test_table.c.data).type == test_table.c.data.type
+ assert test_table.c.data.distinct().type == test_table.c.data.type
class DateTest(TestBase, AssertsExecutionResults):
@classmethod