Example usage for com.mongodb.client.model Filters lt

List of usage examples for com.mongodb.client.model Filters lt

  1. HOME
  2. Java
  3. com.mongodb
  4. com.mongodb.client.model.*
  5. Filters
  6. lt

Introduction

In this page you can find the example usage for com.mongodb.client.model Filters lt.

Prototype

public static <TItem> Bson lt(final String fieldName, final TItem value)

Source Link

Document

Creates a filter that matches all documents where the value of the given field is less than the specified value.

Usage

From source file:com.avbravo.ejbjmoordb.mongodb.repository.Repository.java

/**
 * Devuelve true si no hay registros con la condicion fechay hora de inicio y fin  y el filtro que se pasa como parametro
 *
 * @param filter/*from   w w w .j a  v  a 2 s  . c om*/
 * @param namefieldOfStart
 * @param valueStart
 * @param namefieldOfEnd
 * @param valueEnd
 * @return
 */
public Boolean isAvailableBetweenDateHour(Bson filter, String namefieldOfStart, Date valueStart,
        String namefieldOfEnd, Date valueEnd) {
    try {
        //Vehiculos en viajes

        Integer count = count();
        if (count.equals(0)) {
            return true;
        }
        //inicio

        Bson b = Filters.and(Filters.gt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.gt(namefieldOfEnd, valueEnd));

        Bson c_e_f_g_h_l = Filters.or(Filters.eq(namefieldOfStart, valueStart),
                Filters.eq(namefieldOfStart, valueEnd), Filters.eq(namefieldOfEnd, valueStart),
                Filters.eq(namefieldOfEnd, valueEnd));

        Bson j = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.eq(namefieldOfEnd, valueEnd));

        Bson d = Filters.and(Filters.gt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.lt(namefieldOfEnd, valueEnd));
        Bson i = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.gt(namefieldOfEnd, valueEnd));
        Bson k = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.lt(namefieldOfEnd, valueEnd));

        Bson _filter = Filters.and(filter, or(b, c_e_f_g_h_l, d, i, j, k));

        List<T> list = findBy(_filter);

        if (list.isEmpty()) {
            return true;
        }

    } catch (Exception e) {
        Logger.getLogger(Repository.class.getName() + "isAvailableBetweenDate()").log(Level.SEVERE, null, e);
        exception = new Exception("isAvailableBetweenDate() ", e);

    }
    return false;
}

From source file:com.avbravo.ejbjmoordb.mongodb.repository.Repository.java

/**
 * Devuelve una lista de los elementos que estan en ese rango de fechas y que cumplan la condicion del filtro que se
 * pasa como parametro/*from w  ww  . j  a  v  a  2  s  .  c om*/
 *
 * @param filter
 * @param namefieldOfStart
 * @param valueStart
 * @param namefieldOfEnd
 * @param valueEnd
 * @return Devuelve una lista de los elementos que estan en ese rango de fechas y que cumplan la condicion del filtro que se
 * pasa como parametro
 */
public List<T> notAvailableBetweenDateHour(Bson filter, String namefieldOfStart, Date valueStart,
        String namefieldOfEnd, Date valueEnd) {
    try {
        //Vehiculos en viajes
        list = new ArrayList<>();
        Integer count = count();
        if (count.equals(0)) {
            return list;
        }
        //inicio

        Bson b = Filters.and(Filters.gt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.gt(namefieldOfEnd, valueEnd));

        Bson c_e_f_g_h_l = Filters.or(Filters.eq(namefieldOfStart, valueStart),
                Filters.eq(namefieldOfStart, valueEnd), Filters.eq(namefieldOfEnd, valueStart),
                Filters.eq(namefieldOfEnd, valueEnd));

        Bson j = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.eq(namefieldOfEnd, valueEnd));

        Bson d = Filters.and(Filters.gt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.lt(namefieldOfEnd, valueEnd));
        Bson i = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.gt(namefieldOfEnd, valueEnd));
        Bson k = Filters.and(Filters.lt(namefieldOfStart, valueStart), Filters.lt(namefieldOfStart, valueEnd),
                Filters.gt(namefieldOfEnd, valueStart), Filters.lt(namefieldOfEnd, valueEnd));

        Bson _filter = Filters.and(filter, or(b, c_e_f_g_h_l, d, i, j, k));

        list = findBy(_filter);

    } catch (Exception e) {
        Logger.getLogger(Repository.class.getName() + "isAvailableBetweenDate()").log(Level.SEVERE, null, e);
        exception = new Exception("isAvailableBetweenDate() ", e);

    }
    return list;
}

