Feat(Mapper): Support [Key] and [NotMapped] attributes from DataAnnotations

LiteDB.Benchmarks/Benchmarks/Insertion/InsertionIgnoreExpressionPropertyBenchmark.cs

@@ -93,5 +93,94 @@ public void GlobalCleanup()
 
 			File.Delete(DatabasePath);
 		}
-	}
+	}
+
+
+    [BenchmarkCategory(Constants.Categories.INSERTION)]
+    public class InsertionIgnoreExpressionPropertyComponentModelBenchmark : BenchmarkBase
+    {
+        private List<FileMetaBaseComponentModel> _baseData;
+        private List<FileMetaWithExclusionComponentModel> _baseDataWithBsonIgnore;
+
+        private ILiteCollection<FileMetaBaseComponentModel> _fileMetaCollection;
+        private ILiteCollection<FileMetaWithExclusionComponentModel> _fileMetaExclusionCollection;
+
+        [GlobalSetup(Target = nameof(Insertion))]
+        public void GlobalBsonIgnoreSetup()
+        {
+            File.Delete(DatabasePath);
+
+            DatabaseInstance = new LiteDatabase(ConnectionString());
+            _fileMetaCollection = DatabaseInstance.GetCollection<FileMetaBaseComponentModel>();
+            _fileMetaCollection.EnsureIndex(fileMeta => fileMeta.ShouldBeShown);
+
+            _baseData = FileMetaGeneratorComponentModel<FileMetaBaseComponentModel>.GenerateList(DatasetSize); // executed once per each N value
+        }
+
+        [GlobalSetup(Target = nameof(InsertionWithBsonIgnore))]
+        public void GlobalIgnorePropertySetup()
+        {
+            File.Delete(DatabasePath);
+
+            DatabaseInstance = new LiteDatabase(ConnectionString());
+            _fileMetaExclusionCollection = DatabaseInstance.GetCollection<FileMetaWithExclusionComponentModel>();
+            _fileMetaExclusionCollection.EnsureIndex(fileMeta => fileMeta.ShouldBeShown);
+
+            _baseDataWithBsonIgnore = FileMetaGeneratorComponentModel<FileMetaWithExclusionComponentModel>.GenerateList(DatasetSize); // executed once per each N value
+        }
+
+        [Benchmark(Baseline = true)]
+        public int Insertion()
+        {
+            var count = _fileMetaCollection.Insert(_baseData);
+            DatabaseInstance.Checkpoint();
+            return count;
+        }
+
+        [Benchmark]
+        public int InsertionWithBsonIgnore()
+        {
+            var count = _fileMetaExclusionCollection.Insert(_baseDataWithBsonIgnore);
+            DatabaseInstance.Checkpoint();
+            return count;
+        }
+
+        [IterationCleanup]
+        public void IterationCleanup()
+        {
+            var indexesCollection = DatabaseInstance.GetCollection("$indexes");
+            var droppedCollectionIndexes = indexesCollection.Query().Where(x => x["name"] != "_id").ToDocuments().ToList();
+
+            var collectionNames = DatabaseInstance.GetCollectionNames();
+            foreach (var name in collectionNames)
+            {
+                DatabaseInstance.DropCollection(name);
+            }
+
+            foreach (var indexInfo in droppedCollectionIndexes)
+            {
+                DatabaseInstance.GetCollection(indexInfo["collection"])
+                    .EnsureIndex(indexInfo["name"], BsonExpression.Create(indexInfo["expression"]), indexInfo["unique"]);
+            }
+
+            DatabaseInstance.Checkpoint();
+            DatabaseInstance.Rebuild();
+        }
+
+        [GlobalCleanup]
+        public void GlobalCleanup()
+        {
+            _baseData?.Clear();
+            _baseData = null;
+
+            _baseDataWithBsonIgnore?.Clear();
+            _baseDataWithBsonIgnore = null;
+
+            DatabaseInstance?.Checkpoint();
+            DatabaseInstance?.Dispose();
+            DatabaseInstance = null;
+
+            File.Delete(DatabasePath);
+        }
+    }
 }

LiteDB.Benchmarks/Models/FileMetaBase.cs

