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.Addition?.Get();
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.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).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("=");
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)); // 数据
}
}
}
// 重置累加数据
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 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));
}
static String InsertSQL(IEntity entity, ref IDataParameter[] parameters)
{
var op = EntityFactory.CreateOperate(entity.GetType());
var up = op.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))
{
sbNames = Pool.StringBuilder.Get();
sbValues = Pool.StringBuilder.Get();
}
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.IsDirty(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));
}
}
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})", op.FormatedTableName, ns, vs);
// 缓存参数化时的SQL语句
if (up)
{
op.Session.Items[key] = sql;
}
}
return(sql);
}
