Beispiel #1
0
 public override void Execute()
 {
     JDatabaseResolver.Resolve <SqlConnection>()
     .DbExecutor(db => {
         Result = db.Delete(_removeObj) > 0;
     });
 }
        public override void Execute()
        {
#if __SQLKATA__
#if __MYSQLKATA__
            JDatabaseResolver.Resolve <MySqlConnection>()
            .DbExecuteKata((db, query) => {
                var todo = query.Query("TODO").Where("ID", Request).First <TODO>();
                if (todo.xIsNotEmpty())
                {
                    Result = query.Query("TODO").Where("ID", todo.ID).Delete() > 0;
                }
            });
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecuteKata(db => {
                var todo = db.Query("TODO").Where("ID", Request).First <TODO>();
                if (todo.xIsNotEmpty())
                {
                    Result = db.Query("TODO").Where("ID", todo.ID).Delete() > 0;
                }
            });
#endif
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecute((db, tran) => {
                var exists = db.Query <TODO>(m => m.ID == this.Request).First();
                if (exists.xIsNotNull())
                {
                    this.Result = db.Delete <TODO>(exists) > 0;
                }
            });
#endif
        }
Beispiel #3
0
 public override void Execute()
 {
     JDatabaseResolver.Resolve <SqlConnection>()
     .DbExecuteKata((db, q) => {
         this.Result = q.Query("USER").Where("USER_ID", this.Request).FirstOrDefault <USER>();
     });
 }
Beispiel #4
0
        public override void Execute()
        {
#if __SQLKATA__
#if __MYSQLKATA__
            JDatabaseResolver.Resolve <MySqlConnection>()
            .DbExecuteKata((db, query) => {
                this.Result = query.Query("TODO")
                              .WhereStarts("TODO_TEXT", this.Request.xSafe(), true)//WHERE TODO_TEXT LIKE '[TEXT]%'
                              .Get <TODO>();
            });
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecuteKata((db, query) => {
                this.Result = db.Query("TODO")
                              .WhereStarts("TODO_TEXT", this.Request.xValue(), true)//WHERE TODO_TEXT LIKE '[TEXT]%'
                              .Get <TODO>();
            });
#endif
#else
            //redb db
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecute((db, tran) =>
            {
                this.Result = db.QueryAll <TODO>().Where(m => m.TODO_TEXT.Contains(Request)).ToList();
                //Result = db.GetList<TODO>($"WHERE TODO_TEXT LIKE '%{Request}%'");
            });
#endif
        }
 public override void Execute()
 {
     JDatabaseResolver.Resolve <SqlConnection>()
     .BeginTran()
     .DbExecuteKata((db, q) => {
         this.Result = q.Query("USER").Where("ID", this.Request).Delete() > 0;
     });
 }
Beispiel #6
0
 public override async Task ExecuteAsync()
 {
     var sql = string.Empty;
     await JDatabaseResolver.Resolve <SqlConnection>()
     .DbExecutorAsync(async con => {
         await InitDatabaseAsync(con);
         await InitTableAsync(con);
         var r  = await IsExistsTableAsync(con);
         Result = r > 0;
     });
 }
Beispiel #7
0
        public override void Execute()
        {
            var sql = string.Empty;

            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecutor(con => {
                InitDatabase(con);
                InitTable(con);
                Result = IsExistsTable(con);
            });
        }
 public override void Execute()
 {
     JDatabaseResolver.Resolve <SqlConnection>()
     .DbExecutor(db => {
         if (_exists.xIsNotNull())
         {
             Result = db.Update(Request);
         }
         Result = db.Insert(Request).Value;
     });
 }
        public override void Execute()
        {
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecutor(con => {
                var compiler = new SqlServerCompiler();
                var db       = new QueryFactory(con, compiler);
                var weathers = db.Query("dbo.WEATHER_FORECAST").Get <WEATHER_FORECAST>();
                weathers.xForEach(item => { item.TEMPERATURE_F = 32 + (int)(item.TEMPERATURE_C / 0.5556); });

                Result = weathers;
            });
        }
 public override void Execute()
 {
     JDatabaseResolver.Resolve <SqlConnection>()
     .BeginTran()
     .DbExecuteKata((db, q) => {
         if (_exists.xIsNotNull())
         {
             this.Result = q.Query("USER").Where("ID", this.Request.USER_ID)
                           .Update(this.Request.xToDictionary());
         }
         this.Result = q.Query("TODO").InsertGetId <int>(this.Request.xToDictionary());
     });
 }
