Example #1
0
        public QsiDerivedTableNode VisitQueryParenthesisExpression(QueryParenthesisExpression queryParenthesisExpression)
        {
            return(TreeHelper.Create <QsiDerivedTableNode>(n =>
            {
                // Ignored ForClause, OffsetClause, OrderByClause
                n.Columns.SetValue(TreeHelper.CreateAllColumnsDeclaration());
                n.Source.SetValue(VisitQueryExpression(queryParenthesisExpression.QueryExpression));

                SqlServerTree.PutFragmentSpan(n, queryParenthesisExpression);
            }));
        }
Example #2
0
 public override void Visit(QueryParenthesisExpression node) { this.action(node); }
        public static EngineResult Evaluate(QueryExpression queryExpr, Scope scope)
        {
            var result = queryExpr switch
            {
                QuerySpecification querySpec => Evaluate(querySpec, scope),
                QueryParenthesisExpression paren => Evaluate(paren.QueryExpression, scope),
                BinaryQueryExpression binaryExpr => Evaluate(
                    binaryExpr.BinaryQueryExpressionType,
                    binaryExpr.All,
                    Evaluate(binaryExpr.FirstQueryExpression, scope).ResultSet,
                    Evaluate(binaryExpr.SecondQueryExpression, scope).ResultSet,
                    scope.Env),
                _ => throw FeatureNotSupportedException.Subtype(queryExpr)
            };

            if (result.ResultSet == null)
            {
                return(result);
            }

            var projection = result.ResultSet;

            // ORDER BY

            if (queryExpr.OrderByClause != null)
            {
                var elements     = queryExpr.OrderByClause.OrderByElements;
                var firstElement = elements.First();
                var restElements = elements.Skip(1);
                var temp         = projection.CopyLayout();

                foreach (var row in restElements.Aggregate(
                             Order(projection.Rows, firstElement, scope),
                             (orderedRows, element) => Order(orderedRows, element, scope)))
                {
                    CopyOnto(row, temp, scope.Env);
                }

                projection.Rows.Clear();
                CopyOnto(temp, projection, scope.Env);
            }

            // OFFSET

            if (queryExpr.OffsetClause != null)
            {
                var offset = Evaluate <int>(queryExpr.OffsetClause.OffsetExpression, NullArgument.It, scope);

                for (var i = 0; i < offset; ++i)
                {
                    projection.Rows.RemoveAt(0);
                }

                if (queryExpr.OffsetClause.FetchExpression != null)
                {
                    var fetch = Evaluate <int>(queryExpr.OffsetClause.FetchExpression, NullArgument.It, scope);

                    while (projection.Rows.Count > fetch)
                    {
                        projection.Rows.RemoveAt(projection.Rows.Count - 1);
                    }
                }
            }

            return(new EngineResult(projection));
        }
    }
 public override void ExplicitVisit(QueryParenthesisExpression fragment)
 {
     _fragments.Add(fragment);
 }
 public override void ExplicitVisit(QueryParenthesisExpression node)
 {
     base.ExplicitVisit(node);
 }