apewer-dotnet/Apewer/Source/MySql.cs

#if NET40 || NET461

/* 2021.02.20 */

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

namespace Apewer.Source
{

    /// <summary></summary>
    public class MySql : IDatabase, IDisposable
    {

        #region fields & properties

        private const string EmptyString = TextUtility.EmptyString;

        private MySqlConnection _connection = null;
        private Timeout _timeout = new Timeout();
        private string _address = EmptyString;
        private string _store = EmptyString;
        private string _user = "root";
        private string _pass = EmptyString;

        /// <summary></summary>
        public string Address { get { return _address; } set { _address = TextUtility.AntiInject(value); } }

        /// <summary></summary>
        public string Store { get { return _store; } set { _store = TextUtility.AntiInject(value); } }

        /// <summary></summary>
        public string User { get { return _user; } set { _user = TextUtility.AntiInject(value); } }

        /// <summary></summary>
        public string Pass { get { return _pass; } set { _pass = TextUtility.AntiInject(value); } }

        /// <summary></summary>
        public Timeout Timeout { get { return _timeout; } set { _timeout = value; } }

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

        /// <summary></summary>
        public MySql() { }

        /// <summary></summary>
        public MySql(string address, string store, string user, string pass = null)
        {
            Address = address;
            Store = store;
            User = user;
            Pass = pass;
        }

        #endregion

        #region 日志。

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

        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 methods

        private string CombineString()
        {
            return TextUtility.Merge("server=", _address, "; database=", _store, "; uid=", _user, "; pwd=", _pass, ";");
        }

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

            try
            {
                _connection.Open();
                switch (_connection.State)
                {
                    case ConnectionState.Open: return true;
                    default: return false;
                }
            }
            catch (Exception ex)
            {
                LogError("Connection", ex, _connection.ConnectionString);
                Close();
                return false;
            }
        }

        /// <summary></summary>
        public void Close()
        {
            if (_connection != null)
            {
                _connection.Close();
                _connection.Dispose();
                _connection = null;
            }
        }

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

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

            const string table = "queryresult";

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

