Beispiel #1
0
        internal RankingOrderByChainer(Chainer prev, OrderingArgument[] columns)
            : base(prev)
        {
            Build = (buildContext, buildArgs) =>
            {
                var sql = Text.GenerateSql(30)
                          .Append(Text.OrderBy).S()
                          .Append(OrderingArgument.Concatenate(columns, buildContext, buildArgs, false))
                          .ToString();

                TryThrow(buildContext);

                return(sql);
            };
        }
Beispiel #2
0
        // ctor: Maximized
        internal Predicate(
            DbNode subject,
            MaximizationType maximizationType,
            bool sign,
            LogicalOperator logicalOperator,
            OrderingArgument maximizedExpression,
            long top = 1)
        {
            DbMapping.CheckNullAndThrow(subject);

            if (maximizedExpression == null)
            {
                throw new QueryTalkException("Predicate.ctor", QueryTalkExceptionType.ArgumentNull,
                                             "maximized expression = null", Text.Method.HavingMaxMin);
            }

            // check expression DbColumn type
            if (maximizedExpression.ArgType == typeof(DbColumn))
            {
                var column = (DbColumn)maximizedExpression.Original;
                if (column.Parent != null && column.Parent.Prev != null)
                {
                    throw new QueryTalkException("Predicate.ctor", QueryTalkExceptionType.InvalidHavingPredicateArgument,
                                                 String.Format("node = {0}", column.Parent), Text.Method.HavingMaxMin);
                }

                // column parent must be the same as the subject
                if (!column.Parent.Equals(subject))
                {
                    throw new QueryTalkException("Predicate.ctor", QueryTalkExceptionType.InvalidHavingPredicateArgument,
                                                 String.Format("node = {0}{1}   subject = {2}", column.Parent, Environment.NewLine, subject),
                                                 Text.Method.HavingMaxMin);
                }
            }

            Subject                = subject;
            Sign                   = sign;
            LogicalOperator        = logicalOperator;
            PredicateType          = Wall.PredicateType.Maximized;
            MaximizedType          = maximizationType;
            MaximizedExpression    = maximizedExpression;
            MaximizedTop           = top;
            IsFinalizeable         = true;
            subject.IsFinalizeable = true;
        }
Beispiel #3
0
        private void _Body(OrderingArgument[] columns)
        {
            Query.Clause.OrderBy = this;

            CheckNullOrEmptyAndThrow(Argc(() => columns, columns));

            Query.AddArguments(columns);

            Build = (buildContext, buildArgs) =>
            {
                var sql = Text.GenerateSql(100)
                          .NewLine(Text.OrderBy).S()
                          .Append(OrderingArgument.Concatenate(columns, buildContext, buildArgs, false))
                          .ToString();

                TryThrow(buildContext);

                return(sql);
            };
        }