Add QueryType override for SelectInto

mythz · mythz · commit 951f1a2ae30f · 2021-07-01T16:48:20.000+08:00
diff --git a/src/ServiceStack.OrmLite.Firebird/FirebirdOrmLiteDialectProvider.cs b/src/ServiceStack.OrmLite.Firebird/FirebirdOrmLiteDialectProvider.cs
@@ -801,7 +801,7 @@ public override string ToSelectStatement(QueryType queryType, ModelDefinition mo
                 .Append(selectExpression)
                 .Append(bodyExpression);
 
-            if (orderByExpression != null)
+            if (!string.IsNullOrEmpty(orderByExpression))
                 sb.Append(orderByExpression);
 
             if ((queryType == QueryType.Select || (rows == 1 && offset is null or 0)) && (offset != null || rows != null))
diff --git a/src/ServiceStack.OrmLite.Oracle/OracleOrmLiteDialectProvider.cs b/src/ServiceStack.OrmLite.Oracle/OracleOrmLiteDialectProvider.cs
@@ -1082,7 +1082,7 @@ public override string ToSelectStatement(QueryType queryType, ModelDefinition mo
             if (!offset.HasValue)
                 offset = 0;
 
-            if ((queryType == QueryType.Select || (rows == 1 && offset is null or 0)) && string.IsNullOrEmpty(orderByExpression))
+            if (queryType == QueryType.Select && (offset.GetValueOrDefault() > 0 || rows.GetValueOrDefault() > 1) && orderByExpression.IsEmpty())
             {
                 var primaryKey = modelDef.FieldDefinitions.FirstOrDefault(x => x.IsPrimaryKey);
                 if (primaryKey == null)
diff --git a/src/ServiceStack.OrmLite/Async/ReadExpressionCommandExtensionsAsync.cs b/src/ServiceStack.OrmLite/Async/ReadExpressionCommandExtensionsAsync.cs
@@ -17,20 +17,20 @@ internal static class ReadExpressionCommandExtensionsAsync
     {
         internal static Task<List<Into>> SelectAsync<Into, From>(this IDbCommand dbCmd, SqlExpression<From> q, CancellationToken token)
         {
-            string sql = q.SelectInto<Into>();
+            string sql = q.SelectInto<Into>(QueryType.Select);
             return dbCmd.ExprConvertToListAsync<Into>(sql, q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)
         {
-            string sql = q.SelectInto<T>();
+            string sql = q.SelectInto<T>(QueryType.Select);
             return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);
         }
 
         internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
-            string sql = q.Where(predicate).SelectInto<T>();
+            string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);
 
             return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);
         }
@@ -112,7 +112,7 @@ internal static Task<T> SingleAsync<T>(this IDbCommand dbCmd, Expression<Func<T,
 
         internal static Task<T> SingleAsync<T>(this IDbCommand dbCmd, SqlExpression<T> expression, CancellationToken token)
         {
-            string sql = expression.Limit(1).SelectInto<T>();
+            string sql = expression.Limit(1).SelectInto<T>(QueryType.Single);
 
             return dbCmd.ExprConvertToAsync<T>(sql, expression.Params, token);
         }
@@ -121,7 +121,7 @@ public static Task<TKey> ScalarAsync<T, TKey>(this IDbCommand dbCmd, Expression<
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Select(field);
-            var sql = q.SelectInto<T>();
+            var sql = q.SelectInto<T>(QueryType.Scalar);
             return dbCmd.ScalarAsync<TKey>(sql, q.Params, token);
         }
 
@@ -130,7 +130,7 @@ internal static Task<TKey> ScalarAsync<T, TKey>(this IDbCommand dbCmd,
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Select(field).Where(predicate);
-            string sql = q.SelectInto<T>();
+            string sql = q.SelectInto<T>(QueryType.Scalar);
             return dbCmd.ScalarAsync<TKey>(sql, q.Params, token);
         }
 
@@ -200,7 +200,7 @@ internal static Task<T> ExprConvertToAsync<T>(this IDataReader dataReader, IOrmL
         internal static Task<List<T>> Select<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
-            string sql = q.Where(predicate).SelectInto<T>();
+            string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);
 
             return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);
         }
