From 3b4bbbb2a3d337d0af1ba5ccb0d29d1c48735e83 Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Sat, 15 Aug 2020 15:08:09 -0400 Subject: Create a real type for Tuple() and handle appropriately in compiler Improved the :func:`_sql.tuple_` construct such that it behaves predictably when used in a columns-clause context. The SQL tuple is not supported as a "SELECT" columns clause element on most backends; on those that do (PostgreSQL, not surprisingly), the Python DBAPI does not have a "nested type" concept so there are still challenges in fetching rows for such an object. Use of :func:`_sql.tuple_` in a :func:`_sql.select` or :class:`_orm.Query` will now raise a :class:`_exc.CompileError` at the point at which the :func:`_sql.tuple_` object is seen as presenting itself for fetching rows (i.e., if the tuple is in the columns clause of a subquery, no error is raised). For ORM use,the :class:`_orm.Bundle` object is an explicit directive that a series of columns should be returned as a sub-tuple per row and is suggested by the error message. Additionally ,the tuple will now render with parenthesis in all contexts. Previously, the parenthesization would not render in a columns context leading to non-defined behavior. As part of this change, Tuple receives a dedicated datatype which appears to allow us the very desirable change of removing the bindparam._expanding_in_types attribute as well as ClauseList._tuple_values (which might already have not been needed due to #4645). Fixes: #5127 Change-Id: Iecafa0e0aac2f1f37ec8d0e1631d562611c90200 --- lib/sqlalchemy/dialects/postgresql/array.py | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) (limited to 'lib/sqlalchemy/dialects/postgresql/array.py') diff --git a/lib/sqlalchemy/dialects/postgresql/array.py b/lib/sqlalchemy/dialects/postgresql/array.py index 84fbd2e50..7fd271d52 100644 --- a/lib/sqlalchemy/dialects/postgresql/array.py +++ b/lib/sqlalchemy/dialects/postgresql/array.py @@ -9,8 +9,10 @@ import re from ... import types as sqltypes from ... import util +from ...sql import coercions from ...sql import expression from ...sql import operators +from ...sql import roles def Any(other, arrexpr, operator=operators.eq): @@ -41,7 +43,7 @@ def All(other, arrexpr, operator=operators.eq): return arrexpr.all(other, operator) -class array(expression.Tuple): +class array(expression.ClauseList, expression.ColumnElement): """A PostgreSQL ARRAY literal. @@ -97,16 +99,31 @@ class array(expression.Tuple): __visit_name__ = "array" def __init__(self, clauses, **kw): + clauses = [ + coercions.expect(roles.ExpressionElementRole, c) for c in clauses + ] + super(array, self).__init__(*clauses, **kw) - if isinstance(self.type, ARRAY): + + self._type_tuple = [arg.type for arg in clauses] + main_type = kw.pop( + "type_", + self._type_tuple[0] if self._type_tuple else sqltypes.NULLTYPE, + ) + + if isinstance(main_type, ARRAY): self.type = ARRAY( - self.type.item_type, - dimensions=self.type.dimensions + 1 - if self.type.dimensions is not None + main_type.item_type, + dimensions=main_type.dimensions + 1 + if main_type.dimensions is not None else 2, ) else: - self.type = ARRAY(self.type) + self.type = ARRAY(main_type) + + @property + def _select_iterable(self): + return (self,) def _bind_param(self, operator, obj, _assume_scalar=False, type_=None): if _assume_scalar or operator is operators.getitem: -- cgit v1.2.1