GroupProcessor.cs

using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Persistence.SQL.Groups;
 
namespace Waher.Script.Persistence.SQL.Processors
{
    public class GroupProcessor : IProcessor<object>
    {
        private readonly ScriptNode[] groupBy;
        private readonly ScriptNode[] groupNames;
        private readonly bool[] groupByAsynchronous;
        private readonly IIterativeEvaluator[] iterators;
        private readonly bool[] iteratorUsesElement;
        private readonly bool[] iteratorAsynchronous;
        private readonly Variables variables;
        private readonly int iteratorCount;
        private readonly int count;
        private readonly bool isAsynchronous;
        private IProcessor<object> processor;
        private ObjectProperties objectVariables = null;
        private object[] last = null;
        private object[] current = null;
 
        public GroupProcessor(Variables Variables,
            ScriptNode[] GroupBy, ScriptNode[] GroupNames, ScriptNode[] Columns,
            ref ScriptNode Having)
        {
            this.variables = Variables;
            this.groupBy = GroupBy;
            this.groupNames = GroupNames;
            this.isAsynchronous = false;
 
            int i, c = GroupBy.Length;
            bool b;
 
            this.groupByAsynchronous = new bool[c];
            this.count = c;
 
            for (i = 0; i < c; i++)
            {
                b = this.groupByAsynchronous[i] = GroupBy[i].IsAsynchronous;
                this.isAsynchronous |= b;
            }
 
            if (!this.isAsynchronous && !(GroupNames is null))
            {
                for (i = 0, c = GroupNames.Length; i < c; i++)
                {
                    if (GroupNames[i].IsAsynchronous)
                    {
                        this.isAsynchronous = true;
                        break;
                    }
                }
            }
 
            if (!this.isAsynchronous && !(Columns is null))
            {
                for (i = 0, c = Columns.Length; i < c; i++)
                {
                    if (Columns[i].IsAsynchronous)
                    {
                        this.isAsynchronous = true;
                        break;
                    }
                }
            }
 
            if (!this.isAsynchronous && !(Having is null))
                this.isAsynchronous |= Having.IsAsynchronous;
 
            ChunkedList<IIterativeEvaluator> Iterators = new ChunkedList<IIterativeEvaluator>();
 
            if (!(Columns is null))
            {
                for (i = 0, c = Columns.Length; i < c; i++)
                    FindIterators(ref Columns[i], Iterators);
            }
 
            FindIterators(ref Having, Iterators);
 
            this.iterators = Iterators.ToArray();
            this.iteratorCount = this.iterators.Length;
 
            this.iteratorUsesElement = new bool[this.iteratorCount];
            this.iteratorAsynchronous = new bool[this.iteratorCount];
 
            for (i = 0; i < this.iteratorCount; i++)
            {
                this.iteratorUsesElement[i] = this.iterators[i].UsesElement;
                this.iteratorAsynchronous[i] = b = this.iterators[i].IsAsynchronous;
                this.isAsynchronous |= b;
            }
        }
 
        public void SetInnerProcessor(IProcessor<object> Processor)
        {
            this.processor = Processor;
        }
 
        internal static void FindIterators(ref ScriptNode Node, ChunkedList<IIterativeEvaluator> Iterators)
        {
            if (Node is IIterativeEvaluation IterativeEvaluation2)
            {
                int IteratorIndex = Iterators.Count;
                IIterativeEvaluator Evaluator = IterativeEvaluation2.CreateEvaluator();
                Iterators.Add(Evaluator);
 
                ScriptNode Node0 = Node;
 
                Node = new GroupIteratorValue(Evaluator, IteratorIndex,
                    Node.Start, Node.Length, Node.Expression);
 
                Node.SetParent(Node0.Parent);
            }
            else if (Node is GroupIteratorValue GroupIteratorValue2)
                Iterators.Add(GroupIteratorValue2.Iterator);
            else
                Node?.ForAllChildNodes(FindIterators, Iterators, SearchMethod.TreeOrder);
        }
 
        internal static bool FindIterators(ScriptNode Node, out ScriptNode NewNode, object State)
        {
            NewNode = null;
 
            if (Node is IIterativeEvaluation IterativeEvaluation)
            {
                ChunkedList<IIterativeEvaluator> Iterators = (ChunkedList<IIterativeEvaluator>)State;
                int IteratorIndex = Iterators.Count;
                IIterativeEvaluator Evaluator = IterativeEvaluation.CreateEvaluator();
                Iterators.Add(Evaluator);
 
                NewNode = new GroupIteratorValue(Evaluator, IteratorIndex,
                    Node.Start, Node.Length, Node.Expression);
            }
            else if (Node is GroupIteratorValue GroupIteratorValue)
            {
                ChunkedList<IIterativeEvaluator> Iterators = (ChunkedList<IIterativeEvaluator>)State;
                Iterators.Add(GroupIteratorValue.Iterator);
            }
 
            return true;
        }
 
        public bool IsAsynchronous => this.isAsynchronous;
 
