示例#1
0
文件: BaseQuery.cs 项目: occ/NEST
 public static BaseQuery operator |(BaseQuery lbq, BaseQuery rbq)
 {
     var q = new BaseQuery();
     var bq = new BoolBaseQueryDescriptor();
     bq._ShouldQueries = new[] { lbq, rbq };
     q.BoolQueryDescriptor = bq;
     return q;
 }
示例#2
0
文件: BaseQuery.cs 项目: mivano/NEST
        public static BaseQuery operator !(BaseQuery lbq)
        {
            var q = new BaseQuery();
            var bq = new BoolBaseQueryDescriptor();
            bq._MustNotQueries = new[] { lbq };

            q.BoolQueryDescriptor = bq;
            return q;
        }
示例#3
0
        public static BaseQuery operator !(BaseQuery lbq)
        {
            if (lbq == null || lbq.IsConditionless)
                return new BaseQuery { IsConditionless = true };

            var q = new BaseQuery();
            var bq = new BoolBaseQueryDescriptor();
            bq._MustNotQueries = new[] { lbq };

            q.BoolQueryDescriptor = bq;
            return q;
        }
示例#4
0
文件: BaseQuery.cs 项目: occ/NEST
        public static BaseQuery operator &(BaseQuery lbq, BaseQuery rbq)
        {
            var q = new BaseQuery();
            var bq = new BoolBaseQueryDescriptor();

            bq._MustQueries = new[] { lbq, rbq };

            if (lbq.BoolQueryDescriptor.CanJoinMust()
                && rbq.BoolQueryDescriptor.CanJoinMust())
            {
                bq._MustQueries = lbq.MergeMustQueries(rbq);
            }

            q.BoolQueryDescriptor = bq;
            return q;
        }
示例#5
0
        /// <summary>
        /// AND's two BaseQueries
        /// </summary>
        /// <returns>A new basequery that represents the AND of the two</returns>
        public static BaseQuery operator &(BaseQuery leftQuery, BaseQuery rightQuery)
        {
            var defaultQuery = new BaseQuery() { IsConditionless = true };
            leftQuery = leftQuery ?? defaultQuery;
            rightQuery = rightQuery ?? defaultQuery;
            var combined = new[] { leftQuery, rightQuery };

            //if any of the queries is conditionless return the first one that is not
            //or return the defaultQuery
            if (combined.Any(bf => bf.IsConditionless))
                return combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultQuery;

            //return simple combination of the two if merging is not possible/necessary
            var noMergeQuery = CombineIfNoMergeIsNecessary(leftQuery, rightQuery, combined);
            if (noMergeQuery != null)
                return noMergeQuery;

            //if the left is a strict bool try to merge right on left first
            var joinStrictLeft = StrictSingleSideAndMerge(leftQuery, rightQuery);
            if (joinStrictLeft != null)
                return joinStrictLeft;

            // if the right side is a strict bool try to merge left on right
            var joinStrictRight = StrictSingleSideAndMerge(rightQuery, leftQuery);
            if (joinStrictRight != null)
                return joinStrictRight;

            // if the left side is a normal bool try to merge right on left
            var joinLeft = SingleSideAndMerge(leftQuery, rightQuery);
            if (joinLeft != null)
                return joinLeft;

            // if the right side is a normal bool try to merge lefft on right
            var joinRight = SingleSideAndMerge(rightQuery, leftQuery);
            return joinRight ?? defaultQuery;
        }
