MongoDBProvider.cs

using MongoDB.Bson;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using Waher.Events;
using Waher.Persistence.Filters;
using Waher.Persistence.MongoDB.Serialization;
using Waher.Persistence.MongoDB.Serialization.ReferenceTypes;
using Waher.Persistence.MongoDB.Serialization.ValueTypes;
using Waher.Persistence.Queues;
using Waher.Persistence.Serialization;
using Waher.Runtime.Cache;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence.MongoDB
{
    public class MongoDBProvider : IDatabaseProvider
    {
        private readonly Dictionary<string, IMongoCollection<BsonDocument>> collections = [];
        private readonly Dictionary<Type, IObjectSerializer> serializers = [];
        private readonly AutoResetEvent serializerAdded = new(false);
        private MongoClient client;
        private IMongoDatabase database;
        private string id;
        private string defaultCollectionName;
        private string lastCollectionName = null;
        private IMongoCollection<BsonDocument> lastCollection = null;
        private IMongoCollection<BsonDocument> defaultCollection;
 
        public MongoDBProvider(string DatabaseName, string DefaultCollectionName)
        {
            MongoClientSettings Settings = new();
            this.Init(Settings, DatabaseName, DefaultCollectionName);
        }
 
        public MongoDBProvider(string HostName, string DatabaseName, string DefaultCollectionName)
        {
            MongoClientSettings Settings = new()
            {
                Server = new MongoServerAddress(HostName)
            };
 
            this.Init(Settings, DatabaseName, DefaultCollectionName);
        }
 
        public MongoDBProvider(string HostName, int Port, string DatabaseName, string DefaultCollectionName)
        {
            MongoClientSettings Settings = new()
            {
                Server = new MongoServerAddress(HostName, Port)
            };
 
            this.Init(Settings, DatabaseName, DefaultCollectionName);
        }
 
        public MongoDBProvider(MongoClientSettings Settings, string DatabaseName, string DefaultCollectionName)
        {
            this.Init(Settings, DatabaseName, DefaultCollectionName);
        }
 
        private void Init(MongoClientSettings Settings, string DatabaseName, string DefaultCollectionName)
        {
            this.id = Guid.NewGuid().ToString().Replace("-", string.Empty);
            this.client = new MongoClient(Settings);
            this.database = this.client.GetDatabase(DatabaseName);
 
            this.defaultCollectionName = DefaultCollectionName;
            this.defaultCollection = this.GetCollection(this.defaultCollectionName);
 
            ConstructorInfo DefaultConstructor;
            IObjectSerializer S;
 
            foreach (Type T in Waher.Runtime.Inventory.Types.GetTypesImplementingInterface(typeof(IObjectSerializer)))
            {
                try
                {
                    DefaultConstructor = Types.GetDefaultConstructor(T);
                    if (DefaultConstructor is null)
                        continue;
 
                    S = DefaultConstructor.Invoke(Types.NoParameters) as IObjectSerializer;
                    if (S is null)
                        continue;
                }
                catch (Exception)
                {
                    continue;
                }
 
                this.serializers[S.ValueType] = S;
            }
 
            this.serializers[typeof(GenericObject)] = new GenericObjectSerializer(this, false);
            this.serializers[typeof(object)] = new GenericObjectSerializer(this, true);
        }
 
        public string Id => this.id;
 
        public int ObjectIdByteCount => 12;
 
        public IMongoCollection<BsonDocument> GetCollection(string CollectionName)
        {
            IMongoCollection<BsonDocument> Result;
 
            lock (this.collections)
            {
                if (CollectionName == this.lastCollectionName)
                    Result = this.lastCollection;
                else
                {
                    if (!this.collections.TryGetValue(CollectionName, out Result))
                    {
                        Result = this.database.GetCollection<BsonDocument>(CollectionName);
                        this.collections[CollectionName] = Result;
                    }
 
                    this.lastCollection = Result;
                    this.lastCollectionName = CollectionName;
                }
            }
 
            return Result;
        }
 
        public MongoClient Client => this.client;
 
        public string DefaultCollectionName => this.defaultCollectionName;
 
        public IMongoCollection<BsonDocument> DefaultCollection => this.defaultCollection;
 
        public IObjectSerializer GetObjectSerializer(Type Type)
        {
            IObjectSerializer Result;
            TypeInfo TI = Type.GetTypeInfo();
 
            lock (this.collections)
            {
                if (this.serializers.TryGetValue(Type, out Result))
                    return Result;
 
                if (TI.IsEnum)
                    Result = new EnumSerializer(Type);
                else if (Type.IsArray)
                {
                    Type ElementType = Type.GetElementType();
                    Type T = Waher.Runtime.Inventory.Types.GetType(typeof(ByteArraySerializer).FullName.Replace("ByteArray", "Array"));
                    Type SerializerType = T.MakeGenericType([ElementType]);
                    Result = (IObjectSerializer)Activator.CreateInstance(SerializerType, this);
                }
                else if (TI.IsGenericType)
                {
                    Type GT = Type.GetGenericTypeDefinition();
                    if (GT == typeof(Nullable<>))
                    {
                        Type NullableType = Type.GenericTypeArguments[0];
 
                        if (NullableType.IsEnum)
                            Result = new Serialization.NullableTypes.NullableEnumSerializer(NullableType);
                        else
                            Result = null;
                    }
                    else
                        Result = null;
                }
                else
                    Result = null;
 
                if (Result is not null)
                {
                    this.serializers[Type] = Result;
                    this.serializerAdded.Set();
 
                    return Result;
                }
            }
 
            try
            {
                Result = new ObjectSerializer(Type, this);
 
                lock (this.collections)
                {
                    this.serializers[Type] = Result;
                    this.serializerAdded.Set();
                }
            }
            catch (FileLoadException ex)
            {
                // Serializer in the process of being generated from another task or thread.
 
                while (true)
                {
                    if (!this.serializerAdded.WaitOne(1000))
                        ExceptionDispatchInfo.Capture(ex).Throw();
 
                    lock (this.collections)
                    {
                        if (this.serializers.TryGetValue(Type, out Result))
                            return Result;
                    }
                }
            }
 
            return Result;
        }
 
        public ObjectSerializer GetObjectSerializerEx(object Object)
        {
            return this.GetObjectSerializerEx(Object.GetType());
        }
 
        public ObjectSerializer GetObjectSerializerEx(Type Type)
        {
            if (this.GetObjectSerializer(Type) is not ObjectSerializer Serializer)
                throw new Exception("Objects of type " + Type.FullName + " must be embedded.");
 
            return Serializer;
        }
 
        public async Task Insert(object Object)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Object);
            string CollectionName = Serializer.CollectionName(Object);
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Serializer.HasObjectIdField)
            {
                if (Serializer.HasObjectId(Object))
                    throw new Exception("Object already has an Object ID. If updating an object, use the Update method.");
                else
                    await Serializer.GetObjectId(Object, true);
            }
            else
            {
                BsonDocument Doc = Object.ToBsonDocument(Object.GetType(), Serializer);
                await Collection.InsertOneAsync(Doc);
            }
        }
 
        public Task Insert(params object[] Objects)
        {
            return this.Insert((IEnumerable<object>)Objects);
        }
 
        public async Task Insert(IEnumerable<object> Objects)
        {
            Dictionary<string, KeyValuePair<IMongoCollection<BsonDocument>, LinkedList<BsonDocument>>> DocumentsPerCollection = [];
            Type Type;
            Type LastType = null;
            ObjectSerializer Serializer = null;
            string CollectionName;
            string LastCollectionName = null;
            IMongoCollection<BsonDocument> Collection;
            IMongoCollection<BsonDocument> LastCollection = null;
            LinkedList<BsonDocument> Documents = null;
            BsonDocument Document;
 
            foreach (object Object in Objects)
            {
                Type = Object.GetType();
 
                if (Type != LastType)
                {
                    Serializer = this.GetObjectSerializerEx(Type);
                    CollectionName = Serializer.CollectionName(Object);
                    LastType = Type;
 
                    if (CollectionName == LastCollectionName)
                        Collection = LastCollection;
                    else
                    {
                        LastCollectionName = CollectionName;
 
                        if (string.IsNullOrEmpty(CollectionName))
                            CollectionName = this.defaultCollectionName;
 
                        if (DocumentsPerCollection.TryGetValue(CollectionName, out KeyValuePair<IMongoCollection<BsonDocument>, LinkedList<BsonDocument>> P))
                            Collection = P.Key;
                        else
                        {
                            Collection = this.GetCollection(CollectionName);
                            P = new KeyValuePair<IMongoCollection<BsonDocument>, LinkedList<BsonDocument>>(Collection, new LinkedList<BsonDocument>());
                            DocumentsPerCollection[CollectionName] = P;
                        }
 
                        Documents = P.Value;
                        LastCollection = Collection;
                    }
                }
 
                Document = Object.ToBsonDocument(Type, Serializer);
                Documents.AddLast(Document);
            }
 
            foreach (KeyValuePair<IMongoCollection<BsonDocument>, LinkedList<BsonDocument>> P2 in DocumentsPerCollection.Values)
                await P2.Key.InsertManyAsync(P2.Value);
        }
 
        public Task InsertLazy(object Object, ObjectCallback Callback)
            => Process(Object, this.Insert(Object), Callback);
 
        public Task InsertLazy(object[] Objects, ObjectsCallback Callback)
            => Process(Objects, this.Insert(Objects), Callback);
 
        public Task InsertLazy(IEnumerable<object> Objects, ObjectsCallback Callback)
            => Process(Objects, this.Insert(Objects), Callback);
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return this.Find<T>(Offset, MaxCount, (Filter)null, SortOrder);
        }
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Find<T>(Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, Filter Filter,
            T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Find(Serializer, Collection, Offset, MaxCount, BsonFilter, ContinueAfter, SortOrder);
        }
 
        public Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, FilterDefinition<BsonDocument> BsonFilter,
            params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            return Find<T>(Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<IEnumerable<T>> Find<T>(string CollectionName, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Find<T>(Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<IEnumerable<T>> Find<T>(string CollectionName, int Offset, int MaxCount, Filter Filter,
            T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Find(Serializer, Collection, Offset, MaxCount, BsonFilter, ContinueAfter, SortOrder);
        }
 
        public Task<IEnumerable<object>> Find(string CollectionName, int Offset, int MaxCount, params string[] SortOrder)
        {
            return this.Find(CollectionName, Offset, MaxCount, null, SortOrder);
        }
 
        public Task<IEnumerable<object>> Find(string CollectionName, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(object));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Find<object>(Serializer, Collection, Offset, MaxCount, BsonFilter, SortOrder);
        }
 
        private static async Task<IEnumerable<T>> Find<T>(ObjectSerializer Serializer, IMongoCollection<BsonDocument> Collection,
            int Offset, int MaxCount, FilterDefinition<BsonDocument> BsonFilter, T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            if (ContinueAfter is not null)
                throw new NotImplementedException("Paginated searches not implemented in MongoDB provider.");
 
            IFindFluent<BsonDocument, BsonDocument> ResultSet = Collection.Find(BsonFilter);
 
            if (SortOrder.Length > 0)
            {
                SortDefinition<BsonDocument> SortDefinition = null;
 
                foreach (string SortBy in SortOrder)
                {
                    if (SortDefinition is null)
                    {
                        if (SortBy.StartsWith('-'))
                            SortDefinition = Builders<BsonDocument>.Sort.Descending(Serializer.ToShortName(SortBy[1..]));
                        else
                            SortDefinition = Builders<BsonDocument>.Sort.Ascending(Serializer.ToShortName(SortBy));
                    }
                    else
                    {
                        if (SortBy.StartsWith('-'))
                            SortDefinition = SortDefinition.Descending(Serializer.ToShortName(SortBy[1..]));
                        else
                            SortDefinition = SortDefinition.Ascending(Serializer.ToShortName(SortBy));
                    }
                }
 
                ResultSet = ResultSet.Sort(SortDefinition);
            }
 
            if (Offset > 0)
                ResultSet = ResultSet.Skip(Offset);
 
            if (MaxCount < int.MaxValue)
                ResultSet = ResultSet.Limit(MaxCount);
 
            IAsyncCursor<BsonDocument> Cursor = await ResultSet.ToCursorAsync();
            LinkedList<T> Result = new();
            BsonDeserializationArgs Args = new()
            {
                NominalType = typeof(T)
            };
 
            while (await Cursor.MoveNextAsync())
            {
                foreach (BsonDocument Document in Cursor.Current)
                {
                    BsonDocumentReader Reader = new(Document);
                    BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
 
                    if (Serializer.Deserialize(Context, Args) is T Obj)
                        Result.AddLast(Obj);
                }
            }
 
            return Result;
        }
 
        internal static FilterDefinition<BsonDocument> Convert(Filter Filter, ObjectSerializer Serializer)
        {
            if (Filter is FilterChildren FilterChildren)
            {
                Filter[] ChildFilters = FilterChildren.ChildFilters;
                int i, c = ChildFilters.Length;
                FilterDefinition<BsonDocument>[] Children = new FilterDefinition<BsonDocument>[c];
 
                for (i = 0; i < c; i++)
                    Children[i] = Convert(ChildFilters[i], Serializer);
 
                if (Filter is FilterAnd)
                    return Builders<BsonDocument>.Filter.And(Children);
                else if (Filter is FilterOr)
                    return Builders<BsonDocument>.Filter.Or(Children);
                else
                    throw UnknownFilterType(Filter);
            }
            else if (Filter is FilterChild FilterChild)
            {
                FilterDefinition<BsonDocument> Child = Convert(FilterChild.ChildFilter, Serializer);
 
                if (Filter is FilterNot)
                    return Builders<BsonDocument>.Filter.Not(Child);
                else
                    throw UnknownFilterType(Filter);
            }
            else if (Filter is FilterFieldValue FilterFieldValue)
            {
                object Value = FilterFieldValue.Value;
                string FieldName = Serializer.ToShortName(FilterFieldValue.FieldName, ref Value);
                bool HasType = Serializer.TryGetFieldType(FilterFieldValue.FieldName, null, out Type FieldType);
                bool IsDefaultValue = Serializer.IsDefaultValue(FilterFieldValue.FieldName, Value);
 
                if (Filter is FilterFieldEqualTo)
                {
                    if (IsDefaultValue)
                        return Builders<BsonDocument>.Filter.Eq<string>(FieldName, null);
                    else if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Eq<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Eq<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Eq<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Eq<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Eq<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Eq<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Eq<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Eq<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Eq<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Eq<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Eq<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Eq<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Eq<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Eq<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Eq<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Eq<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is DateTimeOffset DTO)
                    {
                        return Builders<BsonDocument>.Filter.And(
                            Builders<BsonDocument>.Filter.Eq<long>(FieldName + ".tp", (long)(DTO.DateTime - ObjectSerializer.UnixEpoch).TotalMilliseconds),
                            Builders<BsonDocument>.Filter.Eq<string>(FieldName + ".tz", DTO.Offset.ToString()));
                    }
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Eq<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Eq<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Eq<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else if (Filter is FilterFieldNotEqualTo)
                {
                    if (IsDefaultValue)
                        return Builders<BsonDocument>.Filter.Ne<string>(FieldName, null);
                    else if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Ne<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Ne<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Ne<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Ne<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Ne<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Ne<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Ne<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Ne<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Ne<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Ne<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Ne<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Ne<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Ne<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Ne<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Ne<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Ne<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is DateTimeOffset DTO)
                    {
                        return Builders<BsonDocument>.Filter.Or(
                            Builders<BsonDocument>.Filter.Ne<long>(FieldName + ".tp", (long)(DTO.DateTime - ObjectSerializer.UnixEpoch).TotalMilliseconds),
                            Builders<BsonDocument>.Filter.Ne<string>(FieldName + ".tz", DTO.Offset.ToString()));
                    }
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Ne<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Ne<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Ne<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else if (Filter is FilterFieldGreaterThan)
                {
                    if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Gt<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Gt<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Gt<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Gt<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Gt<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Gt<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Gt<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Gt<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Gt<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Gt<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Gt<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Gt<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Gt<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Gt<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Gt<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Gt<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Gt<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Gt<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Gt<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else if (Filter is FilterFieldGreaterOrEqualTo)
                {
                    if (IsDefaultValue)
                    {
                        return Convert(new FilterOr(new FilterFieldGreaterThan(FieldName, Value),
                            new FilterFieldEqualTo(FieldName, Value)), Serializer);
                    }
                    else if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Gte<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Gte<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Gte<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Gte<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Gte<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Gte<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Gte<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Gte<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Gte<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Gte<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Gte<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Gte<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Gte<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Gte<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Gte<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Gte<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Gte<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Gte<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Gte<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else if (Filter is FilterFieldLesserThan)
                {
                    if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Lt<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Lt<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Lt<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Lt<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Lt<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Lt<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Lt<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Lt<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Lt<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Lt<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Lt<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Lt<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Lt<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Lt<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Lt<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Lt<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Lt<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Lt<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Lt<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else if (Filter is FilterFieldLesserOrEqualTo)
                {
                    if (IsDefaultValue)
                    {
                        return Convert(new FilterOr(new FilterFieldLesserThan(FieldName, Value),
                            new FilterFieldEqualTo(FieldName, Value)), Serializer);
                    }
                    else if (Value is string s)
                    {
                        if (HasType && FieldType == typeof(CaseInsensitiveString))
                            return Builders<BsonDocument>.Filter.Lte<string>(FieldName + "_L", s);
                        else
                            return Builders<BsonDocument>.Filter.Lte<string>(FieldName, s);
                    }
                    else if (Value is CaseInsensitiveString cis)
                        return Builders<BsonDocument>.Filter.Lte<string>(FieldName + "_L", cis.LowerCase);
                    else if (Value is sbyte i8)
                        return Builders<BsonDocument>.Filter.Lte<int>(FieldName, i8);
                    else if (Value is short i16)
                        return Builders<BsonDocument>.Filter.Lte<int>(FieldName, i16);
                    else if (Value is int i32)
                        return Builders<BsonDocument>.Filter.Lte<int>(FieldName, i32);
                    else if (Value is long i64)
                        return Builders<BsonDocument>.Filter.Lte<long>(FieldName, i64);
                    else if (Value is byte ui8)
                        return Builders<BsonDocument>.Filter.Lte<int>(FieldName, ui8);
                    else if (Value is ushort ui16)
                        return Builders<BsonDocument>.Filter.Lte<int>(FieldName, ui16);
                    else if (Value is uint ui32)
                        return Builders<BsonDocument>.Filter.Lte<long>(FieldName, ui32);
                    else if (Value is ulong ui64)
                        return Builders<BsonDocument>.Filter.Lte<Decimal128>(FieldName, ui64);
                    else if (Value is double d)
                        return Builders<BsonDocument>.Filter.Lte<double>(FieldName, d);
                    else if (Value is float f)
                        return Builders<BsonDocument>.Filter.Lte<double>(FieldName, f);
                    else if (Value is decimal d2)
                        return Builders<BsonDocument>.Filter.Lte<Decimal128>(FieldName, d2);
                    else if (Value is bool b)
                        return Builders<BsonDocument>.Filter.Lte<bool>(FieldName, b);
                    else if (Value is DateTime DT)
                        return Builders<BsonDocument>.Filter.Lte<long>(FieldName, (long)(DT - ObjectSerializer.UnixEpoch).TotalMilliseconds);
                    else if (Value is TimeSpan TS)
                        return Builders<BsonDocument>.Filter.Lte<string>(FieldName, TS.ToString());
                    else if (Value is Guid Guid)
                        return Builders<BsonDocument>.Filter.Lte<string>(FieldName, Guid.ToString());
                    else if (Value is ObjectId ObjectId)
                        return Builders<BsonDocument>.Filter.Lte<ObjectId>(FieldName, ObjectId);
                    else
                        throw UnhandledFilterValueDataType(Serializer.ValueType.FullName, FieldName, Value);
                }
                else
                    throw UnknownFilterType(Filter);
            }
            else
            {
                if (Filter is FilterFieldLikeRegEx FilterFieldLikeRegEx)
                {
                    return Builders<BsonDocument>.Filter.Regex(Serializer.ToShortName(FilterFieldLikeRegEx.FieldName),
                        FilterFieldLikeRegEx.RegularExpression);
                }
                else
                    throw UnknownFilterType(Filter);
            }
        }
 
        private static NotSupportedException UnknownFilterType(Filter Filter)
        {
            return new NotSupportedException("Filters of type " + Filter.GetType().FullName + " not supported.");
        }
 
        private static NotSupportedException UnhandledFilterValueDataType(string TypeName, string FieldName, object Value)
        {
            if (Value is null)
            {
                return new NotSupportedException("Null filter values for field " + TypeName + "." + FieldName +
                      " not supported.");
            }
            else
            {
                return new NotSupportedException("Filter values of type " + Value.GetType().FullName +
                    " for field " + TypeName + "." + FieldName + " not supported.");
            }
        }
 
        public async Task<IPage<T>> FindFirst<T>(int PageSize, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IEnumerable<T> Items = await this.Find<T>(0, PageSize, SortOrder);
            return new Page<T>(PageSize, null, null, SortOrder, Items, Serializer, this);
        }
 
        public async Task<IPage<T>> FindFirst<T>(int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IEnumerable<T> Items = await this.Find<T>(0, PageSize, Filter, SortOrder);
            return new Page<T>(PageSize, null, Filter, SortOrder, Items, Serializer, this);
        }
 
        public async Task<IPage<object>> FindFirst(string Collection, int PageSize, params string[] SortOrder)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(object));
            IEnumerable<object> Items = await this.Find(Collection, 0, PageSize, SortOrder);
            return new Page<object>(PageSize, Collection, null, SortOrder, Items, Serializer, this);
        }
 
        public async Task<IPage<object>> FindFirst(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(object));
            IEnumerable<object> Items = await this.Find(Collection, 0, PageSize, Filter, SortOrder);
            return new Page<object>(PageSize, Collection, Filter, SortOrder, Items, Serializer, this);
        }
 
        public async Task<IPage<T>> FindFirst<T>(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IEnumerable<T> Items = await this.Find<T>(Collection, 0, PageSize, Filter, SortOrder);
            return new Page<T>(PageSize, Collection, Filter, SortOrder, Items, Serializer, this);
        }
 
        public Task<IPage<T>> FindNext<T>(IPage<T> Page)
            where T : class
        {
            if (Page is Page<T> CurrentPage)
                return CurrentPage.FindNext();
            else
                throw new IOException("Incompatible page.");
        }
 
        public Task<IPage<object>> FindNext(IPage<object> Page)
        {
            if (Page is Page<object> CurrentPage)
                return CurrentPage.FindNext();
            else
                throw new IOException("Incompatible page.");
        }
 
        public Task<T> TryLoadObject<T>(object ObjectId)
            where T : class
        {
            ObjectId OID;
 
            if (ObjectId is ObjectId ObjId)
                OID = ObjId;
            else if (ObjectId is string s)
                OID = new ObjectId(s);
            else if (ObjectId is byte[] A)
                OID = new ObjectId(A);
            else if (ObjectId is Guid Guid)
                OID = GeneratedObjectSerializerBase.GuidToObjectId(Guid);
            else
                throw new NotSupportedException("Unsupported type for Object ID: " + ObjectId.GetType().FullName);
 
            return this.TryLoadObject<T>(OID);
        }
 
        public async Task<T> TryLoadObject<T>(ObjectId ObjectId)
            where T : class
        {
            string Key = typeof(T).FullName + " " + ObjectId.ToString();
 
            if (this.loadCache.TryGetValue(Key, out object Obj) && Obj is T Result)
                return Result;
 
            ObjectSerializer S = this.GetObjectSerializerEx(typeof(T));
            IEnumerable<T> ReferencedObjects = await this.Find<T>(0, 2, new FilterFieldEqualTo(S.ObjectIdMemberName, ObjectId));
            T First = default;
 
            foreach (T Item in ReferencedObjects)
            {
                if (First is null)
                    First = Item;
                else
                    throw new Exception("Multiple objects of type T found with object ID " + ObjectId.ToString());
            }
 
            if (First is not null)
                this.loadCache.Add(Key, First);     // Speeds up readout if reading multiple objects referencing a few common sub-objects.
 
            return First;
        }
 
        public Task<T> TryLoadObject<T>(string CollectionName, object ObjectId)
            where T : class
        {
            ObjectId OID;
 
            if (ObjectId is ObjectId ObjId)
                OID = ObjId;
            else if (ObjectId is string s)
                OID = new ObjectId(s);
            else if (ObjectId is byte[] A)
                OID = new ObjectId(A);
            else if (ObjectId is Guid Guid)
                OID = GeneratedObjectSerializerBase.GuidToObjectId(Guid);
            else
                throw new NotSupportedException("Unsupported type for Object ID: " + ObjectId.GetType().FullName);
 
            return this.TryLoadObject<T>(CollectionName, OID);
        }
 
        public async Task<T> TryLoadObject<T>(string CollectionName, ObjectId ObjectId)
            where T : class
        {
            string Key = typeof(T).FullName + " " + ObjectId.ToString();
 
            if (this.loadCache.TryGetValue(Key, out object Obj) && Obj is T Result)
                return Result;
 
            ObjectSerializer S = this.GetObjectSerializerEx(typeof(T));
            IEnumerable<T> ReferencedObjects = await this.Find<T>(CollectionName, 0, 2, new FilterFieldEqualTo(S.ObjectIdMemberName, ObjectId));
            T First = default;
 
            foreach (T Item in ReferencedObjects)
            {
                if (First is null)
                    First = Item;
                else
                    throw new Exception("Multiple objects of type T found with object ID " + ObjectId.ToString());
            }
 
            if (First is not null)
                this.loadCache.Add(Key, First);     // Speeds up readout if reading multiple objects referencing a few common sub-objects.
 
            return First;
        }
 
        public async Task<object> TryLoadObject(string CollectionName, object ObjectId)
        {
            ObjectId OID;
 
            if (ObjectId is ObjectId ObjId)
                OID = ObjId;
            else if (ObjectId is string s)
                OID = new ObjectId(s);
            else if (ObjectId is byte[] A)
                OID = new ObjectId(A);
            else if (ObjectId is Guid Guid)
                OID = GeneratedObjectSerializerBase.GuidToObjectId(Guid);
            else
                throw new NotSupportedException("Unsupported type for Object ID: " + ObjectId.GetType().FullName);
 
            ObjectSerializer S = this.GetObjectSerializerEx(typeof(object));
            IEnumerable<object> ReferencedObjects = await this.Find(CollectionName, 0, 2, new FilterFieldEqualTo(S.ObjectIdMemberName, OID));
            object First = null;
 
            foreach (object Item in ReferencedObjects)
            {
                if (First is null)
                    First = Item;
                else
                    throw new Exception("Multiple objects of type T found with object ID " + ObjectId.ToString());
            }
 
            return First;
        }
 
        private readonly Cache<string, object> loadCache = new(10000, new TimeSpan(0, 0, 10), new TimeSpan(0, 0, 5), true);  // TODO: Make parameters configurable.
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return this.Process<T>(Processor, Offset, MaxCount, (Filter)null, SortOrder);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, Filter Filter,
            T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, ContinueAfter, SortOrder);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, FilterDefinition<BsonDocument> BsonFilter,
            params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            string CollectionName = Serializer.CollectionName(null);
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, string CollectionName, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, null, SortOrder);
        }
 
        public Task<bool> Process<T>(IProcessor<T> Processor, string CollectionName, int Offset, int MaxCount, Filter Filter,
            T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, ContinueAfter, SortOrder);
        }
 
        public Task<bool> Process(IProcessor<object> Processor, string CollectionName, int Offset, int MaxCount, params string[] SortOrder)
        {
            return this.Process(Processor, CollectionName, Offset, MaxCount, null, SortOrder);
        }
 
        public Task<bool> Process(IProcessor<object> Processor, string CollectionName, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(object));
            IMongoCollection<BsonDocument> Collection;
            FilterDefinition<BsonDocument> BsonFilter;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            if (Filter is null)
                BsonFilter = new BsonDocument();
            else
                BsonFilter = Convert(Filter, Serializer);
 
            return Process(Processor, Serializer, Collection, Offset, MaxCount, BsonFilter, SortOrder);
        }
 
        private static async Task<bool> Process<T>(IProcessor<T> Processor, ObjectSerializer Serializer, IMongoCollection<BsonDocument> Collection,
            int Offset, int MaxCount, FilterDefinition<BsonDocument> BsonFilter, T ContinueAfter, params string[] SortOrder)
            where T : class
        {
            if (ContinueAfter is not null)
                throw new NotImplementedException("Paginated searches not implemented in MongoDB provider.");
 
            IFindFluent<BsonDocument, BsonDocument> ResultSet = Collection.Find(BsonFilter);
 
            if (SortOrder.Length > 0)
            {
                SortDefinition<BsonDocument> SortDefinition = null;
 
                foreach (string SortBy in SortOrder)
                {
                    if (SortDefinition is null)
                    {
                        if (SortBy.StartsWith('-'))
                            SortDefinition = Builders<BsonDocument>.Sort.Descending(Serializer.ToShortName(SortBy[1..]));
                        else
                            SortDefinition = Builders<BsonDocument>.Sort.Ascending(Serializer.ToShortName(SortBy));
                    }
                    else
                    {
                        if (SortBy.StartsWith('-'))
                            SortDefinition = SortDefinition.Descending(Serializer.ToShortName(SortBy[1..]));
                        else
                            SortDefinition = SortDefinition.Ascending(Serializer.ToShortName(SortBy));
                    }
                }
 
                ResultSet = ResultSet.Sort(SortDefinition);
            }
 
            if (Offset > 0)
                ResultSet = ResultSet.Skip(Offset);
 
            if (MaxCount < int.MaxValue)
                ResultSet = ResultSet.Limit(MaxCount);
 
            IAsyncCursor<BsonDocument> Cursor = await ResultSet.ToCursorAsync();
            BsonDeserializationArgs Args = new()
            {
                NominalType = typeof(T)
            };
 
            bool Asynchronous = Processor.IsAsynchronous;
            bool Continue;
 
            while (await Cursor.MoveNextAsync())
            {
                foreach (BsonDocument Document in Cursor.Current)
                {
                    BsonDocumentReader Reader = new(Document);
                    BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
 
                    if (Serializer.Deserialize(Context, Args) is T Obj)
                    {
                        if (Asynchronous)
                            Continue = await Processor.ProcessAsync(Obj);
                        else
                            Continue = Processor.Process(Obj);
 
                        if (!Continue)
                            return false;
                    }
                }
            }
 
            if (Asynchronous)
                return await Processor.FlushAsync();
            else
                return Processor.Flush();
        }
 
        public async Task Update(object Object)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Object);
            ObjectId ObjectId = await Serializer.GetObjectId(Object, false);
            string CollectionName = Serializer.CollectionName(Object);
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            BsonDocument Doc = Object.ToBsonDocument(Object.GetType(), Serializer);
            await Collection.ReplaceOneAsync(Builders<BsonDocument>.Filter.Eq<ObjectId>("_id", ObjectId), Doc);
        }
 
        public Task Update(params object[] Objects)
        {
            return this.Update((IEnumerable<object>)Objects);
        }
 
        public async Task Update(IEnumerable<object> Objects)
        {
            foreach (object Obj in Objects)
                await this.Update(Obj);
        }
 
        public Task UpdateLazy(object Object, ObjectCallback Callback)
            => Process(Object, this.Update(Object), Callback);
 
        public Task UpdateLazy(object[] Objects, ObjectsCallback Callback)
            => Process(Objects, this.Update(Objects), Callback);
 
        public Task UpdateLazy(IEnumerable<object> Objects, ObjectsCallback Callback)
            => Process(Objects, this.Update(Objects), Callback);
 
        public async Task Delete(object Object)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Object);
            ObjectId ObjectId = await Serializer.GetObjectId(Object, false);
            string CollectionName = Serializer.CollectionName(Object);
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.defaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            await Collection.DeleteOneAsync(Builders<BsonDocument>.Filter.Eq<ObjectId>("_id", ObjectId));
        }
 
        public Task Delete(params object[] Objects)
        {
            return this.Delete((IEnumerable<object>)Objects);
        }
 
        public async Task Delete(IEnumerable<object> Objects)
        {
            foreach (object Obj in Objects)
                await this.Delete(Obj);
        }
 
        private static async Task Process(object Object, Task Op, ObjectCallback Callback)
        {
            await Op;
            if (Callback is not null)
                Callback(Object);
        }
 
        private static async Task Process(IEnumerable<object> Objects, Task Op, ObjectsCallback Callback)
        {
            await Op;
 
            if (Callback is not null)
                Callback(Objects);
        }
 
        public Task DeleteLazy(object Object, ObjectCallback Callback)
            => Process(Object, this.Delete(Object), Callback);
 
        public Task DeleteLazy(object[] Objects, ObjectsCallback Callback)
            => Process(Objects, this.Delete(Objects), Callback);
 
        public Task DeleteLazy(IEnumerable<object> Objects, ObjectsCallback Callback)
            => Process(Objects, this.Delete(Objects), Callback);
 
        public async Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            IEnumerable<T> Result = await this.Find<T>(Offset, MaxCount, SortOrder);
            await this.Delete(Result);
            return Result;
        }
 
        public async Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            IEnumerable<T> Result = await this.Find<T>(Offset, MaxCount, Filter, SortOrder);
            await this.Delete(Result);
            return Result;
        }
 
        public async Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            IEnumerable<object> Result = await this.Find(Collection, Offset, MaxCount, SortOrder);
            await this.Delete(Result);
            return Result;
        }
 
        public async Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            IEnumerable<object> Result = await this.Find(Collection, Offset, MaxCount, Filter, SortOrder);
            await this.Delete(Result);
            return Result;
        }
 
        public async Task DeleteLazy<T>(int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback)
            where T : class
        {
            IEnumerable<T> Objects = await this.FindDelete<T>(Offset, MaxCount, SortOrder);
            if (Callback is not null)
                Callback(Objects);
        }
 
        public async Task DeleteLazy<T>(int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback)
            where T : class
        {
            IEnumerable<T> Objects = await this.FindDelete<T>(Offset, MaxCount, Filter, SortOrder);
            if (Callback is not null)
                Callback(Objects);
        }
 
        public async Task DeleteLazy(string Collection, int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback)
        {
            IEnumerable<object> Objects = await this.FindDelete(Collection, Offset, MaxCount, SortOrder);
            if (Callback is not null)
                Callback(Objects);
        }
 
        public async Task DeleteLazy(string Collection, int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback)
        {
            IEnumerable<object> Objects = await this.FindDelete(Collection, Offset, MaxCount, Filter, SortOrder);
            if (Callback is not null)
                Callback(Objects);
        }
 
        public Task Clear(string CollectionName)
        {
            IMongoCollection<BsonDocument> Collection = this.GetCollection(CollectionName);
            return Collection.DeleteManyAsync(FilterDefinition<BsonDocument>.Empty);
        }
 
        public async Task AddIndex(string CollectionName, string[] FieldNames)
        {
            IMongoCollection<BsonDocument> Collection;
            List<BsonDocument> Indices;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.DefaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            IAsyncCursor<BsonDocument> Cursor = await Collection.Indexes.ListAsync();
            Indices = await Cursor.ToListAsync<BsonDocument>();
 
            await ObjectSerializer.CheckIndexExists(Collection, Indices, FieldNames, null);
        }
 
        public async Task RemoveIndex(string CollectionName, string[] FieldNames)
        {
            IMongoCollection<BsonDocument> Collection;
            List<BsonDocument> Indices;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.DefaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            IAsyncCursor<BsonDocument> Cursor = await Collection.Indexes.ListAsync();
            Indices = await Cursor.ToListAsync<BsonDocument>();
 
            await ObjectSerializer.RemoveIndex(Collection, Indices, FieldNames);
        }
 
        public async Task<string[][]> GetIndices(string CollectionName)
        {
            IMongoCollection<BsonDocument> Collection;
 
            if (string.IsNullOrEmpty(CollectionName))
                Collection = this.DefaultCollection;
            else
                Collection = this.GetCollection(CollectionName);
 
            IAsyncCursor<BsonDocument> Cursor = await Collection.Indexes.ListAsync();
            ChunkedList<string[]> Result = [];
 
            while (await Cursor.MoveNextAsync())
            {
                foreach (BsonDocument Index in Cursor.Current)
                {
                    ChunkedList<string> FieldNames = null;
 
                    foreach (BsonElement E in Index.Elements)
                    {
                        if (E.Name != "key")
                            continue;
 
                        FieldNames = [];
 
                        foreach (BsonElement E2 in E.Value.AsBsonDocument.Elements)
                        {
                            // Value is typically 1 (ascending) or -1 (descending). Can also be "text" etc.
                            if (E2.Value.IsInt32 || E2.Value.IsInt64 || E2.Value.IsDouble)
                            {
                                double v = E2.Value.ToDouble();
                                if (v < 0)
                                    FieldNames.Add("-" + E2.Name);
                                else
                                    FieldNames.Add(E2.Name);
                            }
                            else if (E2.Value.IsString)
                            {
                                // For text or hashed indexes we just report the field name without sign.
                                FieldNames.Add(E2.Name);
                            }
                            else
                            {
                                // Fallback: just add field name.
                                FieldNames.Add(E2.Name);
                            }
                        }
 
                        break; // Done with this index.
                    }
 
                    if (FieldNames is not null && FieldNames.Count > 0)
                        Result.Add([.. FieldNames]);
                }
            }
 
            return [.. Result];
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return this.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, false);
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread)
        {
            return this.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, false, Thread);
        }
 
        public Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return this.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, true);
        }
 
        public Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread)
        {
            return this.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, true, Thread);
        }
 
        public Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair)
        {
            return this.Analyze(null, XsltPath, ProgramDataFolder, ExportData, Repair, null);
        }
 
        public async Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair,
            ProfilerThread Thread)
        {
            Thread?.Start();
            Output.WriteStartDocument();
 
            if (!string.IsNullOrEmpty(XsltPath))
            {
                if (File.Exists(XsltPath))
                {
                    try
                    {
                        byte[] XsltBin = File.ReadAllBytes(XsltPath);
 
                        Output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"data:text/xsl;base64," +
                            System.Convert.ToBase64String(XsltBin) + "\"");
                    }
                    catch (Exception)
                    {
                        Output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"" + Encode(XsltPath) + "\"");
                    }
                }
                else
                    Output.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"" + Encode(XsltPath) + "\"");
            }
 
            Output.WriteStartElement("DatabaseStatistics", "http://waher.se/Schema/Persistence/Statistics.xsd");
 
            foreach (string CollectionName in (await this.database.ListCollectionNamesAsync()).ToEnumerable())
            {
                Thread?.NewState(CollectionName);
 
                IMongoCollection<BsonDocument> Collection = this.database.GetCollection<BsonDocument>(CollectionName);
 
                Output.WriteStartElement("File");
                Output.WriteAttributeString("id", Collection.CollectionNamespace.FullName);
                Output.WriteAttributeString("collectionName", CollectionName);
                Output.WriteAttributeString("count", (await Collection.CountDocumentsAsync(Builders<BsonDocument>.Filter.Empty)).ToString());
 
                if (Collection.Settings.WriteEncoding is not null)
                    Output.WriteAttributeString("encoding", Collection.Settings.WriteEncoding.WebName);
 
                if (Collection.Settings.WriteConcern.WTimeout.HasValue)
                    Output.WriteAttributeString("timeoutMs", ((int)Collection.Settings.WriteConcern.WTimeout.Value.TotalMilliseconds).ToString());
 
                foreach (BsonDocument Index in (await Collection.Indexes.ListAsync()).ToEnumerable())
                {
                    List<string> FieldNames = [];
 
                    Output.WriteStartElement("Index");
 
                    foreach (BsonElement E in Index.Elements)
                    {
                        switch (E.Name)
                        {
                            case "key":
                                foreach (BsonElement E2 in E.Value.AsBsonDocument.Elements)
                                {
                                    if (E2.Value.AsInt32 < 0)
                                        FieldNames.Add("-" + E2.Name);
                                    else
                                        FieldNames.Add(E2.Name);
                                }
                                break;
 
                            case "name":
                                Output.WriteAttributeString("id", E.Value.AsString);
                                break;
                        }
                    }
 
                    foreach (string Field in FieldNames)
                        Output.WriteElementString("Field", Field);
 
                    Output.WriteEndElement();
                }
 
                Output.WriteEndElement();
            }
 
            Output.WriteEndElement();
            Output.WriteEndDocument();
 
            Thread?.Idle();
            Thread?.Stop();
 
            return [];
        }
 
        public Task<string[]> Repair(params string[] CollectionNames)
        {
            return Task.FromResult<string[]>([]);
        }
 
        public Task<string[]> Repair(ProfilerThread Thread, params string[] CollectionNames)
        {
            return Task.FromResult<string[]>([]);
        }
 
        private static string Encode(string s)
        {
            return s.
                Replace("&", "&amp;").
                Replace("<", "&lt;").
                Replace(">", "&gt;").
                Replace("\"", "&quot;").
                Replace("'", "&apos;");
        }
 
        public Task<bool> Export(IDatabaseExport Output, string[] CollectionNames)
        {
            return this.Export(Output, CollectionNames, null);
        }
 
        public async Task<bool> Export(IDatabaseExport Output, string[] CollectionNames, ProfilerThread Thread)
        {
            bool Continue;
 
            Thread?.Start();
            if (!await Output.StartDatabase(this))
                return false;
            try
            {
                IDatabaseExportFilter Filter = Output as IDatabaseExportFilter;
                ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(GenericObject));
                BsonDeserializationArgs Args = new()
                {
                    NominalType = typeof(GenericObject)
                };
 
                foreach (string CollectionName in (await this.database.ListCollectionNamesAsync()).ToEnumerable())
                {
                    if (CollectionNames is not null && Array.IndexOf(CollectionNames, CollectionName) < 0)
                        continue;
 
                    if (Filter is not null && !Filter.CanExportCollection(CollectionName))
                        continue;
 
                    Thread?.NewState(CollectionName);
 
                    IMongoCollection<BsonDocument> Collection = this.database.GetCollection<BsonDocument>(CollectionName);
 
                    if (!await Output.StartCollection(CollectionName))
                        return false;
                    try
                    {
                        foreach (BsonDocument Index in (await Collection.Indexes.ListAsync()).ToEnumerable())
                        {
                            if (!await Output.StartIndex())
                                return false;
 
                            foreach (BsonElement E in Index.Elements)
                            {
                                if (E.Name == "key")
                                {
                                    foreach (BsonElement E2 in E.Value.AsBsonDocument.Elements)
                                    {
                                        if (!await Output.ReportIndexField(E2.Name, E2.Value.AsInt32 > 0))
                                            return false;
                                    }
 
                                    break;
                                }
                            }
 
                            if (!await Output.EndIndex())
                                return false;
                        }
 
                        foreach (BsonDocument Doc in (await Collection.FindAsync<BsonDocument>(Builders<BsonDocument>.Filter.Empty)).ToEnumerable())
                        {
                            BsonDocumentReader Reader = new(Doc);
                            BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
 
                            object Object = Serializer.Deserialize(Context, Args);
 
                            if (Object is GenericObject Obj)
                            {
                                if (Filter is not null && !Filter.CanExportObject(Obj))
                                    continue;
 
                                if (await Output.StartObject(Obj.ObjectId.ToString(), Obj.TypeName) is null)
                                    return false;
                                try
                                {
                                    foreach (KeyValuePair<string, object> P in Obj)
                                    {
                                        if (P.Value is ObjectId ObjectId)
                                        {
                                            if (!await Output.ReportProperty(P.Key, GeneratedObjectSerializerBase.ObjectIdToGuid(ObjectId)))
                                                return false;
                                        }
                                        else
                                        {
                                            if (!await Output.ReportProperty(P.Key, P.Value))
                                                return false;
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Thread?.Exception(ex);
                                    if (!await ReportException(ex, Output))
                                        return false;
                                }
                                finally
                                {
                                    Continue = await Output.EndObject();
                                }
 
                                if (!Continue)
                                    return false;
                            }
                            else if (Object is not null)
                            {
                                if (!await Output.ReportError("Unable to load object " + Doc["_id"].AsString + "."))
                                    return false;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Thread?.Exception(ex);
                        if (!await ReportException(ex, Output))
                            return false;
                    }
                    finally
                    {
                        Continue = await Output.EndCollection();
                    }
 
                    if (!Continue)
                        return false;
                }
            }
            catch (Exception ex)
            {
                Thread?.Exception(ex);
                if (!await ReportException(ex, Output))
                    return false;
            }
            finally
            {
                Continue = await Output.EndDatabase();
                Thread?.Idle();
                Thread?.Stop();
            }
 
            return Continue;
        }
 
        private static async Task<bool> ReportException(Exception ex, IDatabaseExport Output)
        {
            ex = Log.UnnestException(ex);
 
            if (ex is AggregateException ex2)
            {
                foreach (Exception ex3 in ex2.InnerExceptions)
                {
                    if (!await Output.ReportException(ex3))
                        return false;
                }
 
                return true;
            }
            else
                return await Output.ReportException(ex);
        }
 
        public Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames)
            where T : class
        {
            return this.Iterate(Recipient, CollectionNames, null);
        }
 
        public async Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames, ProfilerThread Thread)
            where T : class
        {
            Thread?.Start();
            await Recipient.StartDatabase();
            try
            {
                ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(T));
                BsonDeserializationArgs Args = new()
                {
                    NominalType = typeof(GenericObject)
                };
 
                foreach (string CollectionName in (await this.database.ListCollectionNamesAsync()).ToEnumerable())
                {
                    if (CollectionNames is not null && Array.IndexOf(CollectionNames, CollectionName) < 0)
                        continue;
 
                    Thread?.NewState(CollectionName);
 
                    IMongoCollection<BsonDocument> Collection = this.database.GetCollection<BsonDocument>(CollectionName);
 
                    await Recipient.StartCollection(CollectionName);
                    try
                    {
                        foreach (BsonDocument Doc in (await Collection.FindAsync<BsonDocument>(Builders<BsonDocument>.Filter.Empty)).ToEnumerable())
                        {
                            BsonDocumentReader Reader = new(Doc);
                            BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
 
                            object Object = Serializer.Deserialize(Context, Args);
 
                            if (Object is T Obj)
                                await Recipient.ProcessObject(Obj);
                            else if (Object is not null)
                            {
                                ObjectId ObjectId = await Serializer.GetObjectId(Object, false);
                                if (ObjectId != ObjectId.Empty)
                                    await Recipient.IncompatibleObject(ObjectId);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Thread?.Exception(ex);
                        ReportException(ex, Recipient);
                    }
                    finally
                    {
                        await Recipient.EndCollection();
                    }
                }
            }
            catch (Exception ex)
            {
                Thread?.Exception(ex);
                ReportException(ex, Recipient);
            }
            finally
            {
                await Recipient.EndDatabase();
                Thread?.Idle();
                Thread?.Stop();
            }
        }
 
        private static void ReportException<T>(Exception ex, IDatabaseIteration<T> Recipient)
            where T : class
        {
            ex = Events.Log.UnnestException(ex);
 
            if (ex is AggregateException ex2)
            {
                foreach (Exception ex3 in ex2.InnerExceptions)
                    Recipient.ReportException(ex3);
            }
            else
                Recipient.ReportException(ex);
        }
 
        public Task StartBulk()
        {
            return Task.CompletedTask;
        }
 
        public Task EndBulk()
        {
            return Task.CompletedTask;
        }
 
        public Task Start()
        {
            return Task.CompletedTask;
        }
 
        public Task Stop()
        {
            return Task.CompletedTask;
        }
 
        public Task Flush()
        {
            return Task.CompletedTask;
        }
 
        public Task<IPersistentDictionary> GetDictionary(string Collection)
        {
            return Task.FromResult<IPersistentDictionary>(new StringDictionary("DICT_" + Collection, this));  // TODO
        }
 
        public async Task<string[]> GetDictionaries()
        {
            List<string> Collections = [];
 
            foreach (string CollectionName in (await this.database.ListCollectionNamesAsync()).ToEnumerable())
            {
                if (CollectionName.StartsWith("DICT_"))
                    Collections.Add(CollectionName);
            }
 
            return [.. Collections];
        }
 
        public Task<IPersistedQueue> GetQueue(string QueueName, bool CanBeNull)
        {
            IPersistedQueueCollection Collection = Types.FindBest<IPersistedQueueCollection, IDatabaseProvider>(this)
                ?? throw new NotSupportedException("No queue collection creator found for database provider.");
 
            return Collection.GetQueue(this, QueueName, CanBeNull);
        }
 
        public async Task<string[]> GetQueues()
        {
            IMongoCollection<BsonDocument> Collection = this.GetCollection(QueuedItem.QueuedItemCollectionName);
            FilterDefinition<BsonDocument> BsonFilter = Builders<BsonDocument>.Filter.Ne<string>("QueueName", null);
 
            using IAsyncCursor<string> Cursor = await Collection.DistinctAsync<string>("QueueName", BsonFilter);
            
            return [.. await Cursor.ToListAsync()];
        }
 
        public async Task<string[]> GetCollections()
        {
            List<string> Collections = [];
 
            foreach (string CollectionName in (await this.database.ListCollectionNamesAsync()).ToEnumerable())
            {
                if (!CollectionName.StartsWith("DICT_"))
                    Collections.Add(CollectionName);
            }
 
            return [.. Collections];
        }
 
        public Task<string> GetCollection(Type Type)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Type);
            return Task.FromResult(Serializer.CollectionName(null));
        }
 
        public Task<string> GetCollection(object Object)
        {
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Object);
            return Task.FromResult(Serializer.CollectionName(Object));
        }
 
        public async Task<bool> IsLabel(string CollectionName, string Label)
        {
            IMongoCollection<BsonDocument> Collection = this.GetCollection(CollectionName);
            FilterDefinition<BsonDocument> BsonFilter = Builders<BsonDocument>.Filter.Ne<string>(Label, null);
            IFindFluent<BsonDocument, BsonDocument> ResultSet = Collection.Find<BsonDocument>(BsonFilter);
 
            return await ResultSet.SingleAsync<BsonDocument>() is not null;
        }
 
        public Task<string[]> GetLabels(string Collection)
        {
            throw new NotImplementedException();
        }
 
        public async Task<object> TryGetObjectId(object Object)
        {
            if (Object is null)
                return null;
 
            IObjectSerializer Serializer = this.GetObjectSerializer(Object.GetType());
            if (Serializer is ObjectSerializer SerializerEx &&
                SerializerEx.HasObjectId(Object))
            {
                return await SerializerEx.GetObjectId(Object, false);
            }
            else
                return null;
        }
 
        public Task DropCollection(string CollectionName)
        {
            lock (this.collections)
            {
                this.collections.Remove(CollectionName);
 
                if (CollectionName == this.lastCollectionName)
                {
                    this.lastCollection = null;
                    this.lastCollectionName = string.Empty;
                }
            }
 
            return this.database.DropCollectionAsync(CollectionName);
        }
 
        public Task<GenericObject> Generalize(object Object)
        {
            if (Object is null)
                return Task.FromResult<GenericObject>(null);
 
            ObjectSerializer Serializer = this.GetObjectSerializerEx(Object);
            string CollectionName = Serializer.CollectionName(Object);
 
            BsonDocument Doc = Object.ToBsonDocument(Object.GetType(), Serializer);
 
            ObjectSerializer Deserializer = this.GetObjectSerializerEx(typeof(GenericObject));
 
            BsonDocumentReader Reader = new(Doc);
            BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
            BsonDeserializationArgs Args = new()
            {
                NominalType = typeof(GenericObject)
            };
 
            if (Deserializer.Deserialize(Context, Args) is GenericObject Obj)
            {
                Obj.ArchivingTime = Serializer.GetArchivingTimeDays(Object);
                return Task.FromResult(Obj);
            }
            else
                throw new InvalidOperationException("Unable to generalize object.");
        }
 
        public Task<object> Specialize(GenericObject Object)
        {
            if (Object is null)
                return Task.FromResult<object>(null);
 
            Type T = Types.GetType(Object.TypeName);
            if (T is null)
                return Task.FromResult<object>(Object);
 
            ObjectSerializer Serializer = this.GetObjectSerializerEx(typeof(GenericObject));
            string CollectionName = Serializer.CollectionName(Object);
 
            BsonDocument Doc = Object.ToBsonDocument(Object.GetType(), Serializer);
 
            Serializer = this.GetObjectSerializerEx(T);
 
            BsonDocumentReader Reader = new(Doc);
            BsonDeserializationContext Context = BsonDeserializationContext.CreateRoot(Reader);
            BsonDeserializationArgs Args = new()
            {
                NominalType = typeof(GenericObject)
            };
 
            return Task.FromResult<object>(Serializer.Deserialize(Context, Args));
        }
 
        public string[] GetExcludedCollections()
        {
            SortedDictionary<string, bool> Sorted = new(StringComparer.OrdinalIgnoreCase);
 
            lock (this.collections)
            {
                foreach (IObjectSerializer Serializer in this.serializers.Values)
                {
                    if (Serializer is ObjectSerializer ObjectSerializer && !ObjectSerializer.BackupCollection)
                        Sorted[ObjectSerializer.CollectionNameConstant] = true;
                }
            }
 
            string[] Result = new string[Sorted.Count];
            Sorted.Keys.CopyTo(Result, 0);
 
            return Result;
        }
 
        // TODO:
        //  * Created field
        //  * Updated field
        //  * RegEx fields
        //  * JavaScript fields
        //  * Binary fields (BLOBS)
        //  * Image fields
        //  * Collection indices.
        //  * Dictionary<string,T> fields.
        //  * SortedDictionary<string,T> fields.
        //  * Aggregates
        //  * Case insensitive strings.
        //  * Encrypted properties
    }
}