@@ -2,6 +2,7 @@
 
 namespace LiteDB.Benchmarks.Models
 {
+
     public class FileMetaBase
     {
         [BsonIgnore]

LiteDB.Benchmarks/Models/FileMetaBaseComponentModel.cs

@@ -0,0 +1,37 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace LiteDB.Benchmarks.Models
+{
+    public class FileMetaBaseComponentModel
+    {
+        [NotMapped]
+        public const string BsonIdPropertyKey = "_id";
+
+        [Key]
+        public virtual string Id => $"{FileId}_{Version}";
+
+        public Guid FileId { get; set; }
+
+        public string ParentId { get; set; }
+
+        public string Title { get; set; }
+
+        public string MimeType { get; set; }
+
+        public int Version { get; set; }
+
+        public DateTimeOffset? ValidFrom { get; set; }
+
+        public DateTimeOffset? ValidTo { get; set; }
+
+        public bool IsFavorite { get; set; }
+
+        public bool ShouldBeShown { get; set; }
+
+        public float[] Vectors { get; set; }
+
+        public virtual bool IsValid => ValidFrom == null || ValidFrom <= DateTimeOffset.UtcNow && ValidTo == null || ValidTo > DateTimeOffset.UtcNow;
+    }
+}

LiteDB.Benchmarks/Models/FileMetaWithExclusionComponentModel.cs

@@ -0,0 +1,27 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace LiteDB.Benchmarks.Models
+{
+    public class FileMetaWithExclusionComponentModel : FileMetaBaseComponentModel
+    {
+        public FileMetaWithExclusionComponentModel()
+        {
+        }
+
+        public FileMetaWithExclusionComponentModel(FileMetaBaseComponentModel fileMetaBase)
+        {
+            FileId = fileMetaBase.FileId;
+            ParentId = fileMetaBase.ParentId;
+            Title = fileMetaBase.Title;
+            MimeType = fileMetaBase.MimeType;
+            Version = fileMetaBase.Version;
+            ValidFrom = fileMetaBase.ValidFrom;
+            ValidTo = fileMetaBase.ValidTo;
+            IsFavorite = fileMetaBase.IsFavorite;
+            ShouldBeShown = fileMetaBase.ShouldBeShown;
+        }
+
+        [NotMapped]
+        public override bool IsValid => base.IsValid;
+    }
+}

LiteDB.Benchmarks/Models/Generators/FileMetaGenerator.cs

@@ -10,8 +10,8 @@ namespace LiteDB.Benchmarks.Models.Generators
 
         private static T Generate()
         {
-            var docGuid = Guid.NewGuid();
-            
+            var docGuid = Guid.NewGuid();
+
             var generatedFileMeta = new T
             {
                 FileId = docGuid,
@@ -20,7 +20,7 @@ private static T Generate()
                 MimeType = "application/pdf",
                 IsFavorite = _random.Next(10) >= 9,
                 ShouldBeShown = _random.Next(10) >= 7,
-                Vectors =  Enumerable.Range(0, 128).Select(_ => (float)_random.NextDouble()).ToArray()
+                Vectors = Enumerable.Range(0, 128).Select(_ => (float)_random.NextDouble()).ToArray()
             };
 
             if (_random.Next(10) >= 5)

LiteDB.Benchmarks/Models/Generators/FileMetaGeneratorComponentModel.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace LiteDB.Benchmarks.Models.Generators
+{
+    public static class FileMetaGeneratorComponentModel<T> where T : FileMetaBaseComponentModel, new()
+    {
+        private static Random _random;
+
+        private static T Generate()
+        {
+            var docGuid = Guid.NewGuid();
+
+            var generatedFileMeta = new T
+            {
+                FileId = docGuid,
+                Version = _random.Next(5),
+                Title = $"Document-{docGuid}",
+                MimeType = "application/pdf",
+                IsFavorite = _random.Next(10) >= 9,
+                ShouldBeShown = _random.Next(10) >= 7,
+                Vectors = Enumerable.Range(0, 128).Select(_ => (float)_random.NextDouble()).ToArray()
+            };
+
+            if (_random.Next(10) >= 5)
+            {
+                generatedFileMeta.ValidFrom = DateTimeOffset.Now.AddDays(-20 + _random.Next(40));
+                generatedFileMeta.ValidFrom = DateTimeOffset.UtcNow.AddDays(-10 + _random.Next(40));
+            }
+
+            return generatedFileMeta;
+        }
+
+        public static List<T> GenerateList(int amountToGenerate)
+        {
+            _random = new Random(0);
+
+            var generatedList = new List<T>();
+            for (var i = 0; i < amountToGenerate; i++) generatedList.Add(Generate());
+
+            foreach (var fileMeta in generatedList)
+            {
+                if (_random.Next(100) <= 1)
+                {
+                    continue;
+                }
+
+                fileMeta.ParentId = generatedList[_random.Next(amountToGenerate)].Id;
+            }
+
+            return generatedList;
+        }
+    }
+}