private static void CheckIfAuditTableExists(Type auditRecordType, DatabaseType  databaseType)
        {
            var classConfig = ClassConfigContainer.FindClassConfig(auditRecordType);

            var table = classConfig.TableName;

            var sql = string.Empty;

            if (databaseType != DatabaseType.Oracle)
            {
                sql = string.Format("SELECT COUNT(*) " +
                                    "FROM INFORMATION_SCHEMA.TABLES " +
                                    "WHERE TABLE_SCHEMA = '[Schema]'   AND  TABLE_NAME = '{0}'  OR   TABLE_NAME = '{1}' ",
                                    table.ToLower(), table);

            }
            else
            {
                sql = string.Format("SELECT COUNT(*) FROM  ALL_TABLES  WHERE OWNER ='[Schema]'  AND TABLE_NAME ='{0}'",
                                    table);
            }
         
        
            var database = DatabaseCreator.CreateDatabase();

            var result = database.ExecuteScalar(sql);

            if (result.ToString() == "0")
            {
                throw new EasylinkException("Audit table {0} does not exist in the database.", table);
            }

        }

 private void AddCeDatabase(DatabaseType dbType)
 {
     try
     {
         var dialog = new ConnectionDialog();
         string path;
         if (TryGetInitialPath(package, out path))
         {
             dialog.InitialPath = path;                
         }
         dialog.DbType = dbType;
         dialog.ShowDDEXInfo = package.VSSupportsSimpleDDEX4Provider() || package.VSSupportsSimpleDDEX35Provider();
         dialog.CouldSupportPrivateProvider =
             (dbType == DatabaseType.SQLCE40 && (SqlCeToolboxPackage.VisualStudioVersion == new Version(12, 0) || SqlCeToolboxPackage.VisualStudioVersion == new Version(14, 0)) )
             || (dbType == DatabaseType.SQLCE35 && package.VSSupportsEF6());
         bool? result = dialog.ShowModal();
         if (result.HasValue && result.Value == true)
         {
             if (!string.IsNullOrWhiteSpace(dialog.ConnectionString))
             {
                 Helpers.DataConnectionHelper.SaveDataConnection(dialog.ConnectionString, dbType, package);
                 ExplorerControl control = _parentWindow.Content as ExplorerControl;
                 control.BuildDatabaseTree();
                 Helpers.DataConnectionHelper.LogUsage("DatabasesAddCeDatabase");
             }
         }
     }
     catch (Exception ex)
     {
         Helpers.DataConnectionHelper.SendError(ex, dbType);
     }
 }

        public static void UpgradeDatabase(DbConnection connection, DatabaseType databaseType)
        {
            // Figure out the current version of the schema
            int currentVersion;
            using (DbCommand cmd = connection.CreateCommand())
            {
                cmd.CommandText = "SELECT val FROM setup WHERE `key`='schemaVersion';";
                using (DbDataReader reader = cmd.ExecuteReader())
                {
                    if (!reader.Read())
                        currentVersion = 1;
                    else
                        currentVersion = int.Parse(reader.GetString(reader.GetOrdinal("val")));
                }
            }

            // Now get the set of migrations we have avaiable
            List<int> migrationVersions = GetMigrationVersions(databaseType);
            foreach (int migration in migrationVersions)
            {
                if (currentVersion < migration)
                {
                    PerformMigration(connection, databaseType, migration);
                }
            }
        }

 public EntityAttribue(string _TableName, string _ConectionName, DatabaseType _DbType, bool _EnableCache)
 {
     this.TableName = _TableName;
     this.ConectionName = _ConectionName;
     this.DbType = _DbType;
     this.EnableCache = _EnableCache;
 }

 public DirectionBinaryObject(XDirection direction, DatabaseType databaseType)
 {
     DatabaseType = databaseType;
     ObjectType = ObjectType.Direction;
     Direction = direction;
     Build();
 }

 public void AddPutBit(XStateType stateType, XBinaryBase binaryBase, DatabaseType databaseType)
 {
     Add(FormulaOperationType.PUTBIT,
         (byte)stateType,
         binaryBase.GetDatabaseNo(databaseType),
         "Запись состояния " + stateType.ToDescription() + " " + XBinaryBaseToString(binaryBase));
 }

 public ZoneBinaryObject(XZone zone, DatabaseType databaseType)
 {
     DatabaseType = databaseType;
     ObjectType = ObjectType.Zone;
     Zone = zone;
     Build();
 }

 public ConnectionInformation(string tableName, string connKey, string[] pirmaryKeys,DatabaseType dbType)
 {
     this.TableName = tableName;
     this.ConnectionKey = connKey;
     this.PrimaryKeys = pirmaryKeys;
     this.DbType = dbType;
 }

        public static DataTable DataTableUNION(DatabaseType dbT, string cs, params string[] fieldTableUNION)
        {
            string req = "";
            for (int i = 0; i < fieldTableUNION.Length - 2; i += 2)
            {
                req += "SELECT DISTINCT " + fieldTableUNION[i] + " FROM " + fieldTableUNION[i + 1] + " UNION ";
            }
            req += "SELECT DISTINCT " + fieldTableUNION[fieldTableUNION.Length - 2] + " FROM " + fieldTableUNION[fieldTableUNION.Length - 1];

            DataTable t = new DataTable();

            switch (dbT)
            {
                case DatabaseType.OleDb:
                    using (OleDbConnection c = Connection(dbT, cs) as OleDbConnection)
                    {
                        using (OleDbDataAdapter a = new OleDbDataAdapter(req, c))
                        {
                            a.Fill(t);
                        }
                    }
                    break;
                default:
                    break;
            }
            return t;
        }

 public DataTypeInstanceAttribute(string propertyEditorAlias = null, string name = null, Type converterType = null, DatabaseType dbType = DatabaseType.None)
 {
     Name = name;
     PropertyEditorAlias = propertyEditorAlias;
     ConverterType = converterType;
     DbType = dbType;
 }

        public static DbTypeProvider Create(DatabaseType databaseType)
        {
            if (databaseType == DatabaseType.Postgres)
                return new PostgresDbTypeProvider();

            return null;
        }

        public static IDbCommand CreateCommand(string CommandText, DatabaseType dbtype,
            IDbConnection cnn)
        {
            IDbCommand cmd;
            switch (dbtype)
            {
                case DatabaseType.Access:
                    cmd = new OleDbCommand
                       (CommandText,
                       (OleDbConnection)cnn);
                    break;

                case DatabaseType.SQLServer:
                    cmd = new SqlCommand
                       (CommandText,
                       (SqlConnection)cnn);
                    break;

                default:
                    cmd = new SqlCommand
                       (CommandText,
                       (SqlConnection)cnn);
                    break;
            }

            return cmd;
        }

        /// <summary>
        /// 获取数据库帮助对象。
        /// </summary>
        /// <param name="database">数据库类型</param>
        /// <param name="host">数据库主机</param>
        /// <param name="instance">数据库实例</param>
        /// <param name="account">账号</param>
        /// <param name="password">密码</param>
        /// <param name="port">端口号</param>
        /// <returns>数据库帮助对象</returns>
        public static DbHelper Create(
            DatabaseType database,
            string host,
            string instance,
            string account,
            string password,
            int? port = null)
        {
            var connectionString = GetConnectionString(database, host, instance, account, password, port);
            var dbHelper = new DbHelper(Providers[(int)database], connectionString);

            switch (database)
            {
                case DatabaseType.MSSQL:
                    dbHelper.DbMetadata = new MSSQLMetadata();

                    break;
                case DatabaseType.Oracle:
                    dbHelper.DbMetadata = new OracleMetadata();

                    break;
            }

            return dbHelper;
        }

 public DatabaseQueryTransformRule(string connectionString, DatabaseType dbType, string query, DicomTag[] outputTags, DicomTag[] paramTags) {
     _connectionString = connectionString;
     _dbType = dbType;
     _query = query;
     _output = new List<DicomTag>(outputTags);
     _params = new List<DicomTag>(paramTags);
 }

 public static DataTable DataTable(DatabaseType dbT, string cs, string req, params object[] paramaters)
 {
     DataTable t = new DataTable();
     switch (dbT)
     {
         case DatabaseType.OleDb:
             using (OleDbConnection c = Connection(dbT, cs) as OleDbConnection)
             {
                 using (OleDbDataAdapter a = new OleDbDataAdapter(req, c))
                 {
                     for (int i = 0; i < paramaters.Length; i += 2)
                     {
                         if (req.Contains("@" + paramaters[i] as string))
                         {
                             a.SelectCommand.Parameters.AddWithValue("@" + paramaters[i] as string, paramaters[i + 1]);
                         }
                     }
                     a.Fill(t);
                 }
             }
             break;
         default:
             break;
     }
     return t;
 }

 public static void CBFromDb(DatabaseType dbT, string cs, ComboBox cb, string value, string text, string req)
 {
     cb.DataSource = null;
     cb.ValueMember = value;
     cb.DisplayMember = text;
     cb.DataSource = UtlDb.DataTable(dbT, cs, req);
 }

 private void initDatabaseType()
 {
     if (this.radioButton_sqlserver2000.Checked)
     {
         this.DatabaseType = DatabaseType.SqlServer2000;
     }
     else if (this.radioButton_sqlserver2005.Checked)
     {
         this.DatabaseType = DatabaseType.SqlServer2005;
     }
     else if (this.radioButton_sqlserver2008.Checked)
     {
         this.DatabaseType = DatabaseType.SqlServer2008;
     }
     else if (this.radioButton_access.Checked)
     {
         this.DatabaseType = DatabaseType.Access;
     }
     else if (this.radioButton_mysql.Checked)
     {
         this.DatabaseType = DatabaseType.MySql;
     }
     else if (this.radioButton_oracle.Checked)
     {
         this.DatabaseType = DatabaseType.Oracle;
     }
     else if (this.radioButton_sqlite.Checked)
     {
         this.DatabaseType = DatabaseType.Sqlite;
     }
 }

 public DeviceBinaryObject(XDevice device, DatabaseType databaseType)
 {
     DatabaseType = databaseType;
     ObjectType = ObjectType.Device;
     Device = device;
     Build();
 }

        private static string GetDialectNameForType(DatabaseType type)
        {
            Contract.Ensures(!string.IsNullOrEmpty(Contract.Result<string>()));

            switch (type)
            {
                case DatabaseType.MsSql2005:
                    return typeof(global::Migrator.Providers.SqlServer.SqlServer2005Dialect).FullName;
                case DatabaseType.MsSql2008:
                    return typeof(global::Migrator.Providers.SqlServer.SqlServerDialect).FullName;
                case DatabaseType.MsSqlCe:
                    return typeof(global::Migrator.Providers.SqlServer.SqlServerCeDialect).FullName;
                case DatabaseType.MySql:
                    return typeof(global::Migrator.Providers.Mysql.MysqlDialect).FullName;
                case DatabaseType.Oracle10:
                case DatabaseType.OracleData10:
                    return typeof(global::Migrator.Providers.Oracle.OracleDialect).FullName;
                case DatabaseType.PostgreSql:
                    return typeof(global::Migrator.Providers.PostgreSQL.PostgreSQLDialect).FullName;
                case DatabaseType.SQLite:
                    return typeof(global::Migrator.Providers.SQLite.SQLiteDialect).FullName;
                case DatabaseType.DB2:
                    throw new NotSupportedException("The given database type does not support migrations.");
            }

            throw new ArgumentOutOfRangeException("type");
        }

		public DeviceDescriptor(XDevice device, DatabaseType databaseType)
		{
			DatabaseType = databaseType;
			DescriptorType = DescriptorType.Device;
			Device = device;
			Build();
		}