public override string GetColumnDbType(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
if (mm != null && mm.Column != null && !string.IsNullOrEmpty(mm.Column.DbType))
return mm.Column.DbType;
return null;
}
public override bool IsAssociationRelationship(MappingEntity entity, MemberInfo member)
{
if (IsMapped(entity, member) && !IsColumn(entity, member))
{
Type otherType = TypeHelper.GetElementType(TypeHelper.GetMemberType(member));
return !this.IsScalar(otherType);
}
return false;
}
public override IEnumerable<MemberInfo> GetAssociationKeyMembers(MappingEntity entity, MemberInfo member)
{
AttributeMappingEntity thisEntity = (AttributeMappingEntity)entity;
AttributeMappingMember mm = thisEntity.GetMappingMember(member.Name);
if (mm != null && mm.Association != null)
{
return this.GetReferencedMembers(thisEntity, mm.Association.KeyMembers, "Association.KeyMembers", thisEntity.EntityType);
}
return base.GetAssociationKeyMembers(entity, member);
}
public override bool IsPrimaryKey(MappingEntity entity, MemberInfo member)
{
// Customers has CustomerID, Orders has OrderID, etc
if (this.IsColumn(entity, member))
{
string name = NameWithoutTrailingDigits(member.Name);
return member.Name.EndsWith("ID")
&& member.DeclaringType.Name.StartsWith(member.Name.Substring(0, member.Name.Length - 2));
}
return false;
}
public override bool IsPrimaryKey(MappingEntity entity, MemberInfo member)
{
// Customers has CustomerID, Orders has OrderID, etc
//if (this.IsColumn(entity, member))
//{
// string name = NameWithoutTrailingDigits(member.Name);
// return member.Name.EndsWith("ID") && member.DeclaringType.Name.StartsWith(member.Name.Substring(0, member.Name.Length - 2));
//}
//return false;
//TODO: 2010-7.17 更改 获取主键的方式;
return base.IsPrimaryKey(entity, member);
}
public override IEnumerable<MemberInfo> GetMappedMembers(MappingEntity entity)
{
return ((AttributeMappingEntity)entity).MappedMembers;
}
public override bool IsGenerated(MappingEntity entity, MemberInfo member)
{
var dbMapping = (DbMappingEntity)entity;
return(dbMapping.TypeMapping.IsUniqueKey(member.Name));
}
private string GetTableName(MappingEntity entity, TableBaseAttribute attr)
{
string name = (attr != null && !string.IsNullOrEmpty(attr.Name))
? attr.Name
: entity.TableId;
return name;
}
public override string GetColumnName(MappingEntity entity, MemberInfo member)
{
return(this.GetColumnMapper(entity)[member].ColumnName);
}
public override bool IsAssociationRelationship(MappingEntity entity, MemberInfo member)
{
return(base.IsAssociationRelationship(entity, member));
}
public override bool IsRelationshipTarget(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
if (mm != null && mm.Association != null)
{
if (!mm.Association.IsForeignKey || typeof(IEnumerable).IsAssignableFrom(TypeHelper.GetMemberType(member)))
return true;
}
return false;
}
public override MappingEntity GetRelatedEntity(MappingEntity entity, MemberInfo member)
{
AttributeMappingEntity thisEntity = (AttributeMappingEntity)entity;
AttributeMappingMember mm = thisEntity.GetMappingMember(member.Name);
if (mm != null)
{
if (mm.Association != null)
{
Type elementType = TypeHelper.GetElementType(TypeHelper.GetMemberType(member));
Type entityType = (mm.Association.RelatedEntityType != null) ? mm.Association.RelatedEntityType : elementType;
return this.GetReferencedEntity(elementType, mm.Association.RelatedEntityID, entityType, "Association.RelatedEntityID");
}
else if (mm.NestedEntity != null)
{
return mm.NestedEntity;
}
}
return base.GetRelatedEntity(entity, member);
}
public override bool IsRelationshipSource(MappingEntity entity, MemberInfo member)
{
// TODO:
return(false);
}
/// <summary>
/// 获取列别名
/// </summary>
/// <param name="entity"></param>
/// <param name="member"></param>
/// <returns></returns>
public override string GetAlias(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
return (mm != null && mm.Column != null) ? mm.Column.Alias : null;
}
/// <summary>
/// Generate a SQL SELECT distinct for the specific mapping using the Dataset query
/// </summary>
/// <param name="mapping">
/// The mapping to generate the SQL for
/// </param>
/// <param name="sqlWhere">
/// The SQL Query WHERE keyword and where clauses or empty
/// </param>
/// <returns>
/// String with the SQL Query
/// </returns>
private string GenerateSql(MappingEntity mapping, string sqlWhere)
{
var columnList = new StringBuilder();
foreach (DataSetColumnEntity col in mapping.Columns)
{
columnList.AppendFormat(" {0},", col.Name);
}
columnList.Length = columnList.Length - 1;
return string.Format(
CultureInfo.InvariantCulture,
"SELECT DISTINCT {2} \n FROM ({0}) virtualDataset {1} \n ORDER BY {2} ",
this._innerSqlQuery,
sqlWhere,
columnList);
}
/// <summary>
/// Initialize component mappings for coded components and time dimension used in mappings in the dataflow
/// </summary>
/// <param name="dataflowRef">
/// The dataflow Ref.
/// </param>
/// <remarks>
/// This method should be called only once
/// </remarks>
private void Initialize(Sdmx.Model.Registry.DataflowRefBean dataflowRef)
{
this._mappingSet = DataAccess.GetMappingSet(
this._connectionStringSettings,
dataflowRef.Id,
dataflowRef.Version,
dataflowRef.AgencyID,
this._allowedDataflows);
if (this._mappingSet == null)
{
return;
}
NormallizeDatabaseProvider(this._connectionStringSettings);
this._mastoreAccess = new StructureAccess(this._connectionStringSettings);
this._xsMeasureDimensionConstraints.Clear();
this._componentMapping = new Dictionary<string, ComponentInfo>(this._mappingSet.Mappings.Count);
this._innerSqlQuery = this._mappingSet.DataSet.Query;
this._measureComponent = null;
this._timeTranscoder = null;
this._timeMapping = null;
this._timeDimension = null;
bool measureDimensionMapped = false;
foreach (MappingEntity mapping in this._mappingSet.Mappings)
{
foreach (ComponentEntity component in mapping.Components)
{
if (component.ComponentType == SdmxComponentType.TimeDimension)
{
this._timeTranscoder = TimeDimensionMapping.Create(
mapping, this._mappingSet.DataSet.Connection.DBType);
this._timeMapping = mapping;
this._timeDimension = component.Concept.Id;
}
else if (component.CodeList != null)
{
if (component.MeasureDimension)
{
measureDimensionMapped = true;
}
var compInfo = new ComponentInfo();
compInfo.Mapping = mapping;
compInfo.ComponentMapping = ComponentMapping.CreateComponentMapping(component, mapping);
compInfo.CodelistRef.Id = component.CodeList.Id;
compInfo.CodelistRef.Version = component.CodeList.Version;
compInfo.CodelistRef.AgencyID = component.CodeList.Agency;
this._componentMapping.Add(component.Concept.Id, compInfo);
}
}
}
if (!measureDimensionMapped)
{
foreach (ComponentEntity component in this._mappingSet.Dataflow.Dsd.Dimensions)
{
if (component.MeasureDimension)
{
this._measureComponent = component.Concept.Id;
}
}
foreach (ComponentEntity xsMeasure in this._mappingSet.Dataflow.Dsd.CrossSectionalMeasures)
{
this._xsMeasureDimensionConstraints.Add(xsMeasure.Concept.Id, xsMeasure);
}
}
}
public ReplaceAttribute(MappingTarget target, MappingEntity entity)
{
_target = target;
_entity = entity;
}
public override IEnumerable <MemberInfo> GetPrimaryKeyMembers(MappingEntity entity)
{
return(TableCache.GetTableOrCreate(entity.EntityType).KeyMembers);
}
public override IEnumerable <MemberInfo> GetMappedMembers(MappingEntity entity)
{
return(this.GetColumnMapper(entity).Keys);
}
public override bool IsPrimaryKey(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
return mm != null && mm.Column != null && mm.Column.IsPrimaryKey;
}
public override bool IsRelationshipTarget(MappingEntity entity, MemberInfo member)
{
if (IsAssociationRelationship(entity, member))
{
if (typeof(IEnumerable).IsAssignableFrom(TypeHelper.GetMemberType(member)))
{
return true;
}
// is target of relationship if the assoctions keys are the same as this entities primary key
var pks = new HashSet<string>(this.GetPrimaryKeyMembers(entity).Select(m => m.Name));
var keys = new HashSet<string>(this.GetAssociationKeyMembers(entity, member).Select(m => m.Name));
return keys.IsSubsetOf(pks) && pks.IsSubsetOf(keys);
}
return false;
}
public override bool IsAssociationRelationship(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
return mm != null && mm.Association != null;
}
private void GetAssociationKeys(
MappingEntity entity, MemberInfo member, out List<MemberInfo> keyMembers, out List<MemberInfo> relatedKeyMembers)
{
MappingEntity entity2 = GetRelatedEntity(entity, member);
// find all members in common (same name)
var map1 = this.GetMappedMembers(entity).Where(m => this.IsColumn(entity, m)).ToDictionary(m => m.Name);
var map2 = this.GetMappedMembers(entity2).Where(m => this.IsColumn(entity2, m)).ToDictionary(m => m.Name);
var commonNames = map1.Keys.Intersect(map2.Keys).OrderBy(k => k);
keyMembers = new List<MemberInfo>();
relatedKeyMembers = new List<MemberInfo>();
foreach (string name in commonNames)
{
keyMembers.Add(map1[name]);
relatedKeyMembers.Add(map2[name]);
}
}
public override bool IsNestedEntity(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
return mm != null && mm.NestedEntity != null;
}
public override IEnumerable <MemberInfo> GetAssociationRelatedKeyMembers(MappingEntity entity, MemberInfo member)
{
return(base.GetAssociationRelatedKeyMembers(entity, member));
}
public override IList<MappingTable> GetTables(MappingEntity entity)
{
return ((AttributeMappingEntity)entity).Tables;
}
public IObjectActivatorCreator GenarateObjectActivatorCreator(DbSqlQueryExpression sqlQuery)
{
MappingEntity mappingEntity = new MappingEntity(this.ConstructorDescriptor);
MappingObjectExpression mappingMembers = this;
foreach (var kv in this.ConstructorParameters)
{
ParameterInfo pi = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, pi.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.ConstructorParameters.Add(pi, ordinal);
}
foreach (var kv in mappingMembers.ConstructorEntityParameters)
{
ParameterInfo pi = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator navMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.ConstructorEntityParameters.Add(pi, navMappingMember);
}
foreach (var kv in mappingMembers.SelectedMembers)
{
MemberInfo member = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, member.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.Members.Add(member, ordinal);
}
foreach (var kv in mappingMembers.SubResultEntities)
{
MemberInfo member = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator navMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.EntityMembers.Add(kv.Key, navMappingMember);
}
if (mappingEntity.CheckNullOrdinal == null)
{
mappingEntity.CheckNullOrdinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, this.NullChecking);
}
return(mappingEntity);
}
private MemberInfo GetMemberForColumn(MappingEntity entity, string columnName)
{
foreach (var m in this.GetMappedMembers(entity))
{
if (this.IsNestedEntity(entity, m))
{
var m2 = this.GetMemberForColumn(this.GetRelatedEntity(entity, m), columnName);
if (m2 != null)
return m2;
}
else if (this.IsColumn(entity, m) && string.Compare(this.GetColumnName(entity, m), columnName, true) == 0)
{
return m;
}
}
return null;
}
public override string GetColumnName(MappingEntity entity, MemberInfo member)
{
AttributeMappingMember mm = ((AttributeMappingEntity)entity).GetMappingMember(member.Name);
if (mm != null && mm.Column != null && !string.IsNullOrEmpty(mm.Column.Name))
{
return mm.Column.Name;
}
return base.GetColumnName(entity, member);
}
public override IEnumerable<MemberInfo> GetAssociationRelatedKeyMembers(MappingEntity entity, MemberInfo member)
{
List<MemberInfo> keyMembers;
List<MemberInfo> relatedKeyMembers;
this.GetAssociationKeys(entity, member, out keyMembers, out relatedKeyMembers);
return relatedKeyMembers;
}
private void GetAssociationRelatedKey(MappingEntity entity, MemberInfo member, out List<MemberInfo> relatedKeyMembers)
{
//TODO: 2010 - 7- 17 获取 外键引用列
MappingEntity entity2 = GetRelatedEntity(entity, member);
//
var map1 = this.GetMappedMembers(entity).Where(m => this.IsColumn(entity, m) ).ToDictionary(m => m.Name);
var map2 = this.GetMappedMembers(entity2).Where(m => this.IsColumn(entity2, m) ).ToDictionary(m => m.Name);
var keyMembers = new List<MemberInfo>();
relatedKeyMembers = new List<MemberInfo>();
//TODO:这边可能暂时有问题 ...待发现.. ..2010-7-17
//var ats = map1.Values.Where(p => GetKeyMember(entity2, p)).ToList();
var ats2 = map2.Values.Where(p => GetKeyMember(entity, p)).ToList();
//if (ats.Count() > 0)
// keyMembers.AddRange(ats);//
if (ats2.Count() > 0)
relatedKeyMembers.AddRange(ats2);
// 获取标记了
//[Association(Member = "Users", KeyMembers = "RoleID", RelatedEntityID = "Users", RelatedKeyMembers = "RoleID")]
//的信息
if (relatedKeyMembers.Count == 0)//&& keyMembers.Count == 0
{
var commonNames = map1.Keys.Intersect(map2.Keys).OrderBy(k => k);
foreach (string name in commonNames)
{
//keyMembers.Add(map1[name]);//
relatedKeyMembers.Add(map2[name]);
}
}
}
public override string GetTableName(MappingEntity entity)
{
return !string.IsNullOrEmpty(entity.TableId) ? entity.TableId : this.InferTableName(entity.EntityType);
}
/// <summary>
/// Gets the key member.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="member">The member.</param>
/// <returns></returns>
private bool GetKeyMember(MappingEntity entity, MemberInfo member)
{
var a = member.GetCustomAttribute<AssociationAttribute>(false);
return a.Any(p => p.RelatedEntityID == entity.TableId.IfEmptyReplace(entity.EntityType.Name));
}
public override bool IsColumn(MappingEntity entity, MemberInfo member)
{
return IsScalar(TypeHelper.GetMemberType(member));
}
public override string GetTableName(MappingEntity entity)
{
AttributeMappingEntity en = (AttributeMappingEntity)entity;
var table = en.Tables.FirstOrDefault();
return this.GetTableName(table);
}
public override bool IsRelationshipSource(MappingEntity entity, MemberInfo member)
{
if (IsAssociationRelationship(entity, member))
{
if (typeof(IEnumerable).IsAssignableFrom(TypeHelper.GetMemberType(member)))
{
return false;
}
// is source of relationship if relatedKeyMembers are the related entity's primary keys
MappingEntity entity2 = GetRelatedEntity(entity, member);
var relatedPKs = new HashSet<string>(this.GetPrimaryKeyMembers(entity2).Select(m => m.Name));
var relatedKeyMembers = new HashSet<string>(
this.GetAssociationRelatedKeyMembers(entity, member).Select(m => m.Name));
return relatedPKs.IsSubsetOf(relatedKeyMembers) && relatedKeyMembers.IsSubsetOf(relatedPKs);
}
return false;
}
public override string GetTableName(MappingEntity entity)
{
var dbMapping = (DbMappingEntity)entity;
return(dbMapping.TypeMapping.TableName);
}
