IDatabaseProvider.cs

using System;
using System.Collections.Generic;
using System.Xml;
using System.Threading.Tasks;
using Waher.Persistence.Filters;
using Waher.Persistence.Serialization;
using Waher.Runtime.Profiling;
 
namespace Waher.Persistence
{
    public delegate void ObjectCallback(object Object);
 
    public delegate void ObjectsCallback(IEnumerable<object> Objects);
 
    public interface IDatabaseProvider
    {
        Task Insert(object Object);
 
        Task Insert(params object[] Objects);
 
        Task Insert(IEnumerable<object> Objects);
 
        Task InsertLazy(object Object, ObjectCallback Callback);
 
        Task InsertLazy(object[] Objects, ObjectsCallback Callback);
 
        Task InsertLazy(IEnumerable<object> Objects, ObjectsCallback Callback);
 
        Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class;
 
        Task<IEnumerable<T>> Find<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class;
 
        Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, params string[] SortOrder);
 
        Task<IEnumerable<object>> Find(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder);
 
        Task<IEnumerable<T>> Find<T>(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class;
 
        Task<IPage<T>> FindFirst<T>(int PageSize, params string[] SortOrder)
            where T : class;
 
        Task<IPage<T>> FindFirst<T>(int PageSize, Filter Filter, params string[] SortOrder)
            where T : class;
 
        Task<IPage<object>> FindFirst(string Collection, int PageSize, params string[] SortOrder);
 
        Task<IPage<object>> FindFirst(string Collection, int PageSize, Filter Filter, params string[] SortOrder);
 
        Task<IPage<T>> FindFirst<T>(string Collection, int PageSize, Filter Filter, params string[] SortOrder)
            where T : class;
 
        Task<IPage<T>> FindNext<T>(IPage<T> Page)
            where T : class;
 
        Task<IPage<object>> FindNext(IPage<object> Page);
 
        Task Update(object Object);
 
        Task Update(params object[] Objects);
 
        Task Update(IEnumerable<object> Objects);
 
        Task UpdateLazy(object Object, ObjectCallback Callback);
 
        Task UpdateLazy(object[] Objects, ObjectsCallback Callback);
 
        Task UpdateLazy(IEnumerable<object> Objects, ObjectsCallback Callback);
 
        Task Delete(object Object);
 
        Task Delete(params object[] Objects);
 
        Task Delete(IEnumerable<object> Objects);
 
        Task DeleteLazy(object Object, ObjectCallback Callback);
 
        Task DeleteLazy(object[] Objects, ObjectsCallback Callback);
 
        Task DeleteLazy(IEnumerable<object> Objects, ObjectsCallback Callback);
 
        Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, params string[] SortOrder)
            where T : class;
 
        Task<IEnumerable<T>> FindDelete<T>(int Offset, int MaxCount, Filter Filter, params string[] SortOrder)
            where T : class;
 
        Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, params string[] SortOrder);
 
        Task<IEnumerable<object>> FindDelete(string Collection, int Offset, int MaxCount, Filter Filter, params string[] SortOrder);
 
        Task DeleteLazy<T>(int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback)
            where T : class;
 
        Task DeleteLazy<T>(int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback)
            where T : class;
 
        Task DeleteLazy(string Collection, int Offset, int MaxCount, string[] SortOrder, ObjectsCallback Callback);
 
        Task DeleteLazy(string Collection, int Offset, int MaxCount, Filter Filter, string[] SortOrder, ObjectsCallback Callback);
 
        Task<T> TryLoadObject<T>(object ObjectId)
            where T : class;
 
        Task<T> TryLoadObject<T>(string CollectionName, object ObjectId)
            where T : class;
 
        Task<object> TryLoadObject(string CollectionName, object ObjectId);
 
        Task<bool> Export(IDatabaseExport Output, string[] CollectionNames);
 
        Task<bool> Export(IDatabaseExport Output, string[] CollectionNames, ProfilerThread Thread);
 
        Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames)
            where T : class;
 
        Task Iterate<T>(IDatabaseIteration<T> Recipient, string[] CollectionNames, ProfilerThread Thread)
            where T : class;
 
        Task Clear(string CollectionName);
 
        Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData);
 
        Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread);
 
        Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData);
 
        Task<string[]> Repair(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, ProfilerThread Thread);
 
        Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair);
 
        Task<string[]> Analyze(XmlWriter Output, string XsltPath, string ProgramDataFolder, bool ExportData, bool Repair, ProfilerThread Thread);
 
        Task<string[]> Repair(params string[] CollectionNames);
 
        Task<string[]> Repair(ProfilerThread Thread, params string[] CollectionNames);
 
        Task AddIndex(string CollectionName, string[] FieldNames);
 
        Task RemoveIndex(string CollectionName, string[] FieldNames);
 
        Task StartBulk();
 
        Task EndBulk();
 
        Task Start();
 
        Task Stop();
 
        Task Flush();
 
        int ObjectIdByteCount
        {
            get;
        }
 
        Task<IPersistentDictionary> GetDictionary(string Collection);
 
        Task<string[]> GetDictionaries();
 
        Task<string[]> GetCollections();
 
        Task<string> GetCollection(Type Type);
 
        Task<string> GetCollection(Object Object);
 
        Task<bool> IsLabel(string Collection, string Label);
 
        Task<string[]> GetLabels(string Collection);
 
        Task<object> TryGetObjectId(object Object);
 
        Task DropCollection(string CollectionName);
 
        Task<GenericObject> Generalize(object Object);
 
        Task<object> Specialize(GenericObject Object);
 
        string[] GetExcludedCollections();
    }
}