Add QueryType to ToSelectStatement() to be able to change generated SQL

Author: mythz

src/ServiceStack.OrmLite.Firebird/FirebirdOrmLiteDialectProvider.cs

@@ -789,7 +789,7 @@ public override string ToChangeColumnNameStatement(Type modelType, FieldDefiniti
         }
         #endregion DDL
 
-        public override string ToSelectStatement(ModelDefinition modelDef,
+        public override string ToSelectStatement(QueryType queryType, ModelDefinition modelDef,
             string selectExpression,
             string bodyExpression,
             string orderByExpression = null,
@@ -804,7 +804,7 @@ public override string ToSelectStatement(ModelDefinition modelDef,
             if (orderByExpression != null)
                 sb.Append(orderByExpression);
 
-            if (rows != null || offset != null)
+            if ((queryType == QueryType.Select || (rows == 1 && offset is null or 0)) && (offset != null || rows != null))
             {
                 var sqlPrefix = "SELECT";
                 if (rows != null)

src/ServiceStack.OrmLite.Oracle/OracleOrmLiteDialectProvider.cs

@@ -1060,8 +1060,7 @@ public override string EscapeWildcards(string value)
                 .Replace("%", @"^%");
         }
 
-
-        public override string ToSelectStatement(ModelDefinition modelDef,
+        public override string ToSelectStatement(QueryType queryType, ModelDefinition modelDef,
             string selectExpression,
             string bodyExpression,
             string orderByExpression = null,
@@ -1083,24 +1082,23 @@ public override string ToSelectStatement(ModelDefinition modelDef,
             if (!offset.HasValue)
                 offset = 0;
 
-            if (string.IsNullOrEmpty(orderByExpression) && rows.HasValue)
+            if ((queryType == QueryType.Select || (rows == 1 && offset is null or 0)) && string.IsNullOrEmpty(orderByExpression))
             {
                 var primaryKey = modelDef.FieldDefinitions.FirstOrDefault(x => x.IsPrimaryKey);
                 if (primaryKey == null)
                 {
                     if (rows.Value == 1 && offset.Value == 0)
                     {
                         // Probably used Single<> extension method on a table with a composite key so let it through.
-                        // Lack of an orderby expression will mean it returns a random matching row, but that is OK.
+                        // Lack of an order by expression will mean it returns a random matching row, but that is OK.
                         orderByExpression = "";
                     }
                     else
                         throw new ApplicationException("Malformed model, no PrimaryKey defined");
                 }
                 else
                 {
-                    orderByExpression = string.Format("ORDER BY {0}",
-                        this.GetQuotedColumnName(modelDef, primaryKey.FieldName));
+                    orderByExpression = $"ORDER BY {this.GetQuotedColumnName(modelDef, primaryKey.FieldName)}";
                 }
             }
             sbInner.Append(" " + orderByExpression);

src/ServiceStack.OrmLite.SqlServer/SqlServer2012OrmLiteDialectProvider.cs

@@ -75,7 +75,7 @@ public override List<string> SequenceList(Type tableType)
             return gens;
         }
 
-        public override string ToSelectStatement(ModelDefinition modelDef,
+        public override string ToSelectStatement(QueryType queryType, ModelDefinition modelDef,
             string selectExpression,
             string bodyExpression,
             string orderByExpression = null,
@@ -89,11 +89,11 @@ public override string ToSelectStatement(ModelDefinition modelDef,
             if (orderByExpression != null)
                 sb.Append(orderByExpression);
 
-            if (offset != null || rows != null)
+            if (queryType == QueryType.Select || (rows == 1 && offset is null or 0))
             {
-                if (orderByExpression.IsEmpty())
+                if (queryType == QueryType.Select && orderByExpression.IsEmpty())
                 {
-                    var orderBy = offset == null && rows == 1 //Avoid for Single requests
+                    var orderBy = (offset is null or 0) && rows == 1 //Avoid for Single requests
                         ? "1"
                         : this.GetQuotedColumnName(modelDef, modelDef.PrimaryKey);
 

src/ServiceStack.OrmLite.SqlServer/SqlServerOrmLiteDialectProvider.cs

@@ -558,7 +558,7 @@ public override void PrepareInsertRowStatement<T>(IDbCommand dbCmd, Dictionary<s
                 : $"INSERT INTO {GetQuotedTableName(modelDef)} {strReturning}DEFAULT VALUES";
         }
 
-        public override string ToSelectStatement(ModelDefinition modelDef,
+        public override string ToSelectStatement(QueryType queryType, ModelDefinition modelDef,
             string selectExpression,
             string bodyExpression,
             string orderByExpression = null,
@@ -568,22 +568,22 @@ public override string ToSelectStatement(ModelDefinition modelDef,
             var sb = StringBuilderCache.Allocate()
                 .Append(selectExpression)
                 .Append(bodyExpression);
-
-            if (!offset.HasValue && !rows.HasValue)
+            
+            if (!offset.HasValue && !rows.HasValue || (queryType != QueryType.Select && rows != 1))
                 return StringBuilderCache.ReturnAndFree(sb) + orderByExpression;
 
-            if (offset.HasValue && offset.Value < 0)
+            if (offset is < 0)
                 throw new ArgumentException($"Skip value:'{offset.Value}' must be>=0");
 
-            if (rows.HasValue && rows.Value < 0)
+            if (rows is < 0)
                 throw new ArgumentException($"Rows value:'{rows.Value}' must be>=0");
 
             var skip = offset ?? 0;
             var take = rows ?? int.MaxValue;
 
             var selectType = selectExpression.StartsWithIgnoreCase("SELECT DISTINCT") ? "SELECT DISTINCT" : "SELECT";
 
-            //Temporary hack till we come up with a more robust paging sln for SqlServer
+            //Temp hack for SqlServer <= 2008
             if (skip == 0)
             {
                 var sql = StringBuilderCache.ReturnAndFree(sb) + orderByExpression;

src/ServiceStack.OrmLite.VistaDB/VistaDbDialectProvider.cs

@@ -389,8 +389,8 @@ public override string ToChangeColumnNameStatement(Type modelType, FieldDefiniti
         }
 
         /// Limit/Offset paging logic needs to be implemented here:
-        public override string ToSelectStatement(
-            ModelDefinition modelDef, string selectExpression, string bodyExpression, string orderByExpression = null, int? offset = null, int? rows = null)
+        public override string ToSelectStatement(QueryType queryType, ModelDefinition modelDef, string selectExpression,
+            string bodyExpression, string orderByExpression = null, int? offset = null, int? rows = null)
         {
             var sb = StringBuilderCache.Allocate()
                 .Append(selectExpression)
@@ -399,7 +399,7 @@ public override string ToSelectStatement(
             var hasOrderBy = !string.IsNullOrWhiteSpace(orderByExpression);
 
             var skip = offset.GetValueOrDefault();
-            if ((skip > 0 || rows.HasValue) && !hasOrderBy)
+            if (queryType == QueryType.Select && (skip > 0 || rows.HasValue) && !hasOrderBy)
             {
                 hasOrderBy = true;
                 //Ordering by the first column in select list
@@ -409,15 +409,18 @@ public override string ToSelectStatement(
             if (hasOrderBy)
                 sb.Append(orderByExpression);
 
-            if (skip > 0)
-                sb.Append(this.GetPagingOffsetExpression(skip));
-
-            if (rows.HasValue)
+            if (queryType == QueryType.Select)
             {
-                if (skip == 0)
-                    sb.Append(this.GetPagingOffsetExpression(0));
+                if (skip > 0)
+                    sb.Append(this.GetPagingOffsetExpression(skip));
+
+                if (rows.HasValue)
+                {
+                    if (skip == 0)
+                        sb.Append(this.GetPagingOffsetExpression(0));
 
-                sb.Append(this.GetPagingFetchExpression(rows.Value));
+                    sb.Append(this.GetPagingFetchExpression(rows.Value));
+                }
             }
 
             return StringBuilderCache.ReturnAndFree(sb);

src/ServiceStack.OrmLite/Async/OrmLiteResultsFilterExtensionsAsync.cs

@@ -181,7 +181,7 @@ public static Task<object> ScalarAsync(this IDbCommand dbCmd)
 
         public static Task<object> ScalarAsync(this IDbCommand dbCmd, ISqlExpression expression, CancellationToken token)
         {
-            dbCmd.PopulateWith(expression);
+            dbCmd.PopulateWith(expression, QueryType.Scalar);
 
             if (OrmLiteConfig.ResultsFilter != null)
                 return OrmLiteConfig.ResultsFilter.GetScalar(dbCmd).InTask();

src/ServiceStack.OrmLite/Async/ReadExpressionCommandExtensionsAsync.cs

@@ -38,68 +38,68 @@ internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, Expression<F
         internal static Task<List<Tuple<T, T2>>> SelectMultiAsync<T, T2>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, EOT, EOT, EOT, EOT, EOT>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3>>> SelectMultiAsync<T, T2, T3>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, T3, EOT, EOT, EOT, EOT>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4>>> SelectMultiAsync<T, T2, T3, T4>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, T3, T4, EOT, EOT, EOT>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5>>> SelectMultiAsync<T, T2, T3, T4, T5>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, T3, T4, T5, EOT, EOT>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5, T6>>> SelectMultiAsync<T, T2, T3, T4, T5, T6>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, T3, T4, T5, T6, EOT>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5, T6, T7>>> SelectMultiAsync<T, T2, T3, T4, T5, T6, T7>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
             q.Select(q.CreateMultiSelect<T, T2, T3, T4, T5, T6, T7>(dbCmd.GetDialectProvider()));
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6, T7>>(q.ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6, T7>>(q.ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
 
         internal static Task<List<Tuple<T, T2>>> SelectMultiAsync<T, T2>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3>>> SelectMultiAsync<T, T2, T3>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4>>> SelectMultiAsync<T, T2, T3, T4>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5>>> SelectMultiAsync<T, T2, T3, T4, T5>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5, T6>>> SelectMultiAsync<T, T2, T3, T4, T5, T6>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<Tuple<T, T2, T3, T4, T5, T6, T7>>> SelectMultiAsync<T, T2, T3, T4, T5, T6, T7>(this IDbCommand dbCmd, SqlExpression<T> q, string[] tableSelects, CancellationToken token)
         {
-            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6, T7>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(), q.Params, q.OnlyFields, token);
+            return dbCmd.ExprConvertToListAsync<Tuple<T, T2, T3, T4, T5, T6, T7>>(q.Select(q.CreateMultiSelect(tableSelects)).ToSelectStatement(QueryType.Select), q.Params, q.OnlyFields, token);
         }
 
 
@@ -164,7 +164,7 @@ internal static async Task<long> GetCountAsync(this IDbCommand dbCmd, string sql
         internal static Task<long> RowCountAsync<T>(this IDbCommand dbCmd, SqlExpression<T> expression, CancellationToken token)
         {
             var countExpr = expression.Clone().OrderBy();
-            return dbCmd.ScalarAsync<long>(dbCmd.GetDialectProvider().ToRowCountStatement(countExpr.ToSelectStatement()), countExpr.Params, token);
+            return dbCmd.ScalarAsync<long>(dbCmd.GetDialectProvider().ToRowCountStatement(countExpr.ToSelectStatement(QueryType.Scalar)), countExpr.Params, token);
         }
 
         internal static Task<long> RowCountAsync(this IDbCommand dbCmd, string sql, object anonType, CancellationToken token)

src/ServiceStack.OrmLite/Expressions/IUntypedSqlExpression.cs

@@ -620,9 +620,10 @@ public string ToDeleteRowStatement()
             return q.ToDeleteRowStatement();
         }
 
-        public string ToSelectStatement()
+        public string ToSelectStatement() => ToSelectStatement(QueryType.Select);
+        public string ToSelectStatement(QueryType forType)
         {
-            return q.ToSelectStatement();
+            return q.ToSelectStatement(forType);
         }
 
         public string ToCountStatement()