public SqlTable(MappingSchema mappingSchema, Type objectType)
: this(mappingSchema)
{
bool isSet;
_database = _mappingSchema.MetadataProvider.GetDatabaseName(objectType, _mappingSchema.Extensions, out isSet);
_owner = _mappingSchema.MetadataProvider.GetOwnerName(objectType, _mappingSchema.Extensions, out isSet);
_name = _mappingSchema.MetadataProvider.GetTableName(objectType, _mappingSchema.Extensions, out isSet);
_objectType = objectType;
var typeExt = TypeExtension.GetTypeExtension(objectType, _mappingSchema.Extensions);
foreach (MemberMapper mm in MappingSchema.GetObjectMapper(objectType))
{
if (mm.MapMemberInfo.SqlIgnore == false)
{
var ua =
_mappingSchema.MetadataProvider.GetNonUpdatableAttribute(objectType, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
var order = _mappingSchema.MetadataProvider.GetPrimaryKeyOrder(objectType, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
Fields.Add(new SqlField(
mm.Type,
mm.MemberName,
mm.Name,
mm.MapMemberInfo.Nullable,
isSet ? order : int.MinValue,
ua,
mm));
}
}
}
protected SqlQueryInfo CreateUpdateSqlText(DbManager db, Type type)
{
TypeExtension typeExt = TypeExtension.GetTypeExtension(type, Extensions);
ObjectMapper om = db.MappingSchema.GetObjectMapper(type);
StringBuilder sb = new StringBuilder();
SqlQueryInfo query = new SqlQueryInfo(om);
MetadataProviderBase mp = MappingSchema.MetadataProvider;
sb.AppendFormat("UPDATE\n\t{0}\nSET\n",
db.DataProvider.Convert(GetTableName(type), ConvertType.NameToQueryTable));
foreach (MemberMapper mm in GetFieldList(om))
{
bool isSet;
if (!mp.GetNonUpdatableFlag(type, typeExt, mm.MemberAccessor, out isSet) || !isSet)
{
SqlQueryParameterInfo p = query.AddParameter(
db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryParameter).ToString(),
mm.Name);
sb.AppendFormat("\t{0} = {1},\n",
db.DataProvider.Convert(p.FieldName, ConvertType.NameToQueryField),
p.ParameterName);
}
}
sb.Remove(sb.Length - 2, 1);
AddWherePK(db, query, sb);
query.QueryText = sb.ToString();
return(query);
}
protected SqlQueryInfo CreateInsertSqlText(DbManager db, Type type, int nParameter)
{
TypeExtension typeExt = TypeExtension.GetTypeExtension(type, Extensions);
ObjectMapper om = db.MappingSchema.GetObjectMapper(type);
List <MemberMapper> list = new List <MemberMapper>();
StringBuilder sb = new StringBuilder();
SqlQueryInfo query = new SqlQueryInfo(om);
MetadataProviderBase mp = MappingSchema.MetadataProvider;
sb.Append("INSERT INTO ");
AppendTableName(sb, db, type);
sb.Append(" (\n");
foreach (MemberMapper mm in GetFieldList(om))
{
// IT: This works incorrectly for complex mappers.
//
// [2009-03-24] ili: use mm.MemberAccessor instead of mm.ComplexMemberAccessor
// as in CreateUpdateSqlText
//
bool isSet;
if (mp.GetNonUpdatableAttribute(type, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet) == null || !isSet)
{
sb.AppendFormat("\t{0},\n",
db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryField));
list.Add(mm);
}
}
sb.Remove(sb.Length - 2, 1);
sb.Append(") VALUES (\n");
foreach (MemberMapper mm in list)
{
SqlQueryParameterInfo p = query.AddParameter(
db.DataProvider.Convert(mm.Name + "_P", ConvertType.NameToQueryParameter).ToString(),
mm.Name);
if (nParameter < 0)
{
sb.AppendFormat("\t{0},\n", p.ParameterName);
}
//sb.AppendFormat("\t{0},\n", db.DataProvider.Convert(p.ParameterName, ConvertType.NameToQueryParameter));
else
{
sb.AppendFormat("\t{{{0}}},\n", nParameter++);
}
}
sb.Remove(sb.Length - 2, 1);
sb.Append(")");
query.QueryText = sb.ToString();
return(query);
}
protected virtual MemberMapper[] GetNonKeyFieldList(ObjectMapper om)
{
var typeExt = TypeExtension.GetTypeExtension(om.TypeAccessor.OriginalType, Extensions);
var list = new List <MemberMapper>();
foreach (MemberMapper mm in om)
{
if (mm.MapMemberInfo.SqlIgnore)
{
continue;
}
var ma = mm.MapMemberInfo.MemberAccessor;
bool isSet;
MappingSchema.MetadataProvider.GetPrimaryKeyOrder(om.TypeAccessor.OriginalType, typeExt, ma, out isSet);
if (!isSet)
{
list.Add(mm);
}
}
return(list.ToArray());
}
protected internal virtual MemberMapper[] GetKeyFieldList(DbManager db, Type type)
{
var key = type.FullName + "$" + db.DataProvider.UniqueName;
_keyListLock.EnterReadLock();
MemberMapper[] mmList = null;
try
{
mmList = (MemberMapper[])_keyList[key];
}
finally
{
_keyListLock.ExitReadLock();
}
if (mmList == null)
{
var typeExt = TypeExtension.GetTypeExtension(type, Extensions);
var list = new List <MemberOrder>();
foreach (MemberMapper mm in db.MappingSchema.GetObjectMapper(type))
{
if (mm.MapMemberInfo.SqlIgnore)
{
continue;
}
var ma = mm.MapMemberInfo.MemberAccessor;
if (TypeHelper.IsScalar(ma.Type))
{
bool isSet;
var order = MappingSchema.MetadataProvider.GetPrimaryKeyOrder(type, typeExt, ma, out isSet);
if (isSet)
{
list.Add(new MemberOrder(mm, order));
}
}
}
list.Sort((x, y) => x.Order - y.Order);
_keyListLock.EnterWriteLock();
try
{
_keyList[key] = mmList = new MemberMapper[list.Count];
for (var i = 0; i < list.Count; i++)
{
mmList[i] = list[i].MemberMapper;
}
}
finally
{
_keyListLock.ExitWriteLock();
}
}
return(mmList);
}
public override string GetTableName(Type type, ExtensionList extensions, out bool isSet)
{
var typeExt = TypeExtension.GetTypeExtension(type, extensions);
var value = typeExt.Attributes["TableName"].Value;
if (value != null)
{
isSet = true;
return(value.ToString());
}
return(base.GetTableName(type, extensions, out isSet));
}
protected Type GetObjectType()
{
for (var type = OriginalType.BaseType; type != null && type != typeof(object); type = type.BaseType)
{
var extension = TypeExtension.GetTypeExtension(type, Parser.MappingSchema.Extensions);
var mapping = Parser.MappingSchema.MetadataProvider.GetInheritanceMapping(type, extension);
if (mapping.Length > 0)
{
return(type);
}
}
return(OriginalType);
}
protected SqlQueryInfo CreateInsertSqlText(DbManager db, Type type)
{
TypeExtension typeExt = TypeExtension.GetTypeExtension(type, Extensions);
ObjectMapper om = db.MappingSchema.GetObjectMapper(type);
List <MemberMapper> list = new List <MemberMapper>();
StringBuilder sb = new StringBuilder();
SqlQueryInfo query = new SqlQueryInfo(om);
MetadataProviderBase mp = MappingSchema.MetadataProvider;
sb.AppendFormat("INSERT INTO {0} (\n",
db.DataProvider.Convert(GetTableName(type), ConvertType.NameToQueryTable));
foreach (MemberMapper mm in GetFieldList(om))
{
// IT: This works incorrectly for complex mappers.
//
bool isSet;
if (!mp.GetNonUpdatableFlag(type, typeExt, mm.ComplexMemberAccessor, out isSet) || !isSet)
{
sb.AppendFormat("\t{0},\n",
db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryField));
list.Add(mm);
}
}
sb.Remove(sb.Length - 2, 1);
sb.Append(") VALUES (\n");
foreach (MemberMapper mm in list)
{
SqlQueryParameterInfo p = query.AddParameter(
db.DataProvider.Convert(mm.Name, ConvertType.NameToQueryParameter).ToString(),
mm.Name);
sb.AppendFormat("\t{0},\n", p.ParameterName);
}
sb.Remove(sb.Length - 2, 1);
sb.Append(")");
query.QueryText = sb.ToString();
return(query);
}
public SqlTable([JetBrains.Annotations.NotNull] MappingSchema mappingSchema, Type objectType) : this()
{
if (mappingSchema == null)
{
throw new ArgumentNullException("mappingSchema");
}
bool isSet;
Database = mappingSchema.MetadataProvider.GetDatabaseName(objectType, mappingSchema.Extensions, out isSet);
Owner = mappingSchema.MetadataProvider.GetOwnerName(objectType, mappingSchema.Extensions, out isSet);
Name = mappingSchema.MetadataProvider.GetTableName(objectType, mappingSchema.Extensions, out isSet);
ObjectType = objectType;
PhysicalName = Name;
var typeExt = TypeExtension.GetTypeExtension(objectType, mappingSchema.Extensions);
foreach (MemberMapper mm in mappingSchema.GetObjectMapper(objectType))
{
if (mm.MapMemberInfo.SqlIgnore == false)
{
var ua =
mappingSchema.MetadataProvider.GetNonUpdatableAttribute(objectType, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
var order = mappingSchema.MetadataProvider.GetPrimaryKeyOrder(objectType, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
Fields.Add(new SqlField(
mm.Type,
mm.MemberName,
mm.Name,
mm.MapMemberInfo.Nullable,
isSet ? order : int.MinValue,
ua,
mm));
}
}
var identityField = GetIdentityField();
if (identityField != null)
{
var om = mappingSchema.GetObjectMapper(ObjectType);
var mm = om[identityField.Name, true];
_sequenceAttributes = mm.MapMemberInfo.MemberAccessor.GetAttributes <SequenceNameAttribute>();
}
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var table = sequence as TableBuilder.TableContext;
if (table != null && table.InheritanceMapping.Count > 0)
{
var objectType = methodCall.Type.GetGenericArguments()[0];
if (TypeHelper.IsSameOrParent(table.ObjectType, objectType))
{
var predicate = builder.MakeIsPredicate(table, objectType);
if (predicate.GetType() != typeof(SqlQuery.Predicate.Expr))
{
sequence.SqlQuery.Where.SearchCondition.Conditions.Add(new SqlQuery.Condition(false, predicate));
}
}
}
else
{
var toType = methodCall.Type.GetGenericArguments()[0];
var gargs = TypeHelper.GetGenericArguments(methodCall.Arguments[0].Type, typeof(IQueryable <>));
var fromType = gargs == null ? typeof(object) : gargs[0];
if (toType.IsSubclassOf(fromType))
{
for (var type = toType.BaseType; type != null && type != typeof(object); type = type.BaseType)
{
var extension = TypeExtension.GetTypeExtension(type, builder.MappingSchema.Extensions);
var mapping = builder.MappingSchema.MetadataProvider.GetInheritanceMapping(type, extension);
if (mapping.Length > 0)
{
var predicate = MakeIsPredicate(builder, sequence, fromType, toType);
sequence.SqlQuery.Where.SearchCondition.Conditions.Add(new SqlQuery.Condition(false, predicate));
return(new OfTypeContext(sequence, methodCall));
}
}
}
}
return(sequence);
}
protected internal virtual MemberMapper[] GetKeyFieldList(DbManager db, Type type)
{
string key = type.FullName + "$" + db.DataProvider.UniqueName;
MemberMapper[] mmList = (MemberMapper[])_keyList[key];
if (mmList == null)
{
TypeExtension typeExt = TypeExtension.GetTypeExtension(type, Extensions);
List <MemberOrder> list = new List <MemberOrder>();
foreach (MemberMapper mm in db.MappingSchema.GetObjectMapper(type))
{
if (mm.MapMemberInfo.SqlIgnore)
{
continue;
}
MemberAccessor ma = mm.MapMemberInfo.MemberAccessor;
if (TypeHelper.IsScalar(ma.Type))
{
bool isSet;
int order = MappingSchema.MetadataProvider.GetPrimaryKeyOrder(type, typeExt, ma, out isSet);
if (isSet)
{
list.Add(new MemberOrder(mm, order));
}
}
}
list.Sort(delegate(MemberOrder x, MemberOrder y) { return(x.Order - y.Order); });
_keyList[key] = mmList = new MemberMapper[list.Count];
for (int i = 0; i < list.Count; i++)
{
mmList[i] = list[i].MemberMapper;
}
}
return(mmList);
}
protected MemberMapper[] GetNonKeyFieldList(ObjectMapper om)
{
TypeExtension typeExt = TypeExtension.GetTypeExtension(om.TypeAccessor.OriginalType, Extensions);
List <MemberMapper> list = new List <MemberMapper>();
foreach (MemberMapper mm in om)
{
MemberAccessor ma = mm.MemberAccessor;
bool isSet;
MappingSchema.MetadataProvider.GetPrimaryKeyOrder(om.TypeAccessor.OriginalType, typeExt, ma, out isSet);
if (!isSet)
{
list.Add(mm);
}
}
return(list.ToArray());
}
public virtual void Init(MappingSchema mappingSchema, Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
_typeAccessor = TypeAccessor.GetAccessor(type);
_mappingSchema = mappingSchema;
_extension = TypeExtension.GetTypeExtension(_typeAccessor.OriginalType, mappingSchema.Extensions);
_inheritanceMapping.AddRange(GetInheritanceMapping());
foreach (MemberAccessor ma in _typeAccessor)
{
Association a = GetAssociation(ma);
if (a != null)
{
_associations.Add(a);
continue;
}
if (GetMapIgnore(ma))
{
continue;
}
MapFieldAttribute mapFieldAttr = ma.GetAttribute <MapFieldAttribute>();
if (mapFieldAttr == null || (mapFieldAttr.OrigName == null && mapFieldAttr.Format == null))
{
MapMemberInfo mi = new MapMemberInfo();
DbTypeAttribute dbTypeAttribute = ma.GetAttribute <DbTypeAttribute>();
if (dbTypeAttribute != null)
{
mi.DbType = dbTypeAttribute.DbType;
mi.IsDbTypeSet = true;
if (dbTypeAttribute.Size != null)
{
mi.DbSize = dbTypeAttribute.Size.Value;
mi.IsDbSizeSet = true;
}
}
mi.MemberAccessor = ma;
mi.Type = ma.Type;
mi.MappingSchema = mappingSchema;
mi.MemberExtension = _extension[ma.Name];
mi.Name = GetFieldName(ma);
mi.MemberName = ma.Name;
mi.Storage = GetFieldStorage(ma);
mi.IsInheritanceDiscriminator = GetInheritanceDiscriminator(ma);
mi.Trimmable = GetTrimmable(ma);
mi.SqlIgnore = GetSqlIgnore(ma);
mi.MapValues = GetMapValues(ma);
mi.DefaultValue = GetDefaultValue(ma);
mi.Nullable = GetNullable(ma);
mi.NullValue = GetNullValue(ma, mi.Nullable);
Add(CreateMemberMapper(mi));
}
else if (mapFieldAttr.OrigName != null)
{
EnsureMapper(mapFieldAttr.MapName, ma.Name + "." + mapFieldAttr.OrigName);
}
else if (mapFieldAttr.Format != null)
{
foreach (MemberMapper inner in _mappingSchema.GetObjectMapper(ma.Type))
{
EnsureMapper(string.Format(mapFieldAttr.Format, inner.Name), ma.Name + "." + inner.MemberName);
}
}
}
foreach (AttributeExtension ae in _extension.Attributes["MapField"])
{
string mapName = (string)ae["MapName"];
string origName = (string)ae["OrigName"];
if (mapName == null || origName == null)
{
throw new MappingException(string.Format(
"Type '{0}' has invalid extension. MapField MapName='{1}' OrigName='{2}'.",
type.FullName, mapName, origName));
}
EnsureMapper(mapName, origName);
}
MetadataProvider.EnsureMapper(TypeAccessor, MappingSchema, EnsureMapper);
}
protected SqlQueryInfo CreateUpdateSqlText(DbManager db, Type type, int nParameter)
{
var typeExt = TypeExtension.GetTypeExtension(type, Extensions);
var om = db.MappingSchema.GetObjectMapper(type);
var sb = new StringBuilder();
var query = new SqlQueryInfo(om);
var mp = MappingSchema.MetadataProvider;
sb.Append("UPDATE\n\t");
AppendTableName(sb, db, type);
sb.Append("\nSET\n");
var fields = GetFieldList(om);
var hasFields = false;
foreach (var mm in fields)
{
bool isSet;
var nonUpdatableAttribute = mp.GetNonUpdatableAttribute(type, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
if (nonUpdatableAttribute != null && isSet && nonUpdatableAttribute.OnUpdate == true)
{
continue;
}
mp.GetPrimaryKeyOrder(type, typeExt, mm.MapMemberInfo.MemberAccessor, out isSet);
if (isSet)
{
continue;
}
hasFields = true;
var p = query.AddParameter(
db.DataProvider.Convert(mm.Name + "_P", ConvertType.NameToQueryParameter).ToString(),
mm.Name);
sb.AppendFormat("\t{0} = ", db.DataProvider.Convert(p.FieldName, ConvertType.NameToQueryField));
if (nParameter < 0)
{
sb.AppendFormat("{0},\n", p.ParameterName);
}
else
{
sb.AppendFormat("\t{{{0}}},\n", nParameter++);
}
}
if (!hasFields)
{
throw new DataAccessException(
string.Format("There are no fields to update in the type '{0}'.", query.ObjectType.FullName));
}
sb.Remove(sb.Length - 2, 1);
AddWherePK(db, query, sb, nParameter);
query.QueryText = sb.ToString();
return(query);
}
public virtual void Init(MappingSchema mappingSchema, Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
_typeAccessor = TypeAccessor.GetAccessor(type);
_mappingSchema = mappingSchema;
_extension = TypeExtension.GetTypeExtension(
_typeAccessor.OriginalType, mappingSchema.Extensions);
foreach (MemberAccessor ma in _typeAccessor)
{
if (GetIgnore(ma))
{
continue;
}
MapFieldAttribute mapFieldAttr = ma.GetAttribute <MapFieldAttribute>();
if (mapFieldAttr == null || (mapFieldAttr.OrigName == null && mapFieldAttr.Format == null))
{
MapMemberInfo mi = new MapMemberInfo();
mi.MemberAccessor = ma;
mi.Type = ma.Type;
mi.MappingSchema = mappingSchema;
mi.MemberExtension = _extension[ma.Name];
mi.Name = GetFieldName(ma);
mi.MemberName = ma.Name;
mi.Trimmable = GetTrimmable(ma);
mi.MapValues = GetMapValues(ma);
mi.DefaultValue = GetDefaultValue(ma);
mi.Nullable = GetNullable(ma);
mi.NullValue = GetNullValue(ma, mi.Nullable);
Add(CreateMemberMapper(mi));
}
else if (mapFieldAttr.OrigName != null)
{
EnsureMapper(mapFieldAttr.MapName, ma.Name + "." + mapFieldAttr.OrigName);
}
else if (mapFieldAttr.Format != null)
{
foreach (MemberMapper inner in _mappingSchema.GetObjectMapper(ma.Type))
{
EnsureMapper(string.Format(mapFieldAttr.Format, inner.Name), ma.Name + "." + inner.MemberName);
}
}
}
foreach (AttributeExtension ae in _extension.Attributes["MapField"])
{
string mapName = (string)ae["MapName"];
string origName = (string)ae["OrigName"];
if (mapName == null || origName == null)
{
throw new MappingException(string.Format(
"Type '{0}' has invalid extension. MapField MapName='{1}' OrigName='{2}'.",
type.FullName, mapName, origName));
}
EnsureMapper(mapName, origName);
}
MetadataProvider.EnsureMapper(this, EnsureMapper);
}
public override List <MapRelationBase> GetRelations(MappingSchema schema, ExtensionList typeExt, Type master, Type slave, out bool isSet)
{
var masterAccessor = TypeAccessor.GetAccessor(master);
var slaveAccessor = slave != null?TypeAccessor.GetAccessor(slave) : null;
var relations = new List <MapRelationBase>();
foreach (MemberAccessor ma in masterAccessor)
{
var attr = ma.GetAttribute <RelationAttribute>();
if (attr == null || (slave != null && attr.Destination != slave && ma.Type != slave))
{
continue;
}
if (slave == null)
{
slaveAccessor = TypeAccessor.GetAccessor(attr.Destination ?? ma.Type);
}
var toMany = TypeHelper.IsSameOrParent(typeof(IEnumerable), ma.Type);
if (toMany && attr.Destination == null)
{
throw new InvalidOperationException("Destination type should be set for enumerable relations: " + ma.Type.FullName + "." + ma.Name);
}
var masterIndex = attr.MasterIndex;
var slaveIndex = attr.SlaveIndex;
if (slaveIndex == null)
{
var accessor = toMany ? masterAccessor : slaveAccessor;
var tex = TypeExtension.GetTypeExtension(accessor.Type, typeExt);
var keys = GetPrimaryKeyFields(schema, accessor, tex);
if (keys.Count > 0)
{
slaveIndex = new MapIndex(keys.ToArray());
}
}
if (slaveIndex == null)
{
throw new InvalidOperationException("Slave index is not set for relation: " + ma.Type.FullName + "." + ma.Name);
}
if (masterIndex == null)
{
masterIndex = slaveIndex;
}
var relation = new MapRelationBase(attr.Destination ?? ma.Type, slaveIndex, masterIndex, ma.Name);
relations.Add(relation);
}
isSet = true;
return(relations);
}
private IMapper GetObjectMapper(IObjectMapper mapper, ref int startIndex, TypeAccessor akTypeAccessor)
{
//Todo: Remove this Call!
_extension = TypeExtension.GetTypeExtension(mapper.PropertyType /*_typeAccessor.OriginalType*/, MappingSchema.Extensions);
Type mapperType = mapper.PropertyType;
var objectMappers = new List <IObjectMapper>();
TableDescription tableDescription = GetTableDescription(mapperType);
lock (SetterHandlersLock)
{
if (!SettersHandlers.ContainsKey(mapperType))
{
SettersHandlers.Add(mapperType, new Dictionary <string, SetHandler>());
}
if (!GettersHandlers.ContainsKey(mapperType))
{
GettersHandlers.Add(mapperType, new Dictionary <string, GetHandler>());
}
}
PropertyInfo[] properties = mapperType.GetProperties();
MemberAccessor primaryKeyMemberAccessor = null;
foreach (MemberAccessor ma in akTypeAccessor)
{
// Setters
lock (SetterHandlersLock)
{
if (!SettersHandlers[mapper.PropertyType].ContainsKey(ma.Name))
{
SettersHandlers[mapper.PropertyType].Add(ma.Name, ma.SetValue);
}
}
if (GetPrimaryKey(ma) != null)
{
primaryKeyMemberAccessor = ma;
lock (SetterHandlersLock)
{
if (!GettersHandlers[mapperType].ContainsKey(ma.Name))
{
GettersHandlers[mapperType].Add(ma.Name, ma.GetValue);
}
}
mapper.PrimaryKeyValueGetters.Add(GettersHandlers[mapperType][ma.Name]);
mapper.PrimaryKeyNames.Add(ma.Name);
if (mapper.Association != null && (mapper.Association.OtherKey == null || mapper.Association.OtherKey.Length == 0))
{
mapper.Association.OtherKey = new[] { ma.Name };
}
}
}
if (primaryKeyMemberAccessor == null)
{
throw new Exception("PrimaryKey attribute not found on type: " + mapperType);
}
foreach (PropertyInfo prop in properties)
{
var ma = akTypeAccessor.First(x => x.Name == prop.Name);
// Check if the accessor is an association
var association = GetAssociation(ma);
if (association != null)
{
// Getters for IObjectMapper
lock (SetterHandlersLock)
if (!GettersHandlers[mapperType].ContainsKey(prop.Name))
{
GettersHandlers[mapperType].Add(prop.Name, ma.GetValue);
}
bool isCollection = prop.PropertyType.GetInterfaces().ToList().Contains(typeof(IList));
IObjectMapper propertiesMapping;
if (!isCollection)
{
// TODO Generate this instance using the CreateObjectMapperInstance method of fullMappingSchema
// _db.MappingSchema.CreateObjectMapperInstance(prop.PropertyType)
propertiesMapping = new FullObjectMapper(_db, _ignoreLazyLoad, _factoryType)
{
PropertyType = prop.PropertyType,
IsNullable = association.CanBeNull,
Getter = GettersHandlers[mapperType][prop.Name],
};
}
else
{
Type listElementType = GetGenericType(prop.PropertyType);
TableDescription colElementTableDescription = GetTableDescription(listElementType);
// TODO Generate this instance using the CreateObjectMapperInstance method of fullMappingSchema
propertiesMapping = new CollectionFullObjectMapper(_db, _factoryType)
{
PropertyType = listElementType,
Getter = GettersHandlers[mapperType][prop.Name],
TableName = colElementTableDescription.TableName,
PropertyCollectionType = prop.PropertyType,
};
if (mapper is FullObjectMapper)
{
((FullObjectMapper)mapper).ColParent = true;
}
}
if (association.ThisKey == null || association.ThisKey.Length == 0)
{
association.ThisKey = new[] { primaryKeyMemberAccessor.Name }
}
;
bool isLazy = false;
if (!_ignoreLazyLoad)
{
var lazy = GetLazyInstance(ma); // prop.GetCustomAttributes(typeof(LazyInstanceAttribute), true);
if (lazy)
{
isLazy = true;
mapper.ContainsLazyChild = true;
// Getters
lock (SetterHandlersLock)
if (!GettersHandlers[mapperType].ContainsKey(primaryKeyMemberAccessor.Name))
{
GettersHandlers[mapperType].Add(primaryKeyMemberAccessor.Name, primaryKeyMemberAccessor.GetValue);
}
}
}
propertiesMapping.Association = association;
propertiesMapping.PropertyName = prop.Name;
propertiesMapping.IsLazy = isLazy;
propertiesMapping.Setter = SettersHandlers[mapperType][prop.Name];
if (propertiesMapping.IsLazy)
{
propertiesMapping.ParentKeyGetter = GettersHandlers[mapperType][primaryKeyMemberAccessor.Name];
}
objectMappers.Add(propertiesMapping);
}
else
{
var mapIgnore = GetMapIgnore(ma);
if (mapIgnore)
{
continue;
}
var mapField = GetMapField(ma);
string columnName = mapField != null ? mapField.MapName : prop.Name;
var map = new ValueMapper
{
PropertyName = prop.Name,
PropertyType = prop.PropertyType,
DataReaderIndex = startIndex,
Setter = SettersHandlers[mapperType][prop.Name],
TableName = tableDescription.TableName,
ColumnName = columnName,
};
var mapColumnName = map.GetColumnName(columnName);
map.ColumnAlias = columnName == mapColumnName ? null : mapColumnName;
mapper.PropertiesMapping.Add(map);
var pkField = GetPrimaryKey(ma);
if (pkField != null)
{
mapper.DataReaderIndex = startIndex;
}
startIndex++;
}
}
foreach (IObjectMapper objMap in objectMappers)
{
#region Check mapping recursion
IObjectMapper cel = mapper;
while (cel != null)
{
if (mapper.PropertyType == objMap.PropertyType)
{
continue;
}
cel = (IObjectMapper)cel.ParentMapping;
}
#endregion
objMap.ParentMapping = mapper;
mapper.PropertiesMapping.Add(GetObjectMapper(objMap, ref startIndex, MappingSchema.GetObjectMapper(objMap.PropertyType).TypeAccessor));
}
return(mapper);
}
public override List <MapRelationBase> GetRelations(MappingSchema schema, ExtensionList typeExt, Type master, Type slave, out bool isSet)
{
List <MapRelationBase> relations = new List <MapRelationBase>();
TypeExtension ext = typeExt != null ? typeExt[master] : TypeExtension.Null;
isSet = ext != TypeExtension.Null;
if (!isSet)
{
return(relations);
}
TypeAccessor ta = TypeAccessor.GetAccessor(master);
foreach (MemberExtension mex in ext.Members)
{
AttributeExtensionCollection relationInfos = mex.Attributes[TypeExtension.NodeName.Relation];
if (relationInfos == AttributeExtensionCollection.Null)
{
continue;
}
string destinationTypeName = relationInfos[0][TypeExtension.AttrName.DestinationType, string.Empty].ToString();
Type destinationType = slave;
MemberAccessor ma = ta[mex.Name];
bool toMany = TypeHelper.IsSameOrParent(typeof(IEnumerable), ma.Type);
if (destinationTypeName == string.Empty)
{
if (toMany)
{
throw new InvalidOperationException("Destination type should be set for enumerable relations: " + ma.Type.FullName + "." + ma.Name);
}
destinationType = ma.Type;
}
else
{
if (!destinationTypeName.Contains(","))
{
destinationTypeName += ", " + ta.OriginalType.Assembly.FullName;
}
try
{
destinationType = Type.GetType(destinationTypeName, true);
}
catch (TypeLoadException ex)
{
throw new InvalidOperationException(
"Unable to load type by name: " + destinationTypeName
+ "\n may be assembly is not specefied, please see Type.GetType(string typeName) documentation",
ex);
}
}
if (slave != null && !TypeHelper.IsSameOrParent(slave, destinationType))
{
continue;
}
List <string> masterIndexFields = new List <string>();
List <string> slaveIndexFields = new List <string>();
foreach (AttributeExtension ae in relationInfos[0].Attributes[TypeExtension.NodeName.MasterIndex])
{
masterIndexFields.Add(ae[TypeExtension.AttrName.Name].ToString());
}
foreach (AttributeExtension ae in relationInfos[0].Attributes[TypeExtension.NodeName.SlaveIndex])
{
slaveIndexFields.Add(ae[TypeExtension.AttrName.Name].ToString());
}
if (slaveIndexFields.Count == 0)
{
TypeAccessor accessor = toMany ? ta : TypeAccessor.GetAccessor(destinationType);
TypeExtension tex = TypeExtension.GetTypeExtension(accessor.Type, typeExt);
slaveIndexFields = GetPrimaryKeyFields(schema, accessor, tex);
}
if (slaveIndexFields.Count == 0)
{
throw new InvalidOperationException("Slave index is not set for relation: " + ma.Type.FullName + "." + ma.Name);
}
MapIndex slaveIndex = new MapIndex(slaveIndexFields.ToArray());
MapIndex masterIndex = masterIndexFields.Count > 0 ? new MapIndex(masterIndexFields.ToArray()) : slaveIndex;
MapRelationBase mapRelation = new MapRelationBase(destinationType, slaveIndex, masterIndex, mex.Name);
relations.Add(mapRelation);
}
isSet = relations.Count > 0;
return(relations);
}