Fixing #1585 expression cache problem

LiteDB.Tests/Database/Document_Size_Tests.cs

@@ -48,8 +48,9 @@ public void Very_Large_Single_Document_Support_With_Partial_Load_Memory_Usage()
                 var memoryFullDocument = Process.GetCurrentProcess().WorkingSet64;
 
                 // memory after full document must be at least 10Mb more than with name only
+                // using 50% of array size because there are no precise value when using memory usage
 
-                memoryFullDocument.Should().BeGreaterOrEqualTo(memoryForNameOnly + ARRAY_SIZE);
+                memoryFullDocument.Should().BeGreaterOrEqualTo(memoryForNameOnly + (ARRAY_SIZE / 2));
             }
         }
     }

LiteDB.Tests/Issue1585.cs

@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using System.Linq;
+using FluentAssertions;
+using LiteDB.Engine;
+using Xunit;
+
+namespace LiteDB.Issue1585
+{
+    public class Issue1585_Tests
+    {
+        public class PlayerDto
+        {
+            [BsonId]
+            public Guid Id { get; }
+            public string Name { get; }
+
+            public PlayerDto(Guid id, string name)
+            {
+                Id = id;
+                Name = name;
+            }
+        }
+
+        [Fact]
+        public void Dto_Read()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+        [Fact]
+        public void Dto_Read1()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+        [Fact]
+        public void Dto_Read2()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+        [Fact]
+        public void Dto_Read3()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+        [Fact]
+        public void Dto_Read4()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+        [Fact]
+        public void Dto_Read5()
+        {
+            using (var db = new LiteDatabase(new MemoryStream()))
+            {
+                var id = Guid.NewGuid();
+                var col = db.GetCollection<PlayerDto>();
+                col.Insert(new PlayerDto(id, "Bob"));
+                var player = col.FindOne(x => x.Id == id);
+                Assert.NotNull(player);
+            }
+        }
+
+    }
+}

LiteDB.Tests/Mapper/LinqEval_Tests.cs

@@ -18,6 +18,7 @@ public class User
             public string Name { get; set; }
             public DateTime Date { get; set; }
             public bool Active { get; set; }
+            public Guid Ticket { get; set; }
 
             public Address Address { get; set; }
             public List<Phone> Phones { get; set; }
@@ -152,7 +153,6 @@ public void Linq_Array_Navigation_Eval()
             //** Eval(u, x => x.Phones.Items(z => z.Prefix >= 20).Number, 2, 3);
         }
 
-
         /// <summary>
         /// Eval expression and check with expected
         /// </summary>

LiteDB/Document/Expression/BsonExpression.cs

