SubQueryPattern.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
 
namespace Waher.Script.Persistence.SPARQL.Patterns
{
    public class SubQueryPattern : ISparqlPattern
    {
        private SparqlQuery subQuery;
 
        public SubQueryPattern(SparqlQuery SubQuery)
        {
            this.subQuery = SubQuery;
        }
 
        public bool IsEmpty => false;
 
        public async Task<IEnumerable<Possibility>> Search(ISemanticCube Cube,
            Variables Variables, IEnumerable<Possibility> ExistingMatches, SparqlQuery Query)
        {
            IElement E = await this.subQuery.EvaluateAsync(Variables, ExistingMatches);
            if (!(E.AssociatedObjectValue is SparqlResultSet ResultSet))
                throw new ScriptRuntimeException("Subquery did not return a SPARQL Result Set.", this.subQuery);
 
            if (ResultSet.BooleanResult.HasValue)
                throw new ScriptRuntimeException("Subquery only returned a Boolean value.", this.subQuery);
 
            LinkedList<Possibility> Result = new LinkedList<Possibility>();
 
            foreach (ISparqlResultRecord Record in ResultSet.Records)
            {
                Possibility P = null;
 
                foreach (ISparqlResultItem Item in Record)
                {
                    if (P is null)
                        P = new Possibility(Item.Name, Item.Value);
                    else
                        P = new Possibility(Item.Name, Item.Value, P);
                }
 
                Result.AddLast(P);
            }
 
            return Result;
        }
 
        public void SetParent(ScriptNode Parent)
        {
            this.subQuery.SetParent(Parent);
        }
 
        public bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (Order == SearchMethod.DepthFirst)
                this.subQuery.ForAllChildNodes(Callback, State, Order);
 
            this.ForAll(Callback, State, Order);
 
            if (Order == SearchMethod.BreadthFirst)
                this.subQuery.ForAllChildNodes(Callback, State, Order);
 
            return true;
        }
 
        public bool ForAll(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            if (!Callback(this.subQuery, out ScriptNode NewNode, State))
                return false;
 
            if (!(NewNode is null))
            {
                if (!(NewNode is SparqlQuery SubQuery))
                    throw new Exception("Expected sub-query node.");
 
                this.subQuery = SubQuery;
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            return obj is SubQueryPattern Typed &&
                this.subQuery.Equals(Typed.subQuery);
        }
 
        public override int GetHashCode()
        {
            int Result = typeof(SubQueryPattern).GetHashCode();
            Result ^= Result << 5 ^ this.subQuery.GetHashCode();
            return Result;
        }
 
    }
}