示例#6
0
文件: BaseQuery.cs 项目: mivano/NEST
        public static BaseQuery operator &(BaseQuery lbq, BaseQuery rbq)
        {
            var q = new BaseQuery();
            var bq = new BoolBaseQueryDescriptor();
            q.BoolQueryDescriptor = bq;

            if (lbq.BoolQueryDescriptor == null && rbq.BoolQueryDescriptor == null)
            {
                bq._MustQueries = new[] { lbq, rbq };
                return q;
            }
            if (lbq.BoolQueryDescriptor != null && rbq.BoolQueryDescriptor != null)
            {
                if (lbq.BoolQueryDescriptor._HasOnlyMustNot() && rbq.BoolQueryDescriptor._HasOnlyMustNot())
                {
                    bq._MustQueries = null;
                    bq._MustNotQueries = lbq.MergeMustNotQueries(rbq);
                }
                else if (lbq.BoolQueryDescriptor.CanJoinMust() && rbq.BoolQueryDescriptor.CanJoinMust())
                    bq._MustQueries = lbq.MergeMustQueries(rbq);
                else
                    bq._MustQueries = new[] { lbq, rbq };

                if (lbq.BoolQueryDescriptor.CanJoinMustNot() && rbq.BoolQueryDescriptor.CanJoinMustNot())
                    bq._MustNotQueries = lbq.MergeMustNotQueries(rbq);
                return q;
            }
            if (lbq.BoolQueryDescriptor != null)
            {
                if (lbq.BoolQueryDescriptor._HasOnlyMustNot())
                {
                    bq._MustNotQueries = lbq.BoolQueryDescriptor._MustNotQueries;
                    bq._MustQueries = new [] { rbq };
                    return q;
                }

                else if (lbq.BoolQueryDescriptor.CanJoinMust())
                    bq._MustQueries = lbq.MergeMustQueries(rbq);
                else
                    bq._MustQueries = new[] { lbq, rbq };

                if (lbq.BoolQueryDescriptor.CanJoinMustNot())
                    bq._MustNotQueries = lbq.MergeMustNotQueries(rbq);
                return q;
            }

            if (rbq.BoolQueryDescriptor._HasOnlyMustNot())
            {
                bq._MustNotQueries = rbq.BoolQueryDescriptor._MustNotQueries;
                bq._MustQueries = new[] { lbq };
                return q;
            }

            if (rbq.BoolQueryDescriptor.CanJoinMust())
                bq._MustQueries = rbq.MergeMustQueries(lbq);
            else
                bq._MustQueries = new[] { rbq, lbq };

            if (rbq.BoolQueryDescriptor.CanJoinMustNot())
                bq._MustNotQueries = rbq.MergeMustNotQueries(lbq);
            return q;
        }
示例#7
0
文件: BaseQuery.cs 项目: mivano/NEST
 private static void JoinShouldOnSide(BaseQuery lbq, BaseQuery rbq, BoolBaseQueryDescriptor bq)
 {
     bq._ShouldQueries = lbq.MergeShouldQueries(rbq);
 }
示例#8
0
文件: BaseQuery.cs 项目: mivano/NEST
        public static BaseQuery operator |(BaseQuery lbq, BaseQuery rbq)
        {
            var q = new BaseQuery();
            var bq = new BoolBaseQueryDescriptor();
            bq._ShouldQueries = new[] { lbq, rbq };
            q.BoolQueryDescriptor = bq;

            if (lbq.BoolQueryDescriptor == null && rbq.BoolQueryDescriptor == null)
            {
                bq._ShouldQueries = lbq.MergeShouldQueries(rbq);
                return q;
            }
            else if (lbq.BoolQueryDescriptor != null && rbq.BoolQueryDescriptor == null)
            {
                JoinShouldOnSide(lbq, rbq, bq);
            }
            else if (rbq.BoolQueryDescriptor != null && lbq.BoolQueryDescriptor == null)
            {
                JoinShouldOnSide(rbq, lbq, bq);
            }
            else
            {
                if (lbq.BoolQueryDescriptor.CanJoinShould() && rbq.BoolQueryDescriptor.CanJoinShould())
                    bq._ShouldQueries = lbq.MergeShouldQueries(rbq);
                else
                    bq._ShouldQueries = new [] {lbq, rbq};
            }

            return q;
        }
示例#9
0
 public static BaseQuery CreateReturnQuery(Action<BaseQuery, BoolBaseQueryDescriptor> modify = null)
 {
     var returnQuery = new BaseQuery();
     var returnBoolQuery = new BoolBaseQueryDescriptor() { };
     returnQuery.BoolQueryDescriptor = returnBoolQuery;
     if (modify != null)
     {
         modify(returnQuery, returnBoolQuery);
     }
     return returnQuery;
 }
示例#10
0
        private static BaseQuery StrictSingleSideAndMerge(BaseQuery targetQuery, BaseQuery mergeQuery)
        {
            //if the target is not strict return
            if (!targetQuery.IsStrict) return null;

            var mergeBoolQuery = mergeQuery.BoolQueryDescriptor;

            return CreateReturnQuery((returnQuery, returnBoolQuery) =>
            {
                if (mergeBoolQuery._MustNotQueries.HasAny())
                {
                    returnBoolQuery._MustNotQueries = mergeBoolQuery._MustNotQueries;
                    mergeBoolQuery._MustNotQueries = null;
                }

                returnBoolQuery._MustQueries = new[] { targetQuery }.Concat(mergeBoolQuery._MustQueries ?? Empty);
            });
        }
