Example usage for org.apache.lucene.search BooleanQuery setMaxClauseCount

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanQuery setMaxClauseCount.

Prototype

public static void setMaxClauseCount(int maxClauseCount) 

Source Link

Document

Set the maximum number of clauses permitted per BooleanQuery.

Usage

From source file:org.easynet.resource.queryparser.QueryParserTestBase.java

License:Apache License

public void testBooleanQuery() throws Exception {
    BooleanQuery.setMaxClauseCount(2);
    Analyzer purWhitespaceAnalyzer = new MockAnalyzer(random(), MockTokenizer.WHITESPACE, false);
    assertParseException("one two three", purWhitespaceAnalyzer);
}

---

From source file:org.easynet.resource.queryparser.QueryParserTestBase.java

License:Apache License

@After
public void tearDown() throws Exception {
    BooleanQuery.setMaxClauseCount(originalMaxClauses);
}

---

From source file:org.ebayopensource.turmeric.eclipse.mavenapi.impl.MavenEclipseApi.java

License:Open Source License

/**
 * according to artifact name,group and repository url ,to search artifact.
 * It supports wildcard./*  w  w w  .  j  a v  a  2  s  .c  om*/
 *
 * @param name the artifact name, can include wildcards
 * @param group the group id, can include wildcards
 * @param repositoryUrl a repository url location
 * @return a collection of artifacts that matched the query
 * @throws MavenEclipseApiException the maven eclipse api exception
 */
public Collection<Artifact> findArtifactByNameAndGroupAndRepositoryUrl(String name, String group,
        String repositoryUrl) throws MavenEclipseApiException {
    Collection<ArtifactMetadata> ams = null;
    try {
        BooleanQuery bq = new BooleanQuery();
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        Query query = null;
        if (StringUtils.isNotBlank(name)) {
            bq.add(new WildcardQuery(new Term(ArtifactInfo.ARTIFACT_ID, name.toLowerCase())), Occur.MUST);
        } else {
            bq.add(new WildcardQuery(new Term(ArtifactInfo.ARTIFACT_ID, "*")), Occur.MUST);
        }
        if (StringUtils.isNotBlank(group)) {
            bq.add(new WildcardQuery(new Term(ArtifactInfo.GROUP_ID, group.toLowerCase())), Occur.MUST);
        } else {
            bq.add(new WildcardQuery(new Term(ArtifactInfo.GROUP_ID, "*")), Occur.MUST);
        }

        RepositoryInfo repository = new RepositoryInfo(null, repositoryUrl, IRepositoryRegistry.SCOPE_UNKNOWN,
                null);
        final Map<String, IndexedArtifact> results = ((NexusIndexManager) _getIndexManager()).search(repository,
                bq);
        ams = _returnFindings(results);
    } catch (final CoreException e) {
        throw new MavenEclipseApiException(e);
    }
    return _toArtifactCollection(ams);
}

---

From source file:org.eclipse.smila.search.lucene.index.IndexConnection.java

License:Open Source License

/**
 * The Constructor./*from   www  . j  a  va2  s.  co  m*/
 * 
 * @param indexName
 *          Index name.
 * 
 * @throws IndexException
 *           Unable to create index connection.
 */
public IndexConnection(final String indexName) throws IndexException {

    super(indexName);

    try {
        // store index structure from data dictionary
        _index = DataDictionaryController.getIndex(indexName);
    } catch (final DataDictionaryException e) {
        throw new IndexException(e.getMessage(), e);
    }

    if (_index == null) {
        throw new IndexException("index not in data dictionary [" + indexName + "]");
    }

    try {
        // TODO: add parameter
        final String maxClauseCountString = "4096"; // ConfigManager.getString(ConfigBuilder.MAX_CLAUSE_COUNT);
        final int maxClauseCount = Integer.parseInt(maxClauseCountString);
        BooleanQuery.setMaxClauseCount(maxClauseCount);
    } catch (final NumberFormatException ex) {
        _log.error("unable to set BooleanQuery max clause count. using default value", ex);
    }

    _indexName = indexName;
    try {
        final File dataFolder = WorkspaceHelper.createWorkingDir(LuceneService.BUNDLE_NAME, indexName);
        _indexStore = dataFolder.getAbsolutePath();
    } catch (final IOException e) {
        if (_log.isErrorEnabled()) {
            _log.error("", e);
        }
        throw new IndexException(e);
    }

    // prepare analyzer
    _analyzer = AnalyzerFactory.getAnalyzer(_index);
}

