java - 如何在单个查询对象 Mongodb Spring 数据中添加 or & 和 Criteria 子句-6ren

java - 如何在单个查询对象 Mongodb Spring 数据中添加 or & 和 Criteria 子句

转载作者：可可西里更新时间：2023-11-01 09:59:08

我想同时向我的查询对象添加 or & 和子句，但我一直收到以下错误

由于 com.mongodb.BasicDBObject 的限制，您不能添加第二个“空”条件吗？

例如

query.addCriteria(new Criteria().orOperator(Some Critera);


 query.addCriteria(new Criteria().andOperator(Some Critera);

谁能帮我解决这个问题？

详细信息:

实际上我正在尝试解析以下 json 并基于解析后的 json 构建动态查询

{
  "query":{

    "where":[{

              "or":[
              {
                 "fieldName":"address1","fieldValue":"Dummy address1",

                 "operator":"equal"
              }

            ],
            "and":[{
                  "fieldName":"version","fieldValue":"1",

                 "operator":"equal"

             }]
           }
        ]
   }
}

所以你可以建议我使用 mongoTemplate Spring 数据将该 json 解析为 Mongodb 查询的其他方法

这是我的解析代码

if(null != eventSearch.getQuery())
        {

            if(null != eventSearch.getQuery().getWhere() && eventSearch.getQuery().getWhere().size() > 0)
            {

                for (Where whereClause : eventSearch.getQuery().getWhere()) {

                      if(null != whereClause.getOr() && whereClause.getOr().size() > 0){

                          List<org.springframework.data.mongodb.core.query.Criteria> orCriterias = new ArrayList<org.springframework.data.mongodb.core.query.Criteria>(whereClause.getOr().size());

                          for (Field field: whereClause.getOr()) {

                              if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                              {
                                orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                              }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                                orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                               }
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                               }
                          } 

                          query.addCriteria(new org.springframework.data.mongodb.core.query.Criteria().orOperator(orCriterias.toArray(new org.springframework.data.mongodb.core.query.Criteria[whereClause.getOr().size()])));
                      }

                      if(null != whereClause.getAnd() && whereClause.getAnd().size() > 0){

                          List<org.springframework.data.mongodb.core.query.Criteria> andCriterias = new ArrayList<org.springframework.data.mongodb.core.query.Criteria>(whereClause.getAnd().size());

                          for (Field field: whereClause.getAnd()) {

                              if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                              {
                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                              }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                               }
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                               }
                          } 
                          //Getting exception at this line
                          query.addCriteria(new org.springframework.data.mongodb.core.query.Criteria().andOperator(andCriterias.toArray(new org.springframework.data.mongodb.core.query.Criteria[whereClause.getAnd().size()])));
                      }
}}

最佳答案

