public virtual IHierarchicalCodelistMutableObjectBase IGetHierarchicCodeListObjectBase(
				IMaintainableRefObject xref) {
			IHierarchicalCodelistObjectBase hclSuperBean = sdmxSuperBeanRetrievalManager
					.IGetHierarchicCodeListObjectBase(xref);
			if (hclSuperBean != null) {
				return new HierarchicalCodelistMutableObjectBaseCore(hclSuperBean);
			}
			return null;
		}

		public virtual ICategorySchemeObjectBase IGetCategorySchemeObjectBase(
				IMaintainableRefObject xref) {
			ISet<ICategorySchemeObjectBase> beans = IGetCategorySchemeObjectsBase(xref);
			if (!Org.Sdmxsource.Util.ObjectUtil.ValidCollection(beans)) {
				throw new ReferenceException(
						Org.Sdmxsource.Sdmx.Api.Constants.ExceptionCode.ReferenceErrorUnresolvable,
						Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CategoryScheme), xref);
			}
            return (ICategorySchemeObjectBase)Org.Sdmxsource.Sdmx.Util.Objects.SuperBeanRefUtil<ICategorySchemeObjectBase>.ResolveReference(
					beans, xref);
		}

		public virtual IRegistrationObject GetRegistration(IMaintainableRefObject xref) {
			ISet<IRegistrationObject> registrations0 = GetRegistrations(xref);
			if (!Org.Sdmxsource.Util.ObjectUtil.ValidCollection(registrations0)) {
				return null;
			}
			if (registrations0.Count > 1) {
				throw new ArgumentException(
						"More then one registration returned for reference (expected only one):"
								+ xref);
			}
			return (IRegistrationObject) ILOG.J2CsMapping.Collections.Generics.Collections.ToArray(registrations0)[0];
		}

        /// <summary>
        /// Create the WHERE clause from the <paramref name="maintainableRef"/>  and write it to <paramref name="sqlCommand"/>
        /// </summary>
        /// <param name="maintainableRef">
        /// The maintainable Ref.
        /// </param>
        /// <param name="sqlCommand">
        /// The output string buffer
        /// </param>
        /// <param name="whereState">
        /// the current state of the WHERE clause in <paramref name="sqlCommand"/>
        /// </param>
        /// <param name="allowedDataflows">
        /// The allowed Dataflows.
        /// </param>
        /// <returns>
        /// The list of <see cref="DbParameter"/>
        /// </returns>
        protected override IList<DbParameter> CreateArtefactWhereClause(IMaintainableRefObject maintainableRef, StringBuilder sqlCommand, WhereState whereState, IList<IMaintainableRefObject> allowedDataflows)
        {
            IList<DbParameter> parameters = this.CreateArtefactWhereClause(maintainableRef, sqlCommand, whereState);
            if (parameters.Count > 0)
            {
                whereState = WhereState.And;
            }

            if (this._filter == DataflowFilter.Production)
            {
                SqlHelper.AddWhereClause(sqlCommand, whereState, DataflowConstant.ProductionWhereClause);
                whereState = WhereState.And;
            }

            return SecurityHelper.AddWhereClauses(maintainableRef, this.MappingStoreDB, sqlCommand, parameters, allowedDataflows, whereState);
        }

		public virtual ISet<IStructureSetMutableObject> GetMutableStructureSetBeans(
				IMaintainableRefObject xref) {
			ISet<IStructureSetObject> beans = this.SdmxObjectRetrievalManager
					.GetStructureSetBeans(xref);
			ISet<IStructureSetMutableObject> returnSet = new HashSet<IStructureSetMutableObject>();
			/* foreach */
			foreach (IStructureSetObject bean  in  beans) {
				returnSet.Add(new StructureSetMutableCore(bean));
			}
			return returnSet;
		}

		public virtual ISet<IReportingTaxonomyMutableObject> GetMutableReportingTaxonomyBeans(
				IMaintainableRefObject xref) {
			ISet<IReportingTaxonomyObject> beans = this.SdmxObjectRetrievalManager
					.GetReportingTaxonomyBeans(xref);
			ISet<IReportingTaxonomyMutableObject> returnSet = new HashSet<IReportingTaxonomyMutableObject>();
			/* foreach */
			foreach (IReportingTaxonomyObject bean  in  beans) {
				returnSet.Add(new ReportingTaxonomyMutableCore(bean));
			}
			return returnSet;
		}

		public virtual ISet<IProcessMutableObject> GetMutableProcessBeanBeans(
				IMaintainableRefObject xref) {
			ISet<IProcessObject> beans = this.SdmxObjectRetrievalManager.GetProcessBeans(xref);
			ISet<IProcessMutableObject> returnSet = new HashSet<IProcessMutableObject>();
			/* foreach */
			foreach (IProcessObject bean  in  beans) {
				returnSet.Add(new ProcessMutableCore(bean));
			}
			return returnSet;
		}

		public virtual ISet<IOrganisationUnitSchemeMutableObject> GetMutableOrganisationUnitSchemeBeans(
				IMaintainableRefObject xref) {
			ISet<IOrganisationUnitSchemeObject> beans = this.SdmxObjectRetrievalManager
					.GetOrganisationUnitSchemeBeans(xref);
			ISet<IOrganisationUnitSchemeMutableObject> returnSet = new HashSet<IOrganisationUnitSchemeMutableObject>();
			/* foreach */
			foreach (IOrganisationUnitSchemeObject bean  in  beans) {
				returnSet.Add(bean.MutableInstance);
			}
			return returnSet;
		}

		public virtual ISet<IMetadataFlowMutableObject> GetMutableMetadataflowBeans(
				IMaintainableRefObject xref) {
			ISet<IMetadataFlow> beans = this.SdmxObjectRetrievalManager
					.GetMetadataflowBeans(xref);
			ISet<IMetadataFlowMutableObject> returnSet = new HashSet<IMetadataFlowMutableObject>();
			/* foreach */
			foreach (IMetadataFlow bean  in  beans) {
				returnSet.Add(new MetadataflowMutableCore(bean));
			}
			return returnSet;
		}

		public virtual ISet<IMetadataStructureDefinitionMutbale> GetMutableMetadataStructureBeans(
				IMaintainableRefObject xref) {
			ISet<IMetadataStructureDefinitionObject> beans = this.SdmxObjectRetrievalManager
					.GetMetadataStructureBeans(xref);
			ISet<IMetadataStructureDefinitionMutbale> returnSet = new HashSet<IMetadataStructureDefinitionMutbale>();
			/* foreach */
			foreach (IMetadataStructureDefinitionObject bean  in  beans) {
				returnSet.Add(new MetadataStructureDefinitionMutableCore(bean));
			}
			return returnSet;
		}

		public virtual ISet<ICategorisationMutableObject> GetMutableCategorisationBeans(
				IMaintainableRefObject xref) {
			ISet<ICategorisationObject> beans = this.SdmxObjectRetrievalManager
					.GetCategorisationBeans(xref);
			ISet<ICategorisationMutableObject> returnSet = new HashSet<ICategorisationMutableObject>();
			/* foreach */
			foreach (ICategorisationObject csBean  in  beans) {
				returnSet.Add(new CategorisationMutableCore(csBean));
			}
			return returnSet;
		}

		public virtual ICategorisationMutableObject GetMutableCategorisation(
				IMaintainableRefObject xref) {
			ICategorisationObject bean = this.SdmxObjectRetrievalManager
					.GetCategorisation(xref);
			return (bean == null) ? null : new CategorisationMutableCore(bean);
		}

		public virtual ISet<IDataProviderSchemeMutableObject> GetMutableDataProviderSchemeBeans(
				IMaintainableRefObject xref) {
			ISet<IDataProviderSchemeMutableObject> returnSet = new HashSet<IDataProviderSchemeMutableObject>();
			/* foreach */
			foreach (IDataProviderScheme currentBean  in  this.SdmxObjectRetrievalManager
					.GetDataProviderSchemeBeans(xref)) {
				returnSet.Add(currentBean.MutableInstance);
			}
			return returnSet;
		}

 /// <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>
        /// Get the Codes
        /// </summary>
        /// <param name="itemScheme">
        ///     The parent <see cref="ICodelistMutableObject"/>
        /// </param>
        /// <param name="parentSysId">
        ///     The parent ItemScheme primary key in Mapping Store
        /// </param>
        /// <param name="dataflowRef">
        ///     The dataflow Ref.
        /// </param>
        /// <param name="conceptId">
        ///     The concept Id.
        /// </param>
        /// <param name="isTranscoded">
        ///     Set to true if component is transcoded; otherwise false
        /// </param>
        /// <param name="allowedDataflows">The allowed dataflows.</param>
        /// <returns>
        /// The <see cref="ICodelistMutableObject"/>.
        /// </returns>
        private ICodelistMutableObject FillCodes(ICodelistMutableObject itemScheme, long parentSysId, IMaintainableRefObject dataflowRef, string conceptId, bool isTranscoded, IList<IMaintainableRefObject> allowedDataflows)
        {
            var allItems = new Dictionary<long, ICodeMutableObject>();
            var orderedItems = new List<KeyValuePair<long, ICodeMutableObject>>();
            var childItems = new Dictionary<long, long>();
            var sqlQuery = new PartialCodesSqlQuery(isTranscoded ? CodeListConstant.TranscodedSqlQueryInfo : CodeListConstant.LocalCodeSqlQueryInfo, parentSysId)
                               {
                                   ConceptId = conceptId, 
                                   DataflowReference = dataflowRef
                               };

            using (DbCommand command = this._partialCodesCommandBuilder.Build(sqlQuery, allowedDataflows))
            {
                this.ReadItems(allItems, orderedItems, command, childItems);
            }

            this.FillParentItems(itemScheme, childItems, allItems, orderedItems);

            return itemScheme;
        }

		public ISet<IContentConstraintMutableObject> GetMutableContentConstraintBeans(
				IMaintainableRefObject xref) {
			ISet<IContentConstraintObject> beans = this.SdmxObjectRetrievalManager
					.GetContentConstraints(xref);
			ISet<IContentConstraintMutableObject> returnSet = new HashSet<IContentConstraintMutableObject>();
			/* foreach */
			foreach (IContentConstraintObject bean  in  beans) {
				returnSet.Add(new ContentConstraintMutableCore(bean));
			}
			return returnSet;
		}

		public virtual IMetadataStructureDefinitionMutbale GetMutableMetadataStructure(
				IMaintainableRefObject xref) {
			IMetadataStructureDefinitionObject bean = this.SdmxObjectRetrievalManager
					.GetMetadataStructure(xref);
			return (bean == null) ? null
					: new MetadataStructureDefinitionMutableCore(bean);
		}

		public virtual IConceptSchemeMutableObject GetMutableConceptScheme(
				IMaintainableRefObject xref) {
			IConceptSchemeObject bean = this.SdmxObjectRetrievalManager.GetConceptScheme(xref);
			return (bean == null) ? null : new ConceptSchemeMutableCore(bean);
		}

		public virtual IMetadataFlowMutableObject GetMutableMetadataflow(
				IMaintainableRefObject xref) {
			IMetadataFlow bean = this.SdmxObjectRetrievalManager.GetMetadataflow(xref);
			return (bean == null) ? null : new MetadataflowMutableCore(bean);
		}

		public virtual ISet<IConceptSchemeMutableObject> GetMutableConceptSchemeBeans(
				IMaintainableRefObject xref) {
			ISet<IConceptSchemeObject> beans = this.SdmxObjectRetrievalManager
					.GetConceptSchemeBeans(xref);
			ISet<IConceptSchemeMutableObject> returnSet = new HashSet<IConceptSchemeMutableObject>();
			/* foreach */
			foreach (IConceptSchemeObject bean  in  beans) {
				returnSet.Add(new ConceptSchemeMutableCore(bean));
			}
			return returnSet;
		}