From source file:com.dydabo.blackbox.mongodb.tasks.MongoRangeSearchTask.java

License:Apache License

@Override
protected List<T> compute() {

    List<T> results = new ArrayList<>();

    GenericDBTableRow startTableRow = utils.convertRowToTableRow(startRow);
    GenericDBTableRow endTableRow = utils.convertRowToTableRow(endRow);
    List<Bson> filterList = new ArrayList<>();

    startTableRow.forEach((familyName, columnName, columnValue, columnValueAsString) -> {
        if (DyDaBoUtils.isValidRegex(columnValueAsString)) {
            if (DyDaBoUtils.isNumber(columnValue)) {
                filterList.add(Filters.gte(columnName, columnValue));
            } else {
                if (DyDaBoUtils.isARegex(columnValueAsString)) {
                    filterList.add(Filters.regex(columnName, columnValueAsString));
                } else {
                    filterList.add(Filters.gte(columnName, columnValueAsString));
                }//from  ww  w. j a  v  a  2 s .  c o m
            }
        }
    });

    endTableRow.forEach((familyName, columnName, columnValue, columnValueAsString) -> {
        if (DyDaBoUtils.isValidRegex(columnValueAsString)) {
            if (DyDaBoUtils.isNumber(columnValue)) {
                filterList.add(Filters.lt(columnName, columnValue));
            } else {
                if (DyDaBoUtils.isARegex(columnValueAsString)) {
                    filterList.add(Filters.regex(columnName, columnValueAsString));
                } else {
                    filterList.add(Filters.lt(columnName, columnValueAsString));
                }
            }
        }
    });

    String type = startRow.getClass().getTypeName();

    Block<Document> addToResultBlock = (Document doc) -> {
        T resultObject = new Gson().fromJson(doc.toJson(), (Type) startRow.getClass());
        if (resultObject != null) {
            results.add(resultObject);
        }
    };

    logger.finest("Filters :" + filterList);
    filterList.add(Filters.regex(MongoUtils.PRIMARYKEY, type + ":.*"));
    if (filterList.size() > 0) {
        collection.find(Filters.and(filterList)).forEach(addToResultBlock);
    } else {
        collection.find().forEach(addToResultBlock);
    }

    return results;
}

From source file:com.egopulse.querydsl.mongodb.MongodbSerializer.java

License:Apache License

