Beispiel #1
0
        public static void Printf <T>(FluentExpressionSQLCore <T> expression2Sql, string description = "")
        {
            // string sql = expression2Sql.ToSqlString();

            string comment = "--";

            if (!string.IsNullOrWhiteSpace(description))
            {
                Print(comment + description);
            }
            if (ExpressionSqlBuilder.ExistSubQuery())
            {
                foreach (KeyValuePair <string, object> item in ExpressionSqlBuilder.GetExistDbParameters())
                {
                    Print(comment + item.ToString() + " --- " + item.Value.GetType());
                }
            }
            //Console.WriteLine(expression2Sql.RawString);
            Print("-------------------参数----------------------------");
            foreach (KeyValuePair <string, object> item in expression2Sql.DbParams)
            {
                Print(comment + item.ToString() + " --- " + item.Value.GetType());
            }

            Print("-------------------SQL----------------------------");

            Print(expression2Sql.RawString);

            Print("-------------------RawSQL----------------------------");
            Print(expression2Sql.ToSqlString());
            Console.WriteLine();
            Console.WriteLine();
        }
Beispiel #2
0
 public OrderExpression(FluentExpressionSQLCore <T> e) : base(e)
 {
     //ExpressionSqlCore = e;
     SqlPack = e._sqlPack;
     this.ExecuteDelegateAction      = e.ExecuteDelegateAction;
     this.ExecuteScalarAction        = e.ExecuteScalarAction;
     this.ExecuteReaderAction        = e.ExecuteReaderAction;
     this.ExecuteDelegateAsyncAction = e.ExecuteDelegateAsyncAction;
     this.ExecuteScalarAsyncAction   = e.ExecuteScalarAsyncAction;
     this.ExecuteReaderAsyncAction   = e.ExecuteReaderAsyncAction;
     this.Database = e.Database;
 }
        //private Dictionary<Type, dynamic> _ExpressionContainers = null;

        private FluentExpressionSQLCore <T> NewExpressionContainer <T>()
        {
            FluentExpressionSQLCore <T> e = new FluentExpressionSQLCore <T>(DatabaseType, TableMapperContainer);

            e.ExecuteScalarAction        = ExecuteScalarAction;
            e.ExecuteDelegateAction      = ExecuteDelegateAction;
            e.ExecuteReaderAction        = ExecuteReaderAction;
            e.ExecuteScalarAsyncAction   = ExecuteScalarAsyncAction;
            e.ExecuteDelegateAsyncAction = ExecuteDelegateAsyncAction;
            e.ExecuteReaderAsyncAction   = ExecuteReaderAsyncAction;
            e.Database = Database;

            return(e);

            //dynamic cached = null;
            //FluentExpressionSQLCore<T> result = null;
            //Type type = typeof(T);
            //if (_ExpressionContainers.TryGetValue(type, out cached))
            //{
            //    result = cached as FluentExpressionSQLCore<T>;
            //}

            //if (result == null)
            //{
            //    var e = new FluentExpressionSQLCore<T>(DatabaseType, TableMapperContainer);
            //    e.ExecuteScalarAction = ExecuteScalarAction;
            //    e.ExecuteDelegateAction = ExecuteDelegateAction;
            //    e.ExecuteReaderAction = ExecuteReaderAction;
            //    e.ExecuteScalarAsyncAction = ExecuteScalarAsyncAction;
            //    e.ExecuteDelegateAsyncAction = ExecuteDelegateAsyncAction;
            //    e.ExecuteReaderAsyncAction = ExecuteReaderAsyncAction;
            //    e.Database = Database;

            //    result = e;
            //    _ExpressionContainers[type] = e;
            //}
            //else
            //{
            //    result.Clear();
            //}

            //return result;
        }
Beispiel #4
0
 public static async Task <int> ExecuteAsync <TEntity>(this IDatabase db, FluentExpressionSQLCore <TEntity> expression) where TEntity : class
 {
     return(await db.ExecuteAsync(expression.ToSqlString()));
 }
Beispiel #5
0
 public static async Task <IEnumerable <TEntity> > ExecuteQueryAsync <TEntity>(this IDatabase db, FluentExpressionSQLCore <TEntity> expression) where TEntity : class
 {
     //string sql = expression.RawString;
     //return db.SqlQuery<TEntity>(sql, expression.DbParams);
     return(await db.SqlQueryAsync <TEntity>(expression.ToSqlString()));
 }