Merge pull request #514 from shift-evgeny/SqlExpressionJoinFixes

Select entire table in SqlExpression.Select() using anonymous types

Author: mythz

src/ServiceStack.OrmLite.PostgreSQL/PostgreSQLDialectProvider.cs

@@ -128,9 +128,9 @@ public override string GetColumnDefinition(
         //Convert xmin into an integer so it can be used in comparisons
         public const string RowVersionFieldComparer = "int8in(xidout(xmin))";
 
-        public override string GetRowVersionColumnName(FieldDefinition field)
+        public override SelectListItem GetRowVersionColumnName(FieldDefinition field)
         {
-            return "xmin as " + GetQuotedColumnName(field.FieldName);
+            return new SelectListExpression(this, "xmin", field.FieldName);
         }
 
         public override void AppendFieldCondition(StringBuilder sqlFilter, FieldDefinition fieldDef, IDbCommand cmd)

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1449,22 +1449,64 @@ protected virtual object VisitNew(NewExpression nex)
             if (isAnonType)
             {
                 var exprs = VisitExpressionList(nex.Arguments);
+
                 var r = StringBuilderCache.Allocate();
-                foreach (object e in exprs)
+                for (var i = 0; i < exprs.Count; ++i)
                 {
-                    if (r.Length > 0)
+                    exprs[i] = SetAnonTypePropertyNamesForSelectExpression(exprs[i], nex.Arguments[i], nex.Members[i]);
+
+                    if (i > 0)
                         r.Append(",");
 
-                    r.Append(e);
+                    r.Append(exprs[i]);
                 }
                 return StringBuilderCache.ReturnAndFree(r);
             }
 
             return CachedExpressionCompiler.Evaluate(nex);
         }
 
+        private object SetAnonTypePropertyNamesForSelectExpression(object expr, Expression arg, MemberInfo member)
+        {
+            // When selecting a column use the anon type property name, rather than the table property name, as the returned column name
+
+            MemberExpression propertyExpr;
+            if ((propertyExpr = arg as MemberExpression) != null && propertyExpr.Member.Name != member.Name)
+                return new SelectListExpression(DialectProvider, expr.ToString(), member.Name);
+
+            // When selecting an entire table use the anon type property name as a prefix for the returned column name
+            // to allow the caller to distinguish properties with the same names from different tables
+
+            ParameterExpression paramExpr;
+            SelectList selectList;
+            if ((paramExpr = arg as ParameterExpression) != null && paramExpr.Name != member.Name && (selectList = expr as SelectList) != null)
+            {
+                foreach (var item in selectList.Items)
+                {
+                    if (!string.IsNullOrEmpty(item.Alias))
+                    {
+                        item.Alias = member.Name + item.Alias;
+                    }
+                    else
+                    {
+                        var columnItem = item as SelectListColumn;
+                        if (columnItem != null)
+                        {
+                            columnItem.Alias = member.Name + columnItem.ColumnName;
+                        }
+                    }
+                }
+            }
+
+            return expr;
+        }
+
         protected virtual object VisitParameter(ParameterExpression p)
         {
+            var paramModelDef = p.Type.GetModelDefinition();
+            if (paramModelDef != null)
+                return DialectProvider.GetColumnNames(paramModelDef, true);
+
             return p.Name;
         }
 
@@ -2061,6 +2103,118 @@ public EnumMemberAccess(string text, Type enumType)
         public Type EnumType { get; private set; }
     }
 
