XmlSource.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Persistence.Functions;
using Waher.Script.Persistence.SQL.Enumerators;
 
namespace Waher.Script.Persistence.SQL.Sources
{
    public class XmlSource : IDataSource
    {
        private readonly XmlDocument xmlDocument;
        private readonly XmlNode xmlNode;
        private readonly ScriptNode node;
        private readonly string name;
        private readonly string alias;
 
        public XmlSource(string Name, string Alias, XmlDocument Xml, ScriptNode Node)
        {
            this.xmlDocument = Xml;
            this.xmlNode = null;
            this.node = Node;
            this.name = Name;
            this.alias = Alias;
        }
 
        public XmlSource(string Name, string Alias, XmlNode Xml, ScriptNode Node)
        {
            this.xmlDocument = null;
            this.xmlNode = Xml;
            this.node = Node;
            this.name = Name;
            this.alias = Alias;
        }
 
        public async Task<IResultSetEnumerator> Find(int Offset, int Top, bool Generic, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            XPath WhereXPath = Where as XPath;
            if (WhereXPath is null && !(Where is null))
                throw new ScriptRuntimeException("WHERE clause must use an XPATH expression when selecting nodes from XML.", Where);
 
            IElement Obj;
 
            if (WhereXPath is null)
                Obj = new ObjectValue(this.xmlDocument ?? this.xmlNode);
            else
            {
                ObjectProperties P = new ObjectProperties(this.xmlDocument ?? this.xmlNode, Variables);
 
                if (WhereXPath.IsAsynchronous)
                    Obj = await WhereXPath.EvaluateAsync(P);
                else
                    Obj = WhereXPath.Evaluate(P);
            }
 
            if (!(Obj is IVector Vector))
                Vector = Operators.Vectors.VectorDefinition.Encapsulate(new IElement[] { Obj }, false, Node);
 
            return await VectorSource.Find(Vector, Offset, Top, Generic, null, Variables, Order, Node);
        }
 
        public async Task<bool> Process(IProcessor<object> Processor, int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node)
        {
            XPath WhereXPath = Where as XPath;
            if (WhereXPath is null && !(Where is null))
                throw new ScriptRuntimeException("WHERE clause must use an XPATH expression when selecting nodes from XML.", Where);
 
            IElement Obj;
 
            if (WhereXPath is null)
                Obj = new ObjectValue(this.xmlDocument ?? this.xmlNode);
            else
            {
                ObjectProperties P = new ObjectProperties(this.xmlDocument ?? this.xmlNode, Variables);
                Obj = WhereXPath.Evaluate(P);   // TODO: Async
            }
 
            if (!(Obj is IVector Vector))
                Vector = Operators.Vectors.VectorDefinition.Encapsulate(new IElement[] { Obj }, false, Node);
 
            return await VectorSource.Process(Processor, Vector, Offset, Top, Generic, null, Variables, Order, Node);
        }
 
        public Task Update(bool Lazy, IEnumerable<object> Objects)
        {
            return Task.CompletedTask;  // Do nothing.
        }
 
        private Exception InvalidOperation()
        {
            return new ScriptRuntimeException("Operation not permitted on joined sources.", this.node);
        }
 
        public Task<int?> Delete(bool Lazy, int Offset, int Top, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            throw this.InvalidOperation();
        }
 
        public Task Insert(bool Lazy, object Object)
        {
            throw this.InvalidOperation();
        }
 
        public string CollectionName
        {
            get { throw new ScriptRuntimeException("Collection not defined.", this.node); }
        }
 
        public string TypeName
        {
            get { throw new ScriptRuntimeException("Type not defined.", this.node); }
        }
 
        public string Name
        {
            get => string.IsNullOrEmpty(this.alias) ? this.name : this.alias;
        }
 
        public bool IsSource(string Name)
        {
            return
                string.Compare(this.name, Name, true) == 0 ||
                string.Compare(this.alias, Name, true) == 0;
        }
 
        public Task<bool> IsLabel(string Label)
        {
            return Task.FromResult(false);
        }
 
        public Task CreateIndex(string Name, string[] Fields)
        {
            throw this.InvalidOperation();
        }
 
        public Task<bool> DropIndex(string Name)
        {
            throw this.InvalidOperation();
        }
 
        public Task DropCollection()
        {
            throw this.InvalidOperation();
        }
 
    }
}