做外贸球衣用什么网站,网站开发恶意索赔,做设计什么兼职网站建设,富利建设集团有限公司网站文章目录 1. $1. 更新数组中的值2. 更新数组中的嵌入文档 2. $[]1. 更新数组中的所有元素2. 更新数组中的所有嵌入文档 3. $pop1. 删除数组的第一个元素2. 删除数组的最后一个元素 4. $pull1. 删除所有等于指定值的项2. 删除与指定条件匹配的所有项3. 从文档数组中删除项4. 从嵌… 文章目录 1. $1. 更新数组中的值2. 更新数组中的嵌入文档 2. $[]1. 更新数组中的所有元素2. 更新数组中的所有嵌入文档 3. $pop1. 删除数组的第一个元素2. 删除数组的最后一个元素 4. $pull1. 删除所有等于指定值的项2. 删除与指定条件匹配的所有项3. 从文档数组中删除项4. 从嵌套数组中删除文档 5. $push1. $push 将值追加到数组2. $push 与 $each3. $push 与 $each 与 $positon4. $slice5. $push 与 $slice6. $push 与 $sort7. $push 与 $each 与 $position 与 $sort 与 $slice $充当占位符用于更新与查询条件匹配的第一个元素。
$[]充当占位符以更新数组中与查询条件匹配的文档中的所有元素。
$[identifier]充当占位符以更新与查询条件匹配的文档中所有符合 arrayFilters 条件的元素。
$addToSet类似于 $push但是只会向数组字段添加不存在的元素。
$pop用于从数组字段中删除第一个或最后一个元素。
$pull用于从数组字段中删除符合指定条件的元素。
$push用于向数组字段添加元素。
$pullAll用于从数组字段中删除包含在指定数组中的所有元素。
1. $
$ 将数组中匹配到的第一个元素更新为指定的值。
db.collection.updateOne({ array: value ... },{ update operator: { array.$ : value } }
)具体解释如下
update operator表示要使用的更新操作符例如 s e t 、 set、 set、inc、$push等。“array.$”表示要更新的数组字段其中array是数组字段的名称$表示匹配到的第一个元素。value表示要更新的值。
使用这个语法可以将数组中匹配到的第一个元素更新为指定的值。请注意这个语法只能用于更新数组中匹配到的第一个元素无法用于更新数组中的所有元素。如果需要更新数组中的所有元素可以使用array.$[]语法。
1. 更新数组中的值
构造测试数据
db.students.drop()
db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )查询 students 集合中 _id1 并且 grades 数组包含80 的文档将 grades 数组中第一个值为80的元素更新为82如果不知道该元素在数组中的位置$操作符
db.students.updateOne({ _id: 1, grades: 80 },{ $set: { grades.$ : 82 } }
)db.students.find({_id: 1})如果知道该元素在数组中的位置 就可以直接使用数组元素的索引
db.students.updateOne({ _id: 1, grades: 80 },{ $set: { grades.1 : 82 } }
)查询结果
{_id: 1,grades: [85,82,80]
}SpringBoot整合mongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateUser(){// 构建查询条件Query query new Query();query.addCriteria(Criteria.where(_id).is(1).and(grades).is(80));// 构建更新操作Update update new Update();update.set(grades.$, 82);// 执行更新操作mongoTemplate.updateFirst(query, update, students);
}2. 更新数组中的嵌入文档
db.collection.updateOne({ query selector },{ update operator: { array.$.field : value } }
)构造测试数据
db.students.insertOne({_id: 4,course: [{ grade: 80, mean: 75, std: 8 },{ grade: 85, mean: 90, std: 5 },{ grade: 85, mean: 85, std: 8 }]}
)查询 _id4 且 course.grade 包含85的文档将 course 数组中第一个 grade85 的文档的 std 字段更新为6如果不知道该元素在数组中的位置就可以使用位置$操作符
db.students.updateOne({ _id: 4, course.grade: 85 },{ $set: { course.$.std : 6 } }
)db.students.find({_id: 4})查询结果
{_id: 4,course: [{grade: 80,mean: 75,std: 8},{grade: 85,mean: 90,std: 6},{grade: 85,mean: 85,std: 8}]
}如果知道该元素在数组中的位置 就可以直接使用数组元素的索引
db.students.updateOne({ _id: 4, course.grade: 85 },{ $set: { course.1.std : 6 } }
)SpringBoot整合mongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;private ListGrade course;Datapublic static class Grade {private int grade;private int mean;private int std;}
}Test
public void updateUser(){// 构建查询条件Query query new Query();query.addCriteria(Criteria.where(_id).is(4).and(course.grade).is(85));// 构建更新操作Update update new Update();update.set(course.$.std, 6);// 执行更新操作mongoTemplate.updateFirst(query, update, students);
}2. $[]
$[] 将数组中的所有元素都更新为指定的值。
db.collection.updateOne({ query conditions },{ update operator: { array.$[] : value } }
)具体解释如下
update operator表示要使用的更新操作符例如 s e t 、 set、 set、inc、$push等。“array.$[]”表示要更新的数组字段其中array是数组字段的名称$[]表示匹配数组中的所有元素。value表示要更新的值。
使用这个语法可以将数组中的所有元素都更新为指定的值。请注意这个语法只能用于更新数组中的所有元素无法用于更新数组中的部分元素。
1. 更新数组中的所有元素
构造测试数据
db.students.insertMany( [{ _id : 1, grades : [ 85, 82, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )查询 students 集合中的所有文档将 grades 数组中的所有元素都增加10其中$[]表示匹配数组中的所有元素
db.students.updateMany({ },{ $inc: { grades.$[]: 10 } },
)db.students.find()查询结果
// 1
{_id: 1,grades: [95,92,90]
}// 2
{_id: 2,grades: [98,100,102]
}// 3
{_id: 3,grades: [95,110,100]
}SpringBoot 整合 mongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateUser(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.inc(grades.$[], 10);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}2. 更新数组中的所有嵌入文档
db.collection.updateOne({ query selector },{ update operator: { array.$[].field : value } }
)构造测试数据
db.students.insertMany( [{_id : 1,course : [{ grade : 80, mean : 75, std : 8 },{ grade : 85, mean : 90, std : 6 },{ grade : 85, mean : 85, std : 8 }]},{_id : 2,course : [{ grade : 90, mean : 75, std : 8 },{ grade : 87, mean : 90, std : 5 },{ grade : 85, mean : 85, std : 6 }]}
] )查询 students 集合中的所有文档将 course 数组中的所有元素的std字段都增加10其中$[]表示匹配数组中的所有元素
db.students.updateMany({ },{ $inc: { course.$[].std : -2 } },
)db.students.find()查询结果
// 1
{_id: 1,course: [{grade: 80,mean: 75,std: 18},{grade: 85,mean: 90,std: 16},{grade: 85,mean: 85,std: 18}]
}// 2
{_id: 2,course: [{grade: 90,mean: 75,std: 18},{grade: 87,mean: 90,std: 15},{grade: 85,mean: 85,std: 16}]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;private ListGrade course;Datapublic static class Grade {private int grade;private int mean;private int std;}
}SpringBootTest
RunWith(SpringRunner.class)
public class BeanLoadServiceTest {Autowiredprivate MongoTemplate mongoTemplate;Testpublic void updateUser(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.inc(course.$[].std, 10);// 执行更新操作mongoTemplate.updateMulti(query, update, students);}
}3. $pop
$pop 从数组字段中删除第一个或最后一个元素。
db.collection.updateOne(query, { $pop: { field: -1 | 1, ... } }
)field是要操作的数组字段-1 | 1表示删除的方向-1表示删除第一个元素1表示删除最后一个元素。
1. 删除数组的第一个元素
构造测试数据
db.students.insertOne( { _id: 1, grades: [ 8, 9, 10 ] } )查询 students 集合中 _id1 的文档将 grades 数组中的第一个元素删除
db.students.updateOne({ _id: 1 }, { $pop: { grades: -1 } }
)db.students.find({_id:1})查询结果
{_id: 1,grades: [9,10]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateUser(){// 构建查询条件Query query new Query(Criteria.where(_id).is(1));// 构建更新操作Update update new Update();update.pop(grades,Update.Position.FIRST);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}2. 删除数组的最后一个元素
db.students.updateOne({ _id: 1 }, { $pop: { grades: 1 } }
)db.students.find({_id:1})查询结果
{_id: 1,grades: [ 9 ]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateUser(){// 构建查询条件Query query new Query(Criteria.where(_id).is(1));// 构建更新操作Update update new Update();update.pop(grades,Update.Position.LAST);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}4. $pull
$pull 是 MongoDB 的更新操作符用于从数组字段中删除匹配的元素。
db.collection.updateOne(query, { $pull: { field1: value|condition, field2: value|condition, ... } }
)从数组字段中删除匹配的元素。以下是该语法的解释
field1, field2, ... 是要进行更新的字段名。value|condition 是要从数组字段中删除的元素值或删除的条件。
1. 删除所有等于指定值的项
构造测试数据
db.stores.insertMany( [{_id: 1,fruits: [ apples, pears, oranges, grapes, bananas ],vegetables: [ carrots, celery, squash, carrots ]},{_id: 2,fruits: [ plums, kiwis, oranges, bananas, apples ],vegetables: [ broccoli, zucchini, carrots, onions ]}
] )① 删除 stores 集合中vegetables 数组中的 carrots:
db.stores.updateMany({ },{ $pull: { vegetables: carrots } }
)db.stores.find()查询结果
// 1
{_id: 1,fruits: [apples,pears,oranges,grapes,bananas],vegetables: [celery,squash]
}// 2
{_id: 2,fruits: [plums,kiwis,oranges,bananas,apples],vegetables: [broccoli,zucchini,onions]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection stores)
public class Store {Idprivate int id;private ListString fruits;private ListString vegetables;
}Test
public void updateStore(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.pull(vegetables,carrots);// 执行更新操作mongoTemplate.updateMulti(query, update, stores);
}② 删除 stores 集合中 fruits 数组中的 apples 和 oranges
db.stores.updateMany({ },{ $pull: { fruits: { $in: [ apples, oranges ] } } }
)查询结果
// 1
{_id: 1,fruits: [pears,grapes,bananas],vegetables: [carrots,celery,squash,carrots]
}// 2
{_id: 2,fruits: [plums,kiwis,bananas],vegetables: [broccoli,zucchini,carrots,onions]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection stores)
public class Store {Idprivate int id;private ListString fruits;private ListString vegetables;
}Test
public void updateStore(){// 构建查询条件Query query new Query();// 构建更新操作String[] values new String[]{ apples, oranges};Update update new Update();update.pullAll(fruits, values);// 执行更新操作mongoTemplate.updateMulti(query, update, stores);
}③ 删除 stores 集合中fruits 数组中的 apples 和 orangesvegetables 数组中的 carrots
db.stores.updateMany({ },{ $pull: { fruits: { $in: [ apples, oranges ] }, vegetables: carrots } }
)查询结果
// 1
{_id: 1,fruits: [pears,grapes,bananas],vegetables: [celery,squash]
}// 2
{_id: 2,fruits: [plums,kiwis,bananas],vegetables: [broccoli,zucchini,onions]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection stores)
public class Store {Idprivate int id;private ListString fruits;private ListString vegetables;
}Test
public void updateStore(){// 构建查询条件Query query new Query();// 构建更新操作String[] values new String[]{ apples, oranges};Update update new Update();update.pull(vegetables,carrots);update.pullAll(fruits, values);// 执行更新操作mongoTemplate.updateMulti(query, update, stores);
}2. 删除与指定条件匹配的所有项
构造测试数据
db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )查询 _id1的文档将 grades 数组中大于80 的所有项删除
db.students.updateOne( { _id: 1 }, { $pull: { grades: { $gt: 80 } } } )
db.students.find()查询结果
// 1
{_id: 1,grades: [80,80]
}// 2
{_id: 2,grades: [88,90,92]
}// 3
{_id: 3,grades: [85,100,90]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateUser(){// 构建查询条件Query query new Query(Criteria.where(_id).is(1));// 构建更新操作Update update new Update();update.pull(grades, Query.query(Criteria.where(grades).gt(80)));// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}3. 从文档数组中删除项
构造测试数据
db.survey.insertMany([{_id: 1,results: [{ item: A, score: 5 },{ item: B, score: 8 }]},{_id: 2,results: [{ item: C, score: 8 },{ item: B, score: 4 }]}
] )删除 results 数组中 score8 并且 item“B” 的文档
db.survey.updateMany({ },{ $pull: { results: { score: 8 , item: B } } }
)db.survey.find()查询结果
// 1
{_id: 1,results: [{item: A,score: 5}]
}// 2
{_id: 2,results: [{item: C,score: 8},{item: B,score: 4}]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection survey)
public class Survey {Idprivate int id;private ListResult results;Datapublic class Result {private String item;private int score;}
}Test
public void updateResult(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.pull(results, Query.query(Criteria.where(score).is(8).and(item).is(B)));// 执行更新操作mongoTemplate.updateMulti(query, update, survey);
}4. 从嵌套数组中删除文档
构造测试数据
db.survey.drop()db.survey.insertMany( [{_id: 1,results: [{item: A,score: 5,answers: [ { q: 1, a: 4 }, { q: 2, a: 6 } ]},{item: B,score: 8,answers: [ { q: 1, a: 8 }, { q: 2, a: 9 } ]}]},{_id: 2,results: [{item: C,score: 8,answers: [ { q: 1, a: 8 }, { q: 2, a: 7 } ]},{item: B,score: 4,answers: [ { q: 1, a: 0 }, { q: 2, a: 8 } ]}]}
] )删除 results 数组中的 answers 数组中 q2 并且 a8 的文档
db.survey.updateMany({ },{$pull:{results:{answers: { $elemMatch: { q: 2, a: { $gte: 8 } } }}}}
)db.survey.find()查询结果
// 1
{_id: 1,results: [{item: A,score: 5,answers: [{q: 1,a: 4},{q: 2,a: 6}]}]
}// 2
{_id: 2,results: [{item: C,score: 8,answers: [{q: 1,a: 8},{q: 2,a: 7}]}]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection survey)
public class Survey {Idprivate int id;private ListResult results;Datapublic class Result {private String item;private int score;private ListAnswer answers;}Datapublic class Answer {private int q;private int a;}
}Test
public void updateResult(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.pull(results, Query.query(Criteria.where(answers).elemMatch(Criteria.where(q).is(2).and(a).gte(8))));// 执行更新操作mongoTemplate.updateMulti(query, update, survey);
}5. $push
$push 支持一次向多个数组字段添加元素的功能
{ $push: { field1: value1, field2: value2, ... } }其中field1、field2等是要更新的数组字段value1、value2等是要添加到对应数组中的元素。
您可以使用 $push 操作符与以下修饰符一起使用
修饰符说明$each向数组字段追加多个值。$slice限制数组元素的数量。$sort对数组元素进行排序。$position指定数组中插入新元素的位置。如果没有 $position 修饰符$push 会将元素追加到数组的末尾。
1. $push 将值追加到数组
构造测试数据
db.students.insertOne( { _id: 1, grades: [ 44, 78, 38, 80 ] } )向 _id1 文档的 grades 数组中追加一个元素 89
db.students.updateOne({ _id: 1 },{ $push: { grades: 89 } }
)db.students.findOne()查询结果
// 1
{_id: 1,grades: [44,78,38,80,89]
}SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateStudent(){// 构建查询条件Query query new Query();query.addCriteria(Criteria.where(_id).is(1));// 构建更新操作Update update new Update();update.push(grades,89);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}构造测试数据
db.students.drop()db.students.insertOne( { _id: 1, grades: [ 44, 78, 38, 80 ] } )db.students.insertMany( [{ _id: 2, grades: [ 45, 78, 38, 80, 89 ] } ,{ _id: 3, grades: [ 46, 78, 38, 80, 89 ] } ,{ _id: 4, grades: [ 47, 78, 38, 80, 89 ] }
] )向每个文档的 scores 数组追加一个元素 95
db.students.updateMany({ },{ $push: { grades: 95 } }
)db.students.find();查询结果
[{ _id: 1, grades: [ 44, 78, 38, 80, 89, 95 ] },{ _id: 2, grades: [ 45, 78, 38, 80, 89, 95 ] },{ _id: 3, grades: [ 46, 78, 38, 80, 89, 95 ] },{ _id: 4, grades: [ 47, 78, 38, 80, 89, 95 ] }
]SpringBoot 整合 MongoDB 实现以上查询操作
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateStudent(){// 构建查询条件Query query new Query();// 构建更新操作Update update new Update();update.push(grades,89);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}2. $push 与 $each
使用 $push 和 $each 修饰符将多个值附加到数组字段。
向 _id1 文档的 grades 数组中追加多个值 [ 90, 92, 85 ]
db.students.drop()db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )db.students.updateOne({ _id: 1 },{ $push: { grades: { $each: [ 90, 92, 85 ] } } }
)db.students.find({_id:1})查询结果
{ _id: 1, grades: [ 44, 78, 38, 80, 89, 95, 90, 92, 85 ] }SpringBoot整合MongoDB实现
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(1));// 构建更新操作Update update new Update();update.push(grades).each(90,92,95);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}3. $push 与 $each 与 $positon
使用 $each可以将一个包含多个元素的数组添加到目标数组字段中使用 $positon 可以指定插入元素的数组位置。
{$push: {arrayField: {$each: [ value1, value2, ... ],$position: num}}
}构造测试数据
db.students.drop()db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )向 grades 数组索引为1的位置添加 50,60,70 三个值
db.students.updateOne({ _id: 1 },{$push: {grades: {$each: [ 50, 60, 70 ],$position: 1}}}
)db.students.find({_id:1})查询结果
// 1
{_id: 1,grades: [85,50,60,70,80,80]
}SpringBoot 整合 MongoDB 实现
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(5));// 构建更新操作Update update new Update().push(grades).atPosition(1).each(50,60,70);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}4. $slice
$slice 用于在查询结果中限制数组字段的元素数量如果num为正数则从前往后数如果num为负数则从后往前数。
{ arrayField: { $slice: num} }构造测试数据
db.students.drop()db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )查询 grades 数组中的前2个元素
db.students.find({ _id: 1 },{ grades: { $slice: 2 } }
)查询结果
{ _id : 1, grades : [ 85, 80] }查询 scores 数组中的后2个元素
db.students.find({ _id: 1 },{ scores: { $slice: -2 } }
)查询结果
{ _id : 1, grades : [ 80, 80] }5. $push 与 $slice
{$push: {arrayField: {$each: [ value1, value2, ... ],$slice: num}}
}构造测试数据
db.students.drop()db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )向 grades数组索引为 0 的位置添加10,20,30三个元素并返回数组的前2个元素
db.students.updateOne({ _id: 1 },{$push: {grades: {$each: [ 10, 20, 30 ],$position: 0,$slice: 2}}}
)db.students.find({_id:1})查询结果
{_id: 1,grades: [10,20]
}SpringBoot 整合 MongoDB 实现
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(5));// 构建更新操作Update update new Update().push(grades).atPosition(1).each(50,60,70);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}6. $push 与 $sort
$sort 修饰符在 $push 操作期间对数组的元素进行排序。要使用 $sort 修饰符它必须与 $each 修饰符同时出现:
{$push: {field: {$each: [ value1, value2, ... ],$sort: sort specification}}
}构造测试数据
db.students.drop()db.students.insertOne({_id: 1,quizzes: [{ id : 1, score : 6 },{ id : 2, score : 9 }]}
)以下更新将其他文档附加到 quizzes 数组按 score 字段对数组的所有元素进行升序排序
db.students.updateOne({ _id: 1 },{$push: {quizzes: {$each: [ { id: 3, score: 8 }, { id: 4, score: 7 }, { id: 5, score: 6 } ],$sort: { score: 1 }}}}
)db.students.find()查询结果
// 1
{_id: 1,quizzes: [{id: 1,score: 6},{id: 5,score: 6},{id: 4,score: 7},{id: 3,score: 8},{id: 2,score: 9}]
}SpringBoot 整合 MongoDB
Data
Document(collection students)
public class Student {Idprivate int id;AllArgsConstructorNoArgsConstructorDatapublic static class Quiz {private int wk;private int score;}
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(1));// 构建更新操作Update update new Update().push(quizzes).sort(Sort.by(Sort.Direction.ASC, score)).each(new Student.Quiz(3,8),new Student.Quiz(4,7),new Student.Quiz(5,6));// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}构造测试数据
db.students.drop()db.students.insertMany( [{ _id : 1, grades : [ 85, 80, 80 ] },{ _id : 2, grades : [ 88, 90, 92 ] },{ _id : 3, grades : [ 85, 100, 90 ] }
] )向grades数组中添加元素40,60按 score 字段对数组的所有元素进行升序排序
db.students.updateOne({ _id: 2 },{ $push: { grades: { $each: [ 40, 60 ], $sort: 1 } } }
)db.students.find()查询结果
// 1
{_id: 1,grades: [85,80,80]
}// 2
{_id: 2,grades: [40,60,88,90,92]
}// 3
{_id: 3,grades: [85,100,90]
}SpringBoot 整合 MongoDB
Data
Document(collection students)
public class Student {Idprivate int id;private ListInteger grades;
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(2));// 构建更新操作Update update new Update().push(grades).sort(Sort.Direction.ASC).each(40,60);// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}7. $push 与 $each 与 $position 与 $sort 与 $slice
构造测试数据
db.students.drop()db.students.insertOne({_id : 5,quizzes : [{ wk: 1, score : 10 },{ wk: 2, score : 8 },{ wk: 3, score : 5 },{ wk: 4, score : 6 }]}
)以下 $push 操作使用
$each 修饰符将多个文档添加到 quizzes 数组。$position修饰符将多个文档添加到 quizzes 数组索引为0的位置。$sort 修改符对 quizzes 数组按照 score 字段降序排序。$slice 修饰符仅保留 quizzes 数组中的前3个元素。
db.students.updateOne({ _id: 5 },{$push: {quizzes: {$each: [ { wk: 5, score: 8 }, { wk: 6, score: 7 }, { wk: 7, score: 6 } ],$position: 0,$sort: { score: -1 },$slice: 3}}}
)db.students.find({_id:5})查询结果
{_id : 5,quizzes : [{ wk : 1, score : 10 },{ wk : 5, score : 8 },{ wk : 2, score : 8 }]
}SpringBoot整合MongoDB实现
public class Student {Idprivate int id;private ListInteger grades;private ListQuiz quizzes;AllArgsConstructorNoArgsConstructorDatapublic static class Quiz {private int wk;private int score;}
}Test
public void updateResult(){// 构建查询条件Query query new Query(Criteria.where(_id).is(5));// 构建更新操作Update update new Update().push(quizzes).atPosition(0).slice(3).sort(Sort.by(Sort.Direction.DESC, score)).each(new Student.Quiz(5,8), new Student.Quiz(6,7), new Student.Quiz(7,6));// 执行更新操作mongoTemplate.updateMulti(query, update, students);
}
