Examples with RegexpQuery org.apache.lucene.search.RegexpQuery used on opensource projects

Example 26 with RegexpQuery

use of org.apache.lucene.search.RegexpQuery in project lucene-solr by apache.

the class TestQPHelper method testRegexps.

public void testRegexps() throws Exception {
    StandardQueryParser qp = new StandardQueryParser();
    qp.setAnalyzer(new MockAnalyzer(random(), MockTokenizer.WHITESPACE, true));
    final String df = "field";
    RegexpQuery q = new RegexpQuery(new Term("field", "[a-z][123]"));
    assertEquals(q, qp.parse("/[a-z][123]/", df));
    assertEquals(q, qp.parse("/[A-Z][123]/", df));
    assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
    qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
    q.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
    assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
    assertEquals(MultiTermQuery.SCORING_BOOLEAN_REWRITE, ((RegexpQuery) (((BoostQuery) qp.parse("/[A-Z][123]/^0.5", df)).getQuery())).getRewriteMethod());
    qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
    Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
    assertEquals(escaped, qp.parse("/[a-z]\\/[123]/", df));
    Query escaped2 = new RegexpQuery(new Term("field", "[a-z]\\*[123]"));
    assertEquals(escaped2, qp.parse("/[a-z]\\*[123]/", df));
    BooleanQuery.Builder complex = new BooleanQuery.Builder();
    complex.add(new RegexpQuery(new Term("field", "[a-z]\\/[123]")), Occur.MUST);
    complex.add(new TermQuery(new Term("path", "/etc/init.d/")), Occur.MUST);
    complex.add(new TermQuery(new Term("field", "/etc/init[.]d/lucene/")), Occur.SHOULD);
    assertEquals(complex.build(), qp.parse("/[a-z]\\/[123]/ AND path:\"/etc/init.d/\" OR \"/etc\\/init\\[.\\]d/lucene/\" ", df));
    Query re = new RegexpQuery(new Term("field", "http.*"));
    assertEquals(re, qp.parse("field:/http.*/", df));
    assertEquals(re, qp.parse("/http.*/", df));
    re = new RegexpQuery(new Term("field", "http~0.5"));
    assertEquals(re, qp.parse("field:/http~0.5/", df));
    assertEquals(re, qp.parse("/http~0.5/", df));
    re = new RegexpQuery(new Term("field", "boo"));
    assertEquals(re, qp.parse("field:/boo/", df));
    assertEquals(re, qp.parse("/boo/", df));
    assertEquals(new TermQuery(new Term("field", "/boo/")), qp.parse("\"/boo/\"", df));
    assertEquals(new TermQuery(new Term("field", "/boo/")), qp.parse("\\/boo\\/", df));
    BooleanQuery.Builder two = new BooleanQuery.Builder();
    two.add(new RegexpQuery(new Term("field", "foo")), Occur.SHOULD);
    two.add(new RegexpQuery(new Term("field", "bar")), Occur.SHOULD);
    assertEquals(two.build(), qp.parse("field:/foo/ field:/bar/", df));
    assertEquals(two.build(), qp.parse("/foo/ /bar/", df));
}

Example 27 with RegexpQuery

use of org.apache.lucene.search.RegexpQuery in project lucene-solr by apache.

the class TestMultiFieldQueryParser method testSimpleRegex.

public void testSimpleRegex() throws ParseException {
    String[] fields = new String[] { "a", "b" };
    MultiFieldQueryParser mfqp = new MultiFieldQueryParser(fields, new MockAnalyzer(random()));
    BooleanQuery.Builder bq = new BooleanQuery.Builder();
    bq.add(new RegexpQuery(new Term("a", "[a-z][123]")), Occur.SHOULD);
    bq.add(new RegexpQuery(new Term("b", "[a-z][123]")), Occur.SHOULD);
    assertEquals(bq.build(), mfqp.parse("/[a-z][123]/"));
}

Example 28 with RegexpQuery

use of org.apache.lucene.search.RegexpQuery in project SearchServices by Alfresco.

the class Solr4QueryParser method newWildcardQuery.

