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)); }