private MapProvider GetProvider(Type type, String key) { if (type == null) { return(null); } // 区分实体类和提供者 if (type.As <MapProvider>()) { return(Activator.CreateInstance(type) as MapProvider); } if (key.IsNullOrEmpty()) { key = EntityFactory.CreateOperate(type)?.Unique?.Name; } return(new MapProvider { EntityType = type, Key = key }); }
/// <summary>获取数据源</summary> /// <returns></returns> public virtual IDictionary <Object, String> GetDataSource() { var fact = EntityFactory.CreateOperate(EntityType); var key = Key; var mst = fact.Master?.Name; if (key.IsNullOrEmpty()) { throw new ArgumentNullException("没有设置关联键", nameof(Key)); } if (mst.IsNullOrEmpty()) { throw new ArgumentNullException("没有设置主要字段"); } // 数据较少时,从缓存读取 var list = fact.Count < 1000 ? fact.FindAllWithCache() : fact.FindAll("", null, null, 0, 100); return(list.ToDictionary(e => e[key], e => e[mst] + "")); }
/// <summary>更新</summary> /// <param name="entity"></param> /// <returns></returns> public virtual Int32 Update(IEntity entity) { var ds = entity.Dirtys; // 没有脏数据,不需要更新 if (ds.Count == 0) return 0; IDataParameter[] dps = null; var sql = SQL(entity, DataObjectMethodType.Update, ref dps); if (String.IsNullOrEmpty(sql)) return 0; var op = EntityFactory.CreateOperate(entity.GetType()); var session = op.Session; var rs = session.Execute(sql, CommandType.Text, dps); //清除脏数据,避免重复提交 ds.Clear(); EntityAddition.ClearValues(entity as EntityBase); return rs; }
/// <summary>从实体列表创建参数</summary> /// <param name="list">实体列表</param> /// <returns></returns> public static IDataParameter[] CreateParameters <T>(this IEnumerable <T> list) where T : IEntity { var dps = new List <IDataParameter>(); if (list == null || !list.Any()) { return(dps.ToArray()); } var type = list.First().GetType(); var fact = EntityFactory.CreateOperate(type); var db = fact.Session.Dal.Db; foreach (var item in fact.Fields) { var vs = list.Select(e => e[item.Name]).ToArray(); dps.Add(db.CreateParameter(item.ColumnName ?? item.Name, vs, item.Field)); } return(dps.ToArray()); }
/// <summary>更新</summary> /// <param name="entity"></param> /// <returns></returns> public virtual Int32 Update(IEntity entity) { var ds = entity.Dirtys; // 没有脏数据,不需要更新 if (!ds.Any()) { return(0); } IDataParameter[] dps = null; var sql = ""; // 双锁判断脏数据 lock (entity) { if (ds.Count == 0) { return(0); } sql = SQL(entity, DataObjectMethodType.Update, ref dps); if (sql.IsNullOrEmpty()) { return(0); } //清除脏数据,避免重复提交 ds.Clear(); } var op = EntityFactory.CreateOperate(entity.GetType()); var session = op.Session; var rs = session.Execute(sql, CommandType.Text, dps); //EntityAddition.ClearValues(entity as EntityBase); return(rs); }
/// <summary>设置字段值,该方法影响脏数据。</summary> /// <param name="name">字段名</param> /// <param name="value">值</param> /// <returns>返回是否成功设置了数据</returns> public Boolean SetItem(String name, Object value) { var fact = EntityFactory.CreateOperate(GetType()); FieldItem fi = fact.Table.FindByName(name); // 确保数据类型一致 if (fi != null) { value = value.ChangeType(fi.Type); } var b = OnPropertyChanging(name, value); if (b) { // OnPropertyChanging中根据新旧值是否相同来影响脏数据 // SetItem作为必定影响脏数据的代替者 this[name] = value; Dirtys[name] = true; } return(b); }
/// <summary> /// 默认条件。 /// 若有标识列,则使用一个标识列作为条件; /// 如有主键,则使用全部主键作为条件。 /// </summary> /// <param name="entity">实体对象</param> /// <returns>条件</returns> static WhereExpression DefaultCondition(IEntity entity) { var op = EntityFactory.CreateOperate(entity.GetType()); var exp = new WhereExpression(); // 标识列作为查询关键字 var fi = op.Table.Identity; if (fi != null) { exp &= (fi as Field) == entity[fi.Name]; return(exp); } // 主键作为查询关键字 var ps = op.Table.PrimaryKeys; // 没有标识列和主键,返回取所有数据的语句 if (ps == null || ps.Length < 1) { //if (DAL.Debug) throw new XCodeException("因为没有主键,无法给实体类构造默认条件!"); //return null; ps = op.Table.Fields; } //var sb = new StringBuilder(); foreach (var item in ps) { //if (sb.Length > 0) sb.Append(" And "); //sb.Append(op.FormatName(item.ColumnName)); //sb.Append("="); //sb.Append(op.FormatValue(item, entity[item.Name])); exp &= (item as Field) == entity[item.Name]; } //return sb.ToString(); return(exp); }
/// <summary>判断两个实体是否相等。有可能是同一条数据的两个实体对象</summary> /// <param name="entity"></param> /// <returns></returns> Boolean IEntity.EqualTo(IEntity entity) { if (entity == null || GetType() != entity.GetType()) { return(false); } if (this == entity) { return(true); } // 判断是否所有主键相等 var op = EntityFactory.CreateOperate(GetType()); var ps = op.Table.PrimaryKeys; // 如果没有主键,则判断所有字段 if (ps == null || ps.Length < 1) { ps = op.Table.Fields; } foreach (var item in ps) { var v1 = this[item.Name]; var v2 = entity[item.Name]; //// 特殊处理整数类型,避免出现相同值不同整型而导致结果不同 //if (item.Type.IsIntType() && Convert.ToInt64(v1) != Convert.ToInt64(v2)) return false; //if (item.Type == typeof(String)) { v1 += ""; v2 += ""; } //if (!Object.Equals(v1, v2)) return false; if (!CheckEqual(v1, v2)) { return(false); } } return(true); }
/// <summary> /// 默认条件。 /// 若有标识列,则使用一个标识列作为条件; /// 如有主键,则使用全部主键作为条件。 /// </summary> /// <param name="entity">实体对象</param> /// <returns>条件</returns> static String DefaultCondition(IEntity entity) { IEntityOperate op = EntityFactory.CreateOperate(entity.GetType()); // 标识列作为查询关键字 FieldItem fi = op.Table.Identity; if (fi != null) { return(op.MakeCondition(fi, entity[fi.Name], "=")); } // 主键作为查询关键字 FieldItem[] ps = op.Table.PrimaryKeys; // 没有标识列和主键,返回取所有数据的语句 if (ps == null || ps.Length < 1) { if (DAL.Debug) { throw new XCodeException("因为没有主键,无法给实体类构造默认条件!"); } return(null); } StringBuilder sb = new StringBuilder(); foreach (FieldItem item in ps) { if (sb.Length > 0) { sb.Append(" And "); } sb.Append(op.FormatName(item.ColumnName)); sb.Append("="); sb.Append(op.FormatValue(item, entity[item.Name])); } return(sb.ToString()); }
/// <summary>把SQL模版格式化为SQL语句</summary> /// <param name="entity">实体对象</param> /// <param name="methodType"></param> /// <param name="parameters">参数数组</param> /// <returns>SQL字符串</returns> String SQL(IEntity entity, DataObjectMethodType methodType, ref DbParameter[] parameters) { var op = EntityFactory.CreateOperate(entity.GetType()); var formatedTalbeName = op.FormatedTableName; String sql; switch (methodType) { case DataObjectMethodType.Fill: return(String.Format("Select * From {0}", formatedTalbeName)); case DataObjectMethodType.Select: sql = DefaultCondition(entity); // 没有标识列和主键,返回取所有数据的语句 if (String.IsNullOrEmpty(sql)) { throw new XCodeException("实体类缺少主键!"); } return(String.Format("Select * From {0} Where {1}", formatedTalbeName, sql)); case DataObjectMethodType.Insert: return(InsertSQL(entity, ref parameters)); case DataObjectMethodType.Update: return(UpdateSQL(entity, ref parameters)); case DataObjectMethodType.Delete: // 标识列作为删除关键字 sql = DefaultCondition(entity); if (String.IsNullOrEmpty(sql)) { return(null); } return(String.Format("Delete From {0} Where {1}", formatedTalbeName, sql)); } return(null); }
/// <summary>删除</summary> /// <param name="entity"></param> /// <returns></returns> public virtual Int32 Delete(IEntity entity) { var op = EntityFactory.CreateOperate(entity.GetType()); var session = op.Session; String sql = DefaultCondition(entity); if (String.IsNullOrEmpty(sql)) { return(0); } //return session.Execute(String.Format("Delete From {0} Where {1}", op.FormatedTableName, sql)); var rs = session.Execute(false, false, String.Format("Delete From {0} Where {1}", op.FormatedTableName, sql)); //清除脏数据,避免重复提交保存 if (entity.Dirtys != null) { entity.Dirtys.Clear(); } return(rs); }
static String DeleteSQL(IEntity entity, ref IDataParameter[] parameters) { var op = EntityFactory.CreateOperate(entity.GetType()); var up = op.Session.Dal.Db.UserParameter; // 标识列作为删除关键字 var exp = DefaultCondition(entity); var ps = new Dictionary <String, Object>(); if (!up) { ps = null; } var sql = exp?.GetString(ps); if (String.IsNullOrEmpty(sql)) { return(null); } if (ps != null && ps.Count > 0) { var db = op.Session.Dal.Db; var dps = new List <IDataParameter>(); foreach (var item in ps) { var dp = db.CreateParameter(item.Key, item.Value, op.Table.FindByName(item.Key)?.Type); dps.Add(dp); } parameters = dps.ToArray(); } var formatedTalbeName = op.FormatedTableName; return(String.Format("Delete From {0} Where {1}", formatedTalbeName, sql)); }
public static IList <IEntity> SetField(IList <IEntity> list) { if (list == null || list.Count < 1) { return(list); } var entityType = list[0].GetType(); var factory = EntityFactory.CreateOperate(entityType); var fs = factory.AdditionalFields; if (fs.Count > 0) { foreach (EntityBase entity in list) { if (entity != null) { entity.Addition.Set(fs); } } } return(list); }
static String UpdateSQL(IEntity entity, ref IDataParameter[] parameters) { /* * 实体更新原则: * 1,自增不参与 * 2,没有脏数据不参与 * 3,大字段参数化特殊处理 * 4,累加字段特殊处理 */ var fact = EntityFactory.CreateOperate(entity.GetType()); var db = fact.Session.Dal.Db; var exp = DefaultCondition(entity); var ps = !db.UseParameter ? null : new Dictionary<String, Object>(); var def = exp?.GetString(ps); if (def.IsNullOrEmpty()) return null; // 处理累加字段 var dfs = (entity as EntityBase).GetAddition(); var sb = Pool.StringBuilder.Get(); var dps = new List<IDataParameter>(); // 只读列没有更新操作 foreach (var fi in fact.Fields) { if (fi.IsIdentity) continue; //脏数据判断 if (!entity.IsDirty(fi.Name)) continue; var value = entity[fi.Name]; sb.Separate(", "); // 加逗号 var name = fact.FormatName(fi.ColumnName); sb.Append(name); sb.Append("="); // 检查累加 var flag = TryCheckAdditionalValue(dfs, fi.Name, out var val, out var sign); if (db.UseParameter || UseParam(fi, value)) { var dp = CreateParameter(db, fi, flag ? val : value); dps.Add(dp); // 检查累加 if (flag) { if (sign) sb.AppendFormat("{0}+{1}", name, dp.ParameterName); else sb.AppendFormat("{0}-{1}", name, dp.ParameterName); } else { sb.Append(dp.ParameterName); } } else { // 检查累加 if (flag) { if (sign) sb.AppendFormat("{0}+{1}", name, val); else sb.AppendFormat("{0}-{1}", name, val); } else sb.Append(fact.FormatValue(fi, value)); } } // 重置累加数据 if (dfs != null && dfs.Count > 0) (entity as EntityBase).Addition.Reset(dfs); var str = sb.Put(true); if (str.IsNullOrEmpty()) return null; // Where条件里面的参数化 if (ps != null) { foreach (var item in ps) { var dp = db.CreateParameter(item.Key, item.Value, fact.Table.FindByName(item.Key)?.Field); dps.Add(dp); } } if (dps.Count > 0) parameters = dps.ToArray(); return "Update {0} Set {1} Where {2}".F(fact.FormatedTableName, str, def); }
static String UpdateSQL(IEntity entity, ref IDataParameter[] parameters) { /* * 实体更新原则: * 1,自增不参与 * 2,没有脏数据不参与 * 3,大字段参数化特殊处理 * 4,累加字段特殊处理 */ var def = DefaultCondition(entity); //if (String.IsNullOrEmpty(def)) return null; if (def.Empty) { return(null); } // 处理累加字段 var dfs = (entity as EntityBase).Addition.Get(); var op = EntityFactory.CreateOperate(entity.GetType()); var up = op.Session.Dal.Db.UserParameter; var sb = new StringBuilder(); var dps = new List <IDataParameter>(); // 只读列没有更新操作 foreach (var fi in op.Fields) { if (fi.IsIdentity) { continue; } //脏数据判断 if (!entity.Dirtys[fi.Name]) { continue; } var value = entity[fi.Name]; sb.Separate(", "); // 加逗号 var name = op.FormatName(fi.ColumnName); sb.Append(name); sb.Append("="); if (up || UseParam(fi, value)) { dps.Add(CreateParameter(sb, op, fi, value)); } else { // 检查累加 if (!CheckAdditionalValue(sb, dfs, fi.Name, name)) { sb.Append(op.FormatValue(fi, value)); // 数据 } } } // 重置累加数据 (entity as EntityBase).Addition.Reset(dfs); if (sb.Length <= 0) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Update {0} Set {1} Where {2}", op.FormatedTableName, sb, def)); }
static String InsertSQL(IEntity entity, ref IDataParameter[] parameters) { var op = EntityFactory.CreateOperate(entity.GetType()); var up = op.Session.Dal.Db.UserParameter; /* * 插入数据原则: * 1,有脏数据的字段一定要参与 * 2,没有脏数据,允许空的字段不参与 * 3,没有脏数据,不允许空,有默认值的不参与 * 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 */ // 缓存参数化时的SQL语句 var key = "{0}_Insert".F(entity.GetType().FullName); var sql = ""; StringBuilder sbNames = null; StringBuilder sbValues = null; if (!up || !op.Session.Items.TryGetValue(key, out var oql)) { sbNames = new StringBuilder(); sbValues = new StringBuilder(); } else { sql = oql + ""; } var dps = new List <IDataParameter>(); // 只读列没有插入操作 foreach (var fi in op.Fields) { var value = entity[fi.Name]; // 标识列不需要插入,别的类型都需要 if (sbNames != null && CheckIdentity(fi, value, op, sbNames, sbValues)) { continue; } // 1,有脏数据的字段一定要参与同时对于实体有值的也应该参与(针对通过置空主键的方式另存) if (!up && value == null && !entity.Dirtys[fi.Name]) { // 2,没有脏数据,允许空的字段不参与 if (fi.IsNullable) { continue; } //// 3,没有脏数据,不允许空,有默认值的不参与 //if (fi.DefaultValue != null) continue; // 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 value = FormatParamValue(fi, null, op); } if (sbNames != null) { sbNames.Separate(", ").Append(op.FormatName(fi.ColumnName)); } if (sbValues != null) { sbValues.Separate(", "); } if (up || UseParam(fi, value)) { dps.Add(CreateParameter(sbValues, op, fi, value)); } else { sbValues.Append(op.FormatValue(fi, value)); } } if (sbNames != null && sbNames.Length <= 0) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } if (sbNames != null) { sql = String.Format("Insert Into {0}({1}) Values({2})", op.FormatedTableName, sbNames, sbValues); // 缓存参数化时的SQL语句 if (up) { op.Session.Items[key] = sql; } } return(sql); }
static String InsertSQL(IEntity entity, ref IDataParameter[] parameters) { var fact = EntityFactory.CreateOperate(entity.GetType()); var db = fact.Session.Dal.Db; /* * 插入数据原则: * 1,有脏数据的字段一定要参与 * 2,没有脏数据,允许空的字段不参与 * 3,没有脏数据,不允许空,有默认值的不参与 * 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 */ var sbNames = Pool.StringBuilder.Get(); var sbValues = Pool.StringBuilder.Get(); var dps = new List <IDataParameter>(); // 只读列没有插入操作 foreach (var fi in fact.Fields) { var value = entity[fi.Name]; // 标识列不需要插入,别的类型都需要 if (CheckIdentity(fi, value, fact, sbNames, sbValues)) { continue; } // 1,有脏数据的字段一定要参与 if (!fact.FullInsert && !entity.IsDirty(fi.Name)) { continue; } sbNames.Separate(",").Append(fact.FormatName(fi.ColumnName)); sbValues.Separate(","); if (db.UseParameter || UseParam(fi, value)) { var dp = CreateParameter(db, fi, value); dps.Add(dp); sbValues.Append(dp.ParameterName); } else { sbValues.Append(fact.FormatValue(fi, value)); } } var ns = sbNames.Put(true); var vs = sbValues.Put(true); if (ns.IsNullOrEmpty()) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return("Insert Into {0}({1}) Values({2})".F(fact.FormatedTableName, ns, vs)); }
///// <summary>执行SQL查询,返回记录集</summary> ///// <param name="entityType">实体类型</param> ///// <param name="builder">SQL语句</param> ///// <param name="startRowIndex">开始行,0表示第一行</param> ///// <param name="maximumRows">最大返回行数,0表示所有行</param> ///// <returns></returns> //public virtual DataSet Query(Type entityType, SelectBuilder builder, Int32 startRowIndex, Int32 maximumRows) //{ // var op = EntityFactory.CreateOperate(entityType); // var dal = DAL.Create(op.ConnName); // builder.Table = op.FormatName(op.TableName); // return dal.Select(builder, startRowIndex, maximumRows, op.TableName); //} ///// <summary>查询记录数</summary> ///// <param name="entityType">实体类型</param> ///// <param name="builder">查询生成器</param> ///// <returns>记录数</returns> //public virtual Int32 QueryCount(Type entityType, SelectBuilder builder) //{ // var op = EntityFactory.CreateOperate(entityType); // var dal = DAL.Create(op.ConnName); // builder.Table = op.FormatName(op.TableName); // return dal.SelectCount(builder, new String[] { op.TableName }); //} ///// <summary>执行SQL查询,返回记录集</summary> ///// <param name="entityType">实体类型</param> ///// <param name="builder">SQL语句</param> ///// <returns></returns> //public virtual SelectBuilder FindSQL(Type entityType, SelectBuilder builder) //{ // var op = EntityFactory.CreateOperate(entityType); // var dal = DAL.Create(op.ConnName); // builder.Table = op.FormatName(op.TableName); // return builder; //} #endregion #region 添删改方法 /// <summary>插入</summary> /// <param name="entity"></param> /// <returns></returns> public virtual Int32 Insert(IEntity entity) { var op = EntityFactory.CreateOperate(entity.GetType()); var session = op.Session; // 添加数据前,处理Guid SetGuidField(op, entity); DbParameter[] dps = null; var sql = SQL(entity, DataObjectMethodType.Insert, ref dps); if (String.IsNullOrEmpty(sql)) { return(0); } Int32 rs = 0; //检查是否有标识列,标识列需要特殊处理 var field = op.Table.Identity; var bAllow = op.AllowInsertIdentity; if (field != null && field.IsIdentity && !bAllow) { //Int64 res = dps != null && dps.Length > 0 ? session.InsertAndGetIdentity(sql, CommandType.Text, dps) : session.InsertAndGetIdentity(sql); Int64 res = dps != null && dps.Length > 0 ? session.InsertAndGetIdentity(false, sql, CommandType.Text, dps) : session.InsertAndGetIdentity(false, sql); if (res > 0) { entity[field.Name] = res; } rs = res > 0 ? 1 : 0; } else { if (bAllow) { var dal = DAL.Create(op.ConnName); if (dal.DbType == DatabaseType.SqlServer) { // 如果所有字段都不是自增,则取消对自增的处理 if (op.Fields.All(f => !f.IsIdentity)) { bAllow = false; } if (bAllow) { sql = String.Format("SET IDENTITY_INSERT {1} ON;{0};SET IDENTITY_INSERT {1} OFF", sql, op.FormatedTableName); } } } //rs = dps != null && dps.Length > 0 ? session.Execute(sql, CommandType.Text, dps) : session.Execute(sql); rs = dps != null && dps.Length > 0 ? session.Execute(false, false, sql, CommandType.Text, dps) : session.Execute(false, false, sql); } //清除脏数据,避免连续两次调用Save造成重复提交 if (entity.Dirtys != null) { entity.Dirtys.Clear(); } return(rs); }
/// <summary>把SQL模版格式化为SQL语句</summary> /// <param name="entity">实体对象</param> /// <param name="methodType"></param> /// <param name="parameters"></param> /// <returns>SQL字符串</returns> String SQL(IEntity entity, DataObjectMethodType methodType, ref DbParameter[] parameters) { IEntityOperate op = EntityFactory.CreateOperate(entity.GetType()); String sql; StringBuilder sbNames; StringBuilder sbValues; // sbParams用于存储参数化操作时格式化的参数名,参数化和非参数化同时使用,如果存在大字段是,才使用参数化 //StringBuilder sbParams; List <DbParameter> dps; //Boolean hasBigField = false; Boolean isFirst = true; switch (methodType) { case DataObjectMethodType.Fill: return(String.Format("Select * From {0}", op.FormatName(op.TableName))); case DataObjectMethodType.Select: sql = DefaultCondition(entity); // 没有标识列和主键,返回取所有数据的语句 if (String.IsNullOrEmpty(sql)) { throw new XCodeException("实体类缺少主键!"); } return(String.Format("Select * From {0} Where {1}", op.FormatName(op.TableName), sql)); case DataObjectMethodType.Insert: #region Insert sbNames = new StringBuilder(); sbValues = new StringBuilder(); //sbParams = new StringBuilder(); dps = new List <DbParameter>(); // 只读列没有插入操作 foreach (var fi in op.Fields) { // 标识列不需要插入,别的类型都需要 String idv = null; if (fi.IsIdentity) { if (op.AllowInsertIdentity) { idv = "" + entity[fi.Name]; } else { idv = DAL.Create(op.ConnName).Db.FormatIdentity(fi.Field, entity[fi.Name]); } //if (String.IsNullOrEmpty(idv)) continue; // 允许返回String.Empty作为插入空 if (idv == null) { continue; } } // 有默认值,并且没有设置值时,不参与插入操作 // 20120509增加,同时还得判断是否相同数据库或者数据库默认值,比如MSSQL数据库默认值不是GetDate,那么其它数据库是不可能使用的 if (!String.IsNullOrEmpty(fi.DefaultValue) && !entity.Dirtys[fi.Name] && CanUseDefault(fi, op)) { continue; } if (!isFirst) { sbNames.Append(", "); } var name = op.FormatName(fi.ColumnName); sbNames.Append(name); if (!isFirst) { sbValues.Append(", "); } else { isFirst = false; } //// 可空类型插入空 //if (!obj.Dirtys[fi.Name] && fi.DataObjectField.IsNullable) // sbValues.Append("null"); //else //sbValues.Append(SqlDataFormat(obj[fi.Name], fi)); // 数据 if (!fi.IsIdentity) { if (!UseParam(fi)) { sbValues.Append(op.FormatValue(fi, entity[fi.Name])); } else { var paraname = op.FormatParameterName(fi.ColumnName); sbValues.Append(paraname); var dp = op.CreateParameter(); dp.ParameterName = paraname; //dp.Value = entity[fi.Name] ?? DBNull.Value; dp.Value = FormatParamValue(fi, entity[fi.Name], op); dp.IsNullable = fi.IsNullable; dps.Add(dp); } } else { sbValues.Append(idv); } } if (sbNames.Length <= 0) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Insert Into {0}({1}) Values({2})", op.FormatName(op.TableName), sbNames, sbValues)); #endregion case DataObjectMethodType.Update: #region Update sbNames = new StringBuilder(); //sbParams = new StringBuilder(); dps = new List <DbParameter>(); // 只读列没有更新操作 foreach (FieldItem fi in op.Fields) { if (fi.IsIdentity) { continue; } //脏数据判断 if (!entity.Dirtys[fi.Name]) { continue; } if (!isFirst) { sbNames.Append(", "); // 加逗号 } else { isFirst = false; } var name = op.FormatName(fi.ColumnName); sbNames.Append(name); sbNames.Append("="); //sbNames.Append(SqlDataFormat(obj[fi.Name], fi)); // 数据 if (!UseParam(fi)) { // 检查累加 Object addvalue = null; Boolean sign; if (entity.TryGetAdditionalValue(fi.Name, out addvalue, out sign)) { if (sign) { sbNames.AppendFormat("{0}+{1}", name, addvalue); } else { sbNames.AppendFormat("{0}-{1}", name, addvalue); } } else { sbNames.Append(op.FormatValue(fi, entity[fi.Name])); // 数据 } } else { var paraname = op.FormatParameterName(fi.ColumnName); sbNames.Append(paraname); var dp = op.CreateParameter(); dp.ParameterName = paraname; dp.Value = FormatParamValue(fi, entity[fi.Name], op); dp.IsNullable = fi.IsNullable; dps.Add(dp); } } if (sbNames.Length <= 0) { return(null); } sql = DefaultCondition(entity); if (String.IsNullOrEmpty(sql)) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Update {0} Set {1} Where {2}", op.FormatName(op.TableName), sbNames, sql)); #endregion case DataObjectMethodType.Delete: // 标识列作为删除关键字 sql = DefaultCondition(entity); if (String.IsNullOrEmpty(sql)) { return(null); } return(String.Format("Delete From {0} Where {1}", op.FormatName(op.TableName), sql)); } return(null); }
/// <summary>从数据库中删除指定属性列表和值列表所限定的实体对象。</summary> /// <param name="entityType">实体类</param> /// <param name="names">属性列表</param> /// <param name="values">值列表</param> /// <returns></returns> public virtual Int32 Delete(Type entityType, String[] names, Object[] values) { IEntityOperate op = EntityFactory.CreateOperate(entityType); return(Delete(entityType, op.MakeCondition(names, values, "And"))); }
static String UpdateSQL(IEntity entity, ref IDataParameter[] parameters) { /* * 实体更新原则: * 1,自增不参与 * 2,没有脏数据不参与 * 3,大字段参数化特殊处理 * 4,累加字段特殊处理 */ var def = DefaultCondition(entity); //if (String.IsNullOrEmpty(def)) return null; if (def.IsEmpty) { return(null); } // 处理累加字段 var dfs = (entity as EntityBase).GetAddition(); var op = EntityFactory.CreateOperate(entity.GetType()); var up = op.Session.Dal.Db.UseParameter; var sb = Pool.StringBuilder.Get(); var dps = new List <IDataParameter>(); // 只读列没有更新操作 foreach (var fi in op.Fields) { if (fi.IsIdentity) { continue; } //脏数据判断 if (!entity.IsDirty(fi.Name)) { continue; } var value = entity[fi.Name]; sb.Separate(", "); // 加逗号 var name = op.FormatName(fi.ColumnName); sb.Append(name); sb.Append("="); // 检查累加 var flag = TryCheckAdditionalValue(dfs, fi.Name, out var val, out var sign); if (up || UseParam(fi, value)) { var dp = CreateParameter(op, fi, flag ? val : value); dps.Add(dp); // 检查累加 if (flag) { if (sign) { sb.AppendFormat("{0}+{1}", name, dp.ParameterName); } else { sb.AppendFormat("{0}-{1}", name, dp.ParameterName); } } else { sb.Append(dp.ParameterName); } } else { // 检查累加 if (flag) { if (sign) { sb.AppendFormat("{0}+{1}", name, val); } else { sb.AppendFormat("{0}-{1}", name, val); } } else { sb.Append(op.FormatValue(fi, value)); } } } // 重置累加数据 if (dfs != null && dfs.Count > 0) { (entity as EntityBase).Addition.Reset(dfs); } var str = sb.Put(true); if (str.IsNullOrEmpty()) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Update {0} Set {1} Where {2}", op.FormatedTableName, str, def)); }
static String UpdateSQL(IEntity entity, ref DbParameter[] parameters) { /* * 实体更新原则: * 1,自增不参与 * 2,没有脏数据不参与 * 3,大字段参数化特殊处理 * 4,累加字段特殊处理 */ var def = DefaultCondition(entity); if (String.IsNullOrEmpty(def)) { return(null); } var op = EntityFactory.CreateOperate(entity.GetType()); var sb = new StringBuilder(); var dps = new List <DbParameter>(); // 只读列没有更新操作 foreach (var fi in op.Fields) { if (fi.IsIdentity) { continue; } //脏数据判断 if (!entity.Dirtys[fi.Name]) { continue; } var value = entity[fi.Name]; sb.Separate(", "); // 加逗号 var name = op.FormatName(fi.ColumnName); sb.Append(name); sb.Append("="); /*注释的是之前的代码,看起来应该是传错了参数 树獭*/ if (UseParam(fi, value)) //if (UseParam(fi, entity)) { dps.Add(CreateParameter(sb, op, fi, value)); } else { // 检查累加 if (!CheckAdditionalValue(sb, entity, fi.Name, name)) { sb.Append(op.FormatValue(fi, value)); // 数据 } } } if (sb.Length <= 0) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Update {0} Set {1} Where {2}", op.FormatedTableName, sb, def)); }
static String InsertSQL(IEntity entity, ref DbParameter[] parameters) { var op = EntityFactory.CreateOperate(entity.GetType()); /* * 插入数据原则: * 1,有脏数据的字段一定要参与 * 2,没有脏数据,允许空的字段不参与 * 3,没有脏数据,不允许空,有默认值的不参与 * 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 */ var sbNames = new StringBuilder(); var sbValues = new StringBuilder(); //sbParams = new StringBuilder(); var dps = new List <DbParameter>(); // 只读列没有插入操作 foreach (var fi in op.Fields) { var value = entity[fi.Name]; // 标识列不需要插入,别的类型都需要 if (CheckIdentity(fi, value, op, sbNames, sbValues)) { continue; } // 1,有脏数据的字段一定要参与同时对于实体有值的也应该参与(针对通过置空主键的方式另存) if (!entity.Dirtys[fi.Name] && value == null) { // 2,没有脏数据,允许空的字段不参与 if (fi.IsNullable) { continue; } // 3,没有脏数据,不允许空,有默认值的不参与 if (fi.DefaultValue != null) { continue; } // 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 //switch (Type.GetTypeCode(fi.Type)) //{ // case TypeCode.DateTime: // value = DateTime.MinValue; // break; // case TypeCode.String: // value = ""; // break; // default: // break; //} value = FormatParamValue(fi, null, op); } //// 有默认值,并且没有设置值时,不参与插入操作 //// 20120509增加,同时还得判断是否相同数据库或者数据库默认值,比如MSSQL数据库默认值不是GetDate,那么其它数据库是不可能使用的 //if (!String.IsNullOrEmpty(fi.DefaultValue) && !entity.Dirtys[fi.Name] && CanUseDefault(fi, op)) continue; sbNames.Separate(", ").Append(op.FormatName(fi.ColumnName)); sbValues.Separate(", "); //// 可空类型插入空 //if (!obj.Dirtys[fi.Name] && fi.DataObjectField.IsNullable) // sbValues.Append("null"); //else //sbValues.Append(SqlDataFormat(obj[fi.Name], fi)); // 数据 if (UseParam(fi, entity)) { dps.Add(CreateParameter(sbValues, op, fi, value)); } else { sbValues.Append(op.FormatValue(fi, value)); } } if (sbNames.Length <= 0) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } return(String.Format("Insert Into {0}({1}) Values({2})", op.FormatedTableName, sbNames, sbValues)); }
//#region 事件 ///// <summary>设置实体Guid之前触发事件,通过Cancel控制是否取消Guid的自动设置</summary> //public event EventHandler<EntityPersistEventArgs> OnSetGuid; //Boolean AllowSetGuid(IEntity entity) //{ // if (OnSetGuid != null) // { // var e = new EntityPersistEventArgs() { Entity = entity }; // OnSetGuid(this, e); // return !e.Cancel; // } // return false; //} ///// <summary>插入自增之前触发事件,通过Cancel控制是否插入自增</summary> //public event EventHandler<EntityPersistEventArgs> OnInsertIdentity; //Boolean AllowInsertIdentity(IEntity entity) //{ // if (OnInsertIdentity != null) // { // var e = new EntityPersistEventArgs() { Entity = entity }; // OnInsertIdentity(this, e); // return !e.Cancel; // } // return false; //} //#endregion #region 添删改方法 /// <summary>插入</summary> /// <param name="entity"></param> /// <returns></returns> public virtual Int32 Insert(IEntity entity) { var op = EntityFactory.CreateOperate(entity.GetType()); // 添加数据前,处理Guid var fi = op.AutoSetGuidField; if (fi != null) { //SetGuid(entity); // 判断是否设置了数据 if (!entity.Dirtys[fi.Name]) { // 如果没有设置,这里给它设置 if (fi.Type == typeof(Guid)) { entity.SetItem(fi.Name, Guid.NewGuid()); } else { entity.SetItem(fi.Name, Guid.NewGuid().ToString()); } } } DbParameter[] dps = null; var sql = SQL(entity, DataObjectMethodType.Insert, ref dps); if (String.IsNullOrEmpty(sql)) { return(0); } Int32 rs = 0; //检查是否有标识列,标识列需要特殊处理 var field = op.Table.Identity; var bAllow = op.AllowInsertIdentity; if (field != null && field.IsIdentity && !bAllow) { Int64 res = dps != null && dps.Length > 0 ? op.InsertAndGetIdentity(sql, CommandType.Text, dps) : op.InsertAndGetIdentity(sql); if (res > 0) { entity[field.Name] = res; } rs = res > 0 ? 1 : 0; } else { if (bAllow) { var dal = DAL.Create(op.ConnName); if (dal.DbType == DatabaseType.SqlServer) { // 如果所有字段都不是自增,则取消对自增的处理 if (op.Fields.All(f => !f.IsIdentity)) { bAllow = false; } if (bAllow) { sql = String.Format("SET IDENTITY_INSERT {1} ON;{0};SET IDENTITY_INSERT {1} OFF", sql, op.FormatName(op.TableName)); } } } rs = dps != null && dps.Length > 0 ? op.Execute(sql, CommandType.Text, dps) : op.Execute(sql); } //清除脏数据,避免连续两次调用Save造成重复提交 if (entity.Dirtys != null) { entity.Dirtys.Clear(); } return(rs); }
static String InsertSQL(IEntity entity, ref IDataParameter[] parameters) { var fact = EntityFactory.CreateOperate(entity.GetType()); var usep = fact.Session.Dal.Db.UseParameter; /* * 插入数据原则: * 1,有脏数据的字段一定要参与 * 2,没有脏数据,允许空的字段不参与 * 3,没有脏数据,不允许空,有默认值的不参与 * 4,没有脏数据,不允许空,没有默认值的参与,需要智能识别并添加相应字段的默认数据 */ // 缓存参数化时的SQL语句 //var key = "{0}_Insert".F(entity.GetType().FullName); var sql = ""; //StringBuilder sbNames = null; //StringBuilder sbValues = null; //if (!up || !op.Session.Items.TryGetValue(key, out var oql)) //{ var sbNames = Pool.StringBuilder.Get(); var sbValues = Pool.StringBuilder.Get(); //} //else // sql = oql + ""; var dps = new List <IDataParameter>(); // 只读列没有插入操作 foreach (var fi in fact.Fields) { var value = entity[fi.Name]; // 标识列不需要插入,别的类型都需要 if (sbNames != null && CheckIdentity(fi, value, fact, sbNames, sbValues)) { continue; } // 1,有脏数据的字段一定要参与 if (!fact.FullInsert && !entity.IsDirty(fi.Name)) { continue; } if (sbNames != null) { sbNames.Separate(", ").Append(fact.FormatName(fi.ColumnName)); } if (sbValues != null) { sbValues.Separate(", "); } if (usep || UseParam(fi, value)) { var dp = CreateParameter(fact, fi, value); dps.Add(dp); sbValues.Append(dp.ParameterName); } else { sbValues.Append(fact.FormatValue(fi, value)); } } var ns = sbNames.Put(true); var vs = sbValues.Put(true); if (ns.IsNullOrEmpty() && sql.IsNullOrEmpty()) { return(null); } if (dps.Count > 0) { parameters = dps.ToArray(); } if (!ns.IsNullOrEmpty()) { sql = String.Format("Insert Into {0}({1}) Values({2})", fact.FormatedTableName, ns, vs); //// 缓存参数化时的SQL语句 //if (up) op.Session.Items[key] = sql; } return(sql); }