JoinedSource.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Model;
using Waher.Script.Persistence.SQL.Enumerators;
 
namespace Waher.Script.Persistence.SQL.Sources
{
    public abstract class JoinedSource : IDataSource
    {
        private readonly IDataSource left;
        private readonly IDataSource right;
        private readonly ScriptNode conditions;
 
        public JoinedSource(IDataSource Left, IDataSource Right, ScriptNode Conditions)
        {
            this.left = Left;
            this.right = Right;
            this.conditions = Conditions;
        }
 
        public IDataSource Left => this.left;
 
        public IDataSource Right => this.right;
 
        public ScriptNode Conditions => this.conditions;
 
        public abstract Task<IResultSetEnumerator> Find(int Offset, int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node);
        
        public abstract Task<bool> Process(IProcessor<object> Processor, int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node);
 
        public Task Update(bool Lazy, IEnumerable<object> Objects)
        {
            throw InvalidOperation();
        }
 
        private static Exception InvalidOperation()
        {
            return new InvalidOperationException("Operation not permitted on joined sources.");
        }
 
        public Task<int?> Delete(bool Lazy, int Offset, int Top, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            throw InvalidOperation();
        }
 
        public Task Insert(bool Lazy, object Object)
        {
            throw InvalidOperation();
        }
 
        public string CollectionName
        {
            get => throw InvalidOperation();
        }
 
        public string TypeName
        {
            get => throw InvalidOperation();
        }
 
        public string Name => string.Empty;
 
        public bool IsSource(string Name)
        {
            return this.left.IsSource(Name) || this.right.IsSource(Name);
        }
 
        public async Task<bool> IsLabel(string Label)
        {
            return
                await this.left.IsLabel(Label) ||
                await this.right.IsLabel(Label);
        }
 
        protected ScriptNode Combine(ScriptNode Where, ScriptNode On)
        {
            if (Where is null)
                return On;
            else if (On is null)
                return Where;
            else
                return new Operators.Logical.And(Where, On, 0, 0, Where.Expression);
        }
 
        protected static async Task<ScriptNode> Reduce(IDataSource Source, ScriptNode Where)
        {
            KeyValuePair<ScriptNode, int> P = await Reduce(Source, null, Where, 1);
            return P.Key;
        }
 
        protected static async Task<ScriptNode> Reduce(IDataSource Source, IDataSource Source2, ScriptNode Where)
        {
            KeyValuePair<ScriptNode, int> P = await Reduce(Source, Source2, Where, 1);
            return P.Key;
        }
 
