Пример #1
0
 private static void AddExceptionsForAggregateQueries(
     QueryInfo queryInfo,
     QueryFeatures supportedQueryFeatures,
     Lazy <List <Exception> > exceptions)
 {
     if (queryInfo.HasAggregates)
     {
         if (queryInfo.Aggregates.Length == 1)
         {
             // Single aggregate must be a composite or just a VALUE <Aggregate>
             if (queryInfo.HasSelectValue)
             {
                 if (!supportedQueryFeatures.HasFlag(QueryFeatures.Aggregate))
                 {
                     exceptions.Value.Add(QueryContainsUnsupportedAggregates);
                 }
             }
             else
             {
                 if (!supportedQueryFeatures.HasFlag(QueryFeatures.CompositeAggregate))
                 {
                     exceptions.Value.Add(QueryContainsUnsupportedCompositeAggregate);
                 }
             }
         }
         else
         {
             if (!supportedQueryFeatures.HasFlag(QueryFeatures.MultipleAggregates))
             {
                 exceptions.Value.Add(QueryContainsUnsupportedMultipleAggregates);
             }
         }
     }
 }
Пример #2
0
            private static QueryFeatures GetNeededQueryFeaturesIfOrderByQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasOrderBy)
                {
                    if (queryInfo.OrderByExpressions.Length == 1)
                    {
                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.OrderBy))
                        {
                            neededQueryFeatures |= QueryFeatures.OrderBy;
                        }
                    }
                    else
                    {
                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.MultipleOrderBy))
                        {
                            neededQueryFeatures |= QueryFeatures.MultipleOrderBy;
                        }
                    }
                }

                return(neededQueryFeatures);
            }
Пример #3
0
            private static QueryFeatures GetNeededQueryFeaturesIfAggregateQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasAggregates)
                {
                    bool isSingleAggregate = (queryInfo.Aggregates.Length == 1) ||
                                             (queryInfo.GroupByAliasToAggregateType.Values.Where(aggregateOperator => aggregateOperator.HasValue).Count() == 1);
                    if (isSingleAggregate)
                    {
                        if (queryInfo.HasSelectValue)
                        {
                            if (!supportedQueryFeatures.HasFlag(QueryFeatures.Aggregate))
                            {
                                neededQueryFeatures |= QueryFeatures.Aggregate;
                            }
                        }
                        else
                        {
                            if (!supportedQueryFeatures.HasFlag(QueryFeatures.NonValueAggregate))
                            {
                                neededQueryFeatures |= QueryFeatures.NonValueAggregate;
                            }
                        }
                    }
                    else
                    {
                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.NonValueAggregate))
                        {
                            neededQueryFeatures |= QueryFeatures.NonValueAggregate;
                        }

                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.MultipleAggregates))
                        {
                            neededQueryFeatures |= QueryFeatures.MultipleAggregates;
                        }
                    }
                }

                return(neededQueryFeatures);
            }
Пример #4
0
            private static void AddExceptionsForAggregateQueries(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures,
                Lazy <List <Exception> > exceptions)
            {
                if (queryInfo.HasAggregates)
                {
                    bool isSingleAggregate = (queryInfo.Aggregates.Length == 1) ||
                                             (queryInfo.GroupByAliasToAggregateType.Values.Where(aggregateOperator => aggregateOperator.HasValue).Count() == 1);
                    if (isSingleAggregate)
                    {
                        if (queryInfo.HasSelectValue)
                        {
                            if (!supportedQueryFeatures.HasFlag(QueryFeatures.Aggregate))
                            {
                                exceptions.Value.Add(QueryContainsUnsupportedAggregates);
                            }
                        }
                        else
                        {
                            if (!supportedQueryFeatures.HasFlag(QueryFeatures.NonValueAggregate))
                            {
                                exceptions.Value.Add(QueryContainsUnsupportedNonValueAggregate);
                            }
                        }
                    }
                    else
                    {
                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.NonValueAggregate))
                        {
                            exceptions.Value.Add(QueryContainsUnsupportedNonValueAggregate);
                        }

                        if (!supportedQueryFeatures.HasFlag(QueryFeatures.MultipleAggregates))
                        {
                            exceptions.Value.Add(QueryContainsUnsupportedMultipleAggregates);
                        }
                    }
                }
            }
Пример #5
0
 private static void AddExceptionsForTopQueries(
     QueryInfo queryInfo,
     QueryFeatures supportedQueryFeatures,
     Lazy <List <Exception> > exceptions)
 {
     if (queryInfo.HasTop)
     {
         if (!supportedQueryFeatures.HasFlag(QueryFeatures.Top))
         {
             exceptions.Value.Add(QueryContainsUnsupportedTop);
         }
     }
 }
Пример #6
0
 private static void AddExceptionsForOffsetLimitQueries(
     QueryInfo queryInfo,
     QueryFeatures supportedQueryFeatures,
     Lazy <List <Exception> > exceptions)
 {
     if (queryInfo.HasLimit || queryInfo.HasOffset)
     {
         if (!supportedQueryFeatures.HasFlag(QueryFeatures.OffsetAndLimit))
         {
             exceptions.Value.Add(QueryContainsUnsupportedOffsetAndLimit);
         }
     }
 }
Пример #7
0
 private static void AddExceptionsForOrderByQueries(
     QueryInfo queryInfo,
     QueryFeatures supportedQueryFeatures,
     Lazy <List <Exception> > exceptions)
 {
     if (queryInfo.HasOrderBy)
     {
         if (queryInfo.OrderByExpressions.Length == 1)
         {
             if (!supportedQueryFeatures.HasFlag(QueryFeatures.OrderBy))
             {
                 exceptions.Value.Add(QueryContainsUnsupportedOrderBy);
             }
         }
         else
         {
             if (!supportedQueryFeatures.HasFlag(QueryFeatures.MultipleOrderBy))
             {
                 exceptions.Value.Add(QueryContainsUnsupportedMultipleOrderBy);
             }
         }
     }
 }
Пример #8
0
            private static QueryFeatures GetNeedQueryFeaturesIfGroupByQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasGroupBy)
                {
                    if (!supportedQueryFeatures.HasFlag(QueryFeatures.GroupBy))
                    {
                        neededQueryFeatures |= QueryFeatures.GroupBy;
                    }
                }

                return(neededQueryFeatures);
            }
Пример #9
0
            private static QueryFeatures GetNeededQueryFeaturesIfOffsetLimitQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasLimit || queryInfo.HasOffset)
                {
                    if (!supportedQueryFeatures.HasFlag(QueryFeatures.OffsetAndLimit))
                    {
                        neededQueryFeatures |= QueryFeatures.OffsetAndLimit;
                    }
                }

                return(neededQueryFeatures);
            }
Пример #10
0
            private static QueryFeatures GetNeededQueryFeaturesIfTopQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasTop)
                {
                    if (!supportedQueryFeatures.HasFlag(QueryFeatures.Top))
                    {
                        neededQueryFeatures |= QueryFeatures.Top;
                    }
                }

                return(neededQueryFeatures);
            }
Пример #11
0
            private static QueryFeatures GetNeededQueryFeaturesIfDistinctQuery(
                QueryInfo queryInfo,
                QueryFeatures supportedQueryFeatures)
            {
                QueryFeatures neededQueryFeatures = QueryFeatures.None;

                if (queryInfo.HasDistinct)
                {
                    if (!supportedQueryFeatures.HasFlag(QueryFeatures.Distinct))
                    {
                        neededQueryFeatures |= QueryFeatures.Distinct;
                    }
                }

                return(neededQueryFeatures);
            }