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

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

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. BooleanQuery
  6. BooleanQuery

Introduction

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

Prototype

BooleanQuery

Source Link

Usage

From source file:com.stratio.cassandra.index.query.Search.java

License:Apache License

/**
 * Returns the Lucene {@link Query} representation of this search. This {@link Query} include both the querying and
 * filtering {@link Condition}s. If none of them is set, then a {@link MatchAllDocsQuery} is returned, so it never
 * returns {@code null}.//w w  w  . j a  v a  2 s.  co m
 *
 * @param schema     The {@link Schema} to be used.
 * @param rangeQuery An additional range {@link Query} to be used.
 * @return The Lucene {@link Query} representation of this search.
 */
public Query query(Schema schema, Query rangeQuery) {
    if (queryCondition == null && filterCondition == null && rangeQuery == null) {
        return new MatchAllDocsQuery();
    }
    BooleanQuery booleanQuery = new BooleanQuery();
    if (queryCondition != null) {
        Query query = queryCondition.query(schema);
        booleanQuery.add(query, BooleanClause.Occur.MUST);
    }
    if (filterCondition != null) {
        Query query = new ConstantScoreQuery(filterCondition.query(schema));
        booleanQuery.add(query, BooleanClause.Occur.MUST);
    }
    if (rangeQuery != null) {
        booleanQuery.add(rangeQuery, BooleanClause.Occur.MUST);
    }
    return booleanQuery;
}

From source file:com.stratio.cassandra.index.RowMapperWide.java

License:Apache License

/**
 * Returns the Lucene {@link Filter} to get the {@link Document}s satisfying the specified {@link DataRange}.
 *
 * @param dataRange A {@link DataRange}.
 * @return The Lucene {@link Filter} to get the {@link Document}s satisfying the specified {@link DataRange}.
 *//*from w w w  .j  a  v  a 2s.c  o  m*/
public Query query(DataRange dataRange) {
    RowPosition startPosition = dataRange.startKey();
    RowPosition stopPosition = dataRange.stopKey();
    Token startToken = startPosition.getToken();
    Token stopToken = stopPosition.getToken();
    boolean isSameToken = startToken.compareTo(stopToken) == 0 && !tokenMapper.isMinimum(startToken);
    BooleanClause.Occur occur = isSameToken ? MUST : SHOULD;
    boolean includeStart = tokenMapper.includeStart(startPosition);
    boolean includeStop = tokenMapper.includeStop(stopPosition);

    SliceQueryFilter sqf = null;
    if (startPosition instanceof DecoratedKey) {
        sqf = (SliceQueryFilter) dataRange.columnFilter(((DecoratedKey) startPosition).getKey());
    } else {
        sqf = (SliceQueryFilter) dataRange.columnFilter(ByteBufferUtil.EMPTY_BYTE_BUFFER);
    }
    Composite startName = sqf.start();
    Composite stopName = sqf.finish();

    BooleanQuery query = new BooleanQuery();

    if (!startName.isEmpty()) {
        BooleanQuery q = new BooleanQuery();
        q.add(tokenMapper.query(startToken), MUST);
        q.add(clusteringKeyMapper.query(startName, null), MUST);
        query.add(q, occur);
        includeStart = false;
    }

    if (!stopName.isEmpty()) {
        BooleanQuery q = new BooleanQuery();
        q.add(tokenMapper.query(stopToken), MUST);
        q.add(clusteringKeyMapper.query(null, stopName), MUST);
        query.add(q, occur);
        includeStop = false;
    }

    if (!isSameToken) {
        Query rangeQuery = tokenMapper.query(startToken, stopToken, includeStart, includeStop);
        if (rangeQuery != null)
            query.add(rangeQuery, SHOULD);
    } else if (query.getClauses().length == 0) {
        return tokenMapper.query(startToken);
    }

    return query.getClauses().length == 0 ? null : query;
}

From source file:com.stratio.cassandra.index.RowMapperWide.java

License:Apache License

/**
 * Returns the Lucene {@link Query} to get the {@link Document}s satisfying the specified partition key and {@link
 * RangeTombstone}.//from   ww w .j  a v a2s  .  c  o m
 *
 * @param partitionKey   A partition key.
 * @param rangeTombstone A {@link RangeTombstone}.
 * @return The Lucene {@link Query} to get the {@link Document}s satisfying the specified partition key and {@link
 * RangeTombstone}.
 */
