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.Serialization;
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)
        {
            ObjectEventHandler h = ObjectInserted;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        private static void RaiseInserted(IEnumerable<object> Objects)
        {
            foreach (object Object in Objects)
                RaiseInserted(Object);
        }
 
        public static event ObjectEventHandler 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 async static Task Update(object Object)
        {
            await Provider.Update(Object);
            RaiseUpdated(Object);
        }
 
        private static void RaiseUpdated(object Object)
        {
            ObjectEventHandler h = ObjectUpdated;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        private static void RaiseUpdated(IEnumerable<object> Objects)
        {
            foreach (object Object in Objects)
                RaiseUpdated(Object);
        }
 
        public static event ObjectEventHandler 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 ObjectEventHandler 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)
        {
            ObjectEventHandler h = ObjectDeleted;
            if (!(h is null))
            {
                try
                {
                    h(Provider, new ObjectEventArgs(Object));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        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 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, 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);
 
            CollectionEventHandler h = CollectionCleared;
            if (!(h is null))
            {
                try
                {
                    await h(Provider, new CollectionEventArgs(CollectionName));
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
        }
 
        public static event CollectionEventHandler 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)
                RaiseRepaired(Result, Flagged);
 
            return Result;
        }
 
        private static void RaiseRepaired(string[] Collections, KeyValuePair<string, Dictionary<string, FlagSource>>[] Flagged)
        {
            FlagSource[] FlaggedCollection;
            CollectionRepairedEventHandler 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;
                            }
                        }
                    }
 
                    try
                    {
                        h(Provider, new CollectionRepairedEventArgs(Collection, FlaggedCollection));
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
        }
 
        public static event CollectionRepairedEventHandler 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)
                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)
        {
            InconsistencyException Result = new InconsistencyException(Collection, Reason);
            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;
        }
 
        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 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<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();
        }
 
    }
}