示例#1
0
        private bool UpdateValueInForeignTable(Guid tenantId, string tableName, string entityPrefix, string primaryKey, List <ColumnAndField> matchingColumns, string primaryValue)
        {
            var queryBuilder  = new InsertQueryBuilder();
            var insertColumns = new Dictionary <string, string> ();

            foreach (var match in matchingColumns)
            {
                if (match.TableName.Equals(tableName) && match.EntityPrefix.Equals(entityPrefix))
                {
                    if (match.Value != null)
                    {
                        insertColumns.Add(match.ColumnName, match.Value.ToString());
                    }
                }
            }
            if (!insertColumns.Any())
            {
                return(true);
            }
            UpdateQueryBuilder query = new UpdateQueryBuilder();

            query.AddTable(tableName, insertColumns);
            query.AddWhere(primaryKey, Comparison.Equals, primaryValue.ToString(), 1);
            var         updateQuery = query.BuildQuery();
            IQueryAdmin admin       = new QueryAdmin();
            var         status      = admin.UpdateResult(tenantId, "inverse", updateQuery);

            return(status);
        }
示例#2
0
        public void PersistSessionObject(IDbConnectionAbstraction connectionAbstraction)
        {
            Dictionary <string, object> .Enumerator parameters = _parameters.GetEnumerator();

            using (SqlCommand command = new SqlCommand())
            {
                IQueryBuilder queryBuilder = null;

                if (IsNew)
                {
                    queryBuilder = new InsertQueryBuilder();
                }
                else if (IsDirty)
                {
                    queryBuilder = new UpdateQueryBuilder();
                }
                else
                {
                    return;
                }

                while (parameters.MoveNext())
                {
                    queryBuilder.AddParameter(parameters.Current.Key, parameters.Current.Value);
                }

                command.Parameters.AddRange(queryBuilder.GenerateSqlParameters());
                command.Connection  = connectionAbstraction.Connection;
                command.CommandText = queryBuilder.GenerateSqlQuery();

                connectionAbstraction.Open();
                TransactionId = long.Parse(command.ExecuteScalar().ToString());
                connectionAbstraction.Close();
            }
        }
示例#3
0
        private string BuildUpdate(IDictionary <string, object> parameters, UpdateQueryBuilder query)
        {
            if (query == null)
            {
                return(null);
            }
            if (query.Tables.Count == 0)
            {
                return(null);
            }
            if (query.Sets.Count == 0)
            {
                return(null);
            }

            var builder = new StringBuilder();

            builder.Append("UPDATE ")
            .Append(BuildTables(parameters, query.Tables))
            .Append(Environment.NewLine).Append("SET ")
            .Append(string.Join("," + Environment.NewLine, query.Sets.Select(s => BuildUpdateSet(parameters, s))));

            var where = SqlRender.BuildCondition(query.WhereConditions, parameters);
            if (!string.IsNullOrWhiteSpace(where))
            {
                builder.Append(Environment.NewLine).Append($"WHERE ({where})");
            }

            return(builder.ToString());
        }
