コード例 #1
0
 /// <summary>
 /// Create a DataQuery instance.
 /// </summary>
 /// <param name='type'>Type of data query.</param>
 public DataQuery(DataQueryType type)
 {
     _type = type;
 }
        /// <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>
        /// Build complex data queries from the specified <paramref name="dataQueryType"/>
        /// </summary>
        /// <param name="dataQueryType">
        /// The data query type.
        /// </param>
        /// <param name="structureRetrievalManager">
        /// The structure retrieval manager.
        /// </param>
        /// <returns>
        /// The list of complex data query from the specified <paramref name="dataQueryType"/>
        /// </returns>
        public IList<IComplexDataQuery> BuildComplexDataQuery(DataQueryType dataQueryType, ISdmxObjectRetrievalManager structureRetrievalManager)
        {
            if (structureRetrievalManager == null)
            {
                throw new SystemException("ComplexDataQueryBuilder expectes a ISdmxObjectRetrievalManager");
            }

            IList<IComplexDataQuery> returnList = new List<IComplexDataQuery>();
            DataReturnDetailsType returnDetails = dataQueryType.ReturnDetails;
            DataParametersAndType dataWhere = dataQueryType.DataWhere;

            /**process the DataReturnDetailsType*/
            DataQueryDetail queryDetail = GetReturnDetailsDetail(returnDetails);
            int? firstNObs = GetReturnDetailsFirstNobs(returnDetails);
            int? lastNObs = GetReturnDetailsLastNobs(returnDetails);
            int defaultLimit = GetReturnDetailsDefaultLimit(returnDetails);
            ObservationAction obsAction = GetReturnDetailsObsAction(returnDetails);
            IList<object> structureReferenceDetails = GetStructureRefDetails(returnDetails);
            string dimensionAtObservation = (structureReferenceDetails != null) ? (string)structureReferenceDetails[0] : null;
            bool hasExplicitMeasures = (structureReferenceDetails != null && structureReferenceDetails.Count > 1) ? (bool)structureReferenceDetails[1] : false;
            /**process the DataParametersAndType*/
            //Get the Data Providers
            ISet<IDataProvider> dataProviders = GetDataWhereDataProviders(dataWhere, structureRetrievalManager);
            //Get the DatasetId
            string[] datasetArray = GetDataWhereDatasetId(dataWhere);
            string datasetId = (datasetArray != null) ? datasetArray[0] : null;
            TextSearch datasetIdOper = (datasetArray != null) ? TextSearch.ParseString(datasetArray[1]) : null;
            //Get the DataFlow
            IDataflowObject dataFlow = GetDataWhereDataFlow(dataWhere, structureRetrievalManager);
            //Get the Data Structure Definition
            IDataStructureObject dataStructure = GetDataWhereDataStrucuture(dataWhere, structureRetrievalManager, dataFlow);
            //Get the Provision Agreement
            IProvisionAgreementObject provisionAgreement = GetProvisionAgreement(dataWhere, structureRetrievalManager);
            //Get the Updated dates
            IList<ITimeRange> updatedDates = GetDataWhereUpdatedDates(dataWhere);
            //Get the ComplexDataQueryGoups
            ISet<IComplexDataQuerySelectionGroup> complexDataQuerySelectionGroups = BuildComplexDataQueryGroups(dataWhere, structureRetrievalManager, dataProviders);
            //Build the complex Query
            IComplexDataQuery complexQuery = new ComplexDataQueryImpl(datasetId, datasetIdOper, dataProviders, dataStructure, dataFlow, provisionAgreement, updatedDates, firstNObs, lastNObs, defaultLimit, obsAction, dimensionAtObservation, hasExplicitMeasures, queryDetail, complexDataQuerySelectionGroups);
            returnList.Add(complexQuery);
            return returnList;
        }
