Java Spring data MongoDB搜索具有顺序的数组元素

在我的Mongo数据库中有一个名为

places

的集合，然后我得到了以下两个文档：

文档1:

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

文档2:

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

Mongo DB查询：

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

spring数据mongodb查询：

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

@存储库
公共接口PlacesRepository扩展了MongoRepository{
@查询（value=“{'routeMap.location'：{$all:？0}}”）
公共列表查找YexActLocations（列表位置）；
}

电流输出：

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

返回两个文档

所需输出：

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

只有位置在A->B->C->D的第一张单据（不是位置在D->C->B->A的单据）

关于我要找什么的解释：

{
    "place" : "PLACE_AD",
    "routeMap" : [ 
        {
            "location" : "A",
        },
        {
            "location" : "B",
        },
        {
            "location" : "C",
        },
        {
            "location" : "D",
        }
     ]
}

{
    "place" : "PLACE_DA",
    "routeMap" : [ 
        {
            "location" : "D"
        },
        {
            "location" : "C"
        },
        {
            "location" : "B"
        },
        {
            "location" : "A"
        }
     ]
}

db.places.find({ 'routeMap.location' : { '$all' : ['A', 'B'] } });

@Repository
public interface PlacesRepository extends MongoRepository<Place,String> {
   @Query(value = "{ 'routeMap.location' : { $all: ?0 } }")
   public List<Place> findByExactLocations(List<String> locations);
}

这里的问题是，上面的查询返回这两个文档，因为

routeMap.location

数组元素与

A

和

B

都匹配，即查询没有指定 数组元素。 那么，现在我如何修改查询，使其按照我所需的输出返回，即查询应该检查数组元素的顺序

---

另外，只需注意

位置

的数组索引不是固定的（即

位置

A

和

B

可以存在于数组中的任何索引处）.

我建议的技巧是，您可以将routeMap字段投影到单个字符串中，如ABCD，然后将其与您想要的序列匹配

db.collection.aggregate([
        { $unwind : '$routeMap'},
        {
            $group: {
                _id: "$place",
                "routeMap": { $push: "$routeMap.location" }
            }
        },
        {
            $project: {
                routeMap: {
                    $reduce: {
                      input: '$routeMap',
                      initialValue: '',
                      in: {
                        $concat: ['$$this','','$$value']
                      }
                    }
                }   
            }       
        },
        { $match : { 'routeMap' : 'ABCD'}}
    ]);

---

为什么不在

place

字段上使用正则表达式？像

db.places.find（{place:/AB/g}）

place

之类的东西不能从

location

派生出来，上面的示例只是一个示例

place

，刚刚更新了我的问题，以便更清楚地说明问题。我得到了错误：

assert:command失败：{“ok”：0，“errmsg”：“无效的运算符”$reduce'，“code”：15999}：聚合失败

您的mongodb版本是什么？这需要mongodb版本升级到3.4。您可以通过在mongo Shell中执行db.version（）进行检查。我们使用的是

3.2.7

，无法升级，是否还有其他解决方案？