/// <summary>
 /// 上下文初始化器（只赋值，不初始化，有可能被重复创建两次）
 /// </summary>
 /// <param name="connectionString">连接字符串</param>
 /// <param name="dbType">数据库类型</param>
 /// <param name="commandTimeout">命令超时时间</param>
 /// <param name="dataVer">数据库版本</param>
 public ContextConnection(string connectionString, DataBaseType dbType, int commandTimeout, string dataVer)
 {
     this.ConnectionString = connectionString;
     this.DbType = dbType;
     this.CommandTimeout = commandTimeout;
     this.DataVer = dataVer;
 }

 public DBHelper(ConnectionType conncetionType, DataBaseType DBMSType,string strDBFileNamePath)
 {
     DbConnectionType = conncetionType;
     dbType = DBMSType;
     S_DBFILENAME = strDBFileNamePath;
     oFactory = DbProviderFactories.GetFactory(RetreiveConnectionString());
 }

 private void PlotVarDB_Load(object sender, EventArgs e)
 {
     database = new DataBaseType();
     database.ME1 = new List<PlotVarEntry>();
     database.ME2 = new List<PlotVarEntry>();
     database.ME3 = new List<PlotVarEntry>();
 }

        public DBAccess(DataBaseType dbType,string connectionString)
        {
            this._dbType = dbType;
            this._connectionString = connectionString;

            this.dbAccess= new DataBaseAccess(this._dbType, this._connectionString);
        }

 /// <summary>
 ///     默认第一个数据库配置
 /// </summary>
 /// <param name="connectionString">数据库连接字符串</param>
 /// <param name="dbType">数据库类型</param>
 /// <param name="dataVer">数据库版本</param>
 /// <param name="commandTimeout">SQL执行超时时间</param>
 public ContextAttribute(string connectionString, DataBaseType dbType = DataBaseType.SqlServer, string dataVer = "2008", int commandTimeout = 30)
 {
     ConnStr = connectionString;
     DataType = dbType;
     DataVer = dataVer;
     CommandTimeout = commandTimeout;
 }

        public static ConnectionString GetConnectionString(string connectionString, DataBaseType type)
        {
            var values = connectionString.Split((";").ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            var eConnectionString = new ConnectionString();

            eConnectionString.String = connectionString;
            eConnectionString.Type = type;

            switch (eConnectionString.Type)
            {
                case DataBaseType.SqlServer:
                    eConnectionString.Server = values[0].Split('=')[1];
                    eConnectionString.DataSource = values[1].Split('=')[1];
                    eConnectionString.User = values[2].Split('=')[1];
                    eConnectionString.Password = values[3].Split('=')[1];
                    break;
                case DataBaseType.Oracle:
                    eConnectionString.DataSource = values[0].Split('=')[1];
                    eConnectionString.User = values[1].Split('=')[1];
                    eConnectionString.Password = values[2].Split('=')[1];
                    break;
            }

            return eConnectionString;
        }

        public string GetDatabaseCountQuery(DataBaseType dbType)
        {
            if (dbType == DataBaseType.Mssql)
            return "SELECT LTRIM(STR(COUNT(name))) FROM master..sysdatabases";

             return "SELECT COUNT(schema_name) FROM information_schema.SCHEMATA";
        }

        private ExtractObjectsArgs GetFunctionExtractObjectsArgs(DataBaseType dbType)
        {
            switch (dbType)
            {
                case DataBaseType.Oracle:
                    return new ExtractObjectsArgs(
                        Settings.Oracle.Function.Default.Regex,
                        _inputText,
                        Settings.Oracle.Function.Default.DropEnding,
                        Settings.Oracle.Function.Default.DropReplace,
                        Settings.Oracle.Function.Default.CreateEnding,
                        Settings.Oracle.Function.Default.CreateSearch,
                        Settings.Oracle.Function.Default.CreateReplace,
                        _functions,
                        delegate(string str) { return str.Equals("\r\nBEGIN\r\nRETURN NULL;\r\n"); });

                case DataBaseType.SQLServer:
                    return new ExtractObjectsArgs(
                        Settings.SQLServer.Function.Default.Regex,
                        _inputText,
                        Settings.SQLServer.Function.Default.DropEnding,
                        Settings.SQLServer.Function.Default.DropReplace,
                        Settings.SQLServer.Function.Default.CreateEnding,
                        Settings.SQLServer.Function.Default.CreateSearch,
                        Settings.SQLServer.Function.Default.CreateReplace,
                        _functions,
                        delegate(string str) { return str.Equals(" begin\r\nreturn NULL\r\n"); });

                default:
                    throw new NotSupportedException(
                        String.Format("{0} is not a valid DataBase Type!",
                        (DataBaseType)dbType));
            }
        }

        public bool CreateDataBase(DataBaseType nType, string nConnectionString, byte[] nRemotingPassword, out DataBase nDataBase, out string nMessage)
        {
            nMessage = "";
            nDataBase = null;

            try
            {
                if (this.ServerPassword == Crypto.RSADecryptText(nRemotingPassword, this.ServerPrivateKey))
                {
                    nDataBase = DataBaseFactory.CreateDatabase(nType, DataBaseFactory.GetInnerConnectionString(nConnectionString));

                    nDataBase._proxy = this;

                    this._DataBaseList.Add(nDataBase._token, nDataBase);

                    return true;
                }
                else
                {
                    throw new Exception("La contraseña de acceso al servidor remoting no es válida");
                }
            }
            catch (Exception ex)
            {
                nMessage = ex.Message;
            }

            return false;
        }

        public string GetDatarowsCount(string databaseName, string tableName, DataBaseType dbType)
        {
            if (dbType == DataBaseType.Mssql)
            return "SELECT LTRIM(STR(COUNT(*))) FROM " + databaseName + ".." + tableName + "";

             return "SELECT COUNT(*) FROM " + databaseName + "." + tableName;
        }

        public string DbGetVersion(DataBaseType dbType)
        {
            if (dbType == DataBaseType.Mssql)
            return "@@VERSION";

             return "VERSION()";
        }

        public string DbGetUser(DataBaseType dbType)
        {
            if (dbType == DataBaseType.Mssql)
            return "SYSTEM_USER";

             return "CURRENT_USER()";
        }

        public string DbGetDatabase(DataBaseType dbType)
        {
            if (dbType == DataBaseType.Mssql)
            return "DB_NAME()";

             return "DATABASE()";
        }

 /// <summary>
 /// 返回数据库操作
 /// </summary>
 /// <param name="databaseName">数据库名称</param>
 /// <param name="dbType">数据库类型</param>
 /// <returns>返回数据库</returns>
 internal static Database GetDataBase(string databaseName,DataBaseType dbType)
 {
     if(dbType == DataBaseType.Write)
      {
          return  DatabaseFactory.GetWriteDatabase(databaseName);
      }
      return  DatabaseFactory.GetReadDatabase(databaseName);
 }

        /// <summary>
        ///     构造函数
        /// </summary>
        /// <param name="dbType">数据库类型</param>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandTimeout">数据库执行时间，单位秒</param>
        /// <param name="tranLevel">开启事务等级</param>
        public DbExecutor(string connectionString, DataBaseType dbType = DataBaseType.SqlServer, int commandTimeout = 30, IsolationLevel tranLevel = IsolationLevel.Unspecified)
        {
            _connectionString = connectionString;
            _commandTimeout = commandTimeout;
            DataType = dbType;

            OpenTran(tranLevel);
        }

        public string GetDatabaseNameQuery(DataBaseType dbType, int dbIndex)
        {
            if (dbType == DataBaseType.Mssql)
            return "SELECT TOP 1 name FROM master..sysdatabases WHERE name NOT IN (SELECT TOP " + dbIndex +
                   " name FROM master..sysdatabases ORDER BY name)";

             return "SELECT schema_name FROM information_schema.SCHEMATA LIMIT " + dbIndex + ", 1";
        }

        /// <summary>
        ///     构造函数
        /// </summary>
        /// <param name="dbType">数据库类型</param>
        /// <param name="connnection">数据库连接字符串</param>
        /// <param name="commandTimeout">数据库执行时间，单位秒</param>
        /// <param name="tranLevel">开启事务等级</param>
        public DbExecutor(DataBaseType dbType, string connnection, int commandTimeout, IsolationLevel tranLevel = IsolationLevel.Unspecified)
        {
            ConnectionString = connnection.Replace("|RootDirectory|", AppDomain.CurrentDomain.BaseDirectory, RegexOptions.IgnoreCase);
            CommandTimeout = commandTimeout;
            DataType = dbType;

            OpenTran(tranLevel);
        }

 public Request()
 {
     NaturalRequestNr = 0;
      URL = string.Empty;
      POST = string.Empty;
      HTML = string.Empty;
      DataBaseType = DataBaseType.Unknown;
      Function = string.Empty;
 }

 public InternalData()
 {
     Prepared = false;
      ParameterInjectable = false;
      InjectableCondition = string.Empty;
      InjectableBegin = string.Empty;
      InjectableEnd = string.Empty;
      DataBaseType = DataBaseType.Unknown;
      UseConditions = true;
 }

        /// <summary>
        ///     压缩数据库
        /// </summary>
        /// <param name="dataType">数据库类型</param>
        /// <param name="connetionString">连接字符串</param>
        public static void Compression(string connetionString, DataBaseType dataType = DataBaseType.SqlServer)
        {
            var db = new DbExecutor(connetionString, dataType, 30);
            switch (dataType)
            {
                case DataBaseType.SQLite: db.ExecuteNonQuery(CommandType.Text, "VACUUM", null); break;

                default: throw new NotImplementedException("该数据库不支持该方法！");
            }
        }