You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1001 lines
37 KiB

#if NET40 || NET461
using Apewer;
using Apewer.Source;
using Externals.MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.Common;
using System.Text;
using System.Windows.Forms;
using System.Windows.Media.Animation;
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 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)
{
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 tsql, IEnumerable<IDataParameter> parameters)
{
if (tsql.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 = tsql;
if (parameters != null)
{
foreach (var parameter in parameters)
{
if (parameter == null) continue;
command.Parameters.Add(parameter);
}
}
using (var ds = new DataSet())
{
using (var da = new MySqlDataAdapter(tsql, _connection))
{
da.Fill(ds, table);
query.Table = ds.Tables[table];
}
}
command.Dispose();
query.Success = true;
}
catch (Exception exception)
{
query.Success = false;
query.Exception = exception;
}
return query;
}
/// <summary></summary>
public IExecute Execute(string tsql, IEnumerable<IDataParameter> parameters)
{
if (tsql.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 = tsql;
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)
{
try { transaction.Rollback(); } catch { }
execute.Success = false;
execute.Exception = exception;
}
try { transaction.Dispose(); } catch { }
return execute;
}
/// <summary></summary>
public IQuery Query(string tsql)
{
return Query(tsql, null);
}
/// <summary></summary>
public IExecute Execute(string tsql, IEnumerable<Parameter> parameters)
{
var dps = null as List<IDataParameter>;
if (parameters != null)
{
var count = ClassUtility.Count(parameters);
dps = new List<IDataParameter>(count);
foreach (var p in parameters)
{
var dp = CreateDataParameter(p);
dps.Add(dp);
}
}
return Execute(tsql, dps);
}
/// <summary></summary>
public IExecute Execute(string tsql)
{
return Execute(tsql, 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) Record.ResetKey(entity);
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.Lucid;
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 tsql) where T : Record
{
if (tsql.IsEmpty()) return new Result<List<T>>(new ArgumentException());
try
{
// 解析模型,抛出 Exception。
TableStructure.ParseModel(typeof(T));
var query = Query(tsql) 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.RestrictGuid(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 argException)
{
return new Result<List<string>>(argException);
}
}
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 argParameter)
{
var name = TextUtility.AntiInject(argParameter, 255);
if (name.StartsWith("@") && name.Length > 1)
{
name = name.Substring(1, name.Length - 1);
}
return name;
}
private static string GetParameterName(IDataParameter argParameter)
{
var name = TextUtility.EmptyString;
if (argParameter != null)
{
name = GetParameterName(argParameter.ParameterName);
}
return name;
}
private static List<string> GetParametersNames(IEnumerable<IDataParameter> argParameters)
{
var columns = new List<string>();
if (argParameters != null)
{
columns.Capacity = ClassUtility.Count(argParameters);
var columnsAdded = 0;
foreach (var parameter in argParameters)
{
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 argTable, IEnumerable<IDataParameter> parameters)
{
if (argTable == null) throw new ArgumentNullException("argTable");
var table = TextUtility.AntiInject(argTable, 255);
if (TextUtility.IsBlank(table)) throw new ArgumentException("表名无效。", "argTable");
var columns = GetParametersNames(parameters);
if (columns.Count < 1) return TextUtility.EmptyString;
return GenerateInsertStatement(table, 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