/// <summary>
        /// ����һ������
        /// </summary>
        public int Add(Model.contents.article_attribute_field model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("insert into " + databaseprefix + "article_attribute_field(");
            strSql.Append("name,title,control_type,data_type,data_length,data_place,item_option,default_value,is_required,is_password,is_html,editor_type,valid_tip_msg,valid_error_msg,valid_pattern,sort_id,is_sys)");
            strSql.Append(" values (");
            strSql.Append("@name,@title,@control_type,@data_type,@data_length,@data_place,@item_option,@default_value,@is_required,@is_password,@is_html,@editor_type,@valid_tip_msg,@valid_error_msg,@valid_pattern,@sort_id,@is_sys)");
            strSql.Append(";set @ReturnValue= @@IDENTITY");
            SqlParameter[] parameters = {
                    new SqlParameter("@name", SqlDbType.NVarChar,100),
                    new SqlParameter("@title", SqlDbType.NVarChar,100),
                    new SqlParameter("@control_type", SqlDbType.NVarChar,50),
                    new SqlParameter("@data_type", SqlDbType.NVarChar,50),
                    new SqlParameter("@data_length", SqlDbType.Int,4),
                    new SqlParameter("@data_place", SqlDbType.TinyInt,1),
                    new SqlParameter("@item_option", SqlDbType.NText),
                    new SqlParameter("@default_value", SqlDbType.NText),
                    new SqlParameter("@is_required", SqlDbType.TinyInt,1),
                    new SqlParameter("@is_password", SqlDbType.TinyInt,1),
                    new SqlParameter("@is_html", SqlDbType.TinyInt,1),
                    new SqlParameter("@editor_type", SqlDbType.TinyInt,1),
                    new SqlParameter("@valid_tip_msg", SqlDbType.NVarChar,255),
                    new SqlParameter("@valid_error_msg", SqlDbType.NVarChar,255),
                    new SqlParameter("@valid_pattern", SqlDbType.NVarChar,500),
                    new SqlParameter("@sort_id", SqlDbType.Int,4),
                    new SqlParameter("@is_sys", SqlDbType.TinyInt,1),
                    new SqlParameter("@ReturnValue",SqlDbType.Int)};
            parameters[0].Value = model.name;
            parameters[1].Value = model.title;
            parameters[2].Value = model.control_type;
            parameters[3].Value = model.data_type;
            parameters[4].Value = model.data_length;
            parameters[5].Value = model.data_place;
            parameters[6].Value = model.item_option;
            parameters[7].Value = model.default_value;
            parameters[8].Value = model.is_required;
            parameters[9].Value = model.is_password;
            parameters[10].Value = model.is_html;
            parameters[11].Value = model.editor_type;
            parameters[12].Value = model.valid_tip_msg;
            parameters[13].Value = model.valid_error_msg;
            parameters[14].Value = model.valid_pattern;
            parameters[15].Value = model.sort_id;
            parameters[16].Value = model.is_sys;
            parameters[17].Direction = ParameterDirection.Output;

            List<CommandInfo> sqllist = new List<CommandInfo>();
            CommandInfo cmd = new CommandInfo(strSql.ToString(), parameters);
            sqllist.Add(cmd);

            //������չ�ֶα���һ��
            StringBuilder strSql2 = new StringBuilder();
            strSql2.Append("alter table " + databaseprefix + "article_attribute_value add " + model.name + " " + model.data_type);
            SqlParameter[] parameters2 = { };
            cmd = new CommandInfo(strSql2.ToString(), parameters2);
            sqllist.Add(cmd);

            DbHelperSQL.ExecuteSqlTranWithIndentity(sqllist);
            return (int)parameters[17].Value;
        }

        public CommandResult Process(CommandInfo info, Repository repository)
        {
            info.CheckArity(0);
            string key = info.Key;

            return new CommandResult(repository.GetValue(key));
        }

		/// <summary>
		/// Implements the <see cref="IInterceptCommand"/> method for O/R mapper command logging.
		/// </summary>
		/// <param name="transactionId">The transaction ID.</param>
		/// <param name="entityType">The entity type.</param>
		/// <param name="commandInfo">The command info.</param>
		/// <param name="dbCommand">The database command parameters.</param>
		public void InterceptCommand(Guid transactionId, Type entityType, CommandInfo commandInfo, IDbCommand dbCommand)
		{
			if (LogProvider.Logger.IsDebugEnabled)
			{
				LogProvider.Logger.Debug(ParseCommand(commandInfo, dbCommand));
			}
		}

		/// <summary>
		/// Parses the command information provided on construction
		/// to a human-readable format.
		/// </summary>
		/// <returns></returns>
		public static string ParseCommand(CommandInfo commandInfo, IDbCommand dbCommand)
		{
			StringBuilder message = new StringBuilder();
			message.Append(commandInfo.ToString());

			if (dbCommand != null)
			{
				message.Append(": ").Append(dbCommand.CommandText.TrimEnd(lineEnds));

				for (int index = 0; index < dbCommand.Parameters.Count; index++)
				{
					IDbDataParameter parameter = dbCommand.Parameters[index] as IDbDataParameter;
					if (parameter != null)
					{
						message.Append(parameter.ParameterName).Append(" = ").Append(parameter.Value).Append(", ");
					}
				}

				if (dbCommand.Parameters.Count > 0)
				{
					message.Length -= 2;
				}
			}

			return message.ToString();
		}

 /// <summary>
 /// Add a new element to the HashTable.
 /// </summary>
 /// <param name="commandInfo"><see cref="CommandInfo"/> to be added.</param>
 private void add(CommandInfo commandInfo)
 {
     int index = hashFunction(commandName: commandInfo.getName());
     if (array[index] != null) {
         index = collisionHandler(index: index);
     }
     array[index] = commandInfo;
 }

        public void AsyncCommand(string cmd,string parameter)
        {
            var commandInfo = new CommandInfo { Command = cmd, Parameter = parameter};

            var bw = new BackgroundWorker();
            bw.DoWork += AsyncCommandWorker;
            bw.RunWorkerAsync(commandInfo);
        }

        public void CreateCommandWithoutParameters()
        {
            CommandInfo info = new CommandInfo("get", "users:1:name", null);

            Assert.AreEqual("get", info.Verb);
            Assert.AreEqual("users:1:name", info.Key);
            Assert.IsNull(info.Parameters);
        }

      public void TestRefreshState()
      {
         var attacher = new Mock<IAttacher>();
         CommandInfo ci = new CommandInfo();
         ci.AttachTo(attacher.Object);

         ci.RefreshState();
         attacher.Verify(a => a.RefreshState(), Times.Once());
      }

        public CommandResult Process(CommandInfo info, Repository repository)
        {
            info.CheckArity(1);
            string key = info.Key;
            object value = info.Parameters[0];

            repository.SetValue(key, value);
            return ok;
        }

        public void CreateCommandWithParameters()
        {
            CommandInfo info = new CommandInfo("set", "users:1:id", new object[] { 1ul });

            Assert.AreEqual("set", info.Verb);
            Assert.AreEqual("users:1:id", info.Key);
            Assert.IsNotNull(info.Parameters);
            Assert.AreEqual(1, info.Parameters.Count);
            Assert.AreEqual(1ul, info.Parameters[0]);
        }

        //PROTOBUF
        private CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command, ClientManager clientManager)
        {
            CommandInfo cmdInfo = new CommandInfo();

            Alachisoft.NCache.Common.Protobuf.ClearCommand clearCommand= command.clearCommand;
            cmdInfo.FlagMap = new BitSet((byte)clearCommand.flag);
            cmdInfo.RequestId = clearCommand.requestId.ToString();

            return cmdInfo;
        }

        //PROTOBUF
        private CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command, ClientManager clientManager)
        {
            CommandInfo cmdInfo = new CommandInfo();

            Alachisoft.NCache.Common.Protobuf.CountCommand countCommand = command.countCommand;

            cmdInfo.RequestId = countCommand.requestId.ToString();

            return cmdInfo;
        }

 /// <summary>
 ///   Add a command to those which can be invoked from the console.
 /// </summary>
 /// <param name = "command">The string that will make the command execute</param>
 /// <param name = "commandHelp">The message that will show the user how to use the command</param>
 /// <param name = "info">Any information about how the command works or what it does</param>
 /// <param name = "fn"></param>
 public void AddCommand(string command, string commandHelp, string infomessage, CommandDelegate fn)
 {
     CommandInfo info = new CommandInfo{
         command = command,
         commandHelp = commandHelp,
         info = infomessage,
         fn = new List<CommandDelegate> {fn}
     };
     tree.AddCommand(info);
 }

        //PROTOBUF
        private CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command, ClientManager clientManager)
        {
            CommandInfo cmdInfo = new CommandInfo();

            Alachisoft.NCache.Common.Protobuf.GetRunningServersCommand getRunningServerCommand = command.getRunningServersCommand;

            cmdInfo.CacheId = getRunningServerCommand.cacheId;
            cmdInfo.IsDotNetClient = getRunningServerCommand.isDotnetClient;
            cmdInfo.RequestId = getRunningServerCommand.requestId.ToString();
            return cmdInfo;
        }

      public void TestExecuteWhenCanExecuteIsFalse()
      {
         Mock<ICommand> testCommand = new Mock<ICommand>();
         testCommand.Setup(c => c.CanExecute()).Returns(false);

         CommandInfo ci = new CommandInfo();
         ci.Executor(testCommand.Object);
         ci.Execute();

         testCommand.Verify(c => c.Execute(), Times.Never());
      }

      public void TestExecute()
      {
         Mock<ICommand> testCommand = new Mock<ICommand>();
         testCommand.Setup(c => c.CanExecute()).Returns(true);

         CommandInfo ci = new CommandInfo();
         ci.Executor(testCommand.Object);
         ci.Execute();

         testCommand.Verify(c => c.Execute(), Times.Once());
      }

        private CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command)
        {
            CommandInfo cmdInfo = new CommandInfo();

            Alachisoft.NCache.Common.Protobuf.AddAttributeCommand addAttributeCommand = command.addAttributeCommand;
            cmdInfo.ExpHint = Alachisoft.NCache.Caching.Util.ProtobufHelper.GetExpirationHintObj(addAttributeCommand.absExpiration, 0, serializationContext);
            cmdInfo.Key = addAttributeCommand.key;
            cmdInfo.RequestId = addAttributeCommand.requestId.ToString();

            return cmdInfo;
        }

 //PROTOBUF
 private CommandInfo ParseCommand(Alachisoft.NCache.Common.Protobuf.Command command, ClientManager clientManager)
 {
     CommandInfo cmdInfo = new CommandInfo();
     //HACK:notifMask
     Alachisoft.NCache.Common.Protobuf.RegisterNotifCommand registerNotifCommand = command.registerNotifCommand;
     cmdInfo.RegNotifs = registerNotifCommand.notifMask;
     cmdInfo.RequestId = registerNotifCommand.requestId.ToString();
     cmdInfo.datafilter = registerNotifCommand.datafilter;
     cmdInfo.sequence = registerNotifCommand.sequence;
     return cmdInfo;
 }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public int Add(Model.users.user_amount_log model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("insert into " + databaseprefix + "user_amount_log(");
            strSql.Append("user_id,user_name,type,order_no,trade_no,payment_id,value,remark,status,add_time,complete_time)");
            strSql.Append(" values (");
            strSql.Append("@user_id,@user_name,@type,@order_no,@trade_no,@payment_id,@value,@remark,@status,@add_time,@complete_time)");
            strSql.Append(";set @ReturnValue= @@IDENTITY");
            SqlParameter[] parameters = {
                    new SqlParameter("@user_id", SqlDbType.Int,4),
                    new SqlParameter("@user_name", SqlDbType.NVarChar,100),
                    new SqlParameter("@type", SqlDbType.NVarChar,50),
                    new SqlParameter("@order_no", SqlDbType.NVarChar,100),
                    new SqlParameter("@trade_no", SqlDbType.NVarChar,100),
                    new SqlParameter("@payment_id", SqlDbType.Int,4),
                    new SqlParameter("@value", SqlDbType.Decimal,5),
                    new SqlParameter("@remark", SqlDbType.NVarChar,500),
                    new SqlParameter("@status", SqlDbType.TinyInt,1),
                    new SqlParameter("@add_time", SqlDbType.DateTime),
                    new SqlParameter("@complete_time", SqlDbType.DateTime),
                    new SqlParameter("@ReturnValue",SqlDbType.Int)};
            parameters[0].Value = model.user_id;
            parameters[1].Value = model.user_name;
            parameters[2].Value = model.type;
            parameters[3].Value = model.order_no;
            parameters[4].Value = model.trade_no;
            parameters[5].Value = model.payment_id;
            parameters[6].Value = model.value;
            parameters[7].Value = model.remark;
            parameters[8].Value = model.status;
            parameters[9].Value = model.add_time;
            parameters[10].Value = model.complete_time;
            parameters[11].Direction = ParameterDirection.Output;

            List<CommandInfo> sqllist = new List<CommandInfo>();
            CommandInfo cmd = new CommandInfo(strSql.ToString(), parameters);
            sqllist.Add(cmd);

            if (model.status > 0)
            {
                StringBuilder strSql2 = new StringBuilder();
                strSql2.Append("update " + databaseprefix + "users set amount=amount+" + model.value);
                strSql2.Append(" where [email protected]");
                SqlParameter[] parameters2 = {
                    new SqlParameter("@id", SqlDbType.Int,4)};
                parameters2[0].Value = model.user_id;
                cmd = new CommandInfo(strSql2.ToString(), parameters2);
                sqllist.Add(cmd);
            }

            DbHelperSQL.ExecuteSqlTranWithIndentity(sqllist);
            return (int)parameters[11].Value;
        }

		public void InterceptCommand(Guid transactionId, Type entityType, CommandInfo commandInfo, IDbCommand dbCommand) {
			string message = transactionId.ToString() + " - " + commandInfo.ToString();
			if (dbCommand != null) {
				message += ": " + dbCommand.CommandText;
				for (int index = 0; index < dbCommand.Parameters.Count; index++) {
					if (index == 0) message += "\r\n  ";
					IDbDataParameter parameter = dbCommand.Parameters[index] as IDbDataParameter;
					message += parameter.ParameterName + " = " + parameter.Value + ", ";
				}
			}
			this.log.Info(message);
		}