- anonymous column expressions are automatically labeled.

    e.g. select([x* 5]) produces "SELECT x * 5 AS anon_1".
    This allows the labelname to be present in the cursor.description
    which can then be appropriately matched to result-column processing
    rules. (we can't reliably use positional tracking for result-column
    matches since text() expressions may represent multiple columns).

  - operator overloading is now controlled by TypeEngine objects - the
    one built-in operator overload so far is String types overloading
    '+' to be the string concatenation operator.
    User-defined types can also define their own operator overloading
    by overriding the adapt_operator(self, op) method.

  - untyped bind parameters on the right side of a binary expression
    will be assigned the type of the left side of the operation, to better
    enable the appropriate bind parameter processing to take effect
    [ticket:819]

7 files changed, 58 insertions, 35 deletions

diff --git a/lib/sqlalchemy/databases/informix.py b/lib/sqlalchemy/databases/informix.py
index 741641afc..247ab2d41 100644
--- a/lib/sqlalchemy/databases/informix.py
+++ b/lib/sqlalchemy/databases/informix.py
@@ -410,6 +410,7 @@ class InfoCompiler(compiler.DefaultCompiler):
         return ""
 
     def __visit_label(self, label):
+        # TODO: whats this method for ?
         if self.select_stack:
             self.typemap.setdefault(label.name.lower(), label.obj.type)
         if self.strings[label.obj]:
diff --git a/lib/sqlalchemy/databases/mssql.py b/lib/sqlalchemy/databases/mssql.py
index 38e8e1217..92b454f82 100644
--- a/lib/sqlalchemy/databases/mssql.py
+++ b/lib/sqlalchemy/databases/mssql.py
@@ -895,13 +895,13 @@ class MSSQLCompiler(compiler.DefaultCompiler):
         kwargs['mssql_aliased'] = True
         return super(MSSQLCompiler, self).visit_alias(alias, **kwargs)
 
-    def visit_column(self, column):
+    def visit_column(self, column, **kwargs):
         if column.table is not None and not self.isupdate and not self.isdelete:
             # translate for schema-qualified table aliases
             t = self._schema_aliased_table(column.table)
             if t is not None:
                 return self.process(t.corresponding_column(column))
-        return super(MSSQLCompiler, self).visit_column(column)
+        return super(MSSQLCompiler, self).visit_column(column, **kwargs)
 
     def visit_binary(self, binary):
         """Move bind parameters to the right-hand side of an operator, where possible."""
diff --git a/lib/sqlalchemy/databases/postgres.py b/lib/sqlalchemy/databases/postgres.py
index 00b297f97..88ac0e202 100644
--- a/lib/sqlalchemy/databases/postgres.py
+++ b/lib/sqlalchemy/databases/postgres.py
@@ -109,7 +109,7 @@ class PGBoolean(sqltypes.Boolean):
     def get_col_spec(self):
         return "BOOLEAN"
 
-class PGArray(sqltypes.TypeEngine, sqltypes.Concatenable):
+class PGArray(sqltypes.Concatenable, sqltypes.TypeEngine):
     def __init__(self, item_type):
         if isinstance(item_type, type):
             item_type = item_type()
diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index 013c5704b..859fb796e 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -1339,6 +1339,7 @@ class ResultProxy(object):
             for i, item in enumerate(metadata):
                 # sqlite possibly prepending table name to colnames so strip
                 colname = (item[0].split('.')[-1]).decode(self.dialect.encoding)
+
                 if self.context.typemap is not None:
                     type = self.context.typemap.get(colname.lower(), typemap.get(item[1], types.NULLTYPE))
                 else:
diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py
index 9c82cd4aa..140117069 100644
--- a/lib/sqlalchemy/sql/compiler.py
+++ b/lib/sqlalchemy/sql/compiler.py
@@ -213,17 +213,19 @@ class DefaultCompiler(engine.Compiled):
     def visit_grouping(self, grouping, **kwargs):
         return "(" + self.process(grouping.elem) + ")"
         