---

From source file:org.elasticsearch.index.query.BoolQueryParser.java

License:Apache License

@Inject
public BoolQueryParser(Settings settings) {
    BooleanQuery.setMaxClauseCount(settings.getAsInt("index.query.bool.max_clause_count",
            settings.getAsInt("indices.query.bool.max_clause_count", BooleanQuery.getMaxClauseCount())));
}

---

From source file:org.elasticsearch.index.query.xcontent.BoolQueryParser.java

License:Apache License

@Inject
public BoolQueryParser(Index index, @IndexSettings Settings settings) {
    super(index, settings);
    BooleanQuery.setMaxClauseCount(
            settings.getAsInt("index.query.bool.max_clause_count", BooleanQuery.getMaxClauseCount()));
}

---

From source file:org.elasticsearch.search.SearchModule.java

License:Apache License

private void registerQueryParsers(List<SearchPlugin> plugins) {
    registerQuery(new QuerySpec<>(MatchQueryBuilder.QUERY_NAME_FIELD, MatchQueryBuilder::new,
            MatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhraseQueryBuilder.NAME, MatchPhraseQueryBuilder::new,
            MatchPhraseQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhrasePrefixQueryBuilder.NAME, MatchPhrasePrefixQueryBuilder::new,
            MatchPhrasePrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MultiMatchQueryBuilder.NAME, MultiMatchQueryBuilder::new,
            MultiMatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(NestedQueryBuilder.NAME, NestedQueryBuilder::new,
            NestedQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasChildQueryBuilder.NAME, HasChildQueryBuilder::new,
            HasChildQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasParentQueryBuilder.NAME, HasParentQueryBuilder::new,
            HasParentQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(DisMaxQueryBuilder.NAME, DisMaxQueryBuilder::new,
            DisMaxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(IdsQueryBuilder.NAME, IdsQueryBuilder::new, IdsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchAllQueryBuilder.NAME, MatchAllQueryBuilder::new,
            MatchAllQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(QueryStringQueryBuilder.NAME, QueryStringQueryBuilder::new,
            QueryStringQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(BoostingQueryBuilder.NAME, BoostingQueryBuilder::new,
            BoostingQueryBuilder::fromXContent));
    BooleanQuery.setMaxClauseCount(INDICES_MAX_CLAUSE_COUNT_SETTING.get(settings));
    registerQuery(//from  w w w . jav a  2 s.  c o m
            new QuerySpec<>(BoolQueryBuilder.NAME, BoolQueryBuilder::new, BoolQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(TermQueryBuilder.NAME, TermQueryBuilder::new, TermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TermsQueryBuilder.QUERY_NAME_FIELD, TermsQueryBuilder::new,
            TermsQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(FuzzyQueryBuilder.NAME, FuzzyQueryBuilder::new, FuzzyQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(RegexpQueryBuilder.NAME, RegexpQueryBuilder::new,
            RegexpQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(RangeQueryBuilder.NAME, RangeQueryBuilder::new, RangeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(PrefixQueryBuilder.NAME, PrefixQueryBuilder::new,
            PrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WildcardQueryBuilder.NAME, WildcardQueryBuilder::new,
            WildcardQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ConstantScoreQueryBuilder.NAME, ConstantScoreQueryBuilder::new,
            ConstantScoreQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanTermQueryBuilder.NAME, SpanTermQueryBuilder::new,
            SpanTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNotQueryBuilder.NAME, SpanNotQueryBuilder::new,
            SpanNotQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanWithinQueryBuilder.NAME, SpanWithinQueryBuilder::new,
            SpanWithinQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanContainingQueryBuilder.NAME, SpanContainingQueryBuilder::new,
            SpanContainingQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FieldMaskingSpanQueryBuilder.NAME, FieldMaskingSpanQueryBuilder::new,
            FieldMaskingSpanQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanFirstQueryBuilder.NAME, SpanFirstQueryBuilder::new,
            SpanFirstQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNearQueryBuilder.NAME, SpanNearQueryBuilder::new,
            SpanNearQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanOrQueryBuilder.NAME, SpanOrQueryBuilder::new,
            SpanOrQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MoreLikeThisQueryBuilder.QUERY_NAME_FIELD, MoreLikeThisQueryBuilder::new,
            MoreLikeThisQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WrapperQueryBuilder.NAME, WrapperQueryBuilder::new,
            WrapperQueryBuilder::fromXContent));
    // TODO Remove IndicesQuery in 6.0
    registerQuery(new QuerySpec<>(IndicesQueryBuilder.NAME, IndicesQueryBuilder::new,
            IndicesQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(CommonTermsQueryBuilder.NAME, CommonTermsQueryBuilder::new,
            CommonTermsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanMultiTermQueryBuilder.NAME, SpanMultiTermQueryBuilder::new,
            SpanMultiTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FunctionScoreQueryBuilder.NAME, FunctionScoreQueryBuilder::new,
            c -> FunctionScoreQueryBuilder.fromXContent(scoreFunctionParserRegistry, c)));
    registerQuery(new QuerySpec<>(SimpleQueryStringBuilder.NAME, SimpleQueryStringBuilder::new,
            SimpleQueryStringBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(TypeQueryBuilder.NAME, TypeQueryBuilder::new, TypeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ScriptQueryBuilder.NAME, ScriptQueryBuilder::new,
            ScriptQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoDistanceQueryBuilder.NAME, GeoDistanceQueryBuilder::new,
            GeoDistanceQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoDistanceRangeQueryBuilder.NAME, GeoDistanceRangeQueryBuilder::new,
            GeoDistanceRangeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoBoundingBoxQueryBuilder.QUERY_NAME_FIELD, GeoBoundingBoxQueryBuilder::new,
            GeoBoundingBoxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeohashCellQuery.NAME, GeohashCellQuery.Builder::new,
            GeohashCellQuery.Builder::fromXContent));
    registerQuery(new QuerySpec<>(GeoPolygonQueryBuilder.NAME, GeoPolygonQueryBuilder::new,
            GeoPolygonQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ExistsQueryBuilder.NAME, ExistsQueryBuilder::new,
            ExistsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchNoneQueryBuilder.NAME, MatchNoneQueryBuilder::new,
            MatchNoneQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ParentIdQueryBuilder.NAME, ParentIdQueryBuilder::new,
            ParentIdQueryBuilder::fromXContent));

    if (ShapesAvailability.JTS_AVAILABLE && ShapesAvailability.SPATIAL4J_AVAILABLE) {
        registerQuery(new QuerySpec<>(GeoShapeQueryBuilder.NAME, GeoShapeQueryBuilder::new,
                GeoShapeQueryBuilder::fromXContent));
    }

    registerFromPlugin(plugins, SearchPlugin::getQueries, this::registerQuery);
}

---

From source file:org.eu.bitzone.Leia.java

License:Apache License

/**
 * Create a Query instance that corresponds to values selected in the UI, such as analyzer class name and arguments,
 * and default field./*  w  w  w.  j ava 2s  .com*/
 *
 * @return
 */
public Query createQuery(final String queryString) throws Exception {
    final Object srchOpts = find("srchOptTabs");
    final Analyzer analyzer = createAnalyzer(srchOpts);
    if (analyzer == null) {
        return null;
    }
    final String defField = getDefaultField(srchOpts);
    final QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, defField, analyzer);
    final Object ckXmlParser = find(srchOpts, "ckXmlParser");
    final Object ckWild = find(srchOpts, "ckWild");
    final Object ckPosIncr = find(srchOpts, "ckPosIncr");
    final Object ckLoExp = find(srchOpts, "ckLoExp");
    final Object cbDateRes = find(srchOpts, "cbDateRes");
    final DateTools.Resolution resolution = Util.getResolution(getString(cbDateRes, "text"));
    final Object cbOp = find(srchOpts, "cbOp");
    final Object bqMaxCount = find(srchOpts, "bqMaxCount");
    int maxCount = 1024;
    try {
        maxCount = Integer.parseInt(getString(bqMaxCount, "text"));
    } catch (final Exception e) {
        e.printStackTrace();
        showStatus("Invalid BooleanQuery max clause count, using default 1024");
    }
    QueryParser.Operator op;
    BooleanQuery.setMaxClauseCount(maxCount);
    final String opString = getString(cbOp, "text");
    if (opString.equalsIgnoreCase("OR")) {
        op = QueryParserBase.OR_OPERATOR;
    } else {
        op = QueryParserBase.AND_OPERATOR;
    }
    qp.setAllowLeadingWildcard(getBoolean(ckWild, "selected"));
    qp.setEnablePositionIncrements(getBoolean(ckPosIncr, "selected"));
    qp.setLowercaseExpandedTerms(getBoolean(ckLoExp, "selected"));
    qp.setDateResolution(resolution);
    qp.setDefaultOperator(op);
    if (getBoolean(ckXmlParser, "selected")) {

        final CoreParser cp = createParser(defField, analyzer);
        final Query q = cp.parse(new ByteArrayInputStream(queryString.getBytes("UTF-8")));
        return q;
    } else {
        return qp.parse(queryString);
    }
}

---

From source file:org.exoplatform.services.jcr.impl.core.query.SearchManager.java

License:Apache License

/**
 * Return set of uuid of nodes. Contains in names prefixes maped to the
 * given uri// w  w w.java2s  . c  o m
 * 
 * @param prefix
 * @return
 * @throws RepositoryException
 */
public Set<String> getNodesByUri(final String uri) throws RepositoryException {
    Set<String> result;
    final int defaultClauseCount = BooleanQuery.getMaxClauseCount();
    try {

        // final LocationFactory locationFactory = new
        // LocationFactory(this);
        final ValueFactoryImpl valueFactory = new ValueFactoryImpl(new LocationFactory(nsReg), cleanerHolder);
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        BooleanQuery query = new BooleanQuery();

        final String prefix = nsReg.getNamespacePrefixByURI(uri);
        query.add(new WildcardQuery(new Term(FieldNames.LABEL, prefix + ":*")), Occur.SHOULD);
        // name of the property
        query.add(new WildcardQuery(new Term(FieldNames.PROPERTIES_SET, prefix + ":*")), Occur.SHOULD);

        result = getNodes(query);

        // value of the property

        try {
            final Set<String> props = getFieldNames();

            query = new BooleanQuery();
            for (final String fieldName : props) {
                if (!FieldNames.PROPERTIES_SET.equals(fieldName)) {
                    query.add(new WildcardQuery(new Term(fieldName, "*" + prefix + ":*")), Occur.SHOULD);
                }
            }
        } catch (final IndexException e) {
            throw new RepositoryException(e.getLocalizedMessage(), e);
        }

        final Set<String> propSet = getNodes(query);
        // Manually check property values;
        for (final String uuid : propSet) {
            if (isPrefixMatch(valueFactory, uuid, prefix)) {
                result.add(uuid);
            }
        }
    } finally {
        BooleanQuery.setMaxClauseCount(defaultClauseCount);
    }

    return result;
}

---

From source file:org.fao.geonet.kernel.search.LuceneSearcher.java

License:Open Source License

/**
 * Makes a new lucene query.//from w ww.j ava 2 s. c  o  m
 *
 *  If the field to be queried is tokenized then this method applies
 *  the appropriate analyzer (see SearchManager) to the field.
 *
 * @param xmlQuery
 * @param analyzer
 * @param tokenizedFieldSet
 * @param numericFieldSet
 * @return
 * @throws Exception
 */
@SuppressWarnings({ "deprecation" })
private static Query makeQuery(Element xmlQuery, PerFieldAnalyzerWrapper analyzer,
        Set<String> tokenizedFieldSet, Map<String, LuceneConfigNumericField> numericFieldSet) throws Exception {
    if (Log.isDebugEnabled(Geonet.SEARCH_ENGINE))
        Log.debug(Geonet.SEARCH_ENGINE, "MakeQuery input XML:\n" + Xml.getString(xmlQuery));
    String name = xmlQuery.getName();
    Query returnValue;

    if (name.equals("TermQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        returnValue = LuceneSearcher.textFieldToken(xmlQuery.getAttributeValue("txt"), fld,
                xmlQuery.getAttributeValue("sim"), analyzer, tokenizedFieldSet);
    } else if (name.equals("FuzzyQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        returnValue = LuceneSearcher.textFieldToken(xmlQuery.getAttributeValue("txt"), fld,
                xmlQuery.getAttributeValue("sim"), analyzer, tokenizedFieldSet);
    } else if (name.equals("PrefixQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        String txt = LuceneSearcher.analyzeQueryText(fld, xmlQuery.getAttributeValue("txt"), analyzer,
                tokenizedFieldSet);
        returnValue = new PrefixQuery(new Term(fld, txt));
    } else if (name.equals("MatchAllDocsQuery")) {
        return new MatchAllDocsQuery();
    } else if (name.equals("WildcardQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        returnValue = LuceneSearcher.textFieldToken(xmlQuery.getAttributeValue("txt"), fld,
                xmlQuery.getAttributeValue("sim"), analyzer, tokenizedFieldSet);
    } else if (name.equals("PhraseQuery")) {
        PhraseQuery query = new PhraseQuery();
        for (Object o : xmlQuery.getChildren()) {
            Element xmlTerm = (Element) o;
            String fld = xmlTerm.getAttributeValue("fld");
            String txt = LuceneSearcher.analyzeQueryText(fld, xmlTerm.getAttributeValue("txt"), analyzer,
                    tokenizedFieldSet);
            if (txt.length() > 0) {
                query.add(new Term(fld, txt));
            }
        }
        returnValue = query;
    } else if (name.equals("RangeQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        String lowerTxt = xmlQuery.getAttributeValue("lowerTxt");
        String upperTxt = xmlQuery.getAttributeValue("upperTxt");
        String sInclusive = xmlQuery.getAttributeValue("inclusive");
        boolean inclusive = "true".equals(sInclusive);

        LuceneConfigNumericField fieldConfig = numericFieldSet.get(fld);
        if (fieldConfig != null) {
            returnValue = LuceneQueryBuilder.buildNumericRangeQueryForType(fld, lowerTxt, upperTxt, inclusive,
                    inclusive, fieldConfig.getType());
        } else {
            lowerTxt = (lowerTxt == null ? null
                    : LuceneSearcher.analyzeQueryText(fld, lowerTxt, analyzer, tokenizedFieldSet));
            upperTxt = (upperTxt == null ? null
                    : LuceneSearcher.analyzeQueryText(fld, upperTxt, analyzer, tokenizedFieldSet));

            returnValue = new TermRangeQuery(fld, lowerTxt, upperTxt, inclusive, inclusive);
        }
    } else if (name.equals("DateRangeQuery")) {
        String fld = xmlQuery.getAttributeValue("fld");
        String lowerTxt = xmlQuery.getAttributeValue("lowerTxt");
        String upperTxt = xmlQuery.getAttributeValue("upperTxt");
        String sInclusive = xmlQuery.getAttributeValue("inclusive");
        returnValue = new DateRangeQuery(fld, lowerTxt, upperTxt, sInclusive);
    } else if (name.equals("BooleanQuery")) {
        BooleanQuery query = new BooleanQuery();
        for (Object o : xmlQuery.getChildren()) {
            Element xmlBooleanClause = (Element) o;
            String sRequired = xmlBooleanClause.getAttributeValue("required");
            String sProhibited = xmlBooleanClause.getAttributeValue("prohibited");
            boolean required = sRequired != null && sRequired.equals("true");
            boolean prohibited = sProhibited != null && sProhibited.equals("true");
            BooleanClause.Occur occur = LuceneUtils.convertRequiredAndProhibitedToOccur(required, prohibited);
            @SuppressWarnings(value = "unchecked")
            List<Element> subQueries = xmlBooleanClause.getChildren();
            Element xmlSubQuery;
            if (subQueries != null && subQueries.size() != 0) {
                xmlSubQuery = subQueries.get(0);

                Query subQuery = LuceneSearcher.makeQuery(xmlSubQuery, analyzer, tokenizedFieldSet,
                        numericFieldSet);

                // If xmlSubQuery contains only a stopword the query produced is null. Protect against this
                if (subQuery != null) {
                    query.add(subQuery, occur);
                }
            }
        }
        BooleanQuery.setMaxClauseCount(16384); // FIXME: quick fix; using Filters should be better

        returnValue = query;
    } else
        throw new Exception("unknown lucene query type: " + name);

    if (Log.isDebugEnabled(Geonet.SEARCH_ENGINE))
        Log.debug(Geonet.SEARCH_ENGINE,
                "Lucene Query: " + ((returnValue != null) ? returnValue.toString() : ""));
    return returnValue;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• »