Beispiel #11
0
        public override void Execute()
        {
            //use sqlkata
            var query = new Query("WEATHER_FORECAST").Where("ID", Request.ID).Select("*");

            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecutor(con => {
                var compiler = new SqlServerCompiler();
                var db       = new QueryFactory(con, compiler);
                var weather  = db.Query("dbo.WEATHER_FORECAST").Where("ID", Request.ID)
                               .FirstOrDefault <WEATHER_FORECAST>();
                weather.TEMPERATURE_F = 32 + (int)(weather.TEMPERATURE_C / 0.5556);
                Result = weather;
            });
        }
        public override void Execute()
        {
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecuteKata((db, q) => {
                var query = q.Query("USER");
                if (this.Request.USER_ID.xIsNotNullOrEmpty())
                {
                    query = query.WhereLike("USER_ID", this.Request.USER_ID);
                }

                if (this.Request.USER_NM.xIsNotNullOrEmpty())
                {
                    query = query.WhereLike("USER_NM", this.Request.USER_NM);
                }

                this.Result = query.Get <USER>();
            });
        }
Beispiel #13
0
        public override void Execute()
        {
            this.Result = new List <TODO>();
            var sql = "SELECT * FROM TODO";

            JDatabaseResolver.Resolve <SqlConnection>()
            .BeginTran()
            .DbExecute((c, t) =>
            {
                this.Result.AddRange(c.ExecuteQuery <TODO>(sql, transaction: t));

                JDatabaseResolver.Resolve <MySqlConnection>()
                .BeginTran()
                .DbExecute((c1, t1) =>
                {
                    this.Result.AddRange(c1.ExecuteQuery <TODO>(sql, transaction: t1));
                });
            });
        }
Beispiel #14
0
        public override void Execute()
        {
#if __SQLKATA__
#if __MYSQLKATA__
            JDatabaseResolver.Resolve <MySqlConnection>()
            .DbExecuteKata((db, query) => {
                this.Result = query.Query("TODO").Where("ID", Request).FirstOrDefault <TODO>();
            });
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecuteKata(db => {
                this.Result = db.Query("TODO").Where("ID", Request).FirstOrDefault <TODO>();
            });
#endif
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecute((db, tran) => {
                this.Result = db.Query <TODO>(m => m.ID == this.Request).First();
            });
#endif
        }
        public override void Execute()
        {
#if __SQLKATA__
#if __MYSQLKATA__
            JDatabaseResolver.Resolve <MySqlConnection>()
            .DbExecuteKata((db, query) => {
                if (_exists.xIsNotNull())
                {
                    var effectedRow = query.Query("TODO").Where("ID", _exists.ID).Delete();
                    if (effectedRow > 0)
                    {
                        this.Result = query.Query("TODO").InsertGetId <int>(new {
                            TODO_TEXT = this.Request.TODO_TEXT,
                            W_DATE    = DateTime.Now,
                            M_DATE    = DateTime.Now
                        });
                    }
                }
                else
                {
                    this.Result = query.Query("TODO").InsertGetId <int>(new {
                        TODO_TEXT = this.Request.TODO_TEXT,
                        W_DATE    = DateTime.Now,
                        M_DATE    = DateTime.Now
                    });
                }
            });
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecuteKata(db => {
                if (_exists.xIsNotNull())
                {
                    var effectedRow = db.Query("TODO").Where("ID", _exists.ID).Delete();
                    if (effectedRow > 0)
                    {
                        this.Result = db.Query("TODO").InsertGetId <int>(new {
                            TODO_TEXT = this.Request.TODO_TEXT,
                            W_DATE    = DateTime.Now,
                            M_DATE    = DateTime.Now
                        });
                    }
                }
                else
                {
                    this.Result = db.Query("TODO").InsertGetId <int>(new {
                        TODO_TEXT = this.Request.TODO_TEXT,
                        W_DATE    = DateTime.Now,
                        M_DATE    = DateTime.Now
                    });
                }
            });
#endif
#else
            JDatabaseResolver.Resolve <SqlConnection>()
            .DbExecute((db, tran) =>
            {
                if (_exists.xIsNotNull())
                {
                    if (db.Delete(_exists) > 0)
                    {
                        Result = db.Insert <TODO, int>(Request);
                    }
                }
                else
                {
                    Result = db.Insert <TODO, int>(Request);
                }
            });
#endif
        }