/// <summary> /// Retrieve the <see cref="IMaintainableMutableObject"/> from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="versionConstraints"> /// The version types. /// </param> /// <returns> /// The <see cref="ISet{IMaintainableMutableObject}"/>. /// </returns> public override ISet <TMaintaible> Retrieve(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, VersionQueryType versionConstraints) { var sqlInfo = versionConstraints == VersionQueryType.Latest ? this.SqlQueryInfoForLatest : this.SqlQueryInfoForAll; var sqlQuery = new ArtefactSqlQuery(sqlInfo, maintainableRef); return(this.RetrieveItemScheme(detail, sqlQuery)); }
/// <summary> /// Retrieve the <see cref="IDataflowMutableObject"/> from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="versionConstraints"> /// The version query type /// </param> /// <param name="allowedDataflows"> /// The allowed Dataflows. /// </param> /// <returns> /// The <see cref="ISet{IDataflowMutableObject}"/>. /// </returns> public override ISet <IDataflowMutableObject> Retrieve(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, VersionQueryType versionConstraints, IList <IMaintainableRefObject> allowedDataflows) { var dataflowMutableObjects = new HashSet <IDataflowMutableObject>(); var sqlQueryInfo = versionConstraints == VersionQueryType.Latest ? this._sqlQueryInfoLatest : this._sqlQueryInfo; var artefactSqlQuery = new ArtefactSqlQuery(sqlQueryInfo, maintainableRef); // do a security check. return(!SecurityHelper.Contains(allowedDataflows, maintainableRef) ? dataflowMutableObjects : this.RetrieveArtefacts(artefactSqlQuery, detail, query => this._artefactCommandBuilder.Build(query, allowedDataflows))); }
/// <summary> /// Retrieve the <see cref="IDataflowMutableObject"/> with the latest version group by ID and AGENCY from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="allowedDataflows"> /// The allowed Dataflows. /// </param> /// <returns> /// The <see cref="ISet{IDataflowMutableObject}"/>. /// </returns> public override IDataflowMutableObject RetrieveLatest(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, IList <IMaintainableRefObject> allowedDataflows) { var dataflowMutableObjects = new HashSet <IDataflowMutableObject>(); var artefactSqlQuery = new ArtefactSqlQuery(this._sqlQueryInfoLatest, maintainableRef); // do a security check. var dataflows = !SecurityHelper.Contains(allowedDataflows, maintainableRef) ? dataflowMutableObjects : this.RetrieveArtefacts(artefactSqlQuery, detail, query => this._artefactCommandBuilder.Build(query, allowedDataflows)); return(dataflows.GetOneOrNothing()); }
/// <summary> /// Returns the categorisations. /// </summary> /// <param name="maintainableRef"> /// The maintainable ref. /// </param> /// <param name="detail"> /// The detail. /// </param> /// <param name="sqlInfo"> /// The SQL info. /// </param> /// <param name="allowedDataflows"> /// The allowed dataflows. /// </param> /// <returns> /// The <see cref="ISet{ICategorisationMutableObject}"/>. /// </returns> private ISet <ICategorisationMutableObject> GetCategorisations( IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, SqlQueryInfo sqlInfo, IList <IMaintainableRefObject> allowedDataflows) { var artefactSqlQuery = new ArtefactSqlQuery(sqlInfo, maintainableRef); var dataflowCache = new Dictionary <long, IStructureReference>(); var categoryCache = new Dictionary <long, IStructureReference>(); this.RetrieveArtefactReference(dataflowCache, allowedDataflows); this.RetrieveCategoryReference(categoryCache); return(this.RetrieveArtefacts(artefactSqlQuery, detail, null, (o, l) => RetrieveReferences(o, l, l1 => GetReference(l1, dataflowCache), l1 => GetReference(l1, categoryCache)))); }
/// <summary> /// Retrieve the <see cref="IMaintainableMutableObject"/> with the latest version group by ID and AGENCY from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <returns> /// The <see cref="ISet{IMaintainableMutableObject}"/>. /// </returns> public override TMaintaible RetrieveLatest(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail) { var sqlQuery = new ArtefactSqlQuery(this.SqlQueryInfoForLatest, maintainableRef); var mutableObjects = this.RetrieveItemScheme(detail, sqlQuery); switch (mutableObjects.Count) { case 0: return(default(TMaintaible)); case 1: return(mutableObjects.First()); default: throw new ArgumentException(ErrorMessages.MoreThanOneArtefact, "maintainableRef"); } }
/// <summary> /// Retrieve the <see cref="ICodelistMutableObject"/> from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="subset"> /// The subset. /// </param> /// <returns> /// The <see cref="ISet{ICodelistMutableObject}"/>. /// </returns> public ISet <ICodelistMutableObject> Retrieve(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, IList <string> subset) { var sqlQuery = new ArtefactSqlQuery(this.SqlQueryInfoForAll, maintainableRef); Func <ICodelistMutableObject, long, ICodelistMutableObject> hashMethod = (itemSchemeBean, parentSysId) => this.FillCodesHash(itemSchemeBean, parentSysId, subset); Func <ICodelistMutableObject, long, ICodelistMutableObject> whereInMethod = (itemSchemeBean, parentSysId) => this.FillCodes(itemSchemeBean, parentSysId, subset); Func <ICodelistMutableObject, long, ICodelistMutableObject> selected = whereInMethod; switch (this.MappingStoreDb.ProviderName) { case MappingStoreDefaultConstants.SqlServerProvider: // SQL server performs very bad with 'IN' selected = hashMethod; break; case MappingStoreDefaultConstants.MySqlProvider: if (subset.Count > 2000) { selected = hashMethod; } break; case MappingStoreDefaultConstants.OracleProvider: case MappingStoreDefaultConstants.OracleProviderOdp: if (subset.Count > 4000) { selected = hashMethod; } break; default: if (subset.Count > 1000) { selected = hashMethod; } break; } return(this.RetrieveArtefacts(sqlQuery, detail, retrieveDetails: selected)); }
/// <summary> /// Retrieve the set of <see cref="IMaintainableMutableObject"/> from Mapping Store that references /// <paramref name="referencedStructure"/> /// . /// </summary> /// <param name="referencedStructure"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. This is the referenced structure. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="commandBuilder"> /// The command Builder. /// </param> /// <param name="retrieveDetails">The method that retrieves the details of the artefact.</param> /// <returns> /// The <see cref="ISet{IMaintainableMutableObject}"/>. /// </returns> protected ISet <T> RetrieveFromReferencedInternal(IStructureReference referencedStructure, ComplexStructureQueryDetailEnumType detail, Func <ArtefactSqlQuery, DbCommand> commandBuilder, Func <T, long, T> retrieveDetails) { if (referencedStructure == null) { throw new ArgumentNullException("referencedStructure"); } string innerJoin = this.GetReferencedFromInnerJoins(referencedStructure.MaintainableStructureEnumType.EnumType); ISet <T> mutableObjects; if (innerJoin != null) { SqlQueryInfo sqlQueryInfo = this._artefactParentsSqlBuilder.Build(innerJoin); var artefactSqlQuery = new ArtefactSqlQuery(sqlQueryInfo, referencedStructure.MaintainableReference); mutableObjects = this.RetrieveArtefacts(artefactSqlQuery, detail, commandBuilder, retrieveDetails); } else { mutableObjects = new HashSet <T>(); } return(mutableObjects); }
/// <summary> /// /// </summary> /// <param name="maintainableRef"></param> /// <param name="detail"></param> /// <param name="queryInfo"></param> /// <returns></returns> private ISet <IContentConstraintMutableObject> GetConstraintMutableObjects(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, SqlQueryInfo queryInfo) { var artefactSqlQuery = new ArtefactSqlQuery(queryInfo, maintainableRef); return(this.RetrieveArtefacts(artefactSqlQuery, detail)); }
/// <summary> /// Retrieve the common <see cref="IMaintainableMutableObject"/> information from Mapping Store ARTEFACT table. This method does not retrieve the Names and Description /// </summary> /// <param name="sqlQuery"> /// The SQL Query for artefacts /// </param> /// <param name="detail"> /// The structure query detail /// </param> /// <param name="commandBuilder"> /// The command Builder. /// </param> /// <param name="retrieveDetails"> /// The method to retrieve details of the artefacts /// </param> /// <param name="extraFields"> /// The extra Fields. /// </param> /// <returns> /// A dictionary with key the primary key in Mapping Store /// </returns> protected ISet <T> RetrieveArtefacts(ArtefactSqlQuery sqlQuery, ComplexStructureQueryDetailEnumType detail, Func <ArtefactSqlQuery, DbCommand> commandBuilder = null, Func <T, long, T> retrieveDetails = null, Action <T, IDataReader> extraFields = null) { commandBuilder = commandBuilder ?? this.CommandBuilder.Build; retrieveDetails = retrieveDetails ?? this.RetrieveDetails; var artefactPkPairs = new List <KeyValuePair <T, long> >(); using (DbCommand command = commandBuilder(sqlQuery)) { _log.InfoFormat(CultureInfo.InvariantCulture, "Executing Query: '{0}' with '{1}'", command.CommandText, sqlQuery.MaintainableRef); using (IDataReader dataReader = this._mappingStoreDb.ExecuteReader(command)) { int sysIdIdx = dataReader.GetOrdinal("SYSID"); int idIdx = dataReader.GetOrdinal("ID"); int version1Idx = dataReader.GetOrdinal("VERSION"); int agencyIdx = dataReader.GetOrdinal("AGENCY"); int validFromIdx = dataReader.GetOrdinal("VALID_FROM"); int validToIdx = dataReader.GetOrdinal("VALID_TO"); int isFinalIdx = dataReader.GetOrdinal("IS_FINAL"); int txtIdx = dataReader.GetOrdinal("TEXT"); int langIdx = dataReader.GetOrdinal("LANGUAGE"); int typeIdx = dataReader.GetOrdinal("TYPE"); var artefactMap = new Dictionary <long, T>(); while (dataReader.Read()) { long sysId = DataReaderHelper.GetInt64(dataReader, sysIdIdx); T artefact; if (!artefactMap.TryGetValue(sysId, out artefact)) { artefact = this.CreateArtefact(); artefact.FinalStructure = DataReaderHelper.GetTristate(dataReader, isFinalIdx); artefact.EndDate = DataReaderHelper.GetStringDate(dataReader, validToIdx); artefact.StartDate = DataReaderHelper.GetStringDate(dataReader, validFromIdx); artefact.Version = DataReaderHelper.GetString(dataReader, version1Idx); artefact.AgencyId = DataReaderHelper.GetString(dataReader, agencyIdx); artefact.Id = DataReaderHelper.GetString(dataReader, idIdx); this.HandleArtefactExtraFields(artefact, dataReader); if (extraFields != null) { extraFields(artefact, dataReader); } artefactPkPairs.Add(new KeyValuePair <T, long>(artefact, sysId)); artefactMap.Add(sysId, artefact); } if (!artefact.IsDefault()) { ReadLocalisedString(artefact, typeIdx, txtIdx, langIdx, dataReader, detail); } } } } if (artefactPkPairs.Count < 1) { _log.InfoFormat(CultureInfo.InvariantCulture, "No artefacts retrieved for : '{0}'", sqlQuery.MaintainableRef); return(new HashSet <T>()); } return(HandleDetailLevel(detail, retrieveDetails, artefactPkPairs)); }
/// <summary> /// Retrieve the <see cref="ICodelistMutableObject"/> from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="dataflowRef"> /// The dataflow Ref. /// </param> /// <param name="conceptId"> /// The concept Id. /// </param> /// <param name="isTranscoded"> /// The is Transcoded. /// </param> /// <param name="allowedDataflows">The allowed dataflows.</param> /// <returns> /// The <see cref="ISet{ICodelistMutableObject}"/>. /// </returns> public ISet <ICodelistMutableObject> Retrieve(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, IMaintainableRefObject dataflowRef, string conceptId, bool isTranscoded, IList <IMaintainableRefObject> allowedDataflows) { var sqlQuery = new ArtefactSqlQuery(this.SqlQueryInfoForAll, maintainableRef); return(this.RetrieveArtefacts(sqlQuery, detail, retrieveDetails: (o, l) => this.FillCodes(o, l, dataflowRef, conceptId, isTranscoded, allowedDataflows))); }
/// <summary> /// The retrieve item scheme. /// </summary> /// <param name="detail"> /// The detail. /// </param> /// <param name="sqlQuery"> /// The SQL query. /// </param> /// <returns> /// The <see cref="ISet{IItemSchemeObject}"/>. /// </returns> private ISet <TMaintaible> RetrieveItemScheme(ComplexStructureQueryDetailEnumType detail, ArtefactSqlQuery sqlQuery) { return(this.RetrieveArtefacts(sqlQuery, detail)); }
/// <summary> /// Retrieve the <see cref="IHierarchicalCodelistMutableObject"/> from Mapping Store. /// </summary> /// <param name="maintainableRef"> /// The maintainable reference which may contain ID, AGENCY ID and/or VERSION. /// </param> /// <param name="detail"> /// The <see cref="StructureQueryDetail"/> which controls if the output will include details or not. /// </param> /// <param name="queryInfo"> /// The query Info. /// </param> /// <returns> /// The <see cref="ISet{IHierarchicalCodelistMutableObject}"/>. /// </returns> private ISet <IHierarchicalCodelistMutableObject> HierarchicalCodelistMutableObjects(IMaintainableRefObject maintainableRef, ComplexStructureQueryDetailEnumType detail, SqlQueryInfo queryInfo) { var artefactSqlQuery = new ArtefactSqlQuery(queryInfo, maintainableRef); return(this.RetrieveArtefacts(artefactSqlQuery, detail)); }