        public bool Process(object Object)
        {
            IIterativeEvaluator Iterator;
            IElement E;
            object o1, o2;
            int i, j;
 
            if (this.objectVariables is null)
                this.objectVariables = new ObjectProperties(Object, this.variables);
            else
                this.objectVariables.Object = Object;
 
            if (this.last is null)
            {
                this.last = new object[this.count];
 
                for (i = 0; i < this.count; i++)
                {
                    E = this.groupBy[i].Evaluate(this.objectVariables);
                    this.last[i] = E.AssociatedObjectValue;
                }
 
                if (this.iteratorCount > 0)
                {
                    for (j = 0; j < this.iteratorCount; j++)
                        this.iterators[j].RestartEvaluator();
                }
            }
            else
            {
                if (this.current is null)
                    this.current = new object[this.count];
 
                bool Same = true;
 
                for (i = 0; i < this.count; i++)
                {
                    E = this.groupBy[i].Evaluate(this.objectVariables);
 
                    o1 = this.last[i];
                    o2 = this.current[i] = E.AssociatedObjectValue;
 
                    if ((o1 is null ^ o2 is null) ||
                        (!(o1 is null) && !o1.Equals(o2)))
                    {
                        Same = false;
                    }
                }
 
                if (!Same)
                {
                    if (this.processor is null)
                        return false;
 
                    GroupObject Obj = this.GetGroupObject();
                    this.last = null;
 
                    if (!this.processor.Process(Obj))
                        return false;
 
                    this.last = this.current;
                    this.current = null;
                }
            }
 
            if (this.iteratorCount > 0)
            {
                for (j = 0; j < this.iteratorCount; j++)
                {
                    Iterator = this.iterators[j];
 
                    if (this.iteratorUsesElement[j])
                    {
                        E = Iterator.Evaluate(this.objectVariables);
                        Iterator.AggregateElement(E);
                    }
                    else
                        Iterator.AggregateElement(ObjectValue.Null);
                }
            }
 
            return true;
        }
 
        private GroupObject GetGroupObject()
        {
            IElement[] Aggregates = new IElement[this.iteratorCount];
            IIterativeEvaluator Iterator;
            int i;
 
            for (i = 0; i < this.iteratorCount; i++)
            {
                Iterator = this.iterators[i];
                Aggregates[i] = Iterator.GetAggregatedResult();
                Iterator.RestartEvaluator();
            }
 
            return new GroupObject(this.last, Aggregates, this.groupNames, this.variables);
        }
 
        public async Task<bool> ProcessAsync(object Object)
        {
            IIterativeEvaluator Iterator;
            IElement E;
            object o1, o2;
            int i, j;
 
            if (this.objectVariables is null)
                this.objectVariables = new ObjectProperties(Object, this.variables);
            else
                this.objectVariables.Object = Object;
 
            if (this.last is null)
            {
                this.last = new object[this.count];
 
                for (i = 0; i < this.count; i++)
                {
                    if (this.groupByAsynchronous[i])
                        E = await this.groupBy[i].EvaluateAsync(this.objectVariables);
                    else
                        E = this.groupBy[i].Evaluate(this.objectVariables);
 
                    this.last[i] = E.AssociatedObjectValue;
                }
 
                if (this.iteratorCount > 0)
                {
                    for (j = 0; j < this.iteratorCount; j++)
                        this.iterators[j].RestartEvaluator();
                }
            }
            else
            {
                if (this.current is null)
                    this.current = new object[this.count];
 
                bool Same = true;
 
                for (i = 0; i < this.count; i++)
                {
                    if (this.groupByAsynchronous[i])
                        E = await this.groupBy[i].EvaluateAsync(this.objectVariables);
                    else
                        E = this.groupBy[i].Evaluate(this.objectVariables);
 
                    o1 = this.last[i];
                    o2 = this.current[i] = E.AssociatedObjectValue;
 
                    if ((o1 is null ^ o2 is null) ||
                        (!(o1 is null) && !o1.Equals(o2)))
                    {
                        Same = false;
                    }
                }
 
                if (!Same)
                {
                    if (this.processor is null)
                        return false;
 
                    GroupObject Obj = this.GetGroupObject();
                    this.last = null;
 
                    if (!await this.processor.ProcessAsync(Obj))
                        return false;
 
                    this.last = this.current;
                    this.current = null;
                }
            }
 
            if (this.iteratorCount > 0)
            {
                for (j = 0; j < this.iteratorCount; j++)
                {
                    Iterator = this.iterators[j];
 
                    if (this.iteratorUsesElement[j])
                    {
                        if (this.iteratorAsynchronous[j])
                            E = await Iterator.EvaluateAsync(this.objectVariables);
                        else
                            E = Iterator.Evaluate(this.objectVariables);
 
                        Iterator.AggregateElement(E);
                    }
                    else
                        Iterator.AggregateElement(ObjectValue.Null);
                }
            }
 
            return true;
        }
 
        public bool Flush()
        {
            if (!(this.last is null))
            {
                GroupObject Obj = this.GetGroupObject();
                this.last = null;
            
                if (!this.processor.Process(Obj))
                    return false;
            }
 
            return this.processor.Flush();
        }
 
        public async Task<bool> FlushAsync()
        {
            if (!(this.last is null))
            {
                GroupObject Obj = this.GetGroupObject();
                this.last = null;
 
                if (!await this.processor.ProcessAsync(Obj))
                    return false;
            }
 
            return await this.processor.FlushAsync();
        }
    }
}