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

List of usage examples for org.apache.lucene.search BooleanQuery setMaxClauseCount

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. BooleanQuery
  6. 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.kimios.kernel.index.IndexHelper.java

License:Open Source License

public static Query getACLQuery(Session session) throws IndexException {
    BooleanQuery.setMaxClauseCount(10240);
    BooleanQuery q1 = new BooleanQuery();
    q1.add(new WildcardQuery(new Term("DocumentOwner", session.getUserName() + "@" + session.getUserSource())),
            Occur.SHOULD);//from   w  ww  .ja v a 2 s .c  om
    q1.add(new WildcardQuery(new Term("DocumentACL", DMSecurityRule.getInstance(session.getUserName(),
            session.getUserSource(), SecurityEntityType.USER, DMSecurityRule.READRULE).getRuleHash())),
            Occur.SHOULD);
    q1.add(new WildcardQuery(new Term("DocumentACL", DMSecurityRule.getInstance(session.getUserName(),
            session.getUserSource(), SecurityEntityType.USER, DMSecurityRule.WRITERULE).getRuleHash())),
            Occur.SHOULD);
    q1.add(new WildcardQuery(new Term("DocumentACL", DMSecurityRule.getInstance(session.getUserName(),
            session.getUserSource(), SecurityEntityType.USER, DMSecurityRule.FULLRULE).getRuleHash())),
            Occur.SHOULD);
    for (Group g : session.getGroups()) {
        q1.add(new WildcardQuery(
                new Term("DocumentACL",
                        DMSecurityRule.getInstance(g.getGid(), session.getUserSource(),
                                SecurityEntityType.GROUP, DMSecurityRule.READRULE).getRuleHash())),
                Occur.SHOULD);
        q1.add(new WildcardQuery(
                new Term("DocumentACL",
                        DMSecurityRule.getInstance(g.getGid(), session.getUserSource(),
                                SecurityEntityType.GROUP, DMSecurityRule.WRITERULE).getRuleHash())),
                Occur.SHOULD);
        q1.add(new WildcardQuery(
                new Term("DocumentACL",
                        DMSecurityRule.getInstance(g.getGid(), session.getUserSource(),
                                SecurityEntityType.GROUP, DMSecurityRule.FULLRULE).getRuleHash())),
                Occur.SHOULD);
    }
    BooleanQuery q2 = new BooleanQuery();
    q2.add(new WildcardQuery(new Term("DocumentOwner", session.getUserName() + "@" + session.getUserSource())),
            Occur.MUST_NOT);
    q2.add(new WildcardQuery(new Term("DocumentACL", DMSecurityRule.getInstance(session.getUserName(),
            session.getUserSource(), SecurityEntityType.USER, DMSecurityRule.NOACCESS).getRuleHash())),
            Occur.MUST);
    BooleanQuery q3 = new BooleanQuery();
    q3.add(q1, Occur.MUST);
    q3.add(q2, Occur.MUST_NOT);
    return q3;
}

From source file:org.lexevs.system.ResourceManager.java

License:Open Source License

/**
 * Inits the.//from w  ww . j a v a  2s  .c  o  m
 * 
 * @throws Exception the exception
 */
public void init() throws Exception {
    cache_ = Collections.synchronizedMap(new LRUMap(systemVars_.getCacheSize()));

    // This increases the ability of Lucene to do queries against
    // large indexes like the MetaThesaurus without getting errors.
    BooleanQuery.setMaxClauseCount(systemVars_.getLuceneMaxClauseCount());

    codingSchemeToServerMap_ = new Hashtable<String, String>();
    sqlServerInterfaces_ = new Hashtable<String, SQLInterface>();
    historySqlServerInterfaces_ = new Hashtable<String, SQLHistoryInterface>();
    codingSchemeLocalNamesToInternalNameMap_ = new Hashtable<String, Hashtable<String, String>>();
    internalCodingSchemeNameUIDMap_ = new Hashtable<String, List<LocalCodingScheme>>();
    supportedCodingSchemeToInternalMap_ = new Hashtable<String, String>();

    // populate the registry
    //registry_ = new XmlRegistry(systemVars_.getAutoLoadRegistryPath());

    // connect to the histories
    readHistories();

    // go through all of the sql servers and read all of the available code
    // systems.
    // initialize the SQL connections to each server.

    org.lexevs.registry.service.XmlRegistry.DBEntry[] entries = registry_.getDBEntries();
    for (int i = 0; i < entries.length; i++) {
        SQLConnectionInfo temp = new SQLConnectionInfo();
        temp.driver = systemVars_.getAutoLoadDBDriver();
        temp.password = systemVars_.getAutoLoadDBPassword();
        temp.server = entries[i].dbURL;
        temp.prefix = entries[i].prefix;
        temp.username = systemVars_.getAutoLoadDBUsername();
        readTerminologiesFromServer(temp);
    }

    logger_.debug("Reading available terminologies from SQL servers.");

    // same thing as above, this time for pre-configured servers
    Hashtable<String, SQLConnectionInfo> servers = systemVars_.getSqlServers();

    Enumeration<SQLConnectionInfo> e = servers.elements();
    while (e.hasMoreElements()) {
        SQLConnectionInfo server = e.nextElement();
        readTerminologiesFromServer(server);
    }

    logger_.debug("Reading available terminologies from the lucene index locations");

    // go through all of the index locations, finding the right index for
    // each code system.
    // initialize the index readers.
    HashSet<String> indexLocations = systemVars_.getIndexLocations();
    Iterator<String> iterator = indexLocations.iterator();

    indexInterfaces_ = new Hashtable<String, IndexInterface>();
    codingSchemeToIndexMap_ = new Hashtable<String, String>();

    while (iterator.hasNext()) {
        String location = iterator.next();

        File temp = new File(location);
        if (!temp.exists() || !temp.isDirectory()) {
            logger_.error("Bad index location " + location);
        } else {

            IndexInterface is = new IndexInterface(location);
            indexInterfaces_.put(location, is);

            ArrayList<String> keys = is.getCodeSystemKeys();
            for (int i = 0; i < keys.size(); i++) {
                codingSchemeToIndexMap_.put(keys.get(i), location);
            }
        }
    }

    // Start up a thread to handle scheduled deactivations
    fdt_ = new FutureDeactivatorThread();
    deactivatorThread_ = new Thread(fdt_);
    // This allows the JVM to exit while this thread is still active.
    deactivatorThread_.setDaemon(true);
    deactivatorThread_.start();
}