diff --git a/src/ServiceStack.OrmLite/Expressions/IUntypedSqlExpression.cs b/src/ServiceStack.OrmLite/Expressions/IUntypedSqlExpression.cs
@@ -641,10 +641,8 @@ public Tuple<ModelDefinition, FieldDefinition> FirstMatchingField(string fieldNa
             return q.FirstMatchingField(fieldName);
         }
 
-        public string SelectInto<TModel>()
-        {
-            return q.SelectInto<TModel>();
-        }
+        public string SelectInto<TModel>() => q.SelectInto<TModel>();
+        public string SelectInto<TModel>(QueryType queryType) => q.SelectInto<TModel>(queryType);
     }
 
     public static class SqlExpressionExtensions
diff --git a/src/ServiceStack.OrmLite/Expressions/ReadExpressionCommandExtensions.cs b/src/ServiceStack.OrmLite/Expressions/ReadExpressionCommandExtensions.cs
@@ -12,14 +12,14 @@ internal static class ReadExpressionCommandExtensions
     {
         internal static List<T> Select<T>(this IDbCommand dbCmd, SqlExpression<T> q)
         {
-            string sql = q.SelectInto<T>();
+            string sql = q.SelectInto<T>(QueryType.Select);
             return dbCmd.ExprConvertToList<T>(sql, q.Params, onlyFields: q.OnlyFields);
         }
 
         internal static List<T> Select<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
-            string sql = q.Where(predicate).SelectInto<T>();
+            string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);
 
             return dbCmd.ExprConvertToList<T>(sql, q.Params);
         }
@@ -135,22 +135,22 @@ internal static T Single<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> pre
 
         internal static T Single<T>(this IDbCommand dbCmd, SqlExpression<T> q)
         {
-            string sql = q.Limit(1).SelectInto<T>();
+            string sql = q.Limit(1).SelectInto<T>(QueryType.Single);
 
             return dbCmd.ExprConvertTo<T>(sql, q.Params, onlyFields:q.OnlyFields);
         }
 
         public static TKey Scalar<T, TKey>(this IDbCommand dbCmd, SqlExpression<T> expression)
         {
-            var sql = expression.SelectInto<T>();
+            var sql = expression.SelectInto<T>(QueryType.Scalar);
             return dbCmd.Scalar<TKey>(sql, expression.Params);
         }
 
         public static TKey Scalar<T, TKey>(this IDbCommand dbCmd, Expression<Func<T, object>> field)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Select(field);
-            var sql = q.SelectInto<T>();
+            var sql = q.SelectInto<T>(QueryType.Scalar);
             return dbCmd.Scalar<TKey>(sql, q.Params);
         }
 
@@ -159,7 +159,7 @@ internal static TKey Scalar<T, TKey>(this IDbCommand dbCmd,
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
             q.Select(field).Where(predicate);
-            string sql = q.SelectInto<T>();
+            string sql = q.SelectInto<T>(QueryType.Scalar);
             return dbCmd.Scalar<TKey>(sql, q.Params);
         }
 
diff --git a/src/ServiceStack.OrmLite/Expressions/SqlExpression.Join.cs b/src/ServiceStack.OrmLite/Expressions/SqlExpression.Join.cs
@@ -268,11 +268,12 @@ protected virtual SqlExpression<T> InternalJoin(string joinType, Expression join
             return this;
         }
 
-        public string SelectInto<TModel>()
+        public string SelectInto<TModel>() => SelectInto<TModel>(QueryType.Select);
+        public string SelectInto<TModel>(QueryType queryType)
         {
             if ((CustomSelect && OnlyFields == null) || (typeof(TModel) == typeof(T) && !PrefixFieldWithTableName))
             {
-                return ToSelectStatement(QueryType.Select);
+                return ToSelectStatement(queryType);
             }
 
             useFieldName = true;
@@ -411,7 +412,7 @@ public string SelectInto<TModel>()
             var columns = select.Length > 0 ? select : "*";
             SelectExpression = "SELECT " + (selectDistinct ? "DISTINCT " : "") + columns;
 
-            return ToSelectStatement(QueryType.Select);
+            return ToSelectStatement(queryType);
         }
 
         private static FieldDefinition FindWeakMatch(ModelDefinition tableDef, FieldDefinition fieldDef)