@SuppressWarnings("unchecked")
@Override//from ww  w.j  av a  2 s .co  m
public Object visit(Operation<?> expr, Void context) {
    Operator op = expr.getOperator();

    /**
     * user.firstName.eq("test")
     * user.addresses.size().eq(20)
     */
    if (op == Ops.EQ) {
        return handleEqOperation(expr);
    }

    /**
     * user.firstName.ne("test")
     */
    else if (op == Ops.NE) {
        return Filters.ne(asDBKey(expr, 0), asDBValue(expr, 1));

    }

    /**
     * user.firstName.isEmpty()
      */
    else if (op == Ops.STRING_IS_EMPTY) {
        return Filters.eq(asDBKey(expr, 0), new BsonString(""));
    }

    /**
     * user.firstName.eq("test").and(user.lastName.eq("blah"))
     */
    else if (op == Ops.AND) {
        Bson leftOperation = (Bson) handle(expr.getArg(0));
        Bson rightOperation = (Bson) handle(expr.getArg(1));

        return Filters.and(leftOperation, rightOperation);
    }

    /**
     * user.firstName.not[Operation]
     */
    else if (op == Ops.NOT) {
        //Handle the not's child
        Operation<?> subOperation = (Operation<?>) expr.getArg(0);
        Operator subOp = subOperation.getOperator();
        if (subOp == Ops.IN) {
            return visit(ExpressionUtils.operation(Boolean.class, Ops.NOT_IN, subOperation.getArg(0),
                    subOperation.getArg(1)), context);
        } else {
            Bson arg = (Bson) handle(expr.getArg(0));
            return Filters.not(arg);
        }
    }

    /**
     * user.firstName.eq("test").or(user.firstName.eq("else"))
     */
    else if (op == Ops.OR) {
        Bson leftOperation = (Bson) handle(expr.getArg(0));
        Bson rightOperation = (Bson) handle(expr.getArg(1));
        return Filters.or(leftOperation, rightOperation);
    }

    /**
     * Text matching operations
     */
    else if (op == Ops.STARTS_WITH) {
        return Filters.regex(asDBKey(expr, 0), Pattern.compile("^" + regexValue(expr, 1)));

    }

    else if (op == Ops.STARTS_WITH_IC) {
        return Filters.regex(asDBKey(expr, 0),
                Pattern.compile("^" + regexValue(expr, 1), Pattern.CASE_INSENSITIVE));

    }

    else if (op == Ops.ENDS_WITH) {
        return Filters.regex(asDBKey(expr, 0), Pattern.compile(regexValue(expr, 1) + "$"));

    }

    else if (op == Ops.ENDS_WITH_IC) {
        return Filters.regex(asDBKey(expr, 0),
                Pattern.compile(regexValue(expr, 1) + "$", Pattern.CASE_INSENSITIVE));

    }

    else if (op == Ops.EQ_IGNORE_CASE) {
        return Filters.regex(asDBKey(expr, 0),
                Pattern.compile("^" + regexValue(expr, 1) + "$", Pattern.CASE_INSENSITIVE));

    }

    else if (op == Ops.STRING_CONTAINS) {
        return Filters.regex(asDBKey(expr, 0), Pattern.compile(".*" + regexValue(expr, 1) + ".*"));

    }

    else if (op == Ops.STRING_CONTAINS_IC) {
        return Filters.regex(asDBKey(expr, 0),
                Pattern.compile(".*" + regexValue(expr, 1) + ".*", Pattern.CASE_INSENSITIVE));

    }

    else if (op == Ops.MATCHES) {
        return Filters.regex(asDBKey(expr, 0), Pattern.compile(asDBValue(expr, 1).toString()));
    }

    else if (op == Ops.MATCHES_IC) {
        return Filters.regex(asDBKey(expr, 0),
                Pattern.compile(asDBValue(expr, 1).toString(), Pattern.CASE_INSENSITIVE));

    }

    else if (op == Ops.LIKE) {
        String regex = ExpressionUtils.likeToRegex((Expression) expr.getArg(1)).toString();
        return Filters.regex(asDBKey(expr, 0), Pattern.compile(regex));

    }

    else if (op == Ops.BETWEEN) {
        return Filters.and(Filters.gte(asDBKey(expr, 0), asDBValue(expr, 1)),
                Filters.lte(asDBKey(expr, 0), asDBValue(expr, 2)));
    }

    else if (op == Ops.IN) {
        int constIndex = 0;
        int exprIndex = 1;
        if (expr.getArg(1) instanceof Constant<?>) {
            constIndex = 1;
            exprIndex = 0;
        }
        if (Collection.class.isAssignableFrom(expr.getArg(constIndex).getType())) {
            @SuppressWarnings("unchecked") //guarded by previous check
            Collection<?> values = ((Constant<? extends Collection<?>>) expr.getArg(constIndex)).getConstant();
            return Filters.in(asDBKey(expr, exprIndex), values);
        }

        /**
         * user.firstName.in(user.lastName)
         */

        else {
            throw new UnsupportedOperationException();
            //                Path<?> path = (Path<?>) expr.getArg(exprIndex);
            //                Constant<?> constant = (Constant<?>) expr.getArg(constIndex);
            //                return asDBObject(asDBKey(expr, exprIndex), convert(path, constant));
        }

    }

    else if (op == Ops.NOT_IN) {
        int constIndex = 0;
        int exprIndex = 1;
        if (expr.getArg(1) instanceof Constant<?>) {
            constIndex = 1;
            exprIndex = 0;
        }
        if (Collection.class.isAssignableFrom(expr.getArg(constIndex).getType())) {
            @SuppressWarnings("unchecked") //guarded by previous check
            Collection<?> values = ((Constant<? extends Collection<?>>) expr.getArg(constIndex)).getConstant();
            return Filters.nin(asDBKey(expr, exprIndex), values);
        } else {
            throw new UnsupportedOperationException();
            //                Path<?> path = (Path<?>) expr.getArg(exprIndex);
            //                Constant<?> constant = (Constant<?>) expr.getArg(constIndex);
            //                return asDBObject(asDBKey(expr, exprIndex), asDBObject("$ne", convert(path, constant)));
        }

    }

    else if (op == Ops.COL_IS_EMPTY) {
        String field = asDBKey(expr, 0);
        return Filters.or(Filters.exists(field, false), Filters.size(field, 0));
    }

    else if (op == Ops.LT) {
        return Filters.lt(asDBKey(expr, 0), asDBValue(expr, 1));

    } else if (op == Ops.GT) {
        return Filters.gt(asDBKey(expr, 0), asDBValue(expr, 1));

    } else if (op == Ops.LOE) {
        return Filters.lte(asDBKey(expr, 0), asDBValue(expr, 1));

    } else if (op == Ops.GOE) {
        return Filters.gte(asDBKey(expr, 0), asDBValue(expr, 1));

    } else if (op == Ops.IS_NULL) {
        return Filters.exists(asDBKey(expr, 0), false);

    } else if (op == Ops.IS_NOT_NULL) {
        return Filters.exists(asDBKey(expr, 0), true);

    }

    else if (op == Ops.CONTAINS_KEY) {
        Path<?> path = (Path<?>) expr.getArg(0);
        Expression<?> key = expr.getArg(1);
        return Filters.exists(visit(path, context) + "." + key.toString(), true);

    }
    //        else if (op == MongodbOps.NEAR) {
    //            return asDBObject(asDBKey(expr, 0), asDBObject("$near", asDBValue(expr, 1)));
    //
    //        } else if (op == MongodbOps.NEAR_SPHERE) {
    //            return asDBObject(asDBKey(expr, 0), asDBObject("$nearSphere", asDBValue(expr, 1)));
    //
    //        }
    //        else if (op == MongodbOps.ELEM_MATCH) {
    //            return Filters.elemMatch(asDBKey(expr, 0), asDBValue(expr, 1));
    //        }

    throw new UnsupportedOperationException("Illegal operation " + expr);
}

