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

/* 2021.11.07 */

using Apewer;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Text;

using static Apewer.Source.SourceUtility;
using System.Data.SqlClient;

#if NETFRAMEWORK
using System.Data.Sql;
#endif

namespace Apewer.Source
{

    /// <summary></summary>
    [Serializable]
    public class SqlClient : IDbClient
    {

        #region 变量、构造函数

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

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

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

        /// <summary>使用连接字符串创建数据库连接实例。</summary>
        public SqlClient(string connectionString, Timeout timeout = null)
        {
            _timeout = timeout ?? Timeout.Default;
            _connectionstring = connectionString ?? "";
        }

        /// <summary>使用连接凭据创建数据库连接实例。</summary>
        public SqlClient(string address, string store, string user, string pass, Timeout timeout = null)
        {
            if (timeout == null) timeout = Timeout.Default;

            var a = address ?? "";
            var s = store ?? "";
            var u = user ?? "";
            var p = pass ?? "";
            var cs = $"data source = {a}; initial catalog = {s}; ";
            if (string.IsNullOrEmpty(u)) cs += "integrated security = sspi; ";
            else
            {
                cs += $"user id = {u}; ";
                if (!string.IsNullOrEmpty(p)) cs += $"password = {p}; ";
            }
            cs += $"connection timeout = {timeout.Connect}; ";

            _timeout = timeout ?? Timeout.Default;
            _connectionstring = cs;
        }

        #endregion

        #region Ado - Connection

        private SqlConnection _db = null;

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

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

        /// <summary>数据库是否已经连接。</summary>
        public bool Online
        {
            get
            {
                if (_db == null) return false;
                return (_db.State == ConnectionState.Open);
            }
        }

        /// <summary>连接数据库，若未连接则尝试连接，获取连接成功的状态。</summary>
        public string Connect()
        {
            if (_db == null)
            {
                _db = new SqlConnection();
                _db.ConnectionString = _connectionstring;
            }
            else
            {
                if (_db.State == ConnectionState.Open) return null;
            }
            try
            {
                _db.Open();
                switch (_db.State)
                {
                    case ConnectionState.Open: return null;
                    default: return $"连接失败，当前处于 {_db.State} 状态。";
                }
            }
            catch (Exception ex)
            {
                Logger.Error(nameof(SqlClient), "Connection", ex, _db.ConnectionString);
                Close();
                return ex.Message;
            }
        }

        /// <summary>关闭连接，并释放对象所占用的系统资源。</summary>
        public void Close()
        {
            if (_db != null)
            {
                if (_transaction != null)
                {
                    if (_autocommit) Commit();
                    else Rollback();
                }
                _db.Close();
                _db.Dispose();
                _db = null;
            }
        }

        /// <summary>关闭连接，释放对象所占用的系统资源，并清除连接信息。</summary>
        public void Dispose() => Close();

        #endregion

