public override int Update <TEntity>(TEntity entity, string table)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
PublicHelper.EnsureHasPrimaryKey(typeDescriptor);
Dictionary <PropertyDescriptor, object> keyValueMap = PrimaryKeyHelper.CreateKeyValueMap(typeDescriptor);
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <PropertyDescriptor, DbExpression> updateColumns = new Dictionary <PropertyDescriptor, DbExpression>();
foreach (PropertyDescriptor propertyDescriptor in typeDescriptor.PropertyDescriptors)
{
if (keyValueMap.ContainsKey(propertyDescriptor))
{
keyValueMap[propertyDescriptor] = propertyDescriptor.GetValue(entity);
continue;
}
bool hasSequence = propertyDescriptor.HasSequence();
if (hasSequence)
{
continue;
}
object val = propertyDescriptor.GetValue(entity);
if (entityState != null && !entityState.HasChanged(propertyDescriptor, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
updateColumns.Add(propertyDescriptor, valExp);
}
if (updateColumns.Count == 0)
{
return(0);
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbExpression conditionExp = PrimaryKeyHelper.MakeCondition(keyValueMap, dbTable);
DbUpdateExpression e = new DbUpdateExpression(dbTable, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int ret = this.ExecuteNonQuery(e);
if (entityState != null)
{
entityState.Refresh();
}
return(ret);
}
/// <summary>
/// 对 memberExpression 进行求值
/// </summary>
/// <param name="exp"></param>
/// <returns>返回 DbParameterExpression</returns>
public static DbParameterExpression ConvertToParameterExpression(this DbMemberExpression memberExpression)
{
//求值
object val = Evaluate(memberExpression);
return(DbExpression.Parameter(val, memberExpression.Type));
}
public override DbExpression Visit(DbMemberExpression exp)
{
if (exp.Expression != null)
{
DbExpression caller = exp.Expression.Accept(this);
if (caller != exp.Expression)
{
exp = DbExpression.MemberAccess(exp.Member, caller);
}
}
if (exp.Expression != null)
{
if (!IsConstantOrParameter(exp.Expression))
{
return(exp);
}
}
MemberInfo member = exp.Member;
if (this.CanTranslateToSql(exp))
{
return(exp);
}
return(DbExpression.Parameter(exp.Evaluate(), exp.Type));
}
public override TEntity Insert <TEntity>(TEntity entity, string table)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
List <PropertyDescriptor> outputColumns = new List <PropertyDescriptor>();
Dictionary <PropertyDescriptor, DbExpression> insertColumns = new Dictionary <PropertyDescriptor, DbExpression>();
foreach (PropertyDescriptor propertyDescriptor in typeDescriptor.PropertyDescriptors)
{
if (propertyDescriptor.IsAutoIncrement)
{
outputColumns.Add(propertyDescriptor);
continue;
}
if (propertyDescriptor.HasSequence())
{
DbMethodCallExpression getNextValueForSequenceExp = PublicHelper.MakeNextValueForSequenceDbExpression(propertyDescriptor);
insertColumns.Add(propertyDescriptor, getNextValueForSequenceExp);
outputColumns.Add(propertyDescriptor);
continue;
}
object val = propertyDescriptor.GetValue(entity);
DbExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
insertColumns.Add(propertyDescriptor, valExp);
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbInsertExpression e = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
e.Returns.AddRange(outputColumns.Select(a => a.Column));
List <DbParam> parameters;
this.ExecuteNonQuery(e, out parameters);
List <DbParam> outputParams = parameters.Where(a => a.Direction == ParamDirection.Output).ToList();
for (int i = 0; i < outputColumns.Count; i++)
{
PropertyDescriptor propertyDescriptor = outputColumns[i];
string putputColumnName = Utils.GenOutputColumnParameterName(propertyDescriptor.Column.Name);
DbParam outputParam = outputParams.Where(a => a.Name == putputColumnName).First();
var outputValue = PublicHelper.ConvertObjType(outputParam.Value, propertyDescriptor.PropertyType);
outputColumns[i].SetValue(entity, outputValue);
}
return(entity);
}
/// <summary>
/// 修改
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public TEntity Edit(TEntity entity)
{
Checks.NotNull(entity, "entity");
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
object keyVal = null;
MappingMemberDescriptor keyMemberDescriptor = null;
Dictionary <MappingMemberDescriptor, DbExpression> updateColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
object val = memberDescriptor.GetValue(entity);
if (memberDescriptor.SZColumnAttribute.IsKey)
{
if (val == null)
{
throw new SZORMException("主键值不允许为空.");
}
keyVal = val;
keyMemberDescriptor = memberDescriptor;
continue;
}
if (memberDescriptor.SZColumnAttribute.IsEditTime)
{
val = DateTime.Now;
memberDescriptor.SetValue(entity, val);
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
updateColumns.Add(memberDescriptor, valExp);
}
DbExpression left = new DbColumnAccessExpression(typeDescriptor.Table, keyMemberDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyMemberDescriptor.MemberInfoType);
DbExpression conditionExp = new DbEqualExpression(left, right);
DbUpdateExpression e = new DbUpdateExpression(typeDescriptor.Table, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
IDbExpressionTranslator translator = this.DbContext.DatabaseProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = translator.Translate(e, out parameters);
this.DbContext.ExecuteNoQuery(sql, parameters.ToArray());
return(entity);
}
public override TEntity Insert <TEntity>(TEntity entity, string table)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(entity.GetType());
Dictionary <PropertyDescriptor, object> keyValueMap = CreateKeyValueMap(typeDescriptor);
Dictionary <PropertyDescriptor, object> sequenceValues = this.GetSequenceValues(typeDescriptor.PropertyDescriptors.Where(a => a.HasSequence()).ToList());
Dictionary <PropertyDescriptor, DbExpression> insertColumns = new Dictionary <PropertyDescriptor, DbExpression>();
foreach (PropertyDescriptor propertyDescriptor in typeDescriptor.PropertyDescriptors)
{
object val = null;
if (propertyDescriptor.HasSequence())
{
val = sequenceValues[propertyDescriptor];
}
else
{
val = propertyDescriptor.GetValue(entity);
}
if (propertyDescriptor.IsPrimaryKey)
{
keyValueMap[propertyDescriptor] = val;
}
DbExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
insertColumns.Add(propertyDescriptor, valExp);
}
PropertyDescriptor nullValueKey = keyValueMap.Where(a => a.Value == null).Select(a => a.Key).FirstOrDefault();
if (nullValueKey != null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", nullValueKey.Property.Name));
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbInsertExpression e = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
this.ExecuteSqlCommand(e);
foreach (var kv in sequenceValues)
{
kv.Key.SetValue(entity, kv.Value);
}
return(entity);
}
/// <summary>
/// 对 memberExpression 进行求值
/// </summary>
/// <param name="exp"></param>
/// <returns>返回 DbParameterExpression</returns>
public static DbParameterExpression ParseToParameterExpression(this DbMemberExpression memberExpression)
{
DbParameterExpression ret = null;
//求值
object val = DbExpressionExtensions.GetExpressionValue(memberExpression);
ret = DbExpression.Parameter(val, memberExpression.Type);
return(ret);
}
public override DbExpression Visit(DbCoalesceExpression exp)
{
exp = new DbCoalesceExpression(exp.CheckExpression.Accept(this), exp.ReplacementValue.Accept(this));
if (IsConstantOrParameter(exp.CheckExpression) && IsConstantOrParameter(exp.ReplacementValue))
{
return(DbExpression.Parameter(exp.Evaluate(), exp.Type));
}
return(exp);
}
public override DbExpression Visit(DbConvertExpression exp)
{
exp = DbExpression.Convert(exp.Operand.Accept(this), exp.Type);
if (!IsConstantOrParameter(exp.Operand))
{
return(exp);
}
return(DbExpression.Parameter(exp.Evaluate(), exp.Type));
}
public virtual object Insert <T>(Expression <Func <T> > body)
{
Utils.CheckNull(body);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(typeof(T));
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(body);
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
object keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
MappingMemberDescriptor memberDescriptor = typeDescriptor.TryGetMappingMemberDescriptor(key);
if (memberDescriptor == null)
{
throw new ChloeException(string.Format("The member '{0}' does not map any column.", key.Name));
}
if (memberDescriptor.IsPrimaryKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", memberDescriptor.MemberInfo.Name));
}
else
{
keyVal = val;
e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
continue;
}
}
e.InsertColumns.Add(memberDescriptor.Column, typeDescriptor.Visitor.Visit(kv.Value));
}
//主键为空
if (keyVal == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
this.ExecuteSqlCommand(e);
return(keyVal);
}
/// <summary>
/// 增加
/// </summary>
/// <param name="body">() => new User() { Name = "lu", Age = 18, Gender = Gender.Man, CityId = 1, OpTime = DateTime.Now }</param>
/// <returns></returns>
public string Add(Expression <Func <TEntity> > body)
{
Checks.NotNull(body, "body");
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(typeof(TEntity));
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(body);
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
string keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
MappingMemberDescriptor memberDescriptor = typeDescriptor.TryGetMappingMemberDescriptor(key);
//如果是主键
if (memberDescriptor.SZColumnAttribute.IsKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null || string.IsNullOrEmpty(val.ToString()))
{
val = GetNewKey();
keyVal = val.ToString();
e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
continue;
}
}
//如果是添加或修改时间
if (memberDescriptor.SZColumnAttribute.IsAddTime || memberDescriptor.SZColumnAttribute.IsEditTime)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
val = DateTime.Now;
e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
continue;
}
e.InsertColumns.Add(memberDescriptor.Column, typeDescriptor.Visitor.Visit(kv.Value));
}
IDbExpressionTranslator translator = this.DbContext._dbContextServiceProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = translator.Translate(e, out parameters);
this.DbContext.ExecuteNoQuery(sql, parameters.ToArray());
return(keyVal);
}
public virtual T Insert <T>(T entity)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = typeDescriptor.PrimaryKey.MemberInfo;
object keyValue = null;
Dictionary <MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
var val = memberDescriptor.GetValue(entity);
if (memberDescriptor == keyMemberDescriptor)
{
keyValue = val;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
insertColumns.Add(memberDescriptor, valExp);
}
//主键为空并且主键又不是自增列
if (keyValue == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
this.ExecuteSqlCommand(e);
return(entity);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public TEntity Add(TEntity entity)
{
Checks.NotNull(entity, "entity");
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
Dictionary <MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
object val = memberDescriptor.GetValue(entity);
if (memberDescriptor.SZColumnAttribute.IsKey)
{
if (val == null || string.IsNullOrEmpty(val.ToString()))
{
val = GetNewKey();
memberDescriptor.SetValue(entity, val);
}
}
if (memberDescriptor.SZColumnAttribute.IsAddTime || memberDescriptor.SZColumnAttribute.IsEditTime)
{
val = DateTime.Now;
memberDescriptor.SetValue(entity, val);
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
insertColumns.Add(memberDescriptor, valExp);
}
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
IDbExpressionTranslator translator = this.DbContext.DatabaseProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = translator.Translate(e, out parameters);
this.DbContext.ExecuteNoQuery(sql, parameters.ToArray());
return(entity);
}
public static DbExpression MakeCondition(PairList <PrimitivePropertyDescriptor, object> propertyValuePairs, DbTable dbTable)
{
DbExpression conditionExp = null;
foreach (var pair in propertyValuePairs)
{
PrimitivePropertyDescriptor propertyDescriptor = pair.Item1;
object val = pair.Item2;
DbExpression left = new DbColumnAccessExpression(dbTable, propertyDescriptor.Column);
DbExpression right = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
DbExpression equalExp = new DbEqualExpression(left, right);
conditionExp = conditionExp.And(equalExp);
}
return(conditionExp);
}
public override DbExpression Visit(DbMethodCallExpression exp)
{
var args = exp.Arguments.Select(a => a.Accept(this)).ToList();
DbExpression caller = exp.Object;
if (exp.Object != null)
{
caller = exp.Object.Accept(this);
}
exp = DbExpression.MethodCall(caller, exp.Method, args);
if (exp.Object != null)
{
if (!IsConstantOrParameter(exp.Object))
{
return(exp);
}
}
foreach (var arg in exp.Arguments)
{
if (!IsConstantOrParameter(arg))
{
return(exp);
}
}
if (this.CanTranslateToSql(exp))
{
return(exp);
}
if (exp.Method.IsDefined(typeof(DbFunctionAttribute)))
{
return(exp);
}
return(DbExpression.Parameter(exp.Evaluate(), exp.Type));
}
static DbExpression MakeCondition(Dictionary <PropertyDescriptor, object> keyValueMap, DbTable dbTable)
{
DbExpression conditionExp = null;
foreach (var kv in keyValueMap)
{
PropertyDescriptor keyPropertyDescriptor = kv.Key;
object keyVal = kv.Value;
if (keyVal == null)
{
throw new ArgumentException(string.Format("The primary key '{0}' could not be null.", keyPropertyDescriptor.Property.Name));
}
DbExpression left = new DbColumnAccessExpression(dbTable, keyPropertyDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyPropertyDescriptor.PropertyType, keyPropertyDescriptor.Column.DbType);
DbExpression equalExp = new DbEqualExpression(left, right);
conditionExp = conditionExp == null ? equalExp : DbExpression.And(conditionExp, equalExp);
}
return(conditionExp);
}
public override DbExpression Visit(DbExistsExpression exp)
{
this.SqlBuilder.Append("Exists ");
DbSqlQueryExpression rawSqlQuery = exp.SqlQuery;
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression()
{
TakeCount = rawSqlQuery.TakeCount,
SkipCount = rawSqlQuery.SkipCount,
Table = rawSqlQuery.Table,
Condition = rawSqlQuery.Condition,
HavingCondition = rawSqlQuery.HavingCondition,
};
sqlQuery.GroupSegments.AddRange(rawSqlQuery.GroupSegments);
DbColumnSegment columnSegment = new DbColumnSegment(DbExpression.Parameter("1"), "C");
sqlQuery.ColumnSegments.Add(columnSegment);
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
return(subQuery.Accept(this));
}
protected virtual async Task <int> Update <TEntity>(TEntity entity, string table, bool @async)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
PublicHelper.EnsureHasPrimaryKey(typeDescriptor);
PairList <PrimitivePropertyDescriptor, object> keyValues = new PairList <PrimitivePropertyDescriptor, object>(typeDescriptor.PrimaryKeys.Count);
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <PrimitivePropertyDescriptor, DbExpression> updateColumns = new Dictionary <PrimitivePropertyDescriptor, DbExpression>();
foreach (PrimitivePropertyDescriptor propertyDescriptor in typeDescriptor.PrimitivePropertyDescriptors)
{
if (propertyDescriptor.IsPrimaryKey)
{
var keyValue = propertyDescriptor.GetValue(entity);
PrimaryKeyHelper.KeyValueNotNull(propertyDescriptor, keyValue);
keyValues.Add(propertyDescriptor, keyValue);
continue;
}
if (propertyDescriptor.IsAutoIncrement || propertyDescriptor.HasSequence() || propertyDescriptor.IsRowVersion)
{
continue;
}
object val = propertyDescriptor.GetValue(entity);
PublicHelper.NotNullCheck(propertyDescriptor, val);
if (entityState != null && !entityState.HasChanged(propertyDescriptor, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
updateColumns.Add(propertyDescriptor, valExp);
}
object rowVersionNewValue = null;
if (typeDescriptor.HasRowVersion())
{
var rowVersionDescriptor = typeDescriptor.RowVersion;
var rowVersionOldValue = rowVersionDescriptor.GetValue(entity);
rowVersionNewValue = PublicHelper.IncreaseRowVersionNumber(rowVersionOldValue);
updateColumns.Add(rowVersionDescriptor, DbExpression.Parameter(rowVersionNewValue, rowVersionDescriptor.PropertyType, rowVersionDescriptor.Column.DbType));
keyValues.Add(rowVersionDescriptor, rowVersionOldValue);
}
if (updateColumns.Count == 0)
{
return(0);
}
DbTable dbTable = PublicHelper.CreateDbTable(typeDescriptor, table);
DbExpression conditionExp = PublicHelper.MakeCondition(keyValues, dbTable);
DbUpdateExpression e = new DbUpdateExpression(dbTable, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int rowsAffected = await this.ExecuteNonQuery(e, @async);
if (typeDescriptor.HasRowVersion())
{
PublicHelper.CauseErrorIfOptimisticUpdateFailed(rowsAffected);
typeDescriptor.RowVersion.SetValue(entity, rowVersionNewValue);
}
if (entityState != null)
{
entityState.Refresh();
}
return(rowsAffected);
}
protected virtual async Task <object> Insert <TEntity>(Expression <Func <TEntity> > content, string table, bool @async)
{
PublicHelper.CheckNull(content);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
if (typeDescriptor.PrimaryKeys.Count > 1)
{
/* 对于多主键的实体，暂时不支持调用这个方法进行插入 */
throw new NotSupportedException(string.Format("Can not call this method because entity '{0}' has multiple keys.", typeDescriptor.Definition.Type.FullName));
}
PrimitivePropertyDescriptor keyPropertyDescriptor = typeDescriptor.PrimaryKeys.FirstOrDefault();
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(content);
DbTable explicitDbTable = null;
if (table != null)
{
explicitDbTable = new DbTable(table, typeDescriptor.Table.Schema);
}
DefaultExpressionParser expressionParser = typeDescriptor.GetExpressionParser(explicitDbTable);
DbInsertExpression e = new DbInsertExpression(explicitDbTable ?? typeDescriptor.Table);
object keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
PrimitivePropertyDescriptor propertyDescriptor = typeDescriptor.GetPrimitivePropertyDescriptor(key);
if (propertyDescriptor.IsAutoIncrement)
{
throw new ChloeException(string.Format("Could not insert value into the identity column '{0}'.", propertyDescriptor.Column.Name));
}
if (propertyDescriptor.IsPrimaryKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", propertyDescriptor.Property.Name));
}
else
{
keyVal = val;
e.InsertColumns.Add(propertyDescriptor.Column, DbExpression.Parameter(keyVal, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType));
continue;
}
}
e.InsertColumns.Add(propertyDescriptor.Column, expressionParser.Parse(kv.Value));
}
if (keyPropertyDescriptor != null)
{
//主键为空并且主键又不是自增列
if (keyVal == null && !keyPropertyDescriptor.IsAutoIncrement)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyPropertyDescriptor.Property.Name));
}
}
if (keyPropertyDescriptor == null || !keyPropertyDescriptor.IsAutoIncrement)
{
await this.ExecuteNonQuery(e, @async);
return(keyVal); /* It will return null if an entity does not define primary key. */
}
IDbExpressionTranslator translator = this.DatabaseProvider.CreateDbExpressionTranslator();
DbCommandInfo dbCommandInfo = translator.Translate(e);
dbCommandInfo.CommandText = string.Concat(dbCommandInfo.CommandText, ";", this.GetSelectLastInsertIdClause());
//SELECT @@IDENTITY 返回的是 decimal 类型
object retIdentity = await this.ExecuteScalar(dbCommandInfo, @async);
if (retIdentity == null || retIdentity == DBNull.Value)
{
throw new ChloeException("Unable to get the identity value.");
}
retIdentity = PublicHelper.ConvertObjectType(retIdentity, typeDescriptor.AutoIncrement.PropertyType);
return(retIdentity);
}
protected virtual async Task <TEntity> Insert <TEntity>(TEntity entity, string table, bool @async)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
Dictionary <PrimitivePropertyDescriptor, object> keyValueMap = PrimaryKeyHelper.CreateKeyValueMap(typeDescriptor);
Dictionary <PrimitivePropertyDescriptor, DbExpression> insertColumns = new Dictionary <PrimitivePropertyDescriptor, DbExpression>();
foreach (PrimitivePropertyDescriptor propertyDescriptor in typeDescriptor.PrimitivePropertyDescriptors)
{
if (propertyDescriptor.IsAutoIncrement)
{
continue;
}
object val = propertyDescriptor.GetValue(entity);
if (propertyDescriptor.IsPrimaryKey)
{
keyValueMap[propertyDescriptor] = val;
}
PublicHelper.NotNullCheck(propertyDescriptor, val);
DbParameterExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
insertColumns.Add(propertyDescriptor, valExp);
}
PrimitivePropertyDescriptor nullValueKey = keyValueMap.Where(a => a.Value == null && !a.Key.IsAutoIncrement).Select(a => a.Key).FirstOrDefault();
if (nullValueKey != null)
{
/* 主键为空并且主键又不是自增列 */
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", nullValueKey.Property.Name));
}
DbTable dbTable = PublicHelper.CreateDbTable(typeDescriptor, table);
DbInsertExpression e = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
PrimitivePropertyDescriptor autoIncrementPropertyDescriptor = typeDescriptor.AutoIncrement;
if (autoIncrementPropertyDescriptor == null)
{
await this.ExecuteNonQuery(e, @async);
return(entity);
}
IDbExpressionTranslator translator = this.DatabaseProvider.CreateDbExpressionTranslator();
DbCommandInfo dbCommandInfo = translator.Translate(e);
dbCommandInfo.CommandText = string.Concat(dbCommandInfo.CommandText, ";", this.GetSelectLastInsertIdClause());
//SELECT @@IDENTITY 返回的是 decimal 类型
object retIdentity = await this.ExecuteScalar(dbCommandInfo, @async);
if (retIdentity == null || retIdentity == DBNull.Value)
{
throw new ChloeException("Unable to get the identity value.");
}
retIdentity = PublicHelper.ConvertObjectType(retIdentity, autoIncrementPropertyDescriptor.PropertyType);
autoIncrementPropertyDescriptor.SetValue(entity, retIdentity);
return(entity);
}
public void Process(DbMethodCallExpression exp, SqlGeneratorBase generator)
{
MethodInfo method = exp.Method;
if (exp.Method == PublicConstants.MethodInfo_String_Contains)
{
Method_String_Contains(exp, generator);
return;
}
List <DbExpression> exps = new List <DbExpression>();
IEnumerable values = null;
DbExpression operand = null;
Type declaringType = method.DeclaringType;
if (typeof(IList).IsAssignableFrom(declaringType) || (declaringType.IsGenericType && typeof(ICollection <>).MakeGenericType(declaringType.GetGenericArguments()).IsAssignableFrom(declaringType)))
{
if (exp.Object.NodeType == DbExpressionType.SqlQuery)
{
/* where Id in(select id from T) */
operand = exp.Arguments[0];
In(generator, (DbSqlQueryExpression)exp.Object, operand);
return;
}
if (!exp.Object.IsEvaluable())
{
throw new NotSupportedException(exp.ToString());
}
values = DbExpressionExtension.Evaluate(exp.Object) as IEnumerable; //Enumerable
operand = exp.Arguments[0];
goto constructInState;
}
if (method.IsStatic && declaringType == typeof(Enumerable) && exp.Arguments.Count == 2)
{
DbExpression arg0 = exp.Arguments[0];
if (arg0.NodeType == DbExpressionType.SqlQuery)
{
/* where Id in(select id from T) */
operand = exp.Arguments[1];
In(generator, (DbSqlQueryExpression)arg0, operand);
return;
}
if (!arg0.IsEvaluable())
{
throw UtilExceptions.NotSupportedMethod(exp.Method);
}
values = DbExpressionExtension.Evaluate(arg0) as IEnumerable;
operand = exp.Arguments[1];
goto constructInState;
}
throw UtilExceptions.NotSupportedMethod(exp.Method);
constructInState:
foreach (object value in values)
{
if (value == null)
{
exps.Add(DbExpression.Constant(null, operand.Type));
}
else
{
Type valueType = value.GetType();
if (valueType.IsEnum)
{
valueType = Enum.GetUnderlyingType(valueType);
}
if (Utils.IsToStringableNumericType(valueType))
{
exps.Add(DbExpression.Constant(value));
}
else
{
exps.Add(DbExpression.Parameter(value));
}
}
}
In(generator, exps, operand);
}
public override object Insert <TEntity>(Expression <Func <TEntity> > content, string table)
{
PublicHelper.CheckNull(content);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(typeof(TEntity));
if (typeDescriptor.PrimaryKeys.Count > 1)
{
/* 对于多主键的实体，暂时不支持调用这个方法进行插入 */
throw new NotSupportedException(string.Format("Can not call this method because entity '{0}' has multiple keys.", typeDescriptor.Definition.Type.FullName));
}
PropertyDescriptor keyPropertyDescriptor = typeDescriptor.PrimaryKeys.FirstOrDefault();
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(content);
DbTable explicitDbTable = null;
if (table != null)
{
explicitDbTable = new DbTable(table, typeDescriptor.Table.Schema);
}
DefaultExpressionParser expressionParser = typeDescriptor.GetExpressionParser(explicitDbTable);
DbInsertExpression insertExp = new DbInsertExpression(explicitDbTable ?? typeDescriptor.Table);
object keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
PropertyDescriptor propertyDescriptor = typeDescriptor.TryGetPropertyDescriptor(key);
if (propertyDescriptor == null)
{
throw new ChloeException(string.Format("The member '{0}' does not map any column.", key.Name));
}
if (propertyDescriptor.IsAutoIncrement)
{
throw new ChloeException(string.Format("Could not insert value into the auto increment column '{0}'.", propertyDescriptor.Column.Name));
}
if (propertyDescriptor.HasSequence())
{
throw new ChloeException(string.Format("Can not insert value into the column '{0}', because it's mapping member has define a sequence.", propertyDescriptor.Column.Name));
}
if (propertyDescriptor.IsPrimaryKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", propertyDescriptor.Property.Name));
}
else
{
keyVal = val;
insertExp.InsertColumns.Add(propertyDescriptor.Column, DbExpression.Parameter(keyVal, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType));
continue;
}
}
insertExp.InsertColumns.Add(propertyDescriptor.Column, expressionParser.Parse(kv.Value));
}
foreach (PropertyDescriptor propertyDescriptor in typeDescriptor.PropertyDescriptors)
{
if (propertyDescriptor.IsAutoIncrement && propertyDescriptor.IsPrimaryKey)
{
insertExp.Returns.Add(propertyDescriptor.Column);
continue;
}
if (propertyDescriptor.HasSequence())
{
DbMethodCallExpression getNextValueForSequenceExp = PublicHelper.MakeNextValueForSequenceDbExpression(propertyDescriptor);
insertExp.InsertColumns.Add(propertyDescriptor.Column, getNextValueForSequenceExp);
if (propertyDescriptor.IsPrimaryKey)
{
insertExp.Returns.Add(propertyDescriptor.Column);
}
continue;
}
}
if (keyPropertyDescriptor != null)
{
//主键为空并且主键又不是自增列
if (keyVal == null && !keyPropertyDescriptor.IsAutoIncrement && !keyPropertyDescriptor.HasSequence())
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyPropertyDescriptor.Property.Name));
}
}
List <DbParam> parameters;
this.ExecuteNonQuery(insertExp, out parameters);
if (keyPropertyDescriptor != null && (keyPropertyDescriptor.IsAutoIncrement || keyPropertyDescriptor.HasSequence()))
{
string outputColumnName = Utils.GenOutputColumnParameterName(keyPropertyDescriptor.Column.Name);
DbParam outputParam = parameters.Where(a => a.Direction == ParamDirection.Output && a.Name == outputColumnName).First();
keyVal = PublicHelper.ConvertObjType(outputParam.Value, keyPropertyDescriptor.PropertyType);
}
return(keyVal); /* It will return null if an entity does not define primary key. */
}
public override TEntity Insert <TEntity>(TEntity entity, string table)
{
PublicHelper.CheckNull(entity);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(entity.GetType());
Dictionary <PropertyDescriptor, object> keyValueMap = CreateKeyValueMap(typeDescriptor);
Dictionary <PropertyDescriptor, DbExpression> insertColumns = new Dictionary <PropertyDescriptor, DbExpression>();
foreach (PropertyDescriptor propertyDescriptor in typeDescriptor.PropertyDescriptors)
{
if (propertyDescriptor.IsAutoIncrement)
{
continue;
}
if (propertyDescriptor.HasSequence())
{
DbMethodCallExpression getNextValueForSequenceExp = PublicHelper.MakeNextValueForSequenceDbExpression(propertyDescriptor);
insertColumns.Add(propertyDescriptor, getNextValueForSequenceExp);
continue;
}
object val = propertyDescriptor.GetValue(entity);
if (propertyDescriptor.IsPrimaryKey)
{
keyValueMap[propertyDescriptor] = val;
}
DbExpression valExp = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
insertColumns.Add(propertyDescriptor, valExp);
}
PropertyDescriptor nullValueKey = keyValueMap.Where(a => a.Value == null && !a.Key.IsAutoIncrement).Select(a => a.Key).FirstOrDefault();
if (nullValueKey != null)
{
/* 主键为空并且主键又不是自增列 */
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", nullValueKey.Property.Name));
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbInsertExpression insertExp = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
insertExp.InsertColumns.Add(kv.Key.Column, kv.Value);
}
List <PropertyDescriptor> outputColumns = typeDescriptor.PropertyDescriptors.Where(a => a.IsAutoIncrement || a.HasSequence()).ToList();
if (outputColumns.Count == 0)
{
this.ExecuteSqlCommand(insertExp);
return(entity);
}
List <Action <TEntity, IDataReader> > mappers = new List <Action <TEntity, IDataReader> >();
IDbExpressionTranslator translator = this.DatabaseProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = null;
if (outputColumns.Count == 1 && outputColumns[0].IsAutoIncrement)
{
sql = translator.Translate(insertExp, out parameters);
/* 自增 id 不能用 output inserted.Id 输出，因为如果表设置了触发器的话会报错 */
sql = string.Concat(sql, ";", this.GetSelectLastInsertIdClause());
mappers.Add(GetMapper <TEntity>(outputColumns[0], 0));
}
else
{
foreach (PropertyDescriptor outputColumn in outputColumns)
{
mappers.Add(GetMapper <TEntity>(outputColumn, insertExp.Returns.Count));
insertExp.Returns.Add(outputColumn.Column);
}
sql = translator.Translate(insertExp, out parameters);
}
IDataReader dataReader = this.Session.ExecuteReader(sql, parameters.ToArray());
using (dataReader)
{
dataReader.Read();
foreach (var mapper in mappers)
{
mapper(entity, dataReader);
}
}
return(entity);
}
public override int Update <TEntity>(TEntity entity, string table)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = keyMemberDescriptor.MemberInfo;
object keyVal = null;
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <MappingMemberDescriptor, DbExpression> updateColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
if (member == keyMember)
{
keyVal = memberDescriptor.GetValue(entity);
keyMemberDescriptor = memberDescriptor;
continue;
}
SequenceAttribute attr = (SequenceAttribute)memberDescriptor.GetCustomAttribute(typeof(SequenceAttribute));
if (attr != null)
{
continue;
}
object val = memberDescriptor.GetValue(entity);
if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
updateColumns.Add(memberDescriptor, valExp);
}
if (keyVal == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMember.Name));
}
if (updateColumns.Count == 0)
{
return(0);
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbExpression left = new DbColumnAccessExpression(dbTable, keyMemberDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyMemberDescriptor.MemberInfoType);
DbExpression conditionExp = new DbEqualExpression(left, right);
DbUpdateExpression e = new DbUpdateExpression(dbTable, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int ret = this.ExecuteSqlCommand(e);
if (entityState != null)
{
entityState.Refresh();
}
return(ret);
}
public override TEntity Insert <TEntity>(TEntity entity, string table)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = typeDescriptor.PrimaryKey.MemberInfo;
object keyValue = null;
string sequenceName;
object sequenceValue = null;
MappingMemberDescriptor defineSequenceMemberDescriptor = GetDefineSequenceMemberDescriptor(typeDescriptor, out sequenceName);
if (defineSequenceMemberDescriptor != null)
{
sequenceValue = ConvertIdentityType(this.GetSequenceNextValue(sequenceName), defineSequenceMemberDescriptor.MemberInfoType);
}
Dictionary <MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
object val = null;
if (defineSequenceMemberDescriptor != null && memberDescriptor == defineSequenceMemberDescriptor)
{
val = sequenceValue;
}
else
{
val = memberDescriptor.GetValue(entity);
}
if (memberDescriptor == keyMemberDescriptor)
{
keyValue = val;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
insertColumns.Add(memberDescriptor, valExp);
}
if (keyMemberDescriptor != null && keyValue == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbInsertExpression e = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
this.ExecuteSqlCommand(e);
if (defineSequenceMemberDescriptor != null)
{
defineSequenceMemberDescriptor.SetValue(entity, sequenceValue);
}
return(entity);
}
public override object Insert <TEntity>(Expression <Func <TEntity> > content, string table)
{
Utils.CheckNull(content);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(typeof(TEntity));
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
string sequenceName;
object sequenceValue = null;
MappingMemberDescriptor defineSequenceMemberDescriptor = GetDefineSequenceMemberDescriptor(typeDescriptor, out sequenceName);
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(content);
DbTable explicitDbTable = null;
if (table != null)
{
explicitDbTable = new DbTable(table, typeDescriptor.Table.Schema);
}
DefaultExpressionParser expressionParser = typeDescriptor.GetExpressionParser(explicitDbTable);
DbInsertExpression e = new DbInsertExpression(explicitDbTable ?? typeDescriptor.Table);
object keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
MappingMemberDescriptor memberDescriptor = typeDescriptor.TryGetMappingMemberDescriptor(key);
if (memberDescriptor == null)
{
throw new ChloeException(string.Format("The member '{0}' does not map any column.", key.Name));
}
if (memberDescriptor == defineSequenceMemberDescriptor)
{
throw new ChloeException(string.Format("Can not insert value into the column '{0}', because it's mapping member has define a sequence.", memberDescriptor.Column.Name));
}
if (memberDescriptor.IsPrimaryKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", memberDescriptor.MemberInfo.Name));
}
else
{
keyVal = val;
e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
continue;
}
}
e.InsertColumns.Add(memberDescriptor.Column, expressionParser.Parse(kv.Value));
}
if (keyMemberDescriptor == defineSequenceMemberDescriptor)
{
sequenceValue = ConvertIdentityType(this.GetSequenceNextValue(sequenceName), defineSequenceMemberDescriptor.MemberInfoType);
keyVal = sequenceValue;
e.InsertColumns.Add(keyMemberDescriptor.Column, DbExpression.Parameter(keyVal));
}
if (keyMemberDescriptor != null && keyVal == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
this.ExecuteSqlCommand(e);
return(keyVal); /* It will return null if an entity does not define primary key. */
}
public override T Insert <T>(T entity)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = typeDescriptor.PrimaryKey.MemberInfo;
object keyValue = null;
MappingMemberDescriptor autoIncrementMemberDescriptor = GetAutoIncrementMemberDescriptor(typeDescriptor);
Dictionary <MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
if (memberDescriptor == autoIncrementMemberDescriptor)
{
continue;
}
var val = memberDescriptor.GetValue(entity);
if (memberDescriptor == keyMemberDescriptor)
{
keyValue = val;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
insertColumns.Add(memberDescriptor, valExp);
}
//主键为空并且主键又不是自增列
if (keyValue == null && keyMemberDescriptor != autoIncrementMemberDescriptor)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
if (autoIncrementMemberDescriptor == null)
{
this.ExecuteSqlCommand(e);
return(entity);
}
IDbExpressionTranslator translator = this.DbContextServiceProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = translator.Translate(e, out parameters);
sql += ";SELECT @@IDENTITY";
//SELECT @@IDENTITY 返回的是 decimal 类型
object retIdentity = this.CurrentSession.ExecuteScalar(sql, parameters.ToArray());
if (retIdentity == null || retIdentity == DBNull.Value)
{
throw new ChloeException("Unable to get the identity value.");
}
retIdentity = ConvertIdentityType(retIdentity, autoIncrementMemberDescriptor.MemberInfoType);
autoIncrementMemberDescriptor.SetValue(entity, retIdentity);
return(entity);
}
public override object Insert <T>(Expression <Func <T> > body)
{
Utils.CheckNull(body);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(typeof(T));
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MappingMemberDescriptor autoIncrementMemberDescriptor = GetAutoIncrementMemberDescriptor(typeDescriptor);
Dictionary <MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(body);
DbInsertExpression e = new DbInsertExpression(typeDescriptor.Table);
object keyVal = null;
foreach (var kv in insertColumns)
{
MemberInfo key = kv.Key;
MappingMemberDescriptor memberDescriptor = typeDescriptor.TryGetMappingMemberDescriptor(key);
if (memberDescriptor == null)
{
throw new ChloeException(string.Format("The member '{0}' does not map any column.", key.Name));
}
if (memberDescriptor == autoIncrementMemberDescriptor)
{
throw new ChloeException(string.Format("Could not insert value into the identity column '{0}'.", memberDescriptor.Column.Name));
}
if (memberDescriptor.IsPrimaryKey)
{
object val = ExpressionEvaluator.Evaluate(kv.Value);
if (val == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", memberDescriptor.MemberInfo.Name));
}
else
{
keyVal = val;
e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
continue;
}
}
e.InsertColumns.Add(memberDescriptor.Column, typeDescriptor.Visitor.Visit(kv.Value));
}
//主键为空并且主键又不是自增列
if (keyVal == null && keyMemberDescriptor != autoIncrementMemberDescriptor)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name));
}
if (autoIncrementMemberDescriptor == null)
{
this.ExecuteSqlCommand(e);
return(keyVal);
}
IDbExpressionTranslator translator = this.DbContextServiceProvider.CreateDbExpressionTranslator();
List <DbParam> parameters;
string sql = translator.Translate(e, out parameters);
sql += ";SELECT @@IDENTITY";
//SELECT @@IDENTITY 返回的是 decimal 类型
object retIdentity = this.CurrentSession.ExecuteScalar(sql, parameters.ToArray());
if (retIdentity == null || retIdentity == DBNull.Value)
{
throw new ChloeException("Unable to get the identity value.");
}
retIdentity = ConvertIdentityType(retIdentity, autoIncrementMemberDescriptor.MemberInfoType);
return(retIdentity);
}
public override TEntity Insert <TEntity>(TEntity entity, string table)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
Dictionary <MappingMemberDescriptor, object> keyValueMap = CreateKeyValueMap(typeDescriptor);
string sequenceName;
object sequenceValue = null;
MappingMemberDescriptor defineSequenceMemberDescriptor = GetDefineSequenceMemberDescriptor(typeDescriptor, out sequenceName);
if (defineSequenceMemberDescriptor != null)
{
if (defineSequenceMemberDescriptor.IsPrimaryKey && typeDescriptor.PrimaryKeys.Count > 1)
{
/* 自增列不能作为联合主键成员 */
throw new ChloeException("The member of marked sequence can not be union key.");
}
sequenceValue = ConvertIdentityType(this.GetSequenceNextValue(sequenceName), defineSequenceMemberDescriptor.MemberInfoType);
}
Dictionary <MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
object val = null;
if (defineSequenceMemberDescriptor != null && memberDescriptor == defineSequenceMemberDescriptor)
{
val = sequenceValue;
}
else
{
val = memberDescriptor.GetValue(entity);
}
if (keyValueMap.ContainsKey(memberDescriptor))
{
keyValueMap[memberDescriptor] = val;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
insertColumns.Add(memberDescriptor, valExp);
}
MappingMemberDescriptor nullValueKey = keyValueMap.Where(a => a.Value == null).Select(a => a.Key).FirstOrDefault();
if (nullValueKey != null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", nullValueKey.MemberInfo.Name));
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbInsertExpression e = new DbInsertExpression(dbTable);
foreach (var kv in insertColumns)
{
e.InsertColumns.Add(kv.Key.Column, kv.Value);
}
this.ExecuteSqlCommand(e);
if (defineSequenceMemberDescriptor != null)
{
defineSequenceMemberDescriptor.SetValue(entity, sequenceValue);
}
return(entity);
}
public override int Update <TEntity>(TEntity entity, string table)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
Dictionary <MappingMemberDescriptor, object> keyValueMap = CreateKeyValueMap(typeDescriptor);
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <MappingMemberDescriptor, DbExpression> updateColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MappingMemberDescriptor memberDescriptor = kv.Value;
if (keyValueMap.ContainsKey(memberDescriptor))
{
keyValueMap[memberDescriptor] = memberDescriptor.GetValue(entity);
continue;
}
SequenceAttribute attr = (SequenceAttribute)memberDescriptor.GetCustomAttribute(typeof(SequenceAttribute));
if (attr != null)
{
continue;
}
object val = memberDescriptor.GetValue(entity);
if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
updateColumns.Add(memberDescriptor, valExp);
}
if (updateColumns.Count == 0)
{
return(0);
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbExpression conditionExp = MakeCondition(keyValueMap, dbTable);
DbUpdateExpression e = new DbUpdateExpression(dbTable, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int ret = this.ExecuteSqlCommand(e);
if (entityState != null)
{
entityState.Refresh();
}
return(ret);
}
