/// <summary>
/// Initializes a new instance of the <see cref="DataRetrievalInfoTabular"/> class.
/// </summary>
/// <param name="mappingSet">
/// The mapping set of the dataflow found in the sdmx query
/// </param>
/// <param name="query">
/// The current SDMX Query object
/// </param>
/// <param name="connectionStringSettings">
/// The Mapping Store connection string settings
/// </param>
/// <param name="complexWriter">
/// The tabular Writer.
/// </param>
public DataRetrievalInfoComplex(
MappingSetEntity mappingSet,
IComplexDataQuery query,
ConnectionStringSettings connectionStringSettings,
IDataWriterEngine complexWriter)
: base(mappingSet, query, connectionStringSettings, complexWriter)
{
this.Limit = query.DefaultLimit.HasValue ? query.DefaultLimit.Value : 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRetrievalInfoTabular"/> class.
/// </summary>
/// <param name="mappingSet">
/// The mapping set of the dataflow found in the sdmx query
/// </param>
/// <param name="query">
/// The current SDMX Query object
/// </param>
/// <param name="connectionStringSettings">
/// The Mapping Store connection string settings
/// </param>
/// <param name="tabularWriter">
/// The tabular Writer.
/// </param>
public DataRetrievalInfoTabular(
MappingSetEntity mappingSet,
IComplexDataQuery query,
ConnectionStringSettings connectionStringSettings,
ITabularWriter tabularWriter)
: base(mappingSet, query, connectionStringSettings)
{
this._tabularWriter = tabularWriter;
}
public XDocument BuildComplexDataQuery(IComplexDataQuery complexDataQuery, IDataQueryFormat<XDocument> dataQueryFormat)
{
IComplexDataQueryBuilder builder = _factory.GetComplexDataQueryBuilder(dataQueryFormat);
if (builder != null)
{
return builder.BuildComplexDataQuery(complexDataQuery);
}
throw new SdmxUnauthorisedException("Unsupported ComplexDataQueryFormat: " + dataQueryFormat);
}
/// <summary>
/// Sends the SDMX Query Request
/// </summary>
/// <param name="query">
/// The SDMX Query
/// </param>
/// <param name="operation">
/// The Web Service function
/// </param>
/// <param name="output">
/// The output stream
/// </param>
private void SendSdmxQuery(IDataQuery query, SDMXWSFunctionV21 operation, string tempFileName)
{
IDataQueryFormat <XDocument> queryFormat = new StructSpecificDataFormatV21();
IBuilder <IComplexDataQuery, IDataQuery> transformer = new DataQuery2ComplexQueryBuilder(true);
IComplexDataQuery complexDataQuery = transformer.Build(query);
IComplexDataQueryBuilderManager complexDataQueryBuilderManager = new ComplexDataQueryBuilderManager(new ComplexDataQueryFactoryV21());
var xdoc = complexDataQueryBuilderManager.BuildComplexDataQuery(complexDataQuery, queryFormat);
var doc = new XmlDocument();
doc.LoadXml(xdoc.ToString());
this.SendRequest(doc, operation, tempFileName);
}
/// <summary>
/// Synchronously execute the given query expected to return 0 or 1 items.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public T ExecuteSingleQuery <T>(IComplexDataQuery <T> query)
{
using (var cn = new SqlConnection(this.connectionString))
{
var cmd = query.ConstructCommand(cn);
cn.Open();
using (SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection | query.GetCustomCommandBehaviors(cn, cmd)))
{
T row = query.Retrieve(cmd, dr);
return(row);
}
}
}
public XDocument BuildComplexDataQuery(IComplexDataQuery query)
{
var queryMessageType = new DataQueryType();
queryMessageType.Header = new BasicHeaderType();
V21Helper.SetHeader(queryMessageType.Header, null);
var queryType = new Org.Sdmx.Resources.SdmxMl.Schemas.V21.Query.DataQueryType();
var coreBuilder = new ComplexDataQueryCoreBuilderV21();
coreBuilder.FillDataQueryType(queryType, query);
queryMessageType.BaseDataQueryType = queryType;
var queryMessageDocument = new StructureSpecificDataQuery(queryMessageType);
return new XDocument(queryMessageDocument.Untyped);
}
public XDocument BuildComplexDataQuery(IComplexDataQuery query)
{
var queryMessageDocument = new GenericTimeSeriesDataQuery(new GenericTimeSeriesDataQueryType());
queryMessageDocument.Content.Header = new BasicHeaderType();
V21Helper.SetHeader(queryMessageDocument.Content.Header, null);
var queryType = new DataQueryType();
var coreBuilder = new ComplexDataQueryCoreBuilderV21();
coreBuilder.FillDataQueryType(queryType, query);
queryMessageDocument.Content.BaseDataQueryType = queryType;
var xDocument = new XDocument(queryMessageDocument.Untyped);
return xDocument;
}
/// <summary>
/// Asynchronously execute the given query expected to return 0 or 1 items.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="factory"></param>
/// <returns></returns>
public async Task <T> ExecuteSingleQueryAsync <T>(IComplexDataQuery <T> query, TaskFactory <T> factory = null)
{
if (factory == null)
{
factory = new TaskFactory <T>();
}
using (var cn = new SqlConnection(this.connectionString))
{
var cmd = query.ConstructCommand(cn);
cn.Open();
using (SqlDataReader dr = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection | query.GetCustomCommandBehaviors(cn, cmd)))
{
T row = await query.RetrieveAsync(cmd, dr);
return(row);
}
}
}
/// <summary>
/// Asynchronously execute the given query expected to return 0 or more rows.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="expectedCapacity"></param>
/// <param name="factory"></param>
/// <returns></returns>
public async Task <T> ExecuteListQueryAsync <T>(IComplexDataQuery <T> query, int expectedCapacity = 10, TaskFactory <T> factory = null)
{
if (expectedCapacity < 0)
{
expectedCapacity = 0;
}
if (factory == null)
{
factory = new TaskFactory <T>();
}
using (var cn = new SqlConnection(this.connectionString))
{
var cmd = query.ConstructCommand(cn);
cn.Open();
using (SqlDataReader dr = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection | query.GetCustomCommandBehaviors(cn, cmd)))
{
return(await query.RetrieveAsync(cmd, dr, expectedCapacity));
}
}
}
/// <summary>
/// Handles the explicit.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="structure">The structure.</param>
private static void HandleExplicit(IComplexDataQuery complexDataQuery, DataStructureRequestType structure)
{
if (complexDataQuery.HasExplicitMeasures())
{
structure.explicitMeasures = complexDataQuery.HasExplicitMeasures();
}
}
/// <summary>
/// Handles the selection groups.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
private static void HandleSelectionGroups(IComplexDataQuery complexDataQuery, DataParametersAndType whereType)
{
// TODO support for multiple selection groups.
IComplexDataQuerySelectionGroup complexDataQuerySelectionGroup = complexDataQuery.SelectionGroups.First();
//Selections in SelectionGroups - at DataWhere Level
if (complexDataQuerySelectionGroup.Selections != null)
{
HandleSelections(complexDataQuery, whereType, complexDataQuerySelectionGroup.Selections.Where(selection => selection.ShouldUseAnd()), new ParameterBuilderAnd());
}
//Time Dimension clause at DataWhere Level for Date From/To - optional
if (complexDataQuerySelectionGroup.DateFrom != null || complexDataQuerySelectionGroup.DateTo != null)
{
HandleTime(whereType, complexDataQuerySelectionGroup);
}
//Primary Measure Value at DataWhere Level - Zero to more repetitions
if (complexDataQuerySelectionGroup.PrimaryMeasureValue != null)
{
HandlePrimaryMeasure(whereType, complexDataQuerySelectionGroup, complexDataQuery);
}
//Selections in SelectionGroups - OR clauses at DataWhere Level
if (complexDataQuerySelectionGroup.Selections != null)
{
HandleSelections(complexDataQuery, whereType, complexDataQuerySelectionGroup.Selections.Where(selection => !selection.ShouldUseAnd()), new ParameterBuilderOr());
}
}
/// <summary>
/// Handles the primary measure.
/// </summary>
/// <param name="whereType">Type of the where.</param>
/// <param name="complexDataQuerySelectionGroup">The complex data query selection group.</param>
/// <param name="complexDataQuery">The complex data query.</param>
private static void HandlePrimaryMeasure(DataParametersType whereType, IComplexDataQuerySelectionGroup complexDataQuerySelectionGroup, IComplexDataQuery complexDataQuery)
{
var primaryMeasure = complexDataQuery.DataStructure.PrimaryMeasure;
foreach (IComplexComponentValue primaryMeasureValue in complexDataQuerySelectionGroup.PrimaryMeasureValue)
{
var primaryMeasureValueType = new PrimaryMeasureValueType();
SetOperatorAndValue(primaryMeasure, primaryMeasureValue, primaryMeasureValueType);
whereType.PrimaryMeasureValue.Add(primaryMeasureValueType);
}
}
/// <summary>
/// Handles the selections.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
/// <param name="complexDataQuerySelections"></param>
/// <exception cref="Org.Sdmxsource.Sdmx.Api.Exception.SdmxSemmanticException">
/// Invalid structure type for component and
/// </exception>
private static void HandleSelections(IComplexDataQuery complexDataQuery, DataParametersAndType whereType, IEnumerable<IComplexDataQuerySelection> complexDataQuerySelections, IParameterBuilder builder)
{
foreach (IComplexDataQuerySelection complexDataQuerySelection in complexDataQuerySelections)
{
builder.Reset();
// Dimension Values inside an OR -or- AND clause
foreach (IComplexComponentValue complexComponentValue in complexDataQuerySelection.Values)
{
var component = complexDataQuery.DataStructure.GetComponent(complexDataQuerySelection.ComponentId);
if (component == null)
{
throw new SdmxSemmanticException(string.Format("Component with ID {0} does not exist in the DSD {1}", complexDataQuerySelection.ComponentId, complexDataQuery.DataStructure));
}
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
case SdmxStructureEnumType.MeasureDimension:
{
var dimensionValueType = new DimensionValueType { ID = complexDataQuerySelection.ComponentId };
SetOperatorAndValue(component, complexComponentValue, dimensionValueType);
builder.AddDimension(dimensionValueType);
}
break;
case SdmxStructureEnumType.DataAttribute:
{
var attributeValueType = new AttributeValueType { ID = complexDataQuerySelection.ComponentId };
SetOperatorAndValue(component, complexComponentValue, attributeValueType);
builder.AddAttribute(attributeValueType);
}
break;
default:
throw new SdmxSemmanticException(string.Format("Invalid structure type for component ID : {1} Type {0} ", component.StructureType.EnumType, component.Urn));
}
}
builder.PopulateAndParameter(whereType);
}
}
/// <summary>
/// Handles the last updated time.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
private static void HandleLastUpdatedTime(IComplexDataQuery complexDataQuery, DataParametersType whereType)
{
foreach (var timeRange in complexDataQuery.LastUpdatedDateTimeRange)
{
var timeRangeValueType = new TimeRangeValueType();
var startTimePeriodRangeType = new TimePeriodRangeType();
startTimePeriodRangeType.isInclusive = timeRange.IsStartInclusive;
startTimePeriodRangeType.TypedValue = timeRange.StartDate.DateInSdmxFormat;
timeRangeValueType.StartPeriod = startTimePeriodRangeType;
var endTimePeriodRangeType = new TimePeriodRangeType();
endTimePeriodRangeType.isInclusive = timeRange.IsEndInclusive;
endTimePeriodRangeType.TypedValue = timeRange.StartDate.DateInSdmxFormat;
timeRangeValueType.EndPeriod = endTimePeriodRangeType;
whereType.Updated.Add(timeRangeValueType);
}
}
/// <summary>
/// Generates the response function.
/// </summary>
/// <param name="query">
/// The query.
/// </param>
/// <returns>
/// The <see cref="Action"/> that will write the response.
/// </returns>
public Action <T, Queue <Action> > GenerateResponseFunction(IComplexDataQuery query)
{
return((writer, actions) => this._sdmxDataRetrievalWithWriter.GetData(query, this._dataWriterBuilder.Build(writer, actions)));
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRetrievalInfo"/> class.
/// </summary>
/// <param name="mappingSet">
/// The mapping set of the dataflow found in the SDMX query
/// </param>
/// <param name="query">
/// The current SDMX Query object
/// </param>
/// <param name="connectionStringSettings">
/// The Mapping Store connection string settings
/// </param>
public DataRetrievalInfo(MappingSetEntity mappingSet, IComplexDataQuery query, ConnectionStringSettings connectionStringSettings)
{
if (mappingSet == null)
{
throw new ArgumentNullException("mappingSet");
}
if (connectionStringSettings == null)
{
throw new ArgumentNullException("connectionStringSettings");
}
this._schemaVersion = SdmxSchemaEnumType.VersionTwoPointOne;
this._mappingSet = mappingSet;
this._complexQuery = query;
this._connectionStringSettings = connectionStringSettings;
this._limit = query.DefaultLimit.HasValue ? query.DefaultLimit.Value : 0;
this._isTimePeriodAtObservation = DimensionObject.TimeDimensionFixedId.Equals(query.DimensionAtObservation);
if (!this._isTimePeriodAtObservation)
{
this._dimensionAtObservation = query.DimensionAtObservation;
}
this.BuildMappings();
this._buildEffectiveDimensionAtObservation = this.BuildEffectiveDimensionAtObservation();
}
public string GenerateSqlQuery(IComplexDataQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
try
{
// Get mapping set
MappingSetEntity mappingSet = this.InitializeAdvanced(query);
// build the data retrieval state
var info = new DataRetrievalInfo(mappingSet, query, this._connectionStringSettings);
// Generate sql using Tabular SQL Builder and put the sql query into info.SqlString
//this.GenerateSql(info, _sqlBuilderTabular);
// return the sql query
return info.SqlString;
}
catch (DataRetrieverException)
{
throw;
}
catch (Exception ex)
{
throw new DataRetrieverException(ex,
SdmxErrorCode.GetFromEnum(SdmxErrorCodeEnumType.SemanticError),
Resources.DataRetriever_GenerateSqlQuery_Could_not_generate_sql_query);
}
}
/// <summary>
/// Handles the structure request type
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="dataReturnDetails">The data return details.</param>
private static void HandleStructure(IComplexDataQuery complexDataQuery, DataReturnDetailsType dataReturnDetails)
{
var structure = new DataStructureRequestType();
dataReturnDetails.Structure.Add(structure);
if (!string.IsNullOrWhiteSpace(complexDataQuery.DimensionAtObservation))
{
structure.dimensionAtObservation = complexDataQuery.DimensionAtObservation;
}
else
{
structure.dimensionAtObservation = DimensionObject.TimeDimensionFixedId;
}
HandleExplicit(complexDataQuery, structure);
structure.structureID = DefaultStructureId;
if (complexDataQuery.DataStructure != null)
{
RefBaseType structureRefernce = new StructureRefType();
structureRefernce.agencyID = complexDataQuery.DataStructure.AgencyId;
structureRefernce.id = complexDataQuery.DataStructure.Id;
structureRefernce.version = complexDataQuery.DataStructure.Version;
var structureType = new StructureReferenceType();
structureType.SetTypedRef(structureRefernce);
structure.Structure = structureType;
}
else if (complexDataQuery.ProvisionAgreement != null)
{
RefBaseType provisionAgreementReference = new ProvisionAgreementRefType();
provisionAgreementReference.id = complexDataQuery.ProvisionAgreement.Id;
provisionAgreementReference.agencyID = complexDataQuery.ProvisionAgreement.AgencyId;
provisionAgreementReference.version = complexDataQuery.ProvisionAgreement.Version;
var provisionAgreementReferenceType = new ProvisionAgreementReferenceType();
provisionAgreementReferenceType.SetTypedRef(provisionAgreementReference);
structure.ProvisionAgrement = provisionAgreementReferenceType;
}
}
/// <summary>
/// Handles the data provider.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
private static void HandleDataProvider(IComplexDataQuery complexDataQuery, DataParametersAndType whereType)
{
//if only one Data provider let alone otherwise encapsulate it in an Or clause
if (complexDataQuery.DataProvider.Count == 1)
{
IDataProvider dataProvider = complexDataQuery.DataProvider.First();
var dataProviderReferenceType = new DataProviderReferenceType();
RefBaseType dataProviderRefType = new DataProviderRefType();
dataProviderRefType.agencyID = dataProvider.CrossReferences.First().MaintainableReference.AgencyId;
dataProviderRefType.id = dataProvider.Id;
dataProviderRefType.maintainableParentID = dataProvider.MaintainableParent.Id;
dataProviderRefType.maintainableParentVersion = dataProvider.MaintainableParent.Version;
dataProviderReferenceType.Ref = dataProviderRefType;
whereType.DataProvider.Add(dataProviderReferenceType);
}
else
{
var orForDataProviderType = new DataParametersOrType();
foreach (IDataProvider dataProvider in complexDataQuery.DataProvider)
{
RefBaseType dataProviderRefType = new DataProviderRefType();
dataProviderRefType.agencyID = dataProvider.CrossReferences.First().MaintainableReference.AgencyId;
dataProviderRefType.id = dataProvider.Id;
dataProviderRefType.maintainableParentID = dataProvider.MaintainableParent.Id;
dataProviderRefType.maintainableParentVersion = dataProvider.MaintainableParent.Version;
var dataProviderReferenceType = new DataProviderReferenceType { Ref = dataProviderRefType };
orForDataProviderType.DataProvider.Add(dataProviderReferenceType);
}
whereType.Or.Add(orForDataProviderType);
}
}
/// <summary>
/// Handles the dataflow.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
private static void HandleDataflow(IComplexDataQuery complexDataQuery, DataParametersAndType whereType)
{
var dataflowReferenceType = new DataflowReferenceType();
RefBaseType dataflowRefType = new DataflowRefType();
dataflowRefType.agencyID = complexDataQuery.Dataflow.AgencyId;
dataflowRefType.id = complexDataQuery.Dataflow.Id;
dataflowRefType.version = complexDataQuery.Dataflow.Version;
dataflowReferenceType.Ref = dataflowRefType;
whereType.Dataflow.Add(dataflowReferenceType);
}
/// <summary>
/// Handles the provision agreement.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
private static void HandleProvisionAgreement(IComplexDataQuery complexDataQuery, DataParametersAndType whereType)
{
RefBaseType provisionReferenceType = new ProvisionAgreementRefType();
provisionReferenceType.id = complexDataQuery.ProvisionAgreement.Id;
provisionReferenceType.agencyID = complexDataQuery.ProvisionAgreement.AgencyId;
provisionReferenceType.version = complexDataQuery.ProvisionAgreement.Version;
var provisionAgreementReferenceType = new ProvisionAgreementReferenceType { Ref = provisionReferenceType };
whereType.ProvisionAgreement.Add(provisionAgreementReferenceType);
}
private MappingSetEntity InitializeAdvanced(IComplexDataQuery query)
{
Logger.Info(Resources.DataRetriever_RetrieveData_Start_Initializing_Data_Retriever);
if (query == null)
{
throw new ArgumentNullException("query");
}
// Get the dataflow from the query
IDataflowObject dataFlow = query.Dataflow;
// get the mapping set and the keyfamilybean
MappingSetEntity mappingSet = this.RetrieveMappingSet(dataFlow);
// MAT-395
if (mappingSet == null)
{
throw new DataRetrieverException(string.Format(CultureInfo.CurrentCulture, Resources.NoMappingForDataflowFormat1, dataFlow.Id),
SdmxErrorCode.GetFromEnum(SdmxErrorCodeEnumType.NoResultsFound));
}
//mappingSet = FilterMappingSet(query, mappingSet);
Logger.Info(Resources.DataRetriever_RetrieveData_End_Data_Retriever_initialization);
return mappingSet;
}
/// <summary>
/// Fills the type of the data query.
/// </summary>
/// <param name="queryType">Type of the query.</param>
/// <param name="complexDataQuery">The complex data query.</param>
/// <exception cref="Org.Sdmxsource.Sdmx.Api.Exception.SdmxException">Too many Selection Groups in ComplexDataQuery max one supported.</exception>
public void FillDataQueryType(DataQueryType queryType, IComplexDataQuery complexDataQuery)
{
var dataReturnDetailsType = new DataReturnDetailsType();
queryType.ReturnDetails = dataReturnDetailsType;
// TODO: check null in java
if (complexDataQuery.DefaultLimit.HasValue && complexDataQuery.DefaultLimit.Value != 0)
{
dataReturnDetailsType.defaultLimit = complexDataQuery.DefaultLimit;
}
if (complexDataQuery.FirstNObservations.HasValue)
{
dataReturnDetailsType.FirstNObservations = complexDataQuery.FirstNObservations;
}
if (complexDataQuery.LastNObservations.HasValue)
{
dataReturnDetailsType.LastNObservations = complexDataQuery.LastNObservations;
}
if (complexDataQuery.DataQueryDetail != null)
{
dataReturnDetailsType.detail = complexDataQuery.DataQueryDetail.EnumType.ToString();
}
if (complexDataQuery.ObservationAction != null)
{
dataReturnDetailsType.observationAction = complexDataQuery.ObservationAction.EnumType.ToString();
}
HandleStructure(complexDataQuery, dataReturnDetailsType);
var whereType = new DataParametersAndType();
queryType.DataWhere = whereType;
//DataSetId at DataWhere Leveln - Optional
if (complexDataQuery.DatasetId != null)
{
var datasetIdType = new QueryIDType { TypedValue = complexDataQuery.DatasetId, @operator = complexDataQuery.DatasetIdOperator.Operator };
whereType.DataSetID.Add(datasetIdType);
}
//DataProvider at DataWhere Level - Optional;
if (complexDataQuery.DataProvider != null && complexDataQuery.DataProvider.Count != 0)
{
HandleDataProvider(complexDataQuery, whereType);
}
//Dataflow at DataWhere Level - Optional
if (complexDataQuery.Dataflow != null)
{
HandleDataflow(complexDataQuery, whereType);
}
//ProvisionAgreement at DataWhere Level - Optional
if (complexDataQuery.ProvisionAgreement != null)
{
HandleProvisionAgreement(complexDataQuery, whereType);
}
//Updated tag that can have 0 to 2 repetitions
if (complexDataQuery.LastUpdatedDateTimeRange != null)
{
HandleLastUpdatedTime(complexDataQuery, whereType);
}
//Selection Groups - and clause (DataWhere)
if (complexDataQuery.SelectionGroups != null && complexDataQuery.SelectionGroups.Count > 1)
{
throw new SdmxException("Too many Selection Groups in ComplexDataQuery max one supported.", SdmxErrorCode.GetFromEnum(SdmxErrorCodeEnumType.SemanticError));
}
if (complexDataQuery.SelectionGroups != null && complexDataQuery.SelectionGroups.Count != 0)
{
HandleSelectionGroups(complexDataQuery, whereType);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRetrievalInfo"/> class.
/// </summary>
/// <param name="mappingSet">
/// The mapping set of the dataflow found in the sdmx query
/// </param>
/// <param name="query">
/// The current SDMX Query object
/// </param>
/// <param name="connectionStringSettings">
/// The Mapping Store connection string settings
/// </param>
public DataRetrievalInfo(MappingSetEntity mappingSet, IComplexDataQuery query, ConnectionStringSettings connectionStringSettings)
{
if (mappingSet == null)
{
throw new ArgumentNullException("mappingSet");
}
if (connectionStringSettings == null)
{
throw new ArgumentNullException("connectionStringSettings");
}
this._mappingSet = mappingSet;
this._complexQuery = query;
this._connectionStringSettings = connectionStringSettings;
this._limit = query.FirstNObservations.HasValue ? query.FirstNObservations.Value : 0;
//this._dimensionAtObservation = query.DimensionAtObservation();
this._isTimePeriodAtObservation = DimensionObject.TimeDimensionFixedId.Equals(query.DimensionAtObservation);
if (!this._isTimePeriodAtObservation)
{
this._dimensionAtObservation = query.DimensionAtObservation;
}
this.BuildMappings();
}
/// <summary>
/// Gets the data.
/// </summary>
/// <param name="dataQuery">The data query.</param>
/// <param name="dataWriter">The data writer.</param>
public virtual void GetData(IComplexDataQuery dataQuery, IDataWriterEngine dataWriter)
{
this._advancedSdmxDataRetrievalWithWriter.GetData(dataQuery, dataWriter);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataRetrievalInfoSeries"/> class.
/// </summary>
/// <param name="mappingSet">
/// The mapping set of the dataflow found in the sdmx query
/// </param>
/// <param name="query">
/// The current SDMX Query object
/// </param>
/// <param name="connectionStringSettings">
/// The Mapping Store connection string settings
/// </param>
/// <param name="seriesWriter">
/// The series Writer.
/// </param>
public DataRetrievalInfoSeries(
MappingSetEntity mappingSet,
IComplexDataQuery query,
ConnectionStringSettings connectionStringSettings,
IDataWriterEngine seriesWriter)
: base(mappingSet, query, connectionStringSettings)
{
this._seriesWriter = seriesWriter;
this._seriesObsComponents = new List<IComponentMapping>();
this._dataSetAttributes = new List<IComponentMapping>();
this._groups = new Dictionary<GroupEntity, GroupInformation>();
this._useDataSetSqlQuery = mappingSet.Dataflow.Dsd.Groups.Count > 0;
this.BuildSeriesMappings();
// add dimension mappings to groups
this.BuildTimeSeriesGroupMappings();
}
/// <summary>
/// Gets the data.
/// </summary>
/// <param name="dataQuery">The data query.</param>
/// <param name="dataWriter">The data writer.</param>
/// <exception cref="SdmxNoResultsException">0 observations found (SDMX v2.1 behavior)</exception>
/// <exception cref="SdmxResponseTooLargeException">Emulating default limit</exception>
/// <exception cref="SdmxResponseSizeExceedsLimitException">Emulating server side limit</exception>
/// <exception cref="SdmxSemmanticException">Invalid component in query</exception>
public void GetData(IComplexDataQuery dataQuery, IDataWriterEngine dataWriter)
{
dataWriter.StartDataset(null, dataQuery.DataStructure, null);
this.Validate(dataQuery, dataWriter);
WriteData(dataQuery, dataWriter);
}