From source file:com.jaeksoft.searchlib.crawler.cache.MongoDbCrawlCache.java

License:Open Source License

@Override
public long flush(long expiration) throws IOException {
    rwl.r.lock();//  w w w.j a  v  a 2s .c o m
    try {
        final Bson filter = expiration == 0 ? Filters.exists("uri")
                : Filters.lt("_id", new ObjectId(new Date(expiration)));
        indexedCollection.deleteMany(filter);
        for (GridFSFile f : contentGrid.find(filter))
            contentGrid.delete(f.getObjectId());
        long l = metaCollection.deleteMany(filter).getDeletedCount();
        return l;
    } finally {
        rwl.r.unlock();
    }
}

From source file:com.px100systems.data.plugin.storage.mongo.FilterQueryBuilder.java

License:Open Source License

@Override
public Bson convert(lt predicate) {
    return Filters.lt(predicate.getMember(), predicate.getValue());
}

From source file:eu.project.ttc.models.occstore.MongoDBOccurrenceStore.java

License:Apache License

@Override
public void deleteMany(TermSelector selector) {
    if (selector instanceof FrequencyUnderThreshholdSelector) {
        FrequencyUnderThreshholdSelector selector2 = (FrequencyUnderThreshholdSelector) selector;
        sync();/* w w w  .jav  a 2  s . c o m*/
        Stopwatch sw = Stopwatch.createStarted();
        termCollection.deleteMany(Filters.lt(FREQUENCY, selector2.getThreshhold()));
        LOGGER.debug("Terms deleted in MongoDB in {}ms", sw.elapsed(TimeUnit.MILLISECONDS));

    }
}

From source file:io.lumeer.storage.mongodb.dao.collection.MongoDataDao.java

License:Open Source License

private Bson attributeFilter(AttributeFilter filter) {
    switch (filter.getConditionType()) {
    case EQUALS://from  ww w.j  a v a2  s  .c o  m
        return Filters.eq(filter.getAttributeName(), filter.getValue());
    case NOT_EQUALS:
        return Filters.ne(filter.getAttributeName(), filter.getValue());
    case LOWER_THAN:
        return Filters.lt(filter.getAttributeName(), filter.getValue());
    case LOWER_THAN_EQUALS:
        return Filters.lte(filter.getAttributeName(), filter.getValue());
    case GREATER_THAN:
        return Filters.gt(filter.getAttributeName(), filter.getValue());
    case GREATER_THAN_EQUALS:
        return Filters.gte(filter.getAttributeName(), filter.getValue());
    }
    return null;
}

From source file:mongodb.clients.percunia.mongo.Restriction.java

License:Apache License

public static <T> Bson lt(String field, T value) {
    return Filters.lt(field, value);
}

From source file:org.eclipse.ditto.services.thingsearch.persistence.read.criteria.visitors.CreateBsonPredicateVisitor.java

License:Open Source License

@Override
public Function<String, Bson> visitLt(final Object value) {
    return fieldName -> Filters.lt(fieldName, value);
}