CollectionSource.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Persistence.Serialization;
using Waher.Runtime.Settings;
using Waher.Script.Model;
using Waher.Script.Persistence.SQL.Enumerators;
using Waher.Script.Persistence.SQL.Processors;
 
namespace Waher.Script.Persistence.SQL.Sources
{
    public class CollectionSource : IDataSource
    {
        private readonly Dictionary<string, bool> isLabel = new Dictionary<string, bool>();
        private readonly string collectionName;
        private readonly string alias;
 
        public CollectionSource(string CollectionName, string Alias)
        {
            this.collectionName = CollectionName;
            this.alias = Alias;
        }
 
        public async Task<IResultSetEnumerator> Find(int Offset, int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            if (Generic)
            {
                IEnumerable<GenericObject> Objects = await Database.Find<GenericObject>(this.collectionName, Offset, Top,
                    await TypeSource.ConvertAsync(Where, Variables, this.Name), TypeSource.Convert(Order));
 
                return new SynchEnumerator(Objects.GetEnumerator());
            }
            else
            {
                IEnumerable<object> Objects = await Database.Find(this.collectionName, Offset, Top,
                    await TypeSource.ConvertAsync(Where, Variables, this.Name), TypeSource.Convert(Order));
 
                return new SynchEnumerator(Objects.GetEnumerator());
            }
        }
 
        public async Task<bool> Process(IProcessor<object> Processor, int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node)
        {
            if (Generic)
            {
                return await Database.Process(new TypedObjectProcessor<GenericObject>(Processor), this.collectionName, Offset, Top,
                    await TypeSource.ConvertAsync(Where, Variables, this.Name), TypeSource.Convert(Order));
            }
            else
            {
                return await Database.Process(Processor, this.collectionName, Offset, Top,
                    await TypeSource.ConvertAsync(Where, Variables, this.Name), TypeSource.Convert(Order));
            }
        }
 
        public async Task<int?> Delete(bool Lazy, int Offset, int Top, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            Filter Filter = await TypeSource.ConvertAsync(Where, Variables, this.Name);
 
            if (Filter is null && Offset == 0 && Top == int.MaxValue)
            {
                await Database.Clear(this.Name);
                return null;    // TODO: Get number of objects in collection before clearing it.
            }
            else if (Lazy)
            {
                await Database.DeleteLazy(this.collectionName, Offset, Top, Filter, TypeSource.Convert(Order));
                return null;
            }
            else
                return await Database.Delete(this.collectionName, Offset, Top, Filter, TypeSource.Convert(Order));
        }
 
        public Task Update(bool Lazy, IEnumerable<object> Objects)
        {
            return Lazy ? Database.UpdateLazy(Objects) : Database.Update(Objects);
        }
 
        public Task Insert(bool Lazy, object Object)
        {
            return Lazy ? Database.InsertLazy(Object) : Database.Insert(Object);
        }
 
        public string CollectionName => this.collectionName;
 
        public string TypeName
        {
            get { return string.Empty; }
        }
 
        public string Name
        {
            get => string.IsNullOrEmpty(this.alias) ? this.collectionName : this.alias;
        }
 
        public bool IsSource(string Name)
        {
            return
                string.Compare(this.collectionName, Name, true) == 0 ||
                string.Compare(this.alias, Name, true) == 0;
        }
 
        public async Task<bool> IsLabel(string Label)
        {
            bool Result;
 
            lock (this.isLabel)
            {
                if (this.isLabel.TryGetValue(Label, out Result))
                    return Result;
            }
 
            Result = await Database.IsLabel(this.collectionName, Label);
 
            lock (this.isLabel)
            {
                this.isLabel[Label] = Result;
            }
 
            return Result;
        }
 
        public async Task CreateIndex(string Name, string[] Fields)
        {
            await Database.AddIndex(this.collectionName, Fields);
 
            StringBuilder sb = new StringBuilder();
            foreach (string Field in Fields)
                sb.AppendLine(Field);
 
            await RuntimeSettings.SetAsync("SQL.INDEX." + this.collectionName + "." + Name, sb.ToString());
        }
 
        public async Task<bool> DropIndex(string Name)
        {
            string Key = "SQL.INDEX." + this.collectionName + "." + Name;
            string s = await RuntimeSettings.GetAsync(Key, string.Empty);
            string[] Fields = s.Split(crlf, StringSplitOptions.RemoveEmptyEntries);
            if (Fields.Length == 0)
                return false;
 
            await Database.RemoveIndex(this.collectionName, Fields);
            await RuntimeSettings.SetAsync(Key, string.Empty);
 
            return true;
        }
 
        private static readonly char[] crlf = new char[] { '\r', '\n' };
 
        public Task DropCollection()
        {
            return Database.DropCollection(this.collectionName);
        }
 
    }
}