internal override int ExecuteMultiCommands(IDbCommand[] dbcommands, SafeLevel level)
{
int rInt = 0;
if (_isTransaction)
{
foreach (IDbCommand dbcommand in dbcommands)
{
_trconnection.SetupCommand(dbcommand);
rInt += dbcommand.ExecuteNonQuery();
}
}
else
{
TransactionConnection transaction = GetTransactionConnection();
transaction.ResetTransaction(level);
try {
foreach (IDbCommand dbcommand in dbcommands)
{
transaction.SetupCommand(dbcommand);
rInt += dbcommand.ExecuteNonQuery();
}
transaction.Commit();
}
catch (Exception ex) {
transaction.Rollback();
throw ex;
}
}
return(rInt);
}
internal virtual int ExecuteMultiCommands(IDbCommand[] dbcommands, SafeLevel level)
{
if (level == SafeLevel.None)
{
level = SafeLevel.Default;
}
int rInt = 0;
using (TransactionConnection transaction = CreateTransactionConnection(level))
{
transaction.Open();
try
{
foreach (IDbCommand dbcommand in dbcommands)
{
transaction.SetupCommand(dbcommand);
rInt += dbcommand.ExecuteNonQuery();
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(rInt);
}
internal override DataSet QueryDataSet(IDbCommand dbcommand, SafeLevel level)
{
DataSet ds = new DataSet();
if (_isTransaction)
{
_trconnection.SetupCommand(dbcommand);
IDbDataAdapter adapter = _dataBase.CreateDataAdapter(dbcommand);
adapter.Fill(ds);
}
else
{
TransactionConnection transaction = GetTransactionConnection();
transaction.ResetTransaction(level);
try {
transaction.SetupCommand(dbcommand);
IDbDataAdapter adapter = _dataBase.CreateDataAdapter(dbcommand);
adapter.Fill(ds);
transaction.Commit();
}
catch (Exception ex) {
transaction.Rollback();
throw ex;
}
}
return(ds);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="parameters">参数</param>
/// <param name="commandType">命令类型</param>
/// <param name="level">安全级别</param>
/// <param name="context">数据库上下文</param>
internal SqlExecutor(string sql, DataParameter[] parameters, CommandType commandType, SafeLevel level, DataContext context)
{
_level = level;
_context = context;
_command = context.DataBase.CreateCommand(sql);
_command.CommandType = commandType;
if (parameters != null)
{
foreach (DataParameter param in parameters)
{
string parameterName = param.ParameterName;
if (parameterName.StartsWith("@") && parameterName.Length > 1)
{
parameterName = parameterName.Substring(1);
}
IDataParameter dataParameter = context.DataBase.CreateParameter(parameterName, param.Value, param.DbType, param.Direction);
param.SetDataParameter(dataParameter);
_command.Parameters.Add(dataParameter);
if (commandType == CommandType.Text)
{
_command.CommandText = _command.CommandText.Replace(param.ParameterName, dataParameter.ParameterName);
}
else if (commandType == CommandType.StoredProcedure)
{
context.DataBase.FormatStoredProcedureParameter(dataParameter);
}
}
}
}
internal override object ExecuteScalar(IDbCommand dbcommand, SafeLevel level)
{
object result = null;
if (_isTransaction)
{
_trconnection.SetupCommand(dbcommand);
result = dbcommand.ExecuteScalar();
}
else
{
TransactionConnection transaction = GetTransactionConnection();
transaction.ResetTransaction(level);
try {
transaction.SetupCommand(dbcommand);
result = dbcommand.ExecuteScalar();
transaction.Commit();
}
catch (Exception ex) {
transaction.Rollback();
throw ex;
}
}
return(result);
}
/// <summary>
/// 重置条件语句
/// </summary>
/// <returns> 枚举查询器</returns>
public LEnumerable <T> Reset()
{
_query = null;
_order = null;
_region = null;
_level = SafeLevel.Default;
return(this);
}
private async Task <int> CheckDbSaveAsync(bool refresh, SafeLevel level, CancellationToken cancellationToken = default)
{
var context = GetContext();
var mapping = DataEntityMapping.GetTableMapping(GetType());
var ret = await context.InsertOrUpdateAsync(mapping, this, level, refresh, cancellationToken);
return(ret);
}
/// <summary>
/// 重置条件语句
/// </summary>
/// <returns>统计表生成器</returns>
public AggregateTable <T> Reset()
{
_query = null;
_order = null;
_having = null;
_level = SafeLevel.Default;
return(this);
}
private int CheckDbSave(bool refresh, SafeLevel level)
{
var context = GetContext();
var mapping = DataEntityMapping.GetTableMapping(GetType());
var ret = context.InsertOrUpdate(mapping, this, level, refresh);
return(ret);
}
public LightSelectField(DataContext context, LambdaExpression expression, QueryExpression query, OrderExpression order, bool distinct, Region region, SafeLevel level)
: base(context, expression)
{
_query = query;
_order = order;
_distinct = distinct;
_region = region;
_level = level;
}
protected LightSelectJoin(DataContext context, LambdaExpression expression, List <IJoinModel> models, List <IMap> maps, QueryExpression query, OrderExpression order, bool distinct, Region region, SafeLevel level)
: base(context, expression, models, maps)
{
_query = query;
_order = order;
_distinct = distinct;
_region = region;
_level = level;
}
private int CheckDbSave(bool refresh, SafeLevel level)
{
DataContext context = GetContext();
int ret;
DataTableEntityMapping mapping = DataEntityMapping.GetTableMapping(this.GetType());
ret = context.InsertOrUpdate(mapping, this, level, refresh);
return(ret);
}
public TransactionConnection(IDbConnection connection, SafeLevel level)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
_connection = connection;
_level = level;
}
public LightSelect(DataContext context, Expression <Func <T, K> > expression, QueryExpression query, OrderExpression order, bool distinct, JoinSetting joinSetting, Region region, SafeLevel level)
: base(context, expression, typeof(T))
{
_query = query;
_order = order;
_distinct = distinct;
_joinSetting = joinSetting;
_region = region;
_level = level;
}
/// <summary>
/// 查询数据是否存在
/// </summary>
/// <param name="mapping">数据映射表</param>
/// <param name="query">查询表达式</param>
/// <param name="level">安全级别</param>
/// <returns>结果</returns>
internal bool Exists(DataEntityMapping mapping, QueryExpression query, SafeLevel level)
{
bool exists = false;
//Region region = new Region(0, 1);
using (IDbCommand command = _dataBase.Factory.CreateExistsCommand(mapping, query))
{
PrimitiveDataDefine pm = PrimitiveDataDefine.Create(typeof(Int32), 0);
foreach (object obj in QueryDataReader(pm, command, null, level))
{
exists = true;
}
}
return(exists);
}
/// <summary>
/// 开始事务
/// </summary>
public void BeginTrans(SafeLevel level)
{
if (_trconnection != null)
{
if (_isTransaction)
{
_trconnection.Rollback();
}
_trconnection.Dispose();
}
_isTransaction = true;
if (level == SafeLevel.None)
{
_trconnection = CreateTransactionConnection(SafeLevel.Default);
}
else
{
_trconnection = CreateTransactionConnection(level);
}
_trconnection.Open();
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlExecutor"/> class.
/// </summary>
/// <param name="sql">Sql.</param>
/// <param name="parameters">Parameters.</param>
/// <param name="commandType">Command type.</param>
/// <param name="level">Level.</param>
/// <param name="context">Context.</param>
internal SqlExecutor(string sql, DataParameter[] parameters, CommandType commandType, SafeLevel level, DataContext context)
{
_level = level;
_context = context;
var database = context.Database;
_command = database.CreateCommand(sql);
_command.CommandType = commandType;
if (parameters != null)
{
_parameters = new DataParameter[parameters.Length];
int i = 0;
foreach (DataParameter param in parameters)
{
IDataParameter dataParameter = param.ConvertDbParameter(database, commandType);
_command.Parameters.Add(dataParameter);
_parameters[i] = param;
i++;
}
}
}
internal virtual int ExecuteNonQuery(IDbCommand dbcommand, SafeLevel level)
{
int rInt = 0;
using (TransactionConnection transaction = CreateTransactionConnection(level))
{
transaction.Open();
try
{
transaction.SetupCommand(dbcommand);
rInt = dbcommand.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(rInt);
}
/// <summary>
/// DataTable读取
/// </summary>
/// <param name="dbcommand">数据类型</param>
/// <param name="region">查询范围</param>
/// <param name="level">安全级别</param>
/// <returns>DataTable对象</returns>
internal DataTable QueryDataTable(IDbCommand dbcommand, Region region, SafeLevel level)
{
DataTable dt = QueryDataSet(dbcommand, level).Tables[0];
if (region == null)
{
return(dt);
}
else
{
DataTable dt1 = new DataTable();
DataRowCollection drs = dt.Rows;
int start = region.Start;
int size = region.Size;
for (int i = start; i < size; i++)
{
dt1.Rows.Add(drs[i]);
}
return(dt1);
}
}
internal virtual object ExecuteScalar(IDbCommand dbcommand, SafeLevel level)
{
object result = null;
using (TransactionConnection transaction = CreateTransactionConnection(level))
{
transaction.Open();
try
{
transaction.SetupCommand(dbcommand);
result = dbcommand.ExecuteScalar();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(result);
}
internal virtual DataSet QueryDataSet(IDbCommand dbcommand, SafeLevel level)
{
DataSet ds = new DataSet();
using (TransactionConnection transaction = CreateTransactionConnection(level))
{
transaction.Open();
try
{
transaction.SetupCommand(dbcommand);
IDbDataAdapter adapter = _dataBase.CreateDataAdapter(dbcommand);
adapter.Fill(ds);
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(ds);
}
public abstract IQuery <T> SafeMode(SafeLevel level);
internal virtual object ExecuteInsertCommand(IDbCommand dbcommand, IDbCommand indentityCommand, SafeLevel level)
{
object result = null;
using (TransactionConnection transaction = CreateTransactionConnection(level))
{
transaction.Open();
try
{
transaction.SetupCommand(dbcommand);
dbcommand.ExecuteNonQuery();
if (indentityCommand != null)
{
transaction.SetupCommand(indentityCommand);
object obj = indentityCommand.ExecuteScalar();
if (obj != null)
{
result = obj;
}
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(result);
}
/// <summary>
/// 统计行数
/// </summary>
/// <param name="mapping">数据映射表</param>
/// <param name="query">查询表达式</param>
/// <param name="level"></param>
/// <returns>查询行数</returns>
internal object AggregateCount(DataEntityMapping mapping, QueryExpression query, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateAggregateCountCommand(mapping, query))
{
return(ExecuteScalar(command, level));
}
}
/// <summary>
/// 统计字段函数
/// </summary>
/// <param name="fieldMapping">统计字段</param>
/// <param name="aggregateType">统计方式</param>
/// <param name="query">查询表达式</param>
/// <param name="distinct">是否排除重复</param>
/// <param name="level">安全级别</param>
/// <returns>统计结果</returns>
internal object Aggregate(DataFieldMapping fieldMapping, AggregateType aggregateType, QueryExpression query, bool distinct, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateAggregateCommand(fieldMapping, aggregateType, query, distinct))
{
object obj = ExecuteScalar(command, level);
if (Object.Equals(obj, DBNull.Value))
{
return(null);
}
else
{
return(obj);
}
}
}
/// <summary>
/// 获取查询单个数据
/// </summary>
/// <param name="mapping">数据对象映射表</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="index">数据索引</param>
/// <param name="level">安全级别</param>
/// <returns>数据对象</returns>
internal object SelectSingle(DataEntityMapping mapping, QueryExpression query, OrderExpression order, int index, SafeLevel level)
{
object target = null;
Region region = new Region(index, 1);
using (IDbCommand command = _dataBase.Factory.CreateSelectCommand(mapping, query, order, IsInnerPager ? region : null))
{
//target = LExecuteReaderSingle(mapping, command, index, level);
foreach (object obj in QueryDataReader(mapping, command, region, level))
{
target = obj;
}
}
return(target);
}
/// <summary>
/// 动态统计数据到数据集合中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="amapping">统计结果类型</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryDynamicAggregateList(DataEntityMapping mapping, AggregateTableMapping amapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
if (amapping.RelateType != null && amapping.RelateType != mapping.ObjectType)
{
throw new LightDataException(string.Format(RE.AggregateTypeIsNotSpecifyType, amapping.RelateType.FullName));
}
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
IList items = CreateList(amapping.ObjectType);
IEnumerable ie = QueryDataReader(amapping, command, null, level);
foreach (object obj in ie)
{
items.Add(obj);
}
return(items);
}
}
/// <summary>
/// 动态统计数据到数据表中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据表</returns>
internal DataTable QueryDynamicAggregateTable(DataEntityMapping mapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
return(QueryDataTable(command, null, level));
}
}
/// <summary>
/// 查询单列数据
/// </summary>
/// <param name="fieldInfo">字段信息</param>
/// <param name="outputType">输出类型</param>
/// <param name="isNullable">是否可空</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="distinct">是否排除重复</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryColumeList(DataFieldInfo fieldInfo, Type outputType, bool isNullable, QueryExpression query, OrderExpression order, Region region, bool distinct, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateSelectSingleFieldCommand(fieldInfo, query, order, distinct, null))
{
DataDefine define = TransferDataDefine(outputType, null, isNullable);
IList items = CreateList(define.ObjectType);
IEnumerable ie = QueryDataReader(define, command, region, level);
if (define.IsNullable)
{
MethodInfo addMethod = items.GetType().GetMethod("Add");
foreach (object obj in ie)
{
if (Object.Equals(obj, null))
{
addMethod.Invoke(items, new object[] { null });
}
else
{
items.Add(obj);
}
}
}
else
{
foreach (object obj in ie)
{
items.Add(obj);
}
}
return(items);
}
}
/// <summary>
/// 查询单列数据
/// </summary>
/// <param name="fieldInfo">字段信息</param>
/// <param name="outputType">输出类型</param>
/// <param name="isNullable">是否可空</param>
/// <param name="query">查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="region">查询范围</param>
/// <param name="distinct">是否排除重复</param>
/// <param name="level">安全级别</param>
/// <returns>单列数据枚举</returns>
internal IEnumerable QueryColumeEnumerable(DataFieldInfo fieldInfo, Type outputType, bool isNullable, QueryExpression query, OrderExpression order, Region region, bool distinct, SafeLevel level)
{
IDbCommand command = _dataBase.Factory.CreateSelectSingleFieldCommand(fieldInfo, query, order, distinct, null);
DataDefine define = TransferDataDefine(outputType, null, isNullable);
return(QueryDataReader(define, command, region, level));
}