            var query = new Query();
            try
            {
                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(sql, _connection))
                    {
                        da.Fill(ds, table);
                        query.Table = ds.Tables[table];
                    }
                }
                command.Dispose();
                query.Success = true;
            }
            catch (Exception exception)
            {
                LogError("Query", exception, sql);
                query.Success = false;
                query.Exception = exception;
            }
            return query;
        }

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

            var connected = Connect();
            if (!connected) return Example.InvalidExecuteConnection;

            var transaction = _connection.BeginTransaction();
            var execute = new Execute();
            try
            {
                var command = new MySqlCommand();
                command.Connection = _connection;
                command.Transaction = transaction;
                command.CommandTimeout = _timeout.Execute;
                command.CommandText = sql;
                if (parameters != null)
                {
                    foreach (var parameter in parameters)
                    {
                        if (parameter == null) continue;
                        command.Parameters.Add(parameter);
                    }
                }
                execute.Rows += command.ExecuteNonQuery();
                transaction.Commit();
                command.Dispose();
                execute.Success = true;
            }
            catch (Exception exception)
            {
                LogError("Execute", exception, sql);
                try { transaction.Rollback(); } catch { }
                execute.Success = false;
                execute.Exception = exception;
            }
            try { transaction.Dispose(); } catch { }
            return execute;
        }

        /// <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 = RuntimeUtility.Count(parameters);
                dps = new List<IDataParameter>(count);
                foreach (var p in parameters)
                {
                    var dp = CreateDataParameter(p);
                    dps.Add(dp);
                }
            }
            return Execute(sql, dps);
        }

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

        #endregion

        #region linq

        private List<string> QueryFirstColumn(string sql)
        {
            using (var query = Query(sql) as Query) return query.ReadColumn();
        }

        /// <summary></summary>
        public List<string> QueryAllTableNames()
        {
            var sql = TextUtility.Merge("select table_name from information_schema.tables where table_schema='", _store, "' and table_type='base table';");
            return QueryFirstColumn(sql);
        }

        /// <summary></summary>
        public List<string> QueryAllViewNames()
        {
            var sql = TextUtility.Merge("select table_name from information_schema.tables where table_schema='", _store, "' and table_type='view';");
            return QueryFirstColumn(sql);
        }

        /// <summary></summary>
        public List<string> QueryAllColumnNames(string table)
        {
            var sql = TextUtility.Merge("select column_name from information_schema.columns where table_schema='", _store, "' and table_name='", TextUtility.AntiInject(table), "';");
            return QueryFirstColumn(sql);
        }

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

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

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

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

                    // alter table `_record` add column `_index` bigint;
                    sqlsb.Append("alter table `", structure.Table, "` 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.Count);
                var columnsAdded = 0;
                var primarykey = null as string;
                foreach (var kvp in structure.Columns)
                {
                    var property = kvp.Key;
                    var column = kvp.Value;

                    // 检查 Independent 特性。
                    if (structure.Independent && column.Independent) continue;

                    // 字段。
                    var type = GetColumnDeclaration(column);
                    if (type.IsEmpty()) return TextUtility.Merge("类型 ", column.Type.ToString(), " 不受支持。");
                    columns.Add(type);
                    columnsAdded++;

                    // 主键。
                    if (property == "Key") primarykey = column.Field;
                }
                columns.Capacity = columnsAdded;
                var table = structure.Table;
                var joined = string.Join(", ", columns);

                // 设置主键。
                string sql;
                if (!structure.Independent && !string.IsNullOrEmpty(primarykey))
                {
                    sql = TextUtility.Merge("create table `", table, "`(", joined, ", primary key (", primarykey, ") ) engine=innodb default charset=utf8mb4; ");
                }
                else
                {
                    sql = TextUtility.Merge("create table `", table, "`(", joined, ") engine=innodb default charset=utf8mb4; ");
                }

                return sql;
            }
        }

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

            var structure = null as TableStructure;
            try { structure = TableStructure.ParseModel(model); }
            catch (Exception exception)
            {
                sql = "";
                return exception.Message;
            }

            // 连接数据库。
            if (!Connect())
            {
                sql = "";
                return "连接数据库失败。";
            }

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

        /// <summary></summary>
        public string CreateTable(Type model)
        {
            return CreateTable(model, out string sql);
        }

        /// <summary></summary>
        public string CreateTable<T>() where T : Record
        {
            return CreateTable(typeof(T));
        }

        /// <summary></summary>
        public string CreateTable(Record model)
        {
            if (model == null) return "参数无效。";
            return CreateTable(model.GetType());
        }

        /// <summary>插入记录。成功时候返回空字符串，发生异常时返回异常信息。</summary>
        public string Insert(Record entity, bool resetKey = false)
        {
            if (entity == null) return "参数无效。";
            entity.FixProperties();
            if (resetKey) entity.ResetKey();

            var structure = null as TableStructure;
            try { structure = TableStructure.ParseModel(entity); }
            catch (Exception exception) { return exception.Message; }

            var parameters = structure.CreateDataParameters(entity, CreateDataParameter);
            var sql = GenerateInsertStatement(structure.Table, parameters);
            var execute = Execute(sql, parameters);
            if (execute.Success) return TextUtility.EmptyString;
            return execute.Error;
        }

        /// <summary>
        /// <para>更新记录，实体中的 Created 和 Key 属性不被更新。成功时返回空字符串，发生异常时返回异常信息。</para>
        /// <para>无法更新拥有 Independent 特性的模型。</para>
        /// </summary>
        public string Update(Record entity)
        {
            if (entity == null) return "参数无效。";
            entity.FixProperties();
            entity.Updated = ClockUtility.LucidNow;

            var structure = null as TableStructure;
            try { structure = TableStructure.ParseModel(entity); }
            catch (Exception exception) { return exception.Message; }

            // 检查 Independent 特性。
            if (structure.Independent) return "无法更新拥有 Independent 特性的模型。";

            var parameters = structure.CreateDataParameters(entity, CreateDataParameter, "_created", "_key");
            var sql = GenerateUpdateStatement(structure, entity.Key, parameters);
            var execute = Execute(sql, parameters);
            if (execute.Success) return TextUtility.EmptyString;
            return execute.Error;
        }

        /// <summary></summary>
        public Result<List<T>> QueryRecords<T>(string sql) where T : Record
        {
            if (sql.IsEmpty()) return new Result<List<T>>(new ArgumentException());
            try
            {
                // 解析模型，抛出 Exception。
                TableStructure.ParseModel(typeof(T));

                var query = Query(sql) as Query;
                var list = query.Fill<T>();
                query.Dispose();
                return new Result<List<T>>(list);
            }
            catch (Exception exception)
            {
                return new Result<List<T>>(exception);
            }
        }

        /// <summary>获取记录。</summary>
        public Result<T> QueryRecord<T>(string key, long flag = 0) where T : Record
        {
            var k = TextUtility.SafeKey(key);
            if (k.IsEmpty()) new Result<T>(new Exception("参数无效。"));
            try
            {
                var structure = TableStructure.ParseModel(typeof(T));
                var sqlflag = (flag == 0) ? TextUtility.EmptyString : TextUtility.Merge(" `_flag`=", flag.ToString(), " and");
                var sqlkey = TextUtility.Merge(" `_key`='", k, "'");
                var sql = TextUtility.Merge("select * from `", structure.Table, "` where ", sqlflag, sqlkey, " limit 1;");
                var result = QueryRecords<T>(sql);
                var list = result.Entity;
                if (list != null && list.Count > 0) return new Result<T>(list[0]);
                return new Result<T>(null, "无结果。");
            }
            catch (Exception exception)
            {
                return new Result<T>(exception);
            }
        }

        /// <summary>获取所有记录。Flag 为 0 时将忽略 Flag 条件。</summary>
        public Result<List<T>> QueryRecords<T>(long flag = 0) where T : Record
        {
            try
            {
                var structure = TableStructure.ParseModel(typeof(T));
                var sqlflag = (flag == 0) ? TextUtility.EmptyString : TextUtility.Merge(" where `_flag`=", flag.ToString());
                var sql = TextUtility.Merge("select * from `", structure.Table, "`", sqlflag, "; ");
                return QueryRecords<T>(sql);
            }
            catch (Exception exception)
            {
                return new Result<List<T>>(exception);
            }
        }

        /// <summary>获取记录。</summary>
        /// <param name="skip">要跳过的记录数，可用最小值为 0。</param>
        /// <param name="count">要获取的记录数，可用最小值为 1。</param>
        public Result<List<T>> QueryRecords<T>(int skip, int count) where T : Record
        {
            try
            {
                if (skip < 0) return new Result<List<T>>(new ArgumentOutOfRangeException(nameof(skip)));
                if (count < 1) return new Result<List<T>>(new ArgumentOutOfRangeException(nameof(count)));
                var tableName = TableStructure.ParseTable(typeof(T)).Name;
                var sql = $"select * from `{tableName}` where _flag = 1 limit {skip}, {count}; ";
                return QueryRecords<T>(sql);
            }
            catch (Exception exception)
            {
                return new Result<List<T>>(exception);
            }
        }

        /// <summary>查询有效的 Key 值。</summary>
        public Result<List<string>> QueryKeys(Type model, long flag = 0)
        {
            if (model != null)
            {
                try
                {
                    var type = model;
                    var ts = TableStructure.ParseModel(type);
                    var sqlflag = (flag == 0) ? TextUtility.EmptyString : TextUtility.Merge(" where `_flag`=", flag.ToString());
                    var sql = TextUtility.Merge("select `_key` from `", ts.Table, "`", sqlflag, "; ");
                    using (var query = Query(sql) as Query)
                    {
                        var list = query.ReadColumn((r) => TextUtility.Trim(query.Text(r, 0)));
                        return new Result<List<string>>(list);
                    }
                }
                catch (Exception ex)
                {
                    return new Result<List<string>>(ex);
                }
            }
            return new Result<List<string>>(new Exception("参数无效。"));
        }

        /// <summary>查询有效的 Key 值。</summary>
        public Result<List<string>> QueryKeys<T>(long flag = 0) where T : Record
        {
            try
            {
                var type = typeof(T);

                var ts = TableStructure.ParseModel(type);
                var sqlflag = (flag == 0) ? TextUtility.EmptyString : TextUtility.Merge(" where _flag=", flag.ToString());
                var sql = TextUtility.Merge("select `_key` from `", ts.Table, "`", sqlflag, "; ");
                using (var query = Query(sql) as Query)
                {
                    var list = query.ReadColumn((r) => TextUtility.Trim(query.Text(r, 0)));
                    return new Result<List<string>>(list);
                }
            }
            catch (Exception ex)
            {
                return new Result<List<string>>(ex);
            }
        }

        /// <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 : Record
        {
            var columnName = SafeColumn(column);
            if (columnName.IsEmpty()) return "列名无效。";

            var tableName = TableStructure.ParseTable(typeof(T)).Name;

            var columeType = "";
            switch (type)
            {
                case ColumnType.Integer:
                    columeType = "bigint";
                    break;
                case ColumnType.Float:
                    columeType = "double";
                    break;
                case ColumnType.Binary:
                    columeType = "longblob";
                    break;
                case ColumnType.DateTime:
                    columeType = "datetime";
                    break;
                case ColumnType.VarChar:
                case ColumnType.NVarChar:
                    columeType = $"varchar({length})";
                    break;
                case ColumnType.VarChar255:
                case ColumnType.NVarChar255:
                    columeType = "varchar(255)";
                    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.Error;
            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.GetBytes(Encoding.UTF8).Length > bytes)
                {
                    while (true)
                    {
                        t = t.Substring(0, t.Length - 1);
                        if (t.GetBytes(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.RestrictCharacters(table, chars).SafeLower();
            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 CreateDataParameter(Parameter parameter)
        {
            if (parameter == null) throw new InvalidOperationException("参数无效。");
            return CreateDataParameter(parameter.Name, parameter.Type, parameter.Size, parameter.Value);
        }

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

            var dbtype = MySqlDbType.Int64;
            switch (type)
            {
                case ColumnType.Binary:
                    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.VarChar255:
                case ColumnType.VarCharMax:
                case ColumnType.NVarChar:
                case ColumnType.NVarChar255:
                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.RestrictValue(size, 0, 65535);
                    break;
                case ColumnType.VarChar255:
                case ColumnType.NVarChar255:
                    size = NumberUtility.RestrictValue(size, 0, 255);
                    break;
                default:
                    size = 0;
                    break;
            }

            if (value is string && value != null && size > 0)
            {
                value = TextUtility.RestrictLength((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 CreateDataParameter(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 GetColumnDeclaration(ColumnAttribute column)
        {
            var type = TextUtility.EmptyString;
            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.Binary:
                    type = "longblob";
                    break;
                case ColumnType.DateTime:
                    type = "datetime";
                    break;
                case ColumnType.VarChar:
                    type = TextUtility.Merge("varchar(", Math.Max(65535, length).ToString(), ")");
                    break;
                case ColumnType.VarChar255:
                    type = TextUtility.Merge("varchar(255)");
                    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.NVarChar255:
                    type = TextUtility.Merge("varchar(255)");
                    break;
                case ColumnType.NVarCharMax:
                    type = TextUtility.Merge("varchar(65535)");
                    break;
                case ColumnType.NText:
                    type = TextUtility.Merge("longtext");
                    break;
                default:
                    return TextUtility.EmptyString;
            }
            return TextUtility.Merge("`", (string)column.Field, "` ", type);
        }

        private static string GetParameterName(string parameter)
        {
            var name = TextUtility.AntiInject(parameter, 255);
            if (name.StartsWith("@") && name.Length > 1)
            {
                name = name.Substring(1, name.Length - 1);
            }
            return name;
        }

        private static string GetParameterName(IDataParameter parameter)
        {
            var name = TextUtility.EmptyString;
            if (parameter != null)
            {
                name = GetParameterName(parameter.ParameterName);
            }
            return name;
        }

        private static List<string> GetParametersNames(IEnumerable<IDataParameter> parameters)
        {
            var columns = new List<string>();
            if (parameters != null)
            {
                columns.Capacity = RuntimeUtility.Count(parameters);
                var columnsAdded = 0;
                foreach (var parameter in parameters)
                {
                    var name = GetParameterName(parameter);
                    var isblank = TextUtility.IsBlank(name);
                    if (isblank) continue;
                    columns.Add(name);
                    columnsAdded++;
                }
                columns.Capacity = columnsAdded;
            }
            return columns;
        }

        private static string GenerateInsertStatement(string table, List<string> columns)
        {
            var sql = TextUtility.EmptyString;
            var tn = TextUtility.AntiInject(table, 255);
            if (columns != null && !TextUtility.IsBlank(tn))
            {
                var count = columns.Count;
                var names = new List<string>(count);
                var values = new List<string>(count);
                foreach (var column in columns)
                {
                    if (string.IsNullOrEmpty(column)) continue;
                    names.Add($"`{column}`");
                    values.Add($"@{column}");
                }

                var ns = string.Join(", ", names);
                var vs = string.Join(", ", values);

                sql = $"insert into `{tn}` ({ns}) values ({vs}); ";

                // var sb = new StringBuilder();
                // if (columns.Count > 0)
                // {
                //     sb.Append("insert into `");
                //     sb.Append(tn);
                //     sb.Append("` (");
                //     for (var i = 0; i < columns.Count; i++)
                //     {
                //         if (i > 0) sb.Append(", ");
                //         sb.Append("`");
                //         sb.Append(columns[i]);
                //         sb.Append("`");
                //     }
                //     sb.Append(") values (");
                //     for (var i = 0; i < columns.Count; i++)
                //     {
                //         if (i > 0) sb.Append(", ");
                //         sb.Append("@");
                //         sb.Append(columns[i]);
                //     }
                //     sb.Append("); ");
                // }
                // sql = sb.ToString();
            }
            return sql;
        }

        private static string GenerateUpdateStatement(TableStructure structure, string key, List<string> columns)
        {
            var result = TextUtility.EmptyString;

            var table = TextUtility.AntiInject(structure.Table, 255);
            if (TextUtility.IsEmpty(table)) return result;

            var safekey = TextUtility.AntiInject(key, 255);
            if (TextUtility.IsEmpty(safekey)) return result;

            var count = columns == null ? -1 : columns.Count;
            if (count < 1) return result;

            var items = new List<string>(count);
            foreach (var column in columns)
            {
                items.Add(TextUtility.Merge("`", column, "`=@", column));
            }
            result = TextUtility.Merge("update `", table, "` set ", string.Join(", ", items), " where `_key`='", safekey, "'; ");
            return result;
        }

        /// <summary>生成 INSERT INTO 语句。表名必须有效，无有效参数时将获取空结果。</summary>
        /// <exception cref="System.ArgumentException"></exception>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static string GenerateInsertStatement(string table, IEnumerable<IDataParameter> parameters)
        {
            if (table == null) throw new ArgumentNullException("table");
            var tableName = TextUtility.AntiInject(table, 255);
            if (TextUtility.IsBlank(tableName)) throw new ArgumentException("表名无效。", "table");

            var columns = GetParametersNames(parameters);
            if (columns.Count < 1) return TextUtility.EmptyString;

            return GenerateInsertStatement(tableName, columns);
        }

        /// <summary>生成 UPDATE 语句，键字段名为“_key”。表名必须有效，键值必须有效，无有效参数时将获取空结果。</summary>
        /// <exception cref="System.ArgumentException"></exception>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static string GenerateUpdateStatement(TableStructure structure, string key, IEnumerable<IDataParameter> parameters)
        {
            if (structure == null) throw new ArgumentNullException("structure");
            if (key == null) throw new ArgumentNullException("key");

            var table = TextUtility.AntiInject(structure.Table, 255);
            if (TextUtility.IsBlank(table)) throw new ArgumentException("表名无效。", "structure");

            var safekey = TextUtility.AntiInject(key, 255);
            if (TextUtility.IsBlank(safekey)) throw new ArgumentException("键值无效。", "key");

            var columns = GetParametersNames(parameters);
            if (columns.Count < 1) return TextUtility.EmptyString;

            return GenerateUpdateStatement(structure, safekey, columns);
        }

        /// <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())
            {
                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 = TextUtility.GetInt64(query.Text(r, "data_length")) + TextUtility.GetInt64(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