示例#4
0
        /// <summary>
        /// Updates an Entity in the database, provided that none of the Primary
        /// keys were modified.
        /// </summary>
        /// <remarks>This method utilizes the <see cref="PreparedNonQuery"/> to speed things along.</remarks>
        /// <param name="obj">The <see cref="TEntity"/> object to update in the dataset</param>
        /// <returns>true if any records in the database were affected; false otherwise.</returns>
        public bool Update(TEntity obj)
        {
            if (UpdateQuery == null)
            {
                using (var updateQuery = new UpdateQueryBuilder(EntityTable.TableName, Context))
                {
                    // Generate the SQL
                    foreach (var attribute in EntityTable.Columns)
                    {
                        // Keys go in the WHERE statement, not the SET statement
                        if (EntityTable.PrimaryKeys.Contains(attribute.Key))
                        {
                            PropertyInfo info = attribute.Value.Property;
                            updateQuery.Where(attribute.Key, Comparison.Equals, new SqlLiteral($"@{attribute.Key}"));
                        }
                        else
                        {
                            updateQuery.Set(attribute.Key, new SqlLiteral($"@{attribute.Key}"));
                        }
                    }

                    UpdateQuery = new PreparedNonQuery(updateQuery.BuildCommand());
                }
            }

            lock (UpdateQuery)
            {
                // Update parameters and execute the SQL Command
                UpdateQuery.SetParameters(obj, EntityTable);
                return(UpdateQuery.Execute() == 1);
            }
        }
        public static bool updateOrNewConfig(string key, string value)
        {
            MysqlDatas data = getValue(key);

            if (!data.hasRows)
            {
                InsertQueryBuilder query = new InsertQueryBuilder();
                query.Table = _table;
                query.addValue("config_key", key);
                query.addValue("config_value", value);
                query.addValue("created_at", Helper.GetDatabaseDateFormat());
                string cmd = query.BuildQuery();
                return(Utils.Mysql.execute(cmd));
            }
            else
            {
                UpdateQueryBuilder query = new UpdateQueryBuilder();
                query.Table = _table;
                query.addSet("config_value", value);
                query.AddWhere("config_key", Comparison.Equals, key);
                string cmd = query.BuildQuery();
                return(Utils.Mysql.execute(cmd));
            }
            return(false);
        }
        public void TestUpdateQueryBuilder2()
        {
            IDictionary <string, object> param = new Dictionary <string, object>();

            param.Add(@"COLUMN1", 1);
            param.Add(@"COLUMN2", @"ABC");
            string tbl = @"TableName";

            object[] whereParam = { 2, @"DEF" };
            string where = @"COLUMN3=? AND COLUMN4=?";

            string exp = @"UPDATE TableName SET COLUMN1=@__param_0,COLUMN2=@__param_1 WHERE COLUMN3=@__param_2 AND COLUMN4=@__param_3";

            UpdateQueryBuilder b = new UpdateQueryBuilder(tbl);

            b.SetParams(param);
            b.SetWhere(where, whereParam);

            using (SqlConnection conn = new SqlConnection())
                using (DbCommand result = b.Result(conn, UpdateType.UPDATE)) {
                    Assert.AreEqual(exp, result.CommandText);

                    Assert.AreEqual(1, result.Parameters[0].Value);
                    Assert.AreEqual(@"ABC", result.Parameters[1].Value);
                    Assert.AreEqual(2, result.Parameters[2].Value);
                    Assert.AreEqual(@"DEF", result.Parameters[3].Value);
                }
        }
示例#7
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("name", Name)
 .With("display_name", DisplayName)
 .With("description", Description)
 .With("icon", Icon)
 .With("description_privacy", DescriptionPrivacy)
 .With("icon_privacy", IconPrivacy)
 .With("list_privacy", ListPrivacy)
 .With("visibility", Visibility);
示例#8
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("name", Name)
 .With("description", Description)
 .With("tag", Tag)
 .With("avatar_url", AvatarUrl)
 .With("token", Token)
 .With("ui_tz", UiTz)
 .With("description_privacy", DescriptionPrivacy)
 .With("member_list_privacy", MemberListPrivacy)
 .With("front_privacy", FrontPrivacy)
 .With("front_history_privacy", FrontHistoryPrivacy)
 .With("pings_enabled", PingsEnabled);
示例#9
0
        private static void Update <T>(string connectionString, T entity, Dictionary <string, object> fieldsWithValues) where T : new()
        {
            var(condition, wheres) = KeyAttribute.GetKeysQueryWhere(entity);

            var updateBuilder = new UpdateQueryBuilder()
                                .WithFields(fieldsWithValues)
                                .WithWhere(condition, wheres.ToArray());

            var query = updateBuilder.Build <T>();

            DataBaseDataReader.ExecuteNonQuery(connectionString, query);
        }