public Query query(DecoratedKey partitionKey, RangeTombstone rangeTombstone) {
    BooleanQuery query = new BooleanQuery();
    query.add(partitionKeyMapper.query(partitionKey), MUST);
    query.add(clusteringKeyMapper.query(rangeTombstone.min, rangeTombstone.max), MUST);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.BitemporalCondition.java

License:Apache License

/**
 * {@inheritDoc}/* w w  w.  j a v  a2 s  . c  o m*/
 */
@Override
public Query query(Schema schema) {

    Mapper mapper = schema.getMapper(field);
    if (!(mapper instanceof BitemporalMapper)) {
        throw new IllegalArgumentException("BiTemporal mapper required");
    }
    BitemporalMapper bitemporalMapper = (BitemporalMapper) mapper;

    BitemporalMapper.BitemporalDateTime vt_from = this.vtFrom == null
            ? new BitemporalMapper.BitemporalDateTime(DEFAULT_FROM)
            : bitemporalMapper.parseBiTemporalDate(this.vtFrom);
    BitemporalMapper.BitemporalDateTime vt_to = this.vtTo == null
            ? new BitemporalMapper.BitemporalDateTime(DEFAULT_TO)
            : bitemporalMapper.parseBiTemporalDate(this.vtTo);
    BitemporalMapper.BitemporalDateTime tt_from = this.ttFrom == null
            ? new BitemporalMapper.BitemporalDateTime(DEFAULT_FROM)
            : bitemporalMapper.parseBiTemporalDate(this.ttFrom);
    BitemporalMapper.BitemporalDateTime tt_to = this.ttTo == null
            ? new BitemporalMapper.BitemporalDateTime(DEFAULT_TO)
            : bitemporalMapper.parseBiTemporalDate(this.ttTo);

    BooleanQuery query = new BooleanQuery();
    NumberRangePrefixTreeStrategy[] validTimeStrategies = new NumberRangePrefixTreeStrategy[4];
    DateRangePrefixTree[] validTimeTrees = new DateRangePrefixTree[4];
    NumberRangePrefixTreeStrategy[] transactionTimeStrategies = new NumberRangePrefixTreeStrategy[4];
    DateRangePrefixTree[] transactionTimeTrees = new DateRangePrefixTree[4];
    for (int i = 0; i < 4; i++) {
        validTimeStrategies[i] = bitemporalMapper.getStrategy(i, true);
        transactionTimeStrategies[i] = bitemporalMapper.getStrategy(i, false);
        validTimeTrees[i] = bitemporalMapper.getTree(i, true);
        transactionTimeTrees[i] = bitemporalMapper.getTree(i, false);
    }

    if (!tt_from.isNow() && (tt_to.compareTo(vt_from) >= 0)) {
        //R1,R2,R3,R4

        Query vQueryT1 = makeNormalQuery(bitemporalMapper, validTimeStrategies[0], validTimeTrees[0],
                BitemporalMapper.BitemporalDateTime.MIN, vt_to);
        Query tQueryT1 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[0],
                transactionTimeTrees[0], BitemporalMapper.BitemporalDateTime.MIN, tt_to);

        BooleanQuery t1Query = new BooleanQuery();
        t1Query.add(vQueryT1, MUST);
        t1Query.add(tQueryT1, MUST);
        query.add(t1Query, SHOULD);

        Query vQueryT2 = makeNormalQuery(bitemporalMapper, validTimeStrategies[1], validTimeTrees[1], vt_from,
                vt_to);
        Query tQueryT2 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[1],
                transactionTimeTrees[1], BitemporalMapper.BitemporalDateTime.MIN, tt_to);
        BooleanQuery t2Query = new BooleanQuery();
        t2Query.add(vQueryT2, MUST);
        t2Query.add(tQueryT2, MUST);
        query.add(t2Query, SHOULD);

        Query vQueryT3 = makeNormalQuery(bitemporalMapper, validTimeStrategies[2], validTimeTrees[2],
                BitemporalMapper.BitemporalDateTime.MIN, vt_to);
        Query tQueryT3 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[2],
                transactionTimeTrees[2], BitemporalMapper.BitemporalDateTime.max(tt_from, vt_from), tt_to);
        BooleanQuery t3Query = new BooleanQuery();
        t3Query.add(vQueryT3, MUST);
        t3Query.add(tQueryT3, MUST);
        query.add(t3Query, SHOULD);

        Query vQueryT4 = makeNormalQuery(bitemporalMapper, validTimeStrategies[3], validTimeTrees[3], vt_from,
                vt_to);
        Query tQueryT4 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[3],
                transactionTimeTrees[3], tt_from, tt_to);
        BooleanQuery t4Query = new BooleanQuery();
        t4Query.add(vQueryT4, MUST);
        t4Query.add(tQueryT4, MUST);
        query.add(t4Query, SHOULD);

    } else if ((!tt_from.isNow()) && (tt_to.compareTo(vt_from) < 0)) {
        //R2,R4
        Query vQueryT2 = makeNormalQuery(bitemporalMapper, validTimeStrategies[1], validTimeTrees[1], vt_from,
                vt_to);
        Query tQueryT2 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[1],
                transactionTimeTrees[1], BitemporalMapper.BitemporalDateTime.MIN, tt_to);
        BooleanQuery t2Query = new BooleanQuery();
        t2Query.add(vQueryT2, MUST);
        t2Query.add(tQueryT2, MUST);
        query.add(t2Query, SHOULD);

        Query vQueryT4 = makeNormalQuery(bitemporalMapper, validTimeStrategies[3], validTimeTrees[3], vt_from,
                vt_to);
        Query tQueryT4 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[3],
                transactionTimeTrees[3], tt_from, tt_to);
        BooleanQuery t4Query = new BooleanQuery();
        t4Query.add(vQueryT4, MUST);
        t4Query.add(tQueryT4, MUST);
        query.add(t4Query, SHOULD);

    } else if (tt_from.isNow()) {
        if (((!vt_from.isMin()) || (!vt_to.isMax())) && (tt_to.compareTo(vt_from) >= 0)) {
            //R1,R2
            Query vQueryT1 = makeNormalQuery(bitemporalMapper, validTimeStrategies[0], validTimeTrees[0],
                    BitemporalMapper.BitemporalDateTime.MIN, vt_to);
            Query tQueryT1 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[0],
                    transactionTimeTrees[0], BitemporalMapper.BitemporalDateTime.MIN, tt_to);

            BooleanQuery t1Query = new BooleanQuery();
            t1Query.add(vQueryT1, MUST);
            t1Query.add(tQueryT1, MUST);
            query.add(t1Query, SHOULD);

            Query vQueryT2 = makeNormalQuery(bitemporalMapper, validTimeStrategies[1], validTimeTrees[1],
                    vt_from, vt_to);
            Query tQueryT2 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[1],
                    transactionTimeTrees[1], BitemporalMapper.BitemporalDateTime.MIN, tt_to);
            BooleanQuery t2Query = new BooleanQuery();
            t2Query.add(vQueryT2, MUST);
            t2Query.add(tQueryT2, MUST);
            query.add(t2Query, SHOULD);

        } else if (((!vt_from.isMin()) || (!vt_to.isMax())) && (tt_to.compareTo(vt_from) < 0)) {
            //R2
            Query vQueryT2 = makeNormalQuery(bitemporalMapper, validTimeStrategies[1], validTimeTrees[1],
                    vt_from, vt_to);
            Query tQueryT2 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[1],
                    transactionTimeTrees[1], BitemporalMapper.BitemporalDateTime.MIN, tt_to);
            BooleanQuery t2Query = new BooleanQuery();
            t2Query.add(vQueryT2, MUST);
            t2Query.add(tQueryT2, MUST);
            query.add(t2Query, SHOULD);

        } else if ((vt_from.isMin()) && (vt_to.isMax())) { // [vtFrom, vtTo]==[tmin,tmax]])
            //R1,R2
            Query vQueryT1 = makeNormalQuery(bitemporalMapper, validTimeStrategies[0], validTimeTrees[0],
                    BitemporalMapper.BitemporalDateTime.MIN, BitemporalMapper.BitemporalDateTime.MAX);
            Query tQueryT1 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[0],
                    transactionTimeTrees[0], BitemporalMapper.BitemporalDateTime.MIN,
                    BitemporalMapper.BitemporalDateTime.MAX);

            BooleanQuery t1Query = new BooleanQuery();
            t1Query.add(vQueryT1, MUST);
            t1Query.add(tQueryT1, MUST);
            query.add(t1Query, SHOULD);

            Query vQueryT2 = makeNormalQuery(bitemporalMapper, validTimeStrategies[1], validTimeTrees[1],
                    BitemporalMapper.BitemporalDateTime.MIN, BitemporalMapper.BitemporalDateTime.MAX);
            Query tQueryT2 = makeNormalQuery(bitemporalMapper, transactionTimeStrategies[1],
                    transactionTimeTrees[1], BitemporalMapper.BitemporalDateTime.MIN,
                    BitemporalMapper.BitemporalDateTime.MAX);

            BooleanQuery t2Query = new BooleanQuery();
            t2Query.add(vQueryT2, MUST);
            t2Query.add(tQueryT2, MUST);
            query.add(t2Query, SHOULD);
        }
    }
    query.setBoost(boost);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.ContainsCondition.java

