apewer-dotnet/Apewer.Source/Source/MySql.cs

#if MYSQL_6_9 || MYSQL_6_10

/* 2021.11.07 */

using Externals.MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Net;
using System.Text;
using System.Transactions;

using static Apewer.Source.SourceUtility;

namespace Apewer.Source
{

    /// <summary></summary>
    public class MySql : IDbClient
    {

        #region 基础

        private Timeout _timeout = null;
        private string _connectionstring = null;

        /// <summary>获取或设置日志记录。</summary>
        public Logger Logger { get; set; }

        /// <summary>超时设定。</summary>
        public Timeout Timeout { get => _timeout; }

        /// <summary>创建实例。</summary>
        public MySql(string connnectionString, Timeout timeout = default)
        {
            _connectionstring = connnectionString;
            _timeout = timeout ?? Timeout.Default;
        }

        /// <summary>获取当前的 MySqlConnection 对象。</summary>
        public IDbConnection Connection { get => _connection; }

        /// <summary>构建连接字符串以创建实例。</summary>
        public MySql(string address, string store, string user, string pass, Timeout timeout = null)
        {
            _timeout = timeout ?? Timeout.Default;

            var a = address ?? "";
            var s = store ?? "";
            var u = user ?? "";
            var p = pass ?? "";
            var cs = $"server={a}; database={s}; uid={u}; pwd={p}; ";
            _connectionstring = cs;
            _storename = new Class<string>(s);
        }

        #endregion

        #region 日志。

        private void LogError(string action, Exception ex, string addtion)
        {
            var logger = Logger;
            if (logger != null) logger.Error(this, "MySQL", action, ex.GetType().FullName, ex.Message, addtion);
        }

        #endregion

        #region Connection

        private MySqlConnection _connection = null;

        /// <summary></summary>
        public bool Online { get => _connection == null ? false : (_connection.State == ConnectionState.Open); }

        /// <summary>连接字符串。</summary>
        public string ConnectionString { get => _connectionstring; }

        /// <summary></summary>
        public string Connect()
        {
            if (_connection == null)
            {
                _connection = new MySqlConnection();
                _connection.ConnectionString = _connectionstring;
            }
            else
            {
                if (_connection.State == ConnectionState.Open) return null;
            }

            // try
            {
                _connection.Open();
                switch (_connection.State)
                {
                    case ConnectionState.Open: return null;
                    default: return $"连接失败，当前处于 {_connection.State} 状态。";
                }
            }
            // catch (Exception ex)
            // {
            //     LogError("Connection", ex, _connection.ConnectionString);
            //     Close();
            //     return false;
            // }
        }

        /// <summary></summary>
        public void Close()
        {
            if (_connection != null)
            {
                if (_transaction != null)
                {
                    if (_autocommit) Commit();
                    else Rollback();
                }
                _connection.Close();
                _connection.Dispose();
                _connection = null;
            }
        }

        /// <summary></summary>
        public void Dispose() { Close(); }

        #endregion

        #region Transaction

        private IDbTransaction _transaction = null;
        private bool _autocommit = false;

        /// <summary>启动事务。</summary>
        public string Begin(bool commit = true) => Begin(commit, null);

        /// <summary>启动事务。</summary>
        public string Begin(bool commit, Class<System.Data.IsolationLevel> isolation)
        {
            if (Connect() != null) return "未连接。";
            if (_transaction != null) return "存在已启动的事务，无法再次启动。";
            try
            {
                _transaction = isolation ? _connection.BeginTransaction(isolation.Value) : _connection.BeginTransaction();
                _autocommit = commit;
                return null;
            }
            catch (Exception ex)
            {
                Logger.Error(nameof(MySql), "Commit", ex.Message());
                return ex.Message();
            }
        }

        /// <summary>提交事务。</summary>
        public string Commit()
        {
            if (_transaction == null) return "事务不存在。";
            try
            {
                _transaction.Commit();
                RuntimeUtility.Dispose(_transaction);
                _transaction = null;
                return null;
            }
            catch (Exception ex)
            {
                RuntimeUtility.Dispose(_transaction);
                _transaction = null;
                Logger.Error(nameof(MySql), "Commit", ex.Message());
                return ex.Message();
            }
        }