diff --git a/src/ServiceStack.OrmLite/Expressions/SqlExpression.cs b/src/ServiceStack.OrmLite/Expressions/SqlExpression.cs
@@ -3071,6 +3071,7 @@ public interface ISqlExpression
         string ToSelectStatement();
         string ToSelectStatement(QueryType forType);
         string SelectInto<TModel>();
+        string SelectInto<TModel>(QueryType forType);
     }
 
     public enum QueryType
diff --git a/src/ServiceStack.OrmLite/Legacy/ReadExpressionCommandExtensionsAsyncLegacy.cs b/src/ServiceStack.OrmLite/Legacy/ReadExpressionCommandExtensionsAsyncLegacy.cs
@@ -17,15 +17,15 @@ internal static class ReadExpressionCommandExtensionsAsyncLegacy
         internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> expression, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
-            var sql = expression(q).SelectInto<T>();
+            var sql = expression(q).SelectInto<T>(QueryType.Select);
             return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);
         }
 
         [Obsolete("Use db.SelectAsync(db.From<T>())")]
         internal static Task<List<Into>> SelectAsync<Into, From>(this IDbCommand dbCmd, Func<SqlExpression<From>, SqlExpression<From>> expression, CancellationToken token)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<From>();
-            string sql = expression(q).SelectInto<Into>();
+            string sql = expression(q).SelectInto<Into>(QueryType.Select);
             return dbCmd.ExprConvertToListAsync<Into>(sql, q.Params, q.OnlyFields, token);
         }
 
diff --git a/src/ServiceStack.OrmLite/Legacy/ReadExpressionCommandExtensionsLegacy.cs b/src/ServiceStack.OrmLite/Legacy/ReadExpressionCommandExtensionsLegacy.cs
@@ -11,7 +11,7 @@ internal static class ReadExpressionCommandExtensionsLegacy
         internal static List<T> Select<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> expression)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<T>();
-            string sql = expression(q).SelectInto<T>();
+            string sql = expression(q).SelectInto<T>(QueryType.Select);
 
             return dbCmd.ExprConvertToList<T>(sql, q.Params, onlyFields: q.OnlyFields);
         }
@@ -20,14 +20,14 @@ internal static List<T> Select<T>(this IDbCommand dbCmd, Func<SqlExpression<T>,
         internal static List<Into> Select<Into, From>(this IDbCommand dbCmd, Func<SqlExpression<From>, SqlExpression<From>> expression)
         {
             var q = dbCmd.GetDialectProvider().SqlExpression<From>();
-            string sql = expression(q).SelectInto<Into>();
+            string sql = expression(q).SelectInto<Into>(QueryType.Select);
 
             return dbCmd.ExprConvertToList<Into>(sql, q.Params, onlyFields: q.OnlyFields);
         }
 
         internal static List<Into> Select<Into, From>(this IDbCommand dbCmd, SqlExpression<From> q)
         {
-            string sql = q.SelectInto<Into>();
+            string sql = q.SelectInto<Into>(QueryType.Select);
             return dbCmd.ExprConvertToList<Into>(sql, q.Params, onlyFields: q.OnlyFields);
         }
 
diff --git a/src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs b/src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs
@@ -524,7 +524,7 @@ public virtual string ToSelectStatement(QueryType queryType, ModelDefinition mod
             var sb = StringBuilderCache.Allocate();
             sb.Append(selectExpression);
             sb.Append(bodyExpression);
-            if (orderByExpression != null)
+            if (!string.IsNullOrEmpty(orderByExpression))
             {
                 sb.Append(orderByExpression);
             }
diff --git a/src/ServiceStack.OrmLite/OrmLiteReadExpressionsApi.cs b/src/ServiceStack.OrmLite/OrmLiteReadExpressionsApi.cs
@@ -240,12 +240,12 @@ public static List<T> Select<T>(this IDbConnection dbConn, SqlExpression<T> expr
         public static List<T> Select<T>(this IDbConnection dbConn, ISqlExpression expression, object anonType = null)
         {
             if (anonType != null)
-                return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(), anonType));
+                return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(QueryType.Select), anonType));
 
             if (expression.Params != null && expression.Params.Any())
