Use cloned SqlExpression in LoadSelect sub queries to avoid mutating original q

Author: mythz

src/ServiceStack.OrmLite/Expressions/SqlExpression.cs

@@ -1130,6 +1130,16 @@ public virtual string ToSelectStatement()
                 : sql;
         }
 
+        /// <summary>
+        /// Merge params into an encapsulated SQL Statement with embedded param values
+        /// </summary>
+        public virtual string ToMergedParamsSelectStatement()
+        {
+            var sql = this.ToSelectStatement();
+            var mergedSql = DialectProvider.MergeParamsIntoSql(sql, Params);
+            return mergedSql;
+        }
+
         public virtual string ToCountStatement()
         {
             SelectFilter?.Invoke(this);

src/ServiceStack.OrmLite/Support/LoadList.cs

@@ -34,13 +34,17 @@ protected LoadList(IDbCommand dbCmd, SqlExpression<From> q)
             this.dbCmd = dbCmd;
             this.q = q;
 
-            var sql = q.SelectInto<Into>();
-            parentResults = dbCmd.ExprConvertToList<Into>(sql, q.Params, onlyFields:q.OnlyFields);
+            //Use .Clone() to prevent SqlExpressionSelectFilter from adding params to original query
+            var parentQ = q.Clone();
+            var sql = parentQ.SelectInto<Into>();
+            parentResults = dbCmd.ExprConvertToList<Into>(sql, parentQ.Params, onlyFields:q.OnlyFields);
 
             modelDef = ModelDefinition<Into>.Definition;
             fieldDefs = modelDef.AllFieldDefinitionsArray.Where(x => x.IsReference).ToList();
 
-            subSql = dialectProvider.GetLoadChildrenSubSelect(q);
+            var subQ = q.Clone();
+            var subQSql = dialectProvider.GetLoadChildrenSubSelect(subQ);
+            subSql = dialectProvider.MergeParamsIntoSql(subQSql, subQ.Params);
         }
 
         protected string GetRefListSql(ModelDefinition refModelDef, FieldDefinition refField)
@@ -83,9 +87,10 @@ protected void SetListChildResults(FieldDefinition fieldDef, Type refType, IList
         protected string GetRefSelfSql(ModelDefinition modelDef, FieldDefinition refSelf, ModelDefinition refModelDef)
         {
             //Load Self Table.RefTableId PK
-            q.Select(dialectProvider.GetQuotedColumnName(modelDef, refSelf));
+            var refQ = q.Clone();
+            refQ.Select(dialectProvider.GetQuotedColumnName(modelDef, refSelf));
 
-            var subSqlRef = q.ToSelectStatement();
+            var subSqlRef = refQ.ToMergedParamsSelectStatement();
 
             var sqlRef = $"SELECT {dialectProvider.GetColumnNames(refModelDef)} " +
                          $"FROM {dialectProvider.GetQuotedTableName(refModelDef)} " +

tests/ServiceStack.OrmLite.Tests/Async/SqlExpressionTests.cs

@@ -76,6 +76,56 @@ public async Task Can_Select_as_Dictionary_Object_Async()
                 Assert.That(result["sum"], Is.EqualTo(55));
             }
         }
