/// <summary>
        /// Finds objects matching filter conditions in <paramref name="Where"/>.
        /// </summary>
        /// <param name="Offset">Offset at which to return elements.</param>
        /// <param name="Top">Maximum number of elements to return.</param>
        /// <param name="Where">Filter conditions.</param>
        /// <param name="Variables">Current set of variables.</param>
        /// <param name="Order">Order at which to order the result set.</param>
        /// <param name="Node">Script node performing the evaluation.</param>
        /// <returns>Enumerator.</returns>
        public override async Task <IResultSetEnumerator> Find(int Offset, int Top, ScriptNode Where, Variables Variables,
                                                               KeyValuePair <VariableReference, bool>[] Order, ScriptNode Node)
        {
            ScriptNode LeftWhere = await Reduce(this.Left, Where);

            KeyValuePair <VariableReference, bool>[] LeftOrder = await Reduce(this.Left, Order);

            IResultSetEnumerator e = await this.Left.Find(0, int.MaxValue,
                                                          LeftWhere, Variables, LeftOrder, Node);

            ScriptNode RightWhere = this.Combine(await Reduce(this.Right, this.Left, Where), this.Conditions);

            e = new LeftOuterJoinEnumerator(e, this.Left.Name, this.Right, this.Right.Name,
                                            RightWhere, Variables, this.Flipped);

            if (!(Where is null))
            {
                e = new ConditionalEnumerator(e, Variables, Where);
            }

            if (Offset > 0)
            {
                e = new OffsetEnumerator(e, Offset);
            }

            if (Top != int.MaxValue)
            {
                e = new MaxCountEnumerator(e, Top);
            }

            return(e);
        }
Пример #2
0
        /// <summary>
        /// Finds objects matching filter conditions in <paramref name="Where"/>.
        /// </summary>
        /// <param name="Offset">Offset at which to return elements.</param>
        /// <param name="Top">Maximum number of elements to return.</param>
        /// <param name="Where">Filter conditions.</param>
        /// <param name="Variables">Current set of variables.</param>
        /// <param name="Order">Order at which to order the result set.</param>
        /// <param name="Node">Script node performing the evaluation.</param>
        /// <returns>Enumerator.</returns>
        public async Task <IResultSetEnumerator> Find(int Offset, int Top, ScriptNode Where, Variables Variables,
                                                      KeyValuePair <VariableReference, bool>[] Order, ScriptNode Node)
        {
            IResultSetEnumerator e = new SynchEnumerator(this.vector.VectorElements.GetEnumerator());
            int i, c;

            if (Where != null)
            {
                e = new ConditionalEnumerator(e, Variables, Where);
            }

            if ((c = Order?.Length ?? 0) > 0)
            {
                List <IElement> Items = new List <IElement>();

                while (await e.MoveNextAsync())
                {
                    if (e.Current is Element E)
                    {
                        Items.Add(E);
                    }
                    else
                    {
                        Items.Add(Expression.Encapsulate(e.Current));
                    }
                }

                Items.Add(e.Current as IElement);

                IComparer <IElement> Order2;

                if (c == 1)
                {
                    Order2 = ToPropertyOrder(Node, Order[0]);
                }
                else
                {
                    IComparer <IElement>[] Orders = new IComparer <IElement> [c];

                    for (i = 0; i < c; i++)
                    {
                        Orders[i] = ToPropertyOrder(Node, Order[i]);
                    }

                    Order2 = new CompoundOrder(Orders);
                }

                Items.Sort(Order2);

                e = new SynchEnumerator(Items.GetEnumerator());
            }

            if (Offset > 0)
            {
                e = new OffsetEnumerator(e, Offset);
            }

            if (Top != int.MaxValue)
            {
                e = new MaxCountEnumerator(e, Top);
            }

            return(e);
        }