/** * Parses the given string into a Lucene Query. * * @param searchString the search text * @return the Query object * @throws ParseException thrown if the search text cannot be parsed */ protected Query parseQuery(String searchString) throws ParseException { if (searchString == null || searchString.trim().isEmpty()) { throw new ParseException("Query is null or empty"); } LOGGER.debug(searchString); final Query query = queryParser.parse(searchString); return query; }
public TypedField(final String string) throws ParseException { final Matcher matcher = PATTERN.matcher(string); if (!matcher.matches()) { throw new ParseException("Field '" + string + "' not recognized."); } this.name = matcher.group(1); try { this.type = matcher.group(3) == null ? FieldType.TEXT : FieldType.valueOf(matcher.group(3).toUpperCase()); } catch (final IllegalArgumentException e) { throw new ParseException("Unrecognized type '" + matcher.group(3) + "'"); } }
public static long toDate(final Object obj) throws ParseException { if (obj instanceof Date) { return ((Date) obj).getTime(); } try { return DateUtils.parseDate(obj.toString().toUpperCase(), DATE_PATTERNS).getTime(); } catch (final java.text.ParseException e) { throw new ParseException(e.getMessage()); } }
throw new ParseException(e.getMessage()); } finally { queryBuilder.setAnalyzer(oldAnalyzer);
@Override protected Query getFieldQuery(String field, String queryText, int slop) throws ParseException { if (field != null && EXISTS_FIELD.equals(field)) { return existsQuery(queryText); } Map<String, Float> fields = extractMultiFields(field, true); if (fields.isEmpty()) { return newUnmappedFieldQuery(field); } Analyzer oldAnalyzer = queryBuilder.analyzer; int oldSlop = queryBuilder.phraseSlop; try { if (forceQuoteAnalyzer != null) { queryBuilder.setAnalyzer(forceQuoteAnalyzer); } else if (forceAnalyzer != null) { queryBuilder.setAnalyzer(forceAnalyzer); } queryBuilder.setPhraseSlop(slop); Query query = queryBuilder.parse(MultiMatchQueryBuilder.Type.PHRASE, fields, queryText, null); if (query == null) { return null; } return applySlop(query, slop); } catch (IOException e) { throw new ParseException(e.getMessage()); } finally { queryBuilder.setAnalyzer(oldAnalyzer); queryBuilder.setPhraseSlop(oldSlop); } }
/** Returns the numeric value of the hexadecimal character */ static final int hexToInt(char c) throws ParseException { if ('0' <= c && c <= '9') { return c - '0'; } else if ('a' <= c && c <= 'f'){ return c - 'a' + 10; } else if ('A' <= c && c <= 'F') { return c - 'A' + 10; } else { throw new ParseException("Non-hex character in Unicode escape sequence: " + c); } }
/** Returns the numeric value of the hexadecimal character */ static final int hexToInt(char c) throws ParseException { if ('0' <= c && c <= '9') { return c - '0'; } else if ('a' <= c && c <= 'f'){ return c - 'a' + 10; } else if ('A' <= c && c <= 'F') { return c - 'A' + 10; } else { throw new ParseException("Non-hex character in Unicode escape sequence: " + c); } }
private void checkPhraseClauseIsForSameField(String field) throws ParseException { if (!field.equals(currentPhraseQuery.field)) { throw new ParseException("Cannot have clause for field \"" + field + "\" nested in phrase " + " for field \"" + currentPhraseQuery.field + "\""); } }
private void checkPhraseClauseIsForSameField(String field) throws ParseException { if (!field.equals(currentPhraseQuery.field)) { throw new ParseException("Cannot have clause for field \"" + field + "\" nested in phrase " + " for field \"" + currentPhraseQuery.field + "\""); } }
Query handleBareFuzzy(String qfield, Token fuzzySlop, String termImage) throws ParseException { Query q; float fms = fuzzyMinSim; try { fms = Float.valueOf(fuzzySlop.image.substring(1)).floatValue(); } catch (Exception ignored) { } if(fms < 0.0f){ throw new ParseException("Minimum similarity for a FuzzyQuery has to be between 0.0f and 1.0f !"); } else if (fms >= 1.0f && fms != (int) fms) { throw new ParseException("Fractional edit distances are not allowed!"); } q = getFuzzyQuery(qfield, termImage, fms); return q; }
Query handleBareFuzzy(String qfield, Token fuzzySlop, String termImage) throws ParseException { Query q; float fms = fuzzyMinSim; try { fms = Float.valueOf(fuzzySlop.image.substring(1)).floatValue(); } catch (Exception ignored) { } if(fms < 0.0f){ throw new ParseException("Minimum similarity for a FuzzyQuery has to be between 0.0f and 1.0f !"); } else if (fms >= 1.0f && fms != (int) fms) { throw new ParseException("Fractional edit distances are not allowed!"); } q = getFuzzyQuery(qfield, termImage, fms); return q; }
@Override public Filter buildFilter() throws ParseException { try { return FilterConstructor.constructFilter(filter, _qparser); } catch (Exception e) { logger.error(e.getMessage(), e); throw new ParseException(e.getMessage()); } }
/** * Parses the given string into a Lucene Query. * * @param searchString the search text * @return the Query object * @throws ParseException thrown if the search text cannot be parsed */ protected Query parseQuery(String searchString) throws ParseException { if (searchString == null || searchString.trim().isEmpty()) { throw new ParseException("Query is null or empty"); } LOGGER.debug(searchString); final Query query = queryParser.parse(searchString); return query; }
@Override public Query buildQuery() throws ParseException { try { Query q = QueryConstructor.constructQuery(query, _qparser); if (q == null) { q = new MatchAllDocsQuery(); } return q; } catch (Exception e) { logger.error(e.getMessage(), e); throw new ParseException(e.getMessage()); } }
protected void doBuild(SenseiQuery query, QueryParser parser) throws Exception { if (query != null) { byte[] bytes = query.toBytes(); String qString = null; try { qString = new String(bytes, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new ParseException(e.getMessage()); } if (qString.length() > 0) { synchronized (parser) { _query = parser.parse(qString); } } } }
@Override @JsonIgnore final public SpanQuery getQuery(final QueryContext queryContext) throws IOException, ReflectiveOperationException, ParseException, QueryNodeException { final Query subQuery = wrappedQuery.getQuery(queryContext); if (subQuery instanceof SpanQuery) return (SpanQuery) subQuery; else if (subQuery instanceof MultiTermQuery) return new org.apache.lucene.search.spans.SpanMultiTermQueryWrapper((MultiTermQuery) subQuery); else if (subQuery instanceof org.apache.lucene.search.TermQuery) return new org.apache.lucene.search.spans.SpanTermQuery( ((org.apache.lucene.search.TermQuery) subQuery).getTerm()); throw new ParseException("Cannot convert " + subQuery.getClass().getName() + " as SpanQuery"); }
/** Parses a query string, returning a {@link org.apache.lucene.search.Query}. * @param query the query string to be parsed. * @throws ParseException if the parsing fails */ public Query parse(String query) throws ParseException { ReInit(new FastCharStream(new StringReader(query))); try { // TopLevelQuery is a Query followed by the end-of-input (EOF) Query res = TopLevelQuery(field); return res!=null ? res : newBooleanQuery(false).build(); } catch (ParseException | TokenMgrError tme) { // rethrow to include the original query: ParseException e = new ParseException("Cannot parse '" +query+ "': " + tme.getMessage()); e.initCause(tme); throw e; } catch (BooleanQuery.TooManyClauses tmc) { ParseException e = new ParseException("Cannot parse '" +query+ "': too many boolean clauses"); e.initCause(tmc); throw e; } }
/** * Uses {@link SolrPluginUtils#parseFieldBoosts(String)} with the 'qf' * parameter. Falls back to the 'df' parameter or * {@link org.apache.solr.schema.IndexSchema#getDefaultSearchFieldName()}. */ public static Map<String, Float> parseQueryFields(final IndexSchema indexSchema, final SolrParams solrParams) throws ParseException { final Map<String, Float> queryFields = SolrPluginUtils.parseFieldBoosts(solrParams.getParams(SirenParams.QF)); if (queryFields.isEmpty()) { final String df = QueryParsing.getDefaultField(indexSchema, solrParams.get(CommonParams.DF)); if (df == null) { throw new ParseException("Neither "+SirenParams.QF+", "+CommonParams.DF +", nor the default search field are present."); } queryFields.put(df, 1.0f); } checkFieldTypes(indexSchema, queryFields); return queryFields; }
@Override public org.apache.lucene.search.Query parse(ExtensionQuery query) throws ParseException { String field = query.getField(); String term = query.getRawQueryString(); // create either a term query or a phrase query (or a span?) try { if (StringUtils.isEmpty(field)) { return queryBuilder.parseQueryTerm(textFieldName, field, term, 1.0f); } else if (field.charAt(0) == '@') { return queryBuilder.parseQueryTerm(attributeTextFieldName, field.substring(1), term, 1.0f); } else { return queryBuilder.parseQueryTerm(elementTextFieldName, field, term, 1.0f); } } catch (ParserException e) { throw new ParseException (e.getMessage()); } } }
@Test(expectedExceptions = QueryCannotBeParsedException.class) public void testSearchForTextWhenCannotParseQueryShouldThrowError() throws IOException, ParseException { //GIVEN given(readerFactory.create(true)).willReturn(indexReader); given(searcherFactory.create(indexReader)).willReturn(indexSearcher); given(queryParser.parse(TEXT)).willThrow(new ParseException()); //WHEN underTest.searchForText(TEXT); //THEN it should throw exception }