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