Database.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Events;
using Waher.Persistence.Exceptions;
using Waher.Persistence.Filters;
using Waher.Persistence.Processors;
using Waher.Persistence.Serialization;
using Waher.Runtime.Collections;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence
{
    public static class Database
    {
        private static readonly Dictionary<string, Dictionary<string, FlagSource>> toRepair = new Dictionary<string, Dictionary<string, FlagSource>>();
        private static IDatabaseProvider provider = null;
        private static bool locked = false;
 
        public static void Register(IDatabaseProvider DatabaseProvider)
        {
            Register(DatabaseProvider, true);
        }
 
        public static void Register(IDatabaseProvider DatabaseProvider, bool Lock)
        {
            if (!(provider is null) && locked)
                throw new Exception("A database provider is already registered.");
 
            provider = DatabaseProvider;
            locked = Lock;
        }
 
        public static IDatabaseProvider Provider
        {
            get
            {
                if (!(provider is null))
                    return provider;
                else
                    throw new Exception("A database provider has not been registered.");
            }
        }
 
        internal static IDatabaseProvider Stop()
        {
            IDatabaseProvider Result = provider;
            provider = new NullDatabaseProvider();
            locked = false;
            return Result;
        }
 
        public static bool HasProvider
        {
            get => !(provider is null) && (!(provider is NullDatabaseProvider) || locked);
        }
 
        public static bool Locked
        {
            get { return locked; }
        }
 
        public async static Task Insert(object Object)
        {
            await Provider.Insert(Object);
            RaiseInserted(Object);
        }
 
        private static void RaiseInserted(object Object)
        {
            ObjectInserted?.Raise(Provider, new ObjectEventArgs(Object));
        }
 
        private static void RaiseInserted(IEnumerable<object> Objects)
        {
            foreach (object Object in Objects)
                RaiseInserted(Object);
        }
 
        public static event EventHandler<ObjectEventArgs> ObjectInserted = null;
 
        public async static Task Insert(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.Insert(Objects[0]);
            else
                await Provider.Insert(Objects);
 
            RaiseInserted(Objects);
        }
 
        public async static Task Insert(IEnumerable<object> Objects)
        {
            await Provider.Insert(Objects);
            RaiseInserted(Objects);
        }
 
        public static async Task InsertLazy(object Object)
        {
            await Provider.InsertLazy(Object, RaiseInserted);
        }
 
        public static async Task InsertLazy(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.InsertLazy(Objects[0], RaiseInserted);
            else
                await Provider.InsertLazy(Objects, RaiseInserted);
        }
 
        public static async Task InsertLazy(IEnumerable<object> Objects)
        {
            await Provider.InsertLazy(Objects, RaiseInserted);
        }
 
        public static Task<IEnumerable<T>> Find<T>(params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(0, int.MaxValue, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(Offset, MaxCount, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<IEnumerable<object>> Find(string Collection, params string[] SortOrder)
        {
            return Provider.Find(Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static Task<IEnumerable<object>> Find(string Collection, Filter Filter, params string[] SortOrder)
        {
            return Provider.Find(Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Provider.Find(Collection, Offset, MaxCount, SortOrder);
        }
 
        public static Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Provider.Find(Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(string Collection, string[] SortOrder)   // Note: No params, to avoid confusion with Find<T>(params SortOrder)
            where T : class
        {
            return Provider.Find<T>(Collection, 0, int.MaxValue, null, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(string Collection, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(string Collection, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(Collection, Offset, MaxCount, null, SortOrder);
        }
 
        public static Task<IEnumerable<T>> Find<T>(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Find<T>(Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<IPage<T>> FindFirst<T>(int PageSize, params string[] SortOrder)
            where T : class
        {
            return Provider.FindFirst<T>(PageSize, SortOrder);
        }
 
        public static Task<IPage<T>> FindFirst<T>(int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.FindFirst<T>(PageSize, Filter, SortOrder);
        }
 
 
        public static Task<IPage<object>> FindFirst(string Collection, int PageSize, params string[] SortOrder)
        {
            return Provider.FindFirst(Collection, PageSize, SortOrder);
        }
 
        public static Task<IPage<object>> FindFirst(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
        {
            return Provider.FindFirst(Collection, PageSize, Filter, SortOrder);
        }
 
        public static Task<IPage<T>> FindFirst<T>(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.FindFirst<T>(Collection, PageSize, Filter, SortOrder);
        }
 
        public static Task<IPage<T>> FindNext<T>(IPage<T> Page)
            where T : class
        {
            return Provider.FindNext(Page);
        }
 
        public static Task<IPage<object>> FindNext(IPage<object> Page)
        {
            return Provider.FindNext(Page);
        }
 
        public static async Task<PaginatedEnumerator<T>> Enumerate<T>(int PageSize, params string[] SortOrder)
            where T : class
        {
            return new PaginatedEnumerator<T>(await FindFirst<T>(PageSize, SortOrder));
        }
 
        public static async Task<PaginatedEnumerator<T>> Enumerate<T>(int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return new PaginatedEnumerator<T>(await FindFirst<T>(PageSize, Filter, SortOrder));
        }
 
 
        public static async Task<PaginatedEnumerator<object>> Enumerate(string Collection, int PageSize, params string[] SortOrder)
        {
            return new PaginatedEnumerator<object>(await FindFirst(Collection, PageSize, SortOrder));
        }
 
        public static async Task<PaginatedEnumerator<object>> Enumerate(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
        {
            return new PaginatedEnumerator<object>(await FindFirst(Collection, PageSize, Filter, SortOrder));
        }
 
        public static async Task<PaginatedEnumerator<T>> Enumerate<T>(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return new PaginatedEnumerator<T>(await FindFirst<T>(Collection, PageSize, Filter, SortOrder));
        }
 
        public async static Task<T> FindFirstDeleteRest<T>(params string[] SortOrder)
            where T : class
        {
            return await FirstDeleteRest(await Provider.Find<T>(0, int.MaxValue, SortOrder));
        }
 
        private static async Task<T> FirstDeleteRest<T>(IEnumerable<T> Set)
            where T : class
        {
            T Result = default;
            bool First = true;
 
            foreach (T Obj in Set)
            {
                if (First)
                {
                    First = false;
                    Result = Obj;
                }
                else
                {
                    try
                    {
                        await Delete(Obj);
                    }
                    catch (KeyNotFoundException)
                    {
                        // TODO: Inconsistency should flag collection for repairing
                    }
                }
            }
 
            return Result;
        }
 
        public static async Task<T> FindFirstDeleteRest<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return await FirstDeleteRest(await Provider.Find<T>(0, int.MaxValue, Filter, SortOrder));
        }
 
        public async static Task<T> FindFirstIgnoreRest<T>(params string[] SortOrder)
            where T : class
        {
            return FirstIgnoreRest(await Provider.Find<T>(0, 1, SortOrder));
        }
 
        private static T FirstIgnoreRest<T>(IEnumerable<T> Set)
            where T : class
        {
            foreach (T Obj in Set)
                return Obj;
 
            return default;
        }
 
        public static async Task<T> FindFirstIgnoreRest<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return FirstIgnoreRest(await Provider.Find<T>(0, 1, Filter, SortOrder));
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process(IProcessor<object> Processor, string Collection, params string[] SortOrder)
        {
            return Provider.Process(Processor, Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process(IProcessor<object> Processor, string Collection, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(Processor, Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process(IProcessor<object> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Provider.Process(Processor, Collection, Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process(IProcessor<object> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(Processor, Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, string Collection, string[] SortOrder)   // Note: No params, to avoid confusion with Find<T>(params SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Collection, 0, int.MaxValue, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, string Collection, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Collection, Offset, MaxCount, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(IProcessor<T> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(Processor, Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process(Predicate<object> Processor, string Collection, params string[] SortOrder)
        {
            return Provider.Process(new PredicateProcessor<object>(Processor), Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process(Predicate<object> Processor, string Collection, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(new PredicateProcessor<object>(Processor), Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process(Predicate<object> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Provider.Process(new PredicateProcessor<object>(Processor), Collection, Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process(Predicate<object> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(new PredicateProcessor<object>(Processor), Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, string Collection, string[] SortOrder)   // Note: No params, to avoid confusion with Find<T>(params SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Collection, 0, int.MaxValue, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, string Collection, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Collection, Offset, MaxCount, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(Predicate<T> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateProcessor<T>(Processor), Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process(PredicateAsync<object> Processor, string Collection, params string[] SortOrder)
        {
            return Provider.Process(new PredicateAsyncProcessor<object>(Processor), Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static Task<bool> Process(PredicateAsync<object> Processor, string Collection, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(new PredicateAsyncProcessor<object>(Processor), Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process(PredicateAsync<object> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Provider.Process(new PredicateAsyncProcessor<object>(Processor), Collection, Offset, MaxCount, SortOrder);
        }
 
        public static Task<bool> Process(PredicateAsync<object> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Provider.Process(new PredicateAsyncProcessor<object>(Processor), Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, string Collection, string[] SortOrder)   // Note: No params, to avoid confusion with Find<T>(params SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Collection, 0, int.MaxValue, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, string Collection, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, string Collection, int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Collection, Offset, MaxCount, null, SortOrder);
        }
 
        public static Task<bool> Process<T>(PredicateAsync<T> Processor, string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.Process(new PredicateAsyncProcessor<T>(Processor), Collection, Offset, MaxCount, Filter, SortOrder);
        }
 
        public async static Task Update(object Object)
        {
            await Provider.Update(Object);
            RaiseUpdated(Object);
        }
 
        private static void RaiseUpdated(object Object)
        {
            ObjectUpdated?.Raise(Provider, new ObjectEventArgs(Object));
        }
 
        private static void RaiseUpdated(IEnumerable<object> Objects)
        {
            foreach (object Object in Objects)
                RaiseUpdated(Object);
        }
 
        public static event EventHandler<ObjectEventArgs> ObjectUpdated = null;
 
        public async static Task Update(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.Update(Objects[0]);
            else
                await Provider.Update(Objects);
 
            RaiseUpdated(Objects);
        }
 
        public async static Task Update(IEnumerable<object> Objects)
        {
            await Provider.Update(Objects);
            RaiseUpdated(Objects);
        }
 
        public async static Task UpdateLazy(object Object)
        {
            await Provider.UpdateLazy(Object, RaiseUpdated);
        }
 
        public async static Task UpdateLazy(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.UpdateLazy(Objects[0], RaiseUpdated);
            else
                await Provider.UpdateLazy(Objects, RaiseUpdated);
        }
 
        public async static Task UpdateLazy(IEnumerable<object> Objects)
        {
            await Provider.UpdateLazy(Objects, RaiseUpdated);
        }
 
        public async static Task Delete(object Object)
        {
            await Provider.Delete(Object);
            RaiseDeleted(Object);
        }
 
        public static event EventHandler<ObjectEventArgs> ObjectDeleted = null;
 
        public async static Task Delete(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.Delete(Objects[0]);
            else
                await Provider.Delete(Objects);
 
            RaiseDeleted(Objects);
        }
 
        public async static Task Delete(IEnumerable<object> Objects)
        {
            await Provider.Delete(Objects);
            RaiseDeleted(Objects);
        }
 
        public async static Task DeleteLazy(object Object)
        {
            await Provider.DeleteLazy(Object, RaiseDeleted);
        }
 
        public async static Task DeleteLazy(params object[] Objects)
        {
            if (Objects.Length == 1)
                await Provider.DeleteLazy(Objects[0], RaiseDeleted);
            else
                await Provider.DeleteLazy(Objects, RaiseDeleted);
        }
 
        public async static Task DeleteLazy(IEnumerable<object> Objects)
        {
            await Provider.DeleteLazy(Objects, RaiseDeleted);
        }
 
        private static void RaiseDeleted(object Object)
        {
            ObjectDeleted?.Raise(Provider, new ObjectEventArgs(Object));
        }
 
        private static void RaiseDeleted(IEnumerable<object> Objects)
        {
            foreach (object Object in Objects)
                RaiseDeleted(Object);
        }
 
        public static Task<IEnumerable<T>> FindDelete<T>(params string[] SortOrder)
            where T : class
        {
            return FindDelete<T>(0, int.MaxValue, SortOrder);
        }
 
        public static async Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            IEnumerable<T> Result = await Provider.FindDelete<T>(Offset, MaxCount, SortOrder);
 
            foreach (T Object in Result)
                RaiseDeleted(Object);
 
            return Result;
        }
 
        public static Task<IEnumerable<T>> FindDelete<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return FindDelete<T>(0, int.MaxValue, Filter, SortOrder);
        }
 
        public static async Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            IEnumerable<T> Result = await Provider.FindDelete<T>(Offset, MaxCount, Filter, SortOrder);
 
            foreach (T Object in Result)
                RaiseDeleted(Object);
 
            return Result;
        }
 
        public static Task<IEnumerable<object>> FindDelete(string Collection, params string[] SortOrder)
        {
            return FindDelete(Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static async Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            IEnumerable<object> Result = await Provider.FindDelete(Collection, Offset, MaxCount, SortOrder);
 
            foreach (object Object in Result)
                RaiseDeleted(Object);
 
            return Result;
        }
 
        public static Task<IEnumerable<object>> FindDelete(string Collection, Filter Filter, params string[] SortOrder)
        {
            return FindDelete(Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static async Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            IEnumerable<object> Result = await Provider.FindDelete(Collection, Offset, MaxCount, Filter, SortOrder);
 
            foreach (object Object in Result)
                RaiseDeleted(Object);
 
            return Result;
        }
 
        public static Task<int> Delete<T>(params string[] SortOrder)
            where T : class
        {
            return Delete<T>(0, int.MaxValue, SortOrder);
        }
 
        public static async Task<int> Delete<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            int MaxCount2;
            int Count = 0;
            bool Found;
 
            do
            {
                Found = false;
                MaxCount2 = Math.Min(MaxCount, 1000);
 
                IEnumerable<T> Result = await Provider.FindDelete<T>(Offset, MaxCount2, SortOrder);
 
                foreach (T Object in Result)
                {
                    RaiseDeleted(Object);
                    MaxCount--;
                    Count++;
                    Found = true;
                }
            }
            while (Found && MaxCount > 0);
 
            return Count;
        }
 
        public static Task<int> Delete<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Delete<T>(0, int.MaxValue, Filter, SortOrder);
        }
 
        public static async Task<int> Delete<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            int MaxCount2;
            int Count = 0;
            bool Found;
 
            do
            {
                Found = false;
                MaxCount2 = Math.Min(MaxCount, 1000);
 
                IEnumerable<T> Result = await Provider.FindDelete<T>(Offset, MaxCount2, Filter, SortOrder);
 
                foreach (T Object in Result)
                {
                    RaiseDeleted(Object);
                    MaxCount--;
                    Count++;
                    Found = true;
                }
            }
            while (Found && MaxCount > 0);
 
            return Count;
        }
 
        public static Task<int> Delete(string Collection, params string[] SortOrder)
        {
            return Delete(Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static async Task<int> Delete(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            int MaxCount2;
            int Count = 0;
            bool Found;
 
            do
            {
                Found = false;
                MaxCount2 = Math.Min(MaxCount, 1000);
 
                IEnumerable<object> Result = await Provider.FindDelete(Collection, Offset, MaxCount2, SortOrder);
 
                foreach (object Object in Result)
                {
                    RaiseDeleted(Object);
                    MaxCount--;
                    Count++;
                    Found = true;
                }
            }
            while (Found && MaxCount > 0);
 
            return Count;
        }
 
        public static Task<int> Delete(string Collection, Filter Filter, params string[] SortOrder)
        {
            return Delete(Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static async Task<int> Delete(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            int MaxCount2;
            int Count = 0;
            bool Found;
 
            do
            {
                Found = false;
                MaxCount2 = Math.Min(MaxCount, 1000);
 
                IEnumerable<object> Result = await Provider.FindDelete(Collection, Offset, MaxCount2, Filter, SortOrder);
 
                foreach (object Object in Result)
                {
                    RaiseDeleted(Object);
                    MaxCount--;
                    Count++;
                    Found = true;
                }
            }
            while (Found && MaxCount > 0);
 
            return Count;
        }
 
        public static Task DeleteLazy<T>(params string[] SortOrder)
            where T : class
        {
            return DeleteLazy<T>(0, int.MaxValue, SortOrder);
        }
 
        public static Task DeleteLazy<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class
        {
            return Provider.DeleteLazy<T>(Offset, MaxCount, SortOrder, RaiseDeleted);
        }
 
        public static Task DeleteLazy<T>(Filter Filter, params string[] SortOrder)
            where T : class
        {
            return DeleteLazy<T>(0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task DeleteLazy<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class
        {
            return Provider.DeleteLazy<T>(Offset, MaxCount, Filter, SortOrder, RaiseDeleted);
        }
 
        public static Task DeleteLazy(string Collection, params string[] SortOrder)
        {
            return DeleteLazy(Collection, 0, int.MaxValue, SortOrder);
        }
 
        public static Task DeleteLazy(string Collection, int Offset, int MaxCount, params string[] SortOrder)
        {
            return Provider.DeleteLazy(Collection, Offset, MaxCount, SortOrder, RaiseDeleted);
        }
 
        public static Task DeleteLazy(string Collection, Filter Filter, params string[] SortOrder)
        {
            return DeleteLazy(Collection, 0, int.MaxValue, Filter, SortOrder);
        }
 
        public static Task DeleteLazy(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
        {
            return Provider.DeleteLazy(Collection, Offset, MaxCount, Filter, SortOrder, RaiseDeleted);
        }
 
        public static Task<T> TryLoadObject<T>(object ObjectId)
            where T : class
        {
            return Provider.TryLoadObject<T>(ObjectId);
        }
 
        public static Task<T> TryLoadObject<T>(string CollectionName, object ObjectId)
            where T : class
        {
            return Provider.TryLoadObject<T>(CollectionName, ObjectId);
        }
 
        public static Task<object> TryLoadObject(string CollectionName, object ObjectId)
        {
            return Provider.TryLoadObject(CollectionName, ObjectId);
        }
 
        public static async Task<T> LoadObject<T>(object ObjectId)
            where T : class
        {
            T Result = await Provider.TryLoadObject<T>(ObjectId)
                ?? throw new KeyNotFoundException("Object not found.");
 
            return Result;
        }
 
        public async static Task<T> LoadObject<T>(string CollectionName, object ObjectId)
            where T : class
        {
            T Result = await Provider.TryLoadObject<T>(CollectionName, ObjectId)
                ?? throw new KeyNotFoundException("Object not found.");
 
            return Result;
        }
 
        public static async Task<object> LoadObject(string CollectionName, object ObjectId)
        {
            object Result = await Provider.TryLoadObject(CollectionName, ObjectId)
                ?? throw new KeyNotFoundException("Object not found.");
 
            return Result;
        }
 
        public static Task<bool> Export(IDatabaseExport Output)
        {
            return Export(Output, null);
        }
 
        public static Task<bool> Export(IDatabaseExport Output, string[] CollectionNames)
        {
            return Provider.Export(Output, CollectionNames);
        }
 
        public static Task<bool> Export(IDatabaseExport Output, string[] CollectionNames, ProfilerThread Thread)
        {
            return Provider.Export(Output, CollectionNames, Thread);
        }
 
        public static Task Iterate<T>(IDatabaseIteration<T> Recipient)
            where T : class
        {
            return Iterate(Recipient, null);
        }
 
        public static Task Iterate<T>(IDatabaseIteration<T> Recipient, params string[] CollectionNames)
            where T : class
        {
            return Provider.Iterate(Recipient, CollectionNames);
        }
 
        public static Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames, ProfilerThread Thread)
            where T : class
        {
            return Provider.Iterate(Recipient, CollectionNames, Thread);
        }
 
        public async static Task Clear(string CollectionName)
        {
            await Provider.Clear(CollectionName);
 
            await CollectionCleared.Raise(Provider, new CollectionEventArgs(CollectionName));
        }
 
        public static event EventHandlerAsync<CollectionEventArgs> CollectionCleared = null;
 
        public static Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return Provider.Analyze(Output, XsltPath, ProgramDataFolder, ExportData);
        }
 
        public static Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData,
            ProfilerThread Thread)
        {
            return Provider.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, Thread);
        }
 
        public static Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData)
        {
            return Repair(Output, XsltPath, ProgramDataFolder, ExportData, null);
        }
 
        public async static Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData,
            ProfilerThread Thread)
        {
            KeyValuePair<string, Dictionary<string, FlagSource>>[] Flagged = GetFlaggedCollections();
 
            string[] Result = await Provider.Repair(Output, XsltPath, ProgramDataFolder, ExportData, Thread);
 
            if (Result.Length > 0)
                await RaiseRepaired(Result, Flagged);
 
            return Result;
        }
 
        private static async Task RaiseRepaired(string[] Collections, KeyValuePair<string, Dictionary<string, FlagSource>>[] Flagged)
        {
            try
            {
                FlagSource[] FlaggedCollection;
                EventHandlerAsync<CollectionRepairedEventArgs> h = CollectionRepaired;
 
                if (!(h is null))
                {
                    foreach (string Collection in Collections)
                    {
                        FlaggedCollection = null;
 
                        if (!(Flagged is null))
                        {
                            foreach (KeyValuePair<string, Dictionary<string, FlagSource>> Rec in Flagged)
                            {
                                if (Rec.Key == Collection)
                                {
                                    FlaggedCollection = new FlagSource[Rec.Value.Count];
                                    Rec.Value.Values.CopyTo(FlaggedCollection, 0);
                                    break;
                                }
                            }
                        }
 
                        await h.Raise(Provider, new CollectionRepairedEventArgs(Collection, FlaggedCollection));
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public static event EventHandlerAsync<CollectionRepairedEventArgs> CollectionRepaired = null;
 
        public static Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData,
            bool Repair)
        {
            return Analyze(Output, XsltPath, ProgramDataFolder, ExportData, Repair, null);
        }
 
        public async static Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, 
            bool Repair, ProfilerThread Thread)
        {
            KeyValuePair<string, Dictionary<string, FlagSource>>[] Flagged = GetFlaggedCollections();
 
            string[] Result = await Provider.Analyze(Output, XsltPath, ProgramDataFolder, ExportData, Repair, Thread);
 
            if (Repair && Result.Length > 0)
                await RaiseRepaired(Result, Flagged);
 
            return Result;
        }
 
        private static KeyValuePair<string, Dictionary<string, FlagSource>>[] GetFlaggedCollections()
        {
            KeyValuePair<string, Dictionary<string, FlagSource>>[] Flagged;
            int i;
 
            lock (toRepair)
            {
                Flagged = new KeyValuePair<string, Dictionary<string, FlagSource>>[toRepair.Count];
                i = 0;
 
                foreach (KeyValuePair<string, Dictionary<string, FlagSource>> P in toRepair)
                    Flagged[i++] = P;
 
                toRepair.Clear();
            }
 
            return Flagged;
        }
 
        public static string[] GetFlaggedCollectionNames()
        {
            string[] Result;
 
            lock (toRepair)
            {
                Result = new string[toRepair.Count];
                toRepair.Keys.CopyTo(Result, 0);
            }
 
            return Result;
        }
 
        public static void BeginRepair(string Collection)
        {
            lock (toRepair)
            {
                toRepair[Collection] = null;
            }
        }
 
        public static void EndRepair(string Collection)
        {
            lock (toRepair)
            {
                toRepair.Remove(Collection);
            }
        }
 
        public static Exception FlagForRepair(string Collection, string Reason)
        {
            if (!string.IsNullOrEmpty(Collection))
            {
                InconsistencyException Result = new InconsistencyException(Collection, Reason + " (" + Collection + ")");
                string StackTrace = Log.CleanStackTrace(Environment.StackTrace);
                string Key = Reason + " | " + StackTrace;
 
                lock (toRepair)
                {
                    if (toRepair.TryGetValue(Collection, out Dictionary<string, FlagSource> PerStackTrace))
                    {
                        if (!(PerStackTrace is null))
                        {
                            if (PerStackTrace.TryGetValue(Key, out FlagSource FlagSource))
                                FlagSource.Count++;
                            else
                                PerStackTrace[Key] = new FlagSource(Reason, StackTrace, 1);
                        }
                    }
                    else
                        toRepair[Collection] = new Dictionary<string, FlagSource>() { { Key, new FlagSource(Reason, StackTrace, 1) } };
                }
 
                return Result;
            }
            else
                return new Exception(Reason);
        }
 
        public static Task AddIndex(string CollectionName, string[] FieldNames)
        {
            return Provider.AddIndex(CollectionName, FieldNames);
        }
 
        public static Task RemoveIndex(string CollectionName, string[] FieldNames)
        {
            return Provider.RemoveIndex(CollectionName, FieldNames);
        }
 
        public static Task<string[][]> GetIndices(string CollectionName)
        {
            return Provider.GetIndices(CollectionName);
        }
 
        public static Task StartBulk()
        {
            return Provider.StartBulk();
        }
 
        public static Task EndBulk()
        {
            return Provider.EndBulk();
        }
 
        public static string[] ToStringArray(this CaseInsensitiveString[] A)
        {
            if (A is null)
                return null;
 
            int i, c = A.Length;
            string[] B = new string[c];
 
            for (i = 0; i < c; i++)
                B[i] = A[i].Value;
 
            return B;
        }
 
        public static CaseInsensitiveString[] ToCaseInsensitiveStringArray(this string[] A)
        {
            if (A is null)
                return null;
 
            int i, c = A.Length;
            CaseInsensitiveString[] B = new CaseInsensitiveString[c];
 
            for (i = 0; i < c; i++)
                B[i] = A[i];
 
            return B;
        }
 
        public static Task<IPersistentDictionary> GetDictionary(string Collection)
        {
            return Provider.GetDictionary(Collection);
        }
 
        public static Task<string[]> GetDictionaries()
        {
            return Provider.GetDictionaries();
        }
 
        public static Task<IPersistedQueue> GetQueue(string QueueName)
        {
            return GetQueue(QueueName, false);
        }
 
        public static Task<IPersistedQueue> GetQueue(string QueueName, bool CanBeNull)
        {
            return Provider.GetQueue(QueueName, CanBeNull);
        }
 
        public static Task<string[]> GetQueues()
        {
            return Provider.GetQueues();
        }
 
        public static Task<string[]> GetCollections()
        {
            return Provider.GetCollections();
        }
 
        public static Task<string> GetCollection(Type Type)
        {
            return Provider.GetCollection(Type);
        }
 
        public static Task<string> GetCollection(Object Object)
        {
            return Provider.GetCollection(Object);
        }
 
        public static Task<bool> IsLabel(string Collection, string Label)
        {
            return Provider.IsLabel(Collection, Label);
        }
 
        public static Task<string[]> GetLabels(string Collection)
        {
            return Provider.GetLabels(Collection);
        }
 
        public static Task<object> TryGetObjectId(object Object)
        {
            return Provider.TryGetObjectId(Object);
        }
 
        public static Task DropCollection(string CollectionName)
        {
            return Provider.DropCollection(CollectionName);
        }
 
        public static string WildcardToRegex(string s, string Wildcard)
        {
            string[] Parts = s.Split(new string[] { Wildcard }, StringSplitOptions.None);
            StringBuilder RegEx = new StringBuilder();
            bool First = true;
            int i, j, c;
 
            foreach (string Part in Parts)
            {
                if (First)
                    First = false;
                else
                    RegEx.Append(".*");
 
                i = 0;
                c = Part.Length;
                while (i < c)
                {
                    j = Part.IndexOfAny(regexSpecialCharaters, i);
                    if (j < i)
                    {
                        RegEx.Append(Part.Substring(i));
                        i = c;
                    }
                    else
                    {
                        if (j > i)
                            RegEx.Append(Part.Substring(i, j - i));
 
                        RegEx.Append('\\');
                        RegEx.Append(Part[j]);
 
                        i = j + 1;
                    }
                }
            }
 
            return RegEx.ToString();
        }
 
        private static readonly char[] regexSpecialCharaters = new char[] { '\\', '^', '$', '{', '}', '[', ']', '(', ')', '.', '*', '+', '?', '|', '<', '>', '-', '&' };
 
        public static Task<GenericObject> Generalize(object Object)
        {
            return Provider.Generalize(Object);
        }
 
        public static Task<object> Specialize(GenericObject Object)
        {
            return Provider.Specialize(Object);
        }
 
        public static string[] GetExcludedCollections()
        {
            return Provider.GetExcludedCollections();
        }
 
    }
}