QueryParser parser = new QueryParser(Version.LUCENE_30, LUCENE_FIELD_DATA, analyzer); Query query = parser.parse(text);
@SuppressWarnings("deprecation") public QueryNode parseQuery(final String queryStr) throws ParseException { org.apache.lucene.queryParser.QueryParser qp = new org.apache.lucene.queryParser.QueryParser(Version.LUCENE_CURRENT, defaultField, getAnalyzer()); qp.setDefaultOperator(org.apache.lucene.queryParser.QueryParser.Operator.AND); org.apache.lucene.search.Query luceneQuery; try { luceneQuery = qp.parse(queryStr); } catch (Exception e) { throw new ParseException("lucene failed parsing. " + e); } return internalParse(luceneQuery, queryStr); }
/** Return the Lucene QueryParser for this LARQ index */ public final QueryParser getLuceneQueryParser() { if ( luceneQueryParser != null ) return luceneQueryParser ; // Creating a new parser makes this class thread safe for search() return new QueryParser(LARQ.fIndex, analyzer) ; } }
private QueryParser getQueryParser(URI propertyURI) { // check out which query parser to use, based on the given property URI if (propertyURI == null) // if we have no property given, we create a default query parser // which // has the TEXT_FIELD_NAME as the default field return new QueryParser(Version.LUCENE_35, SearchFields.TEXT_FIELD_NAME, this.queryAnalyzer); else // otherwise we create a query parser that has the given property as // the default field return new QueryParser(Version.LUCENE_35, SearchFields.getPropertyField(propertyURI), this.queryAnalyzer); }
/** Parses a query string, returning a {@link org.apache.lucene.search.Query}. * @param query the query string to be parsed. * @param field the default field for query terms. * @param analyzer used to find terms in the query text. * @throws ParseException if the parsing fails */ static public Query parse(String query, String field, Analyzer analyzer) throws ParseException { QueryParser parser = new QueryParser(field, analyzer); return parser.parse(query); }
public List<String> search(String query) throws Exception { List<String> results = new ArrayList<String>(); QueryParser queryParser = new QueryParser(Version.LUCENE_35, null, new StandardAnalyzer(Version.LUCENE_35)); Query q = queryParser.parse(query); TopDocs topDocs = searcher.search(q, MAX_RESULTS); for (ScoreDoc sd : topDocs.scoreDocs) { Document document = searcher.doc(sd.doc); results.add(document.get("id")); } return results; }
protected HitHighlighter getHitHighlighter(String queryString) { try { Query query = new QueryParser(LUCENE_24, "", queryAnalyzer).parse(queryString); return new HitHighlighter(query, queryAnalyzer); } catch (ParseException e) { throw new RuntimeException(e); } } }
/** * Initializes the query based on the queryStr * * @param queryStr * query string, can use Lucene Query constructs */ public void initialize(String queryStr) throws IndexerException{ try { parser = new QueryParser(defaultField, analyzer); query = parser.parse(queryStr); } catch (ParseException e) { log.error( this, e); throw new IndexerException(e); } }
public static void main( String[] args ) throws Exception { Analyzer analyzer = new WhitespaceAnalyzer(); QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "f", analyzer ); Query query = parser.parse( "a x:b" ); FieldQuery fieldQuery = new FieldQuery( query, true, false ); Directory dir = new RAMDirectory(); IndexWriter writer = new IndexWriter( dir, analyzer, MaxFieldLength.LIMITED ); Document doc = new Document(); doc.add( new Field( "f", "a a a b b c a b b c d e f", Store.YES, Index.ANALYZED, TermVector.WITH_POSITIONS_OFFSETS ) ); doc.add( new Field( "f", "b a b a f", Store.YES, Index.ANALYZED, TermVector.WITH_POSITIONS_OFFSETS ) ); writer.addDocument( doc ); writer.close(); IndexReader reader = IndexReader.open( dir, true ); FieldTermStack ftl = new FieldTermStack( reader, 0, "f", fieldQuery ); reader.close(); }
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); }
/** * Command line tool to test QueryParser, using {@link org.apache.lucene.analysis.SimpleAnalyzer}. * Usage:<br> * <code>java org.apache.lucene.queryParser.QueryParser <input></code> */ public static void main(String[] args) throws Exception { if (args.length == 0) { System.out.println("Usage: java org.apache.lucene.queryParser.QueryParser <input>"); System.exit(0); } QueryParser qp = new QueryParser("field", new org.apache.lucene.analysis.SimpleAnalyzer()); Query q = qp.parse(args[0]); System.out.println(q.toString("field")); }
/** * Command line tool to test QueryParser, using {@link org.apache.lucene.analysis.SimpleAnalyzer}. * Usage:<br> * <code>java org.apache.lucene.queryParser.QueryParser <input></code> */ public static void main(String[] args) throws Exception { if (args.length == 0) { System.out.println("Usage: java org.apache.lucene.queryParser.QueryParser <input>"); System.exit(0); } QueryParser qp = new QueryParser("field", new org.apache.lucene.analysis.SimpleAnalyzer()); Query q = qp.parse(args[0]); System.out.println(q.toString("field")); }
private Query getQuery(final String field, final String query) throws ParseException { final QueryParser queryParser = new QueryParser(LUCENE_VERSION, field, analyzer); queryParser.setAllowLeadingWildcard(true); queryParser.setDefaultOperator(QueryParser.Operator.OR); return queryParser.parse(query); }
public static void main(String[] args) throws Exception { QueryParser qp = new QueryParser("field", new org.apache.lucene.analysis.SimpleAnalyzer()); Query q = qp.parse(args[0]); System.out.println(q.toString("field")); }
private Query queryForString(String fieldName, String queryString) throws ParseException { Analyzer analyzer = attributeNamed(fieldName).analyzer(); QueryParser parser = new QueryParser(Version.LUCENE_29, fieldName, analyzer); Query query = parser.parse(queryString); return query; }
@Override public void deleteNamespace(String namespaceId) { String query = "namespace:" + namespaceId; try { Query q = new QueryParser(Version.LUCENE_35, "name", _analyzer).parse(query); _index.deleteDocuments(q); } catch (Exception e) { throw new KlabRuntimeException(e); } }
private FullTextQuery createFullTextQuery(final SearchQueryBuilder query, final Class<?> indexClass) { QueryParser parser = null; final String expression = query.getQuery(); if (!expression.contains("\\:")) { parser = new QueryParser(LUCENE_VERSION, query.getIndex().getDefaultField(), new StandardAnalyzer(LUCENE_VERSION)); } else { final List<String> list = query.getIndex().getAllFields(); final String[] fields = list.toArray(new String[list.size()]); parser = new MultiFieldQueryParser(LUCENE_VERSION, fields, new StandardAnalyzer(LUCENE_VERSION)); } final FullTextSession searchSession = Search.getFullTextSession(getSession()); try { final org.apache.lucene.search.Query luceneQuery = parser.parse(query.getQuery()); return searchSession.createFullTextQuery(luceneQuery, indexClass); } catch (final ParseException e) { throw new BonitaRuntimeException(e.getMessage()); } }
public List<InteractionOntologyTerm> search(String strQuery, Analyzer analyzer) throws IOException, ParseException { QueryParser queryParser = new QueryParser(Version.LUCENE_30, "identifier", analyzer); return search(queryParser.parse(strQuery), new Sort(new SortField("count", SortField.INT, true))); }
public List<InteractionOntologyTerm> searchByName(String strQuery, Analyzer analyzer) throws IOException, ParseException { QueryParser queryParser = new QueryParser(Version.LUCENE_30, "label", analyzer); return search(queryParser.parse(strQuery), new Sort(new SortField("count", SortField.INT, true))); }
private Query parserSearchString(String searchString, Analyzer analyzer) throws ParseException { QueryParser queryParser = new QueryParser(LUCENE_VERSION, Field.CONTENTS.toString(), analyzer); queryParser.setDefaultOperator(Operator.AND); // all fields required queryParser.setLowercaseExpandedTerms(false); queryParser.setPhraseSlop(DEFAULT_PHRASE_SLOP); /* * Allow words in the query to begin with * * see http://lucene.apache.org/java/2_3_1/api/org/apache/lucene/queryParser/QueryParser.html#setAllowLeadingWildcard%28boolean%29 */ queryParser.setAllowLeadingWildcard(true); Query parsedQuery = queryParser.parse(searchString); return parsedQuery; }