        #region Ado - 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<IsolationLevel> isolation)
        {
            var connect = Connect();
            if (connect.NotEmpty()) return connect;
            if (_transaction != null) return "存在已启动的事务，无法再次启动。";
            try
            {
                _transaction = isolation ? _db.BeginTransaction(isolation.Value) : _db.BeginTransaction();
                _autocommit = commit;
                return null;
            }
            catch (Exception ex)
            {
                Logger.Error(nameof(SqlClient), "Begin", 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(SqlClient), "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(SqlClient), "Rollback", ex.Message);
                return ex.Message();
            }
        }

        #endregion

        #region Ado - SQL

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

        /// <summary>查询。</summary>
        public IQuery Query(string sql, IEnumerable<IDataParameter> parameters)
        {
            if (TextUtility.IsBlank(sql)) return Example.InvalidQueryStatement;
            var connected = Connect();
            if (connected.NotEmpty()) return new Query(false, connected);

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

        /// <summary>执行。</summary>
        public IExecute Execute(string sql) => Execute(sql, null);

        /// <summary>执行单条 Transact-SQL 语句，并加入参数。</summary>
        public IExecute Execute(string sql, IEnumerable<IDataParameter> parameters)
        {
            if (TextUtility.IsBlank(sql)) 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 SqlCommand())
                {
                    command.Connection = _db;
                    command.Transaction = (SqlTransaction)_transaction;
                    command.CommandTimeout = _timeout.Execute;
                    command.CommandText = sql;
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            if (parameter != null) command.Parameters.Add(parameter);
                        }
                    }
                    var rows = command.ExecuteNonQuery();
                    if (!inTransaction) Commit(); // todo 此处应该检查事务提交产生的错误。
                    return new Execute(true, rows);
                }
            }
            catch (Exception exception)
            {
                Logger.Error(nameof(SqlClient), "Execute", exception, sql);
                if (!inTransaction) Rollback();
                return new Execute(exception);
            }
        }

        #endregion

        #region ORM

        /// <summary>查询数据库中的所有表名。</summary>
        public string[] TableNames()
        {
            var list = new List<string>();
            if (Connect().IsEmpty())
            {
                var sql = "select [name] from [sysobjects] where [type] = 'u' order by [name]; ";
                var query = (Query)Query(sql);
                for (int r = 0; r < query.Rows; r++)
                {
                    var cell = query.Text(r, 0);
                    if (TextUtility.IsBlank(cell)) continue;
                    list.Add(cell);
                }
                query.Dispose();
            }
            return list.ToArray();
        }

        /// <summary>查询数据库实例中的所有数据库名。</summary>
        public string[] StoreNames()
        {
            var list = new List<string>();
            if (Connect().IsEmpty())
            {
                var sql = "select [name] from [master]..[sysdatabases] order by [name]; ";
                var query = (Query)Query(sql);
                for (int r = 0; r < query.Rows; r++)
                {
                    var cell = query.Text(r, 0);
                    if (TextUtility.IsBlank(cell)) continue;
                    if (cell == "master") continue;
                    if (cell == "model") continue;
                    if (cell == "msdb") continue;
                    if (cell == "tempdb") continue;
                    list.Add(cell);
                }
                query.Dispose();
            }
            return list.ToArray();
        }

        /// <summary>查询表中的所有列名。</summary>
        public string[] ColumnNames(string tableName)
        {
            var list = new List<string>();
            if (Connect().IsEmpty())
            {
                var table = TextUtility.AntiInject(tableName);
                var sql = TextUtility.Merge("select [name] from [syscolumns] where [id] = object_id('", table, "'); ");
                var query = (Query)Query(sql);
                for (int r = 0; r < query.Rows; r++)
                {
                    var cell = query.Text(r, 0);
                    if (TextUtility.IsBlank(cell)) continue;
                    list.Add(cell);
                }
                query.Dispose();
            }
            return list.ToArray();
        }

        static string XType(int xtype)
        {
            switch (xtype)
            {
                case 34: return "image";
                case 35: return "text";
                case 36: return "uniqueidentifier";
                case 48: return "tinyint";
                case 52: return "smallint";
                case 56: return "int";
                case 58: return "smalldatetime";
                case 59: return "real";
                case 60: return "money";
                case 61: return "datetime";
                case 62: return "float";
                case 98: return "sql_variant";
                case 99: return "ntext";
                case 104: return "bit";
                case 106: return "decimal";
                case 108: return "numeric";
                case 122: return "smallmoney";
                case 127: return "bigint";
                case 165: return "varbinary";
                case 167: return "varchar";
                case 173: return "binary";
                case 175: return "char";
                case 189: return "timestamp";
                case 231: return "nvarchar";
                case 239: return "nchar";
                case 241: return "xml";
            }
            return null;
        }

        /// <summary>获取列信息。</summary>
        public ColumnInfo[] ColumnsInfo(string tableName)
        {
            if (tableName.IsEmpty()) throw new ArgumentNullException(nameof(tableName));
            var sql = $"select name, xtype, length from syscolumns where id = object_id('{tableName}') ";
            using (var query = Query(sql))
            {
                var ab = new ArrayBuilder<ColumnInfo>();
                for (var i = 0; i < query.Rows; i++)
                {
                    var info = new ColumnInfo();
                    info.Name = query.Text(i, "name");
                    info.Type = XType(query.Int32(i, "xtype"));
                    info.Length = query.Int32(i, "length");
                    ab.Add(info);
                }
                return ab.Export();
            }
        }

        /// <summary>创建表，当表不存在时创建表，当现存表中缺少模型中属性对应的列时增加列。成功时返回空字符串，发生异常时返回异常信息。</summary>
        public string Initialize<T>() where T : class, new() => Initialize(typeof(T));

        /// <summary>创建表，当表不存在时创建表，当现存表中缺少模型中属性对应的列时增加列。成功时返回空字符串，发生异常时返回异常信息。</summary>
        public string Initialize(Type model)
        {
            var structure = TableStructure.Parse(model);
            if (structure == null) return "无法解析记录模型。";

            // 连接数据库。
            var connect = Connect();
            if (connect.NotEmpty()) return connect;

            // 检查现存表。
            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>();
                    foreach (var column in columns)
                    {
                        if (TextUtility.IsBlank(column)) continue;
                        lower.Add(column.ToLower());
                    }
                    columns = lower.ToArray();
                }

                // 增加列。
                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 (string.IsNullOrEmpty(type)) return TextUtility.Merge("类型 ", column.Type.ToString(), " 不受支持。");

                    var sql = TextUtility.Merge("alter table [", structure.Name, "] add ", type, "; ");
                    var execute = Execute(sql);
                    if (execute.Success == false) return execute.Message;
                }
                return TextUtility.Empty;
            }
            else
            {
                var sqlcolumns = new List<string>();
                foreach (var column in structure.Columns)
                {
                    // 检查 Independent 特性。
                    if (structure.Independent && column.Independent) continue;

                    var type = Declaration(column);
                    if (!column.Independent && column.Property.Name == "Key") type = type + " primary key";

                    if (string.IsNullOrEmpty(type)) return TextUtility.Merge("类型 ", column.Type.ToString(), " 不受支持。");
                    sqlcolumns.Add(type);
                }
                var sql = TextUtility.Merge("create table [", structure.Name, "](", string.Join(", ", sqlcolumns.ToArray()), "); ");
                var execute = Execute(sql);
                if (execute.Success) return TextUtility.Empty;
                return execute.Message;
            }
        }

        /// <summary>插入记录。返回错误信息。</summary>
        public string Insert(object record, string table = null)
        {
            if (record == null) return "参数无效。";
            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 ps = structure.CreateParameters(record, Parameter);
            var psc = ps.Length;
            if (psc < 1) return "数据模型不包含字段。";

            var names = new List<string>(psc);
            var values = new List<string>(psc);
            foreach (var column in ps)
            {
                //names.Add(TextGenerator.Merge("[", column, "]"));
                names.Add(TextUtility.Merge(column));
                values.Add("@" + column);
            }
            var sb = new StringBuilder();
            sb.Append("insert into [", table, "](", string.Join(", ", names.ToArray()), ") ");
            sb.Append("values(", string.Join(", ", values.ToArray()), "); ");
            var sql = sb.ToString();

            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 ps = structure.CreateParameters(record, Parameter, "_key");
            var psc = ps.Length;
            if (psc < 1) return "数据模型不包含字段。";

            var items = new List<string>();
            foreach (var p in ps)
            {
                var pn = p.ParameterName;
                items.Add(TextUtility.Merge("[", pn, "] = @", pn));
            }
            var key = record.Key.SafeKey();
            var sql = TextUtility.Merge("update [", table, "] set ", string.Join(", ", items.ToArray()), " 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>获取记录。</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>获取记录。</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>获取具有指定 Key 的记录。</summary>
        public Result<object> Get(Type model, string key, long flag = 0) => SourceUtility.Get(this, model, key, (tn, sk) =>
        {
            if (flag == 0) return $"select top 1 * from [{tn}] _key='{sk}'; ";
            return $"select top 1 * from [{tn}] where _key='{sk}' and _key='{sk}'; ";
        });

        /// <summary>获取具有指定 Key 的记录。</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 top 1 * from [{tn}] _key='{sk}'; ";
            return $"select top 1 * from [{tn}] where _key='{sk}' and _key='{sk}'; ";
        });

        /// <summary>查询有效的 Key 值。</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>查询有效的 Key 值。</summary>
        public Result<string[]> Keys<T>(long flag = 0) where T : class, IRecord, new() => Keys(typeof(T), flag);

        #endregion

        #region public static

