Пример #1
0
 private void AddSingleColumn(SubqueryExpression subQuery)
 {
     if (subQuery.Select !.Columns.Count != 1)
     {
         throw new InvalidOperationException("Subquery has {0} columns: {1}".FormatWith(subQuery.Select.Columns.Count, subQuery.ToString()));
     }
     allColumnsUsed.GetOrCreate(subQuery.Select.Alias).Add(subQuery.Select.Columns[0].Name);
 }
        /// <summary>
        /// 子查询转sql
        /// </summary>
        /// <param name="expression">表达式</param>
        /// <param name="Param">返回的参数</param>
        /// <returns></returns>
        public static string MethodCallExpressionToSql(this MethodCallExpression expression, ref DynamicParameters Param)
        {
            //解析子查询
            var subquery = new SubqueryExpression(expression);

            Param = subquery.Param;
            return(subquery.SqlCmd);
        }
Пример #3
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     if ((subquery.NodeType == (ExpressionType)DbExpressionType.Scalar || subquery.NodeType == (ExpressionType)DbExpressionType.In) && subquery.Select != null)
     {
         System.Diagnostics.Debug.Assert(subquery.Select.Columns.Count == 1);
         MarkColumnAsUsed(subquery.Select.Alias, subquery.Select.Columns[0].Name);
     }
     return(base.VisitSubquery(subquery));
 }
Пример #4
0
        protected override Expression VisitSubquery(SubqueryExpression subquery)
        {
            var saveSuppressOrderBy = this.suppressOrderby;

            this.suppressOrderby = true;
            var result = base.VisitSubquery(subquery);

            this.suppressOrderby = saveSuppressOrderBy;
            return(result);
        }
Пример #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="subquery"></param>
        /// <returns></returns>
        protected override Expression VisitSubquery(SubqueryExpression subquery)
        {
            var saveOrderings = this.gatheredOrderings;

            this.gatheredOrderings = null;
            var result = base.VisitSubquery(subquery);

            this.gatheredOrderings = saveOrderings;
            return(result);
        }
		protected override Expression VisitSubquery(SubqueryExpression subquery)
		{
			if ((subquery.NodeType == (ExpressionType)DbExpressionType.Scalar
			     || subquery.NodeType == (ExpressionType)DbExpressionType.In) && subquery.Select != null)
			{
				System.Diagnostics.Debug.Assert(subquery.Select.Columns.Count == 1);
				MarkColumnAsUsed(subquery.Select.Alias, subquery.Select.Columns[0].Name);
			}
			return base.VisitSubquery(subquery);
		}
Пример #7
0
        protected override Expression VisitSubquery(SubqueryExpression subquery)
        {
            if ((subquery.NodeType == DbExpressionType.Scalar ||
                 subquery.NodeType == DbExpressionType.In) &&
                subquery.Select != null)
            {
                MarkColumnAsUsed(subquery.Select.Alias, subquery.Select.Columns[0].Name);
            }

            return(base.VisitSubquery(subquery));
        }
Пример #8
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     if ((subquery.NodeType == (ExpressionType)DbExpressionType.Scalar ||
         subquery.NodeType == (ExpressionType)DbExpressionType.In) &&
         subquery.Select != null)
     {
         if (subquery.Select.Columns.Count != 1)
             throw new InvalidOperationException("Subquery has {0} columns: {1}".Formato(subquery.Select.Columns.Count, subquery.NiceToString()));
         allColumnsUsed.GetOrCreate(subquery.Select.Alias).Add(subquery.Select.Columns[0].Name);
     }
     return base.VisitSubquery(subquery);
 }
Пример #9
0
        /*
         * protected virtual bool CompareNamedValue(NamedValueExpression a, NamedValueExpression b)
         * {
         *  return a.Name == b.Name && Compare(a.Value, b.Value);
         * }
         */

        protected virtual bool CompareSubquery(SubqueryExpression a, SubqueryExpression b)
        {
            if (a.NodeType != b.NodeType)
            {
                return(false);
            }

            return((DbExpressionType)a.NodeType switch
            {
                DbExpressionType.Scalar => CompareScalar((ScalarExpression)a, (ScalarExpression)b),
                DbExpressionType.Exists => CompareExists((ExistsExpression)a, (ExistsExpression)b),
                DbExpressionType.In => CompareIn((InExpression)a, (InExpression)b),
                _ => false,
            });
Пример #10
0
        /*
         * protected virtual bool CompareNamedValue(NamedValueExpression a, NamedValueExpression b)
         * {
         *  return a.Name == b.Name && Compare(a.Value, b.Value);
         * }
         */

        protected virtual bool CompareSubquery(SubqueryExpression a, SubqueryExpression b)
        {
            if (a.NodeType != b.NodeType)
            {
                return(false);
            }

            switch (a.NodeType)
            {
            case DbExpressionType.Scalar:
                return(CompareScalar((ScalarExpression)a, (ScalarExpression)b));

            case DbExpressionType.Exists:
                return(CompareExists((ExistsExpression)a, (ExistsExpression)b));

            case DbExpressionType.In:
                return(CompareIn((InExpression)a, (InExpression)b));
            }

            return(false);
        }
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     return subquery;
 }