+    public abstract class SelectListItem
+    {
+        protected SelectListItem(IOrmLiteDialectProvider dialectProvider, string alias)
+        {
+            if (dialectProvider == null)
+                throw new ArgumentNullException("dialectProvider");
+
+            DialectProvider = dialectProvider;
+            Alias = alias;
+        }
+
+        /// <summary>
+        /// Unquoted alias for the column or expression being selected.
+        /// </summary>
+        public string Alias { get; set; }
+
+        protected IOrmLiteDialectProvider DialectProvider { get; }
+
+        public abstract override string ToString();
+    }
+
+    public class SelectListExpression : SelectListItem
+    {
+        public SelectListExpression(IOrmLiteDialectProvider dialectProvider, string selectExpression, string alias)
+            : base(dialectProvider, alias)
+        {
+            if (string.IsNullOrEmpty(selectExpression))
+                throw new ArgumentNullException("selectExpression");
+            if (string.IsNullOrEmpty(alias))
+                throw new ArgumentNullException("alias");
+
+            SelectExpression = selectExpression;
+            Alias = alias;
+        }
+
+        /// <summary>
+        /// The SQL expression being selected, including any necessary quoting.
+        /// </summary>
+        public string SelectExpression { get; }
+
+        public override string ToString()
+        {
+            return SelectExpression + " AS " + DialectProvider.GetQuotedName(Alias); // Alias is required for a non-column expression
+        }
+    }
+
+    public class SelectListColumn : SelectListItem
+    {
+        public SelectListColumn(IOrmLiteDialectProvider dialectProvider, string columnName, string columnAlias = null, string quotedTableAlias = null)
+            : base(dialectProvider, columnAlias)
+        {
+            if (string.IsNullOrEmpty(columnName))
+                throw new ArgumentNullException("columnName");
+
+            ColumnName = columnName;
+            QuotedTableAlias = quotedTableAlias;
+        }
+
+        /// <summary>
+        /// Unquoted column name being selected.
+        /// </summary>
+        public string ColumnName { get; }
+        /// <summary>
+        /// Table name or alias used to prefix the column name, if any. Already quoted.
+        /// </summary>
+        public string QuotedTableAlias { get; }
+
+        public override string ToString()
+        {
+            var text = DialectProvider.GetQuotedColumnName(ColumnName);
+
+            if (!string.IsNullOrEmpty(QuotedTableAlias))
+                text = QuotedTableAlias + "." + text;
+            if (!string.IsNullOrEmpty(Alias))
+                text += " AS " + DialectProvider.GetQuotedName(Alias);
+
+            return text;
+        }
+    }
+
+    public class SelectList
+    {
+        public SelectList()
+        {
+            Items = new List<SelectListItem>();
+        }
+
+        public SelectList(ICollection<SelectListItem> items)
+        {
+            if (items == null)
+                throw new ArgumentNullException("items");
+
+            Items = new List<SelectListItem>(items);
+        }
+
+        public List<SelectListItem> Items { get; }
+
+        public override string ToString()
+        {
+            var sb = StringBuilderCache.Allocate();
+
+            foreach (var item in Items)
+            {
+                if (sb.Length > 0)
+                    sb.Append(", ");
+                sb.Append(item);
+            }
+
+            return StringBuilderCache.ReturnAndFree(sb);
+        }
+    }
+
     public class OrmLiteDataParameter : IDbDataParameter
     {
         public DbType DbType { get; set; }

src/ServiceStack.OrmLite/FieldDefinition.cs

@@ -74,7 +74,7 @@ public object GetValue(object onInstance)
         public string GetQuotedName(IOrmLiteDialectProvider dialectProvider)
         {
             return IsRowVersion
-                ? dialectProvider.GetRowVersionColumnName(this)
+                ? dialectProvider.GetRowVersionColumnName(this).ToString()
                 : dialectProvider.GetQuotedColumnName(FieldName);
         }
 

src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs

@@ -157,9 +157,10 @@ string ToSelectFromProcedureStatement(object fromObjWithProperties,
         bool DoesSequenceExist(IDbCommand dbCmd, string sequencName);
 
         ulong FromDbRowVersion(object value);
-        string GetRowVersionColumnName(FieldDefinition field);
+        SelectListItem GetRowVersionColumnName(FieldDefinition field);
 
         string GetColumnNames(ModelDefinition modelDef);
+        SelectList GetColumnNames(ModelDefinition modelDef, bool tableQualified);
 
         SqlExpression<T> SqlExpression<T>();
 

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -546,30 +546,44 @@ public virtual string ToSelectStatement(ModelDefinition modelDef,
             return StringBuilderCache.ReturnAndFree(sb);
         }
 
-        public virtual string GetRowVersionColumnName(FieldDefinition field)
+        public virtual SelectListItem GetRowVersionColumnName(FieldDefinition field)
         {
-            return GetQuotedColumnName(field.FieldName);
+            return new SelectListColumn(this, field.FieldName);
         }
 
         public virtual string GetColumnNames(ModelDefinition modelDef)
         {
-            var sqlColumns = StringBuilderCache.Allocate();
-            foreach (var field in modelDef.FieldDefinitions)
+            return GetColumnNames(modelDef, false).ToString();
+        }
+
+        public virtual SelectList GetColumnNames(ModelDefinition modelDef, bool tableQualified)
+        {
+            var tablePrefix = "";
+            if (tableQualified)
+            {
+                tablePrefix = GetQuotedTableName(modelDef);
+            }
+
+            var sqlColumns = new SelectListItem[modelDef.FieldDefinitions.Count];
+            for (var i = 0; i < sqlColumns.Length; ++i)
             {
-                if (sqlColumns.Length > 0)
-                    sqlColumns.Append(", ");
+                var field = modelDef.FieldDefinitions[i];
 
-                if (field.CustomSelect == null)
+                if (field.CustomSelect != null)
+                {
+                    sqlColumns[i] = new SelectListExpression(this, field.CustomSelect, field.FieldName);
+                }
+                else if (field.IsRowVersion)
                 {
-                    sqlColumns.Append(field.GetQuotedName(this));
+                    sqlColumns[i] = GetRowVersionColumnName(field);
                 }
                 else
                 {
-                    sqlColumns.Append(field.CustomSelect + " AS " + field.FieldName);
+                    sqlColumns[i] = new SelectListColumn(this, field.FieldName, null, tablePrefix);
                 }
             }
 
-            return StringBuilderCache.ReturnAndFree(sqlColumns);
+            return new SelectList(sqlColumns);
         }
 
         public virtual string ToInsertRowStatement(IDbCommand cmd, object objWithProperties, ICollection<string> insertFields = null)