-                return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(), expression.Params.ToDictionary(param => param.ParameterName, param => param.Value)));
+                return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(QueryType.Select), expression.Params.ToDictionary(param => param.ParameterName, param => param.Value)));
 
-            return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(), expression.Params));
+            return dbConn.Exec(dbCmd => dbCmd.SqlList<T>(expression.SelectInto<T>(QueryType.Select), expression.Params));
         }
 
         public static List<Tuple<T, T2>> SelectMulti<T, T2>(this IDbConnection dbConn, SqlExpression<T> expression) => dbConn.Exec(dbCmd => dbCmd.SelectMulti<T, T2>(expression));
@@ -297,7 +297,7 @@ public static T Single<T>(this IDbConnection dbConn, SqlExpression<T> expression
         /// </summary>
         public static T Single<T>(this IDbConnection dbConn, ISqlExpression expression)
         {
-            return dbConn.Exec(dbCmd => dbCmd.Single<T>(expression.SelectInto<T>(), expression.Params));
+            return dbConn.Exec(dbCmd => dbCmd.Single<T>(expression.SelectInto<T>(QueryType.Single), expression.Params));
         }
 
         /// <summary>
diff --git a/src/ServiceStack.OrmLite/OrmLiteReadExpressionsApiAsync.cs b/src/ServiceStack.OrmLite/OrmLiteReadExpressionsApiAsync.cs
@@ -43,7 +43,7 @@ public static Task<List<Into>> SelectAsync<Into, From>(this IDbConnection dbConn
         /// Returns results from using an SqlExpression lambda. E.g:
         /// <para>db.SelectAsync(db.From&lt;Person&gt;().Where(x =&gt; x.Age &gt; 40))</para>
         /// </summary>
-        public static Task<List<T>> SelectAsync<T>(this IDbConnection dbConn, ISqlExpression expression, CancellationToken token = default) => dbConn.Exec(dbCmd => dbCmd.SqlListAsync<T>(expression.SelectInto<T>(), expression.Params, token));
+        public static Task<List<T>> SelectAsync<T>(this IDbConnection dbConn, ISqlExpression expression, CancellationToken token = default) => dbConn.Exec(dbCmd => dbCmd.SqlListAsync<T>(expression.SelectInto<T>(QueryType.Select), expression.Params, token));
 
         public static Task<List<Tuple<T, T2>>> SelectMultiAsync<T, T2>(this IDbConnection dbConn, SqlExpression<T> expression, CancellationToken token = default) => dbConn.Exec(dbCmd => dbCmd.SelectMultiAsync<T, T2>(expression, token));
 
@@ -94,7 +94,7 @@ public static Task<T> SingleAsync<T>(this IDbConnection dbConn, SqlExpression<T>
         /// </summary>
         public static Task<T> SingleAsync<T>(this IDbConnection dbConn, ISqlExpression expression, CancellationToken token = default)
         {
-            return dbConn.Exec(dbCmd => dbCmd.SingleAsync<T>(expression.SelectInto<T>(), expression.Params, token));
+            return dbConn.Exec(dbCmd => dbCmd.SingleAsync<T>(expression.SelectInto<T>(QueryType.Single), expression.Params, token));
         }
 
         /// <summary>
diff --git a/src/ServiceStack.OrmLite/SqlBuilder.cs b/src/ServiceStack.OrmLite/SqlBuilder.cs
@@ -235,10 +235,8 @@ public string ToSelectStatement(QueryType forType)
                 return RawSql;
             }
 
-            public string SelectInto<T>()
-            {
-                return RawSql;
-            }
+            public string SelectInto<T>() => RawSql;
+            public string SelectInto<T>(QueryType queryType) => RawSql;
         }
 
         public Template AddTemplate(string sql, object parameters = null)
diff --git a/src/ServiceStack.OrmLite/Support/LoadList.cs b/src/ServiceStack.OrmLite/Support/LoadList.cs
@@ -37,7 +37,7 @@ protected LoadList(IDbCommand dbCmd, SqlExpression<From> q)
 
             //Use .Clone() to prevent SqlExpressionSelectFilter from adding params to original query
             var parentQ = q.Clone();
-            var sql = parentQ.SelectInto<Into>();
+            var sql = parentQ.SelectInto<Into>(QueryType.Select);
             parentResults = dbCmd.ExprConvertToList<Into>(sql, parentQ.Params, onlyFields:q.OnlyFields);
 
             modelDef = ModelDefinition<Into>.Definition;
diff --git a/tests/ServiceStack.OrmLite.Tests/CustomSqlExpressionTests.cs b/tests/ServiceStack.OrmLite.Tests/CustomSqlExpressionTests.cs
@@ -224,13 +224,13 @@ public void Can_Select_hierarchy_classes1()
             var q1 = db.From<WaybillIn>();
             q1.PrefixFieldWithTableName = true;
             q1.Select(x => new {x.Name, x.Number});
-            q1.SelectInto<WaybillIn>();
+            q1.SelectInto<WaybillIn>(QueryType.Select);
             var sql1 = q1.SelectExpression;
 
             var q2 = db.From<WaybillBase>();
             q2.PrefixFieldWithTableName = true;
             q2.Select(x => new {x.Name, x.Number});
-            q2.SelectInto<WaybillIn>();
+            q2.SelectInto<WaybillIn>(QueryType.Select);
             var sql2 = q2.SelectExpression;
 
             Assert.AreEqual(sql1, sql2);
diff --git a/tests/ServiceStack.OrmLite.Tests/Support/JoinSqlBuilder.cs b/tests/ServiceStack.OrmLite.Tests/Support/JoinSqlBuilder.cs
@@ -492,7 +492,8 @@ public virtual JoinSqlBuilder<TNewPoco, TBasePoco> Limit()
             return this;
         }
 