        private static async Task<KeyValuePair<ScriptNode, int>> Reduce(IDataSource Source, IDataSource Source2, ScriptNode Where, int Mask)
        {
            KeyValuePair<ScriptNode, int> P1, P2;
            ScriptNode Op1;
            ScriptNode Op2;
            int s1;
            int s2;
            int s;
 
            if (Where is null)
                return Null;
            else if (Where is Operators.Comparisons.Range Range)
            {
                if (Range.LeftInclusive)
                    Op1 = new Operators.Comparisons.LesserThanOrEqualTo(Range.LeftOperand, Range.MiddleOperand, Range.Start, Range.Length, Range.Expression);
                else
                    Op1 = new Operators.Comparisons.LesserThan(Range.LeftOperand, Range.MiddleOperand, Range.Start, Range.Length, Range.Expression);
 
                if (Range.RightInclusive)
                    Op2 = new Operators.Comparisons.GreaterThanOrEqualTo(Range.MiddleOperand, Range.RightOperand, Range.Start, Range.Length, Range.Expression);
                else
                    Op2 = new Operators.Comparisons.GreaterThan(Range.MiddleOperand, Range.RightOperand, Range.Start, Range.Length, Range.Expression);
 
                return await Reduce(Source, Source2, new Operators.Logical.And(Op1, Op2, Range.Start, Range.Length, Range.Expression), Mask);
            }
            else if (Where is BinaryOperator BinOp)
            {
                P1 = await Reduce(Source, Source2, BinOp.LeftOperand, Mask);
                Op1 = P1.Key;
                s1 = P1.Value;
 
                P2 = await Reduce(Source, Source2, BinOp.RightOperand, Mask);
                Op2 = P2.Key;
                s2 = P2.Value;
 
                s = s1 | s2;
 
                if ((s & Mask) == 0)
                    return Null;
 
                bool IsAnd = BinOp is Operators.Logical.And || BinOp is Operators.Dual.And;
                bool IsOr = !IsAnd && (Where is Operators.Logical.Or || Where is Operators.Dual.Or);
 
                if (IsAnd || IsOr)
                {
                    if (Op1 is null)
                        return P2;
                    else if (Op2 is null)
                        return P1;
                    else if (IsAnd)
                        return new KeyValuePair<ScriptNode, int>(new Operators.Logical.And(Op1, Op2, 0, 0, BinOp.Expression), s);
                    else if (IsOr)
                        return new KeyValuePair<ScriptNode, int>(new Operators.Logical.Or(Op1, Op2, 0, 0, BinOp.Expression), s);
                }
                else if (Op1 is null || Op2 is null)
                    return Null;
                else if (Op1 == BinOp.LeftOperand && Op2 == BinOp.RightOperand)
                    return new KeyValuePair<ScriptNode, int>(Where, s);
                else if (BinOp is Operators.Comparisons.EqualTo)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.EqualTo(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.GreaterThan)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.GreaterThan(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.GreaterThanOrEqualTo)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.GreaterThanOrEqualTo(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.LesserThan)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.LesserThan(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.LesserThanOrEqualTo)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.LesserThanOrEqualTo(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.Like)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.Like(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.NotEqualTo)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.NotEqualTo(Op1, Op2, 0, 0, BinOp.Expression), s);
                else if (BinOp is Operators.Comparisons.NotLike)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Comparisons.NotLike(Op1, Op2, 0, 0, BinOp.Expression), s);
            }
            else if (Where is Operators.Membership.NamedMember N)
            {
                if (N.Operand is VariableReference Ref)
                {
                    if (Source.IsSource(Ref.VariableName))
                        return new KeyValuePair<ScriptNode, int>(N, 1);
                    else if (Source2?.IsSource(Ref.VariableName) ?? false)
                        return new KeyValuePair<ScriptNode, int>(N, 2);
                    else
                        return Null;
                }
                else
                    return Null;
            }
            else if (Where is UnaryOperator UnOp)
            {
                P1 = await Reduce(Source, Source2, UnOp.Operand, Mask);
                Op1 = P1.Key;
                s1 = P1.Value;
 
                if (Op1 is null)
                    return Null;
 
                if (UnOp is Operators.Logical.Not)
                    return new KeyValuePair<ScriptNode, int>(new Operators.Logical.Not(Op1, 0, 0, UnOp.Expression), s1);
            }
            else if (Where is VariableReference Ref)
            {
                if (await Source.IsLabel(Ref.VariableName))
                    return new KeyValuePair<ScriptNode, int>(Ref, 1);
                else if (!(Source2 is null) && await Source2.IsLabel(Ref.VariableName))
                    return new KeyValuePair<ScriptNode, int>(Ref, 2);
                else
                    return Null;
            }
            else if (Where is ConstantElement C)
                return new KeyValuePair<ScriptNode, int>(C, 0);
 
            return Null;
        }
 
        private static readonly KeyValuePair<ScriptNode, int> Null = new KeyValuePair<ScriptNode, int>(null, 0);
 
        protected static async Task<KeyValuePair<VariableReference, bool>[]> Reduce(IDataSource Source,
            KeyValuePair<VariableReference, bool>[] Order)
        {
            if (Order is null)
                return null;
 
            int i, c = Order.Length;
 
            for (i = 0; i < c; i++)
            {
                if (!await Source.IsLabel(Order[i].Key.VariableName))
                    break;
            }
 
            if (i != c)
                Array.Resize(ref Order, c);
 
            return Order;
        }
 
        public Task CreateIndex(string Name, string[] Fields)
        {
            throw InvalidOperation();
        }
 
        public Task<bool> DropIndex(string Name)
        {
            throw InvalidOperation();
        }
 
        public Task DropCollection()
        {
            throw InvalidOperation();
        }
 
    }
}