From source file:org.ohdsi.usagi.UsagiSearchEngine.java

License:Apache License

public void openIndexForSearching() {
    try {//from  w ww.j a  va2s .co  m
        reader = DirectoryReader.open(FSDirectory.open(new File(folder + "/" + DERIVED_INDEX_FOLDER)));
        searcher = new IndexSearcher(reader);
        searcher.setSimilarity(new CustomSimilarity());
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        QueryParser typeQueryParser = new QueryParser(Version.LUCENE_4_9, "TYPE", new KeywordAnalyzer());
        conceptQuery = typeQueryParser.parse(CONCEPT_TYPE_STRING);
        conceptIdQueryParser = new QueryParser(Version.LUCENE_4_9, "CONCEPT_ID", new KeywordAnalyzer());
        conceptClassQueryParser = new QueryParser(Version.LUCENE_4_9, "CONCEPT_CLASS", new KeywordAnalyzer());
        vocabularyQueryParser = new QueryParser(Version.LUCENE_4_9, "VOCABULARY", new KeywordAnalyzer());
        keywordsQueryParser = new QueryParser(Version.LUCENE_4_9, "TERM", analyzer);
        domainQueryParser = new QueryParser(Version.LUCENE_4_9, "DOMAINS", analyzer);
        invalidQueryParser = new QueryParser(Version.LUCENE_4_9, "INVALID_REASON", new KeywordAnalyzer());
        numDocs = reader.numDocs();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.polymap.alkis.model.AlkisRepository.java

License:Open Source License

/**
 * Configure and initializing the one and only global instance.
 *//* www  .  ja  v a  2s. co m*/
private AlkisRepository() {
    try {
        log.info("Assembling repository...");

        //            Logging.GEOTOOLS.setLoggerFactory( "org.geotools.util.logging.CommonsLoggerFactory" );

        //
        BooleanQuery.setMaxClauseCount(MAX_RESULTS * 2);
        log.info("Maximale Anzahl Lucene-Klauseln erhht auf: " + BooleanQuery.getMaxClauseCount());

        // init fulltext
        File dataDir = new File(DATA_DIR);
        fulltextIndex = new LuceneFulltextIndex(new File(dataDir, "fulltext"));
        fulltextIndex.addTokenFilter(new LowerCaseTokenFilter());

        // store
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("dbtype", "postgis");
        params.put("host", "localhost");
        params.put("port", 5432);
        params.put("schema", "public");
        params.put("database", "ALKIS");
        params.put("user", "postgres");
        params.put("passwd", "postgres");
        params.put(JDBCDataStoreFactory.MAXCONN.key, 24);
        params.put(JDBCDataStoreFactory.MAXWAIT.key, 20);
        ds = new PostgisNGDataStoreFactory().createDataStore(params);

        // primary key: gml_id
        ((JDBCDataStore) ds).setPrimaryKeyFinder(new PrimaryKeyFinder() {
            @Override
            public PrimaryKey getPrimaryKey(JDBCDataStore store, String schema, String table, Connection cx)
                    throws SQLException {
                // Alkis_Beziehungen
                if (table.equals(Alkis_Beziehungen.TYPE.info().getNameInStore())) {
                    AutoGeneratedPrimaryKeyColumn col = new AutoGeneratedPrimaryKeyColumn("ogc_fid",
                            String.class);
                    return new PrimaryKey(table, Collections.singletonList(col));
                }
                // AX_*
                else {
                    AutoGeneratedPrimaryKeyColumn col = new AutoGeneratedPrimaryKeyColumn("gml_id",
                            String.class);
                    return new PrimaryKey(table, Collections.singletonList(col));
                }
            }
        });

        FeatureStoreAdapter store = new FeatureStoreAdapter(ds).createOrUpdateSchemas.put(false);

        // repo
        repo = EntityRepository.newConfiguration().entities.set(new Class[] { AX_Flurstueck.class,
                AX_Buchungsstelle.class, AX_Buchungsblatt.class, AX_Buchungsblattbezirk.class, AX_Person.class,
                AX_Anschrift.class, AX_LagebezeichnungMitHausnummer.class,
                AX_LagebezeichnungOhneHausnummer.class, AX_LagebezeichnungKatalog.class, AX_Namensnummer.class,
                AX_Gemarkung.class, AX_Gemeinde.class, Alkis_Beziehungen.class }).store.set(
                        //new FulltextIndexer( fulltextIndex, new TypeFilter( Waldbesitzer.class ), newArrayList( wbTransformer ),
                        store) //)
                        .create();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.polymap.kaps.ui.filter.VertraegeFuerBaujahrUndGebaeudeartFilter.java

License:Open Source License

protected Query<VertragComposite> createFilterQuery(final IFilterEditorSite site,
        final KapsRepository repository) {

    List<GebaeudeArtComposite> gebaeudeArten = (List<GebaeudeArtComposite>) site.getFieldValue("gebart");
    NutzungComposite nutzung = (NutzungComposite) site.getFieldValue("nutzung");
    VertragsArtComposite art = (VertragsArtComposite) site.getFieldValue("vertragsart");

    Object[] vertragsDatum = (Object[]) site.getFieldValue("datum");
    BooleanExpression vertragsDatumExpr = null;
    if (vertragsDatum != null) {
        VertragComposite dateTemplate = QueryExpressions.templateFor(VertragComposite.class);
        BooleanExpression ge = vertragsDatum[0] != null
                ? QueryExpressions.ge(dateTemplate.vertragsDatum(), dayStart((Date) vertragsDatum[0]))
                : null;/*from  w  ww.j  a v a 2s  . c o m*/

        BooleanExpression le = vertragsDatum[1] != null
                ? QueryExpressions.le(dateTemplate.vertragsDatum(), dayEnd((Date) vertragsDatum[1]))
                : null;

        if (ge != null) {
            vertragsDatumExpr = ge;
        }
        if (le != null) {
            vertragsDatumExpr = vertragsDatumExpr == null ? le : QueryExpressions.and(ge, le);
        }
    }

    if (art != null) {
        VertragComposite vTemplate = QueryExpressions.templateFor(VertragComposite.class);
        BooleanExpression artExpr = QueryExpressions.eq(vTemplate.vertragsArt(), art);
        if (vertragsDatumExpr == null) {
            vertragsDatumExpr = artExpr;
        } else {
            vertragsDatumExpr = QueryExpressions.and(vertragsDatumExpr, artExpr);
        }
    }

    // nach Vertragsdatum vorsortieren fhrt zu StackOverflow
    Set<VertragComposite> vertraegeNachDatum = null;
    if (vertragsDatumExpr != null) {
        vertraegeNachDatum = Sets.newHashSet();
        Query<VertragComposite> vertraege = repository().findEntities(VertragComposite.class, vertragsDatumExpr,
                0, -1);
        for (VertragComposite vertrag : vertraege) {
            vertraegeNachDatum.add(vertrag);
        }
    }

    BooleanExpression fExpr = null;
    VertragComposite template = QueryExpressions.templateFor(VertragComposite.class);

    // if (gebaeude != null || nutzung != null || gemeinde != null) {
    FlurstueckComposite flurTemplate = QueryExpressions.templateFor(FlurstueckComposite.class);

    // gemeinde
    BooleanExpression gExpr = null;
    GemeindeComposite gemeinde = (GemeindeComposite) site.getFieldValue("gemeinde");
    GemarkungComposite gemarkung = (GemarkungComposite) site.getFieldValue("gemarkung");
    if (gemarkung != null) {
        gExpr = QueryExpressions.eq(flurTemplate.gemarkung(), gemarkung);
    } else if (gemeinde != null) {
        GemarkungComposite gemarkungTemplate = QueryExpressions.templateFor(GemarkungComposite.class);
        Query<GemarkungComposite> gemarkungen = repository().findEntities(GemarkungComposite.class,
                QueryExpressions.eq(gemarkungTemplate.gemeinde(), gemeinde), 0, -1);
        for (GemarkungComposite gemarkungg : gemarkungen) {
            BooleanExpression newExpr = QueryExpressions.eq(flurTemplate.gemarkung(), gemarkungg);
            if (gExpr == null) {
                gExpr = newExpr;
            } else {
                gExpr = QueryExpressions.or(gExpr, newExpr);
            }
        }
    }

    BooleanExpression qExpr = null;
    if (gebaeudeArten != null) {
        for (GebaeudeArtComposite gebaeudeArt : gebaeudeArten) {
            BooleanExpression newExpr = QueryExpressions.eq(flurTemplate.gebaeudeArt(), gebaeudeArt);
            if (qExpr == null) {
                qExpr = newExpr;
            } else {
                qExpr = QueryExpressions.or(qExpr, newExpr);
            }
        }
    }

    BooleanExpression nExpr = nutzung != null ? QueryExpressions.eq(flurTemplate.nutzung(), nutzung) : null;

    if (qExpr != null) {
        if (gExpr != null) {
            qExpr = QueryExpressions.and(qExpr, gExpr);
        }
    } else {
        qExpr = gExpr;
    }
    if (qExpr != null) {
        if (nExpr != null) {
            qExpr = QueryExpressions.and(qExpr, nExpr);
        }
    } else {
        qExpr = nExpr;
    }

    Set<VertragComposite> vertraegeNachDatumUndFlurstueck = null;
    if (qExpr != null) {
        // flurstcke eingeschrnkt, falls keine gefunden werden ist das set leer
        vertraegeNachDatumUndFlurstueck = new HashSet<VertragComposite>();
        Query<FlurstueckComposite> flurstuecke = repository().findEntities(FlurstueckComposite.class, qExpr, 0,
                -1);
        for (FlurstueckComposite fc : flurstuecke) {
            // mehrere Flurstcke knnen einem Vertrag angehren
            VertragComposite vertrag = fc.vertrag().get();
            if (vertrag != null) {
                if (vertraegeNachDatum == null || vertraegeNachDatum.contains(vertrag)) {
                    vertraegeNachDatumUndFlurstueck.add(vertrag);
                }
            }
        }
    } else {
        // ansonsten flurstcke nicht weiter eingeschrnkt, nimm alle nach Datum
        vertraegeNachDatumUndFlurstueck = vertraegeNachDatum;
    }

    Object[] jahre = (Object[]) site.getFieldValue("baujahr");
    Set<VertragComposite> vertraegeNachDatumUndFlurstueckUndBaujahr = null;
    if (jahre != null) {
        vertraegeNachDatumUndFlurstueckUndBaujahr = new HashSet<VertragComposite>();
        VertragsdatenBaulandComposite dateTemplate = QueryExpressions
                .templateFor(VertragsdatenBaulandComposite.class);
        BooleanExpression expr2 = null;

        BooleanExpression ge = jahre[0] != null
                ? QueryExpressions.ge(dateTemplate.baujahr(), Integer.parseInt((String) jahre[0]))
                : null;

        BooleanExpression le = jahre[1] != null
                ? QueryExpressions.le(dateTemplate.baujahr(), Integer.parseInt((String) jahre[1]))
                : null;

        if (ge != null) {
            expr2 = ge;
        }
        if (le != null) {
            expr2 = expr2 == null ? le : QueryExpressions.and(ge, le);
        }
        if (expr2 != null) {
            Query<VertragsdatenBaulandComposite> daten = repository()
                    .findEntities(VertragsdatenBaulandComposite.class, expr2, 0, -1);
            for (VertragsdatenBaulandComposite kv : daten) {
                VertragComposite v = kv.vertrag().get();
                if (vertraegeNachDatumUndFlurstueck == null || vertraegeNachDatumUndFlurstueck.contains(v)) {
                    // ist schon in Menge vorhanden, also auch hier rein
                    vertraegeNachDatumUndFlurstueckUndBaujahr.add(v);
                }
            }
        }
    } else {
        vertraegeNachDatumUndFlurstueckUndBaujahr = vertraegeNachDatumUndFlurstueck;
    }

    if (vertraegeNachDatumUndFlurstueckUndBaujahr != null) {
        if (vertraegeNachDatumUndFlurstueckUndBaujahr.size() > 5000) {

            sessionDisplay().asyncExec(new Runnable() {

                public void run() {
                    MessageDialog.openError(PolymapWorkbench.getShellToParentOn(), "Zu viele Ergebnisse",
                            "Es wurden ber 5000 Ergebnisse gefunden. Bitte schrnken Sie die Suche weiter ein.");
                }
            });
            return repository().findEntities(VertragComposite.class,
                    QueryExpressions.eq(template.identity(), "unknown"), 0, -1);
        }
        for (VertragComposite vertrag : vertraegeNachDatumUndFlurstueckUndBaujahr) {
            BooleanExpression newExpr = QueryExpressions.eq(template.identity(), vertrag.id());
            if (fExpr == null) {
                fExpr = newExpr;
            } else {
                fExpr = QueryExpressions.or(fExpr, newExpr);
            }
        }
    }

    String urkunde = (String) site.getFieldValue("urkunde");
    if (urkunde != null && !urkunde.trim().isEmpty()) {
        BooleanExpression newExpr = QueryExpressions.eq(template.urkundenNummer(), urkunde.trim());
        if (fExpr == null) {
            fExpr = newExpr;
        } else {
            fExpr = QueryExpressions.and(fExpr, newExpr);
        }
    }
    String notariat = (String) site.getFieldValue("notariat");
    if (notariat != null && !notariat.trim().isEmpty()) {
        BooleanExpression newExpr = QueryExpressions.eq(template.notariat(), notariat.trim());
        if (fExpr == null) {
            fExpr = newExpr;
        } else {
            fExpr = QueryExpressions.and(fExpr, newExpr);
        }
    }
    // wenn keine gefunden, ungltige Query erzeugen, damit auch keine
    // Vertrge gefunden werden
    if (fExpr == null) {
        fExpr = QueryExpressions.eq(template.identity(), "unknown");
    }

    int oldMax = BooleanQuery.getMaxClauseCount();
    try {
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        return repository().findEntities(VertragComposite.class, fExpr, 0, getMaxResults());
    } finally {
        BooleanQuery.setMaxClauseCount(oldMax);
    }
}

From source file:org.polymap.kaps.ui.filter.VertragsdatenAgrarAgrarFilter.java

License:Open Source License

@Override
protected Query<VertragsdatenAgrarComposite> createFilterQuery(final IFilterEditorSite site,
        final KapsRepository repository) {

    List<NutzungComposite> nutzungen = (List<NutzungComposite>) site.getFieldValue("nutzung");
    List<BodennutzungComposite> bodennutzungen = (List<BodennutzungComposite>) site
            .getFieldValue("bodennutzung");
    List<GemeindeComposite> gemeinden = (List<GemeindeComposite>) site.getFieldValue("gemeinde");
    Integer nutzungsGroesseMin = (Integer) site.getFieldValue("nutzungsGroesseMin");
    Integer nutzungsGroesseMax = (Integer) site.getFieldValue("nutzungsGroesseMax");

    Object[] vertragsDatum = (Object[]) site.getFieldValue("datum");
    BooleanExpression vertragsDatumExpr = null;
    if (vertragsDatum != null) {
        VertragComposite dateTemplate = QueryExpressions.templateFor(VertragComposite.class);
        BooleanExpression ge = vertragsDatum[0] != null
                ? QueryExpressions.ge(dateTemplate.vertragsDatum(), dayStart((Date) vertragsDatum[0]))
                : null;//from  www  .j av a 2s.c  om
        BooleanExpression le = vertragsDatum[1] != null
                ? QueryExpressions.le(dateTemplate.vertragsDatum(), dayEnd((Date) vertragsDatum[1]))
                : null;
        if (ge != null) {
            vertragsDatumExpr = ge;
        }
        if (le != null) {
            vertragsDatumExpr = vertragsDatumExpr == null ? le : QueryExpressions.and(ge, le);
        }
    }

    BooleanExpression fExpr = null;
    VertragsdatenAgrarComposite template = QueryExpressions.templateFor(VertragsdatenAgrarComposite.class);

    FlurstueckComposite flurTemplate = QueryExpressions.templateFor(FlurstueckComposite.class);

    // nach Vertragsdatum vorsortieren fhrt zu StackOverflow
    Set<VertragComposite> vertraegeNachDatum = null;
    if (vertragsDatumExpr != null) {
        vertraegeNachDatum = Sets.newHashSet();
        Query<VertragComposite> vertraege = repository().findEntities(VertragComposite.class, vertragsDatumExpr,
                0, -1);
        for (VertragComposite vertrag : vertraege) {
            vertraegeNachDatum.add(vertrag);
        }
    }

    // gemeinde
    BooleanExpression gExpr = null;
    List<GemarkungComposite> gemarkungen = (List<GemarkungComposite>) site.getFieldValue("gemarkung");
    if (gemarkungen != null) {
        for (GemarkungComposite gemarkung : gemarkungen) {
            BooleanExpression newExpr = QueryExpressions.eq(flurTemplate.gemarkung(), gemarkung);
            if (gExpr == null) {
                gExpr = newExpr;
            } else {
                gExpr = QueryExpressions.or(gExpr, newExpr);
            }
        }
    } else if (gemeinden != null) {
        GemarkungComposite gemarkungTemplate = QueryExpressions.templateFor(GemarkungComposite.class);
        BooleanExpression gSubExpr = null;
        for (GemeindeComposite gemeinde : gemeinden) {
            BooleanExpression newExpr = QueryExpressions.eq(gemarkungTemplate.gemeinde(), gemeinde);
            if (gSubExpr == null) {
                gSubExpr = newExpr;
            } else {
                gSubExpr = QueryExpressions.or(gSubExpr, newExpr);
            }
        }
        if (gSubExpr == null) {
            gSubExpr = QueryExpressions.eq(gemarkungTemplate.identity(), "unknown");
        }
        Query<GemarkungComposite> subGemarkungen = repository().findEntities(GemarkungComposite.class, gSubExpr,
                0, -1);
        for (GemarkungComposite gemarkungg : subGemarkungen) {
            BooleanExpression newExpr = QueryExpressions.eq(flurTemplate.gemarkung(), gemarkungg);
            if (gExpr == null) {
                gExpr = newExpr;
            } else {
                gExpr = QueryExpressions.or(gExpr, newExpr);
            }
        }
        // gemeinde gewhlt, aber keine gemeinden gefunden
        if (gExpr == null) {
            gExpr = QueryExpressions.eq(flurTemplate.identity(), "unknown");
        }
    }

    // nutzungen
    BooleanExpression nExpr = null;
    if (nutzungen != null) {
        for (NutzungComposite nutzung : nutzungen) {
            BooleanExpression newExpr = QueryExpressions.eq(flurTemplate.nutzung(), nutzung);
            if (nExpr == null) {
                nExpr = newExpr;
            } else {
                nExpr = QueryExpressions.or(nExpr, newExpr);
            }
        }
    }

    if (nExpr != null) {
        if (gExpr != null) {
            nExpr = QueryExpressions.and(nExpr, gExpr);
        }
    } else {
        nExpr = gExpr;
    }

    Set<VertragComposite> vertraegeNachDatumUndFlurstueck = new HashSet<VertragComposite>();

    if (nExpr != null) {
        Query<FlurstueckComposite> flurstuecke = repository().findEntities(FlurstueckComposite.class, nExpr, 0,
                -1);

        for (FlurstueckComposite fc : flurstuecke) {
            // mehrere Flurstcke knnen einem Vertrag angehren
            VertragComposite vertrag = fc.vertrag().get();
            if (vertrag != null) {
                if ((vertraegeNachDatum == null || vertraegeNachDatum.contains(vertrag))) {
                    vertraegeNachDatumUndFlurstueck.add(vertrag);
                }
            }
        }
    }
    if (vertraegeNachDatumUndFlurstueck.size() > 5000) {
        sessionDisplay().asyncExec(new Runnable() {

            public void run() {
                MessageDialog.openError(PolymapWorkbench.getShellToParentOn(), "Zu viele Ergebnisse",
                        "Es wurden ber 5000 Ergebnisse gefunden. Bitte schrnken Sie die Suche weiter ein.");
            }
        });
        return repository().findEntities(VertragsdatenAgrarComposite.class,
                QueryExpressions.eq(template.identity(), "unknown"), 0, -1);
    }
    for (VertragComposite vertrag : vertraegeNachDatumUndFlurstueck) {
        BooleanExpression newExpr = QueryExpressions.eq(template.vertrag(), vertrag);
        if (fExpr == null) {
            fExpr = newExpr;
        } else {
            fExpr = QueryExpressions.or(fExpr, newExpr);
        }
    }
    // wenn keine vertrge gefunden, ungltige Query erzeugen, damit auch keine
    // Vertrge gefunden werden
    if (fExpr == null) {
        fExpr = QueryExpressions.eq(template.identity(), "unknown");
    }
    // }
    BooleanExpression bExpr = null;
    if (bodennutzungen != null) {
        for (BodennutzungComposite nutzung : bodennutzungen) {
            BooleanExpression newExpr = QueryExpressions.or(
                    QueryExpressions.eq(template.bodennutzung1(), nutzung),
                    QueryExpressions.eq(template.bodennutzung2(), nutzung),
                    QueryExpressions.eq(template.bodennutzung3(), nutzung),
                    QueryExpressions.eq(template.bodennutzung4(), nutzung),
                    QueryExpressions.eq(template.bodennutzung5(), nutzung),
                    QueryExpressions.eq(template.bodennutzung6(), nutzung));
            if (bExpr == null) {
                bExpr = newExpr;
            } else {
                bExpr = QueryExpressions.or(bExpr, newExpr);
            }
        }
    }
    if (bExpr != null) {
        fExpr = QueryExpressions.and(bExpr, fExpr);
    }

    BooleanExpression bodenExp1 = getBodennutzungExpression(template.bodennutzung1(), bodennutzungen);
    BooleanExpression bodenExp2 = getBodennutzungExpression(template.bodennutzung2(), bodennutzungen);
    BooleanExpression bodenExp3 = getBodennutzungExpression(template.bodennutzung3(), bodennutzungen);
    BooleanExpression bodenExp4 = getBodennutzungExpression(template.bodennutzung4(), bodennutzungen);
    BooleanExpression bodenExp5 = getBodennutzungExpression(template.bodennutzung5(), bodennutzungen);
    BooleanExpression bodenExp6 = getBodennutzungExpression(template.bodennutzung6(), bodennutzungen);

    BooleanExpression greaterEquals = null;
    if (nutzungsGroesseMin != null) {
        BooleanExpression nutzungExp1 = QueryExpressions.ge(template.flaechenAnteil1(),
                Double.valueOf(nutzungsGroesseMin));
        BooleanExpression nutzungExp2 = QueryExpressions.ge(template.flaechenAnteil2(),
                Double.valueOf(nutzungsGroesseMin));
        BooleanExpression nutzungExp3 = QueryExpressions.ge(template.flaechenAnteil3(),
                Double.valueOf(nutzungsGroesseMin));
        BooleanExpression nutzungExp4 = QueryExpressions.ge(template.flaechenAnteil4(),
                Double.valueOf(nutzungsGroesseMin));
        BooleanExpression nutzungExp5 = QueryExpressions.ge(template.flaechenAnteil5(),
                Double.valueOf(nutzungsGroesseMin));
        BooleanExpression nutzungExp6 = QueryExpressions.ge(template.flaechenAnteil6(),
                Double.valueOf(nutzungsGroesseMin));

        greaterEquals = QueryExpressions.or(
                (bodenExp1 != null ? QueryExpressions.and(nutzungExp1, bodenExp1) : nutzungExp1),
                (bodenExp2 != null ? QueryExpressions.and(nutzungExp2, bodenExp2) : nutzungExp2),
                (bodenExp3 != null ? QueryExpressions.and(nutzungExp3, bodenExp3) : nutzungExp3),
                (bodenExp4 != null ? QueryExpressions.and(nutzungExp4, bodenExp4) : nutzungExp4),
                (bodenExp5 != null ? QueryExpressions.and(nutzungExp5, bodenExp5) : nutzungExp5),
                (bodenExp6 != null ? QueryExpressions.and(nutzungExp6, bodenExp6) : nutzungExp6));
    }

    BooleanExpression flaecheExpression = null;
    BooleanExpression lowerEquals = null;
    if (nutzungsGroesseMax != null) {
        BooleanExpression nutzungExp1 = QueryExpressions.le(template.flaechenAnteil1(),
                Double.valueOf(nutzungsGroesseMax));
        BooleanExpression nutzungExp2 = QueryExpressions.le(template.flaechenAnteil2(),
                Double.valueOf(nutzungsGroesseMax));
        BooleanExpression nutzungExp3 = QueryExpressions.le(template.flaechenAnteil3(),
                Double.valueOf(nutzungsGroesseMax));
        BooleanExpression nutzungExp4 = QueryExpressions.le(template.flaechenAnteil4(),
                Double.valueOf(nutzungsGroesseMax));
        BooleanExpression nutzungExp5 = QueryExpressions.le(template.flaechenAnteil5(),
                Double.valueOf(nutzungsGroesseMax));
        BooleanExpression nutzungExp6 = QueryExpressions.le(template.flaechenAnteil6(),
                Double.valueOf(nutzungsGroesseMax));

        lowerEquals = QueryExpressions.or(
                (bodenExp1 != null ? QueryExpressions.and(nutzungExp1, bodenExp1) : nutzungExp1),
                (bodenExp2 != null ? QueryExpressions.and(nutzungExp2, bodenExp2) : nutzungExp2),
                (bodenExp3 != null ? QueryExpressions.and(nutzungExp3, bodenExp3) : nutzungExp3),
                (bodenExp4 != null ? QueryExpressions.and(nutzungExp4, bodenExp4) : nutzungExp4),
                (bodenExp5 != null ? QueryExpressions.and(nutzungExp5, bodenExp5) : nutzungExp5),
                (bodenExp6 != null ? QueryExpressions.and(nutzungExp6, bodenExp6) : nutzungExp6));
    }
    if (greaterEquals != null) {
        if (lowerEquals != null) {
            flaecheExpression = QueryExpressions.and(greaterEquals, lowerEquals);
        } else {
            flaecheExpression = greaterEquals;
        }
    } else {
        flaecheExpression = lowerEquals;
    }

    if (flaecheExpression != null) {
        fExpr = QueryExpressions.and(flaecheExpression, fExpr);
    }

    int oldMax = BooleanQuery.getMaxClauseCount();
    try {
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        return repository().findEntities(VertragsdatenAgrarComposite.class, fExpr, 0, getMaxResults());
    } finally {
        BooleanQuery.setMaxClauseCount(oldMax);
    }
}

From source file:org.polymap.wbv.model.WbvRepository.java

License:Open Source License

/**
 * Configure and initializing the repository.
 *//*from  www .jav  a 2  s.c  o  m*/
public static void init() {
    try {
        log.info("Assembling repository...");

        //            // find service for SERVICE_ID
        //            IService service = null;
        //            URL url = RServiceExtension.toURL( DB_NAME );
        //            ICatalog catalog = CatalogPlugin.getDefault().getLocalCatalog();
        //            List<IResolve> canditates = catalog.find( url, new NullProgressMonitor() );
        //            for (IResolve resolve : canditates) {
        //                if (resolve instanceof IService) {
        //                    service = (IService)resolve;
        //                }
        //            }
        //            if (service == null) {
        //                throw new RuntimeException( "Kein Service im Katalog fr URL: " + url );
        //            }

        //
        BooleanQuery.setMaxClauseCount(8 * 1024);
        log.info("Maximale Anzahl Lucene-Klauseln erhht auf: " + BooleanQuery.getMaxClauseCount());

        // init fulltext
        @SuppressWarnings("deprecation")
        File wbvDir = new File(Polymap.getDataDir(), WbvPlugin.ID);
        fulltextIndex = new LuceneFulltextIndex(new File(wbvDir, "fulltext"));
        fulltextIndex.setTokenizer(new WbvTokenizer());
        fulltextIndex.addTokenFilter(new LowerCaseTokenFilter());

        WaldbesitzerFulltextTransformer wbTransformer = new WaldbesitzerFulltextTransformer();

        //            // find DataStore from service
        //            DataAccess ds = service.resolve( DataAccess.class, new NullProgressMonitor() );
        //            if (ds == null) {
        //                throw new RuntimeException( "Kein DataStore fr Service: " + service );
        //            }
        // create repo
        @SuppressWarnings("deprecation")
        IRecordStore store = LuceneRecordStore.newConfiguration().indexDir
                .put(new File(Polymap.getDataDir(), "recordstore/WBV")).create();
        repo = EntityRepository.newConfiguration().entities.set(new Class[] { Revier.class, Waldstueck.class,
                Waldbesitzer.class, Kontakt.class, Flurstueck.class, Gemarkung.class }).store
                        .set(new OptimisticLocking(new FulltextIndexer(fulltextIndex,
                                new TypeFilter(Waldbesitzer.class), newArrayList(wbTransformer),
                                new RecordStoreAdapter(store)))).commitLockStrategy.set(() ->
        // other strategies are not thoroughly tested
        new CommitLockStrategy.Serialize()).create();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.quelea.services.lucene.BibleSearchIndex.java

License:Open Source License

/**
 * Search for bible chapters that match the given filter.
 *
 * @param queryString the query string to filter.
 * @param type ignored - may be null./*from   www  .  ja  v  a2 s .  c om*/
 * @return a list of all bible chapters that match the given filter.
 */
@Override
public BibleChapter[] filter(String queryString, FilterType type) {
    String sanctifyQueryString = SearchIndexUtils.makeLuceneQuery(queryString);
    if (chapters.isEmpty() || sanctifyQueryString.isEmpty()) {
        return chapters.values().toArray(new BibleChapter[chapters.size()]);
    }
    List<BibleChapter> ret;
    try (DirectoryReader dr = DirectoryReader.open(index)) {
        IndexSearcher searcher = new IndexSearcher(dr);
        BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
        Query q = new ComplexPhraseQueryParser("text", analyzer).parse(sanctifyQueryString);
        TopScoreDocCollector collector = TopScoreDocCollector.create(10000, 10000);
        searcher.search(q, collector);
        ScoreDoc[] hits = collector.topDocs().scoreDocs;
        ret = new ArrayList<>();
        for (int i = 0; i < hits.length; ++i) {
            int docId = hits[i].doc;
            Document d = searcher.doc(docId);
            BibleChapter chapter = chapters.get(Integer.parseInt(d.get("number")));
            ret.add(chapter);
        }
        return ret.toArray(new BibleChapter[ret.size()]);
    } catch (ParseException | IOException ex) {
        LOGGER.log(Level.WARNING, "Invalid query string: " + sanctifyQueryString, ex);
        return new BibleChapter[0];
    }
}

From source file:org.rssowl.core.internal.persist.search.ModelSearchImpl.java

License:Open Source License

public List<SearchHit<NewsReference>> searchNews(Collection<ISearchCondition> conditions,
        ISearchCondition scope, boolean matchAllConditions) throws PersistenceException {
    try {/*ww w  . j a  va  2  s  .c o  m*/
        return doSearchNews(conditions, scope, matchAllConditions);
    }

    /* Too Many Clauses - Increase Clauses Limit */
    catch (TooManyClauses e) {

        /* Disable Clauses Limit */
        if (BooleanQuery.getMaxClauseCount() != ModelSearchImpl.MAX_CLAUSE_COUNT) {
            BooleanQuery.setMaxClauseCount(MAX_CLAUSE_COUNT);
            return doSearchNews(conditions, scope, matchAllConditions);
        }

        /* Maximum reached */
        throw new PersistenceException(Messages.ModelSearchImpl_ERROR_WILDCARDS, e);
    }
}

From source file:org.rssowl.core.internal.persist.search.ModelSearchQueries.java

License:Open Source License

/**
 * Creates a Lucene {@link Query} from the given parameters.
 *
 * @param conditions the search conditions for the query.
 * @param scope a specific {@link ISearchCondition} that scopes the results.
 * As such, the scope condition is a must criteria for the results.
 * @param matchAllConditions <code>true</code> to match all conditions and
 * <code>false</code> otherwise.
 * @return a {@link Query} from the given parameters.
 * @throws IOException in case of an error.
 *//*from   www  .  j  av a 2s  . c  o m*/
public static Query createQuery(Collection<ISearchCondition> conditions, ISearchCondition scope,
        boolean matchAllConditions) throws IOException {
    try {
        return internalCreateQuery(conditions, scope, matchAllConditions);
    }

    /* Too Many Clauses - Increase Clauses Limit */
    catch (TooManyClauses e) {

        /* Disable Clauses Limit */
        if (BooleanQuery.getMaxClauseCount() != ModelSearchImpl.MAX_CLAUSE_COUNT) {
            BooleanQuery.setMaxClauseCount(ModelSearchImpl.MAX_CLAUSE_COUNT);
            return internalCreateQuery(conditions, scope, matchAllConditions);
        }

        /* Maximum reached */
        throw e;
    }
}