示例#11
0
        private static BaseQuery SingleSideAndMerge(BaseQuery targetQuery, BaseQuery mergeQuery)
        {
            var targetBoolQuery = targetQuery.BoolQueryDescriptor;
            var mergeBoolQuery = mergeQuery.BoolQueryDescriptor;

            if (targetBoolQuery == null) return null;

            var combined = new[] { targetQuery, mergeQuery };
            return CreateReturnQuery((returnQuery, returnBoolQuery) =>
            {
                if (!targetBoolQuery.CanMergeMustAndMustNots() || !mergeBoolQuery.CanMergeMustAndMustNots())
                {
                    returnBoolQuery._MustQueries = combined;
                    return;
                }

                returnBoolQuery._MustQueries = (targetBoolQuery._MustQueries ?? Empty)
                    .Concat(mergeBoolQuery != null
                        ? (mergeBoolQuery._MustQueries ?? Empty)
                        : new[] { mergeQuery })
                    .NullIfEmpty();
                returnBoolQuery._MustNotQueries = (targetBoolQuery._MustNotQueries ?? Empty)
                    .Concat(mergeBoolQuery != null
                        ? (mergeBoolQuery._MustNotQueries ?? Empty)
                        : Empty
                    ).NullIfEmpty();

            });
        }
示例#12
0
        private static BaseQuery CombineIfNoMergeIsNecessary(
			BaseQuery leftQuery,
			BaseQuery rightQuery,
			BaseQuery[] combined)
        {
            var leftBoolQuery = leftQuery.BoolQueryDescriptor;
            var rightBoolQuery = rightQuery.BoolQueryDescriptor;
            //if neither side is already a boolquery
            //  or if all boolqueries are strict.
            //  or if one side is strict and the other is null

            var mergeLeft = !leftQuery.IsStrict && (leftBoolQuery == null || leftBoolQuery._MinimumNumberShouldMatches == null);
            var mergeRight = !rightQuery.IsStrict && (rightBoolQuery == null || rightBoolQuery._MinimumNumberShouldMatches == null);

            //no merging is needed just return the combination
            if (
                (leftBoolQuery == null && rightBoolQuery == null)
                || (!mergeLeft && !mergeRight)
                || (leftQuery.IsStrict && rightBoolQuery == null)
                || (rightQuery.IsStrict && leftBoolQuery == null)
                )
            {
                return CreateReturnQuery((returnQuery, returnBoolQuery) => returnBoolQuery._MustQueries = combined);
            }
            return null;
        }
示例#13
0
        public static BaseQuery operator |(BaseQuery leftQuery, BaseQuery rightQuery)
        {
            var defaultQuery = new BaseQuery() { IsConditionless = true };
            leftQuery = leftQuery ?? defaultQuery;
            rightQuery = rightQuery ?? defaultQuery;
            var combined = new[] { leftQuery, rightQuery };

            if (combined.Any(bf => bf.IsConditionless))
                return combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultQuery;

            var leftBoolQuery = leftQuery.BoolQueryDescriptor;
            var rightBoolQuery = rightQuery.BoolQueryDescriptor;

            var f = new BaseQuery();
            var fq = new BoolBaseQueryDescriptor();
            fq._ShouldQueries = new[] { leftQuery, rightQuery };
            f.BoolQueryDescriptor = fq;

            var mergeLeft = !leftQuery.IsStrict && (leftBoolQuery == null || leftBoolQuery._MinimumNumberShouldMatches == null);
            var mergeRight = !rightQuery.IsStrict && (rightBoolQuery == null || rightBoolQuery._MinimumNumberShouldMatches == null);

            //if neither the left nor the right side represent a bool query join them
            if (leftQuery.BoolQueryDescriptor == null && rightQuery.BoolQueryDescriptor == null)
            {
                fq._ShouldQueries = leftQuery.MergeShouldQueries(rightQuery);
                return f;
            }
            //if the left or right sight already is a bool query join the non bool query side of the
            //of the operation onto the other.
            if (leftQuery.BoolQueryDescriptor != null
                && rightQuery.BoolQueryDescriptor == null
                && mergeLeft)
            {
                JoinShouldOnSide(leftQuery, rightQuery, fq);
            }
            else if (rightQuery.BoolQueryDescriptor != null
                && leftQuery.BoolQueryDescriptor == null
                && mergeRight)
            {
                JoinShouldOnSide(rightQuery, leftQuery, fq);
            }
            //both sides already represent a bool query
            else
            {
                //both sides report that we may merge the shoulds
                if (mergeLeft && mergeRight
                    && leftBoolQuery.CanJoinShould()
                    && rightBoolQuery.CanJoinShould())
                    fq._ShouldQueries = leftQuery.MergeShouldQueries(rightQuery);
                else
                    //create a new nested bool with two separate should bool sections
                    fq._ShouldQueries = new[] { leftQuery, rightQuery };
            }
            return f;
        }
示例#14
0
        private void DoValidSemiStrictBoolQueryStatic(BaseQuery query)
        {
            Assert.DoesNotThrow(() =>
            {
                var s = new SearchDescriptor<ElasticSearchProject>()
                    .From(0)
                    .Take(10)
                    .Query(query);

                this.JsonNotEquals(s, System.Reflection.MethodInfo.GetCurrentMethod(), "MatchAll");
            });
        }