/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns></returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (query.MemberMap == null)
{
query.MemberMap = sqlTool.GetSelectMemberMap(memberMap);
}
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
if (DataModel.Model <modelType> .Identity != null)
{
if (!query.NotQuery)
{
getByIdentity(sqlStream, sqlTool.TableName, value, query.MemberMap);
query.Sql = sqlStream.ToString();
sqlStream.ByteSize = 0;
}
sqlStream.SimpleWriteNotNull(" update `");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.SimpleWriteNotNull("` set ");
DataModel.Model <modelType> .Updater.Update(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool);
sqlStream.SimpleWriteNotNull(" where ");
sqlStream.SimpleWriteNotNull(DataModel.Model <modelType> .IdentitySqlName);
sqlStream.Write('=');
AutoCSer.Extension.Number.ToString(DataModel.Model <modelType> .GetIdentity(value), sqlStream);
sqlStream.Write(';');
query.UpdateSql = sqlStream.ToString();
return(true);
}
if (DataModel.Model <modelType> .PrimaryKeys.Length != 0)
{
if (!query.NotQuery)
{
getByPrimaryKey(sqlStream, sqlTool.TableName, value, query.MemberMap);
query.Sql = sqlStream.ToString();
sqlStream.ByteSize = 0;
}
sqlStream.WriteNotNull(" update `");
sqlStream.WriteNotNull(sqlTool.TableName);
sqlStream.WriteNotNull("` set ");
DataModel.Model <modelType> .Updater.Update(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool);
sqlStream.WriteNotNull(" where ");
DataModel.Model <modelType> .PrimaryKeyWhere.Write(sqlStream, value, ConstantConverter.Default);
sqlStream.Write(';');
query.UpdateSql = sqlStream.ToString();
return(true);
}
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
return(false);
}
public static MemberMap <T, ushort> PartFilename <T>(this MemberMap <T, ushort> map, string partType)
{
return(map.TypeConverter(Utils.GetFileNameConverter(partType)));
}
public static void Set(DbDataReader reader, valueType value, MemberMap memberMap)
{
#if NOJIT
if (fields != null)
{
int index = 0;
object[] sqlColumnParameters = null, castParameters = null;
foreach (sqlModel.setField field in fields)
{
AutoCSer.code.cSharp.sqlModel.fieldInfo fieldInfo = field.Field;
if (memberMap.IsMember(fieldInfo.MemberMapIndex))
{
if (fieldInfo.DataReaderMethod == null)
{
if (sqlColumnParameters == null)
{
sqlColumnParameters = new object[] { reader, null, null }
}
;
sqlColumnParameters[1] = null;
sqlColumnParameters[2] = index;
field.SqlColumnMethod.Invoke(null, sqlColumnParameters);
fieldInfo.Field.SetValue(value, sqlColumnParameters[1]);
index = (int)sqlColumnParameters[2];
}
else
{
object memberValue;
if (fieldInfo.DataType == fieldInfo.NullableDataType && (fieldInfo.DataType.IsValueType || !fieldInfo.DataMember.IsNull))
{
memberValue = reader[index++];
if (fieldInfo.ToModelCastMethod != null)
{
if (castParameters == null)
{
castParameters = new object[1];
}
castParameters[0] = memberValue;
memberValue = fieldInfo.ToModelCastMethod.Invoke(null, castParameters);
}
}
else if (reader.IsDBNull(index))
{
memberValue = null;
++index;
}
else
{
memberValue = reader[index++];
if (fieldInfo.ToModelCastMethod != null && fieldInfo.DataType == fieldInfo.NullableDataType)
{
if (castParameters == null)
{
castParameters = new object[1];
}
castParameters[0] = memberValue;
memberValue = fieldInfo.ToModelCastMethod.Invoke(null, castParameters);
}
}
fieldInfo.Field.SetValue(value, memberValue);
}
}
}
}
#else
if (setter != null)
{
setter(reader, value, memberMap);
}
#endif
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue"></param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap"></param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
keyType key = getKey(value), oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
onInserted(cacheValue, key);
onDeleted(oldKey);
}
}
/// <summary>
/// Creates a member expression for the given member on the record.
/// This will recursively traverse the mapping to find the member
/// and create a safe member accessor for each level as it goes.
/// </summary>
/// <param name="recordExpression">The current member expression.</param>
/// <param name="mapping">The mapping to look for the member to map on.</param>
/// <param name="memberMap">The member map to look for on the mapping.</param>
/// <returns>An Expression to access the given member.</returns>
public virtual Expression CreateGetMemberExpression(Expression recordExpression, ClassMap mapping, MemberMap memberMap)
{
if (mapping.MemberMaps.Any(mm => mm == memberMap))
{
// The member is on this level.
if (memberMap.Data.Member is PropertyInfo)
{
return(Expression.Property(recordExpression, (PropertyInfo)memberMap.Data.Member));
}
if (memberMap.Data.Member is FieldInfo)
{
return(Expression.Field(recordExpression, (FieldInfo)memberMap.Data.Member));
}
}
// The member isn't on this level of the mapping.
// We need to search down through the reference maps.
foreach (var refMap in mapping.ReferenceMaps)
{
var wrapped = refMap.Data.Member.GetMemberExpression(recordExpression);
var memberExpression = CreateGetMemberExpression(wrapped, refMap.Data.Mapping, memberMap);
if (memberExpression == null)
{
continue;
}
if (refMap.Data.Member.MemberType().GetTypeInfo().IsValueType)
{
return(memberExpression);
}
var nullCheckExpression = Expression.Equal(wrapped, Expression.Constant(null));
var isValueType = memberMap.Data.Member.MemberType().GetTypeInfo().IsValueType;
var isGenericType = isValueType && memberMap.Data.Member.MemberType().GetTypeInfo().IsGenericType;
Type memberType;
if (isValueType && !isGenericType && !writer.Configuration.UseNewObjectForNullReferenceMembers)
{
memberType = typeof(Nullable <>).MakeGenericType(memberMap.Data.Member.MemberType());
memberExpression = Expression.Convert(memberExpression, memberType);
}
else
{
memberType = memberMap.Data.Member.MemberType();
}
var defaultValueExpression = isValueType && !isGenericType
? (Expression)Expression.New(memberType)
: Expression.Constant(null, memberType);
var conditionExpression = Expression.Condition(nullCheckExpression, defaultValueExpression, memberExpression);
return(conditionExpression);
}
return(null);
}
public FieldInfo[] GetFields(BindingFlags bindFlags)
{
return(MemberMap.GetFields(GetAllPropertyNames()));
}
public static bool Verify(modelType value, MemberMap memberMap, Table sqlTool)
{
#if NOJIT
if (fields != null)
{
object[] sqlColumnParameters = null, castParameters = null;
foreach (sqlModel.verifyField field in fields)
{
AutoCSer.code.cSharp.sqlModel.fieldInfo fieldInfo = field.Field;
if (memberMap.IsMember(fieldInfo.MemberMapIndex))
{
object memberValue = fieldInfo.Field.GetValue(value);
if (field.IsSqlVerify)
{
if (!fieldInfo.Field.FieldType.IsValueType && memberValue == null)
{
return(false);
}
if (!(bool)((AutoCSer.emit.sqlTable.ISqlVerify)memberValue).IsSqlVeify())
{
return(false);
}
}
else if (fieldInfo.IsSqlColumn)
{
if (sqlColumnParameters == null)
{
sqlColumnParameters = new object[] { null, sqlTool, null }
}
;
sqlColumnParameters[0] = memberValue;
sqlColumnParameters[2] = fieldInfo.Field.Name;
if (!(bool)field.SqlColumnMethod.Invoke(null, sqlColumnParameters))
{
return(false);
}
}
else if (fieldInfo.DataType == typeof(string))
{
if (fieldInfo.ToSqlCastMethod != null)
{
if (castParameters == null)
{
castParameters = new object[1];
}
castParameters[0] = memberValue;
memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters);
}
dataMember dataMember = fieldInfo.DataMember;
if (!sqlTool.StringVerify(fieldInfo.Field.Name, (string)memberValue, dataMember.MaxStringLength, dataMember.IsAscii, dataMember.IsNull))
{
return(false);
}
}
else
{
if (fieldInfo.ToSqlCastMethod != null && !fieldInfo.IsUnknownJson)
{
if (castParameters == null)
{
castParameters = new object[1];
}
castParameters[0] = memberValue;
memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters);
}
if (memberValue == null)
{
sqlTool.NullVerify(fieldInfo.Field.Name);
return(false);
}
}
}
}
}
return(true);
#else
return(verifyer == null || verifyer(value, memberMap, sqlTool));
#endif
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue">缓存数据</param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap"></param>
private void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
keyType key = getKey(value);
if (cacheValue == null)
{
ListArray <valueType> values;
if (queueCache.Remove(ref key, out values))
{
foreach (valueType removeValue in values)
{
counter.Remove(removeValue);
}
}
}
else
{
keyType oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
ListArray <valueType> values = queueCache.Get(ref key, null), oldValues = queueCache.Get(ref oldKey, null);
if (values != null)
{
if (oldValues != null)
{
values.Add(cacheValue);
if (!oldValues.Remove(cacheValue))
{
counter.SqlTable.Log.Fatal(typeof(valueType).FullName + " 缓存同步错误", LogLevel.Fatal | LogLevel.AutoCSer);
}
}
else
{
values.Add(counter.Add(cacheValue));
}
}
else if (oldValues != null)
{
if (oldValues.Remove(cacheValue))
{
counter.Remove(cacheValue);
}
else
{
counter.SqlTable.Log.Fatal(typeof(valueType).FullName + " 缓存同步错误", LogLevel.Fatal | LogLevel.AutoCSer);
}
}
}
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue"></param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap"></param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
keyType key = getKey(value), oldKey = getKey(oldValue);
int index = getIndex(value), oldIndex = getIndex(oldValue);
if (key.Equals(oldKey))
{
if (index != oldIndex)
{
targetType target = getValue(key);
if (target == null)
{
cache.SqlTable.Log.Add(AutoCSer.Log.LogType.Debug | AutoCSer.Log.LogType.Info, typeof(valueType).FullName + " 没有找到缓存目标对象 " + key.ToString());
}
else
{
LazyOrderArray <valueType>[] arrays = getMember(target);
if (arrays != null)
{
LazyOrderArray <valueType> array = arrays[index];
if (array == null)
{
arrays[index] = array = new LazyOrderArray <valueType>();
}
array.Insert(cacheValue);
if ((array = arrays[oldIndex]) != null)
{
array.Delete(cacheValue);
return;
}
}
cache.SqlTable.Log.Add(AutoCSer.Log.LogType.Fatal, typeof(valueType).FullName + " 缓存同步错误");
}
}
}
else
{
onInserted(cacheValue, key, index);
onDeleted(cacheValue, oldKey, getIndex(oldValue));
}
}
public static void Insert(CharStream sqlStream, MemberMap memberMap, modelType value, ConstantConverter converter, Table table)
{
#if NOJIT
if (fields != null)
{
object[] sqlColumnParameters = null, castParameters = null, parameters = null;
byte isNext = 0;
foreach (InsertField field in fields)
{
if (memberMap.IsMember(field.Field.MemberMapIndex))
{
if (isNext == 0)
{
isNext = 1;
}
else
{
sqlStream.Write(',');
}
Field fieldInfo = field.Field;
if (fieldInfo.IsSqlColumn)
{
if (sqlColumnParameters == null)
{
sqlColumnParameters = new object[] { sqlStream, null, converter }
}
;
sqlColumnParameters[1] = fieldInfo.FieldInfo.GetValue(value);
field.SqlColumnMethod.Invoke(null, sqlColumnParameters);
}
else if (fieldInfo.NowTimeField == null)
{
object memberValue = fieldInfo.FieldInfo.GetValue(value);
if (fieldInfo.ToSqlCastMethod != null)
{
if (castParameters == null)
{
castParameters = new object[1];
}
castParameters[0] = memberValue;
memberValue = fieldInfo.ToSqlCastMethod.Invoke(null, castParameters);
}
if (parameters == null)
{
parameters = new object[] { sqlStream, null }
}
;
parameters[1] = memberValue;
fieldInfo.ToSqlMethod.Invoke(converter, parameters);
}
else
{
if (parameters == null)
{
parameters = new object[] { sqlStream, null }
}
;
parameters[1] = fieldInfo.NowTimeField.GetValue(null);
fieldInfo.ToSqlMethod.Invoke(converter, parameters);
}
}
}
}
#else
if (inserter != null)
{
inserter(sqlStream, memberMap, value, converter, table);
}
#endif
}
public EntityMember GetMemberFromColumn(ColumnSchema column)
{
return((MemberMap.ContainsKey(column))
? MemberMap[column]
: null);
}
/// <summary>
/// 获取添加数据 SQL 语句
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="value">添加数据</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">添加数据查询信息</param>
internal override void insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref InsertQuery query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
if (DataModel.Model <modelType> .Identity != null)
{
long identity;
if (sqlTool.Attribute.IsSetIdentity)
{
DataModel.Model <modelType> .SetIdentity(value, identity = sqlTool.NextIdentity);
}
else
{
sqlTool.Identity64 = identity = DataModel.Model <modelType> .GetIdentity(value);
}
sqlStream.WriteNotNull("insert into`");
sqlStream.WriteNotNull(sqlTool.TableName);
sqlStream.WriteNotNull("`(");
DataModel.Model <modelType> .Inserter.GetColumnNames(sqlStream, memberMap);
sqlStream.WriteNotNull(")values(");
DataModel.Model <modelType> .Inserter.Insert(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool);
sqlStream.WriteNotNull(");");
query.InsertSql = sqlStream.ToString();
if (!query.NotQuery)
{
sqlStream.ByteSize = 0;
getByIdentity(sqlStream, sqlTool.TableName, value, memberMap);
query.Sql = sqlStream.ToString();
}
}
else
{
sqlStream.WriteNotNull("insert into`");
sqlStream.WriteNotNull(sqlTool.TableName);
sqlStream.WriteNotNull("`(");
DataModel.Model <modelType> .Inserter.GetColumnNames(sqlStream, memberMap);
sqlStream.WriteNotNull(")values(");
DataModel.Model <modelType> .Inserter.Insert(sqlStream, memberMap, value, ConstantConverter.Default, sqlTool);
sqlStream.WriteNotNull(");");
query.InsertSql = sqlStream.ToString();
if (!query.NotQuery && DataModel.Model <modelType> .PrimaryKeys.Length != 0)
{
sqlStream.ByteSize = 0;
getByPrimaryKey(sqlStream, sqlTool.TableName, value, memberMap);
query.Sql = sqlStream.ToString();
}
}
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="transaction">事务操作</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, Transaction transaction, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (sqlTool.CallOnUpdate(value, memberMap) && executeNonQuery(transaction, query.UpdateSql) > 0)
{
sqlTool.CallOnUpdated(transaction, value, memberMap);
return(true);
}
return(false);
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (query.NotQuery)
{
if (executeNonQuery(ref connection, query.UpdateSql) > 0)
{
sqlTool.CallOnUpdated(value, null, memberMap);
return(true);
}
}
else
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = query.MemberMap, Sql = query.Sql
};
valueType oldValue = AutoCSer.Emit.Constructor <valueType> .New();
if (Get(sqlTool, ref connection, oldValue, ref getQuery) && executeNonQuery(connection, query.UpdateSql) > 0 && Get(sqlTool, ref connection, value, ref getQuery))
{
sqlTool.CallOnUpdated(value, oldValue, memberMap);
return(true);
}
}
return(false);
}
public bool Update(valueType value, MemberMap <modelType> memberMap, bool isIgnoreTransaction = false)
{
valueType cacheLock = this[AutoCSer.Sql.DataModel.Model <modelType> .GetIdentity32(value)];
return(cacheLock != null && SqlTable.UpdateQueue(value, memberMap, isIgnoreTransaction));
}
/// <summary>
/// 获取分组数据成员位图
/// </summary>
/// <param name="group">分组</param>
/// <returns>分组数据成员位图</returns>
private static MemberMap <modelType> getGroupMemberMap(int group)
{
if (groupMemberMaps == null)
{
LeftArray <KeyValue <MemberMap <modelType>, int> > memberMaps = new LeftArray <KeyValue <MemberMap <modelType>, int> >();
memberMaps.Add(new KeyValue <MemberMap <modelType>, int>(MemberMap, 0));
Monitor.Enter(groupMemberMapLock);
if (groupMemberMaps == null)
{
try
{
foreach (Field field in Fields)
{
if (field.DataMember.Group != 0)
{
int index = memberMaps.Length;
foreach (KeyValue <MemberMap <modelType>, int> memberMap in memberMaps.Array)
{
if (memberMap.Value == field.DataMember.Group || --index == 0)
{
break;
}
}
if (index == 0)
{
MemberMap <modelType> memberMap = new MemberMap <modelType>();
memberMaps.Add(new KeyValue <MemberMap <modelType>, int>(memberMap, field.DataMember.Group));
memberMap.SetMember(field.MemberMapIndex);
}
else
{
memberMaps.Array[memberMaps.Length - index].Key.SetMember(field.MemberMapIndex);
}
}
}
if (memberMaps.Length != 1)
{
MemberMap <modelType> memberMap = memberMaps.Array[0].Key = new MemberMap <modelType>();
foreach (Field field in Fields)
{
if (field.DataMember.Group == 0)
{
memberMap.SetMember(field.MemberMapIndex);
}
}
}
groupMemberMaps = memberMaps.ToArray();
}
finally { Monitor.Exit(groupMemberMapLock); }
}
else
{
Monitor.Exit(groupMemberMapLock);
}
}
foreach (KeyValue <MemberMap <modelType>, int> memberMap in groupMemberMaps)
{
if (memberMap.Value == group)
{
return(memberMap.Key);
}
}
AutoCSer.Log.Pub.Log.Add(AutoCSer.Log.LogType.Error, typeof(modelType).fullName() + " 缺少缓存分组 " + group.toString());
return(null);
}
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
onDeleted(oldValue);
onInserted(cacheValue);
}
public ValidationContext(TypePair types, MemberMap memberMap, IObjectMapper objectMapper) : this(types, memberMap, objectMapper, null)
{
}
private void onUpdated(valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
onInserted(value);
onDeleted(oldValue);
}
public ValidationContext(TypePair types, MemberMap memberMap, TypeMap typeMap) : this(types, memberMap, null, typeMap)
{
}
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression) =>
Expression.Call(destExpression.Type.GetMethod("Parse", new[] { typeof(string) }), sourceExpression);
private void DryRunTypeMap(ICollection <TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, MemberMap memberMap)
{
if (typeMap == null)
{
if (types.ContainsGenericParameters)
{
return;
}
typeMap = _config.ResolveTypeMap(types.SourceType, types.DestinationType);
}
if (typeMap != null)
{
if (typeMapsChecked.Contains(typeMap))
{
return;
}
typeMapsChecked.Add(typeMap);
var context = new ValidationContext(types, memberMap, typeMap);
Validate(context);
if (!typeMap.ShouldCheckForValid)
{
return;
}
CheckPropertyMaps(typeMapsChecked, typeMap);
typeMap.IsValid = true;
}
else
{
var mapperToUse = _config.FindMapper(types);
if (mapperToUse == null)
{
throw new AutoMapperConfigurationException(memberMap.TypeMap.Types)
{
MemberMap = memberMap
};
}
var context = new ValidationContext(types, memberMap, mapperToUse);
Validate(context);
if (mapperToUse is IObjectMapperInfo mapperInfo)
{
var newTypePair = mapperInfo.GetAssociatedTypes(types);
if (newTypePair != types)
{
DryRunTypeMap(typeMapsChecked, newTypePair, null, memberMap);
}
}
}
}
/// <summary>
/// Creates an expression the represents getting the field for the given
/// member and converting it to the member's type.
/// </summary>
/// <param name="memberMap">The mapping for the member.</param>
public virtual Expression CreateGetFieldExpression(MemberMap memberMap)
{
if (memberMap.Data.ReadingConvertExpression != null)
{
// The user is providing the expression to do the conversion.
Expression exp = Expression.Invoke(memberMap.Data.ReadingConvertExpression, Expression.Constant(new ConvertFromStringArgs {
Row = reader
}));
return(Expression.Convert(exp, memberMap.Data.Member.MemberType()));
}
if (!reader.CanRead(memberMap))
{
return(null);
}
if (memberMap.Data.TypeConverter == null)
{
// Skip if the type isn't convertible.
return(null);
}
int index;
if (memberMap.Data.IsNameSet || reader.Configuration.HasHeaderRecord && !memberMap.Data.IsIndexSet)
{
// Use the name.
index = reader.GetFieldIndex(memberMap.Data.Names.ToArray(), memberMap.Data.NameIndex, memberMap.Data.IsOptional);
if (index == -1)
{
if (memberMap.Data.IsDefaultSet)
{
return(CreateDefaultExpression(memberMap, Expression.Constant(string.Empty)));
}
// Skip if the index was not found.
return(null);
}
}
else
{
// Use the index.
index = memberMap.Data.Index;
}
// Get the field using the field index.
var method = typeof(IReaderRow).GetProperty("Item", typeof(string), new[] { typeof(int) }).GetGetMethod();
Expression fieldExpression = Expression.Call(Expression.Constant(reader), method, Expression.Constant(index, typeof(int)));
// Validate the field.
if (memberMap.Data.ValidateExpression != null)
{
var constructor = typeof(ValidateArgs).GetConstructor(new Type[] { typeof(string) });
var args = Expression.New(constructor, fieldExpression);
var validateExpression = Expression.IsFalse(Expression.Invoke(memberMap.Data.ValidateExpression, args));
var validationExceptionConstructor = typeof(FieldValidationException).GetConstructors().OrderBy(c => c.GetParameters().Length).First();
var newValidationExceptionExpression = Expression.New(validationExceptionConstructor, Expression.Constant(reader.Context), fieldExpression);
var throwExpression = Expression.Throw(newValidationExceptionExpression);
fieldExpression = Expression.Block(
// If the validate method returns false, throw an exception.
Expression.IfThen(validateExpression, throwExpression),
fieldExpression
);
}
if (memberMap.Data.IsConstantSet)
{
fieldExpression = Expression.Convert(Expression.Constant(memberMap.Data.Constant), memberMap.Data.Member.MemberType());
}
else if (memberMap.Data.IsDefaultSet)
{
return(CreateDefaultExpression(memberMap, fieldExpression));
}
else
{
fieldExpression = CreateTypeConverterExpression(memberMap, fieldExpression);
}
return(fieldExpression);
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="cacheValue"></param>
/// <param name="value">更新后的数据</param>
/// <param name="oldValue">更新前的数据</param>
/// <param name="memberMap"></param>
protected void onUpdated(valueType cacheValue, valueType value, valueType oldValue, MemberMap <modelType> memberMap)
{
keyType key = getKey(value), oldKey = getKey(oldValue);
if (!key.Equals(oldKey))
{
Array.Add(key, cacheValue);
Array.Remove(oldKey, out value);
if (value == null)
{
cache.SqlTable.Log.add(AutoCSer.Log.LogType.Fatal, typeof(valueType).FullName + " 缓存同步错误");
}
}
}
public void SetUp()
{
_sut = new MemberAccess();
_mapper = new MemberMap();
}
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap,
MemberMap memberMap, Expression sourceExpression, Expression destExpression) =>
Call(MapMethodInfo, sourceExpression, destExpression.ToObject(), Constant(destExpression.Type), ContextParameter, Constant(profileMap));
public void EmitMemberMap(LocalBuilderWrapper fromLocal, LocalBuilderWrapper toLocal,
MemberMap memberMap, HashSet <Type> convertedTypes)
{
var skipMemberMap = this.DefineLabel();
if (memberMap.FromMember.NeedsContainsCheck)
{
var containsKey = fromLocal.LocalType.GetMethod("ContainsKey", new[] { typeof(string) });
this.EmitLocal(fromLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, fromLocal);
this.EmitString(memberMap.FromMember.Name);
this.EmitCall(OpCodes.Call, containsKey);
this.EmitBreak(OpCodes.Brfalse, skipMemberMap);
}
// Load toLocal as parameter for the setter
this.EmitLocal(toLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, toLocal);
if (memberMap.ToMember.NeedsStringIndex)
{
this.EmitString(memberMap.ToMember.Name);
}
// Load fromLocal as parameter for the getter
this.EmitLocal(fromLocal.LocalType.IsValueType ? OpCodes.Ldloca : OpCodes.Ldloc, fromLocal);
if (memberMap.FromMember.MemberInfo is PropertyInfo)
{
var getter = (memberMap.FromMember.MemberInfo as PropertyInfo).GetGetMethod();
if (memberMap.FromMember.MemberType == MemberType.StringIndexer)
{
this.EmitString(memberMap.FromMember.Name);
}
this.EmitCall(OpCodes.Callvirt, getter);
}
else if (memberMap.FromMember.MemberInfo is FieldInfo)
{
this.EmitField(OpCodes.Ldfld, memberMap.FromMember.MemberInfo as FieldInfo);
}
else if (memberMap.FromMember.MemberInfo is MethodInfo)
{
var method = memberMap.FromMember.MemberInfo as MethodInfo;
if (memberMap.FromMember.NeedsStringIndex)
{
this.EmitString(memberMap.FromMember.Name);
}
this.EmitCall(OpCodes.Callvirt, method);
}
// Convert the value on top of the stack to the correct toType
this.EmitConvertValue(memberMap.FromMember.Type, memberMap.ToMember.Type, new HashSet <Type>(convertedTypes));
if (memberMap.ToMember.MemberInfo is PropertyInfo)
{
var setter = (memberMap.ToMember.MemberInfo as PropertyInfo).GetSetMethod();
this.EmitCall(OpCodes.Callvirt, setter);
}
else if (memberMap.ToMember.MemberInfo is FieldInfo)
{
this.EmitField(OpCodes.Stfld, memberMap.ToMember.MemberInfo as FieldInfo);
}
else if (memberMap.ToMember.MemberInfo is MethodInfo)
{
this.EmitCall(OpCodes.Call, memberMap.ToMember.MemberInfo as MethodInfo);
}
if (memberMap.FromMember.NeedsContainsCheck)
{
this.MarkLabel(skipMemberMap);
}
}
/// <summary>
/// Applies configuration to the given <see cref="MemberMap" />.
/// </summary>
/// <param name="memberMap">The member map.</param>
public void ApplyTo(MemberMap memberMap)
{
memberMap.Data.NameIndex = NameIndex;
}
/// <summary>
/// Creates an expression the represents getting the field for the given
/// member and converting it to the member's type.
/// </summary>
/// <param name="memberMap">The mapping for the member.</param>
public virtual Expression CreateGetFieldExpression(MemberMap memberMap)
{
if (memberMap.Data.ReadingConvertExpression != null)
{
// The user is providing the expression to do the conversion.
Expression exp = Expression.Invoke(memberMap.Data.ReadingConvertExpression, Expression.Constant(reader));
return(Expression.Convert(exp, memberMap.Data.Member.MemberType()));
}
if (!reader.CanRead(memberMap))
{
return(null);
}
if (memberMap.Data.TypeConverter == null)
{
// Skip if the type isn't convertible.
return(null);
}
int index;
if (memberMap.Data.IsNameSet || reader.Context.ReaderConfiguration.HasHeaderRecord && !memberMap.Data.IsIndexSet)
{
// Use the name.
index = reader.GetFieldIndex(memberMap.Data.Names.ToArray(), memberMap.Data.NameIndex, memberMap.Data.IsOptional);
if (index == -1)
{
// Skip if the index was not found.
return(null);
}
}
else
{
// Use the index.
index = memberMap.Data.Index;
}
// Get the field using the field index.
var method = typeof(IReaderRow).GetProperty("Item", typeof(string), new[] { typeof(int) }).GetGetMethod();
Expression fieldExpression = Expression.Call(Expression.Constant(reader), method, Expression.Constant(index, typeof(int)));
// Validate the field.
if (memberMap.Data.ValidateExpression != null)
{
var validateExpression = Expression.IsFalse(Expression.Invoke(memberMap.Data.ValidateExpression, fieldExpression));
var validationExceptionConstructor = typeof(ValidationException).GetConstructors().OrderBy(c => c.GetParameters().Length).First();
var throwExpression = Expression.Throw(Expression.Constant(new ValidationException(reader.Context)));
fieldExpression = Expression.Block(
// If the validate method returns false, throw an exception.
Expression.IfThen(validateExpression, throwExpression),
fieldExpression
);
}
// Convert the field.
var typeConverterExpression = Expression.Constant(memberMap.Data.TypeConverter);
memberMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions {
CultureInfo = reader.Context.ReaderConfiguration.CultureInfo
}, reader.Context.ReaderConfiguration.TypeConverterOptionsCache.GetOptions(memberMap.Data.Member.MemberType()), memberMap.Data.TypeConverterOptions);
// Create type converter expression.
Expression typeConverterFieldExpression = Expression.Call(typeConverterExpression, nameof(ITypeConverter.ConvertFromString), null, fieldExpression, Expression.Constant(reader), Expression.Constant(memberMap.Data));
typeConverterFieldExpression = Expression.Convert(typeConverterFieldExpression, memberMap.Data.Member.MemberType());
if (memberMap.Data.IsConstantSet)
{
fieldExpression = Expression.Convert(Expression.Constant(memberMap.Data.Constant), memberMap.Data.Member.MemberType());
}
else if (memberMap.Data.IsDefaultSet)
{
// Create default value expression.
Expression defaultValueExpression;
if (memberMap.Data.Member.MemberType() != typeof(string) && memberMap.Data.Default != null && memberMap.Data.Default.GetType() == typeof(string))
{
// The default is a string but the member type is not. Use a converter.
defaultValueExpression = Expression.Call(typeConverterExpression, nameof(ITypeConverter.ConvertFromString), null, Expression.Constant(memberMap.Data.Default), Expression.Constant(reader), Expression.Constant(memberMap.Data));
}
else
{
// The member type and default type match.
defaultValueExpression = Expression.Constant(memberMap.Data.Default);
}
defaultValueExpression = Expression.Convert(defaultValueExpression, memberMap.Data.Member.MemberType());
// If null, use string.Empty.
var coalesceExpression = Expression.Coalesce(fieldExpression, Expression.Constant(string.Empty));
// Check if the field is an empty string.
var checkFieldEmptyExpression = Expression.Equal(Expression.Convert(coalesceExpression, typeof(string)), Expression.Constant(string.Empty, typeof(string)));
// Use a default value if the field is an empty string.
fieldExpression = Expression.Condition(checkFieldEmptyExpression, defaultValueExpression, typeConverterFieldExpression);
}
else
{
fieldExpression = typeConverterFieldExpression;
}
return(fieldExpression);
}
/// <summary>
/// 查询对象
/// </summary>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlStream"></param>
/// <param name="tableName"></param>
/// <param name="value"></param>
/// <param name="memberMap"></param>
private void getByPrimaryKey <modelType>(CharStream sqlStream, string tableName, modelType value, MemberMap <modelType> memberMap)
where modelType : class
{
sqlStream.WriteNotNull("select ");
DataModel.Model <modelType> .GetNames(sqlStream, memberMap);
sqlStream.WriteNotNull(" from `");
sqlStream.WriteNotNull(tableName);
sqlStream.WriteNotNull("` where ");
DataModel.Model <modelType> .PrimaryKeyWhere.Write(sqlStream, value, ConstantConverter.Default);
sqlStream.WriteNotNull(" limit 0,1;");
}
