/// <summary>
/// Replace or insert the specified <paramref name="artefact"/> to MAPPING STORE
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="artefact">
/// The artefact.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="state"/> is null
/// -or-
/// <paramref name="artefact"/> is null
/// </exception>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
protected ArtefactImportStatus ReplaceOrInsert(DbTransactionState state, IMaintainableObject artefact)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
if (artefact == null)
{
throw new ArgumentNullException("artefact");
}
var structureReference = artefact.AsReference;
_log.DebugFormat(CultureInfo.InvariantCulture, "Replacing or Insert artefact = {0}", structureReference);
var finalStatus = GetFinalStatus(state, structureReference);
ArtefactImportStatus status;
if (finalStatus == null || finalStatus.PrimaryKey < 0)
{
status = this.InsertArtefact(state, artefact);
}
else if (!finalStatus.IsFinal)
{
this.Delete(state, finalStatus.PrimaryKey);
status = this.InsertArtefact(state, artefact);
}
else
{
status = new ArtefactImportStatus(finalStatus.PrimaryKey, this.GetCannotReplaceMessage(structureReference));
}
return(status);
}
/// <summary>
/// Insert or replace artefacts.
/// </summary>
/// <param name="maintainables">
/// The maintainables.
/// </param>
/// <typeparam name="T">
/// The <see cref="IMaintainableObject"/> based interface
/// </typeparam>
/// <returns>
/// The <see cref="IEnumerable{ArtefactImportStatus}"/>.
/// </returns>
protected IEnumerable <ArtefactImportStatus> ReplaceOrInsert <T>(IEnumerable <T> maintainables) where T : IMaintainableObject
{
foreach (var artefact in maintainables)
{
using (DbTransactionState state = DbTransactionState.Create(this._database))
{
ArtefactImportStatus artefactImportStatus;
try
{
artefactImportStatus = this.ReplaceOrInsert(state, artefact);
state.Commit();
}
catch (MappingStoreException e)
{
_log.Error(artefact.Urn.ToString(), e);
state.RollBack();
artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e));
}
catch (DbException e)
{
_log.Error(artefact.Urn.ToString(), e);
state.RollBack();
artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e));
}
yield return(artefactImportStatus);
}
}
}
/// <summary>
/// Delete the specified <paramref name="objects"/> from Mapping Store if they exist.
/// </summary>
/// <param name="objects">
/// The objects.
/// </param>
/// <typeparam name="T"> The type of maintainable object</typeparam>
protected void DeleteObjects <T>(IEnumerable <T> objects) where T : IMaintainableObject
{
foreach (var maintainableObject in objects)
{
using (DbTransactionState state = DbTransactionState.Create(this._database))
{
try
{
IStructureReference structureReference = maintainableObject.AsReference;
var status = GetFinalStatus(state, structureReference);
if (status != null && status.PrimaryKey > 0)
{
_log.DebugFormat(CultureInfo.InvariantCulture, "Deleting artefact record {0}.", structureReference.GetAsHumanReadableString());
this.Delete(state, status.PrimaryKey);
}
else
{
_log.WarnFormat(CultureInfo.InvariantCulture, "Failed to delete artefact record {0}.", structureReference.GetAsHumanReadableString());
}
state.Commit();
}
catch (Exception e)
{
state.RollBack();
_log.Error(maintainableObject.Urn, e);
throw;
}
}
}
}
/// <summary>
/// Insert a <see cref="ILevelObject"/> to mapping store table LEVEL.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="level">
/// The level.
/// </param>
/// <param name="hierarchyId">
/// The hierarchy id.
/// </param>
/// <param name="parentID">
/// The parent level id.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
private long InsertLevel(DbTransactionState state, ILevelObject level, long hierarchyId, long parentID)
{
long artefactImportStatus;
var artefactStoredProcedure = _storedProcedures.InsertHlevel;
using (DbCommand command = artefactStoredProcedure.CreateCommandWithDefaults(state))
{
DbParameter hierarchyIdParameter = artefactStoredProcedure.CreateHIdParameter(command);
hierarchyIdParameter.Value = hierarchyId;
DbParameter parentLevelIdParameter = artefactStoredProcedure.CreateParentLevelIdParameter(command);
if (parentID > 0)
{
parentLevelIdParameter.Value = parentID;
}
if (level.Uri != null)
{
artefactStoredProcedure.CreateUriParameter(command).Value = level.Uri.ToString();
}
artefactImportStatus = this.RunNameableArtefactCommand(level, command, artefactStoredProcedure);
}
return(artefactImportStatus);
}
/// <summary>
/// Inserts the specified item.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="schemaMaps">The schema maps.</param>
/// <param name="structureSetId">The structure set identifier.</param>
/// <returns>
/// The primary key value
/// </returns>
public IEnumerable <long> Insert(DbTransactionState state, IEnumerable <TSchemaMap> schemaMaps, long structureSetId)
{
var procedure = new TProc();
var cache = new StructureCache();
var primaryKeys = new List <long>();
foreach (var schemaMap in schemaMaps)
{
long primaryKey;
using (var command = procedure.CreateCommandWithDefaults(state))
{
procedure.CreateParentIdParameter(command).Value = structureSetId;
var sourceCodelistStatus = this._validateStatusEngine.GetReferenceStatus(state, schemaMap.SourceRef, cache);
var targetCodelistStatus = this._validateStatusEngine.GetReferenceStatus(state, schemaMap.TargetRef, cache);
procedure.CreateSourceIdParameter(command).Value = sourceCodelistStatus.FinalStatus.PrimaryKey;
procedure.CreateTargetIdParameter(command).Value = targetCodelistStatus.FinalStatus.PrimaryKey;
primaryKey = this._nameableImportEngine.RunCommand(schemaMap, command, procedure, state);
}
primaryKeys.Add(primaryKey);
this.WriteItemMaps(state, schemaMap, primaryKey);
}
return(primaryKeys);
}
/// <summary>
/// Insert the specified <paramref name="maintainable"/> to the mapping store with <paramref name="state"/>
/// </summary>
/// <param name="state">
/// The MAPPING STORE connection and transaction state
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
public override ArtefactImportStatus Insert(DbTransactionState state, IDataConsumerScheme maintainable)
{
_log.DebugFormat(CultureInfo.InvariantCulture, "Importing artefact {0}", maintainable.Urn);
var artefactStoredProcedure = _storedProcedures.InsertDataConsumerScheme;
return(this.InsertInternal(state, maintainable, artefactStoredProcedure));
}
/// <summary>
/// The insert.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="hierarchies">
/// The hierarchies.
/// </param>
/// <param name="parentArtefact">
/// The parent artefact.
/// </param>
/// <returns>
/// The <see cref="IEnumerable"/>.
/// </returns>
private IEnumerable <KeyValuePair <long, IHierarchy> > InsertHierarchies(DbTransactionState state, IEnumerable <IHierarchy> hierarchies, long parentArtefact)
{
foreach (IHierarchy item in hierarchies)
{
yield return(new KeyValuePair <long, IHierarchy>(this.InsertHierarchy(state, item, parentArtefact), item));
}
}
/// <summary>
/// Insert the specified <paramref name="items"/> to the mapping store with <paramref name="state"/>
/// </summary>
/// <param name="state">
/// The MAPPING STORE connection and transaction state
/// </param>
/// <param name="items">
/// The items.
/// </param>
/// <param name="parentArtefact">
/// The primary key of the parent artefact.
/// </param>
/// <returns>
/// The <see cref="IEnumerable{Long}"/>.
/// </returns>
public ItemStatusCollection Insert(DbTransactionState state, IEnumerable <IComponent> items, long parentArtefact)
{
var components = items as IComponent[] ?? items.ToArray();
if (components.Length == 0)
{
return(new ItemStatusCollection());
}
var cache = new StructureCache();
var returnValues = new ItemStatusCollection();
var dsd = components[0].MaintainableParent as IDataStructureObject;
if (dsd == null)
{
throw new ArgumentException(Resources.ExceptionCannotDetermineParent, "items");
}
foreach (var component in components)
{
returnValues.Add(new ItemStatus(component.Id, Insert(state, component, cache, parentArtefact)));
}
return(returnValues);
}
/// <summary>
/// Inserts the attribute attachment measures. (SDMX V2.0 only)
/// </summary>
/// <param name="state">The state.</param>
/// <param name="dsd">The DSD.</param>
/// <param name="components">The components.</param>
private static void InsertAttributeAttachmentMeasures(DbTransactionState state, IDataStructureObject dsd, ItemStatusCollection components)
{
var cross = dsd as ICrossSectionalDataStructureObject;
if (cross == null)
{
// it is not a SDXM v2.0 cross sectional DSD therefor there are no Measure dimensions or CrossSectional measures.
return;
}
var parameterList = new List <DbParameter[]>();
foreach (var attributeObject in cross.Attributes)
{
ItemStatus attributeStatus;
if (components.TryGetValue(attributeObject.Id, out attributeStatus))
{
foreach (var crossSectionalMeasure in cross.GetAttachmentMeasures(attributeObject))
{
ItemStatus measureStatus;
if (components.TryGetValue(crossSectionalMeasure.Id, out measureStatus))
{
var parameters = new DbParameter[2];
parameters[0] = state.Database.CreateInParameter(IdParameter, DbType.Int64, attributeStatus.SysID);
parameters[1] = state.Database.CreateInParameter("measureId", DbType.Int64, measureStatus.SysID);
parameterList.Add(parameters);
}
}
}
}
state.ExecuteNonQueryFormat("insert into ATT_MEASURE (ATT_COMP_ID, MEASURE_COMP_ID) VALUES ({0}, {1})", parameterList);
}
/// <summary>
/// Insert the specified <paramref name="maintainables"/> to the mapping store.
/// </summary>
/// <param name="maintainables">
/// The maintainable.
/// </param>
/// <returns>
/// The <see cref="IEnumerable{ArtefactImportStatus}"/>.
/// </returns>
public new IEnumerable <ArtefactImportStatus> Insert(IEnumerable <ICategorisationObject> maintainables)
{
var cache = new StructureCache();
foreach (var artefact in maintainables)
{
using (DbTransactionState state = DbTransactionState.Create(this.Database))
{
ArtefactImportStatus artefactImportStatus;
try
{
artefactImportStatus = this.InsertInternal(state, artefact, cache);
state.Commit();
}
catch (MappingStoreException e)
{
_log.Error(artefact.Urn.ToString(), e);
state.RollBack();
artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e));
}
catch (DbException e)
{
_log.Error(artefact.Urn.ToString(), e);
state.RollBack();
artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e));
}
yield return(artefactImportStatus);
}
}
}
/// <summary>
/// Insert dimension group.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="dsd">
/// The DSD.
/// </param>
/// <param name="groups">
/// The groups.
/// </param>
/// <param name="components">
/// The components.
/// </param>
private static void InsertDimensionGroup(DbTransactionState state, IDataStructureObject dsd, ItemStatusCollection groups, ItemStatusCollection components)
{
var parameterList = new List <DbParameter[]>();
foreach (var dsdGroup in dsd.Groups)
{
ItemStatus dsdGroupStatus;
if (groups.TryGetValue(dsdGroup.Id, out dsdGroupStatus))
{
foreach (var dimensionRef in dsdGroup.DimensionRefs)
{
ItemStatus dimensionStatus;
if (components.TryGetValue(dimensionRef, out dimensionStatus))
{
var parameters = new DbParameter[2];
parameters[0] = state.Database.CreateInParameter(IdParameter, DbType.Int64, dimensionStatus.SysID);
parameters[1] = state.Database.CreateInParameter(GroupIdParameter, DbType.Int64, dsdGroupStatus.SysID);
parameterList.Add(parameters);
}
}
}
}
state.ExecuteNonQueryFormat("insert into DIM_GROUP (COMP_ID, GR_ID) VALUES ({0}, {1})", parameterList);
}
/// <summary>
/// Insert attribute group.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="dsd">
/// The DSD.
/// </param>
/// <param name="components">
/// The components.
/// </param>
private static void InsertAttributeDimensions(DbTransactionState state, IDataStructureObject dsd, ItemStatusCollection components)
{
var parameterList = new List <DbParameter[]>();
foreach (var attributeObject in dsd.DimensionGroupAttributes)
{
ItemStatus attributeStatus;
if (components.TryGetValue(attributeObject.Id, out attributeStatus))
{
foreach (var dimensionReference in attributeObject.DimensionReferences)
{
ItemStatus dimensionStatus;
if (components.TryGetValue(dimensionReference, out dimensionStatus))
{
var parameters = new DbParameter[2];
parameters[0] = state.Database.CreateInParameter(IdParameter, DbType.Int64, attributeStatus.SysID);
parameters[1] = state.Database.CreateInParameter(GroupIdParameter, DbType.Int64, dimensionStatus.SysID);
parameterList.Add(parameters);
}
}
}
}
state.ExecuteNonQueryFormat("insert into ATTR_DIMS (ATTR_ID, DIM_ID) VALUES ({0}, {1})", parameterList);
}
/// <summary>
/// Gets the structure.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="reference">The reference.</param>
/// <returns>The <see cref="ItemStatusCollection"/></returns>
public ItemSchemeFinalStatus GetStructure(DbTransactionState state, IStructureReference reference)
{
ItemSchemeFinalStatus returnObjet;
if (!this._dictionary.TryGetValue(reference, out returnObjet))
{
var artefactFinalStatus = ArtefactBaseEngine.GetFinalStatus(state, reference);
ItemStatusCollection collection = null;
if (artefactFinalStatus != null && artefactFinalStatus.IsFinal && reference.HasChildReference())
{
switch (reference.TargetReference.EnumType)
{
case SdmxStructureEnumType.Component:
case SdmxStructureEnumType.Dimension:
case SdmxStructureEnumType.TimeDimension:
case SdmxStructureEnumType.MeasureDimension:
case SdmxStructureEnumType.DataAttribute:
case SdmxStructureEnumType.PrimaryMeasure:
case SdmxStructureEnumType.CrossSectionalMeasure:
var map = GetComponentMapIds(state, reference);
collection = new ItemStatusCollection(map.Select(pair => new ItemStatus(pair.Key, pair.Value)));
break;
default:
collection = GetId(state, reference.TargetReference.EnumType, artefactFinalStatus.PrimaryKey);
break;
}
}
returnObjet = new ItemSchemeFinalStatus(artefactFinalStatus ?? ArtefactFinalStatus.Empty, collection);
}
return(returnObjet);
}
/// <summary>
/// Gets the component map ids.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="dsdReference">
/// The DSD reference.
/// </param>
/// <returns>
/// The component id to primary key value dictionary
/// </returns>
public static IDictionary <string, long> GetComponentMapIds(DbTransactionState state, IStructureReference dsdReference)
{
IDictionary <string, long> map = new Dictionary <string, long>(StringComparer.Ordinal);
var idParameter = state.Database.CreateInParameter("p_id", DbType.AnsiString, dsdReference.MaintainableId);
var agencyParameter = state.Database.CreateInParameter("p_agency", DbType.AnsiString, dsdReference.AgencyId);
var versionParameter = state.Database.CreateInParameter("p_version", DbType.AnsiString, dsdReference.Version);
var queryFormat = dsdReference.MaintainableStructureEnumType.EnumType == SdmxStructureEnumType.Dsd
? "select c.COMP_ID, c.ID from COMPONENT c inner join ARTEFACT_VIEW a on a.ART_ID = c.DSD_ID where a.ID = {0} and a.AGENCY = {1} and a.VERSION = {2}"
: "select c.COMP_ID, c.ID from COMPONENT c inner join DATAFLOW d on d.DSD_ID = c.DSD_ID inner join ARTEFACT_VIEW a on a.ART_ID = d.DF_ID where a.ID = {0} and a.AGENCY = {1} and a.VERSION = {2}";
using (var command = state.Database.GetSqlStringCommandFormat(queryFormat, idParameter, agencyParameter, versionParameter))
using (var reader = state.Database.ExecuteReader(command))
{
var sysIdOrdinal = reader.GetOrdinal("COMP_ID");
var idOrdinal = reader.GetOrdinal("ID");
while (reader.Read())
{
map.Add(reader.GetString(idOrdinal), reader.GetInt64(sysIdOrdinal));
}
}
return(map);
}
/// <summary>
/// Converts the concept schemes to code lists.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="conceptSchemesPerMeasureDimension">
/// The concept schemes per measure dimension.
/// </param>
private void ConvertConceptSchemes(DbTransactionState state, IEnumerable <KeyValuePair <long, IMaintainableRefObject> > conceptSchemesPerMeasureDimension)
{
var transactionalDatabase = new Database(this._database, state.Transaction);
var mutableObjectRetrievalManager = this.GetRetrievalManager(transactionalDatabase);
var codelistPrimaryKeyCache = new Dictionary <IMaintainableRefObject, ArtefactFinalStatus>();
foreach (var keyValuePair in conceptSchemesPerMeasureDimension)
{
ArtefactFinalStatus artefactFinalStatus;
if (!codelistPrimaryKeyCache.TryGetValue(keyValuePair.Value, out artefactFinalStatus))
{
artefactFinalStatus = ArtefactBaseEngine.GetFinalStatus(state, new StructureReferenceImpl(keyValuePair.Value, SdmxStructureEnumType.CodeList));
if (artefactFinalStatus.IsEmpty)
{
var conceptScheme = mutableObjectRetrievalManager.GetMutableConceptScheme(keyValuePair.Value, false, false);
var codelist = conceptScheme.ConvertToCodelist();
var importStatus = this._importEngine.Insert(state, codelist.ImmutableInstance);
artefactFinalStatus = new ArtefactFinalStatus(importStatus.PrimaryKeyValue, true);
}
codelistPrimaryKeyCache.Add(keyValuePair.Value, artefactFinalStatus);
}
state.ExecuteNonQueryFormat(
UpdateComponentCodelist,
transactionalDatabase.CreateInParameter("clId", DbType.Int64, artefactFinalStatus.PrimaryKey),
transactionalDatabase.CreateInParameter("compId", DbType.Int64, keyValuePair.Key));
}
}
/// <summary>
/// The (fast) method that inserts codes from <paramref name="items"/> together with parent item information without
/// using an update SQL statement for parents.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="parentArtefact">
/// The parent artefact.
/// </param>
/// <param name="items">
/// The items.
/// </param>
/// <param name="parentMap">
/// The parent map.
/// </param>
private void InsertCodesNoUpdate(DbTransactionState state, long parentArtefact, LinkedList <TItem> items, IDictionary <string, long> parentMap)
{
int lastCount = items.Count;
LinkedListNode <TItem> current = items.First;
while (current != null)
{
var item = current.Value;
long parentCodePrimaryKey = 0;
var parentItem = this.GetParentItem(item);
if (string.IsNullOrEmpty(parentItem) || parentMap.TryGetValue(parentItem, out parentCodePrimaryKey))
{
var itemID = this.InsertCode(state, parentArtefact, parentCodePrimaryKey, item);
parentMap.Add(item.Id, itemID);
items.Remove(current);
}
current = current.Next;
if (current == null && items.Count != lastCount)
{
current = items.First;
lastCount = items.Count;
}
}
}
/// <summary>
/// Gets the CodeList status.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="reference">
/// The reference.
/// </param>
/// <param name="itemScheme">
/// The item scheme.
/// </param>
/// <returns>
/// The <see cref="ItemSchemeFinalStatus"/>.
/// </returns>
public ItemSchemeFinalStatus GetReferenceStatus(DbTransactionState state, IStructureReference reference, StructureCache itemScheme)
{
ItemSchemeFinalStatus codelistStatus = itemScheme.GetStructure(state, reference);
this.ValidateFinalStatus(codelistStatus.FinalStatus, reference);
return(codelistStatus);
}
/// <summary>
/// Insert a record with the values from <paramref name="annotations"/> to <paramref name="annotationProcedureBase"/>
/// for an artifact with the specified
/// <paramref name="annotatablePrimaryKey"/>
/// </summary>
/// <param name="state">
/// The mapping store connection and transaction state
/// </param>
/// <param name="annotatablePrimaryKey">
/// The artifact primary key.
/// </param>
/// <param name="annotationProcedureBase">
/// The annotation procedure base.
/// </param>
/// <param name="annotations">
/// The annotations.
/// </param>
public void Insert(DbTransactionState state, long annotatablePrimaryKey, AnnotationProcedureBase annotationProcedureBase, IList <IAnnotation> annotations)
{
this._decorated.Insert(
state,
annotatablePrimaryKey,
annotationProcedureBase,
annotations.Where(annotation => !string.Equals(annotation.Title, AnnotationConstant.CodeTimeDimensionTitle)).ToArray());
}
public virtual void Rollback()
{
state = DbTransactionState.Rolledback;
if (referenceCount == 0)
{
state = DbTransactionState.Disposed;
}
}
protected virtual void Commit()
{
state = DbTransactionState.Committed;
if (referenceCount == 0)
{
state = DbTransactionState.Disposed;
}
}
/// <summary>
/// Deletes the child items.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="primaryKey">The primary key.</param>
protected override void DeleteChildStructures(DbTransactionState state, long primaryKey)
{
state.ExecuteNonQueryFormat(
"DELETE FROM ANNOTATION WHERE ANN_ID IN (SELECT DISTINCT ANN_ID FROM COMPONENT_ANNOTATION WHERE COMP_ID IN (SELECT COMP_ID FROM COMPONENT WHERE DSD_ID = {0}))",
state.Database.CreateInParameter("p_fk", DbType.Int64, primaryKey));
state.ExecuteNonQueryFormat(
"DELETE FROM ANNOTATION WHERE ANN_ID IN (SELECT DISTINCT ANN_ID FROM GROUP_ANNOTATION WHERE GR_ID IN (SELECT GR_ID FROM DSD_GROUP WHERE DSD_ID = {0}))",
state.Database.CreateInParameter("p_fk", DbType.Int64, primaryKey));
}
/// <summary>
/// Run common artefact import command.
/// </summary>
/// <param name="artefact">
/// The artefact.
/// </param>
/// <param name="command">
/// The command.
/// </param>
/// <param name="artefactStoredProcedure">
/// The artefact stored procedure.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
protected long RunNameableArtefactCommand(INameableObject artefact, DbCommand command, ArtefactProcedurebase artefactStoredProcedure)
{
var artID = this.RunIdentifiableArterfactCommand(artefact, command, artefactStoredProcedure);
DbTransactionState state = new DbTransactionState(command.Transaction, this._database);
_localisedStringInsertEngine.InsertForArtefact(artID, artefact, state.Database);
return(artID);
}
/// <summary>
/// Insert text formats.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="formats">
/// The formats.
/// </param>
public void InsertTextFormats(DbTransactionState state, IEnumerable <KeyValuePair <long, ITextFormat> > formats)
{
var insertTextFormat = _insertTextFormat;
using (DbCommand command = insertTextFormat.CreateCommand(state))
{
var compidParameter = insertTextFormat.CreateCompidParameter(command);
var facetTypeEnumParameter = insertTextFormat.CreateFacetTypeEnumParameter(command);
var facetValueParameter = insertTextFormat.CreateFacetValueParameter(command);
insertTextFormat.CreateOutputParameter(command);
var facets = new Stack <KeyValuePair <long, string> >();
foreach (var format in formats)
{
compidParameter.Value = format.Key;
var textFormat = format.Value;
if (textFormat.TextType != null)
{
var textType = textFormat.TextType.EnumType.ToString();
long id;
if (this._dataTypeMap.TryGetValue(textType, out id))
{
facetTypeEnumParameter.Value = id;
facetValueParameter.Value = DBNull.Value;
command.ExecuteNonQuery();
}
}
this.AddFacet(textFormat.Decimals, "decimals", facets);
this.AddFacet(textFormat.MaxLength, "maxLength", facets);
this.AddFacet(textFormat.MinLength, "minLength", facets);
this.AddFacet(textFormat.Pattern, "pattern", facets);
this.AddFacet(textFormat.TimeInterval, "timeInterval", facets);
this.AddFacet(textFormat.EndValue, "endValue", facets);
this.AddFacet(textFormat.Interval, "interval", facets);
this.AddFacet(textFormat.Sequence, "isSequence", facets);
this.AddFacet(textFormat.StartValue, "startValue", facets);
while (facets.Count > 0)
{
var keyValuePair = facets.Pop();
if (keyValuePair.Value.Length > 51)
{
_log.Error("ERROR: facet value over 51 characters.");
}
facetTypeEnumParameter.Value = keyValuePair.Key;
facetValueParameter.Value = keyValuePair.Value.Length > 51 ? keyValuePair.Value.Substring(0, 51) : keyValuePair.Value;
command.ExecuteNonQuery();
}
}
}
}
/// <summary>
/// Insert the specified <paramref name="maintainable"/> to mapping store <c>CATEGORISATION</c> table
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <param name="cache">
/// The cached Dataflow and Category Scheme
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
private ArtefactImportStatus InsertInternal(DbTransactionState state, ICategorisationObject maintainable, StructureCache cache)
{
var dataflowStatus = cache.GetStructure(state, maintainable.StructureReference);
ArtefactImportStatus returnValue;
if (dataflowStatus.FinalStatus.PrimaryKey > 0)
{
var categoryScheme = cache.GetStructure(state, maintainable.CategoryReference);
if (categoryScheme.FinalStatus.PrimaryKey > 0 && categoryScheme.FinalStatus.IsFinal)
{
var categoryPrimaryKey = this.GetCategoryPrimaryKey(state, maintainable, categoryScheme);
if (!ExistsCategorisation(state, dataflowStatus.FinalStatus.PrimaryKey, categoryPrimaryKey.SysID))
{
var artefactStoredProcedure = _storedProcedures.InsertCategorisation;
returnValue = this.InsertArtefactInternal(
state,
maintainable,
artefactStoredProcedure,
command =>
{
artefactStoredProcedure.CreateArtIdParameter(command).Value = dataflowStatus.FinalStatus.PrimaryKey;
artefactStoredProcedure.CreateCatIdParameter(command).Value = categoryPrimaryKey.SysID;
});
string message = string.Format(
CultureInfo.InvariantCulture,
"Successfully categorized {0} with Category {1} of {2}\n",
maintainable.StructureReference.GetAsHumanReadableString(),
maintainable.CategoryReference.ChildReference.Id,
maintainable.CategoryReference.GetAsHumanReadableString());
returnValue = new ArtefactImportStatus(returnValue.PrimaryKeyValue, new ImportMessage(ImportMessageStatus.Success, maintainable.AsReference, message));
}
else
{
returnValue = BuildWarningMessage(maintainable, "Warning: Ignoring duplicate categorisation of {0} with {1}\n");
}
}
else if (!categoryScheme.FinalStatus.IsFinal)
{
returnValue = BuildWarningMessage(maintainable, "Failure: {0} is not Final so it cannot be referenced from {1}\n");
}
else
{
returnValue = BuildWarningMessage(maintainable, "Failure: {0} does not exist so it cannot be referenced from {1}\n");
}
}
else
{
string message = string.Format(CultureInfo.InvariantCulture, "Failure: Cannot categorize {0}, because it does not exist\n", maintainable.StructureReference.GetAsHumanReadableString());
returnValue = new ArtefactImportStatus(-1, new ImportMessage(ImportMessageStatus.Warning, maintainable.AsReference, message));
}
return(returnValue);
}
/// <summary>
/// Insert the specified <paramref name="maintainable"/> to the mapping store with <paramref name="state"/>
/// </summary>
/// <param name="state">
/// The MAPPING STORE connection and transaction state
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
public override ArtefactImportStatus Insert(DbTransactionState state, IStructureSetObject maintainable)
{
_log.DebugFormat(CultureInfo.InvariantCulture, "Importing artefact {0}", maintainable.Urn);
var artefactStoredProcedure = _artefactStoredProcedure;
var artefactStatus = this.InsertArtefactInternal(state, maintainable, artefactStoredProcedure);
this._codelistMapImport.Insert(state, maintainable.CodelistMapList, artefactStatus.PrimaryKeyValue);
this._structureMapImportEngine.Insert(state, maintainable.StructureMapList, artefactStatus.PrimaryKeyValue);
return(artefactStatus);
}
/// <summary>
/// Delete an ARTEFACT with the specified <paramref name="primaryKey"/> value
/// </summary>
/// <param name="state">
/// The Mapping Store <see cref="DbTransactionState"/>
/// </param>
/// <param name="primaryKey">
/// The primary key value.
/// </param>
/// <returns>
/// The number of records deleted.
/// </returns>
public int Delete(DbTransactionState state, long primaryKey)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
this.DeleteChildStructures(state, primaryKey);
_log.DebugFormat(CultureInfo.InvariantCulture, "Deleting artefact record with primary key (ART_ID) = {0}", primaryKey);
state.ExecuteNonQueryFormat("DELETE FROM ANNOTATION WHERE ANN_ID in (select ANN_ID from ARTEFACT_ANNOTATION WHERE ART_ID = {0})", state.Database.CreateInParameter("artId", DbType.Int64, primaryKey));
return(state.ExecuteNonQueryFormat("DELETE FROM ARTEFACT WHERE ART_ID = {0}", state.Database.CreateInParameter("artId", DbType.Int64, primaryKey)));
}
/// <summary>
/// The (slow) method that inserts items from <paramref name="items"/> without parent code information with an update
/// SQL statement for parents.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="parentArtefact">
/// The parent artefact.
/// </param>
/// <param name="items">
/// The code collection
/// </param>
/// <param name="parentMap">
/// The parent map.
/// </param>
/// <exception cref="MappingStoreException">
/// Invalid parent code found.
/// </exception>
/// <remarks>
/// This method normally shouldn't run because Common API <c>SDMX Source.NET 0.9.15</c> validation rules check for
/// codes with parent recursive loops. <see cref="ExceptionCode.ParentRecursiveLoop"/>
/// </remarks>
private void InsertItemsWithUpdate(DbTransactionState state, long parentArtefact, ICollection <TItem> items, IDictionary <string, long> parentMap)
{
if (items.Count == 0)
{
return;
}
_log.InfoFormat(CultureInfo.InvariantCulture, "Using slow InsertItemsWithUpdate method for {0} codes. Already inserted : {1}", items.Count, parentMap.Count);
var itemsWithParents = new List <KeyValuePair <long, string> >(items.Count);
foreach (var item in items)
{
var parentItem = this.GetParentItem(item);
if (!string.IsNullOrEmpty(parentItem))
{
long parentItemPrimaryKey;
long itemID;
if (parentMap.TryGetValue(parentItem, out parentItemPrimaryKey))
{
itemID = this.InsertCode(state, parentArtefact, parentItemPrimaryKey, item);
}
else
{
itemID = this.InsertCode(state, parentArtefact, 0, item);
itemsWithParents.Add(new KeyValuePair <long, string>(itemID, parentItem));
}
parentMap.Add(item.Id, itemID);
}
else
{
Debug.Fail("Error in first algorithm. We should have never reached this point.");
}
}
foreach (var itemWithParent in itemsWithParents)
{
long parentCodePrimaryKey;
if (parentMap.TryGetValue(itemWithParent.Value, out parentCodePrimaryKey))
{
state.ExecuteNonQueryFormat(
"update DSD_CODE set PARENT_CODE = {0} where LCD_ID = {1}",
state.Database.CreateInParameter("parent", DbType.Int64, parentCodePrimaryKey),
state.Database.CreateInParameter("code", DbType.Int64, itemWithParent.Key));
}
else
{
var message = "Invalid parent code : " + itemWithParent.Value;
_log.Error(message);
throw new MappingStoreException(message);
}
}
}
/// <summary>
/// Deletes annotations for annotatoble with the specified <paramref name="annotableSysId"/> and the specified <paramref name="type"/>
/// </summary>
/// <param name="state">The state.</param>
/// <param name="annotableSysId">The annotable system identifier.</param>
/// <param name="type">The type.</param>
/// <param name="structureType">Type of the structure.</param>
/// <returns>The number of annotations deleted.</returns>
public int DeleteByType(DbTransactionState state, long annotableSysId, string type, SdmxStructureType structureType)
{
var annotationRelationTable = this._annotationRelationInfoBuilder.Build(structureType);
var query = string.Format(
CultureInfo.InvariantCulture,
"DELETE FROM ANNOTATION WHERE ANN_ID IN (SELECT DISTINCT ANN_ID FROM {0} WHERE {1} = {{0}} AND TYPE={{1}})",
annotationRelationTable.Table,
annotationRelationTable.PrimaryKey);
return(state.Database.ExecuteNonQueryFormat(query, this._mappingStoreDatabase.CreateInParameter("p_id", DbType.Int64, annotableSysId), this._mappingStoreDatabase.CreateInParameter("p_type", DbType.String, type)));
}
/// <summary>
/// Returns the referenced category primary key. If the category does not exist it will be added.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <param name="categoryScheme">
/// The category scheme.
/// </param>
/// <returns>
/// The <see cref="ItemStatus"/>.
/// </returns>
private ItemStatus GetCategoryPrimaryKey(DbTransactionState state, ICategorisationObject maintainable, ItemSchemeFinalStatus categoryScheme)
{
ItemStatus categoryPrimaryKey;
if (!categoryScheme.ItemIdMap.TryGetValue(maintainable.CategoryReference.ChildReference.Id, out categoryPrimaryKey))
{
ICategoryObject categoryObject = this._categoryBuilder.Build(maintainable.CategoryReference);
var primaryKey = this._categoryImport.Insert(state, new[] { categoryObject }, categoryScheme.FinalStatus.PrimaryKey).FirstOrDefault();
categoryPrimaryKey = new ItemStatus(categoryObject.Id, primaryKey);
}
return(categoryPrimaryKey);
}
/// <summary>
/// Create a dummy codelist for all SDMX v2.1 DSD MeasureDimensions.
/// </summary>
public void CreateDummyCodelistForAll()
{
using (var state = DbTransactionState.Create(this._database))
{
var conceptSchemesPerMeasureDimension = new Dictionary <long, IMaintainableRefObject>();
state.ExecuteReaderFormat(GetAllMeasureDimensionsWithoutCodelist, reader => PopulateConceptSchemePerMeasureDimension(reader, conceptSchemesPerMeasureDimension));
this.ConvertConceptSchemes(state, conceptSchemesPerMeasureDimension);
state.Commit();
}
}
