/// <summary> /// 在事务中删除数据表中满足指定条件的数据. /// </summary> /// <param name="trans">写事务的事务控制器.</param> /// <param name="func">用于创建删除条件.</param> /// <exception cref="ArgumentNullException">当未指派事务控制器时引发此异常.</exception> /// <exception cref="Exception">当未指定更新条件或删除过程产生错误时引发此异常.</exception> /// <returns></returns> public int Delete(DBTransactionController trans, Func <TEntityAgent, object[]> func) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (func == null) { throw new Exception("在不指定条件的情况下将会删除整个数据表中的所有数据,该操作已被禁止."); } EntityTableAttribute tableAttribute = GetTableAttribute(); QuickDataChanger DC = new QuickDataChanger(trans, Writer); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; DC.Conditions.AddRange(func(agent)); trans.DBA.Errors.Clear(); int result = DC.Delete(tableAttribute.TableName); if (result == -1) { if (trans.DBA.Errors != null && trans.DBA.Errors.Count > 0) { throw new Exception(trans.DBA.Errors[0].Message); } else { throw new Exception("删除数据是产生了未知的错误."); } } return(result); }
/// <summary> /// 获取数据表的映射信息. /// </summary> /// <returns></returns> public override EntityTableAttribute GetTableAttribute() { Type agentType = typeof(TEntityAgent); if (TableAttributeCache.ContainsKey(agentType)) { return(TableAttributeCache[agentType]); } object[] Attributes = agentType.GetCustomAttributes(typeof(EntityTableAttribute), true); if (Attributes == null || Attributes.Length < 0) { throw new NotSupportedException(string.Format("Not supported table context object, please use {1} for class: {0}.", typeof(EntityTableAttribute).FullName, agentType.FullName)); } EntityTableAttribute tableAttribute = (EntityTableAttribute)Attributes[0]; lock (TableAttributeCache) // 防止多任务时产生并发调用而引起错误 { if (!(TableAttributeCache.ContainsKey(agentType))) { TableAttributeCache.Add(agentType, tableAttribute); } } return(tableAttribute); }
/// <summary> /// 执行查询,并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。 /// </summary> /// <param name="action">用于构建查询命令.</param> /// <returns></returns> public object QueryScalar(Action <TEntityAgent, TableQuerySelector> action) { EntityTableAttribute entityTable = GetTableAttribute(); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; TableQuerySelector selector = new TableQuerySelector(entityTable.TableName); action(agent, selector); object Result; if (BatchProccesser == null) { Result = Reader.ExecuteScalar(selector.DbCommand); if (Result == null && Reader.DBA.Error != null) { throw new Exception(Reader.DBA.Error.Message); } } else { Result = BatchProccesser.Commander.QueryScalar(selector.DbCommand); } return(Result); }
/// <summary> /// 删除数据表中满足指定条件的数据. /// </summary> /// <param name="func">用于创建删除条件.</param> /// <exception cref="Exception">当未指定更新条件或删除过程产生错误时引发此异常.</exception> /// <returns>返回受影响记录数.</returns> public int Delete(Func <TEntityAgent, object[]> func) { if (func == null) { throw new Exception("在不指定条件的情况下将会删除整个数据表中的所有数据,该操作已被禁止."); } EntityTableAttribute tableAttribute = GetTableAttribute(); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; object[] conditions = func(agent); int result = 0; if (BatchProccesser == null) { QuickDataChanger DC = new QuickDataChanger(Writer); DC.Conditions.AddRange(conditions); result = DC.Delete(tableAttribute.TableName); if (result == -1) { throw new Exception(Writer.DBA.Error.Message); } } else { DbCommandBuilder cb = new DbCommandBuilder(); cb.Delete(tableAttribute.TableName).Where(conditions); result = BatchProccesser.Commander.ExecuteNonQuery(cb); } return(result); }
/// <summary> /// 更新数据表中的记录. /// </summary> /// <typeparam name="TEntity">数据表对应的实体类型.</typeparam> /// <param name="entity">实体对象.</param> /// <param name="func">用于创建更新条件.</param> /// <exception cref="ArgumentNullException">当必备的参数为空时引发此异常.</exception> /// <exception cref="Exception">当执行更新时产生错误时引发此异常.</exception> /// <returns>返回受影响的记录数.</returns> protected int Update <TEntity>(TEntity entity, Func <TEntityAgent, object[]> func) where TEntity : DataEntity, new() { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (func == null) { throw new Exception("未指定更新条件时,整个数据表中的所有数据都将被更新为一样的,此操作已被禁止."); } // 过滤掉自增长字段. string[] withOutFields = GetWithOutFields(entity.GetType()); EntityTableAttribute tableAttribute = GetTableAttribute(); QuickDataChanger DC = new QuickDataChanger(Writer); if (func != null) { TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; DC.Conditions.AddRange(func(agent)); } int result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), true); if (result == -1) // 若更新失败时向外界抛出异常. { throw new Exception(Writer.DBA.Error.Message); } return(result); }
/// <summary> /// 向多表查询中添加一个联合查询的表. /// </summary> /// <typeparam name="TEntityAgent">表的实体映射代理对象.</typeparam> /// <returns></returns> public EntityJoinSelector Join <TEntityAgent>() where TEntityAgent : EntityAgent, new() { if (sBlock == null) { throw new NullReferenceException("Please invoke in advance the \"From\" method."); } TEntityAgent agent = new TEntityAgent(); TableMapper context = agent.CreateContext(); context.SetDataEngine(ReadEngine, null); agent.TableContext = context; agent.IncludeTableName = true; // 指法查询代理对象在生成字段信息时带上表名. // 将实体表的代理类记录下来,后面组织查询时还要用到. if (!(AgentsIndexes.ContainsKey(typeof(TEntityAgent)))) { AgentBufferItem BufferItem = new AgentBufferItem(agent); AgentsIndexes.Add(typeof(TEntityAgent), BufferItem); Agents.Add(BufferItem); } // 向 FROM 子向中添加 LEFT JOIN 子句. EntityTableAttribute tableAttribute = context.GetTableAttribute(); LeftJoinDescription leftJoin = fm.LeftJoin(fm.Table(tableAttribute.TableName)); fBlock.Content.Add(leftJoin); // 返回 JEFT JOIN 子句的筛选器构建对象. return(new EntityJoinSelector(this, leftJoin, (t) => { if (AgentsIndexes.ContainsKey(t)) { return AgentsIndexes[t].Agent <EntityAgent>(); } return null; })); }
/// <summary> /// 根据指定的条件查询指定实体对应的表,并返回数据集合. /// </summary> /// <typeparam name="TEntity">对应数据库表的实体类型.</typeparam> /// <param name="action">用于指定查询条件.</param> /// <returns></returns> protected List <TEntity> Select <TEntity>(Action <TEntityAgent, SelectBlock> action) where TEntity : DataEntity, new() { EntityTableAttribute entityTable = GetTableAttribute(); DbCommandBuilder Command = new DbCommandBuilder(); SelectBlock select = Command.Select(td.Field("*")).From(entityTable.TableName); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; action(agent, select); return(ExecuteQuery <TEntity>(Command)); }
/// <summary> /// 向数据表中添加一条记录. /// </summary> /// <typeparam name="TEntity">数据表对应的实体类型.</typeparam> /// <param name="entity">实体对象.</param> /// <param name="trans">写事务的事务控制器.</param> /// <exception cref="Exception">当新增数据失败时引发该异常.</exception> protected void Add <TEntity>(TEntity entity, DBTransactionController trans = null) where TEntity : DataEntity, new() { if (entity == null) { return; } // 增加记录时过滤掉自增长字段. string[] withOutFields = GetWithOutFields(entity.GetType()); // 向数据库中增加记录 bool InTransaction = trans != null; EntityTableAttribute tableAttribute = GetTableAttribute(); QuickDataChanger DC; if (InTransaction) { DC = new QuickDataChanger(trans, Writer); } else { DC = new QuickDataChanger(Writer); } int result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), false); if (result == -1) // 若添加失败则向外界抛出异常. { string Error; if (InTransaction) { Error = (trans.DBA.Errors != null && trans.DBA.Errors.Count > 0) ? trans.DBA.Errors[0].Message : string.Format("新增:{0}是产生未知错误.", entity.GetType().Name); } else { Error = (Writer.DBA.Error == null) ? string.Format("新增:{0}是产生未知错误.", entity.GetType().Name) : Writer.DBA.Error.Message; } throw new Exception(Error); } else // 新增成功时更新实体中的自增长字段值. { if (withOutFields.Length > 0) { if (InTransaction) { entity.SetValue(withOutFields[withOutFields.Length - 1], trans.DBA.SCOPE_IDENTITY, true); } else { entity.SetValue(withOutFields[withOutFields.Length - 1], Writer.DBA.SCOPE_IDENTITY, true); } } } }
/// <summary> /// 更新数据表中的记录. /// </summary> /// <typeparam name="TEntity">数据表对应的实体类型.</typeparam> /// <param name="entity">实体对象.</param> /// <param name="func">用于创建更新条件.</param> /// <exception cref="ArgumentNullException">当必备的参数为空时引发此异常.</exception> /// <exception cref="Exception">当执行更新时产生错误时引发此异常.</exception> /// <returns>返回受影响的记录数.</returns> protected int Update <TEntity>(TEntity entity, Func <TEntityAgent, object[]> func) where TEntity : DataEntity, new() { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (func == null) { throw new Exception("未指定更新条件时,整个数据表中的所有数据都将被更新为一样的,此操作已被禁止."); } // 过滤掉自增长字段. string[] withOutFields = GetWithOutFields(entity.GetType()); EntityTableAttribute tableAttribute = GetTableAttribute(); object[] conditions = null; if (func != null) // 获得外部 lambda 表达式返回的条件. { TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; conditions = func(agent); } int result = 0; if (BatchProccesser == null) //非同连接分批处理模式. { QuickDataChanger DC = new QuickDataChanger(Writer); if (conditions != null) { DC.Conditions.AddRange(conditions); } result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), true); if (result == -1) // 若更新失败时向外界抛出异常. { throw new Exception(Writer.DBA.Error.Message); } } else //在同一个连接的分批处理模式. { List <IDescription> exp = new List <IDescription>(); Dictionary <string, object> data = entity.ToDictionary(withOutFields); foreach (KeyValuePair <string, object> item in data) { exp.Add(td.Field(item.Key) == item.Value); } DbCommandBuilder cb = new DbCommandBuilder(); cb.Update(tableAttribute.TableName).Set(exp.ToArray()).Where(conditions); result = BatchProccesser.Commander.ExecuteNonQuery(cb); } return(result); }
/// <summary> /// 获取或设置表名称. /// </summary> /// <returns></returns> internal override string GetTableName() { if (string.IsNullOrEmpty(tableName)) { EntityTableAttribute tableAttribute = GetTableAttribute(); StringBuilder tabName = new StringBuilder(); tabName.Append(Reader.CommandParserAdapter.ElemIdentifierL); tabName.Append(tableAttribute.TableName); tabName.Append(Reader.CommandParserAdapter.ElemIdentifierR); tableName = tabName.ToString(); return(tabName.ToString()); } else { return(tableName); } }
/// <summary> /// 在事务中更新数据表中的记录. /// </summary> /// <typeparam name="TEntity">数据表对应的实体类型.</typeparam> /// <param name="trans">写事务的事务控制器.</param> /// <param name="entity">实体对象.</param> /// <param name="func">用于创建更新条件.</param> /// <exception cref="ArgumentNullException">当必备的参数为空时引发此异常.</exception> /// <exception cref="Exception">当执行更新时产生错误时引发此异常.</exception> /// <returns>返回受影响的记录数.</returns> protected int Update <TEntity>(DBTransactionController trans, TEntity entity, Func <TEntityAgent, object[]> func) where TEntity : DataEntity, new() { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (func == null) { throw new Exception("未指定更新条件时,整个数据表中的所有数据都将被更新为一样的,此操作已被禁止."); } // 过滤掉自增长字段. // 过滤掉自增长字段. string[] withOutFields = GetWithOutFields(entity.GetType()); EntityTableAttribute tableAttribute = GetTableAttribute(); QuickDataChanger DC = new QuickDataChanger(trans, Writer); if (func != null) { TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; DC.Conditions.AddRange(func(agent)); } trans.DBA.Errors.Clear(); int result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), true); if (result == -1) // 若更新失败时向外界抛出异常. { string Error; if (trans.DBA.Errors.Count < 1) { Error = "更新表时产生了未知的异常."; } else { Error = trans.DBA.Errors[0].Message; } throw new Exception(Error); } return(result); }
/// <summary> /// 查询指定实体对应的表,并返回数据集合. /// </summary> /// <typeparam name="TEntity">对应数据库表的实体类型.</typeparam> /// <param name="selector">返回查询条件的方法.</param> /// <exception cref="NotSupportedException">当<c>TEntity</c>指定的实体类型未标记<see cref="EntityTableAttribute"/>属性时引发该异常</exception> /// <exception cref="Exception">当数据库查询过程产生错误时引发该异常.</exception> /// <returns></returns> protected List <TEntity> Select <TEntity>(Func <TEntityAgent, object> selector) where TEntity : DataEntity, new() { EntityTableAttribute entityTable = GetTableAttribute(); DbCommandBuilder Command = new DbCommandBuilder(); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; object Conditions = selector(agent); if (Conditions == null) { Command.Select(agent.GetFieldsArray()).From(entityTable.TableName); } else { Command.Select(agent.GetFieldsArray()).From(entityTable.TableName).Where(Conditions); } return(ExecuteQuery <TEntity>(Command)); }
/// <summary> /// 删除数据表中满足指定条件的数据. /// </summary> /// <param name="func">用于创建删除条件.</param> /// <exception cref="Exception">当未指定更新条件或删除过程产生错误时引发此异常.</exception> /// <returns>返回受影响记录数.</returns> public int Delete(Func <TEntityAgent, object[]> func) { if (func == null) { throw new Exception("在不指定条件的情况下将会删除整个数据表中的所有数据,该操作已被禁止."); } EntityTableAttribute tableAttribute = GetTableAttribute(); QuickDataChanger DC = new QuickDataChanger(Writer); TEntityAgent agent = new TEntityAgent(); agent.TableContext = this; DC.Conditions.AddRange(func(agent)); int result = DC.Delete(tableAttribute.TableName); if (result == -1) { throw new Exception(Writer.DBA.Error.Message); } return(result); }
/// <summary> /// 开始建立查询命令对象树. /// </summary> /// <typeparam name="TEntityAgent">表对应的实体映射代理对象.</typeparam> /// <returns></returns> internal MultiQuerySelector From <TEntityAgent>() where TEntityAgent : EntityAgent, new() { sBlock = Command.Select(); TEntityAgent agent = new TEntityAgent(); TableMapper context = agent.CreateContext(); context.SetDataEngine(ReadEngine, null); agent.TableContext = context; agent.IncludeTableName = true; // 指法查询代理对象在生成字段信息时带上表名. // 将实体表的代理类记录下来,后面组织查询时还要用到. if (!(AgentsIndexes.ContainsKey(typeof(TEntityAgent)))) { AgentBufferItem BufferItem = new AgentBufferItem(agent); AgentsIndexes.Add(typeof(TEntityAgent), BufferItem); Agents.Add(BufferItem); } // 向 FROM 了向中添加查询的表. EntityTableAttribute tableAttribute = context.GetTableAttribute(); fBlock.Content.Add(fm.Table(tableAttribute.TableName)); sBlock.Blocks.Add(fBlock); return(this); }
/// <summary> /// 向数据表中添加一条记录. /// </summary> /// <typeparam name="TEntity">数据表对应的实体类型.</typeparam> /// <param name="entity">实体对象.</param> /// <param name="trans">写事务的事务控制器.</param> /// <exception cref="Exception">当新增数据失败时引发该异常.</exception> protected void Add <TEntity>(TEntity entity, DBTransactionController trans = null) where TEntity : DataEntity, new() { if (entity == null) { return; } // 增加记录时过滤掉自增长字段. string[] withOutFields = GetWithOutFields(entity.GetType()); EntityTableAttribute tableAttribute = GetTableAttribute(); int result = 0; if (BatchProccesser == null) // 非同连接分批处理模式. { bool InTransaction = trans != null; QuickDataChanger DC; if (InTransaction) { DC = new QuickDataChanger(trans, Writer); } else { DC = new QuickDataChanger(Writer); } result = DC.SaveToDataBase(tableAttribute.TableName, entity.ToDictionary(withOutFields), false); if (result == -1) // 若添加失败则向外界抛出异常. { string Error; if (InTransaction) { Error = (trans.DBA.Errors != null && trans.DBA.Errors.Count > 0) ? trans.DBA.Errors[0].Message : string.Format("新增:{0}是产生未知错误.", entity.GetType().Name); } else { Error = (Writer.DBA.Error == null) ? string.Format("新增:{0}是产生未知错误.", entity.GetType().Name) : Writer.DBA.Error.Message; } throw new Exception(Error); } else // 新增成功时更新实体中的自增长字段值. { if (withOutFields.Length > 0) { if (InTransaction) { entity.SetValue(withOutFields[withOutFields.Length - 1], trans.DBA.SCOPE_IDENTITY, true); } else { entity.SetValue(withOutFields[withOutFields.Length - 1], Writer.DBA.SCOPE_IDENTITY, true); } } } } else // 在同一个连接的分批处理模式. { List <FieldDescription> fields = new List <FieldDescription>(); List <object> values = new List <object>(); Dictionary <string, object> data = entity.ToDictionary(withOutFields); foreach (KeyValuePair <string, object> item in data) { fields.Add(td.Field(item.Key)); values.Add(item.Value); } DbCommandBuilder cb = new DbCommandBuilder(); cb.Insert(tableAttribute.TableName, fields.ToArray()).Values(values.ToArray()); result = BatchProccesser.Commander.ExecuteNonQuery(cb); if (withOutFields.Length > 0 && result > 0) { entity.SetValue(withOutFields[withOutFields.Length - 1], BatchProccesser.Commander.SCOPE_IDENTITY, true); } } }