        /// <summary>从挂起状态回滚事务。</summary>
        public string Rollback()
        {
            if (_transaction == null) return "事务不存在。";
            try
            {
                _transaction.Rollback();
                RuntimeUtility.Dispose(_transaction);
                _transaction = null;
                return null;
            }
            catch (Exception ex)
            {
                RuntimeUtility.Dispose(_transaction);
                _transaction = null;
                Logger.Error(nameof(MySql), "Rollback", ex.Message());
                return ex.Message();
            }
        }

        #endregion

        #region SQL

        /// <summary></summary>
        public IQuery Query(string sql, IEnumerable<IDataParameter> parameters)
        {
            if (sql.IsBlank()) return Example.InvalidQueryStatement;

            var connected = Connect();
            if (connected.NotEmpty()) return Example.InvalidQueryConnection;

            try
            {
                using (var command = new MySqlCommand())
                {
                    command.Connection = _connection;
                    command.CommandTimeout = _timeout.Query;
                    command.CommandText = sql;
                    if (parameters != null)
                    {
                        foreach (var p in parameters)
                        {
                            if (p != null) command.Parameters.Add(p);
                        }
                    }
                    using (var ds = new DataSet())
                    {
                        using (var da = new MySqlDataAdapter(command))
                        {
                            var name = "table_" + Guid.NewGuid().ToString("n");
                            da.Fill(ds, name);
                            var table = ds.Tables[name];
                            return new Query(table);
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                Logger.Error(nameof(MySql), "Query", exception, sql);
                return new Query(exception);
            }
        }

        /// <summary></summary>
        public IExecute Execute(string sql, IEnumerable<IDataParameter> parameters)
        {
            if (sql.IsBlank()) return Example.InvalidExecuteStatement;

            var connected = Connect();
            if (connected.NotEmpty()) return new Execute(false, connected);

            var inTransaction = _transaction != null;
            if (!inTransaction) Begin();
            try
            {
                using (var command = new MySqlCommand())
                {
                    command.Connection = _connection;
                    command.Transaction = (MySqlTransaction)_transaction;
                    command.CommandTimeout = _timeout.Execute;
                    command.CommandText = sql;
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            if (parameter == null) continue;
                            command.Parameters.Add(parameter);
                        }
                    }
                    var rows = command.ExecuteNonQuery();
                    if (!inTransaction) Commit(); // todo 此处应该检查事务提交产生的错误。
                    return new Execute(true, rows);
                }
            }
            catch (Exception exception)
            {
                Logger.Error(nameof(MySql), "Execute", exception, sql);
                if (!inTransaction) Rollback();
                return new Execute(exception);
            }
        }

        /// <summary></summary>
        public IQuery Query(string sql) => Query(sql, null);

        /// <summary></summary>
        public IExecute Execute(string sql, IEnumerable<Parameter> parameters)
        {
            var dps = null as List<IDataParameter>;
            if (parameters != null)
            {
                var count = parameters.Count();
                dps = new List<IDataParameter>(count);
                foreach (var p in parameters)
                {
                    var dp = Parameter(p);
                    dps.Add(dp);
                }
            }
            return Execute(sql, dps);
        }

        /// <summary></summary>
        public IExecute Execute(string sql) => Execute(sql, null as IEnumerable<IDataParameter>);

        #endregion

        #region ORM

        private Class<string> _storename = null;

        private string StoreName()
        {
            if (_storename) return _storename.Value;
            _storename = new Class<string>(Internals.TextHelper.ParseConnectionString(_connectionstring).GetValue("database"));
            return _storename.Value ?? "";
        }

        private string[] FirstColumn(string sql)
        {
            using (var query = Query(sql) as Query) return query.ReadColumn();
        }

        /// <summary></summary>
        public string[] TableNames()
        {
            var sql = TextUtility.Merge("select table_name from information_schema.tables where table_schema='", StoreName(), "' and table_type='base table';");
            return FirstColumn(sql);
        }

        /// <summary></summary>
        public string[] ViewNames()
        {
            var sql = TextUtility.Merge("select table_name from information_schema.tables where table_schema='", StoreName(), "' and table_type='view';");
            return FirstColumn(sql);
        }

        /// <summary></summary>
        public string[] ColumnNames(string table)
        {
            var sql = TextUtility.Merge("select column_name from information_schema.columns where table_schema='", StoreName(), "' and table_name='", TextUtility.AntiInject(table), "';");
            return FirstColumn(sql);
        }

        /// <summary>获取用于创建表的语句。</summary>
        private string GetCreateStetement(TableStructure structure)
        {
            // 检查现存表。
            var exists = false;
            var tables = TableNames();
            if (tables.Length > 0)
            {
                var lower = structure.Name.ToLower();
                foreach (var table in tables)
                {
                    if (TextUtility.IsBlank(table)) continue;
                    if (table.ToLower() == lower)
                    {
                        exists = true;
                        break;
                    }
                }
            }

            if (exists)
            {
                var columns = ColumnNames(structure.Name);
                if (columns.Length > 0)
                {
                    var lower = new List<string>(columns.Length);
                    var added = 0;
                    foreach (var column in columns)
                    {
                        if (TextUtility.IsBlank(column)) continue;
                        lower.Add(column.ToLower());
                        added++;
                    }
                    lower.Capacity = added;
                    columns = lower.ToArray();
                }
                var sqlsb = new StringBuilder();
                foreach (var column in structure.Columns)
                {
                    // 检查 Independent 特性。
                    if (structure.Independent && column.Independent) continue;

                    // 去重。
                    var lower = column.Field.ToLower();
                    if (columns.Contains(lower)) continue;

                    var type = Declaration(column);
                    if (type.IsEmpty()) return TextUtility.Merge("类型 ", column.Type.ToString(), " 不受支持。");

                    // alter table `_record` add column `_index` bigint;
                    sqlsb.Append("alter table `", structure.Name, "` add column ", type, "; ");
                }
                var sql = sqlsb.ToString();
                return sql;
            }
            else
            {
                // create table _record (`_index` bigint, `_key` varchar(255),  `_text` longtext) engine=innodb default charset=utf8mb4

                var columns = new List<string>(structure.Columns.Length);
                var columnsAdded = 0;
                var primarykeys = new List<string>();
                foreach (var column in structure.Columns)
                {
                    // 检查 Independent 特性。
                    if (structure.Independent && column.Independent) continue;

                    // 字段。
                    var type = Declaration(column);
                    if (type.IsEmpty()) return TextUtility.Merge("类型 ", column.Type.ToString(), " 不受支持。");
                    if (!column.Independent)
                    {
                        if (column.PrimaryKey) primarykeys.Add(column.Field);
                        if (column.Incremental) type += " auto_increment";
                    }

                    columns.Add(type);
                    columnsAdded++;
                }
                columns.Capacity = columnsAdded;
                var table = structure.Name;
                var joined = string.Join(", ", columns);

                // 设置主键。
                string sql;
                var sqlPrimaryKey = primarykeys.Count < 1 ? "" : (", primary key (" + string.Join(", ", primarykeys.ToArray()) + ")");
                sql = TextUtility.Merge("create table `", table, "`(", joined, sqlPrimaryKey, ") engine=innodb default charset=utf8mb4; ");

                return sql;
            }
        }

        /// <summary></summary>
        private string Initialize(Type model, out string sql)
        {
            if (model == null)
            {
                sql = null;
                return "指定的类型无效。";
            }

            var structure = TableStructure.Parse(model);
            if (structure == null)
            {
                sql = null;
                return "无法解析记录模型。";
            }

            // 连接数据库。
            var connect = Connect();
            if (connect.NotEmpty())
            {
                sql = null;
                return $"连接数据库失败。（{connect}）";
            }

            sql = GetCreateStetement(structure);
            if (sql.NotEmpty())
            {
                var execute = Execute(sql);
                if (!execute.Success) return execute.Message;
            }
            return null;
        }

        /// <summary></summary>
        public string Initialize(Type model) => Initialize(model, out string sql);

        /// <summary></summary>
        public string Initialize<T>() where T : class, new() => Initialize(typeof(T));

        /// <summary></summary>
        public string Initialize(Record model) => (model == null) ? "参数无效。" : Initialize(model.GetType());

        /// <summary>插入记录。返回错误信息。</summary>
        public string Insert(object record, string table = null)
        {
            if (record == null) return "参数无效。";
            SourceUtility.FixProperties(record);

            var structure = TableStructure.Parse(record.GetType());
            if (structure == null) return "无法解析记录模型。";
            if (string.IsNullOrEmpty(table)) table = structure.Name;
            if (string.IsNullOrEmpty(table)) return "表名称无效。";

            // 排除字段。
            var excluded = new List<string>();
            foreach (var ca in structure.Columns)
            {
                // 排除不使用 ORM 的属性。
                if (ca.Independent || ca.Incremental) excluded.Add(ca.Field);
            }

            var ps = structure.CreateParameters(record, Parameter, excluded);
            var psc = ps.Length;
            if (psc < 1) return "数据模型不包含字段。";

            var names = new List<string>(psc);
            var values = new List<string>(psc);
            foreach (var p in ps)
            {
                var pn = p.ParameterName;
                names.Add("`" + p + "`");
                values.Add("@" + p);
            }
            var ns = string.Join(", ", names);
            var vs = string.Join(", ", values);
            var sql = $"insert into `{table}` ({ns}) values ({vs}); ";

            var execute = Execute(sql, ps);
            if (execute.Success) return TextUtility.Empty;
            return execute.Message;
        }

        /// <summary>更新记录，实体中的 Key 属性不被更新。返回错误信息。</summary>
        /// <remarks>无法更新带有 Independent 特性的模型（缺少 Key 属性）。</remarks>
        public string Update(IRecord record, string table = null)
        {
            if (record == null) return "参数无效。";
            FixProperties(record);
            SetUpdated(record);

            var structure = TableStructure.Parse(record.GetType());
            if (structure == null) return "无法解析记录模型。";
            if (structure.Independent) return "无法更新带有 Independent 特性的模型。";
            if (string.IsNullOrEmpty(table)) table = structure.Name;
            if (string.IsNullOrEmpty(table)) return "表名称无效。";

            // 排除字段。
            var excluded = new List<string>();
            if (structure.Key != null) excluded.Add(structure.Key.Field);
            foreach (var ca in structure.Columns)
            {
                // 排除不使用 ORM 的属性、自增属性和主键属性。
                if (ca.Independent || ca.Incremental || ca.PrimaryKey) excluded.Add(ca.Field);
            }

            var ps = structure.CreateParameters(record, Parameter, excluded);
            var psc = ps.Length;
            if (psc < 1) return "数据模型不包含字段。";

            var items = new List<string>(psc);
            foreach (var p in ps)
            {
                var pn = p.ParameterName;
                items.Add(TextUtility.Merge("`", pn, "` = @", pn));
            }
            var key = record.Key.SafeKey();
            var sql = $"update `{table}` set {string.Join(", ", items)} where `_key`='{key}'; ";

            var execute = Execute(sql, ps);
            if (execute.Success) return TextUtility.Empty;
            return execute.Message;
        }

        /// <summary></summary>
        public Result<object[]> Query(Type model, string sql, IEnumerable<IDataParameter> parameters = null) => SourceUtility.Query(this, model, sql, parameters);

        /// <summary></summary>
        public Result<T[]> Query<T>(string sql, IEnumerable<IDataParameter> parameters = null) where T : class, new()
        {
            var query = Query(sql, parameters);
            if (!query.Success) return new Result<T[]>(query.Message);
            var records = query.Fill<T>();
            query.Dispose();

            var result = new Result<T[]>(records);
            return result;
        }

        /// <summary>获取所有记录。Flag 为 0 时将忽略 Flag 条件。</summary>
        public Result<object[]> Query(Type model, long flag = 0) => SourceUtility.Query(this, model, (tn) =>
        {
            if (flag == 0) return $"select * from `{tn}`; ";
            return $"select * from `{tn}` where `_flag`={flag}; ";
        });

        /// <summary>获取所有记录。Flag 为 0 时将忽略 Flag 条件。</summary>
        public Result<T[]> Query<T>(long flag = 0) where T : class, IRecord, new() => SourceUtility.Query<T>(this, (tn) =>
        {
            if (flag == 0) return $"select * from `{tn}`; ";
            return $"select * from `{tn}` where `_flag`={flag}; ";
        });

        /// <summary>获取记录。</summary>
        /// <param name="model">填充的记录模型。</param>
        /// <param name="skip">要跳过的记录数，可用最小值为 0。</param>
        /// <param name="count">要获取的记录数，可用最小值为 1。</param>
        public Result<object[]> Query(Type model, int skip, int count)
        {
            if (skip < 0) return new Result<object[]>("参数 skip 超出了范围。");
            if (count < 1) return new Result<object[]>("参数 count 超出了范围。");
            return SourceUtility.Query(this, model, (tn) => $"select * from `{tn}` limit {skip}, {count}; ");
        }

        /// <summary>获取记录。</summary>
        /// <param name="skip">要跳过的记录数，可用最小值为 0。</param>
        /// <param name="count">要获取的记录数，可用最小值为 1。</param>
        public Result<T[]> Query<T>(int skip, int count) where T : class, IRecord, new()
        {
            if (skip < 0) return new Result<T[]>("参数 skip 超出了范围。");
            if (count < 1) return new Result<T[]>("参数 count 超出了范围。");
            return SourceUtility.Query<T>(this, (tn) => $"select * from `{tn}` limit {skip}, {count}; ");
        }

        /// <summary>获取记录。</summary>
        public Result<object> Get(Type model, string key, long flag = 0) => SourceUtility.Get(this, model, key, (tn, sk) =>
        {
            if (flag == 0) return $"select * from `{tn}` where `_key`='{sk}' limit 1;";
            return $"select * from `{tn}` where `_key`='{sk}' and `_flag`={flag} limit 1;";
        });

        /// <summary>获取记录。</summary>
        public Result<T> Get<T>(string key, long flag = 0) where T : class, IRecord, new() => SourceUtility.Get<T>(this, key, (tn, sk) =>
        {
            if (flag == 0) return $"select * from `{tn}` where `_key`='{sk}' limit 1;";
            return $"select * from `{tn}` where `_key`='{sk}' and `_flag`={flag} limit 1;";
        });

        /// <summary>>获取指定类型的主键，按 Flag 属性筛选。</summary>
        public Result<string[]> Keys(Type model, long flag = 0) => SourceUtility.Keys(this, model, (tn) =>
        {
            if (flag == 0) return $"select `_key` from `{tn}`;";
            return $"select `_key` from `{tn}` where `_flag`={flag};";
        });

        /// <summary>>获取指定类型的主键，按 Flag 属性筛选。</summary>
        public Result<string[]> Keys<T>(long flag = 0) where T : class, IRecord, new() => Keys(typeof(T), flag);

        /// <summary>对表添加列，返回错误信息。</summary>
        /// <typeparam name="T">记录类型。</typeparam>
        /// <param name="column">列名称。</param>
        /// <param name="type">字段类型。</param>
        /// <param name="length">字段长度，仅对 VarChar 和 NVarChar 类型有效。</param>
        /// <returns></returns>
        public string AddColumn<T>(string column, ColumnType type, int length = 0) where T : class, IRecord
        {
            var columnName = SafeColumn(column);
            if (columnName.IsEmpty()) return "列名无效。";

            var ta = TableAttribute.Parse(typeof(T));
            if (ta == null) return "无法解析记录模型。";
            var tableName = ta.Name;

            var columeType = "";
            switch (type)
            {
                case ColumnType.Integer:
                    columeType = "bigint";
                    break;
                case ColumnType.Float:
                    columeType = "double";
                    break;
                case ColumnType.Bytes:
                    columeType = "longblob";
                    break;
                case ColumnType.DateTime:
                    columeType = "datetime";
                    break;
                case ColumnType.VarChar:
                case ColumnType.NVarChar:
                    columeType = $"varchar({length})";
                    break;
                case ColumnType.VarChar191:
                case ColumnType.NVarChar191:
                    columeType = "varchar(191)";
                    break;
                case ColumnType.VarCharMax:
                case ColumnType.NVarCharMax:
                    columeType = "varchar(max)";
                    break;
                case ColumnType.Text:
                    columeType = "longtext";
                    break;
            }
            if (columeType.IsEmpty()) return "类型不支持。";

            var sql = $"alter table `{tableName}` add {columnName} {columeType}; ";
            var execute = Execute(sql) as Execute;
            var error = execute.Message;
            return error;
        }

        #endregion

        #region static

        /// <summary>对文本转义，符合 SQL 安全性。可根据字段类型限制 UTF-8 字节数，默认为 0 时不限制字节数。</summary>
        public static string Escape(string text, int bytes = 0)
        {
            if (text.IsEmpty()) return "";

            var t = text ?? "";
            t = t.Replace("\\", "\\\\");
            t = t.Replace("'", "\\'");
            t = t.Replace("\n", "\\n");
            t = t.Replace("\r", "\\r");
            t = t.Replace("\b", "\\b");
            t = t.Replace("\t", "\\t");
            t = t.Replace("\f", "\\f");

            if (bytes > 5)
            {
                if (t.Bytes(Encoding.UTF8).Length > bytes)
                {
                    while (true)
                    {
                        t = t.Substring(0, t.Length - 1);
                        if (t.Bytes(Encoding.UTF8).Length <= (bytes - 4)) break;
                    }
                    t = t + " ...";
                }
            }

            return t;
        }

        /// <summary></summary>
        public static string SafeTable(string table)
        {
            const string chars = "0123456789_-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
            var safety = TextUtility.Restrict(table, chars).Lower();
            var pc = 0;
            for (var i = 0; i < safety.Length; i++)
            {
                if (safety[i] == '-') pc += 1;
                else break;
            }
            if (pc == safety.Length) return "";
            if (pc > 0) safety = safety.Substring(pc);
            return safety;
        }

        /// <summary></summary>
        public static string SafeColumn(string column) => SafeTable(column);

        /// <summary></summary>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="InvalidOperationException"></exception>
        internal static MySqlParameter Parameter(Parameter parameter)
        {
            if (parameter == null) throw new InvalidOperationException("参数无效。");
            return Parameter(parameter.Name, parameter.Type, parameter.Size, parameter.Value);
        }

        /// <summary></summary>
        internal static MySqlParameter Parameter(string name, ColumnType type, Int32 size, object value)
        {
            if (TextUtility.IsBlank(name)) return null;

            var dbtype = MySqlDbType.Int64;
            switch (type)
            {
                case ColumnType.Bytes:
                    dbtype = MySqlDbType.LongBlob;
                    break;
                case ColumnType.Integer:
                    dbtype = MySqlDbType.Int64;
                    break;
                case ColumnType.Float:
                    dbtype = MySqlDbType.Double;
                    break;
                case ColumnType.DateTime:
                    dbtype = MySqlDbType.DateTime;
                    break;
                case ColumnType.VarChar:
                case ColumnType.VarChar191:
                case ColumnType.VarCharMax:
                case ColumnType.NVarChar:
                case ColumnType.NVarChar191:
                case ColumnType.NVarCharMax:
                    dbtype = MySqlDbType.VarChar;
                    break;
                case ColumnType.Text:
                case ColumnType.NText:
                    dbtype = MySqlDbType.LongText;
                    break;
                default:
                    throw new InvalidOperationException(TextUtility.Merge("类型 ", type.ToString(), " 不受支持。"));
            }

            switch (type)
            {
                case ColumnType.VarChar:
                case ColumnType.NVarChar:
                    size = NumberUtility.Restrict(size, 0, 65535);
                    break;
                case ColumnType.VarChar191:
                case ColumnType.NVarChar191:
                    size = NumberUtility.Restrict(size, 0, 191);
                    break;
                default:
                    size = 0;
                    break;
            }

            if (value is string && value != null && size > 0)
            {
                value = TextUtility.Left((string)value, size);
            }

            var parameter = new MySqlParameter();
            parameter.ParameterName = name;
            parameter.MySqlDbType = dbtype;
            parameter.Value = value;
            if (size > 0) parameter.Size = size;
            return parameter;
        }

        /// <summary></summary>
        internal static MySqlParameter Parameter(string name, MySqlDbType type, object value, Int32 size = 0)
        {
            var parameter = new MySqlParameter();
            parameter.ParameterName = name;
            parameter.MySqlDbType = type;
            parameter.Value = value;
            if (size > 0) parameter.Size = size;
            return parameter;
        }

        private static string Declaration(ColumnAttribute column)
        {
            var type = TextUtility.Empty;
            var length = Math.Max(0, (int)column.Length);
            switch (column.Type)
            {
                case ColumnType.Integer:
                    type = "bigint";
                    break;
                case ColumnType.Float:
                    type = "double";
                    break;
                case ColumnType.Bytes:
                    type = "longblob";
                    break;
                case ColumnType.DateTime:
                    type = "datetime";
                    break;
                case ColumnType.VarChar:
                    type = TextUtility.Merge("varchar(", Math.Max(65535, length).ToString(), ")");
                    break;
                case ColumnType.VarChar191:
                    type = TextUtility.Merge("varchar(191)");
                    break;
                case ColumnType.VarCharMax:
                    type = TextUtility.Merge("varchar(max)");
                    break;
                case ColumnType.Text:
                    type = TextUtility.Merge("longtext");
                    break;
                case ColumnType.NVarChar:
                    type = TextUtility.Merge("varchar(", Math.Min(65535, length).ToString(), ")");
                    break;
                case ColumnType.NVarChar191:
                    type = TextUtility.Merge("varchar(191)");
                    break;
                case ColumnType.NVarCharMax:
                    type = TextUtility.Merge("varchar(65535)");
                    break;
                case ColumnType.NText:
                    type = TextUtility.Merge("longtext");
                    break;
                default:
                    return TextUtility.Empty;
            }
            return TextUtility.Merge("`", (string)column.Field, "` ", type);
        }

        /// <summary>获取每个数据库中，每个表的容量，单位为字节。</summary>
        public static Dictionary<string, Dictionary<string, long>> GetTablesCapacity(MySql source)
        {
            var result = new Dictionary<string, Dictionary<string, long>>();
            if (source != null && source.Connect().IsEmpty())
            {
                var sql = "select `table_schema`, `table_name`, `engine`, `data_length`, `index_length` from `information_schema`.tables order by `table_schema`, `table_name`";
                using (var query = (Query)source.Query(sql))
                {
                    for (var r = 0; r < query.Rows; r++)
                    {
                        var store = query.Text(r, "table_schema");
                        var table = query.Text(r, "table_name");
                        var engine = query.Text(r, "engine");
                        var capacity = NumberUtility.Int64(query.Text(r, "data_length")) + NumberUtility.Int64(query.Text(r, "index_length"));

                        if (store == "mysql") continue;
                        if (store == "information_schema") continue;
                        if (store == "performance_schema") continue;

                        if (engine != "MyISAM" && engine != "InnoDB") continue;

                        if (!result.ContainsKey(store)) result.Add(store, new Dictionary<string, long>());
                        if (!result[store].ContainsKey(table)) result[store].Add(table, 0L);
                        result[store][table] = capacity;
                    }
                }
            }
            return result;
        }

        #endregion

    }

}

#endif