-        public string SelectInto<T>()
+        public string SelectInto<T>() => SelectInto<T>(QueryType.Select);
+        public string SelectInto<T>(QueryType queryType)
         {
             var modelDef = typeof(T).GetModelMetadata();
 
@@ -598,15 +599,15 @@ public string SelectInto<T>()
 
         public string ToSql()
         {
-            return SelectInto<TNewPoco>();
+            return SelectInto<TNewPoco>(QueryType.Select);
         }
 
         public List<IDbDataParameter> Params { get; private set; }
 
         public string ToSelectStatement() => ToSelectStatement(QueryType.Select);
         public string ToSelectStatement(QueryType forType)
         {
-            return SelectInto<TNewPoco>();
+            return SelectInto<TNewPoco>(forType);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1082,7 +1082,7 @@ public override string ToSelectStatement(QueryType queryType, ModelDefinition mo`
`1082`	`1082`	`if (!offset.HasValue)`
`1083`	`1083`	`offset = 0;`
`1084`	`1084`
`1085`		`- if ((queryType == QueryType.Select \|\| (rows == 1 && offset is null or 0)) && string.IsNullOrEmpty(orderByExpression))`
	`1085`	`+ if (queryType == QueryType.Select && (offset.GetValueOrDefault() > 0 \|\| rows.GetValueOrDefault() > 1) && orderByExpression.IsEmpty())`
`1086`	`1086`	`{`
`1087`	`1087`	`var primaryKey = modelDef.FieldDefinitions.FirstOrDefault(x => x.IsPrimaryKey);`
`1088`	`1088`	`if (primaryKey == null)`
Original file line number	Diff line number	Diff line change
`@@ -17,20 +17,20 @@ internal static class ReadExpressionCommandExtensionsAsync`
`17`	`17`	`{`
`18`	`18`	`internal static Task<List<Into>> SelectAsync<Into, From>(this IDbCommand dbCmd, SqlExpression<From> q, CancellationToken token)`
`19`	`19`	`{`
`20`		`- string sql = q.SelectInto<Into>();`
	`20`	`+ string sql = q.SelectInto<Into>(QueryType.Select);`
`21`	`21`	`return dbCmd.ExprConvertToListAsync<Into>(sql, q.Params, q.OnlyFields, token);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, SqlExpression<T> q, CancellationToken token)`
`25`	`25`	`{`
`26`		`- string sql = q.SelectInto<T>();`
	`26`	`+ string sql = q.SelectInto<T>(QueryType.Select);`
`27`	`27`	`return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate, CancellationToken token)`
`31`	`31`	`{`
`32`	`32`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`33`		`- string sql = q.Where(predicate).SelectInto<T>();`
	`33`	`+ string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);`
`34`	`34`
`35`	`35`	`return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);`
`36`	`36`	`}`
`@@ -112,7 +112,7 @@ internal static Task<T> SingleAsync<T>(this IDbCommand dbCmd, Expression<Func<T,`
`112`	`112`
`113`	`113`	`internal static Task<T> SingleAsync<T>(this IDbCommand dbCmd, SqlExpression<T> expression, CancellationToken token)`
`114`	`114`	`{`
`115`		`- string sql = expression.Limit(1).SelectInto<T>();`
	`115`	`+ string sql = expression.Limit(1).SelectInto<T>(QueryType.Single);`
`116`	`116`
`117`	`117`	`return dbCmd.ExprConvertToAsync<T>(sql, expression.Params, token);`
`118`	`118`	`}`
`@@ -121,7 +121,7 @@ public static Task<TKey> ScalarAsync<T, TKey>(this IDbCommand dbCmd, Expression<`
`121`	`121`	`{`
`122`	`122`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`123`	`123`	`q.Select(field);`
`124`		`- var sql = q.SelectInto<T>();`
	`124`	`+ var sql = q.SelectInto<T>(QueryType.Scalar);`
`125`	`125`	`return dbCmd.ScalarAsync<TKey>(sql, q.Params, token);`
`126`	`126`	`}`
`127`	`127`
`@@ -130,7 +130,7 @@ internal static Task<TKey> ScalarAsync<T, TKey>(this IDbCommand dbCmd,`
`130`	`130`	`{`
`131`	`131`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`132`	`132`	`q.Select(field).Where(predicate);`
`133`		`- string sql = q.SelectInto<T>();`
	`133`	`+ string sql = q.SelectInto<T>(QueryType.Scalar);`
`134`	`134`	`return dbCmd.ScalarAsync<TKey>(sql, q.Params, token);`
`135`	`135`	`}`
`136`	`136`
`@@ -200,7 +200,7 @@ internal static Task<T> ExprConvertToAsync<T>(this IDataReader dataReader, IOrmL`
`200`	`200`	`internal static Task<List<T>> Select<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate, CancellationToken token)`
`201`	`201`	`{`
`202`	`202`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`203`		`- string sql = q.Where(predicate).SelectInto<T>();`
	`203`	`+ string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);`
`204`	`204`
`205`	`205`	`return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);`
`206`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -641,10 +641,8 @@ public Tuple<ModelDefinition, FieldDefinition> FirstMatchingField(string fieldNa`
`641`	`641`	`return q.FirstMatchingField(fieldName);`
`642`	`642`	`}`
`643`	`643`
`644`		`- public string SelectInto<TModel>()`
`645`		`- {`
`646`		`- return q.SelectInto<TModel>();`
`647`		`- }`
	`644`	`+ public string SelectInto<TModel>() => q.SelectInto<TModel>();`
	`645`	`+ public string SelectInto<TModel>(QueryType queryType) => q.SelectInto<TModel>(queryType);`
`648`	`646`	`}`
`649`	`647`
`650`	`648`	`public static class SqlExpressionExtensions`
Original file line number	Diff line number	Diff line change
`@@ -12,14 +12,14 @@ internal static class ReadExpressionCommandExtensions`
`12`	`12`	`{`
`13`	`13`	`internal static List<T> Select<T>(this IDbCommand dbCmd, SqlExpression<T> q)`
`14`	`14`	`{`
`15`		`- string sql = q.SelectInto<T>();`
	`15`	`+ string sql = q.SelectInto<T>(QueryType.Select);`
`16`	`16`	`return dbCmd.ExprConvertToList<T>(sql, q.Params, onlyFields: q.OnlyFields);`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`internal static List<T> Select<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> predicate)`
`20`	`20`	`{`
`21`	`21`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`22`		`- string sql = q.Where(predicate).SelectInto<T>();`
	`22`	`+ string sql = q.Where(predicate).SelectInto<T>(QueryType.Select);`
`23`	`23`
`24`	`24`	`return dbCmd.ExprConvertToList<T>(sql, q.Params);`
`25`	`25`	`}`
`@@ -135,22 +135,22 @@ internal static T Single<T>(this IDbCommand dbCmd, Expression<Func<T, bool>> pre`
`135`	`135`
`136`	`136`	`internal static T Single<T>(this IDbCommand dbCmd, SqlExpression<T> q)`
`137`	`137`	`{`
`138`		`- string sql = q.Limit(1).SelectInto<T>();`
	`138`	`+ string sql = q.Limit(1).SelectInto<T>(QueryType.Single);`
`139`	`139`
`140`	`140`	`return dbCmd.ExprConvertTo<T>(sql, q.Params, onlyFields:q.OnlyFields);`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`public static TKey Scalar<T, TKey>(this IDbCommand dbCmd, SqlExpression<T> expression)`
`144`	`144`	`{`
`145`		`- var sql = expression.SelectInto<T>();`
	`145`	`+ var sql = expression.SelectInto<T>(QueryType.Scalar);`
`146`	`146`	`return dbCmd.Scalar<TKey>(sql, expression.Params);`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`public static TKey Scalar<T, TKey>(this IDbCommand dbCmd, Expression<Func<T, object>> field)`
`150`	`150`	`{`
`151`	`151`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`152`	`152`	`q.Select(field);`
`153`		`- var sql = q.SelectInto<T>();`
	`153`	`+ var sql = q.SelectInto<T>(QueryType.Scalar);`
`154`	`154`	`return dbCmd.Scalar<TKey>(sql, q.Params);`
`155`	`155`	`}`
`156`	`156`
`@@ -159,7 +159,7 @@ internal static TKey Scalar<T, TKey>(this IDbCommand dbCmd,`
`159`	`159`	`{`
`160`	`160`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`161`	`161`	`q.Select(field).Where(predicate);`
`162`		`- string sql = q.SelectInto<T>();`
	`162`	`+ string sql = q.SelectInto<T>(QueryType.Scalar);`
`163`	`163`	`return dbCmd.Scalar<TKey>(sql, q.Params);`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -268,11 +268,12 @@ protected virtual SqlExpression<T> InternalJoin(string joinType, Expression join`
`268`	`268`	`return this;`
`269`	`269`	`}`
`270`	`270`
`271`		`- public string SelectInto<TModel>()`
	`271`	`+ public string SelectInto<TModel>() => SelectInto<TModel>(QueryType.Select);`
	`272`	`+ public string SelectInto<TModel>(QueryType queryType)`
`272`	`273`	`{`
`273`	`274`	`if ((CustomSelect && OnlyFields == null) \|\| (typeof(TModel) == typeof(T) && !PrefixFieldWithTableName))`
`274`	`275`	`{`
`275`		`- return ToSelectStatement(QueryType.Select);`
	`276`	`+ return ToSelectStatement(queryType);`
`276`	`277`	`}`
`277`	`278`
`278`	`279`	`useFieldName = true;`
`@@ -411,7 +412,7 @@ public string SelectInto<TModel>()`
`411`	`412`	`var columns = select.Length > 0 ? select : "*";`
`412`	`413`	`SelectExpression = "SELECT " + (selectDistinct ? "DISTINCT " : "") + columns;`
`413`	`414`
`414`		`- return ToSelectStatement(QueryType.Select);`
	`415`	`+ return ToSelectStatement(queryType);`
`415`	`416`	`}`
`416`	`417`
`417`	`418`	`private static FieldDefinition FindWeakMatch(ModelDefinition tableDef, FieldDefinition fieldDef)`
Original file line number	Diff line number	Diff line change
`@@ -3071,6 +3071,7 @@ public interface ISqlExpression`
`3071`	`3071`	`string ToSelectStatement();`
`3072`	`3072`	`string ToSelectStatement(QueryType forType);`
`3073`	`3073`	`string SelectInto<TModel>();`
	`3074`	`+ string SelectInto<TModel>(QueryType forType);`
`3074`	`3075`	`}`
`3075`	`3076`
`3076`	`3077`	`public enum QueryType`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ internal static class ReadExpressionCommandExtensionsAsyncLegacy`
`17`	`17`	`internal static Task<List<T>> SelectAsync<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> expression, CancellationToken token)`
`18`	`18`	`{`
`19`	`19`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`20`		`- var sql = expression(q).SelectInto<T>();`
	`20`	`+ var sql = expression(q).SelectInto<T>(QueryType.Select);`
`21`	`21`	`return dbCmd.ExprConvertToListAsync<T>(sql, q.Params, q.OnlyFields, token);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`[Obsolete("Use db.SelectAsync(db.From<T>())")]`
`25`	`25`	`internal static Task<List<Into>> SelectAsync<Into, From>(this IDbCommand dbCmd, Func<SqlExpression<From>, SqlExpression<From>> expression, CancellationToken token)`
`26`	`26`	`{`
`27`	`27`	`var q = dbCmd.GetDialectProvider().SqlExpression<From>();`
`28`		`- string sql = expression(q).SelectInto<Into>();`
	`28`	`+ string sql = expression(q).SelectInto<Into>(QueryType.Select);`
`29`	`29`	`return dbCmd.ExprConvertToListAsync<Into>(sql, q.Params, q.OnlyFields, token);`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal static class ReadExpressionCommandExtensionsLegacy`
`11`	`11`	`internal static List<T> Select<T>(this IDbCommand dbCmd, Func<SqlExpression<T>, SqlExpression<T>> expression)`
`12`	`12`	`{`
`13`	`13`	`var q = dbCmd.GetDialectProvider().SqlExpression<T>();`
`14`		`- string sql = expression(q).SelectInto<T>();`
	`14`	`+ string sql = expression(q).SelectInto<T>(QueryType.Select);`
`15`	`15`
`16`	`16`	`return dbCmd.ExprConvertToList<T>(sql, q.Params, onlyFields: q.OnlyFields);`
`17`	`17`	`}`
`@@ -20,14 +20,14 @@ internal static List<T> Select<T>(this IDbCommand dbCmd, Func<SqlExpression<T>,`
`20`	`20`	`internal static List<Into> Select<Into, From>(this IDbCommand dbCmd, Func<SqlExpression<From>, SqlExpression<From>> expression)`
`21`	`21`	`{`
`22`	`22`	`var q = dbCmd.GetDialectProvider().SqlExpression<From>();`
`23`		`- string sql = expression(q).SelectInto<Into>();`
	`23`	`+ string sql = expression(q).SelectInto<Into>(QueryType.Select);`
`24`	`24`
`25`	`25`	`return dbCmd.ExprConvertToList<Into>(sql, q.Params, onlyFields: q.OnlyFields);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`internal static List<Into> Select<Into, From>(this IDbCommand dbCmd, SqlExpression<From> q)`
`29`	`29`	`{`
`30`		`- string sql = q.SelectInto<Into>();`
	`30`	`+ string sql = q.SelectInto<Into>(QueryType.Select);`
`31`	`31`	`return dbCmd.ExprConvertToList<Into>(sql, q.Params, onlyFields: q.OnlyFields);`
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -524,7 +524,7 @@ public virtual string ToSelectStatement(QueryType queryType, ModelDefinition mod`
`524`	`524`	`var sb = StringBuilderCache.Allocate();`
`525`	`525`	`sb.Append(selectExpression);`
`526`	`526`	`sb.Append(bodyExpression);`
`527`		`- if (orderByExpression != null)`
	`527`	`+ if (!string.IsNullOrEmpty(orderByExpression))`
`528`	`528`	`{`
`529`	`529`	`sb.Append(orderByExpression);`
`530`	`530`	`}`