/// <summary>
        /// Instantiate a Table by directly deserializing byte data from the given Deserializer.
        /// </summary>
        /// <param name="input">The Deserializer providing the data for the table.</param>
        internal TableBase(Deserializer input)
        {
            // Total byte length of the table data (ignored).
            int tableLength = input.ReadInt32();

            // Total byte length of the Table metadata.
            int tableMetadataLength = input.ReadInt32();

            // Status code (custom user-set value).
            this.Status = input.ReadSByte();
            // Column Count.
            this.ColumnCount = input.ReadInt16();

            // Initialize column-driven data store.
            ColumnType = new DBType[this.ColumnCount];
            Column = new object[this.ColumnCount];

            // Read column data types.
            for (short c = 0; c < this.ColumnCount; c++)
                ColumnType[c] = (DBType)input.ReadSByte();

            // Read column names.
            this.ColumnNameData = input.ReadRaw(tableMetadataLength - 3 - this.ColumnCount);

            // Row count.
            this.RowCount = input.ReadInt32();
        }

        public WebConfigImpl(FileInfo fileInfo)
        {
            Debug.Assert(null != fileInfo);
            if (!fileInfo.Exists) throw new InvalidDataException("fileInfo file does not exists.");

            string xsd = "http://chernoivanov.org/SmsDeliveryTest";
            XmlDocument xDoc = new XmlDocument();
            xDoc.Load(fileInfo.FullName);
            XmlNamespaceManager names = new XmlNamespaceManager(xDoc.NameTable);
            names.AddNamespace("a", xsd);

            XmlNode node = xDoc.SelectSingleNode("//a:DB", names);
            this.dbType = (DBType)Enum.Parse(typeof(DBType), node.Attributes["type"].Value, true);
            this.dbConnectionString = Utils.formatText(node.SelectSingleNode("a:ConnectionString/text()", names).Value).Replace("; ", ";");

            XmlNodeList nodes = xDoc.SelectNodes("//a:AudioFiles/*", names);

            if (0 == nodes.Count)
                throw new InvalidDataException("No nodes in AudioFiles");
            foreach (XmlNode n in xDoc.SelectNodes("//a:AudioFiles/*", names))
            {
                WebFileConfigImpl fileCfg = new WebFileConfigImpl(
                    n.Attributes["DirectoryForAudioFiles"].Value, 
                    n.Attributes["AudioFileExtension"].Value);
                senderConfigDictionary.Add(n.Attributes["MailSender"].Value, fileCfg);
            }
        }

        public static IDBProvider InitProvider(DBType type, IPEndPoint ep, string user, string pwd, object other)
        {
            IDBProvider provider = null;
            switch (type)
            {
                case DBType.MSSQL:
                    {
                        provider = new MSSQLProvider();
                        provider.Username = user;
                        provider.Password = pwd;
                        provider.SetConnectionBuilder(ep, user, pwd);
                    }
                    break;
                case DBType.MYSQL:
                    {

                    }
                    break;
                case DBType.ORACLE:
                    {

                    }
                    break;
                default:
                    {
                        provider = null;
                    }
                    break;
            }
            return provider;
        }

 public void Put(DBType typecode, int size, string value)
 {
     SortedList<int, string> map;
     if (!weighted.TryGetValue(typecode, out map))
     {
         weighted[typecode] = map = new SortedList<int, string>();
     }
     map[size] = value;
 }

        protected override void ConvertDBTypeToNativeType(IDbDataParameter p, DBType dbType)
        {
            if (SetSqlDbType == null)
            {
                SetSqlDbType = p.GetType().Module.GetType("System.Data.SqlServerCe.SqlCeParameter").GetProperty("SqlDbType", BindingFlags.Public | BindingFlags.Instance).GetSetter();

            }
            if (SetSqlDbType != null)
                SetSqlDbType(p, (SqlDbType)(int)dbType);
            else
                base.ConvertDBTypeToNativeType(p, dbType);
        }

 public string Get(DBType typecode, int size, int precision, byte scale)
 {
     if (size == 0 && precision == 0 && scale == 0)
         return Get(typecode);
     SortedList<int, string> map;
     weighted.TryGetValue(typecode, out map);
     if (map != null && map.Count > 0)
         foreach (KeyValuePair<int, string> entry in map)
             if (size <= entry.Key || precision > 0 || scale > 0)
                 return Replace(entry.Value, size, precision, scale);
     return Replace(Get(typecode), size, precision, scale);
 }

 public static IHaveDbProvider GetProvider(DBType type)
 {
     switch (type)
     {
         case DBType.SqlServer: return new SqlServerProvider();
         case DBType.SqlServerCE: return new SqlServerCEProvider();
         case DBType.MySql: return new MySqlProvider();
         case DBType.PostgreSQL:return new PostgresProvider();
         case DBType.Oracle:return new OracleProvider();
         case DBType.SQLite:return new SqliteProvider();
     }
     throw new Exception("Unkown provider");
 }

 private static string GetDBTypeString(DBType dbType)
 {
     switch (dbType)
     {
         case DBType.Date:
             return "Date";
         case DBType.Integer:
             return "Integer";
         case DBType.NVarChar:
             return "Nvarchar";
         default:
             return "Ntext";
     }
 }

 private void button2_Click(object sender, EventArgs e)
 {
     DbSettings dialog = new DbSettings();
     DialogResult result = dialog.ShowDialog(this);
     if (result == DialogResult.OK)
     {
         DBType = dialog.DBType;
         DbUser = dialog.DBUser;
         DbPass = dialog.DBPass;
         DbName = dialog.DBName;
         DbAddr = dialog.DBAddr;
         DbTNam = dialog.DBTNam;
     }
 }

 public static IDBDialog GetDBDialog(DBType dbTypeName)
 {
     switch (dbTypeName)
     {
         case DBType.Oracle:
             return new OracleDBDialog();
         case DBType.MySql:
             return new MySQLDBDialog();
         case DBType.SqlServer:
             return new SqlServerDBDialog();
         default:
             return null;
     }
 }

        public static IDBAccess Create(DBType type)
        {
            IDBAccess IRet = null;
            switch (type)
            {
                case DBType.Access:
                    IRet = new Access(type);
                    break;

                case DBType.SQL:
                    IRet = new SQL(type);
                    break;

                default:
                    break;
            }
            return IRet;
        }

 public static string GetStatementByDBType(SQLStatementType statetype, DBType dbtype, object other)
 {
     string statement;
     switch (statetype)
     {
         case SQLStatementType.EXISTSLM:
             {
                 switch (dbtype)
                 {
                     case DBType.MSSQL:
                         {
                             statement = string.Format("select count(*) from master.dbo.sysobjects where xtype = 'U' and object_id(N'{0}') = id", Settings.Default.LMTABLE);
                         }
                         break;
                 }
             }
             break;
     }
     return null;
 }

        public WorkingSet(string plantConnStr)
        {
            _dbType = Utility.GetDBType(plantConnStr);
              _connStrs[Constants.SPPID_PLANT_SCHEMA] = plantConnStr;

              if (Utility.GetDBType(plantConnStr) == DBType.ORACLE)
              {
            DataTable result = DBManager.Instance.ExecuteQuery(plantConnStr, Constants.ORACLE_GET_CURRENT_SCHEMA);

            if (result != null && result.Rows.Count > 0)
            {
              _plantSchema = result.Rows[0][0].ToString();
            }
              }
              else if (Utility.GetDBType(plantConnStr) == DBType.SQLServer)
              {
            //TODO: need to verify
            _plantSchema = "dbo";
              }
        }

 SqlType(DBType dbType)
 {
     this.DbType = dbType;
     hashCode = dbType.GetHashCode();
 }

 DB showForm(DBType t, DB db = null)
 {
     NewForm newForm = new NewForm(t);
     if (db != null) newForm.db = db;
     if (newForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         return newForm.db;
     }
     return null;
 }

 protected void RegisterCastType(DBType code, string name)
 {
     castTypeNames.Put(code, name);
 }

 public BaseProvider(string connectionStringName, DBType dbType)
     : base("KingSite.Purview", connectionStringName, dbType)
 {
 }

        //
        // System.Configuration.Provider.ProviderBase.Initialize Method
        //
        public override void Initialize(string name, NameValueCollection config)
        {
            //
            // Initialize values from web.config.
            //

            if (config == null)
                throw new ArgumentNullException("config");

            if (name == null || name.Length == 0)
                name = "KSP RoleProvider";

            if (String.IsNullOrEmpty(config["description"])) {
                config.Remove("description");
                config.Add("description", "KSP RoleProvider for sqlserver/mysql/oracle");
            }

            // Initialize the abstract base class.
            base.Initialize(name, config);

            _ApplicationName = Config.GetApplicationName();
            _KSPDBType = Config.GetDBType();
            _ConnectionStringName = Config.GetConnectionName();

            if (config["writeExceptionsToEventLog"] != null) {
                if (config["writeExceptionsToEventLog"].ToUpper() == "TRUE") {
                    _WriteExceptionsToEventLog = true;
                }
            }

            InitRepostory();
        }

 public SelectBuilder DB(DBType dbType)
 {
     DBType = dbType;
     return this;
 }

 public Sys_UserInRoleRepository(string connectionStringName, DBType dbType)
     : base(connectionStringName, dbType)
 {
 }