License:Apache License

/** {@inheritDoc} */
@Override/*  w w  w  . j av  a2 s  . c om*/
public Query query(Schema schema) {
    BooleanQuery query = new BooleanQuery();
    for (Object value : values) {
        Condition condition = new MatchCondition(boost, field, value);
        query.add(condition.query(schema), BooleanClause.Occur.SHOULD);
    }
    query.setBoost(boost);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.GeoDistanceCondition.java

License:Apache License

/** {@inheritDoc} */
@Override//w  ww  . j a  va2s . c  o  m
public Query query(Schema schema) {

    Mapper mapper = schema.getMapper(field);
    if (!(mapper instanceof GeoPointMapper)) {
        throw new IllegalArgumentException("Geo point mapper required");
    }
    GeoPointMapper geoPointMapper = (GeoPointMapper) mapper;
    SpatialStrategy spatialStrategy = geoPointMapper.getStrategy();

    BooleanQuery query = new BooleanQuery();
    query.add(query(maxGeoDistance, spatialStrategy), BooleanClause.Occur.MUST);
    if (minGeoDistance != null) {
        query.add(query(minGeoDistance, spatialStrategy), BooleanClause.Occur.MUST_NOT);
    }
    query.setBoost(boost);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.MatchCondition.java

License:Apache License

/** {@inheritDoc} */
@Override/*from  w  ww  .j  av a  2s  .c  o m*/
public Query query(Schema schema) {
    SingleColumnMapper<?> columnMapper = getMapper(schema, field);
    Class<?> clazz = columnMapper.baseClass();
    Query query;
    if (clazz == String.class) {
        String value = (String) columnMapper.base(field, this.value);
        Analyzer analyzer = schema.getAnalyzer();
        QueryBuilder queryBuilder = new QueryBuilder(analyzer);
        query = queryBuilder.createPhraseQuery(field, value, 0);
        if (query == null)
            query = new BooleanQuery();
    } else if (clazz == Integer.class) {
        Integer value = (Integer) columnMapper.base(field, this.value);
        query = NumericRangeQuery.newIntRange(field, value, value, true, true);
    } else if (clazz == Long.class) {
        Long value = (Long) columnMapper.base(field, this.value);
        query = NumericRangeQuery.newLongRange(field, value, value, true, true);
    } else if (clazz == Float.class) {
        Float value = (Float) columnMapper.base(field, this.value);
        query = NumericRangeQuery.newFloatRange(field, value, value, true, true);
    } else if (clazz == Double.class) {
        Double value = (Double) columnMapper.base(field, this.value);
        query = NumericRangeQuery.newDoubleRange(field, value, value, true, true);
    } else {
        String message = String.format("Match queries are not supported by %s mapper", clazz.getSimpleName());
        throw new UnsupportedOperationException(message);
    }
    query.setBoost(boost);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.PhraseCondition.java

License:Apache License

/** {@inheritDoc} */
@Override/*w  w  w .  ja  va2 s .  c  om*/
public Query query(Schema schema) {
    SingleColumnMapper<?> columnMapper = getMapper(schema, field);
    Class<?> clazz = columnMapper.baseClass();
    if (clazz == String.class) {
        Analyzer analyzer = schema.getAnalyzer();
        QueryBuilder queryBuilder = new QueryBuilder(analyzer);
        Query query = queryBuilder.createPhraseQuery(field, value, slop);
        if (query == null)
            query = new BooleanQuery();
        query.setBoost(boost);
        return query;
    } else {
        String message = String.format("Unsupported query %s for mapper %s", this, columnMapper);
        throw new UnsupportedOperationException(message);
    }
}

From source file:com.stratio.cassandra.lucene.search.Search.java

License:Apache License

/**
 * Returns the Lucene {@link Query} representation of this search. This {@link Query} include both the querying and
 * filtering {@link Condition}s. If none of them is set, then a {@link MatchAllDocsQuery} is returned, so it never
 * returns {@code null}.//from   w  ww.  j  a  v a  2 s.  c o  m
 *
 * @param schema     The {@link Schema} to be used.
 * @param rangeQuery An additional range {@link Query} to be used.
 * @return The Lucene {@link Query} representation of this search.
 */
public Query query(Schema schema, Query rangeQuery) {
    if (queryCondition == null && filterCondition == null && rangeQuery == null) {
        return new MatchAllDocsQuery();
    }
    BooleanQuery booleanQuery = new BooleanQuery();
    if (queryCondition != null) {
        Query query = queryCondition.query(schema);
        booleanQuery.add(query, BooleanClause.Occur.MUST);
    }
    if (filterCondition != null) {
        Query query = filterCondition.query(schema);
        booleanQuery.add(query, BooleanClause.Occur.FILTER);
    }
    if (rangeQuery != null) {
        booleanQuery.add(rangeQuery, BooleanClause.Occur.FILTER);
    }
    return booleanQuery;
}

From source file:com.stratio.cassandra.lucene.service.RowMapperWide.java

License:Apache License

/**
 * Returns the Lucene {@link Query} to get the {@link Document}s satisfying the specified {@link DataRange}.
 *
 * @param dataRange A {@link DataRange}.
 * @return The Lucene {@link Query} to get the {@link Document}s satisfying the specified {@link DataRange}.
 *//*  w  ww. java2 s.  c  om*/
public Query query(DataRange dataRange) {
    RowPosition startPosition = dataRange.startKey();
    RowPosition stopPosition = dataRange.stopKey();
    Token startToken = startPosition.getToken();
    Token stopToken = stopPosition.getToken();
    boolean isSameToken = startToken.compareTo(stopToken) == 0 && !tokenMapper.isMinimum(startToken);
    BooleanClause.Occur occur = isSameToken ? MUST : SHOULD;
    boolean includeStart = tokenMapper.includeStart(startPosition);
    boolean includeStop = tokenMapper.includeStop(stopPosition);

    SliceQueryFilter sqf;
    if (startPosition instanceof DecoratedKey) {
        sqf = (SliceQueryFilter) dataRange.columnFilter(((DecoratedKey) startPosition).getKey());
    } else {
        sqf = (SliceQueryFilter) dataRange.columnFilter(ByteBufferUtil.EMPTY_BYTE_BUFFER);
    }
    Composite startName = sqf.start();
    Composite stopName = sqf.finish();

    BooleanQuery query = new BooleanQuery();

    if (!startName.isEmpty()) {
        BooleanQuery q = new BooleanQuery();
        q.add(tokenMapper.query(startToken), MUST);
        q.add(clusteringKeyMapper.query(startName, null), MUST);
        query.add(q, occur);
        includeStart = false;
    }

    if (!stopName.isEmpty()) {
        BooleanQuery q = new BooleanQuery();
        q.add(tokenMapper.query(stopToken), MUST);
        q.add(clusteringKeyMapper.query(null, stopName), MUST);
        query.add(q, occur);
        includeStop = false;
    }

    if (!isSameToken) {
        Query rangeQuery = tokenMapper.query(startToken, stopToken, includeStart, includeStop);
        if (rangeQuery != null)
            query.add(rangeQuery, SHOULD);
    } else if (query.getClauses().length == 0) {
        return tokenMapper.query(startToken);
    }

    return query.getClauses().length == 0 ? null : query;
}