你的代码太乱了，我换成了org.springframework.data.mongodb.core.query.Criteria与 Criteria暂时。

    // added
    Query query = new Query();

    if(null != eventSearch.getQuery())
    {

        if(null != eventSearch.getQuery().getWhere() && eventSearch.getQuery().getWhere().size() > 0)
        {
            // added
            List<Criteria> wheres = new ArrayList<>();

            for (Where whereClause : eventSearch.getQuery().getWhere()) {

                // added
                Criteria where = new Criteria();

                  if(null != whereClause.getOr() && whereClause.getOr().size() > 0){

                      List<Criteria> orCriterias = new ArrayList<Criteria>(whereClause.getOr().size());

                      for (Field field: whereClause.getOr()) {

                          if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                          {
                            orCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                          }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                            orCriterias.add(Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                              orCriterias.add(Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                              orCriterias.add(Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                           }
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                              orCriterias.add(Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                           }
                      } 

                      // comment out
                      // query.addCriteria(new Criteria().orOperator(orCriterias.toArray(new Criteria[whereClause.getOr().size()])));

                      // replaced with
                      if (orCriterias.size() > 0) {
                          where.orOperator(orCriterias.toArray(new Criteria[0]));
                      }
                  }

                  if(null != whereClause.getAnd() && whereClause.getAnd().size() > 0){

                      List<Criteria> andCriterias = new ArrayList<Criteria>(whereClause.getAnd().size());

                      for (Field field: whereClause.getAnd()) {

                          if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                          {
                              andCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                          }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                              andCriterias.add(Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                              andCriterias.add(Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                              andCriterias.add(Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                           }
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                              andCriterias.add(Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                           }
                      } 

                      // comment out
                      // //Getting exception at this line
                      // query.addCriteria(new Criteria().andOperator(andCriterias.toArray(new Criteria[whereClause.getAnd().size()])));

                      // replaced with
                      if (andCriterias.size() > 0) {
                          where.andOperator(andCriterias.toArray(new Criteria[0]));
                      }

                  }

                  // added
                  wheres.add(where);
                }
                // added
                if (wheres.size() > 0) {
                    query.addCriteria(new Criteria().andOperator(wheres.toArray(new Criteria[0])));
                }
            }
    }

如果您的运营商只包括 == != < <= > >= ，您可以尝试通过直接或间接更改 JSON 来缩短代码，如下所示:

{
  "query":{

    "where":[{

              "or":[
              {
                 "fieldName":"address1","fieldValue":"Dummy address1",

                 "operator":"equal"
              },
              {
                 "fieldName":"address1","fieldValue":"Dummy address2",

                 "operator":"$gt" // added: greater than
              },
              {
                 "fieldName":"address1","fieldValue":"Dummy address3",

                 "operator":"$ne" // added: not equal
              }

            ],
            "and":[{
                  "fieldName":"version","fieldValue":"1",

                 "operator":"equal"

             }]
           }
        ]
   }
}

那么，部分代码可以这样写:

  for (Field field: whereClause.getAnd()) {

      if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
      {
          andCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

      } else {
          andCriterias.add(Criteria.where(field.getOperator()).is(new BasicDBObject(field.getFieldName(), field.getFieldValue())));
      }
  }

whereClause.getOr()类似于 whereClause.getAnd() , 然后您可以将它们组合在一个循环中以根据需要缩短代码。

关于java - 如何在单个查询对象 Mongodb Spring 数据中添加 or & 和 Criteria 子句，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25425577/

文章推荐： mongodb - 在 mongodb 中查找特定日期的数据

文章推荐： python - 批量运行 python 脚本并等待执行返回

文章推荐： windows - 如何从 heroku 中的 postgresql 获取表？

hibernate-criteria - 如何将 Hibernate Criteria 对象用于多个和/或条件
我需要创建一个 Hibernate 标准限制，或者 3 个条件。问题是最后一个条件实际上是使用 AND 运算符的条件。我的第一个条件: Criterion startInRange = Restri
java - JPA Criteria 类似于 Hibernate Criteria Alias
假设我的类型为 User，其中包含带有属性 Name 的类 Tenant 的对象。我想从数据库用户中选择，其租户包含给定名称。在 Hibernate Criteria 中，我可以使用别名简单地实现
java - 从 SQL 查询生成案例表达式 - Criteria Builder、Criteria Query
select (case when dob = '2020-02-03' then 'adult' else 'teenage' end) as Age
java - 为什么 hibernate Criteria 不维护 criteria.list() 结果的顺序？
我正在使用 Java 中的 hibernate 条件进行 MySql 查询。我在下面给出了我的代码的小快照。 Criteria criteria = getCurrentSession
java.lang.AbstractMethodError : org. hibernate.ejb.criteria.CriteriaBuilderImpl.createCriteriaDelete()Ljavax/persistence/criteria/CriteriaDelete;
我正在尝试使用条件查询进行删除。但看起来不错，但在运行时显示错误。我收到如下错误: Caused by: java.lang.AbstractMethodError: org.hibernate.ej
criteria - 半边塌陷
我目前正在尝试实现半边折叠以执行增量重新网格化。我正在处理流形网格。考虑以下简单网格: 目标是将 a 折叠成 b。然而，在这种情况下，这会导致非流形网格我想阻止。我的问题是: 我怎样才能提前做到这
criteria - 对编程作业进行评分的良好标准是什么？
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
火力地堡分析 : Retention criteria
我正在考虑为我的应用使用 Firebase Analytics。我很好奇: 保留的标准是什么？保留是否跟踪具有我必须发送的唯一 ID 或唯一设备的用户帐户？如果用户从多个设备登录到我的应用程序，我将
Grails with Criteria 测试
我想测试一个“withCriteria”闭包，但不知道如何去做。我看到了如何模拟 withCriteria 调用，但没有测试闭包中的代码。在运行执行“withCriteria”的测试时，我不断收到 M
Hibernate Criteria 连接查询
如何从以下 sql 创建 Hibernate 条件查询？ String hql = "select e.employeeId,m.meetingId,e.firstname from Employee
Hibernate Criteria - 如何过滤嵌套子项？
我担心我可能已经表达了我的previous question很糟糕，所以为了清楚起见，我重新开始。想象许多表，每个表之间存在 OneToMany 关联；农场 -> 田地 -> RegionGrou
Hibernate Criteria 关联查询
我将如何使用条件 API 执行以下 Hibernate 查询。我有一个对象 Parent 和 List Children。我想搜索所有 parent 并找到哪些 parent 包含指定的 child
SQL : Sum by criteria
我正在使用 Oracle，目前无法实现我需要的查询。假设我有下表: - ID Date Type Value - 1 01/12/2016 prod 1 - 2
JPA Criteria 选择组中具有最大值的所有实例
有没有办法用 JPA 2 CriteriaBuilder 编写与以下查询等效的内容？ select * from season s1 where end = ( select max(end)
Hibernate Criteria 通过聚合进行限制
背景我们定期对多个项目进行测试，并产生测试结果(通过或失败)。单个测试可以应用于多个项目，单个项目可以对其进行多个不同的测试。我们需要做的是生成当前未通过测试的所有项目/测试组合的列表，以及自上次
java - Criteria 查询返回所有记录
SQL: String hql1 = "SELECT /* PARALLEL(MVR,16) PARALLEL(MVRS,16)*/ * FROM ICM MINUS SELECT I1.* FRO
Hibernate - setProjection after Criteria
为什么这是不可能的？ Criteria crit1 = sess.createCriteria(Criteria1Class.class); Criteria crit2 = crit1.creat
java - Criteria 添加顺序作为列操作
我通常在 hibernate 状态下使用 criteria.addOrder(Order.desc("myField")); 如何在不使用 hsql 的情况下在 Hibernate 中编写此语句？ s
sql - Where Criteria on 空场
假设我有一个具有以下值的表 Plan。 planName(VARCHAR2) | validFrom(timestamp) | validTo(timestamp) -----------------
java - Criteria 查询中的数学运算符
给定映射的 hibernate 类: @Entity public class MyTestClass { /* id and stuff */ private Integer aValue;

可可西里

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 如何在单个查询对象 Mongodb Spring 数据中添加 or & 和 Criteria 子句