+
+        [Test]
+        public void Can_select_limit_on_Table_with_References()
+        {
+            if (Dialect == Dialect.MySql)
+                return; //= This version of MySQL doesn't yet support 'LIMIT & IN/ALL/ANY/SOME subquery'
+
+            if (Dialect == Dialect.SqlServer)
+                return; // generates Windowing function "... WHERE CustomerId IN (SELECT * FROM ...)" 
+                        // when should generate "... WHERE CustomerId IN (SELECT Id FROM ...)" 
+                        // both on .NET and .NET Core
+
+            using (var db = OpenDbConnection())
+            {
+                CustomerOrdersUseCase.DropTables(db); //Has conflicting 'Order' table
+                db.DropAndCreateTable<Order>();
+                db.DropAndCreateTable<Customer>();
+                db.DropAndCreateTable<CustomerAddress>();
+
+                var customer1 = LoadReferencesTests.GetCustomerWithOrders("1");
+                db.Save(customer1, references: true);
+
+                var customer2 = LoadReferencesTests.GetCustomerWithOrders("2");
+                db.Save(customer2, references: true);
+
+                var results = db.LoadSelect(db.From<Customer>()
+                    .OrderBy(x => x.Id)
+                    .Limit(1, 1));
+
+                //db.GetLastSql().Print();
+
+                Assert.That(results.Count, Is.EqualTo(1));
+                Assert.That(results[0].Name, Is.EqualTo("Customer 2"));
+                Assert.That(results[0].PrimaryAddress.AddressLine1, Is.EqualTo("2 Humpty Street"));
+                Assert.That(results[0].Orders.Count, Is.EqualTo(2));
+
+                results = db.LoadSelect(db.From<Customer>()
+                    .Join<CustomerAddress>()
+                    .OrderBy(x => x.Id)
+                    .Limit(1, 1));
+
+                db.GetLastSql().Print();
+
+                Assert.That(results.Count, Is.EqualTo(1));
+                Assert.That(results[0].Name, Is.EqualTo("Customer 2"));
+                Assert.That(results[0].PrimaryAddress.AddressLine1, Is.EqualTo("2 Humpty Street"));
+                Assert.That(results[0].Orders.Count, Is.EqualTo(2));
+            }
+        }
+
         [Test]
         public async Task Can_select_limit_on_Table_with_References_Async()
         {

tests/ServiceStack.OrmLite.Tests/Issues/LoadSelectIssue.cs

@@ -1,12 +1,41 @@
-using NUnit.Framework;
+using System;
+using NUnit.Framework;
+using ServiceStack.Data;
 using ServiceStack.DataAnnotations;
+using ServiceStack.Logging;
+using ServiceStack.OrmLite.SqlServer;
 using ServiceStack.Text;
 
 namespace ServiceStack.OrmLite.Tests.Issues
 {
     [TestFixture]
     public class LoadSelectIssue : OrmLiteTestBase
     {
+        public class PlayerEquipment
+        {
+            public string Id => PlayerId + "/" + ItemId;
+
+            public int PlayerId { get; set; }
+
+            [References(typeof(ItemData))]
+            public int ItemId { get; set; }
+
+            public int Quantity { get; set; }
+
+            public bool IsEquipped { get; set; }
+
+            [Reference]
+            public ItemData ItemData { get; set; }
+        }
+
+        public class ItemData
+        {
+            [AutoIncrement]
+            public int Id { get; set; }
+
+            public string Data { get; set; }
+        }
+
         [Test]
         public void Can_LoadSelect_PlayerEquipment()
         {
@@ -46,33 +75,87 @@ public void Can_LoadSelect_PlayerEquipment()
                 results.PrintDump();
             }
         }
-    }
 
-    public class PlayerEquipment
-    {
-        public string Id
+        [Alias("EventCategory")]
+        public class EventCategoryTbl : IHasSoftDelete, IHasTimeStamp
         {
-            get { return PlayerId + "/" + ItemId; }
+            [PrimaryKey]
+            public Guid EventCategoryId { get; set; }
+
+
+            [System.ComponentModel.DataAnnotations.Required]
+            public string Name { get; set; }
+
+            /// <summary>
+            /// Link to the file record that contains any image related to this category
+            /// </summary>
+            [References(typeof(FileTbl))]
+            public Guid LinkedImageId { get; set; }
+
+            [Reference]
+            public FileTbl LinkedImage { get; set; }
+
+            public bool IsDeleted { get; set; }
+
+            [RowVersion]
+            public ulong RowVersion { get; set; }
         }
 
-        public int PlayerId { get; set; }
+        [Alias("File")]
+        public class FileTbl : IHasSoftDelete, IHasTimeStamp
+        {
+            [PrimaryKey]
+            public Guid FileId { get; set; }
 
-        [References(typeof(ItemData))]
-        public int ItemId { get; set; }
+            public string Name { get; set; }
 
-        public int Quantity { get; set; }
+            public string Extension { get; set; }
 
-        public bool IsEquipped { get; set; }
+            public long FileSizeBytes { get; set; }
 
-        [Reference]
-        public ItemData ItemData { get; set; }
-    }
+            public bool IsDeleted { get; set; }
 
-    public class ItemData
-    {
-        [AutoIncrement]
-        public int Id { get; set; }
+            [RowVersion]
+            public ulong RowVersion { get; set; }
+        }
+
+        public interface IHasTimeStamp
+        {
+            [RowVersion]
+            ulong RowVersion { get; set; }
+        }
+
+        public interface IHasSoftDelete
+        {
+            bool IsDeleted { get; set; }
+        }
+
+        [Test]
+        public void Can_execute_LoadSelect_when_child_references_implement_IHasSoftDelete()
+        {
+            LogManager.LogFactory = new ConsoleLogFactory(debugEnabled:true);
+            // Automatically filter out all soft deleted records, for ALL table types.
+            OrmLiteConfig.SqlExpressionSelectFilter = q =>
+            {
+                if (q.ModelDef.ModelType.HasInterface(typeof(IHasSoftDelete)))
+                {
+                    q.Where<IHasSoftDelete>(x => x.IsDeleted != true);
+                }
+            };
+
+            using (var db = OpenDbConnection())
+            {
+                db.DropTable<EventCategoryTbl>();
+                db.DropTable<FileTbl>();
+
+                db.CreateTable<FileTbl>();
+                db.CreateTable<EventCategoryTbl>();
+
+                var results = db.LoadSelect<EventCategoryTbl>();
+            }
+
+            OrmLiteConfig.SqlExpressionSelectFilter = null;
+        }
 
-        public string Data { get; set; }
     }
 }