VectorSource.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Objects.Matrices;
using Waher.Script.Objects.VectorSpaces;
using Waher.Script.Order;
using Waher.Script.Persistence.Functions;
using Waher.Script.Persistence.SQL.Enumerators;
 
namespace Waher.Script.Persistence.SQL.Sources
{
    public class VectorSource : IDataSource
    {
        private readonly Dictionary<Type, bool> types = new Dictionary<Type, bool>();
        private readonly Dictionary<string, bool> isLabel = new Dictionary<string, bool>();
        private readonly IVector vector;
        private readonly ScriptNode node;
        private readonly string name;
        private readonly string alias;
 
        public VectorSource(string Name, string Alias, IVector Vector, ScriptNode Node)
        {
            this.vector = Vector;
            this.node = Node;
            this.name = Name;
            this.alias = Alias;
 
            Type LastType = null;
            Type T;
 
            foreach (IElement E in Vector.ChildElements)
            {
                T = E.AssociatedObjectValue?.GetType();
                if (T is null || T == LastType)
                    continue;
 
                LastType = T;
                this.types[T] = true;
            }
        }
 
        public IVector Vector => this.vector;
 
        public Task<IResultSetEnumerator> Find(int Offset, int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            return Find(this.vector, Offset, Top, Generic, Where, Variables, Order, Node);
        }
 
        public static async Task<IResultSetEnumerator> Find(IVector Vector, int Offset, 
            int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            IResultSetEnumerator e = new SynchEnumerator(Vector.VectorElements.GetEnumerator());
            int i, c;
 
            if (!(Where is null))
                e = new ConditionalEnumerator(e, Variables, Where);
 
            if ((c = Order?.Length ?? 0) > 0)
            {
                List<IElement> Items = new List<IElement>();
 
                while (await e.MoveNextAsync())
                {
                    if (!(e.Current is IElement E))
                        E = Expression.Encapsulate(e.Current);
 
                    Items.Add(Generic ? await Generalize.EvaluateAsync(E) : E);
                }
 
                IComparer<IElement> Order2;
 
                if (c == 1)
                    Order2 = ToPropertyOrder(Node, Order[0]);
                else
                {
                    IComparer<IElement>[] Orders = new IComparer<IElement>[c];
 
                    for (i = 0; i < c; i++)
                        Orders[i] = ToPropertyOrder(Node, Order[i]);
 
                    Order2 = new CompoundOrder(Orders);
                }
 
                Items.Sort(Order2);
 
                e = new SynchEnumerator(Items.GetEnumerator());
            }
 
            if (Offset > 0)
                e = new OffsetEnumerator(e, Offset);
 
            if (Top != int.MaxValue)
                e = new MaxCountEnumerator(e, Top);
 
            return e;
        }
 
        private static PropertyOrder ToPropertyOrder(ScriptNode Node, KeyValuePair<VariableReference, bool> Order)
        {
            return new PropertyOrder(Node, Order.Key.VariableName, Order.Value ? 1 : -1);
        }
 
        public Task<bool> Process(IProcessor<object> Processor, int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node)
        {
            return Process(Processor, this.vector, Offset, Top, Generic, Where, Variables, Order, Node);
        }
 
        internal static async Task<bool> Process(IProcessor<object> Processor, IVector Vector,
            int Offset, int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            IResultSetEnumerator e = await Find(Vector, Offset, Top, Generic, Where, Variables, Order, Node);
            bool IsAsynchronous = Processor.IsAsynchronous;
 
            while (await e.MoveNextAsync())
            {
                if (IsAsynchronous)
                {
                    if (!await Processor.ProcessAsync(e.Current))
                        return false;
                }
                else
                {
                    if (!Processor.Process(e.Current))
                        return false;
                }
            }
            
            return true;
        }
 
        public Task Update(bool Lazy, IEnumerable<object> Objects)
        {
            return Task.CompletedTask;  // Do nothing.
        }
 
        private Exception InvalidOperation()
        {
            return new ScriptRuntimeException("Operation not permitted on joined sources.", this.node);
        }
 
        public Task<int?> Delete(bool Lazy, int Offset, int Top, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            throw this.InvalidOperation();
        }
 
        public Task Insert(bool Lazy, object Object)
        {
            throw this.InvalidOperation();
        }
 
        public string CollectionName
        {
            get { throw new ScriptRuntimeException("Collection not defined.", this.node); }
        }
 
        public string TypeName
        {
            get { throw new ScriptRuntimeException("Type not defined.", this.node); }
        }
 
        public string Name
        {
            get => string.IsNullOrEmpty(this.alias) ? this.name : this.alias;
        }
 
        public bool IsSource(string Name)
        {
            return
                string.Compare(this.name, Name, true) == 0 ||
                string.Compare(this.alias, Name, true) == 0;
        }
 
        public Task<bool> IsLabel(string Label)
        {
            lock (this.isLabel)
            {
                if (!this.isLabel.TryGetValue(Label, out bool Result))
                {
                    Result = false;
 
                    foreach (Type T in this.types.Keys)
                    {
                        PropertyInfo PI = T.GetRuntimeProperty(Label);
 
                        if (PI is null)
                        {
                            FieldInfo FI = T.GetRuntimeField(Label);
 
                            if (!(FI is null))
                            {
                                Result = FI.IsPublic;
                                break;
                            }
                        }
                        else
                        {
                            Result = PI.CanRead && PI.GetMethod.IsPublic;
                            break;
                        }
                    }
 
                    this.isLabel[Label] = Result;
                }
 
                return Task.FromResult<bool>(Result);
            }
        }
 
        public Task CreateIndex(string Name, string[] Fields)
        {
            throw this.InvalidOperation();
        }
 
        public Task<bool> DropIndex(string Name)
        {
            throw this.InvalidOperation();
        }
 
        public Task DropCollection()
        {
            throw this.InvalidOperation();
        }
 
        public static ObjectVector ToGenericObjectVector(ObjectMatrix ResultSet)
        {
            if (!ResultSet.HasColumnNames)
                throw new ArgumentException("Result Set lacks named columns.", nameof(ResultSet));
 
            int Rows = ResultSet.Rows;
            int Columns = ResultSet.Columns;
            string[] Names = ResultSet.ColumnNames;
            IElement[] Objects = new IElement[Rows];
            Dictionary<string, object> Object;
            int x, y;
 
            for (y = 0; y < Rows; y++)
            {
                Object = new Dictionary<string, object>();
                Objects[y] = new ObjectValue(Object);
 
                for (x = 0; x < Columns; x++)
                    Object[Names[x]] = ResultSet.GetElement(x, y).AssociatedObjectValue;
            }
 
            return new ObjectVector(Objects);
        }
 
    }
}