-    def visit_label(self, label):
+    def visit_label(self, label, typemap=None, column_labels=None):
         labelname = self._truncated_identifier("colident", label.name)
         
-        if len(self.stack) == 1 and self.stack[-1].get('select'):
+        if typemap is not None:
             self.typemap.setdefault(labelname.lower(), label.obj.type)
+            
+        if column_labels is not None:
             if isinstance(label.obj, sql._ColumnClause):
-                self.column_labels[label.obj._label] = labelname
-            self.column_labels[label.name] = labelname
+                column_labels[label.obj._label] = labelname
+            column_labels[label.name] = labelname
         return " ".join([self.process(label.obj), self.operator_string(operators.as_), self.preparer.format_label(label, labelname)])
         
-    def visit_column(self, column, **kwargs):
+    def visit_column(self, column, typemap=None, column_labels=None, **kwargs):
         # there is actually somewhat of a ruleset when you would *not* necessarily
         # want to truncate a column identifier, if its mapped to the name of a 
         # physical column.  but thats very hard to identify at this point, and 
@@ -234,10 +236,9 @@ class DefaultCompiler(engine.Compiled):
         else:
             name = column.name
 
-        if len(self.stack) == 1 and self.stack[-1].get('select'):
-            # if we are within a visit to a Select, set up the "typemap"
-            # for this column which is used to translate result set values
-            self.typemap.setdefault(name.lower(), column.type)
+        if typemap is not None:
+            typemap.setdefault(name.lower(), column.type)
+        if column_labels is not None:    
             self.column_labels.setdefault(column._label, name.lower())
         
         if column._is_oid:
@@ -303,15 +304,12 @@ class DefaultCompiler(engine.Compiled):
     def visit_calculatedclause(self, clause, **kwargs):
         return self.process(clause.clause_expr)
 
-    def visit_cast(self, cast, **kwargs):
-        if self.stack and self.stack[-1].get('select'):
-            # not sure if we want to set the typemap here...
-            self.typemap.setdefault("CAST", cast.type)
+    def visit_cast(self, cast, typemap=None, **kwargs):
         return "CAST(%s AS %s)" % (self.process(cast.clause), self.process(cast.typeclause))
 
-    def visit_function(self, func, **kwargs):
-        if self.stack and self.stack[-1].get('select'):
-            self.typemap.setdefault(func.name, func.type)
+    def visit_function(self, func, typemap=None, **kwargs):
+        if typemap is not None:
+            typemap.setdefault(func.name, func.type)
         if not self.apply_function_parens(func):
             return ".".join(func.packagenames + [func.name])
         else:
@@ -349,12 +347,14 @@ class DefaultCompiler(engine.Compiled):
             s = s + " " + self.operator_string(unary.modifier)
         return s
         
-    def visit_binary(self, binary, **kwargs):
+    def visit_binary(self, binary, typemap=None, **kwargs):
         op = self.operator_string(binary.operator)
         if callable(op):
             return op(self.process(binary.left), self.process(binary.right))
         else:
             return self.process(binary.left) + " " + op + " " + self.process(binary.right)
+            
+        return ret
         
     def operator_string(self, operator):
         return self.operators.get(operator, str(operator))
@@ -453,6 +453,8 @@ class DefaultCompiler(engine.Compiled):
             column.table is not None and \
             not isinstance(column.table, sql.Select):
             return column.label(column.name)
+        elif not isinstance(column, (sql._UnaryExpression, sql._TextClause)) and not hasattr(column, 'name'):
+            return column.label(None)
         else:
             return None
 
@@ -462,13 +464,18 @@ class DefaultCompiler(engine.Compiled):
         
         if asfrom:
             stack_entry['is_selected_from'] = stack_entry['is_subquery'] = True
+            column_clause_args = {}
         elif self.stack and self.stack[-1].get('select'):
             stack_entry['is_subquery'] = True