示例#10
0
        /// <summary>
        /// Adds a server's posted snapshot into the Snapshot Processing Queue, which
        /// will process the snapshot as soon as possible. This method is Non-Blocking.
        /// </summary>
        /// <remarks>
        /// Any errors that occur during the actual import of the data will be
        /// logged inside the StatsDebug log
        /// </remarks>
        /// <param name="Data">The snapshot data provided by the server.</param>
        /// <param name="ServerAddress">The IP address of the server.</param>
        /// <exception cref="UnauthorizedAccessException">
        ///     Thrown if the Server IP is not authorized to post game data to this server
        /// </exception>
        /// <exception cref="InvalidDataException">
        ///     Thrown if the provided Snapshot data is not valid, and cannot be processed
        /// </exception>
        public static void QueueServerSnapshot(string Data, IPAddress ServerAddress)
        {
            // Make sure the server is authorized
            if (!IsAuthorizedGameServer(ServerAddress))
            {
                throw new UnauthorizedAccessException("Un-Authorised Gameserver (Ip: " + ServerAddress + ")");
            }

            // Create the Snapshot Object
            Snapshot Snap = new Snapshot(Data, ServerAddress);

            // Update this server in the Database
            using (StatsDatabase Database = new StatsDatabase())
            {
                // Try and grab the ID of this server
                int id = Database.ExecuteScalar <int>(
                    "SELECT COALESCE(id, -1), COUNT(id) FROM servers WHERE ip=@P0 AND port=@P1",
                    ServerAddress, Snap.ServerPort
                    );

                // New server?
                if (id < 0)
                {
                    InsertQueryBuilder builder = new InsertQueryBuilder(Database);
                    builder.SetTable("servers");
                    builder.SetField("ip", ServerAddress);
                    builder.SetField("port", Snap.ServerPort);
                    builder.SetField("prefix", Snap.ServerPrefix);
                    builder.SetField("name", Snap.ServerName);
                    builder.SetField("queryport", Snap.QueryPort);
                    builder.SetField("lastupdate", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
                    builder.Execute();
                }
                else // existing
                {
                    UpdateQueryBuilder builder = new UpdateQueryBuilder(Database);
                    builder.SetTable("servers");
                    builder.SetField("prefix", Snap.ServerPrefix);
                    builder.SetField("name", Snap.ServerName);
                    builder.SetField("queryport", Snap.QueryPort);
                    builder.SetField("lastupdate", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
                    builder.AddWhere("id", Comparison.Equals, id);
                    builder.Execute();
                }
            }

            // Add snapshot to Queue
            SnapshotQueue.Enqueue(Snap);
        }
        /// <summary>
        /// Updates an Account's information by ID
        /// </summary>
        /// <param name="Id">The Current Account ID</param>
        /// <param name="NewPid">New Account ID</param>
        /// <param name="NewNick">New Account Name</param>
        /// <param name="NewPassword">New Account Password, UN HASHED. Leave empty to not set a new password</param>
        /// <param name="NewEmail">New Account Email Address</param>
        public void UpdateUser(int Id, int NewPid, string NewNick, string NewPassword, string NewEmail)
        {
            UpdateQueryBuilder Query = new UpdateQueryBuilder("accounts", this);

            Query.SetField("id", NewPid);
            Query.SetField("name", NewNick);
            Query.SetField("email", NewEmail.ToLowerInvariant());
            Query.AddWhere("id", Comparison.Equals, Id);

            // Set new password if not empty
            if (!String.IsNullOrWhiteSpace(NewPassword))
            {
                Query.SetField("password", NewPassword.GetMD5Hash(false));
            }

            Query.Execute();
        }
示例#12
0
        public TriggerExecutionMessage ExecuteTrigger(TriggerExecutionPayload payload)
        {
            var updateQuery     = new UpdateQueryBuilder();
            var columnWithValue = new Dictionary <string, string>();
            var value           = payload.PayloadObj.Where(item => !string.IsNullOrEmpty(item.Value)).Aggregate(string.Empty, (current, item) => current + (item.Value + " "));

            columnWithValue.Add("[Name]", value.TrimEnd());
            updateQuery.AddTable("[dbo].[Item]", columnWithValue);
            updateQuery.AddWhere("[Id]", Comparison.Equals, payload.ConditionalValue);
            var queryRes = updateQuery.BuildQuery();
            var message  = new TriggerExecutionMessage
            {
                Message = queryRes
            };

            return(message);
        }
        public void GenerateSimpleQueryTest()
        {
            // Arrange
            const string queryExpected = "UPDATE `books` SET `Title` = 'Essential C#', `Price` = 20.99";
            var          fields        = new Dictionary <string, object>
            {
                { GetColumnNameWithQuotes <Book>(nameof(Book.Title)), "Essential C#" },
                { GetColumnNameWithQuotes <Book>(nameof(Book.Price)), 20.99d }
            };
            var updateQueryBuilder = new UpdateQueryBuilder()
                                     .WithFields(fields);

            // Act
            var query = updateQueryBuilder.Build <Book>();

            // Assert
            Assert.AreEqual(queryExpected, query);
        }
        public void TestUpdateQueryBuilder3()
        {
            string tbl = @"TableName";
            string exp = @"INSERT INTO TableName (COLUMN1,COLUMN2) VALUES (@__param_0,@__param_1)";

            UpdateQueryBuilder b    = new UpdateQueryBuilder(tbl);
            UpdatePabo         pabo = new UpdatePabo();

            b.SetParams(ObjectQuery.GetParams(pabo));

            using (SqlConnection conn = new SqlConnection())
                using (DbCommand result = b.Result(conn, UpdateType.INSERT)) {
                    Assert.AreEqual(exp, result.CommandText);

                    Assert.AreEqual(pabo.Num, result.Parameters[0].Value);
                    Assert.AreEqual(pabo.S, result.Parameters[1].Value);
                }
        }
示例#15
0
        public static bool deleteValue(int id)
        {
            DeleteQueryBuilder query = new DeleteQueryBuilder();

            query.Table = _table;
            query.AddWhere("id", Comparison.Equals, id);
            string cmd    = query.BuildQuery();
            bool   result = Utils.Mysql.execute(cmd);

            if (result)
            {
                UpdateQueryBuilder update = new UpdateQueryBuilder();
                update.Table = "users";
                update.addSet("faculty", "0");
                update.AddWhere("faculty", Comparison.Equals, id);
                cmd = update.BuildQuery();
                Utils.Mysql.execute(cmd);
            }
            return(result);
        }
        public void TestUpdateQueryBuilder1()
        {
            IDictionary <string, object> param = new Dictionary <string, object>();

            param.Add(@"COLUMN1", 1);
            param.Add(@"COLUMN2", @"ABC");
            string tbl = @"TableName";

            string exp = @"INSERT INTO TableName (COLUMN1,COLUMN2) VALUES (@__param_0,@__param_1)";

            UpdateQueryBuilder b = new UpdateQueryBuilder(tbl);

            b.SetParams(param);
            using (SqlConnection conn = new SqlConnection())
                using (DbCommand result = b.Result(conn, UpdateType.INSERT)) {
                    Assert.AreEqual(exp, result.CommandText);

                    Assert.AreEqual(1, result.Parameters[0].Value);
                    Assert.AreEqual(@"ABC", result.Parameters[1].Value);
                }
        }
示例#17
0
        public static bool blockedUser(int id)
        {
            /* Hard Delete */

            /*
             * DeleteQueryBuilder query = new DeleteQueryBuilder();
             * query.Table = _table;
             * query.AddWhere("id", Comparison.Equals, id);
             * string cmd = query.BuildQuery();
             * bool result = Mysql.execute(cmd);
             * return result;
             */

            /*Soft Delete*/
            UpdateQueryBuilder query = new UpdateQueryBuilder();

            query.Table = _table;
            query.addSet("status", "blocked");
            query.AddWhere("id", Comparison.Equals, id);
            string cmd    = query.BuildQuery();
            bool   result = Mysql.execute(cmd);

            return(result);
        }
示例#18
0
        private string BuildInsertQueryV1(Guid itemId, string entityName, List <GroupedColumns> matchingColumns)
        {
            //create lower tables...
            Dictionary <string, string> executedTables = new Dictionary <string, string>();
            var query = "";
            var tablesWhoHasForeignKeyReference = matchingColumns.Where(t => t.NeedToUpdateColumn != null).ToList();

            if (tablesWhoHasForeignKeyReference.Any())
            {
                foreach (var table in tablesWhoHasForeignKeyReference)
                {
                    query += GetQueryStr(table);
                    StoreExecutedTables(executedTables, table);
                }
            }

            //create item table..
            var itemTable = matchingColumns.FirstOrDefault(t => t.EntityFullName.ToLower().Equals(ItemHelper.ItemClassName.ToLower()));

            if (itemTable != null)
            {
                query += GetQueryStr(itemTable);
                StoreExecutedTables(executedTables, itemTable);
            }

            //create other tables..
            foreach (var item in matchingColumns)
            {
                var clientName = (string.IsNullOrEmpty(item.ClientName)) ? item.EntityFullName : item.ClientName;
                var isExecuted = executedTables.Where(t => t.Key.Equals(clientName)).ToList();
                if (isExecuted.Any())
                {
                    continue;
                }
                query += GetQueryStr(item);
            }

            // add relateions
            foreach (var table in tablesWhoHasForeignKeyReference)
            {
                if (table.NeedToUpdateColumn == null)
                {
                    continue;
                }
                var columnWithValue            = new Dictionary <string, string>();
                UpdateQueryBuilder updateQuery = new UpdateQueryBuilder();
                columnWithValue.Add(table.NeedToUpdateColumn.ColumnName, table.Id.ToString());
                updateQuery.AddTable(table.NeedToUpdateColumn.TableName, columnWithValue);
                var targetRow = matchingColumns.FirstOrDefault(t => t.EntityFullName.ToLower().Equals(table.NeedToUpdateColumn.EntityFullName.ToLower()));
                if (targetRow == null)
                {
                    continue;
                }
                updateQuery.AddWhere(table.NeedToUpdateColumn.PrimaryKey, Comparison.Equals, targetRow.Id.ToString(), 1);
                query += updateQuery.BuildQuery();
            }

            IMetadataManager iMetadataManager = new MetadataManager.Contracts.MetadataManager();
            var triggers = iMetadataManager.GetTriggerProperties(entityName);

            if (triggers.Any())
            {
                var singletonTrigger = triggers[0];
                var bodyProp         = singletonTrigger.GetBody();
                var search           = matchingColumns.FirstOrDefault(t => t.EntityFullName.ToLower().Equals(entityName.ToLower()));
                if (search == null)
                {
                    return(TransactionHelper.BuildQuery(query));
                }
                {
                    var payload = bodyProp.Select(item => search.Columns.FirstOrDefault(t => t.FieldName.ToLower().Equals(item.ToLower()))).Where(matching => matching != null).ToDictionary <ColumnAndField, string, string>(matching => matching.ColumnName, matching => matching.Value);
                    if (!payload.Any())
                    {
                        return(TransactionHelper.BuildQuery(query));
                    }
                    var triggerEngine           = new TriggerEngine();
                    var triggerExecutionPayload = new TriggerExecutionPayload
                    {
                        PayloadObj       = payload,
                        ConditionalValue = itemId.ToString()
                    };
                    var triggerQuery = triggerEngine.GetQuery(triggers, triggerExecutionPayload);
                    if (!string.IsNullOrEmpty(triggerQuery))
                    {
                        query += triggerQuery;
                    }
                }
            }
            //------------
            return(TransactionHelper.BuildQuery(query));
        }
示例#19
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("display_name", DisplayName)
 .With("avatar_url", AvatarUrl);
示例#20
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("log_channel", LogChannel)
 .With("log_blacklist", LogBlacklist)
 .With("blacklist", Blacklist)
 .With("log_cleanup_enabled", LogCleanupEnabled);
示例#21
0
 public static UpdateQueryBuilder Table(this UpdateQueryBuilder @this, string tableName)
 {
     @this.Tables.Clear();
     @this.Tables.Add(new Table(tableName));
     return(@this);
 }
        /// <summary>
        /// Save Button Click Event
        /// </summary>
        private void SaveBtn_Click(object sender, EventArgs e)
        {
            try
            {
                using (StatsDatabase Driver = new StatsDatabase())
                {
                    bool Changes             = false;
                    UpdateQueryBuilder Query = new UpdateQueryBuilder("player", Driver);
                    int Rank = Int32.Parse(Player["rank"].ToString());

                    // Update clantag
                    if (Player["clantag"].ToString() != ClanTagBox.Text.Trim())
                    {
                        Player["clantag"] = ClanTagBox.Text.Trim();
                        Query.SetField("clantag", ClanTagBox.Text.Trim());
                        Changes = true;
                    }

                    // Update Rank
                    if (Rank != RankSelect.SelectedIndex)
                    {
                        if (Rank > RankSelect.SelectedIndex)
                        {
                            Query.SetField("decr", 1);
                            Query.SetField("chng", 0);
                        }
                        else
                        {
                            Query.SetField("decr", 0);
                            Query.SetField("chng", 1);
                        }

                        Player["rank"] = RankSelect.SelectedIndex;
                        Query.SetField("rank", RankSelect.SelectedIndex);
                        Changes = true;
                    }

                    // update perm ban status
                    if (Int32.Parse(Player["permban"].ToString()) != PermBanSelect.SelectedIndex)
                    {
                        Player["permban"] = PermBanSelect.SelectedIndex;
                        Query.SetField("permban", PermBanSelect.SelectedIndex);
                        Changes = true;
                    }

                    // If no changes made, just return
                    if (!Changes)
                    {
                        MessageBox.Show("Unable to save player because no changes were made.",
                                        "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        return;
                    }

                    // Preform Query
                    Query.AddWhere("id", Comparison.Equals, Pid);
                    Query.Execute();
                    this.Close();
                }
            }
            catch (DbConnectException Ex)
            {
                HttpServer.Stop();
                ExceptionForm.ShowDbConnectError(Ex);
                return;
            }
        }
示例#23
0
        public void Run()
        {
            var _distinctdata = _alldata.SelectMany(e => e.BaseObject.Select(w => w.Key)).Distinct().ToList();

            var AllValidfields = _tableInfo.ColumnInfos.Select(e => e.ColumnName).Intersect(_distinctdata);

            var ValidKeys = _tableInfo.ColumnInfos.Where(q => q.IsKey).Select(e => e.ColumnName).Intersect(_distinctdata).ToList();

            if (ValidKeys.Count != _tableInfo.ColumnInfos.Where(e => e.IsKey).Select(e => e.ColumnName).Distinct().Count())
            {
                Console.WriteLine($"Key missed -Type {_tableName} ");
                throw new Exception();
            }

            querybulder = new UpdateQueryBuilder(_tableName);

            List <SqlParameter> _paramsSql = new List <SqlParameter>();

            int _index = 0;

            foreach (var item in _alldata)
            {
                List <string> stringParamForQuery = new List <string>();

                List <string> stringKeyParam = new List <string>();

                var data = item.ChangedProperties.Intersect(AllValidfields);

                if (data.Count() > 0)
                {
                    foreach (var obj in data)
                    {
                        string param = $"@p{_index++}";

                        stringParamForQuery.Add(param);

                        var dbpar = new SqlParameter(param, shcema[_tableName][obj]);

                        if (item.BaseObject.ContainsKey(obj))
                        {
                            dbpar.Value = QueryBuilderHelper.FormatSQLForDb(_tableName, obj, item.BaseObject[obj]);
                        }
                        else
                        {
                            dbpar.Value = DBNull.Value;
                        }

                        _paramsSql.Add(dbpar);
                    }

                    foreach (var singleKey in ValidKeys)
                    {
                        string param = $"@p{_index++}";
                        var    dbpar = new SqlParameter(param, shcema[_tableName][singleKey]);

                        stringKeyParam.Add(param);
                        dbpar.Value = QueryBuilderHelper.FormatSQLForDb(_tableName, singleKey, item.BaseObject[singleKey]);
                        _paramsSql.Add(dbpar);
                    }

                    querybulder.AppendCommand(data.ToList(), stringParamForQuery, ValidKeys, stringKeyParam);

                    if (_paramsSql.Count > UpdateCommandParametersCount)
                    {
                        Execute(_paramsSql);
                        _paramsSql = new List <SqlParameter>();
                        _index     = 0;
                        querybulder.Reset();
                        stringParamForQuery = new List <string>();
                        stringKeyParam      = new List <string>();
                    }
                }
            }

            if (_paramsSql.Count > 0)
            {
                Execute(_paramsSql);
                _paramsSql = new List <SqlParameter>();
                _index     = 0;
            }
        }
示例#24
0
        //public static UpdateQueryBuilder Set(this UpdateQueryBuilder @this, Func<FieldBuilder, FieldSet> field)
        //{
        //    var f = field.Invoke(FieldBuilder.Current);
        //    return @this.Set(f);
        //}

        //public static UpdateQueryBuilder Set(this UpdateQueryBuilder @this, Func<FieldBuilder, FieldSet[]> fields)
        //{
        //    var fs = fields.Invoke(FieldBuilder.Current);
        //    return @this.Set(fs);
        //}

        public static FieldSet <UpdateQueryBuilder> Set(this UpdateQueryBuilder @this, string fieldName)
        => new FieldSet <UpdateQueryBuilder>(@this, fieldName);
示例#25
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("allow_autoproxy", AllowAutoproxy);
示例#26
0
        public void PersistSessionObject(IDbConnectionAbstraction connectionAbstraction)
        {
            Dictionary<string, object>.Enumerator parameters = _parameters.GetEnumerator();

            using (SqlCommand command = new SqlCommand())
            {
                IQueryBuilder queryBuilder = null;

                if (IsNew)
                {
                    queryBuilder = new InsertQueryBuilder();
                }
                else if (IsDirty)
                {
                    queryBuilder = new UpdateQueryBuilder();
                }
                else
                {
                    return;
                }

                while (parameters.MoveNext())
                {
                    queryBuilder.AddParameter(parameters.Current.Key, parameters.Current.Value);
                }

                command.Parameters.AddRange(queryBuilder.GenerateSqlParameters());
                command.Connection = connectionAbstraction.Connection;
                command.CommandText = queryBuilder.GenerateSqlQuery();

                connectionAbstraction.Open();
                TransactionId = long.Parse(command.ExecuteScalar().ToString());
                connectionAbstraction.Close();
            }
        }
示例#27
0
 public abstract UpdateQueryBuilder Apply(UpdateQueryBuilder b);
示例#28
0
 public override UpdateQueryBuilder Apply(UpdateQueryBuilder b) => b
 .With("proxy_enabled", ProxyEnabled)
 .With("autoproxy_mode", AutoproxyMode)
 .With("autoproxy_member", AutoproxyMember);