RecordProcessor.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Persistence.SQL.Processors
{
    public class RecordProcessor : IProcessor<object>
    {
        private readonly ChunkedList<IElement[]> items = new ChunkedList<IElement[]>();
        private readonly ScriptNode[] columns;
        private readonly bool[] columnAsynchronous;
        private readonly Variables variables;
        private readonly int count;
        private readonly bool isAsynchronous;
        private ObjectProperties properties = null;
 
        public RecordProcessor(ScriptNode[] Columns, Variables Variables)
        {
            this.columns = Columns;
            this.variables = Variables;
            this.count = this.columns?.Length ?? 0;
            this.columnAsynchronous = new bool[this.count];
 
            for (int i = 0; i < this.count; i++)
            {
                bool b = this.columnAsynchronous[i] = this.columns[i].IsAsynchronous;
                this.isAsynchronous |= b;
            }
        }
 
        public bool IsAsynchronous => this.isAsynchronous;
 
        public int Count => this.items.Count;
 
        public IElement[][] GetRecordSet()
        {
            return this.items.ToArray();
        }
 
        public bool TryGetSingleElement(out IElement Result)
        {
            if (!this.items.HasFirstItem)
            {
                Result = ObjectValue.Null;
                return true;
            }
            else if (this.items.Count == 1 && this.items.FirstItem.Length == 1)
            {
                Result = this.items.FirstItem[0];
                return true;
            }
            else
            {
                Result = null;
                return false;
            }
        }
 
        public bool Process(object Object)
        {
            IElement Element = Object as IElement;
            IElement[] Record;
            int i;
 
            if (this.properties is null)
                this.properties = new ObjectProperties(Element?.AssociatedObjectValue ?? Object, this.variables);
            else
                this.properties.Object = Element?.AssociatedObjectValue ?? Object;
 
            if (this.columns is null)
                Record = new IElement[1] { Element ?? Expression.Encapsulate(Object) };
            else
            {
                Record = new IElement[this.count];
 
                for (i = 0; i < this.count; i++)
                {
                    try
                    {
                        Record[i] = this.columns[i].Evaluate(this.properties);
                    }
                    catch (Exception ex)
                    {
                        ex = Log.UnnestException(ex);
                        Record[i] = Expression.Encapsulate(ex);
                    }
                }
            }
 
            this.ProcessRecord(Record);
 
            return true;
        }
 
        protected virtual void ProcessRecord(IElement[] Record)
        {
            this.items.Add(Record);
        }
 
        public async Task<bool> ProcessAsync(object Object)
        {
            IElement Element = Object as IElement;
            IElement[] Record;
            int i;
 
            if (this.properties is null)
                this.properties = new ObjectProperties(Element?.AssociatedObjectValue ?? Object, this.variables);
            else
                this.properties.Object = Element?.AssociatedObjectValue ?? Object;
 
            if (this.columns is null)
                Record = new IElement[1] { Element ?? Expression.Encapsulate(Object) };
            else
            {
                Record = new IElement[this.count];
 
                for (i = 0; i < this.count; i++)
                {
                    try
                    {
                        if (this.columnAsynchronous[i])
                            Record[i] = await this.columns[i].EvaluateAsync(this.properties);
                        else
                            Record[i] = this.columns[i].Evaluate(this.properties);
                    }
                    catch (Exception ex)
                    {
                        ex = Log.UnnestException(ex);
                        Record[i] = Expression.Encapsulate(ex);
                    }
                }
            }
 
            this.ProcessRecord(Record);
 
            return true;
        }
 
        public bool Flush()
        {
            return true;
        }
 
        public Task<bool> FlushAsync()
        {
            return Task.FromResult(true);
        }
    }
}