Пример #1
0
        public string Visit_WithValidBoolQuery_ReturnsSuccess()
        {
            var luceneNetBoolQuery = new Lucene.Net.Search.BooleanQuery();

            luceneNetBoolQuery.Clauses.Add(
                new Lucene.Net.Search.BooleanClause(
                    new Lucene.Net.Search.WildcardQuery(
                        new Lucene.Net.Index.Term("*", "Lo*d?n")),
                    Lucene.Net.Search.Occur.MUST_NOT));

            var boolQuery = new LuceneBoolQuery
            {
                LuceneQuery = luceneNetBoolQuery,
            };

            var luceneVisitor = new LuceneVisitor();

            luceneVisitor.Visit(boolQuery);

            var es = boolQuery.ESQuery;

            Assert.NotNull(es);

            var visitor = new ElasticSearchDSLVisitor(SchemaRetrieverMock.CreateMockSchemaRetriever());

            visitor.Visit((BoolQuery)es);

            return(((BoolQuery)es).KustoQL);
        }
Пример #2
0
        public void Visit_WithInvalidBoolQuery_ThrowsException()
        {
            var boolQuery = new LuceneBoolQuery
            {
                LuceneQuery = null,
            };
            var visitor = new LuceneVisitor();

            Assert.That(
                () => visitor.Visit(boolQuery),
                Throws.TypeOf <IllegalClauseException>());
        }
Пример #3
0
        /// <inheritdoc/>
        public void Visit(LuceneBoolQuery boolQueryWrapper)
        {
            VerifyValid(boolQueryWrapper);

            var boolClause = new BoolQuery();
            var must       = new List <IQuery>();
            var should     = new List <IQuery>();
            var mustNot    = new List <IQuery>();
            var clauses    = ((BooleanQuery)boolQueryWrapper.LuceneQuery).GetClauses();

            foreach (BooleanClause clause in clauses)
            {
                // based on the the current clause, instansiate the correct Lucene Query object
                var luceneQuery =
                    VisitableLuceneQueryFactory.Make(clause.Query);
                luceneQuery.Accept(this);
                switch (clause.Occur)
                {
                case Occur.MUST:
                    must.Add(luceneQuery.ESQuery);
                    break;

                case Occur.SHOULD:
                    should.Add(luceneQuery.ESQuery);
                    break;

                case Occur.MUST_NOT:
                    mustNot.Add(luceneQuery.ESQuery);
                    break;
                }
            }

            boolClause.Must          = must;
            boolClause.Should        = should;
            boolClause.MustNot       = mustNot;
            boolQueryWrapper.ESQuery = boolClause;
        }