-
+            column_clause_args = {}
+        else:
+            column_clause_args = {'typemap':self.typemap, 'column_labels':self.column_labels}
+            
         if self.stack and self.stack[-1].get('from'):
             existingfroms = self.stack[-1]['from']
         else:
             existingfroms = None
+            
         froms = select._get_display_froms(existingfroms)
 
         correlate_froms = util.Set()
@@ -492,15 +499,15 @@ class DefaultCompiler(engine.Compiled):
                 labelname = co._label
                 if labelname is not None:
                     l = co.label(labelname)
-                    inner_columns.add(self.process(l))
+                    inner_columns.add(self.process(l, **column_clause_args))
                 else:
-                    inner_columns.add(self.process(co))
+                    inner_columns.add(self.process(co, **column_clause_args))
             else:
                 l = self.label_select_column(select, co)
                 if l is not None:
-                    inner_columns.add(self.process(l))
+                    inner_columns.add(self.process(l, **column_clause_args))
                 else:
-                    inner_columns.add(self.process(co))
+                    inner_columns.add(self.process(co, **column_clause_args))
             
         collist = string.join(inner_columns.difference(util.Set([None])), ', ')
 
diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index e066632af..7c42ae9a2 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -1200,11 +1200,7 @@ class _CompareMixin(ColumnOperators):
 
         type_ = self._compare_type(obj)
 
-        # TODO: generalize operator overloading like this out into the
-        # types module
-        if op == operators.add and isinstance(type_, (sqltypes.Concatenable)):
-            op = operators.concat_op
-        return _BinaryExpression(self.expression_element(), obj, op, type_=type_)
+        return _BinaryExpression(self.expression_element(), obj, type_.adapt_operator(op), type_=type_)
 
     # a mapping of operators with the method they use, along with their negated
     # operator for comparison operators
@@ -1289,7 +1285,10 @@ class _CompareMixin(ColumnOperators):
         return self.__compare(operators.like_op, po)
 
     def label(self, name):
-        """Produce a column label, i.e. ``<columnname> AS <name>``"""
+        """Produce a column label, i.e. ``<columnname> AS <name>``.
+        
+        if 'name' is None, an anonymous label name will be generated.
+        """
         return _Label(name, self, self.type)
 
     def desc(self):
@@ -1333,7 +1332,10 @@ class _CompareMixin(ColumnOperators):
         return _BindParamClause('literal', obj, type_=self.type, unique=True)
 
     def _check_literal(self, other):
-        if isinstance(other, Operators):
+        if isinstance(other, _BindParamClause) and isinstance(other.type, sqltypes.NullType):
+            other.type = self.type
+            return other
+        elif isinstance(other, Operators):
             return other.expression_element()
         elif _is_literal(other):
             return self._bind_param(other)
diff --git a/lib/sqlalchemy/types.py b/lib/sqlalchemy/types.py
index ec2d1072d..9e1f6aa44 100644
--- a/lib/sqlalchemy/types.py
+++ b/lib/sqlalchemy/types.py
@@ -131,7 +131,14 @@ class AbstractType(object):
         """
 
         return None
-
+    
+    def adapt_operator(self, op):
+        """given an operator from the sqlalchemy.sql.operators package, 
+        translate it to a new operator based on the semantics of this type.
+        
+        By default, returns the operator unchanged."""
+        return op
+        
     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, ",".join(["%s=%s" % (k, getattr(self, k)) for k in inspect.getargspec(self.__init__)[0][1:]]))
 
@@ -282,9 +289,14 @@ NullTypeEngine = NullType
 
 class Concatenable(object):
     """marks a type as supporting 'concatenation'"""
-    pass
+    def adapt_operator(self, op):
+        from sqlalchemy.sql import operators
+        if op == operators.add:
+            return operators.concat_op
+        else:
+            return op
     
-class String(TypeEngine, Concatenable):
+class String(Concatenable, TypeEngine):
     def __init__(self, length=None, convert_unicode=False):
         self.length = length
         self.convert_unicode = convert_unicode