#if NET20 || NET40

        /// <summary>枚举本地网络中服务器的名称。</summary>
        public static SqlServerSource[] EnumerateServer()
        {
            var list = new List<SqlServerSource>();

            // 表中列名：ServerName、InstanceName、IsClustered、Version。
            using (var query = new Query(SqlDataSourceEnumerator.Instance.GetDataSources()))
            {
                for (int i = 0; i < query.Rows; i++)
                {
                    var item = new SqlServerSource();
                    item.ServerName = query.Text(i, "ServerName");
                    list.Add(item);
                }
            }
            return list.ToArray();
        }

#endif

        /// <summary>指定的连接凭据是否符合连接要求，默认指定 master 数据库。</summary>
        public static bool Proven(string address, string user, string pass) => Proven(address, "master", user, pass);

        /// <summary>指定的连接凭据是否符合连接要求。</summary>
        public static bool Proven(string address, string store, string user, string pass)
        {
            var a = string.IsNullOrEmpty(address);
            var s = string.IsNullOrEmpty(store);
            var u = string.IsNullOrEmpty(user);
            var p = string.IsNullOrEmpty(pass);
            if (a) return false;
            if (s) return false;
            if (u && !p) return false;
            return true;
        }

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

        /// <summary>创建参数。</summary>
        public static SqlParameter Parameter(string name, ColumnType type, int size, object value)
        {
            var vname = TextUtility.Trim(name);
            if (TextUtility.IsBlank(vname)) return null;

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

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

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

            var parameter = new SqlParameter();
            parameter.ParameterName = vname;
            parameter.SqlDbType = vtype;
            parameter.Value = vvalue;
            if (vsize > 0) parameter.Size = vsize;
            return parameter;
        }

        /// <summary>创建参数。</summary>
        public static SqlParameter Parameter(string name, SqlDbType type, int size, object value)
        {
            if (value is string && value != null && size > 0)
            {
                value = TextUtility.Left((string)value, (int)size);
            }

            var p = new SqlParameter();
            p.ParameterName = name ?? "";
            p.SqlDbType = type;
            p.Size = size;
            p.Value = value;
            return p;
        }

        /// <summary>创建参数。</summary>
        public static SqlParameter Parameter(string name, SqlDbType type, object value)
        {
            var p = new SqlParameter();
            p.ParameterName = name ?? "";
            p.SqlDbType = type;
            p.Value = value;
            return p;
        }

        static string Declaration(ColumnAttribute column)
        {
            var type = TextUtility.Empty;
            var vcolumn = column;
            var length = Math.Max(0, vcolumn.Length);
            switch (vcolumn.Type)
            {
                case ColumnType.Integer:
                    type = "bigint";
                    break;
                case ColumnType.Float:
                    type = "float";
                    break;
                case ColumnType.Bytes:
                    type = "image";
                    break;
                case ColumnType.DateTime:
                    type = "datetime";
                    break;
                case ColumnType.VarChar:
                    type = TextUtility.Merge("varchar(", Math.Min(8000, 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("text");
                    break;
                case ColumnType.NVarChar:
                    type = TextUtility.Merge("nvarchar(", Math.Min(4000, length).ToString(), ")");
                    break;
                case ColumnType.NVarChar191:
                    type = TextUtility.Merge("nvarchar(191)");
                    break;
                case ColumnType.NVarCharMax:
                    type = TextUtility.Merge("nvarchar(max)");
                    break;
                case ColumnType.NText:
                    type = TextUtility.Merge("ntext");
                    break;
                default:
                    return TextUtility.Empty;
            }
            return TextUtility.Merge("[", vcolumn.Field, "] ", type);
        }

        #endregion

    }

}