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

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

Introduction

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

Prototype

public static Bson size(final String fieldName, final int size) 

Source Link

Document

Creates a filter that matches all documents where the value of a field is an array of the specified size.

Usage

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

License:Apache License

protected Bson handleEqSizeOperation(Operation<?> expr) {
    Operation<?> lhs = (Operation<?>) expr.getArg(0);
    if (lhs.getOperator() == Ops.COL_SIZE || lhs.getOperator() == Ops.ARRAY_SIZE) {
        return Filters.size(asDBKey(lhs, 0), (Integer) asDBValue(expr, 1));
    } else { // Right hand must be number
        throw new UnsupportedOperationException("Illegal operation " + expr);
    }/*from  w  w w  .  j a  v  a  2s.  c  o m*/
}

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

License:Apache License

@SuppressWarnings("unchecked")
@Override/*from  www .  j a  v  a2s  .  c  o 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:org.opencb.commons.datastore.mongodb.MongoDBQueryUtils.java

License:Apache License

public static Bson createAutoFilter(String mongoDbField, String queryParam, Query query, QueryParam.Type type,
        LogicalOperator operator) throws NumberFormatException {

    List<String> queryParamList = query.getAsStringList(queryParam, getLogicalSeparator(operator));

    if (LogicalOperator.OR.equals(operator)
            && queryParamsOperatorAlwaysMatchesOperator(type, queryParamList, ComparisonOperator.EQUALS)) {
        // It is better to perform a $in operation
        return Filters.in(mongoDbField, removeOperatorsFromQueryParamList(type, queryParamList));
    } else if (LogicalOperator.AND.equals(operator)
            && queryParamsOperatorAlwaysMatchesOperator(type, queryParamList, ComparisonOperator.NOT_EQUALS)) {
        // It is better to perform a $nin operation
        return Filters.nin(mongoDbField, removeOperatorsFromQueryParamList(type, queryParamList));
    } else {// w w  w  .j av  a 2s .c  om
        List<Bson> bsonList = new ArrayList<>(queryParamList.size());
        for (String queryItem : queryParamList) {
            Matcher matcher = getPattern(type).matcher(queryItem);
            String op = "";
            String queryValueString = queryItem;
            if (matcher.find()) {
                op = matcher.group(1);
                queryValueString = matcher.group(2);
            }
            ComparisonOperator comparator = getComparisonOperator(op, type);
            switch (type) {
            case STRING:
            case TEXT:
            case TEXT_ARRAY:
                bsonList.add(createFilter(mongoDbField, queryValueString, comparator));
                break;
            case LONG:
            case LONG_ARRAY:
            case INTEGER:
            case INTEGER_ARRAY:
                bsonList.add(createFilter(mongoDbField, Long.parseLong(queryValueString), comparator));
                break;
            case DOUBLE:
            case DECIMAL:
            case DECIMAL_ARRAY:
                bsonList.add(createFilter(mongoDbField, Double.parseDouble(queryValueString), comparator));
                break;
            case BOOLEAN:
            case BOOLEAN_ARRAY:
                bsonList.add(createFilter(mongoDbField, Boolean.parseBoolean(queryValueString), comparator));
                break;
            case DATE:
            case TIMESTAMP:
                List<String> dateList = new ArrayList<>();
                dateList.add(queryValueString);
                if (!matcher.group(3).isEmpty()) {
                    dateList.add(matcher.group(4));
                    comparator = ComparisonOperator.BETWEEN;
                }
                bsonList.add(createDateFilter(mongoDbField, dateList, comparator, type));
                break;
            default:
                break;
            }
        }

        Bson filter;
        if (bsonList.size() == 0) {
            filter = Filters.size(queryParam, 0);
        } else if (bsonList.size() == 1) {
            filter = bsonList.get(0);
        } else {
            if (operator.equals(LogicalOperator.OR)) {
                filter = Filters.or(bsonList);
            } else {
                filter = Filters.and(bsonList);
            }
        }

        return filter;
    }
}