@@ -12,6 +12,16 @@
 
 namespace LiteDB
 {
+    /// <summary>
+    /// Delegate function to get compiled enumerable expression
+    /// </summary>
+    internal delegate IEnumerable<BsonValue> BsonExpressionEnumerableDelegate(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation, BsonDocument parameters);
+
+    /// <summary>
+    /// Delegate function to get compiled scalar expression
+    /// </summary>
+    internal delegate BsonValue BsonExpressionScalarDelegate(IEnumerable<BsonDocument> source, BsonDocument root, BsonValue current, Collation collation, BsonDocument parameters);
+
     /// <summary>
     /// Compile and execute string expressions using BsonDocuments. Used in all document manipulation (transform, filter, indexes, updates). See https://github.com/mbdavid/LiteDB/wiki/Expressions
     /// </summary>
@@ -107,12 +117,12 @@ public sealed class BsonExpression
         /// <summary>
         /// Compiled Expression into a function to be executed: func(source[], root, current, parameters)[]
         /// </summary>
-        private Func<IEnumerable<BsonDocument>, BsonDocument, BsonValue, Collation, BsonDocument, IEnumerable<BsonValue>> _func;
+        private BsonExpressionEnumerableDelegate _func;
 
         /// <summary>
         /// Compiled Expression into a scalar function to be executed: func(source[], root, current, parameters)1
         /// </summary>
-        private Func<IEnumerable<BsonDocument>, BsonDocument, BsonValue, Collation, BsonDocument, BsonValue> _funcScalar;
+        private BsonExpressionScalarDelegate _funcScalar;
 
         /// <summary>
         /// Get default field name when need convert simple BsonValue into BsonDocument
@@ -275,6 +285,29 @@ internal BsonValue ExecuteScalar(IEnumerable<BsonDocument> source, BsonDocument
         /// Parse string and create new instance of BsonExpression - can be cached
         /// </summary>
         public static BsonExpression Create(string expression)
+        {
+            return Create(expression, new BsonDocument());
+        }
+
+        /// <summary>
+        /// Parse string and create new instance of BsonExpression - can be cached
+        /// </summary>
+        public static BsonExpression Create(string expression, params BsonValue[] args)
+        {
+            var parameters = new BsonDocument();
+
+            for(var i = 0; i < args.Length; i++)
+            {
+                parameters[i.ToString()] = args[i];
+            }
+
+            return Create(expression, parameters);
+        }
+
+        /// <summary>
+        /// Parse string and create new instance of BsonExpression - can be cached
+        /// </summary>
+        public static BsonExpression Create(string expression, BsonDocument parameters)
         {
             if (string.IsNullOrWhiteSpace(expression)) throw new ArgumentNullException(nameof(expression));
 
@@ -300,6 +333,7 @@ public static BsonExpression Create(string expression)
                 IsImmutable = expr.IsImmutable,
                 UseSource = expr.UseSource,
                 IsScalar = expr.IsScalar,
+                Parameters = parameters ?? new BsonDocument(),
                 Fields = expr.Fields,
                 Left = expr.Left,
                 Right = expr.Right,
@@ -310,33 +344,6 @@ public static BsonExpression Create(string expression)
             };
         }
 
-        /// <summary>
-        /// Parse string and create new instance of BsonExpression - can be cached
-        /// </summary>
-        public static BsonExpression Create(string expression, params BsonValue[] args)
-        {
-            var expr = Create(expression);
-
-            for(var i = 0; i < args.Length; i++)
-            {
-                expr.Parameters[i.ToString()] = args[i];
-            }
-
-            return expr;
-        }
-
-        /// <summary>
-        /// Parse string and create new instance of BsonExpression - can be cached
-        /// </summary>
-        public static BsonExpression Create(string expression, BsonDocument parameters)
-        {
-            var expr = Create(expression);
-
-            expr.Parameters = parameters;
-
-            return expr;
-        }
-
         /// <summary>
         /// Parse tokenizer and create new instance of BsonExpression - for now, do not use cache
         /// </summary>
@@ -395,13 +402,13 @@ internal static void Compile(BsonExpression expr, ExpressionContext context)
             // compile linq expression according with return type (scalar or not)
             if (expr.IsScalar)
             {
-                var lambda = System.Linq.Expressions.Expression.Lambda<Func<IEnumerable<BsonDocument>, BsonDocument, BsonValue, Collation, BsonDocument, BsonValue>>(expr.Expression, context.Source, context.Root, context.Current, context.Collation, context.Parameters);
+                var lambda = System.Linq.Expressions.Expression.Lambda<BsonExpressionScalarDelegate>(expr.Expression, context.Source, context.Root, context.Current, context.Collation, context.Parameters);
 
                 expr._funcScalar = lambda.Compile();
             }
             else
             {
-                var lambda = System.Linq.Expressions.Expression.Lambda<Func<IEnumerable<BsonDocument>, BsonDocument, BsonValue, Collation, BsonDocument, IEnumerable<BsonValue>>>(expr.Expression, context.Source, context.Root, context.Current, context.Collation, context.Parameters);
+                var lambda = System.Linq.Expressions.Expression.Lambda<BsonExpressionEnumerableDelegate>(expr.Expression, context.Source, context.Root, context.Current, context.Collation, context.Parameters);
 
                 expr._func = lambda.Compile();
             }