Java QueryParser.escape方法代码示例

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
protected String escapeKeywords(String keywords) {
    keywords = keywords.trim();
    if (keywords.isEmpty()) {
        return keywords;
    }

    if (keywords.charAt(0) == '*') {
        if (keywords.length() == 1) {
            return "";
        } else {
            keywords = keywords.substring(1).trim();
        }
    }

    keywords = QueryParser.escape(keywords);

    return keywords;
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public List<Document> search (String queryString, SearchScope luceneFields) throws Exception {
    // using stop analyzer in search
    Analyzer analyzer = new StopAnalyzer(Version.LUCENE_30,  new File(ApplicationConstants.STOP_WORD_FILE));
    
    String[] fields = getSupportedFileds(luceneFields);
    
    MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_30, fields, analyzer);
    
    // scpaing special characters
    queryString = QueryParser.escape(queryString);
    
    Query query = parser.parse(queryString);
    TopDocs topDocs = searcher.search(query, MAX_RESULT);

    List<Document> documents = new ArrayList<Document>();
    for(ScoreDoc scoreDocs: topDocs.scoreDocs) {
        Document document = searcher.doc(scoreDocs.doc);
        documents.add(document);
    }
    
    return documents;
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)
public Page<Article> search(String keyword, Pageable pageable) {
	if (StringUtils.isEmpty(keyword)) {
		return new Page<Article>();
	}
	if (pageable == null) {
		pageable = new Pageable();
	}
	try {
		String text = QueryParser.escape(keyword);
		QueryParser titleParser = new QueryParser(Version.LUCENE_35, "title", new IKAnalyzer());
		titleParser.setDefaultOperator(QueryParser.AND_OPERATOR);
		Query titleQuery = titleParser.parse(text);
		FuzzyQuery titleFuzzyQuery = new FuzzyQuery(new Term("title", text), FUZZY_QUERY_MINIMUM_SIMILARITY);
		Query contentQuery = new TermQuery(new Term("content", text));
		Query isPublicationQuery = new TermQuery(new Term("isPublication", "true"));
		BooleanQuery textQuery = new BooleanQuery();
		BooleanQuery query = new BooleanQuery();
		textQuery.add(titleQuery, Occur.SHOULD);
		textQuery.add(titleFuzzyQuery, Occur.SHOULD);
		textQuery.add(contentQuery, Occur.SHOULD);
		query.add(isPublicationQuery, Occur.MUST);
		query.add(textQuery, Occur.MUST);
		FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
		FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(query, Article.class);
		fullTextQuery.setSort(new Sort(new SortField[] { new SortField("isTop", SortField.STRING, true), new SortField(null, SortField.SCORE), new SortField("createDate", SortField.LONG, true) }));
		fullTextQuery.setFirstResult((pageable.getPageNumber() - 1) * pageable.getPageSize());
		fullTextQuery.setMaxResults(pageable.getPageSize());
		return new Page<Article>(fullTextQuery.getResultList(), fullTextQuery.getResultSize(), pageable);
	} catch (ParseException e) {
		e.printStackTrace();
	}
	return new Page<Article>();
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public String escapeSearchString() {
	// Anführungszeichen und * nicht escapen!!!
	this.wildcardQuery = this.searchString.contains("*") || this.searchString.contains("?");
	String escapedString = QueryParser.escape(this.searchString);
	escapedString = escapedString.replaceAll("\\\\([\"*?])", "$1");
	System.out.println("\nresulting query string: "+escapedString);
	return escapedString;
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public Query getQueryForContext(Text context) throws ParseException {
	LOG.debug("[getQueryForContext] - BEGIN");
	Query result;
	QueryParser parser = new QueryParser(Version.LUCENE_36,
		"CONTEXT", this.getLuceneDefaultAnalyzer());
	LOG.debug("Analyzer used here: " + getLuceneDefaultAnalyzer());
	// Escape special characters:
	String queryText = context.getText().replaceAll(
			"[\\+\\-\\|!\\(\\)\\{\\}\\[\\]\\^~\\*\\?\"\\\\:&]", " ");
	queryText = QueryParser.escape(queryText);
	result = parser.parse(queryText);
	LOG.debug("Main query from Classify: " + result);
	LOG.debug("[getQueryForContext] - END");
	return result;
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public TopScoreDocCollector search(String queryString, int lucHits, String fieldName, Analyzer analyzer) {
	queryString = QueryParser.escape(queryString.trim());		
	if(queryString.equalsIgnoreCase("")) 
		return null;
	Query query = null;
	try {
		QueryParser queryParser = new QueryParser(Version.LUCENE_36, fieldName, analyzer);			
		query = queryParser.parse(queryString);
	} catch (ParseException e) {
		e.printStackTrace();
	}						
	return search(query, lucHits);	
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
private AutoCompleteResult buildAutoCompleteResult(String value, boolean term)
{
	return new AutoCompleteResult(value, QueryParser.escape(value), term);
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
/**
 *  Make a Lucene boolean clause suitable for use with the Lucene QueryParser. <p>
 *
 *  Examples:<p>
 *
 *  input: strings=['car','train station','airplane'], operator=OR, asPhrases=true, escape=false<br/>
 *  output: ("car" OR "train station" OR "airplane")<p>
 *
 *  input: strings=['car','train station','airplane'], operator=AND, asPhrases=false, escape=false<br/>
 *  output: ((car) AND (train station) AND (airplane))
 *
 * @param  strings        One or more Strings
 * @param  operator       The String OR, AND, or NOT
 * @param  asPhrases      True to treat each String as a phrase (e.g. surround in quotes)
 * @param  escape         True to return a String where characters that QueryParser expects to be escaped are
 *      escaped by a preceding \.
 * @return                A boolean clause
 * @exception  Exception  If error
 * @see                   org.apache.lucene.queryParser.QueryParser
 */
public final static String makeBooleanClause(String[] strings, String operator, boolean asPhrases, boolean escape) throws Exception {
	if (operator == null || (!operator.equals("OR") && !operator.equals("AND") && !operator.equals("NOT")))
		throw new Exception("boolean operator must be 'OR' or 'AND' or 'NOT'");

	if (strings == null || strings.length == 0)
		return "";
	String queryClause = "(";
	for (int i = 0; i < strings.length; i++) {
		if (escape)
			queryClause += (asPhrases ? "\"" : "(") + QueryParser.escape(strings[i]) + (asPhrases ? "\"" : ")");
		else
			queryClause += (asPhrases ? "\"" : "(") + strings[i] + (asPhrases ? "\"" : ")");
		if (i < strings.length - 1)
			queryClause += " " + operator + " ";
	}
	queryClause += ")";
	return queryClause;
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public static String escapeQuery( String query ) {
    return QueryParser.escape( query );
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
public String escape(final String in) {
  return QueryParser.escape(in);
}
 

import org.apache.lucene.queryParser.QueryParser; //导入方法依赖的package包/类
private static void escapeStrings(String[] queryStrings) {
	for(int i=0; i<queryStrings.length; i++) {
		queryStrings[i] = QueryParser.escape(queryStrings[i]);
	}
}