ExportToTable.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Objects.Matrices;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public class ExportToTable : ILedgerExport
    {
        private readonly LinkedList<IElement> elements = new LinkedList<IElement>();
        private readonly ScriptNode[] columns;
        private readonly int width;
        private int height;
        private Variables variables;
 
        public ExportToTable(ScriptNode[] Columns)
        {
            this.columns = Columns;
            this.width = this.columns.Length;
        }
 
        public Variables Variables
        {
            get => this.variables;
            internal set => this.variables = value;
        }
 
        public ObjectMatrix ToMatrix()
        {
            string[] Headers = new string[this.width];
            int i;
 
            for (i = 0; i < this.width; i++)
            {
                if (this.columns[i] is VariableReference Ref)
                    Headers[i] = Ref.VariableName;
                else
                    Headers[i] = "c" + (i + 1).ToString();
            }
 
            return new ObjectMatrix(this.height, this.width, this.elements)
            {
                ColumnNames = Headers
            };
        }
 
        public Task<bool> StartLedger()
        {
            this.height = 0;
            this.elements.Clear();
 
            return Task.FromResult(true);
        }
 
        public Task<bool> EndLedger()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartCollection(string CollectionName)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> EndCollection()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartBlock(string BlockID)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> BlockMetaData(string Key, object Value)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> EndBlock()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndEntry()
        {
            if (this.variables is null)
                return false;
 
            foreach (ScriptNode Ref in this.columns)
            {
                try
                {
                    IElement E;
 
                    if (Ref.IsAsynchronous)
                        E = await Ref.EvaluateAsync(this.variables);
                    else
                        E = Ref.Evaluate(this.variables);
 
                    this.elements.AddLast(E);
                }
                catch (Exception ex)
                {
                    this.elements.AddLast(new ObjectValue(ex));
                }
            }
 
            this.height++;
 
            return true;
        }
 
        public Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportError(string Message)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportException(Exception Exception)
        {
            return Task.FromResult(true);
        }
    }
}