/// <summary> /// Handles the ordered. /// </summary> /// <param name="dsd">The DSD.</param> /// <param name="dimensionAtObservation">The dimension attribute observation.</param> /// <param name="orderComponents">The order components.</param> private static void HandleOrdered(DsdEntity dsd, string dimensionAtObservation, List<ComponentEntity> orderComponents) { ComponentEntity dimensionAtObsEntity = dsd.TimeDimension; foreach (ComponentEntity dim in dsd.Dimensions) { if (!dim.Id.Equals(dimensionAtObservation)) { orderComponents.Add(dim); } else { dimensionAtObsEntity = dim; } } if (!Equals(dimensionAtObsEntity, dsd.TimeDimension)) { orderComponents.Add(dsd.TimeDimension); } orderComponents.Add(dimensionAtObsEntity); }
/// <summary> /// Handles the flat. /// </summary> /// <param name="orderComponents">The order components.</param> /// <param name="dsd">The DSD.</param> private static void HandleFlat(List<ComponentEntity> orderComponents, DsdEntity dsd) { bool bFlat; if (!bool.TryParse(ConfigurationManager.AppSettings["QueryFlatFormat"], out bFlat) || !bFlat) { orderComponents.AddRange(dsd.Dimensions); if (dsd.TimeDimension == null) { // Comment out because I don't understand why we remove the last dimension and why we add the last attribute to the order by. // This code will fail if there are no attributes in a DSD ////orderComponents.RemoveAt(orderComponents.Count - 1); ////orderComponents.Add(dsd.Attributes[dsd.Attributes.Count - 1]); } else { orderComponents.Add(dsd.TimeDimension); } } }
/// <summary> /// This method checks whether a mapping set is complete, in order to be used for the Data Retriever. /// For example,one of the checks is whether all dimensions and mandatory attributes are mapped. /// </summary> /// <param name="dsd">The DSD to be checked</param> /// <param name="componentMapping">Map between components and their mapping</param> /// <returns> /// True if the mapping is complete /// </returns> public static bool IsMappingSetComplete( DsdEntity dsd, Dictionary<ComponentEntity, MappingEntity> componentMapping) { // _log.Info(String.Format(CultureInfo.InvariantCulture,"Checking if mapping for dataflow '{0}' DSD '{1}' is complete.", // mappingSet.Dataflow.Id, dsd.Id)); bool returnValue = true; bool measureDimensionNotMapped = false; if (dsd.Dimensions != null) { int i = 0; // check if all dimensions are mapped while (i < dsd.Dimensions.Count) { if (!dsd.Dimensions[i].MeasureDimension && !componentMapping.ContainsKey(dsd.Dimensions[i])) { _log.WarnFormat( CultureInfo.InvariantCulture, "Dimension '{0}' is not mapped.", dsd.Dimensions[i].Concept.Id); returnValue = false; } else if (dsd.Dimensions[i].MeasureDimension && !componentMapping.ContainsKey(dsd.Dimensions[i])) { measureDimensionNotMapped = true; } i++; } } else { string message = string.Format( CultureInfo.InvariantCulture, "No dimensions defined in the DSD {0}", dsd.Id); _log.Info(message); // throw new DataRetrieverException(ErrorTypes.NO_MAPPING_SET, message); return false; } // check if time dimension is mapped, if one exists. if (dsd.TimeDimension != null) { if (!componentMapping.ContainsKey(dsd.TimeDimension)) { _log.WarnFormat(CultureInfo.InvariantCulture, "Time Dimension '{0}' is not mapped.", dsd.TimeDimension.Concept.Id); returnValue = false; } } // check xs-measures if (dsd.CrossSectionalMeasures != null && dsd.CrossSectionalMeasures.Count > 0 && measureDimensionNotMapped) { foreach (ComponentEntity component in dsd.CrossSectionalMeasures) { if (!componentMapping.ContainsKey(component)) { _log.WarnFormat(CultureInfo.InvariantCulture, ErrorMessages.CrossSectionalMeasureNotMappedFormat1, component.Concept.Id); returnValue = false; } } } else if (dsd.PrimaryMeasure != null) { // primary measure if (!componentMapping.ContainsKey(dsd.PrimaryMeasure)) { { _log.WarnFormat(CultureInfo.InvariantCulture, ErrorMessages.PrimaryMeasureNotMappedFormat1, dsd.PrimaryMeasure.Concept.Id); returnValue = false; } } } // atributes if (dsd.Attributes != null && dsd.Attributes.Count > 0) { foreach (ComponentEntity component in dsd.Attributes) { if (component.AttStatus == AssignmentStatus.Mandatory && !componentMapping.ContainsKey(component)) { _log.WarnFormat(CultureInfo.InvariantCulture, ErrorMessages.MandatoryAttributeNotMappedFormat1, component.Concept.Id); returnValue = false; } } } // test if 1-N or N-1 mappings have transcoding foreach (var kv in componentMapping) { if (kv.Value.Transcoding == null && (kv.Value.Columns.Count > 1 || kv.Value.Components.Count > 1)) { _log.WarnFormat(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoTranscodingFormat1, kv.Key.Concept.Id); returnValue = false; } } _log.Info( string.Format( CultureInfo.InvariantCulture, InformativeMessages.CheckMappingSetResultFormat1, returnValue)); return returnValue; }
/// <summary> /// The method retrieves the <see cref="DsdEntity"/> object /// by the data flow system identifier /// </summary> /// <param name="mappingStoreDb"> /// The <see cref="Database"/> instance for Mapping Store database /// </param> /// <param name="sysId"> /// The data flow with the specified system identifier /// </param> /// <returns> /// The populated <see cref="DsdEntity"/>object /// </returns> private static DsdEntity GetDsdByDataFlowSysId(Database mappingStoreDb, long sysId) { DsdEntity ret = null; string paramId = mappingStoreDb.BuildParameterName(ParameterNameConstants.IdParameter); var sqlCommand = new StringBuilder(); sqlCommand.Append("SELECT DSD.DSD_ID, ART.ID, ART.VERSION, ART.AGENCY "); sqlCommand.Append("FROM DSD, DATAFLOW DF, ARTEFACT_VIEW ART "); sqlCommand.Append("WHERE DF.DSD_ID = DSD.DSD_ID "); sqlCommand.Append("AND DSD.DSD_ID = ART.ART_ID "); sqlCommand.AppendFormat("AND DF.DF_ID = {0} ", paramId); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sqlCommand.ToString())) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { // we expect only 1 record here if (dataReader.Read()) { ret = new DsdEntity(DataReaderHelper.GetInt64(dataReader, "DSD_ID")) { Id = DataReaderHelper.GetString(dataReader, "ID"), Version = DataReaderHelper.GetString(dataReader, "VERSION"), Agency = DataReaderHelper.GetString(dataReader, "AGENCY") }; } } } if (ret == null) { throw new MappingStoreException( string.Format( CultureInfo.InvariantCulture, ErrorMessages.MappingStoreNoEntityFormat2, typeof(DsdEntity), sysId)); } // populate the Dsd fields by the correct components PoulateDsdComponentsByDsdSysId(mappingStoreDb, ret.SysId, ref ret); return ret; }
/// <summary> /// The method populates all the <see cref="ComponentEntity">DSD components</see> /// of a <see cref="DsdEntity"/> object by the data structure definition identifier /// </summary> /// <param name="mappingStoreDb"> /// The <see cref="Database"/> instance for Mapping Store database /// </param> /// <param name="sysId"> /// The data flow with the specified system identifier /// </param> /// <param name="dsd"> /// The populated <see cref="DsdEntity"/>object containing also the /// <see cref="ComponentEntity">DSD components</see> /// </param> private static void PoulateDsdComponentsByDsdSysId(Database mappingStoreDb, long sysId, ref DsdEntity dsd) { GroupEntity group; string id; string paramId = mappingStoreDb.BuildParameterName(ParameterNameConstants.IdParameter); var sqlCommand = new StringBuilder(); sqlCommand.Append("SELECT G.GR_ID AS GR_ID, G.ID AS ID, DG.COMP_ID AS COMP_ID "); sqlCommand.Append("FROM DSD D, DSD_GROUP G, DIM_GROUP DG "); sqlCommand.AppendFormat("WHERE D.DSD_ID = G.DSD_ID AND G.GR_ID = DG.GR_ID AND D.DSD_ID = {0} ", paramId); sqlCommand.Append("ORDER BY G.GR_ID"); // used to store the groups given the dimension system id. Is used later to gather actual ComponentVO objects and set them to Group var groupsFromDim = new Dictionary<long, List<GroupEntity>>(); // holds the groups created given their group id var groupsFromId = new Dictionary<string, GroupEntity>(); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sqlCommand.ToString())) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { // we expect only 1 record here ? while (dataReader.Read()) { id = DataReaderHelper.GetString(dataReader, "ID"); // do we have a new group id if (!groupsFromId.ContainsKey(id)) { group = new GroupEntity(DataReaderHelper.GetInt64(dataReader, "GR_ID")) { Id = id }; dsd.AddGroup(group); groupsFromId.Add(id, group); } else { group = groupsFromId[id]; } long dimId = DataReaderHelper.GetInt64(dataReader, "COMP_ID"); List<GroupEntity> groupsList; if (!groupsFromDim.TryGetValue(dimId, out groupsList)) { groupsList = new List<GroupEntity>(); groupsFromDim.Add(dimId, groupsList); } groupsList.Add(group); } } } sqlCommand = new StringBuilder(); sqlCommand.Append("SELECT COMP.COMP_ID, COMP.ID as CID, COMP.TYPE, COMP.DSD_ID, COMP.CON_ID, COMP.CL_ID, "); sqlCommand.Append("COMP.IS_FREQ_DIM, COMP.IS_MEASURE_DIM, COMP.ATT_ASS_LEVEL, COMP.ATT_STATUS, "); sqlCommand.Append("COMP.ATT_IS_TIME_FORMAT, COMP.XS_ATTLEVEL_DS, COMP.XS_ATTLEVEL_GROUP, "); sqlCommand.Append("COMP.XS_ATTLEVEL_SECTION, COMP.XS_ATTLEVEL_OBS, COMP.XS_MEASURE_CODE, "); sqlCommand.Append("AG.GR_ID, GR.ID AS GID, MC.ID as MID "); sqlCommand.Append("FROM DSD INNER JOIN COMPONENT COMP ON DSD.DSD_ID = COMP.DSD_ID "); sqlCommand.Append("LEFT OUTER JOIN ATT_GROUP AG ON COMP.COMP_ID = AG.COMP_ID "); sqlCommand.Append("LEFT OUTER JOIN DSD_GROUP GR ON AG.GR_ID = GR.GR_ID "); sqlCommand.Append("LEFT OUTER JOIN ATT_MEASURE AM ON AM.ATT_COMP_ID = COMP.COMP_ID "); sqlCommand.Append("LEFT OUTER JOIN COMPONENT MC ON AM.MEASURE_COMP_ID = MC.COMP_ID "); sqlCommand.AppendFormat("WHERE DSD.DSD_ID = {0} ", paramId); // make sure that they are returned in the order they were inserted (proper order) sqlCommand.Append("ORDER BY COMP.COMP_ID "); // hashmap keeping components already met with key the sys id. var componentsMap = new Dictionary<long, ComponentEntity>(); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sqlCommand.ToString())) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { // GetOrdinal positions int compIdIdx = dataReader.GetOrdinal("COMP_ID"); int type = dataReader.GetOrdinal("TYPE"); int isFreqDim = dataReader.GetOrdinal("IS_FREQ_DIM"); int isMeasureDim = dataReader.GetOrdinal("IS_MEASURE_DIM"); int attAssLevel = dataReader.GetOrdinal("ATT_ASS_LEVEL"); int attStatus = dataReader.GetOrdinal("ATT_STATUS"); int attIsTimeFormat = dataReader.GetOrdinal("ATT_IS_TIME_FORMAT"); int crossSectionalAttachmentlevelDataSet = dataReader.GetOrdinal("XS_ATTLEVEL_DS"); int attlevelGroup = dataReader.GetOrdinal("XS_ATTLEVEL_GROUP"); int attlevelSection = dataReader.GetOrdinal("XS_ATTLEVEL_SECTION"); int attlevelObs = dataReader.GetOrdinal("XS_ATTLEVEL_OBS"); int measureCode = dataReader.GetOrdinal("XS_MEASURE_CODE"); int gid = dataReader.GetOrdinal("GID"); int cid = dataReader.GetOrdinal("CID"); int mid = dataReader.GetOrdinal("MID"); while (dataReader.Read()) { long compSysId = DataReaderHelper.GetInt64(dataReader, compIdIdx); // check if new populate ComponentEntity component; if (!componentsMap.TryGetValue(compSysId, out component)) { component = new ComponentEntity(compSysId); component.Id = DataReaderHelper.GetString(dataReader, cid); component.SetType(DataReaderHelper.GetString(dataReader, type)); component.CrossSectionalLevelDataSet = DataReaderHelper.GetBoolean( dataReader, crossSectionalAttachmentlevelDataSet); component.CrossSectionalLevelGroup = DataReaderHelper.GetBoolean(dataReader, attlevelGroup); component.CrossSectionalLevelSection = DataReaderHelper.GetBoolean( dataReader, attlevelSection); component.CrossSectionalLevelObs = DataReaderHelper.GetBoolean(dataReader, attlevelObs); component.CrossSectionalMeasureCode = DataReaderHelper.GetString(dataReader, measureCode); switch (component.ComponentType) { case SdmxComponentType.Dimension: component.FrequencyDimension = DataReaderHelper.GetBoolean(dataReader, isFreqDim); component.MeasureDimension = DataReaderHelper.GetBoolean(dataReader, isMeasureDim); dsd.Dimensions.Add(component); break; case SdmxComponentType.Attribute: component.SetAttachmentLevel(DataReaderHelper.GetString(dataReader, attAssLevel)); component.SetAssignmentStatus(DataReaderHelper.GetString(dataReader, attStatus)); component.AttTimeFormat = DataReaderHelper.GetBoolean(dataReader, attIsTimeFormat); dsd.Attributes.Add(component); break; case SdmxComponentType.TimeDimension: dsd.TimeDimension = component; break; case SdmxComponentType.PrimaryMeasure: dsd.PrimaryMeasure = component; break; case SdmxComponentType.CrossSectionalMeasure: dsd.CrossSectionalMeasures.Add(component); break; } componentsMap.Add(compSysId, component); } // populate for current groups the related assigned groups if any id = DataReaderHelper.GetString(dataReader, gid); if (!string.IsNullOrEmpty(id)) { group = groupsFromId[id]; component.AttAssignmentGroups.Add(group); } var measureId = DataReaderHelper.GetString(dataReader, mid); if (!string.IsNullOrEmpty(measureId)) { component.AttAttachmentMeasures.Add(measureId); } // if component is a dimension used in group definition, add it in their object List<GroupEntity> groupFromDim; if (groupsFromDim.TryGetValue(compSysId, out groupFromDim)) { foreach (GroupEntity groupsItem in groupFromDim) { groupsItem.Dimensions.Add(component); } } } } } foreach (var kv in componentsMap) { kv.Value.Concept = GetConceptByComponentSysId(mappingStoreDb, kv.Key); kv.Value.CodeList = GetCodeListByComponentSysId(mappingStoreDb, kv.Key); } }
/// <summary> /// Gets the requested component unique identifier. /// </summary> /// <param name="dsdEntity">The DSD entity.</param> /// <param name="conceptId">The requested component.</param> /// <returns> /// The Component.Id /// </returns> private static string GetRequestedComponentId(DsdEntity dsdEntity, string conceptId) { if (dsdEntity.TimeDimension != null && dsdEntity.TimeDimension.Concept.Id.Equals(conceptId)) { conceptId = dsdEntity.TimeDimension.Id; } else { var dimension = dsdEntity.Dimensions.FirstOrDefault(entity => entity.Concept.Id.Equals(conceptId)); conceptId = dimension == null ? conceptId : dimension.Id; } return conceptId; }