/// <summary> /// Initializes a new instance of the <see cref="TimeDimensionDateType"/> class. /// Builds a TimeDimensionDateType /// </summary> /// <param name="mapping"> /// The mapping of TimeDimension component /// </param> /// <param name="expression"> /// The expression that is used in this mapping /// </param> /// <param name="databaseType"> /// The dissemination database type /// </param> public TimeDimensionDateType(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) : base(mapping, expression, databaseType) { string provider = DatabaseType.GetProviderName(databaseType); string cast = DatabaseType.DatabaseSettings[provider].DateCast; /* if (databaseType.Equals(DatabaseType.Mappings.Oracle.Name, StringComparison.OrdinalIgnoreCase) || databaseType.Equals(DatabaseType.Mappings.MySql.Name, StringComparison.OrdinalIgnoreCase)) { cast = "DATE"; } */ var dateColumnSysId = expression.DateColumnSysId; string columnName = GetColumnName(mapping, dateColumnSysId); this._startWhereFormat = string.Format( CultureInfo.InvariantCulture, "({0}>= {2}'{1}')", columnName, "{0}", cast); this._endWhereFormat = string.Format( CultureInfo.InvariantCulture, "({0}<= {2}'{1}')", columnName, "{0}", cast); this._resultParsingMap.Add(typeof(DateTime), x => (DateTime)x); this._resultParsingMap.Add(typeof(long), x => new DateTime((long)x)); this._resultParsingMap.Add( typeof(string), x => { DateTime time; return DateTime.TryParse((string)x, CultureInfo.InvariantCulture, DateTimeStyles.None, out time) ? DateTime.MinValue : time; }); this._fieldOrdinals = new TimeTranscodingFieldOrdinal(mapping, this.Expression); }
/// <summary> /// Initializes a new instance of the <see cref="TimeDimensionConstant"/> class. /// Initialize an new instance of the TimeDimensionMapping based class /// </summary> /// <param name="mapping"> /// The time dimension mapping /// </param> /// <param name="expression"> /// It is not used in this implementation /// </param> /// <param name="databaseType"> /// The dissemination database vendor from DB_CONNECTION.DB_TYPE at Mapping Store database. It is used to determine the substring command to use /// </param> /// <exception cref="TranscodingException"> /// It is not used in this implementation /// </exception> public TimeDimensionConstant(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) : base(mapping, expression, databaseType) { this._fromWhere = string.Format( CultureInfo.InvariantCulture, " ( '{0}' >= '{1}' )", mapping.Constant, "{0}"); this._toWhere = string.Format(CultureInfo.InvariantCulture, " ( '{0}' <= '{1}' )", mapping.Constant, "{0}"); this._equalsWhere = string.Format( CultureInfo.InvariantCulture, " ( '{0}' = '{1}' )", mapping.Constant, "{0}"); }
/// <summary> /// Initializes a new instance of the <see cref="TimeDimension1To1"/> class. /// Initialize an new instance of the TimeDimensionMapping based class /// </summary> /// <param name="mapping"> /// The time dimension mapping /// </param> /// <param name="expression"> /// It is not used in this implementation /// </param> /// <param name="databaseType"> /// The dissemination database vendor from DB_CONNECTION.DB_TYPE at Mapping Store database. It is used to determine the substring command to use /// </param> /// <exception cref="TranscodingException"> /// It is not used in this implementation /// </exception> public TimeDimension1To1(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) : base(mapping, expression, databaseType) { this._fromWhere = string.Format( CultureInfo.InvariantCulture, " ( {0} >= '{1}' )", mapping.Columns[0].Name, "{0}"); this._toWhere = string.Format( CultureInfo.InvariantCulture, " ( {0} <= '{1}' )", mapping.Columns[0].Name, "{0}"); this._equalsWhere = string.Format( CultureInfo.InvariantCulture, " ( {0} = '{1}' )", mapping.Columns[0].Name, "{0}"); }
/// <summary> /// Initializes a new instance of the <see cref="TimeDimensionMapping"/> class. /// Initialize an new instance of the TimeDimensionMapping based class /// </summary> /// <param name="mapping"> /// The time dimension mapping /// </param> /// <param name="expression"> /// The TRANSCODING.EXPRESSION contents /// </param> /// <param name="databaseType"> /// The dissemination database vendor from DB_CONNECTION.DB_TYPE at Mapping Store database. It is used to determine the substring command to use /// </param> /// <exception cref="TranscodingException"> /// Occurs when transcoding cannot performed due to incorrect mapping store data /// </exception> protected TimeDimensionMapping(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) { this.Mapping = mapping; this.Component = mapping.Components[0]; this._expression = expression; this.SetDbType(databaseType); if (expression != null) { this._periodicity = PeriodicityFactory.Create(expression.Freq); } }
/// <summary> /// Initializes a new instance of the <see cref="TimeTranscodingFieldOrdinal"/> class. /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> /// <param name="mapping"> /// The mapping. /// </param> /// <param name="expression"> /// The expression. /// </param> public TimeTranscodingFieldOrdinal(MappingEntity mapping, TimeExpressionEntity expression) { this._yearColumn = new NameOrdinal(GetColumnName(mapping, expression.YearColumnSysId)); this._periodColumn = new NameOrdinal(GetColumnName(mapping, expression.PeriodColumnSysId)); this._dateColumn = new NameOrdinal(GetColumnName(mapping, expression.DateColumnSysId)); if (this._yearColumn.IsSet) { this._nameOrdinals = this._periodColumn.IsSet ? new[] { this._yearColumn, this._periodColumn } : new[] { this._yearColumn }; } else { this._nameOrdinals = new[] { this._dateColumn }; } }
/// <summary> /// Initializes a new instance of the <see cref="TimeDimension1Column"/> class. /// </summary> /// <param name="mapping"> /// The time dimension mapping /// </param> /// <param name="expression"> /// The TRANSCODING.EXPRESSION contents /// </param> /// <param name="databaseType"> /// The dissemination database vendor from DB_CONNECTION.DB_TYPE at Mapping Store database. It is used to determine the substring command to use /// </param> /// <exception cref="TranscodingException"> /// Occurs when transcoding cannot performed due to incorrect mapping store data /// </exception> public TimeDimension1Column(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) : base(mapping, expression, databaseType) { this._periodLocalCode = new CodeCollection(); string yearPeriodColumn = GetColumnName(mapping, expression.YearColumnSysId); string yearOnlyStart = this.CreateSubStringClause(yearPeriodColumn, expression.YearStart + 1, expression.YearLength, ">="); string yearOnlyEnd = this.CreateSubStringClause(yearPeriodColumn, expression.YearStart + 1, expression.YearLength, "<="); string whereFormat = this.CreateSubStringClause(yearPeriodColumn, expression.PeriodStart + 1, expression.PeriodLength, "="); string yearOnlyWhereFormat = this.CreateSubStringClause(yearPeriodColumn, expression.YearStart + 1, expression.YearLength, "="); this._whereBuilder = new TimeTranscodingWhereBuilder(this.Periodicity, this.Expression, whereFormat, yearOnlyEnd, yearOnlyStart, yearOnlyWhereFormat); this._fieldOrdinals = new TimeTranscodingFieldOrdinal(mapping, this.Expression); }
/// <summary> /// Initializes a new instance of the <see cref="TimeDimension2Column"/> class. /// </summary> /// <param name="mapping"> /// The time dimension mapping /// </param> /// <param name="expression"> /// The TRANSCODING.EXPRESSION contents /// </param> /// <param name="databaseType"> /// The dissemination database vendor from DB_CONNECTION.DB_TYPE at Mapping Store database. It is used to determine the substring command to use /// </param> /// <exception cref="TranscodingException"> /// Occurs when transcoding cannot performed due to incorrect mapping store data /// </exception> public TimeDimension2Column(MappingEntity mapping, TimeExpressionEntity expression, string databaseType) : base(mapping, expression, databaseType) { string yearOnlyWhereFormat; string yearOnlyStart; string yearOnlyEnd; string whereFormat; this._periodLocalCode = new CodeCollection(); string yearColumn = GetColumnName(mapping, expression.YearColumnSysId); string periodColumn = GetColumnName(mapping, expression.PeriodColumnSysId); string periodClause = expression.PeriodLength == 0 ? string.Format(FormatProvider, "( {0} = '{1}' )", periodColumn, "{0}") : this.CreateSubStringClause(periodColumn, expression.PeriodStart + 1, expression.PeriodLength, "="); if (expression.YearLength == 0) { yearOnlyStart = string.Format(FormatProvider, " ( {0} >= '{1}' )", yearColumn, "{0}"); yearOnlyEnd = string.Format(FormatProvider, " ( {0} <= '{1}' )", yearColumn, "{0}"); yearOnlyWhereFormat = string.Format(FormatProvider, "( {0} = '{1}' )", yearColumn, "{0}"); // whereFormat = String.Format(FormatProvider,"({0} = '{1}' and {2} )",yearColumn, "{0}",periodClause); whereFormat = periodClause; } else { yearOnlyStart = this.CreateSubStringClause(yearColumn, expression.YearStart + 1, expression.YearLength, ">="); yearOnlyEnd = this.CreateSubStringClause(yearColumn, expression.YearStart + 1, expression.YearLength, "<="); whereFormat = periodClause; yearOnlyWhereFormat = this.CreateSubStringClause(yearColumn, expression.YearStart + 1, expression.YearLength, "="); } this._whereBuilder = new TimeTranscodingWhereBuilder(this.Periodicity, this.Expression, whereFormat, yearOnlyEnd, yearOnlyStart, yearOnlyWhereFormat); this._fieldOrdinals = new TimeTranscodingFieldOrdinal(mapping, this.Expression); }
/// <summary> /// Gets the name of the column. /// </summary> /// <param name="mapping"> /// The mapping. /// </param> /// <param name="dateColumnSysId"> /// The date column sys id. /// </param> /// <returns> /// The column name /// </returns> private static string GetColumnName(MappingEntity mapping, long dateColumnSysId) { if (dateColumnSysId > 0) { return mapping.Columns.First(entity => entity.SysId == dateColumnSysId).Name; } return null; }
/// <summary> /// Retrieve time transcoding and populate the <paramref name="timeDimensionMapping"/>. /// </summary> /// <param name="mappingStoreDb"> /// The mapping store DB. /// </param> /// <param name="timeDimensionMapping"> /// The time dimension mapping. /// </param> private static void RetrieveTimeTranscoding(Database mappingStoreDb, MappingEntity timeDimensionMapping) { if (timeDimensionMapping == null) { return; } DbParameter parameter = mappingStoreDb.CreateInParameter(ParameterNameConstants.TranscodingId, DbType.Int64, timeDimensionMapping.Transcoding.SysId); using (DbCommand command = mappingStoreDb.GetSqlStringCommandFormat(MappingStoreSqlStatements.TimeTranscoding, parameter)) { using (IDataReader reader = mappingStoreDb.ExecuteReader(command)) { int freqIdx = reader.GetOrdinal("FREQ"); int yearColIdIdx = reader.GetOrdinal("YEAR_COL_ID"); int periodColIdIdx = reader.GetOrdinal("PERIOD_COL_ID"); int dateColIdIdx = reader.GetOrdinal("DATE_COL_ID"); int expressionIdx = reader.GetOrdinal("EXPRESSION"); var timeTranscodingCollection = timeDimensionMapping.Transcoding.TimeTranscodingCollection; while (reader.Read()) { var timeTranscoding = timeTranscodingCollection.Add(DataReaderHelper.GetString(reader, freqIdx)); timeTranscoding.YearColumnId = DataReaderHelper.GetInt64(reader, yearColIdIdx); timeTranscoding.PeriodColumnId = DataReaderHelper.GetInt64(reader, periodColIdIdx); timeTranscoding.DateColumnId = DataReaderHelper.GetInt64(reader, dateColIdIdx); timeTranscoding.Expression = DataReaderHelper.GetString(reader, expressionIdx); } } } }
/// <summary> /// Retrieve TimeDimension transcoding, if <paramref name="timeDimensionMapping"/> is null /// </summary> /// <param name="mappingStoreDb"> /// The mapping store DB. /// </param> /// <param name="timeDimensionMapping"> /// The time dimension mapping. /// </param> private static void RetrieveTimeDimensionTranscoding( Database mappingStoreDb, MappingEntity timeDimensionMapping) { if (timeDimensionMapping == null) { return; } RetrieveTimeTranscoding(mappingStoreDb, timeDimensionMapping); TimeTranscodingCollection timeTranscodingCollection = timeDimensionMapping.Transcoding.TimeTranscodingCollection; if (timeTranscodingCollection.Count == 1 && TimeFormat.GetTimeFormatFromCodeId(timeTranscodingCollection[0].FrequencyValue).EnumType == TimeFormatEnumType.Year) { return; } var codelists = PeriodCodelist.PeriodCodelistIdMap; IDictionary<string, TimeTranscodingEntity> transcodingMap = new Dictionary<string, TimeTranscodingEntity>(StringComparer.Ordinal); foreach (var periodObject in codelists) { if (timeTranscodingCollection.Contains(periodObject.Key)) { var timeTranscodingEntity = timeTranscodingCollection[periodObject.Key]; if (timeTranscodingEntity.PeriodColumnId > 0) { var timeDimensionRules = new TranscodingRulesEntity(); timeDimensionRules.AddColumn(timeTranscodingEntity.PeriodColumnId, 0); timeDimensionRules.AddComponent(timeDimensionMapping.Components[0].SysId, 0); timeTranscodingEntity.TranscodingRules = timeDimensionRules; transcodingMap.Add(periodObject.Value.Id, timeTranscodingEntity); } } } DbParameter parameter = mappingStoreDb.CreateInParameter(ParameterNameConstants.TranscodingId, DbType.Int64, timeDimensionMapping.Transcoding.SysId); using (DbCommand command = mappingStoreDb.GetSqlStringCommandFormat(MappingStoreSqlStatements.TranscodingRulesTimeDimension, parameter)) using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { int dsdcodeIdx = dataReader.GetOrdinal("DSDCODE"); int localcodeIdx = dataReader.GetOrdinal("LOCALCODE"); int codelistId = dataReader.GetOrdinal("CODELIST_ID"); while (dataReader.Read()) { var periodCodelist = DataReaderHelper.GetString(dataReader, codelistId); TimeTranscodingEntity timeTranscodingEntity; if (transcodingMap.TryGetValue(periodCodelist, out timeTranscodingEntity)) { var timeDimensionRules = timeTranscodingEntity.TranscodingRules; var dsdperiod = new CodeCollection(); var localperiod = new CodeCollection(); dsdperiod.Add(DataReaderHelper.GetString(dataReader, dsdcodeIdx)); localperiod.Add(DataReaderHelper.GetString(dataReader, localcodeIdx)); timeDimensionRules.Add(localperiod, dsdperiod); } } } }
/// <summary> /// This method retrieves a list of <see cref="MappingEntity"/> objects /// by the mapping set system identifier /// </summary> /// <param name="mappingStoreDb"> /// The <see cref="Database"/> instance for Mapping Store database /// </param> /// <param name="mappingSet"> /// The mapping set /// </param> private static void GetMappingsByMappingSetSysId(Database mappingStoreDb, MappingSetEntity mappingSet) { long sysId = mappingSet.SysId; var dictionary = new Dictionary<long, MappingEntity>(); var componentMap = new Dictionary<long, ComponentEntity>(); bool transcoded = false; MappingEntity timeDimensionMapping = null; AddToComponentMap(mappingSet.Dataflow.Dsd.Dimensions, componentMap); if (mappingSet.Dataflow.Dsd.TimeDimension != null) { componentMap.Add(mappingSet.Dataflow.Dsd.TimeDimension.SysId, mappingSet.Dataflow.Dsd.TimeDimension); } componentMap.Add(mappingSet.Dataflow.Dsd.PrimaryMeasure.SysId, mappingSet.Dataflow.Dsd.PrimaryMeasure); AddToComponentMap(mappingSet.Dataflow.Dsd.Attributes, componentMap); AddToComponentMap(mappingSet.Dataflow.Dsd.CrossSectionalMeasures, componentMap); string paramId = mappingStoreDb.BuildParameterName(ParameterNameConstants.IdParameter); var sqlCommand = new StringBuilder(); // select sqlCommand.Append("SELECT CMAP.MAP_ID, CMAP.TYPE, CMAP.CONSTANT, CMAPCOMP.COMP_ID, TR.TR_ID, TR.EXPRESSION "); // from1 sqlCommand.Append("FROM COMPONENT_MAPPING CMAP INNER JOIN MAPPING_SET MSET ON MSET.MAP_SET_ID = CMAP.MAP_SET_ID INNER JOIN COM_COL_MAPPING_COMPONENT CMAPCOMP ON CMAPCOMP.MAP_ID = CMAP.MAP_ID "); sqlCommand.Append(" LEFT OUTER JOIN TRANSCODING TR ON TR.MAP_ID = CMAP.MAP_ID "); // where sqlCommand.AppendFormat(" WHERE MSET.MAP_SET_ID = {0} ", paramId); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sqlCommand.ToString())) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { int mapID = dataReader.GetOrdinal("MAP_ID"); int type = dataReader.GetOrdinal("TYPE"); int constant = dataReader.GetOrdinal("CONSTANT"); int compIDIdx = dataReader.GetOrdinal("COMP_ID"); int tridIdx = dataReader.GetOrdinal("TR_ID"); int exprIdx = dataReader.GetOrdinal("EXPRESSION"); while (dataReader.Read()) { // get existing or create new mapping object long mapId = DataReaderHelper.GetInt64(dataReader, mapID); MappingEntity mapping; if (!dictionary.TryGetValue(mapId, out mapping)) { // create new mapping and append it to the mapping set mapping = new MappingEntity(mapId) { MappingType = DataReaderHelper.GetString(dataReader, type), Constant = DataReaderHelper.GetString(dataReader, constant) }; long trid = DataReaderHelper.GetInt64(dataReader, tridIdx); if (trid > 0) { mapping.Transcoding = new TranscodingEntity(trid) { Expression = DataReaderHelper.GetString(dataReader, exprIdx) }; transcoded = true; } dictionary.Add(mapId, mapping); mappingSet.Mappings.Add(mapping); } long componentSysId = DataReaderHelper.GetInt64(dataReader, compIDIdx); ComponentEntity component; if (componentMap.TryGetValue(componentSysId, out component)) { mapping.Components.Add(component); if (component.Equals(mappingSet.Dataflow.Dsd.TimeDimension) && mapping.Transcoding != null) { timeDimensionMapping = mapping; } } } } } // second select sqlCommand = new StringBuilder(); sqlCommand.Append( "SELECT CMAP.MAP_ID, CMAP.TYPE, CMAP.CONSTANT, DSCOL.COL_ID, DSCOL.NAME, DSCOL.DS_ID "); sqlCommand.Append( "FROM COMPONENT_MAPPING CMAP, MAPPING_SET MSET, COM_COL_MAPPING_COLUMN CMAPCOL, DATASET_COLUMN DSCOL "); sqlCommand.Append("WHERE MSET.MAP_SET_ID = CMAP.MAP_SET_ID "); sqlCommand.Append("AND CMAP.MAP_ID = CMAPCOL.MAP_ID "); sqlCommand.Append("AND CMAPCOL.COL_ID = DSCOL.COL_ID "); sqlCommand.AppendFormat("AND MSET.MAP_SET_ID = {0} ", paramId); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sqlCommand.ToString())) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { int mapID = dataReader.GetOrdinal("MAP_ID"); int type = dataReader.GetOrdinal("TYPE"); int constant = dataReader.GetOrdinal("CONSTANT"); int colIDIdx = dataReader.GetOrdinal("COL_ID"); int nameIdx = dataReader.GetOrdinal("NAME"); ////int descIdx = dataReader.GetOrdinal("DESCRIPTION"); while (dataReader.Read()) { // get existing or create new mapping object long mapId = DataReaderHelper.GetInt64(dataReader, mapID); MappingEntity mapping; if (!dictionary.TryGetValue(mapId, out mapping)) { // create new mapping and append it to the mapping set mapping = new MappingEntity(mapId) { MappingType = DataReaderHelper.GetString(dataReader, type), Constant = DataReaderHelper.GetString(dataReader, constant) }; dictionary.Add(mapId, mapping); mappingSet.Mappings.Add(mapping); } var column = new DataSetColumnEntity(DataReaderHelper.GetInt64(dataReader, colIDIdx)) { Name = DataReaderHelper.GetString(dataReader, nameIdx) }; // dsColumn.SysId = DataReaderHelper.GetInt64(dataReader, "DS_ID"); ////column.Description = DataReaderHelper.GetString(dataReader, descIdx); mapping.Columns.Add(column); } } } if (transcoded) { GetTranscodingRulesByMapSetId(mappingStoreDb, sysId, timeDimensionMapping, dictionary); RetrieveTimeDimensionTranscoding(mappingStoreDb, timeDimensionMapping); } }
/// <summary> /// The method retrieves the <see cref="TranscodingRulesEntity"/> object /// by the transcoding system identifier /// </summary> /// <param name="mappingStoreDb"> /// The <see cref="Database"/> instance for Mapping Store database /// </param> /// <param name="sysId"> /// The mapping set with the specified system identifier /// </param> /// <param name="timeDimensionMapping"> /// The TRANSCODING.TR_ID value of the TimeDimension, if there is TimeDimension and is transcoded; otherwise set to null /// </param> /// <param name="mappingsMap"> /// The map between COMPONENT_MAPPING.MAP_ID value and MappingEntity /// </param> private static void GetTranscodingRulesByMapSetId(Database mappingStoreDb, long sysId, MappingEntity timeDimensionMapping, IDictionary<long, MappingEntity> mappingsMap) { string paramId = mappingStoreDb.BuildParameterName(ParameterNameConstants.IdParameter); string timeDimensionTranscodingIdParam = mappingStoreDb.BuildParameterName(ParameterNameConstants.TranscodingId); object timedimensionID = timeDimensionMapping == null ? (object)null : timeDimensionMapping.Transcoding.SysId; // holds the dsd codes by rule var componentsByRule = new Dictionary<long, CodeCollection>(); string sql = string.Format( CultureInfo.InvariantCulture, MappingStoreSqlStatements.TranscodingRulesDsdCodes, paramId, timeDimensionTranscodingIdParam); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sql)) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); mappingStoreDb.AddInParameter(command, ParameterNameConstants.TranscodingId, DbType.Int64, timedimensionID); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { int pos = 0; long prevMapId = -1; TranscodingRulesEntity currentRules = null; long firstTrRuleID = -1; long curTrRuleID = -1; long prevTrRuleID = -1; var componentList = new CodeCollection(); int ruleIDIdx = dataReader.GetOrdinal("TR_RULE_ID"); int componentIdx = dataReader.GetOrdinal("COMPONENT"); int codeIdx = dataReader.GetOrdinal("CODE"); int mapIdIdx = dataReader.GetOrdinal("MAP_ID"); while (dataReader.Read()) { long curMapId = DataReaderHelper.GetInt64(dataReader, mapIdIdx); if (prevMapId != curMapId || currentRules == null) { prevMapId = curMapId; if (curTrRuleID > -1) { componentsByRule.Add(curTrRuleID, componentList); } componentList = new CodeCollection(); firstTrRuleID = -1; prevTrRuleID = -1; pos = 0; MappingEntity curretMapping = mappingsMap[curMapId]; currentRules = new TranscodingRulesEntity(); curretMapping.Transcoding.TranscodingRules = currentRules; } curTrRuleID = DataReaderHelper.GetInt64(dataReader, ruleIDIdx); if (firstTrRuleID == -1 || firstTrRuleID == curTrRuleID) { firstTrRuleID = curTrRuleID; prevTrRuleID = curTrRuleID; currentRules.AddComponent(DataReaderHelper.GetInt64(dataReader, componentIdx), pos); pos++; } else if (prevTrRuleID != curTrRuleID) { componentsByRule.Add(prevTrRuleID, componentList); componentList = new CodeCollection(); prevTrRuleID = curTrRuleID; } componentList.Add(DataReaderHelper.GetString(dataReader, codeIdx)); } if (curTrRuleID > -1) { componentsByRule.Add(curTrRuleID, componentList); } } } if (componentsByRule.Count > 0) { sql = string.Format( CultureInfo.InvariantCulture, MappingStoreSqlStatements.TranscodingRulesLocalCodes, paramId, timeDimensionTranscodingIdParam); using (DbCommand command = mappingStoreDb.GetSqlStringCommand(sql)) { mappingStoreDb.AddInParameter(command, ParameterNameConstants.IdParameter, DbType.Int64, sysId); mappingStoreDb.AddInParameter(command, ParameterNameConstants.TranscodingId, DbType.Int64, timedimensionID); using (IDataReader dataReader = mappingStoreDb.ExecuteReader(command)) { long prevMapId = -1; int pos = 0; TranscodingRulesEntity currentRules = null; long firstTrRuleID = -1; long curTrRuleID = -1; long prevTrRuleID = -1; var columnList = new CodeCollection(); int ruleIDIdx = dataReader.GetOrdinal("TR_RULE_ID"); int columnIdx = dataReader.GetOrdinal("LOCAL_COLUMN"); int codeIdx = dataReader.GetOrdinal("CODE"); int mapIdIdx = dataReader.GetOrdinal("MAP_ID"); while (dataReader.Read()) { long curMapId = DataReaderHelper.GetInt64(dataReader, mapIdIdx); if (prevMapId != curMapId || currentRules == null) { prevMapId = curMapId; if (curTrRuleID > -1 && currentRules != null) { currentRules.Add(columnList, componentsByRule[curTrRuleID]); } firstTrRuleID = -1; prevTrRuleID = -1; pos = 0; columnList = new CodeCollection(); MappingEntity curretMapping = mappingsMap[curMapId]; currentRules = curretMapping.Transcoding.TranscodingRules; } curTrRuleID = DataReaderHelper.GetInt64(dataReader, ruleIDIdx); if (firstTrRuleID == -1 || firstTrRuleID == curTrRuleID) { firstTrRuleID = curTrRuleID; prevTrRuleID = curTrRuleID; currentRules.AddColumn(DataReaderHelper.GetInt64(dataReader, columnIdx), pos); pos++; } else if (prevTrRuleID != curTrRuleID) { currentRules.Add(columnList, componentsByRule[prevTrRuleID]); columnList = new CodeCollection(); prevTrRuleID = curTrRuleID; } columnList.Add(DataReaderHelper.GetString(dataReader, codeIdx)); } if (curTrRuleID > -1 && currentRules != null) { currentRules.Add(columnList, componentsByRule[curTrRuleID]); } } } } }
/// <summary> /// Creates the appropriate Time Dimension Mapping object <see cref="ITimeDimension"/> based on the mapping from the mapping store /// e.g. it will create a different object if TimeDimension is mapped to one column, different if it is mapped two column and different if the column is Date type /// </summary> /// <param name="mapping"> /// The mapping entity<see cref="MappingEntity"/> of the Time Dimension component /// </param> /// <param name="frequencyComponentMapping"> /// The frequency component mapping. /// </param> /// <param name="databaseType"> /// The dissemination database vendor. Is needed to generate the correct SQL query where conditions /// </param> /// <returns> /// An Time Dimension Transcoding object<see cref="ITimeDimension"/> /// </returns> public static ITimeDimension Create(MappingEntity mapping, IComponentMapping frequencyComponentMapping, string databaseType) { ITimeDimension timeDimensionTranscoding = null; if (mapping.Transcoding == null) { timeDimensionTranscoding = new TimeDimensionSingleFrequency(CreateTimeDimensionMapping(mapping, databaseType)); } else if (mapping.Transcoding.TimeTranscodingCollection.Count == 1) { timeDimensionTranscoding = new TimeDimensionSingleFrequency(CreateTranscodedTimeDimensionMapping(mapping, databaseType, mapping.Transcoding.TimeTranscodingCollection.First())); } else if (mapping.Transcoding.TimeTranscodingCollection.Count > 1) { var timeDimensionMappings = new Dictionary<string, ITimeDimensionMapping>(StringComparer.Ordinal); foreach (var transcodingEntity in mapping.Transcoding.TimeTranscodingCollection) { var timeDimensionSubTranscoding = CreateTranscodedTimeDimensionMapping(mapping, databaseType, transcodingEntity); timeDimensionMappings[transcodingEntity.FrequencyValue] = timeDimensionSubTranscoding; } timeDimensionTranscoding = new TimeDimensionMultiFrequency(timeDimensionMappings, frequencyComponentMapping); } if (timeDimensionTranscoding != null) { timeDimensionTranscoding.Component = mapping.Components[0]; timeDimensionTranscoding.Mapping = mapping; } return timeDimensionTranscoding; }
/// <summary> /// Create time dimension mapping without transcoding /// </summary> /// <param name="mapping"> /// The mapping entity<see cref="MappingEntity"/> of the Time Dimension component /// </param> /// <param name="databaseType"> /// The dissemination database vendor. Is needed to generate the correct SQL query where conditions /// </param> /// <exception cref="TranscodingException"> /// Incomplete Mapping. N column Time Dimension mapping without transcoding is not supported, where N not in 0,1 /// </exception> /// <returns> /// An Time Dimension Transcoding object<see cref="ITimeDimension"/> /// </returns> private static ITimeDimensionMapping CreateTimeDimensionMapping(MappingEntity mapping, string databaseType) { ITimeDimensionMapping timeDimensionTranscoding; switch (mapping.Columns.Count) { case 1: timeDimensionTranscoding = new TimeDimension1To1(mapping, null, databaseType); break; case 0: timeDimensionTranscoding = new TimeDimensionConstant(mapping, null, databaseType); break; default: throw new TranscodingException( string.Format( CultureInfo.CurrentCulture, ErrorMessages.TimeDimensionUnsupportedMappingFormat1, mapping.Columns.Count)); // MAT-496 } return timeDimensionTranscoding; }
/// <summary> /// Gets the name of the column. /// </summary> /// <param name="mapping">The mapping.</param> /// <param name="dateColumnSysId">The date column sys id.</param> /// <returns>The column name</returns> protected static string GetColumnName(MappingEntity mapping, long dateColumnSysId) { return mapping.Columns.First(entity => entity.SysId == dateColumnSysId).Name; }
/// <summary> /// Builds the component to Mapping dictionary. Before building it the methods make sure that the dictionary is empty /// </summary> private void BuildMappings() { // do some safety work bool measureDimensionMapped = false; IComponentMapping frequencyMapping = null; // fill the dictionaries and the fields foreach (MappingEntity mapping in this._mappingSet.Mappings) { if (this.IsTimeDimensionMapping(mapping)) { // find the mapping that contains the timedimension this._timeMapping = mapping; this._componentMapping.Add(mapping.Components[0], mapping); } else { foreach (ComponentEntity component in mapping.Components) { this._componentMapping.Add(component, mapping); IComponentMapping componentMapping = Sri.MappingStoreRetrieval.Engine.Mapping.ComponentMapping.CreateComponentMapping(component, mapping); //// TODO REMOVE this._componentMappingType.Add(component, componentMapping); this._componentIdMap.Add(component.Id, componentMapping); switch (component.ComponentType) { case SdmxComponentType.Dimension: if (component.MeasureDimension) { measureDimensionMapped = true; } if (component.FrequencyDimension) { frequencyMapping = componentMapping; } if (component.Id.Equals(this._dimensionAtObservation)) { this._dimensionAtObservationMapping = componentMapping; } break; case SdmxComponentType.CrossSectionalMeasure: this._xsMeasureMappings.Add(component.CrossSectionalMeasureCode, mapping); break; } } } } this._componentMappingList = new IComponentMapping[this._componentIdMap.Count]; this._componentIdMap.Values.CopyTo(this._componentMappingList, 0); if (this._timeMapping != null) { this._timeTranscoder = TimeDimensionMapping.Create(this._timeMapping, frequencyMapping, this._mappingSet.DataSet.Connection.DBType); } if (!measureDimensionMapped) { foreach (ComponentEntity component in this._mappingSet.Dataflow.Dsd.Dimensions) { if (component.MeasureDimension) { this.MeasureComponent = component; return; } } } }
/// <summary> /// Create time dimension mapping with transcoding /// </summary> /// <param name="mapping"> /// The mapping entity<see cref="MappingEntity"/> of the Time Dimension component /// </param> /// <param name="databaseType"> /// The dissemination database vendor. Is needed to generate the correct SQL query where conditions /// </param> /// <param name="timeTranscoding"> /// The Mapping Store <c>TIME_TRANSCODING</c> object /// </param> /// <exception cref="TranscodingException"> /// Incomplete/Invalid mapping or expression /// </exception> /// <returns> /// An Time Dimension Transcoding object<see cref="ITimeDimension"/> /// </returns> private static ITimeDimensionMapping CreateTranscodedTimeDimensionMapping(MappingEntity mapping, string databaseType, TimeTranscodingEntity timeTranscoding) { ITimeDimensionMapping timeDimensionTranscoding; TimeExpressionEntity expr = TimeExpressionEntity.CreateExpression(timeTranscoding); if (!expr.IsDateTime) { if (!expr.OneColumnMapping) { timeDimensionTranscoding = new TimeDimension2Column(mapping, expr, databaseType); } else { if (expr.YearLength != 4) { throw new TranscodingException(ErrorMessages.TimeDimensionYearNo4Digits); } if (expr.Freq != TimeFormatEnumType.Year) { if (expr.PeriodLength <= 0 && expr.YearStart > expr.PeriodStart) { throw new TranscodingException(ErrorMessages.TimeDimensionVariableLenPeriodNotFirst); } if (((expr.YearStart + expr.YearLength) > expr.PeriodStart && expr.YearStart < expr.PeriodStart) || ((expr.PeriodStart + expr.PeriodLength) > expr.YearStart && expr.YearStart > expr.PeriodStart) || expr.PeriodStart == expr.YearStart) { throw new TranscodingException(ErrorMessages.TimeDimensionYearPeriodOverlap); } } timeDimensionTranscoding = new TimeDimension1Column(mapping, expr, databaseType); } } else { timeDimensionTranscoding = new TimeDimensionDateType(mapping, expr, databaseType); } return timeDimensionTranscoding; }
/// <summary> /// Returns a value indicating whether the <paramref name="mapping"/> is for a TimeDimension /// </summary> /// <param name="mapping"> /// The <see cref="MappingEntity"/> to check /// </param> /// <returns> /// A value indicating whether the <paramref name="mapping"/> is for a TimeDimension /// </returns> private bool IsTimeDimensionMapping(MappingEntity mapping) { return this._mappingSet.Dataflow.Dsd.TimeDimension != null && mapping.Components.Count == 1 && mapping.Components[0].SysId == this._mappingSet.Dataflow.Dsd.TimeDimension.SysId; }
/// <summary> /// Create the IComponentMapping object for a specific component in a mapping depending on the type of mapping e.g. 1 /// DSD component - N local columns e.t.c. /// </summary> /// <param name="component"> /// The component entity /// </param> /// <param name="mapping"> /// The mapping entity /// </param> /// <returns> /// An IComponentMapping object based on the mapping or null if the mapping is not supported /// </returns> /// <exception cref="TranscodingException"> /// Invalid or unsupported mapping /// </exception> public static IComponentMapping CreateComponentMapping(ComponentEntity component, MappingEntity mapping) { IComponentMapping componentMapping; if (mapping.Components.Count == 1) { // one component switch (mapping.Columns.Count) { case 0: // no columns => constant mapping if (mapping.Constant != null) { componentMapping = new ComponentMapping1C(); } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoMappingFormat1, mapping.Components[0])); } break; case 1: // 1 to 1 mapping if (mapping.Transcoding != null) { // with transcoding if (mapping.Transcoding.TranscodingRules.ColumnAsKeyPosition.Count > 0 && mapping.Transcoding.TranscodingRules.ComponentAsKeyPosition.Count > 0) { componentMapping = new ComponentMapping1To1T(); } else { // transcoding enabled but no transcoding rules // TODO log a warning componentMapping = new ComponentMapping1To1(); // disable transcoding } } else { // without transcoding componentMapping = new ComponentMapping1To1(); } break; default: // N columns where N > 1 if (mapping.Transcoding != null) { // transcoding is mandatory if (mapping.Transcoding.TranscodingRules.ColumnAsKeyPosition.Count > 0 && mapping.Transcoding.TranscodingRules.ComponentAsKeyPosition.Count > 0) { // there are transcoding rules componentMapping = new ComponentMapping1N(); } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoTranscodingRulesFormat1, component.Id)); } } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoTranscodingFormat1, component.Id)); } break; } } else if (mapping.Columns.Count == 1 && mapping.Components.Count > 1) { // N components to 1 column mapping if (mapping.Transcoding != null) { // transcoding is mandatory if (mapping.Transcoding.TranscodingRules.ColumnAsKeyPosition.Count > 0 && mapping.Transcoding.TranscodingRules.ComponentAsKeyPosition.Count > 0) { // there are transcoding rules componentMapping = new ComponentMappingNto1(mapping.Transcoding.TranscodingRules.ComponentAsKeyPosition[component.SysId]); } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoTranscodingRulesFormat1, component.Id)); } } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNoTranscodingFormat1, component.Id)); } } else { throw new TranscodingException(string.Format(CultureInfo.CurrentCulture, ErrorMessages.ComponentMappingNNMapping, component.Id)); } componentMapping.Mapping = mapping; componentMapping.Component = component; return componentMapping; }