コード例 #4
0
        private static string GetCondition(DataQueryType dataQueryType, object propertyValue, string columnName, Operator optr)
        {
            if (propertyValue == null)
            {
                return(string.Empty);
            }

            if (optr == Operator.In)
            {
                #region In
                if (propertyValue is IList <long> )
                {
                    return(string.Format("{0} IN ({1})", columnName, GetSqlInConditions((IEnumerable <long>)propertyValue)));
                }
                else if (propertyValue is IList <int> )
                {
                    return(string.Format("{0} IN ({1})", columnName, GetSqlInConditions((IEnumerable <int>)propertyValue)));
                }
                else if (propertyValue is IList <string> )
                {
                    return(string.Format("{0} IN ({1})", columnName, GetSqlInConditions((IEnumerable <string>)propertyValue)));
                }
                else
                {
                    return(string.Empty);
                }
                #endregion
            }

            if (optr == Operator.NotIn)
            {
                #region Not In
                if (propertyValue is IList <long> )
                {
                    return(string.Format("{0} Not IN ({1})", columnName, GetSqlInConditions((IEnumerable <long>)propertyValue)));
                }
                else if (propertyValue is IList <int> )
                {
                    return(string.Format("{0} Not IN ({1})", columnName, GetSqlInConditions((IEnumerable <int>)propertyValue)));
                }
                else if (propertyValue is IList <string> )
                {
                    return(string.Format("{0} Not IN ({1})", columnName, GetSqlInConditions((IEnumerable <string>)propertyValue)));
                }
                else
                {
                    return(string.Empty);
                }
                #endregion
            }

            if (dataQueryType == DataQueryType.String)
            {
                #region
                string value = (string)propertyValue;
                value = value.Replace(@"\", @"\\");
                if (string.IsNullOrEmpty(value))
                {
                    return(string.Empty);
                }
                switch (optr)
                {
                case Operator.Eq:
                    return(string.Format("{0}='{1}'", columnName, value));

                case Operator.NotEq:
                    return(string.Format("{0}!='{1}'", columnName, value));

                case Operator.Like:
                    return(string.Format("{0} like '%{1}%'", columnName, value));

                case Operator.LeftLike:
                    return(string.Format("{0} like '{1}%'", columnName, value));

                case Operator.RightLike:
                    return(string.Format("{0} like '%{1}'", columnName, value));

                default:
                    throw new Exception(string.Format("当属性类型是string时,操作符{0}无效", optr));
                }
                #endregion
            }
            else if (dataQueryType == DataQueryType.DateTime)
            {
                #region
                DateTime value = (DateTime)propertyValue;
                if (value == DateTime.MinValue)
                {
                    return(string.Empty);
                }
                switch (optr)
                {
                case Operator.Eq:
                    return(string.Format("{0}='{1}'", columnName, value.ToString(_DateTimeFormat)));

                case Operator.NotEq:
                    return(string.Format("{0}!='{1}'", columnName, value.ToString(_DateTimeFormat)));

                case Operator.Gt:
                    return(string.Format("{0}>'{1}'", columnName, value.ToString(_DateTimeFormat)));

                case Operator.Ge:
                    return(string.Format("{0}>='{1}'", columnName, value.ToString(_DateTimeFormat)));

                case Operator.Lt:
                    return(string.Format("{0}<'{1}'", columnName, value.ToString(_DateTimeFormat)));

                case Operator.Le:
                    return(string.Format("{0}<='{1}'", columnName, value.ToString(_DateTimeFormat)));

                default:
                    throw new Exception(string.Format("当属性类型是DateTime时,操作符{0}无效", optr));
                }

                #endregion
            }
            else if (dataQueryType == DataQueryType.Number)
            {
                #region
                switch (optr)
                {
                case Operator.Eq:
                    return(string.Format("{0}={1}", columnName, propertyValue.ToString()));

                case Operator.NotEq:
                    return(string.Format("{0}!={1}", columnName, propertyValue.ToString()));

                case Operator.Gt:
                    return(string.Format("{0}>{1}", columnName, propertyValue.ToString()));

                case Operator.Ge:
                    return(string.Format("{0}>={1}", columnName, propertyValue.ToString()));

                case Operator.Lt:
                    return(string.Format("{0}<{1}", columnName, propertyValue.ToString()));

                case Operator.Le:
                    return(string.Format("{0}<={1}", columnName, propertyValue.ToString()));

                default:
                    throw new Exception(string.Format("当属性类型是整数时,操作符{0}无效", optr));
                }

                #endregion
            }
            else if (dataQueryType == DataQueryType.Enum)
            {
                #region
                if (EnumMetaDataCacheManager.GetEnumStorageType(propertyValue.GetType()) == EnumStorageType.EnumName)
                {
                    string value = propertyValue.ToString();
                    switch (optr)
                    {
                    case Operator.Eq:
                        return(string.Format("{0}='{1}'", columnName, value));

                    case Operator.NotEq:
                        return(string.Format("{0}!='{1}'", columnName, value));

                    default:
                        throw new Exception(string.Format("当属性类型是枚举时,操作符{0}无效", optr));
                    }
                }
                else
                {
                    int value = (int)propertyValue;
                    switch (optr)
                    {
                    case Operator.Eq:
                        return(string.Format("{0}={1}", columnName, value));

                    case Operator.NotEq:
                        return(string.Format("{0}!={1}", columnName, value));

                    default:
                        throw new Exception(string.Format("当属性类型是枚举时,操作符{0}无效", optr));
                    }
                }
                #endregion
            }
            else
            {
                throw new Exception(string.Format("查询条件的属性类型{0}无效", dataQueryType));
            }
        }