/*
     * (non-Javadoc)
     * 
     * @see
     * org.apache.lucene.queryParser.QueryParser#newWildcardQuery(org.apache.
     * lucene.index.Term)
     */
@Override
protected Query newWildcardQuery(Term t) {
    if (t.text().equals("*")) {
        BooleanQuery.Builder bQuery = new BooleanQuery.Builder();
        bQuery.add(createTermQuery(FIELD_FIELDS, t.field()), Occur.SHOULD);
        bQuery.add(createTermQuery(FIELD_PROPERTIES, t.field()), Occur.SHOULD);
        return bQuery.build();
    } else if (t.text().contains("\\")) {
        String regexp = SearchLanguageConversion.convert(SearchLanguageConversion.DEF_LUCENE, SearchLanguageConversion.DEF_REGEX, t.text());
        return new RegexpQuery(new Term(t.field(), regexp));
    } else {
        org.apache.lucene.search.WildcardQuery query = new org.apache.lucene.search.WildcardQuery(t);
        query.setRewriteMethod(new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(topTermSpanRewriteLimit));
        return query;
    }
}

Example 29 with RegexpQuery

use of org.apache.lucene.search.RegexpQuery in project Krill by KorAP.

the class TestIndex method indexLucene.

@Test
public void indexLucene() throws Exception {
    // Base analyzer for searching and indexing
    StandardAnalyzer analyzer = new StandardAnalyzer();
    // Based on
    // http://lucene.apache.org/core/4_0_0/core/org/apache/lucene/
    // analysis/Analyzer.html?is-external=true
    // Create configuration with base analyzer
    IndexWriterConfig config = new IndexWriterConfig(analyzer);
    // Add a document 1 with the correct fields
    IndexWriter w = new IndexWriter(index, config);
    Collection docs = initIndexer();
    @SuppressWarnings("unchecked") Iterator<Map<String, String>> i = (Iterator<Map<String, String>>) docs.iterator();
    for (; i.hasNext(); ) {
        addDoc(w, i.next());
    }
    ;
    assertEquals(3, w.numDocs());
    w.close();
    // Check directory
    DirectoryReader reader = DirectoryReader.open(index);
    assertEquals(docs.size(), reader.maxDoc());
    assertEquals(docs.size(), reader.numDocs());
    // Check searcher
    IndexSearcher searcher = new IndexSearcher(reader);
    // textClass
    // All texts of text class "news"
    assertEquals(2, searcher.search(new TermQuery(new Term("textClass", "news")), 10).totalHits);
    // textClass
    // All texts of text class "sports"
    assertEquals(2, searcher.search(new TermQuery(new Term("textClass", "sports")), 10).totalHits);
    // TextIndex
    // All docs containing "l:nehmen"
    assertEquals(1, searcher.search(new TermQuery(new Term("text", "l:nehmen")), 10).totalHits);
    // TextIndex
    // All docs containing "s:den"
    assertEquals(2, searcher.search(new TermQuery(new Term("text", "s:den")), 10).totalHits);
    /*
        assertEquals(3,
              searcher.search(
                new TermQuery(
                  new Term("text", "T")
            ), 10
          ).totalHits
            );
        */
    // BooleanQuery
    // All docs containing "s:den" and "l:sie"
    TermQuery s_den = new TermQuery(new Term("text", "s:den"));
    TermQuery l_sie = new TermQuery(new Term("text", "l:sie"));
    BooleanQuery bool = new BooleanQuery();
    bool.add(s_den, BooleanClause.Occur.MUST);
    bool.add(l_sie, BooleanClause.Occur.MUST);
    assertEquals(1, searcher.search(bool, 10).totalHits);
    // BooleanQuery
    // All docs containing "s:den" or "l:sie"
    bool = new BooleanQuery();
    bool.add(s_den, BooleanClause.Occur.SHOULD);
    bool.add(l_sie, BooleanClause.Occur.SHOULD);
    assertEquals(2, searcher.search(bool, 10).totalHits);
    // RegexpQuery
    // All docs containing ".{4}en" (liefen und Hunden)
    RegexpQuery srquery = new RegexpQuery(new Term("text", "s:.{4}en"));
    assertEquals(2, searcher.search(srquery, 10).totalHits);
    // RegexpQuery
    // All docs containing "E." (Er) (2x)
    srquery = new RegexpQuery(new Term("text", "s:E."));
    assertEquals(2, searcher.search(srquery, 10).totalHits);
    SpanRegexQueryWrapper ssrquery = new SpanRegexQueryWrapper("text", "s:E.");
    assertEquals(2, searcher.search(ssrquery.toQuery(), 10).totalHits);
    // RegexpQuery
    // All docs containing "E." (er) (0x)
    srquery = new RegexpQuery(new Term("text", "s:e."));
    assertEquals(0, searcher.search(srquery, 10).totalHits);
    ssrquery = new SpanRegexQueryWrapper("text", "s:e.");
    assertEquals(0, searcher.search(ssrquery.toQuery(), 10).totalHits);
    // RegexpQuery
    // All docs containing "E."/i ([Ee]r) (2x)
    srquery = new RegexpQuery(new Term("text", "i:e."));
    assertEquals(2, searcher.search(srquery, 10).totalHits);
    ssrquery = new SpanRegexQueryWrapper("text", "s:e.", true);
    assertEquals("SpanMultiTermQueryWrapper(text:/i:e./)", ssrquery.toQuery().toString());
    assertEquals(2, searcher.search(ssrquery.toQuery(), 10).totalHits);
    // All docs containing "ng"/x (Angst) (2x)
    srquery = new RegexpQuery(new Term("text", "s:.*ng.*"));
    assertEquals(2, searcher.search(srquery, 10).totalHits);
    // Check http://comments.gmane.org/gmane.comp.jakarta.lucene.user/52283
    // for Carstens question on wildcards
    // Wildcardquery
    // All docs containing ".{4}en" (liefen und Hunden)
    WildcardQuery swquery = new WildcardQuery(new Term("text", "s:*ng*"));
    assertEquals("text:s:*ng*", swquery.toString());
    assertEquals(2, searcher.search(swquery, 10).totalHits);
    // [base=angst]
    SpanTermQuery stq = new SpanTermQuery(new Term("text", "l:angst"));
    assertEquals(2, searcher.search(srquery, 10).totalHits);
    // vor Angst
    // [orth=vor][orth=Angst]
    SpanNearQuery snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "s:vor")), new SpanTermQuery(new Term("text", "s:Angst")) }, 1, true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    // Spannearquery [p:VVFIN][]{,5}[m:nom:sg:fem]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:VVFIN")), new SpanSegmentQueryWrapper("text", "m:c:nom", "m:n:sg", "m:g:fem").toQuery() }, // slop
    5, // inOrder
    true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    // Spannearquery [p:VVFIN][m:acc:sg:masc]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:VVFIN")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "m:c:acc")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "m:n:sg")), new SpanTermQuery(new Term("text", "m:g:masc")) }, -1, false) }, // slop
    -1, // inOrder
    false) // new SpanTermQuery(new Term("text", "m:-acc:--sg:masc"))
    }, // slop
    0, // inOrder
    true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    // Spannearquery [p:VVFIN|m:3:sg:past:ind]
    // Exact match!
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:VVFIN")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "m:p:3")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "m:n:sg")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "m:t:past")), new SpanTermQuery(new Term("text", "m:m:ind")) }, -1, false) }, -1, false) }, -1, false) }, // slop
    -1, // inOrder
    false);
    assertEquals(2, searcher.search(snquery, 10).totalHits);
    // To make sure, this is not equal:
    // Spannearquery [p:VVFIN & m:3:sg:past:ind]
    // Exact match!
    // Maybe it IS equal
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:VVFIN")), new SpanTermQuery(new Term("text", "m:p:3")), new SpanTermQuery(new Term("text", "m:n:sg")), new SpanTermQuery(new Term("text", "m:t:past")), new SpanTermQuery(new Term("text", "m:m:ind")) }, // slop
    -1, // inOrder
    false);
    assertNotEquals(2, searcher.search(snquery, 10).totalHits);
    // assertEquals(2, searcher.search(snquery, 10).totalHits);
    // Spannearquery [p:VVFIN & m:3:sg & past:ind]
    SpanSegmentQueryWrapper sniquery = new SpanSegmentQueryWrapper("text", "p:VVFIN", "m:p:3", "m:n:sg", "m:t:past", "m:m:ind");
    assertEquals(2, searcher.search(sniquery.toQuery(), 10).totalHits);
    // Todo:
    /*
        sniquery = new SpanSegmentQuery(
              "text",
          "p:VVFIN",
          "m:p:3",
          "m:n:sg",
          "m:t:past",
          "m:m:ind"
            );
        */
    // Spannearquery [p:VVFIN][]{,5}[m:nom:sg:fem]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:VVFIN")), new SpanSegmentQueryWrapper("text", "m:c:nom", "m:n:sg", "m:g:fem").toQuery() }, // slop
    5, // inOrder
    true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    sniquery = new SpanSegmentQueryWrapper("text", "p:VVFIN", "m:p:3", "m:t:past", "m:m:ind", "m:n:sg");
    assertEquals(2, searcher.search(sniquery.toQuery(), 10).totalHits);
    // [p = VVFIN & m:p = 3 & m:t = past & m:n != pl] or
    // [p = VVFIN & m:p = 3 & m:t = past & !m:n = pl]
    // TODO: Problem: What should happen in case the category does not exist?
    // pssible solution: & ( m:n != pl & exists(m:n))
    sniquery = new SpanSegmentQueryWrapper("text", "p:VVFIN", "m:p:3", "m:t:past");
    SpanQuery snqquery = new SpanNotQuery(sniquery.toQuery(), new SpanTermQuery(new Term("text", "m:n:pl")));
    assertEquals(2, searcher.search(snqquery, 10).totalHits);
    // [p = NN & (m:c: = dat | m:c = acc)]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:NN")), new SpanOrQuery(new SpanTermQuery(new Term("text", "m:c:nom")), new SpanTermQuery(new Term("text", "m:c:acc"))) }, -1, false);
    assertEquals(2, searcher.search(snqquery, 10).totalHits);
    // [p = NN & !(m:c: = nom | m:c = acc)]
    snqquery = new SpanNotQuery(new SpanTermQuery(new Term("text", "p:NN")), new SpanOrQuery(new SpanTermQuery(new Term("text", "m:c:nom")), new SpanTermQuery(new Term("text", "m:c:acc"))));
    assertEquals(1, searcher.search(snqquery, 10).totalHits);
    // [p = NN & !(m:c = nom)]
    snqquery = new SpanNotQuery(new SpanTermQuery(new Term("text", "p:NN")), new SpanTermQuery(new Term("text", "m:c:nom")));
    assertEquals(3, searcher.search(snqquery, 10).totalHits);
    // [p=NN & !(m:c = acc)]
    snqquery = new SpanNotQuery(new SpanTermQuery(new Term("text", "p:NN")), new SpanTermQuery(new Term("text", "m:c:acc")));
    assertEquals(2, searcher.search(snqquery, 10).totalHits);
    // [p=PPER][][p=ART]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "p:PPER")), new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "T")), new SpanTermQuery(new Term("text", "p:ART")) }, 0, true) }, 0, true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    // Todo:
    // [orth=się][]{2,4}[base=bać]
    // [orth=się][orth!="[.!?,:]"]{,5}[base=bać]|[base=bać][base="on|ja|ty|my|wy"]?[orth=się]
    // [pos=subst & orth="a.*"]{2}
    // [tag=subst:sg:nom:n]
    // [case==acc & case==gen] ??
    // [case~acc & case~gen]
    // [case~~acc]
    // [base=bać][orth!=się]+[orth=się] within s
    // [][][p:VAFIN] within s
    // [][p:VAFIN] within s
    // [][][p:VAFIN]
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "T")), new SpanTermQuery(new Term("text", "T")) }, 0, true), new SpanTermQuery(new Term("text", "p:VAFIN")) }, 0, true);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    /*
        http://stackoverflow.com/questions/1311199/finding-the-position-of-search-hits-from-lucene
        */
    StringBuilder payloadString = new StringBuilder();
    Map<Term, TermContext> termContexts = new HashMap<>();
    for (LeafReaderContext atomic : reader.leaves()) {
        Bits bitset = atomic.reader().getLiveDocs();
        // Spans spans = NearSpansOrdered();
        Spans spans = snquery.getSpans(atomic, bitset, termContexts);
        while (spans.next()) {
            int docid = atomic.docBase + spans.doc();
            if (spans.isPayloadAvailable()) {
                for (byte[] payload : spans.getPayload()) {
                    /* retrieve payload for current matching span */
                    payloadString.append(new String(payload));
                    payloadString.append(" | ");
                }
                ;
            }
            ;
        }
        ;
    }
    ;
    // assertEquals(33, payloadString.length());
    assertEquals(0, payloadString.length());
    // [][][p:VAFIN]
    // without collecting payloads
    snquery = new SpanNearQuery(new SpanQuery[] { new SpanNearQuery(new SpanQuery[] { new SpanTermQuery(new Term("text", "T")), new SpanTermQuery(new Term("text", "T")) }, 0, true, false), new SpanTermQuery(new Term("text", "p:VAFIN")) }, 0, true, false);
    assertEquals(1, searcher.search(snquery, 10).totalHits);
    payloadString = new StringBuilder();
    termContexts = new HashMap<>();
    for (LeafReaderContext atomic : reader.leaves()) {
        Bits bitset = atomic.reader().getLiveDocs();
        // Spans spans = NearSpansOrdered();
        Spans spans = snquery.getSpans(atomic, bitset, termContexts);
        while (spans.next()) {
            int docid = atomic.docBase + spans.doc();
            for (byte[] payload : spans.getPayload()) {
                /* retrieve payload for current matching span */
                payloadString.append(new String(payload));
                payloadString.append(" | ");
            }
            ;
        }
        ;
    }
    ;
    assertEquals(0, payloadString.length());
    // [][][p:VAFIN] in s
    // ([e:s:<][]*[T] | [T & e:s:<]) [T] ([p:VAFIN & e:s:>] | [T][]*[e:s:>]
    /*
        
        SpanSegmentWithinQuery ssequery = new SpanSegmentWithinQuery(
            "text","s", new SpanSegmentSequenceQuery("text", "T", "T", "p:VAFIN")
            );
        assertEquals(0, searcher.search(ssequery.toQuery(), 10).totalHits);
        
        payloadString = new StringBuilder();
        termContexts = new HashMap<>();
        for (LeafReaderContext atomic : reader.leaves()) {
            Bits bitset = atomic.reader().getLiveDocs();
            // Spans spans = NearSpansOrdered();
            Spans spans = ssequery.toQuery().getSpans(atomic, bitset, termContexts);
        
            while (spans.next()) {
        	int docid = atomic.docBase + spans.doc();
        	for (byte[] payload : spans.getPayload()) {
        	/// retrieve payload for current matching span
        	    payloadString.append(new String(payload));
        	    payloadString.append(" | ");
        	};
            };
        };
        assertEquals(0, payloadString.length(), 1);
        
        ssequery = new SpanSegmentWithinQuery(
            "text","s", new SpanSegmentSequenceQuery("text", "T", "p:VAFIN")
            );
        
        assertEquals("for " + ssequery.toQuery(),
        	     1, searcher.search(ssequery.toQuery(), 10).totalHits);
        
        payloadString = new StringBuilder();
        termContexts = new HashMap<>();
        for (LeafReaderContext atomic : reader.leaves()) {
            Bits bitset = atomic.reader().getLiveDocs();
            // Spans spans = NearSpansOrdered();
            Spans spans = ssequery.toQuery().getSpans(atomic, bitset, termContexts);
        
            while (spans.next()) {
        	int docid = atomic.docBase + spans.doc();
        	for (byte[] payload : spans.getPayload()) {
        	    // retrieve payload for current matching span
        	    payloadString.append(new String(payload));
        	    payloadString.append(" | ");
        	};
        	fail("Doc: " + docid + " with " + spans.start() + "-" + spans.end() + " || " + payloadString.toString());
            };
        };
        assertEquals(20, payloadString.length());
        
        */
    // --------------------______>
    // Spans spans = MultiSpansWrapper.wrap(searcher.getTopReaderContext(), ssequery.toQuery());
    /*
        TopDocs topDocs = is.search(snq, 1);
        Set<String> payloadSet = new HashSet<String>();
        for (int i = 0; i < topDocs.scoreDocs.length; i++) {
          while (spans.next()) {
            Collection<byte[]> payloads = spans.getPayload();
        
            for (final byte [] payload : payloads) {
              payloadSet.add(new String(payload, "UTF-8"));
            }
          }
        }
        */
    /*
        Alternativ:
        IndexReader reader = writer.getReader();
        writer.close();
        IndexSearcher searcher = newSearcher(reader);
        
        PayloadSpanUtil psu = new PayloadSpanUtil(searcher.getTopReaderContext());
        
        Collection<byte[]> payloads = psu.getPayloadsForQuery(new TermQuery(new Term(PayloadHelper.FIELD, "rr")));
        if(VERBOSE)
          System.out.println("Num payloads:" + payloads.size());
        for (final byte [] bytes : payloads) {
          if(VERBOSE)
            System.out.println(new String(bytes, "UTF-8"));
        }
        */
    /* new: */
    // PayloadHelper helper = new PayloadHelper();
    // Map<Term, TermContext> termContexts = new HashMap<>();
    // Spans spans;
    // spans = snquery.getSpans(searcher.getIndexReader());
    // searcher = helper.setUp(similarity, 1000);
    /*
        IndexReader reader = search.getReader(querycontainer.getFoundry());
        Spans luceneSpans;
        Bits bitset = atomic.reader().getLiveDocs();
        for (byte[] payload : luceneSpans.getPayload())
        
        /* Iterate over all matching documents */
    /*
            while (luceneSpans.next() && total < config.getMaxhits()) {
        	Span matchSpan;
        	StringBuilder payloadString = new StringBuilder();
        	int docid = atomic.docBase + luceneSpans.doc();
        	String docname = search.retrieveDocname(docid,
        					querycontainer.getFoundry());
        					total++;
        
        	for (byte[] payload : luceneSpans.getPayload())
        */
    /* retrieve payload for current matching span */
    // payloadString.append(new String(payload));
    /* create span containing result */
    /*
        		matchSpan = new Span(docname);
        		matchSpan.setIndexdocid(docid);
        		matchSpan.setLayer(querycontainer.getLayer());
        		matchSpan.storePayloads(payloadString.toString());
        		matchSpans.add(matchSpan);
        */
    /*
         * topdocs = searcher.search(new ConstantScoreQuery(corpusQ add
         * position to list of positions to be considered for later
         * searches
         */
    /*
        validValues.put(docname,
        		matchSpan.getPayload(config.getPrefix()));
        }
        */
    // Todo: API made by add() typisiert für queries, strings
    // SpanPayloadCheckQuery for sentences!
    /* Support regular expression in SpanSegmentQuery */
    // new Regexp();
    // new Term();
    /*
          Vielleicht: spanSegmentQuery(new Term(), new Wildcard(), new Regex());
         */
    // And Not ->
    // SpanTermDiffQuery
    /*
        SpanNearQuery poquery = new SpanNearQuery(
        
        );
        */
    reader.close();
}

Example 30 with RegexpQuery

use of org.apache.lucene.search.RegexpQuery in project Krill by KorAP.

the class TestRegexIndex method testWildcardPlusRewritten.

@Test
public void testWildcardPlusRewritten() throws IOException {
    ki = new KrillIndex();
    ki.addDoc(createFieldDoc1());
    ki.commit();
    // C2 meine+ /+w1:2,s0 &Erfahrung
    // meine+ rewritten into meine.?
    SpanMultiTermQueryWrapper<RegexpQuery> mtq = new SpanMultiTermQueryWrapper<RegexpQuery>(new RegexpQuery(new Term("tokens", "s:meine.?")));
    SpanMultipleDistanceQuery mdsq = new SpanMultipleDistanceQuery(new SpanClassQuery(mtq, (byte) 129), new SpanClassQuery(sq, (byte) 129), constraints, true, true);
    kr = ki.search(mdsq, (short) 10);
    assertEquals(4, kr.getMatches().size());
}