- [feature] The Core oeprator system now includes

the `getitem` operator, i.e. the bracket
operator in Python.  This is used at first
to provide index and slice behavior to the
Postgresql ARRAY type, and also provides a hook
for end-user definition of custom __getitem__
schemes which can be applied at the type
level as well as within ORM-level custom
operator schemes.

Note that this change has the effect that
descriptor-based __getitem__ schemes used by
the ORM in conjunction with synonym() or other
"descriptor-wrapped" schemes will need
to start using a custom comparator in order
to maintain this behavior.

- [feature] postgresql.ARRAY now supports
indexing and slicing.  The Python [] operator
is available on all SQL expressions that are
of type ARRAY; integer or simple slices can be
passed.  The slices can also be used on the
assignment side in the SET clause of an UPDATE
statement by passing them into Update.values();
see the docs for examples.

- [feature] Added new "array literal" construct
postgresql.array().  Basically a "tuple" that
renders as ARRAY[1,2,3].

1 files changed, 17 insertions, 4 deletions

diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index d02710d9f..41f4910a7 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -1404,7 +1404,10 @@ def _column_as_key(element):
         return element
     if hasattr(element, '__clause_element__'):
         element = element.__clause_element__()
-    return element.key
+    try:
+        return element.key
+    except AttributeError:
+        return None
 
 def _clause_element_as_expr(element):
     if hasattr(element, '__clause_element__'):
@@ -1940,7 +1943,7 @@ class _DefaultColumnComparator(operators.ColumnOperators):
                             type_=sqltypes.BOOLEANTYPE,
                             negate=negate, modifiers=kwargs)
 
-    def _binary_operate(self, expr, op, obj, reverse=False):
+    def _binary_operate(self, expr, op, obj, reverse=False, result_type=None):
         obj = self._check_literal(expr, op, obj)
 
         if reverse:
@@ -1948,7 +1951,9 @@ class _DefaultColumnComparator(operators.ColumnOperators):
         else:
             left, right = expr, obj
 
-        op, result_type = left.comparator._adapt_expression(op, right.comparator)
+        if result_type is None:
+            op, result_type = left.comparator._adapt_expression(
+                                                op, right.comparator)
 
         return BinaryExpression(left, right, op, type_=result_type)
 
@@ -2005,6 +2010,11 @@ class _DefaultColumnComparator(operators.ColumnOperators):
         return self._boolean_compare(expr, op,
                               ClauseList(*args).self_group(against=op),
                               negate=negate_op)
+
+    def _unsupported_impl(self, expr, op, *arg, **kw):
+        raise NotImplementedError("Operator '%s' is not supported on "
+                            "this expression" % op.__name__)
+
     def _neg_impl(self, expr, op, **kw):
         """See :meth:`.ColumnOperators.__neg__`."""
         return UnaryExpression(expr, operator=operators.neg)
@@ -2097,6 +2107,7 @@ class _DefaultColumnComparator(operators.ColumnOperators):
         "startswith_op": (_startswith_impl,),
         "endswith_op": (_endswith_impl,),
         "neg": (_neg_impl,),
+        "getitem": (_unsupported_impl,),
     }
 
 
@@ -3260,8 +3271,10 @@ class Tuple(ClauseList, ColumnElement):
 
     def __init__(self, *clauses, **kw):
         clauses = [_literal_as_binds(c) for c in clauses]
+        self.type = kw.pop('type_', None)
+        if self.type is None:
+            self.type = _type_from_args(clauses)
         super(Tuple, self).__init__(*clauses, **kw)
-        self.type = _type_from_args(clauses)
 
     @property
     def _select_iterable(self):