Java tutorial
/** * License Agreement for OpenSearchServer * * Copyright (C) 2013-2015 Emmanuel Keller / Jaeksoft * * http://www.open-search-server.com * * This file is part of OpenSearchServer. * * OpenSearchServer is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * OpenSearchServer is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with OpenSearchServer. * If not, see <http://www.gnu.org/licenses/>. **/ package com.jaeksoft.searchlib.query; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.TreeSet; import org.antlr.v4.runtime.ANTLRInputStream; import org.antlr.v4.runtime.BailErrorStrategy; import org.antlr.v4.runtime.BaseErrorListener; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.RecognitionException; import org.antlr.v4.runtime.Recognizer; import org.antlr.v4.runtime.tree.TerminalNode; import org.apache.lucene.index.Term; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanClause.Occur; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.PhraseQuery; import org.apache.lucene.search.Query; import org.apache.lucene.search.TermQuery; import com.jaeksoft.searchlib.analysis.CompiledAnalyzer; import com.jaeksoft.searchlib.query.parser.BooleanQueryBaseListener; import com.jaeksoft.searchlib.query.parser.BooleanQueryLexer; import com.jaeksoft.searchlib.query.parser.BooleanQueryParser; import com.jaeksoft.searchlib.util.StringUtils; public class QueryParser extends BooleanQueryBaseListener { private final Set<String> fields; private final String defaultField; private final int defaultOperator; private final CompiledAnalyzer analyzer; private final int phraseSlop; private final Double termBoost; private final Double phraseBoost; private String currentField; private int currentOperator; private Query holdQuery; private BooleanQuery booleanQuery; private IOException ioError; public QueryParser(final String defaultField, final Set<String> fields, final Occur occur, final CompiledAnalyzer analyzer, final int phraseSlop, final Double termBoost, final Double phraseBoost) { this.defaultField = defaultField; this.fields = fields; this.defaultOperator = getOperator(occur); this.analyzer = analyzer; this.phraseSlop = phraseSlop; this.termBoost = termBoost; this.phraseBoost = phraseBoost; } final private static int getOperator(final Occur occur) { if (occur == null) return BooleanQueryLexer.AND; switch (occur) { default: case MUST: return BooleanQueryLexer.AND; case MUST_NOT: return BooleanQueryLexer.NOT; case SHOULD: return BooleanQueryLexer.OR; } } final private void addBooleanClause(final Query query, final int operator) { Occur occur = null; switch (operator) { case BooleanQueryLexer.AND: occur = Occur.MUST; break; case BooleanQueryLexer.OR: occur = Occur.SHOULD; break; case BooleanQueryLexer.NOT: occur = Occur.MUST_NOT; break; } booleanQuery.add(new BooleanClause(query, occur)); } final private void addBooleanClause(final Query query) { if (currentOperator == -1) { holdQuery = query; } else { if (holdQuery != null) { addBooleanClause(holdQuery, currentOperator == BooleanQueryLexer.NOT ? defaultOperator : currentOperator); holdQuery = null; } addBooleanClause(query, currentOperator); } currentOperator = defaultOperator; } final private List<String> getWords(final String text) throws IOException { List<String> words = new ArrayList<String>(1); if (analyzer != null) analyzer.extractTerms(text, words); else words.add(text); return words; } final private void addTermQuery(final String text) throws IOException { for (String word : getWords(text)) { Term term = new Term(currentField, word); TermQuery termQuery = new TermQuery(term); if (termBoost != null) termQuery.setBoost(termBoost.floatValue()); addBooleanClause(termQuery); } currentField = defaultField; } final private void addPhraseQuery(String text) throws IOException { int s = 0; if (text.startsWith("\"")) s = 1; int l = text.length() + 1 - s; if (text.endsWith("\"")) l--; if (l > 0) text = text.substring(s, l); PhraseQuery phraseQuery = new PhraseQuery(); phraseQuery.setSlop(phraseSlop); if (phraseBoost != null) phraseQuery.setBoost(phraseBoost.floatValue()); for (String word : getWords(text)) phraseQuery.add(new Term(currentField, word)); addBooleanClause(phraseQuery); currentField = defaultField; } final private void setCurrentField(final String text) throws IOException { String field = text.endsWith(":") ? text.substring(0, text.length() - 1) : text; if (fields != null && fields.contains(field)) currentField = field; else addTermQuery(text); } @Override final public void visitTerminal(final TerminalNode node) { try { int type = node.getSymbol().getType(); switch (type) { case BooleanQueryLexer.AND: case BooleanQueryLexer.OR: case BooleanQueryLexer.NOT: currentOperator = type; break; case BooleanQueryLexer.QSTRING: addPhraseQuery(node.getText()); break; case BooleanQueryLexer.STRING: addTermQuery(node.getText()); break; case BooleanQueryLexer.FIELD: setCurrentField(node.getText()); break; case BooleanQueryLexer.WS: currentField = defaultField; break; default: break; } } catch (IOException e) { ioError = e; } } private final class ErrorListener extends BaseErrorListener { @Override public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) { ioError = new IOException(StringUtils.fastConcat("line: ", Integer.toString(line), " - pos: ", Integer.toString(charPositionInLine), " - ", msg)); } } public final Query parse(String query) throws IOException { try { currentOperator = -1; currentField = defaultField; holdQuery = null; booleanQuery = new BooleanQuery(); ioError = null; ANTLRInputStream input = new ANTLRInputStream(query); BooleanQueryLexer lexer = new BooleanQueryLexer(input); ErrorListener errorListener = new ErrorListener(); lexer.removeErrorListeners(); lexer.addErrorListener(errorListener); CommonTokenStream tokens = new CommonTokenStream(lexer); BooleanQueryParser parser = new BooleanQueryParser(tokens); BailErrorStrategy errorHandler = new BailErrorStrategy(); parser.setErrorHandler(errorHandler); parser.addParseListener(this); parser.removeErrorListeners(); parser.addErrorListener(errorListener); parser.expression(); if (ioError != null) throw ioError; if (holdQuery != null) addBooleanClause(holdQuery, currentOperator); return booleanQuery; } catch (org.antlr.v4.runtime.RecognitionException e) { if (ioError != null) throw ioError; throw new IOException(e); } catch (org.antlr.v4.runtime.misc.ParseCancellationException e) { if (ioError != null) throw ioError; throw new IOException(e); } } public final static void main(String[] arvs) throws IOException { TreeSet<String> fields = new TreeSet<String>(); fields.add("field2"); fields.add("field3"); QueryParser queryParser = new QueryParser("field", fields, Occur.MUST, null, 1, null, null); System.out.println(queryParser.parse("word")); System.out.println( queryParser.parse("word1 field2:word2 fauxfield\\:fauxword field:field3:\"quoted words\"")); System.out.println(queryParser.parse("field:\"quoted words\"")); System.out.println(queryParser.parse("\"quoted words\"")); System.out.println(queryParser.parse("\"quoted words\" word")); System.out.println(queryParser.parse("word OR \"quoted words\"")); System.out.println(queryParser.parse("word OR \"quoted words")); System.out.println(queryParser.parse("word1 word2 AND \"quoted words\"")); System.out.println(queryParser.parse("word1 OU word2 \"quoted words\" NON unwanted")); System.out.println(queryParser.parse("\"\"")); System.out.println(queryParser.parse("\"non ending quote")); System.out.println(queryParser.parse("22\"")); System.out.println(queryParser.parse("\"")); System.out.println(queryParser.parse("OU OU")); System.out.println(queryParser.parse(" \"\"")); } }