InsertValues.cs

using System;
using System.Threading.Tasks;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators;
 
namespace Waher.Script.Persistence.SQL
{
    public class InsertValues : ScriptNode, IEvaluateAsync
    {
        private SourceDefinition source;
        private ElementList columns;
        private ElementList values;
        private readonly int nrFields;
        private readonly bool lazy;
 
        public InsertValues(SourceDefinition Source, ElementList Columns, ElementList Values, bool Lazy, int Start, int Length, Expression Expression)
            : base(Start, Length, Expression)
        {
            if ((this.nrFields = Columns.Elements.Length) != Values.Elements.Length)
                throw new ArgumentException("Column and Value lists must have the same lengths.", nameof(Values));
 
            this.source = Source;
            this.source?.SetParent(this);
 
            this.columns = Columns;
            this.columns?.SetParent(this);
 
            this.values = Values;
            this.values?.SetParent(this);
 
            this.lazy = Lazy;
        }
 
        public override bool IsAsynchronous => true;
 
        public override IElement Evaluate(Variables Variables)
        {
            return this.EvaluateAsync(Variables).Result;
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            IDataSource Source = await this.source.GetSource(Variables);
            GenericObject Obj = new GenericObject(Source.CollectionName, Source.TypeName, Guid.Empty);
            ScriptNode Node;
            IElement E;
            string Column;
            int i;
 
            for (i = 0; i < this.nrFields; i++)
            {
                Column = await GetNameAsync(this.columns.Elements[i], Variables);
 
                Node = this.values.Elements[i];
                E = await Node.EvaluateAsync(Variables);
 
                Obj[Column] = E.AssociatedObjectValue;
            }
 
            await Source.Insert(this.lazy, Obj);
 
            return new ObjectValue(Obj);
        }
 
        public static async Task<string> GetNameAsync(ScriptNode Node, Variables Variables)
        {
            if (Node is VariableReference Ref)
                return Ref.VariableName;
            else
            {
                IElement E = await Node.EvaluateAsync(Variables);
                if (E.AssociatedObjectValue is string s)
                    return s;
                else
                    throw new ScriptRuntimeException("Exepected variable reference or string value.", Node);
            }
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
            {
                if (!(this.source?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.columns?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.values?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            ScriptNode NewNode;
            bool b;
 
            if (!(this.source is null))
            {
                b = !Callback(this.source, out NewNode, State);
                if (!(NewNode is null) && NewNode is SourceDefinition Source2)
                {
                    this.source = Source2;
                    this.source.SetParent(this);
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.source.ForAllChildNodes(Callback, State, Order)))
                    return false;
            }
 
            if (!(this.columns is null))
            {
                b = !Callback(this.columns, out NewNode, State);
                if (!(NewNode is null) && NewNode is ElementList NewColumns)
                {
                    this.columns = NewColumns;
                    this.columns.SetParent(this);
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.columns.ForAllChildNodes(Callback, State, Order)))
                    return false;
            }
 
            if (!(this.values is null))
            {
                b = !Callback(this.values, out NewNode, State);
                if (!(NewNode is null) && NewNode is ElementList NewValues)
                {
                    this.values = NewValues;
                    this.values.SetParent(this);
                }
 
                if (b || (Order == SearchMethod.TreeOrder && !this.values.ForAllChildNodes(Callback, State, Order)))
                    return false;
            }
 
            if (Order == SearchMethod.BreadthFirst)
            {
                if (!(this.source?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.columns?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
 
                if (!(this.values?.ForAllChildNodes(Callback, State, Order) ?? true))
                    return false;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return (obj is InsertValues O &&
                AreEqual(this.source, O.source) &&
                AreEqual(this.columns, O.columns) &&
                AreEqual(this.values, O.values) &&
                base.Equals(obj));
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ GetHashCode(this.source);
            Result ^= Result << 5 ^ GetHashCode(this.columns);
            Result ^= Result << 5 ^ GetHashCode(this.values);
            return Result;
        }
 
    }
}