public override CodeSourceCollection CreateSources(string aFileName)
{
SIImage image = SIImage.New(base.Tracer, aFileName);
if (image == null)
{
throw new NotSupportedException("The specified image file is not supported");
}
// We need to make a source and (single) collection for each content object within the image.
// This enables relocation support when an image is actually used (i.e. read & decompress code
// on demand, rather than up front).
CodeSourceCollection sources = new CodeSourceCollection();
//
foreach (SIContent content in image)
{
CodeCollection collection = CodeCollection.New(base.IdAllocator, aFileName, content.FileName);
collection.IsRelocatable = content.IsRelocationSupported;
// The URI must be unique
string uri = string.Format("{0} [{1}]", aFileName, content.FileName);
ImgSource source = new ImgSource(uri, this, collection, content);
sources.Add(source);
}
//
return(sources);
}
public CodeCollectionViewModel(Boolean isInDesignMode)
{
this._model = new CodeCollection()
{
new Code()
{
Id = "default",
Title = "(Default)",
Description = new Lazy <String>(() => "Default empty code."),
OriginalBody = new Lazy <String>(() => ""),
Output = "YACQ Silverlight Runner (version " + YacqServices.Version + ")",
}
};
this._model.ForEach(c => this.Add(new CodeViewModel(c)));
this._model.CollectionChanged += (s, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
if (!isInDesignMode)
{
DispatcherHelper.UIDispatcher.BeginInvoke(() =>
this.Add(new CodeViewModel(e.NewItems.OfType <Code>().Single()))
);
}
break;
}
};
this.Fetch = new RelayCommand(() => this._model.Fetch(), () => true);
}
internal CodeSourceAndCollection(CodeSource aSource, CodeCollection aCollection)
{
System.Diagnostics.Debug.Assert(aSource != null && aCollection != null);
//
iSource = aSource;
iCollection = aCollection;
}
public ImgSource(string aURI, CodeSourceProvider aProvider, CodeCollection aCollection, SIContent aImageContent)
: base(aURI, aProvider)
{
iImageContent = aImageContent;
// Make sure we receive any requests from the collection object for code.
aCollection.IfaceInstructionConverter = this;
aCollection.IsRelocatable = aImageContent.IsRelocationSupported;
// XIP content should be read during priming.
TTimeToRead timeToRead = TTimeToRead.EReadWhenPriming;
if (aImageContent.IsRelocationSupported)
{
timeToRead = TTimeToRead.EReadWhenNeeded;
}
else
{
// If the image is fixed, then so is the collection base address
aCollection.Relocate(aImageContent.RelocationAddress);
}
// Must add the collection *after* setting it's properties
base.TimeToRead = timeToRead;
base.Add(aCollection);
}
/// <summary>
/// Build where clauses in the form of : (year and (periodA or periodB or ... ) and write them
/// to a specified StringBuilder
/// </summary>
/// <param name="ret">The StringBuilder to write the output</param>
/// <param name="yearStr">The year string</param>
/// <param name="firstPeriod">The first period</param>
/// <param name="lastPeriod">The last period</param>
/// <param name="periodicity">The periodicity.</param>
/// <param name="timeExpressionEntity">The time expression entity.</param>
/// <returns>
/// The position of the last clause inside the StringBuilder
/// </returns>
private int BuildPeriodWhere(StringBuilder ret, string yearStr, int firstPeriod, int lastPeriod, IPeriodicity periodicity, TimeExpressionEntity timeExpressionEntity)
{
var queryCode = new CodeCollection();
ret.Append("( ");
ret.AppendFormat(this._yearOnlyWhereFormat, yearStr);
int lastClause = ret.Length;
ret.Append(" and ");
ret.Append("( ");
for (int x = firstPeriod; x <= lastPeriod; x++)
{
string periodStr = x.ToString(periodicity.Format, _formatProvider);
queryCode.Clear();
queryCode.Add(periodStr);
string periodCode = timeExpressionEntity.TranscodingRules.GetLocalCodes(queryCode)[0][0];
ret.AppendFormat(CultureInfo.InvariantCulture, this._whereFormat, periodCode);
lastClause = ret.Length;
ret.Append(" or ");
}
ret.Length = lastClause;
ret.Append(") ");
ret.Append(") ");
lastClause = ret.Length;
ret.Append(" or ");
return(lastClause);
}
/// <summary>
/// Transcodes the time period returned by the local database to SDMX Time period
/// </summary>
/// <param name="reader">
/// The data reader reading the Dissemination database
/// </param>
/// <returns>
/// The transcoded time period, as in SDMX Time period type
/// </returns>
public string MapComponent(IDataReader reader)
{
string ret;
this._fieldOrdinals.BuildOrdinal(reader);
string yearperiod = DataReaderHelper.GetString(reader, this._fieldOrdinals.YearOrdinal);
if (this.Expression.YearStart + this.Expression.YearLength > yearperiod.Length)
{
return(null);
}
string year = yearperiod.Substring(this.Expression.YearStart, this.Expression.YearLength);
var rowFreq = this.Expression.Freq;
if (rowFreq != TimeFormatEnumType.Year)
{
if (this.Expression.PeriodStart >= yearperiod.Length)
{
return(null);
}
string period;
if (this.Expression.PeriodLength > 0)
{
int rowPeriodLen = this.Expression.PeriodLength;
if (this.Expression.PeriodLength + this.Expression.PeriodStart > yearperiod.Length)
{
rowPeriodLen = yearperiod.Length - this.Expression.PeriodStart;
}
period = yearperiod.Substring(this.Expression.PeriodStart, rowPeriodLen);
}
else
{
period = yearperiod.Substring(this.Expression.PeriodStart);
}
this._periodLocalCode.Clear();
this._periodLocalCode.Add(period);
CodeCollection periodDsdCode =
this.Expression.TranscodingRules.GetDsdCodes(this._periodLocalCode);
if (periodDsdCode == null)
{
return(null); // MAT-495
// periodDsdCode = periodLocalCode;
}
ret = string.Format(CultureInfo.InvariantCulture, "{0}-{1}", year, periodDsdCode[0]);
}
else
{
ret = year.ToString(FormatProvider);
}
return(ret);
}
public ActionResult Save(Bam.Net.Presentation.Unicode.Code[] values)
{
try
{
CodeCollection saver = new CodeCollection();
saver.AddRange(values);
saver.Save();
return(Json(new { Success = true, Message = "", Dao = "" }));
}
catch (Exception ex)
{
return(GetErrorResult(ex));
}
}
public CodeCollection Activate(CodeSegDefinition aCodeSegment)
{
CodeCollection ret = null;
// Find the corresponding Code seg
CodeSourceAndCollection pair = SourceManager[aCodeSegment];
if (pair != null)
{
CodeCollection col = pair.Collection;
if (col.IsFixed)
{
// Cannot activate a fixed Code segment - TODO: should this return "true", i.e. already activated?
}
else
{
bool safe = CheckSafeToActivate(aCodeSegment);
if (safe)
{
// Deep copy the collection
CodeCollection dupe = CodeCollection.NewCopy(iPlugin.ProvisioningManager.IdAllocator, col);
// Set new process-specific relocated base address. This causes the underlying code to be
// decompressed/read if not already done so.
dupe.Relocate(aCodeSegment.Base);
// At this point, the code owned by 'col' will have definitely been read (if available)
// and that means col.IsCodeAvailable is probably true. However, dupe.IsCodeAvailable
// is almost certainly false so we may need to copy the code over...
if (dupe.IsCodeAvailable == false && col.IsCodeAvailable == true)
{
dupe.Code = col.Code;
}
System.Diagnostics.Debug.Assert(dupe.IsCodeAvailable == col.IsCodeAvailable);
// Save so that we can unload it later
pair = new CodeSourceAndCollection(pair, dupe);
AddToActivationList(pair, aCodeSegment);
// We managed to activate a binary, so return the collection
ret = dupe;
iPlugin.Trace("[C] ACTIVATE - {0}", aCodeSegment);
}
}
}
//
return(ret);
}
/// <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="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);
}
public CodeSourceAndCollection this[CodeSegDefinition aCodeSeg]
{
get
{
CodeSourceAndCollection ret = null;
//
foreach (CodeSource source in this)
{
CodeCollection col = source[aCodeSeg];
if (col != null)
{
ret = new CodeSourceAndCollection(source, col);
break;
}
}
//
return(ret);
}
}
/// <summary>
/// Maps the column of the mapping to the components of this <see cref="ComponentMappingNto1"/> object and transcodes it.
/// </summary>
/// <param name="reader">
/// The DataReader for retrieving the values of the column.
/// </param>
/// <returns>
/// The value of the component or null if no transcoding rule for the column values is found
/// </returns>
public string MapComponent(IDataReader reader)
{
string ret = null;
this.BuildOrdinals(reader);
ColumnOrdinal column = this.ColumnOrdinals[0];
var resultCodes = new CodeCollection {
DataReaderHelper.GetString(reader, column.Value)
};
CodeCollection transcodedCodes = this.Mapping.Transcoding.TranscodingRules.GetDsdCodes(resultCodes);
if (transcodedCodes != null && this._componentIndex < transcodedCodes.Count)
{
ret = transcodedCodes[this._componentIndex];
}
return(ret);
}
/// <summary>
/// Maps the column of the mapping to the component of this ComponentMapping1to1T object
/// and transcodes it.
/// </summary>
/// <param name="reader">
/// The DataReader for retrieving the values of the column.
/// </param>
/// <returns>
/// The value of the component or null if no transcoding rule for the column values is found
/// </returns>
public string MapComponent(IDataReader reader)
{
var resultCodes = new CodeCollection();
this.BuildOrdinals(reader);
var column = this.ColumnOrdinals[0];
string columnValue = DataReaderHelper.GetString(reader, column.Value);
resultCodes.Add(columnValue);
Collection <string> transcodedCodes = this.Mapping.Transcoding.TranscodingRules.GetDsdCodes(resultCodes);
string ret = null;
if (transcodedCodes != null && transcodedCodes.Count > 0)
{
ret = transcodedCodes[0];
}
return(ret);
}
/// <summary>
/// Transcodes the time period returned by the local database to SDMX Time period
/// </summary>
/// <param name="reader">
/// The data reader reading the Dissemination database
/// </param>
/// <returns>
/// The transcoded time period, as in SDMX Time period type
/// </returns>
public string MapComponent(IDataReader reader)
{
this._fieldOrdinals.BuildOrdinal(reader);
string year = DataReaderHelper.GetString(reader, this._fieldOrdinals.YearOrdinal);
if (this.Expression.YearLength > 0)
{
year = year.Substring(this.Expression.YearStart, this.Expression.YearLength);
}
string period = DataReaderHelper.GetString(reader, this._fieldOrdinals.PeriodOrdinal);
if (this.Expression.PeriodLength > 0)
{
int rowPeriodLen = this.Expression.PeriodLength;
if (this.Expression.PeriodLength + this.Expression.PeriodStart > period.Length)
{
rowPeriodLen = period.Length - this.Expression.PeriodStart;
}
period = period.Substring(this.Expression.PeriodStart, rowPeriodLen);
}
this._periodLocalCode.Clear();
this._periodLocalCode.Add(period);
CodeCollection periodDsdCode = this.Expression.TranscodingRules.GetDsdCodes(this._periodLocalCode);
if (periodDsdCode == null)
{
return(null); // MAT-495
// periodDsdCode = periodLocalCode;
}
string ret = string.Format(CultureInfo.InvariantCulture, "{0}-{1}", year, periodDsdCode[0]);
// ret = _timePeriodTranscoding[String.Format(CultureInfo.InvariantCulture,"{0}-{1}", year, period)];
return(ret);
}
protected override void OnReadComplete()
{
try
{
base.OnReadComplete();
}
finally
{
System.Diagnostics.Debug.Assert(base.Count == 1);
CodeCollection col = this[0];
bool codeAvailable = col.IsCodeAvailable;
//
if (iImageContent != null && codeAvailable == false)
{
// Update the underlying collection with it.
col.Code = iImageContent.GetAllData();
// Don't need this anymore
iImageContent.Dispose();
iImageContent = null;
}
}
}
/// <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>
/// 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>
/// Maps the column of the mapping to the components of this <see cref="ComponentMappingNto1"/> object and transcodes it.
/// </summary>
/// <param name="reader">
/// The DataReader for retrieving the values of the column.
/// </param>
/// <returns>
/// The value of the component or null if no transcoding rule for the column values is found
/// </returns>
public string MapComponent(IDataReader reader)
{
string ret = null;
this.BuildOrdinals(reader);
ColumnOrdinal column = this.ColumnOrdinals[0];
var resultCodes = new CodeCollection { DataReaderHelper.GetString(reader, column.Value) };
CodeCollection transcodedCodes = this.Mapping.Transcoding.TranscodingRules.GetDsdCodes(resultCodes);
if (transcodedCodes != null && this._componentIndex < transcodedCodes.Count)
{
ret = transcodedCodes[this._componentIndex];
}
return ret;
}
/// <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>
/// 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>
/// Maps the column of the mapping to the component of this ComponentMapping1to1T object
/// and transcodes it.
/// </summary>
/// <param name="reader">
/// The DataReader for retrieving the values of the column.
/// </param>
/// <returns>
/// The value of the component or null if no transcoding rule for the column values is found
/// </returns>
public string MapComponent(IDataReader reader)
{
var resultCodes = new CodeCollection();
this.BuildOrdinals(reader);
var column = this.ColumnOrdinals[0];
string columnValue = DataReaderHelper.GetString(reader, column.Value);
resultCodes.Add(columnValue);
Collection<string> transcodedCodes = this.Mapping.Transcoding.TranscodingRules.GetDsdCodes(resultCodes);
string ret = null;
if (transcodedCodes != null && transcodedCodes.Count > 0)
{
ret = transcodedCodes[0];
}
return ret;
}
public override CodeCollection ActivateAndGetCollection(CodeSegDefinition aCodeSegment)
{
CodeCollection ret = iRelocator.Activate(aCodeSegment);
return(ret);
}
internal CodeSourceAndCollection(CodeSourceAndCollection aCopy, CodeCollection aCollection)
{
iSource = aCopy.Source;
iCollection = aCollection;
}
/// <summary>
/// Build where clauses in the form of : (year and (periodA or periodB or ... ) and write them
/// to a specified StringBuilder
/// </summary>
/// <param name="ret">The StringBuilder to write the output</param>
/// <param name="yearStr">The year string</param>
/// <param name="firstPeriod">The first period</param>
/// <param name="lastPeriod">The last period</param>
/// <param name="periodicity">The periodicity.</param>
/// <param name="timeExpressionEntity">The time expression entity.</param>
/// <returns>
/// The position of the last clause inside the StringBuilder
/// </returns>
private int BuildPeriodWhere(StringBuilder ret, string yearStr, int firstPeriod, int lastPeriod, IPeriodicity periodicity, TimeExpressionEntity timeExpressionEntity)
{
var queryCode = new CodeCollection();
ret.Append("( ");
ret.AppendFormat(this._yearOnlyWhereFormat, yearStr);
int lastClause = ret.Length;
ret.Append(" and ");
ret.Append("( ");
for (int x = firstPeriod; x <= lastPeriod; x++)
{
string periodStr = x.ToString(periodicity.Format, _formatProvider);
queryCode.Clear();
queryCode.Add(periodStr);
string periodCode = timeExpressionEntity.TranscodingRules.GetLocalCodes(queryCode)[0][0];
ret.AppendFormat(CultureInfo.InvariantCulture, this._whereFormat, periodCode);
lastClause = ret.Length;
ret.Append(" or ");
}
ret.Length = lastClause;
ret.Append(") ");
ret.Append(") ");
lastClause = ret.Length;
ret.Append(" or ");
return lastClause;
}
