import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
public static String getSimilarityQuery(String searchPattern, Integer maxEditDistance, Operator operator) {
	if (maxEditDistance == null) {
		throw new IllegalArgumentException("maxEditDistance may not be null");
	}
	
	String cleanSearchPattern = StringUtils.clean(searchPattern);
	
	if (!StringUtils.hasText(cleanSearchPattern)) {
		throw new IllegalArgumentException("cleanSearchPattern may not be empty");
	}
	
	List<String> searchPatternFragments = getSearchPatternFragments(cleanSearchPattern);
	
	StringBuilder similarityQuery = new StringBuilder();
	for (String searchPatternFragment : searchPatternFragments) {
		if (similarityQuery.length() > 0) {
			similarityQuery.append(" ");
			if (operator != null) {
				similarityQuery.append(operator).append(" ");
			}
		}
		similarityQuery.append(searchPatternFragment).append(FUZZY_PARAMETER_SUFFIX).append(maxEditDistance.toString());
	}
	
	return similarityQuery.toString().trim();
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Test
public void testGetAutocompleteQuery() {
	assertEquals(null, LuceneUtils.getAutocompleteQuery(null));
	assertEquals("", LuceneUtils.getAutocompleteQuery(""));
	
	assertEquals("alfresc*", LuceneUtils.getAutocompleteQuery("alfresc"));
	assertEquals("alfresc*", LuceneUtils.getAutocompleteQuery("alfresc*"));
	assertEquals("alfresco sha*", LuceneUtils.getAutocompleteQuery("alfresco-sha"));
	assertEquals("alfresco sha1*", LuceneUtils.getAutocompleteQuery("alfresco-sha1"));
	assertEquals("alfresco sha1*", LuceneUtils.getAutocompleteQuery("alfresco sha1"));
	assertEquals("t es t*", LuceneUtils.getAutocompleteQuery("t' -_es**t"));
	
	assertEquals("alfresc*", LuceneUtils.getAutocompleteQuery("alfresc", Operator.AND));
	assertEquals("alfresc*", LuceneUtils.getAutocompleteQuery("alfresc*", Operator.AND));
	assertEquals("alfresco AND sha*", LuceneUtils.getAutocompleteQuery("alfresco-sha", Operator.AND));
	assertEquals("alfresco AND sha1*", LuceneUtils.getAutocompleteQuery("alfresco-sha1", Operator.AND));
	assertEquals("alfresco AND sha1*", LuceneUtils.getAutocompleteQuery("alfresco sha1", Operator.AND));
	assertEquals("t AND es AND t*", LuceneUtils.getAutocompleteQuery("t' -_es**t", Operator.AND));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** more complex synonyms with default AND operator */
public void testCJKSynonymsAND2() throws Exception {
  BooleanQuery expected = new BooleanQuery();
  expected.add(new TermQuery(new Term("field", "中")), BooleanClause.Occur.MUST);
  BooleanQuery inner = new BooleanQuery(true);
  inner.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  inner.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  expected.add(inner, BooleanClause.Occur.MUST);
  BooleanQuery inner2 = new BooleanQuery(true);
  inner2.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  inner2.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  expected.add(inner2, BooleanClause.Occur.MUST);
  QueryParser qp = new QueryParser("field", new MockCJKSynonymAnalyzer());
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("中国国"));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("中国国^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Test
public void makeSureCompositeQueriesCanBeAsked()
{
    Index<Node> index = nodeIndex( LuceneIndexImplementation.EXACT_CONFIG );
    Node neo = graphDb.createNode();
    Node trinity = graphDb.createNode();
    index.add( neo, "username", "[email protected]" );
    index.add( neo, "sex", "male" );
    index.add( trinity, "username", "[email protected]" );
    index.add( trinity, "sex", "female" );

    for ( int i = 0; i < 2; i++ )
    {
        assertThat( index.query( "username:*@matrix AND sex:male" ), contains( neo ) );
        assertThat( index.query( new QueryContext( "username:*@matrix sex:male" ).defaultOperator( Operator.AND ) ), contains( neo ) );
        assertThat( index.query( "username:*@matrix OR sex:male" ), contains( neo, trinity ) );
        assertThat( index.query( new QueryContext( "username:*@matrix sex:male" ).defaultOperator( Operator.OR ) ), contains( neo, trinity ) );

        restartTx();
    }
    index.delete();
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** more complex synonyms with default AND operator */
public void testCJKSynonymsAND2() throws Exception {
  BooleanQuery expected = new BooleanQuery();
  expected.add(new TermQuery(new Term("field", "中")), BooleanClause.Occur.MUST);
  BooleanQuery inner = new BooleanQuery(true);
  inner.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  inner.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  expected.add(inner, BooleanClause.Occur.MUST);
  BooleanQuery inner2 = new BooleanQuery(true);
  inner2.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  inner2.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  expected.add(inner2, BooleanClause.Occur.MUST);
  QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, "field", new MockCJKSynonymAnalyzer());
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("中国国"));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("中国国^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
public static String getAutocompleteQuery(String searchPattern, int enableWildcardMinChars, Operator operator) {
	String cleanSearchPattern = StringUtils.clean(searchPattern);
	
	if(StringUtils.hasText(cleanSearchPattern) && cleanSearchPattern.length() >= enableWildcardMinChars) {
		List<String> searchPatternFragments = getSearchPatternFragments(cleanSearchPattern);
		
		StringBuilder autocompleteQuery = new StringBuilder();
		Iterator<String> searchPatternFragmentsIt = searchPatternFragments.iterator();
		
		while (searchPatternFragmentsIt.hasNext()) {
			if (autocompleteQuery.length() > 0) {
				autocompleteQuery.append(" ");
				if (operator != null) {
					autocompleteQuery.append(Operator.AND).append(" ");
				}
			}
			
			autocompleteQuery.append(searchPatternFragmentsIt.next());
			
			if (!searchPatternFragmentsIt.hasNext()) {
				autocompleteQuery.append(WILDCARD_SUFFIX);
			}
		}
		
		cleanSearchPattern = autocompleteQuery.toString().trim();
	}
	
	return cleanSearchPattern;
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/**
 * Nettoie la chaîne de recherche et autorise une recherche avec wildcard.
 * 
 * A noter que si stemming ou truc tordu il y a, il faut quand même faire la recherche à la fois sur le champ stemmé
 * et sur un champ non stemmé sinon le wildcard pourra ne pas renvoyer de résultat.
 */
public static String getQuery(String searchPattern, Operator operator) {
	String cleanSearchPattern = StringUtils.cleanForQuery(searchPattern);
	
	if(StringUtils.hasText(cleanSearchPattern)) {
		List<String> searchPatternFragments = getSearchPatternFragments(cleanSearchPattern);
		
		StringBuilder query = new StringBuilder();
		for (String searchPatternFragment : searchPatternFragments) {
			if (WILDCARD_SUFFIX.equals(searchPatternFragment)) {
				// si c'est juste une *, on ne peut pas faire grand chose, passons...
				continue;
			}
			if (query.length() > 0) {
				query.append(" ");
				if (operator != null) {
					query.append(operator).append(" ");
				}
			}
			query.append(searchPatternFragment);
		}
		
		cleanSearchPattern = query.toString().trim();
	}
	
	return cleanSearchPattern;
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Test
public void testGetSimilarityQuery() {
	assertEquals("alfresc~2", LuceneUtils.getSimilarityQuery("alfresc", 2));
	assertEquals("alfresco~2 sha~2", LuceneUtils.getSimilarityQuery("alfresco-sha", 2));
	assertEquals("alfresco~2 sha1~2", LuceneUtils.getSimilarityQuery("alfresco-sha1", 2));
	assertEquals("alfresco~2 sha1~2", LuceneUtils.getSimilarityQuery("alfresco sha1", 2));
	assertEquals("t~2 es~2 t~2", LuceneUtils.getSimilarityQuery("t' -_es**t", 2));
	
	assertEquals("alfresc~2", LuceneUtils.getSimilarityQuery("alfresc", 2, Operator.AND));
	assertEquals("alfresco~2 AND sha~2", LuceneUtils.getSimilarityQuery("alfresco-sha", 2, Operator.AND));
	assertEquals("alfresco~2 AND sha1~2", LuceneUtils.getSimilarityQuery("alfresco-sha1", 2, Operator.AND));
	assertEquals("alfresco~2 AND sha1~2", LuceneUtils.getSimilarityQuery("alfresco sha1", 2, Operator.AND));
	assertEquals("t~2 AND es~2 AND t~2", LuceneUtils.getSimilarityQuery("t' -_es**t", 2, Operator.AND));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Test
public void testGetQuery() {
	assertEquals("elephant de test", LuceneUtils.getQuery("éléphant de test"));
	assertEquals("elephant de* test*", LuceneUtils.getQuery("éléphant de* test*"));
	assertEquals("elephant test*", LuceneUtils.getQuery("éléphant * test*"));
	
	assertEquals("elephant OR de OR test", LuceneUtils.getQuery("éléphant de test", Operator.OR));
	assertEquals("elephant OR de* OR test*", LuceneUtils.getQuery("éléphant de* test*", Operator.OR));
	assertEquals("elephant OR test*", LuceneUtils.getQuery("éléphant * test*", Operator.OR));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Deprecated
private MultiFieldQueryParser getMultiFieldQueryParser(FullTextEntityManager fullTextEntityManager, String[] fields, Operator defaultOperator, Analyzer analyzer) {
	MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
	parser.setDefaultOperator(defaultOperator);
	
	return parser;
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Test
public void test () throws ParseException
{
  final QueryParser aQP = new QueryParser ("", PDLucene.createAnalyzer ());
  aQP.setDefaultOperator (Operator.AND);
  aQP.setAllowLeadingWildcard (true);
  final Query aQuery = aQP.parse ("(allfields:*9905* AND allfields:*leckma*) AND NOT deleted:(*)");
  System.out.println (aQuery.getClass () + " -- " + aQuery);
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** simple synonyms test */
public void testSynonyms() throws Exception {
  BooleanQuery expected = new BooleanQuery(true);
  expected.add(new TermQuery(new Term("field", "dogs")), BooleanClause.Occur.SHOULD);
  expected.add(new TermQuery(new Term("field", "dog")), BooleanClause.Occur.SHOULD);
  QueryParser qp = new QueryParser("field", new MockSynonymAnalyzer());
  assertEquals(expected, qp.parse("dogs"));
  assertEquals(expected, qp.parse("\"dogs\""));
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("dogs"));
  assertEquals(expected, qp.parse("\"dogs\""));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("dogs^2"));
  assertEquals(expected, qp.parse("\"dogs\"^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** forms multiphrase query */
public void testSynonymsPhrase() throws Exception {
  MultiPhraseQuery expected = new MultiPhraseQuery();
  expected.add(new Term("field", "old"));
  expected.add(new Term[] { new Term("field", "dogs"), new Term("field", "dog") });
  QueryParser qp = new QueryParser("field", new MockSynonymAnalyzer());
  assertEquals(expected, qp.parse("\"old dogs\""));
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("\"old dogs\""));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("\"old dogs\"^2"));
  expected.setSlop(3);
  assertEquals(expected, qp.parse("\"old dogs\"~3^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** simple CJK synonym test */
public void testCJKSynonym() throws Exception {
  BooleanQuery expected = new BooleanQuery(true);
  expected.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  expected.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  QueryParser qp = new QueryParser("field", new MockCJKSynonymAnalyzer());
  assertEquals(expected, qp.parse("国"));
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("国"));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("国^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** synonyms with default AND operator */
public void testCJKSynonymsAND() throws Exception {
  BooleanQuery expected = new BooleanQuery();
  expected.add(new TermQuery(new Term("field", "中")), BooleanClause.Occur.MUST);
  BooleanQuery inner = new BooleanQuery(true);
  inner.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
  inner.add(new TermQuery(new Term("field", "國")), BooleanClause.Occur.SHOULD);
  expected.add(inner, BooleanClause.Occur.MUST);
  QueryParser qp = new QueryParser("field", new MockCJKSynonymAnalyzer());
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("中国"));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("中国^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
/** forms multiphrase query */
public void testCJKSynonymsPhrase() throws Exception {
  MultiPhraseQuery expected = new MultiPhraseQuery();
  expected.add(new Term("field", "中"));
  expected.add(new Term[] { new Term("field", "国"), new Term("field", "國")});
  QueryParser qp = new QueryParser("field", new MockCJKSynonymAnalyzer());
  qp.setDefaultOperator(Operator.AND);
  assertEquals(expected, qp.parse("\"中国\""));
  expected.setBoost(2.0f);
  assertEquals(expected, qp.parse("\"中国\"^2"));
  expected.setSlop(3);
  assertEquals(expected, qp.parse("\"中国\"~3^2"));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
protected void init(boolean write) throws IOException {
	// configure/initialize lucene
       Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_44);
       IndexWriterConfig conf = new IndexWriterConfig(Version.LUCENE_44, 
       		new LimitTokenCountAnalyzer(analyzer, Integer.MAX_VALUE));
       
       // if index doesn't exist, create it (otherwise you get an error trying to open the reader)
       if (write || !DirectoryReader.indexExists(directory)) {
		this.writer = new IndexWriter(directory, conf);
		this.writer.commit(); // for ensuring the index exists the first time
       }
	this.reader = DirectoryReader.open(directory);
	this.searcher = new IndexSearcher(this.reader);
	this.parser = new QueryParser(Version.LUCENE_44, "description", analyzer);
	this.parser.setDefaultOperator(Operator.AND);
	
	// get the unique SAB's
	Set<String> sabs = new HashSet<>();
	Fields fields = MultiFields.getFields(this.reader);
	if (fields != null) {
		Terms terms = fields.terms("sab");
		TermsEnum itr = terms.iterator(null);
		BytesRef bytes = null;
		while((bytes = itr.next()) != null) {
			String term = new String(bytes.bytes, bytes.offset, bytes.length);
			sabs.add(term);
		}
	}
	this.systems = Collections.unmodifiableSet(sabs);
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Ignore
@Test
public void testLuceneSearch() {
	try {
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_44);
    	Directory directory = FSDirectory.open(new File("/Users/Les.Westberg/Projects/vistacore/ehmp/product/production/hmp-main/data/termdb-1.UMLS2013AA.20131017-drugdb/lucene"));
		DirectoryReader reader = DirectoryReader.open(directory);
		IndexSearcher searcher = new IndexSearcher(reader);
		QueryParser parser = new QueryParser(Version.LUCENE_44, "description", analyzer);
		parser.setDefaultOperator(Operator.AND);
		
		Query oQuery = new TermQuery(new Term("urn", "urn:vandf:4020400"));
		TopDocs oTopDocs = searcher.search(oQuery, 100);
		
		assertNotNull(oTopDocs);
		
		for (ScoreDoc oScoreDoc : oTopDocs.scoreDocs) {
			assertNotNull(oScoreDoc);
			Document oDocument = reader.document(oScoreDoc.doc);
			@SuppressWarnings("unused")
			Document oDocument2 = searcher.doc(oScoreDoc.doc);
			assertNotNull(oDocument);
		}
	}
	catch (Exception e) {
		System.out.println("An unhandled exception occurred.  Error: " + e.getMessage());
		e.printStackTrace();
		fail("An unhandled exception occurred.  Error: " + e.getMessage());
	}
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
@Override
public MiruFilter parse(String locale, boolean useStopWords, String queryString) throws Exception {
    Analyzer analyzer = termAnalyzers.findAnalyzer(locale, useStopWords);
    QueryParser parser = new QueryParser(defaultField, analyzer);
    parser.setDefaultOperator(Operator.AND);
    return makeFilter(parser.parse(queryString));
}
 

import org.apache.lucene.queryparser.classic.QueryParser.Operator; //导入依赖的package包/类
public SpanQParser(String qstr, SolrParams localParams, SolrParams params, SolrQueryRequest req){
    super(qstr, localParams, params, req);
    IndexSchema schema = req.getSchema();

    //preamble to initializing the parser
    Analyzer analyzer;

    defaultFieldName = getDefaultField(schema);

    SchemaField sf = schema.getField(defaultFieldName);
    if(sf != null && sf.getType() != null)
      analyzer = sf.getType().getQueryAnalyzer();
    else
      analyzer = schema.getQueryAnalyzer();	//default analyzer?

    //initialize the parser
    parser = new SolrSpanQueryParser(defaultFieldName, analyzer, schema, this);

    //now set the params
    SolrParams solrParams = SolrParams.wrapDefaults(localParams, params);

    parser.setAllowLeadingWildcard(solrParams.getBool(ALLOW_LEADING_WILDCARD, true));

//    parser.setAnalyzeRangeTerms(solrParams.getBool(ANALYZE_RANGE_TERMS, true));
    parser.setAutoGeneratePhraseQueries(solrParams.getBool(AUTO_GENERATE_PHRASE, false));
    QueryParser.Operator defaultOp = 
        QueryParsing.getQueryParserDefaultOperator(req.getSchema(), solrParams.get(QueryParsing.OP));

    if (defaultOp == QueryParser.Operator.AND) {
      parser.setDefaultOperator(Operator.AND);
    }
    parser.setFuzzyMaxEdits(solrParams.getInt(MAX_FUZZY_EDITS, 2));
    parser.setFuzzyPrefixLength(solrParams.getInt(PREFIX_LENGTH, 0));
    parser.setPhraseSlop(solrParams.getInt(PHRASE_SLOP, 0));
    parser.setSpanNearMaxDistance(solrParams.getInt(NEAR_MAX, -1));
    parser.setSpanNotNearMaxDistance(solrParams.getInt(NOT_NEAR_MAX, -1));

  }