Пример #12
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     // don't gather inside scalar and exists
     return(subquery);
 }
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     // don't gather inside scalar & exists
     return subquery;
 }
Пример #14
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     // don't count aggregates in subqueries
     return subquery;
 }
Пример #15
0
 protected virtual Expression VisitSubquery(SubqueryExpression subquery)
 {
     switch ((DbExpressionType)subquery.NodeType)
     {
         case DbExpressionType.Scalar:
             return this.VisitScalar((ScalarExpression)subquery);
         case DbExpressionType.Exists:
             return this.VisitExists((ExistsExpression)subquery);
         case DbExpressionType.In:
             return this.VisitIn((InExpression)subquery);
     }
     return subquery;
 }
Пример #16
0
 protected virtual bool CompareSubquery(SubqueryExpression a, SubqueryExpression b)
 {
     if (a.NodeType != b.NodeType)
         return false;
     switch ((DbExpressionType)a.NodeType)
     {
         case DbExpressionType.Scalar:
             return this.CompareScalar((ScalarExpression)a, (ScalarExpression)b);
         case DbExpressionType.Exists:
             return this.CompareExists((ExistsExpression)a, (ExistsExpression)b);
         case DbExpressionType.In:
             return this.CompareIn((InExpression)a, (InExpression)b);
     }
     return false;
 }
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     var saveOrderings = this.gatheredOrderings;
     this.gatheredOrderings = null;
     var result = base.VisitSubquery(subquery);
     this.gatheredOrderings = saveOrderings;
     return result;
 }
Пример #18
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     var saveSuppressOrderBy = this.suppressOrderby;
     this.suppressOrderby = true;
     var result = base.VisitSubquery(subquery);
     this.suppressOrderby = saveSuppressOrderBy;
     return result;
 }
Пример #19
0
    public void SubQueryStatement() {
      var subQuery = new SubqueryExpression(Sql.Select(Users.Id)
        .AddColumns(Users.Balance, Users.GroupId));

      SelectStatement sql = Sql.Select(Users.Id)
        .AddColumns(Users.Balance, Users.GroupId)
        .Where(Users.Balance == subQuery);
      Assert.AreEqual(sql.ToSQL(),
        "SELECT users.id, users.balance, users.group_id FROM users WHERE (users.balance = (SELECT users.id, users.balance, users.group_id FROM users))");
    }
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     return(subquery);
 }
Пример #21
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     // don't count aggregates in subqueries
     return(subquery);
 }
Пример #22
0
    public void SubQueryStatementWithouBrackets() {
      var subQuery = new SubqueryExpression(Sql.Select(Users.Id)
        .AddColumns(Users.Balance, Users.GroupId), false);

      SelectStatement sql = Sql.Select(Users.Id)
        .AddColumns(Users.Balance, Users.GroupId)
        .Where(Sql.Exists(subQuery));
      Assert.AreEqual(sql.ToSQL(),
        "SELECT users.id, users.balance, users.group_id FROM users WHERE (EXISTS(SELECT users.id, users.balance, users.group_id FROM users))");
    }
Пример #23
0
 private void AddSingleColumn(SubqueryExpression subQuery)
 {
     if (subQuery.Select.Columns.Count != 1)
         throw new InvalidOperationException("Subquery has {0} columns: {1}".FormatWith(subQuery.Select.Columns.Count, subQuery.ToString()));
     allColumnsUsed.GetOrCreate(subQuery.Select.Alias).Add(subQuery.Select.Columns[0].Name);
 }
Пример #24
0
 protected override Expression VisitSubquery(SubqueryExpression subquery)
 {
     return base.VisitSubquery(subquery);
 }