MongoDB高级查询介绍

最新推荐文章于 2024-05-29 12:00:00 发布
最新推荐文章于 2024-05-29 12:00:00 发布
阅读量990 收藏 2
点赞数 1
文章标签： mongodb 数据库 nosql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxing598/article/details/128887236
版权

title: MongoDB高级查询介绍
date: 2017-12-3 22:14:19
tags:

  • MongoDB
  • MongoDB查询
    categories:
  • 数据库

在几乎所有的项目中对数据库的操作是必要且高频的，对数据库的操作可以大致可分为读和写，其中读的概率要远远大于写。我们选用非关系性数据库一个很重要的原因在于它的查询相对于关系性数据库来讲是非常高效的，它极大地减少了表之间联合查询，只要数据结构设计合理，很多时候一条查询语句即可得到你想要的结果。

基本查询

基本查询指的是通过 find 语句进行的查询，也是使用比较多的一种查询，类似于关系型数据库的 select。

准备测试数据

为了方便进行语法示例，我们在数据库中装填一些数据。

{
    "_id" : ObjectId("5a23dff29369d959a2ec17a0"),
    "age" : 30.0,
    "label" : [
        "钓鱼",
        "旅行"
    ],
    "name" : "ZhanShan",
    "nickname" : "张三"
},
{
    "_id" : ObjectId("5a23e0239369d959a2ec17a1"),
    "age" : 28.0,
    "label" : [
        "喝茶"
    ],
    "name" : "LiShi",
    "nickname" : "李四"
},
{
    "_id" : ObjectId("5a23e07b9369d959a2ec17a2"),
    "age" : 17.0,
    "label" : [
        "锻炼",
        "泡吧",
        "直播"
    ],
    "name" : "WangWu",
    "nickname" : "王五"
}

查询示例

  • findOne() 执行查询后仅返回一条数据，不管查询条件如何都只会返回一条结果。
    # 查询年龄大于18岁的用户
> db.user.findOne({ age: { $gt: 18 } })
{
    "_id" : ObjectId("5a23dff29369d959a2ec17a0"),
    "name" : "ZhanShan",
    "nickname" : "张三",
    "age" : 30,
    "label" : [
        "钓鱼",
        "旅行"
    ]
}
  • find() 执行查询后返回多条数据，具体根据传入的查询来决定。
    > db.user.find()
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ] }
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ] }
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# 查询参数用类JSON对象来表示，例如 `{name: 'ZhanShan'}`，其中name可以省略引号。
> db.user.find({name: 'ZhanShan'})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ] }

# 指定结果返回的字段投影，这和sql中指定返回字段作用相同
> db.user.find({ age: { $gt: 18 } }, {name:1})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan" }
# 默认主键编号将被投影，如果不希望看到可以明确指定期可见性为0
> db.user.find({ age: { $gt: 18 } }, {name:1, _id:0})
{ "name" : "ZhanShan" }

# 比较操作 $lt $lte $gt $gte $ne，用来对字段值进行比较匹配，例如查询未满18周岁的用户。
> db.user.find({ age: { $lt: 18 } }, {name: 1, age: 1})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "age" : 17 }
# 对应上面比较操作的含义是小于、小于等于、大于、大于等于和不等于

# $and 包含多个条件，之间是并的关系，例如查询成年人且爱好都是钓鱼的用户
> db.user.find({$and:[{age:{$gte:18}}, {label:'钓鱼'}]})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ] }

# $or 包含多个条件，之间是或的关系，用法和上面示例的类似。
# $nor 相当于$or取反

# $not 用作其他条件之上取反，例如查询不姓张的用户
> db.user.find({nickname: {$not: /张/}})
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ] }
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# $mod 将查询的值除以第一个给定的值，如果余数等于第二个值则匹配成功，例如查询用户年龄是偶数的有哪些？
> db.user.find({age: {$mod: [2, 0]}})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ] }
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ] }

# $in 查询一个键的多个值，只要键匹配其中的一个即可，这类似于sql中的in查询。例如查询爱好是钓鱼或锻炼的用户
> db.user.find({label: {$in: ['钓鱼', '锻炼']}})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ] }
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }
# $nin为不包含，就是上面的条件取反。

# $all 同时匹配多个值，也就是说要全部满足条件。例如同时有钓鱼和锻炼爱好的用户在目前的数据库中没有
> db.user.find({label: {$all: ['钓鱼', '锻炼']}})
>

# $exists 过滤是否出现指定的字段，1取存在0取不存在，例如判断有填写手机号码的用户是哪些，示例数据中没有添加过phone字段，所以下面的查询肯定没有数据返回。
> db.user.find({phone: {$exists: 1}})
>
# 如果我们为李四增加phone字段，则李四用户会被查询出来
> db.user.update({name: 'LiShi'}, {$set: {phone: 13723458987}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.user.find({phone: {$exists: 1}})
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }

# 对字段的模糊匹配，在sql中使用like关键字，在这里是使用正则匹配语法来操作的。例如查询姓王的用户有哪些？
> db.user.find({nickname: /^王/})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# 如果字段值是数组形式，该怎样查询呢？
# 单个元素匹配，直接指定值就可以了，例如看看爱好喜欢直播的用户有哪些？
> db.user.find({label: '直播'})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# 多个元素匹配，同时都匹配。
> db.user.find({label: {$all: ['直播', '喝茶']}})
>

# 多个元素匹配，只满足一个就可以了
> db.user.find({label: {$in: ['直播', '喝茶']}})
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# 匹配数组中某个索引的值，记住此时字段名称+索引需要用引号引起来。
> db.user.find({'label.1': '泡吧'})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ] }

# 按数组长度匹配，例如查询只有一个爱好的用户
> db.user.find({label: {$size: 1}})
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }

# 使用$slice对数组切片，正数是前面多少条，负数是尾部多少条。这非常类似于Python中的列表切片操作，从数组中返回你指定的元素，这些你要的元素通过索引标识。仔细看下面的示例就比较容易理解了。
> db.user.find({_id: ObjectId("5a23e07b9369d959a2ec17a2")}, {label: {$slice: 2}})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧" ] }
> db.user.find({_id: ObjectId("5a23e07b9369d959a2ec17a2")}, {label: {$slice: 1}})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼" ] }
> db.user.find({_id: ObjectId("5a23e07b9369d959a2ec17a2")}, {label: {$slice: 1}})

# 使用$来指定符合条件的任意一个数组元素，即匹配的数组中仅返回查询到的值
> db.user.find({label: '锻炼'}, {'label.$': 1})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "label" : [ "锻炼" ] }

# $elemMatch 要求同时使用多个条件语句来对一个数组元素进行判断，我们添加一些测试数据以演示这个修饰符的使用方法。
> db.user.update({name:'WangWu'}, {$set: {heartbeat: [60,67,59,69,71,73,80,90,91,55,101]}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
# 找出心跳值在80-90之间的用户
> db.user.find({heartbeat:{$elemMatch:{$gte:80, $lte:90}}})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ], "heartbeat" : [ 60, 67, 59, 69, 71, 73, 80, 90, 91, 55, 101 ] }
> db.user.find({heartbeat:{$elemMatch:{$gte:180, $lte:190}}})
>

# 查询内嵌文档，只需要在指定查询字段时用分隔符.进行区分即可，我们添加一些测试数据以方便。
> db.user.update({name:'ZhanShan'}, {$set:{score:{'java':78.5, 'c++': 90}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
# 注意像这种多字段需要用引号引起来，下面查找用户c++课程考试分数在90分以上的用户有哪些？
> db.user.find({'score.c++': {$gte: 90}})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ], "score" : { "java" : 78.5, "c++" : 90 } }
  • count() 统计数据行
    > db.user.find().count()
3
  • skip limit 分页返回数据，在项目中做查询的时候势必要进行分页的操作，这是个好习惯，不管程序员有没有指定分页参数，在DAO层中都必须有默认的分页值。
    # 例如每页只有2条数据，下面的参数表示第一页
> db.user.find().skip(0).limit(2)
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ], "score" : { "java" : 78.5, "c++" : 90 } }
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }
# 当查询第2页时，应该使用下面的参数
> db.user.find().skip(2).limit(2)
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ], "heartbeat" : [ 60, 67, 59, 69, 71, 73, 80, 90, 91, 55, 101 ] }
  • sort() 排序，-1是降序，1是升序
    # 依据年龄字段升序
> db.user.find().skip(0).limit(2).sort({age: 1})
{ "_id" : ObjectId("5a23e07b9369d959a2ec17a2"), "name" : "WangWu", "nickname" : "王五", "age" : 17, "label" : [ "锻炼", "泡吧", "直播" ], "heartbeat" : [ 60, 67, 59, 69, 71, 73, 80, 90, 91, 55, 101 ] }
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }
> db.user.find().skip(0).limit(2).sort({age: -1})
{ "_id" : ObjectId("5a23dff29369d959a2ec17a0"), "name" : "ZhanShan", "nickname" : "张三", "age" : 30, "label" : [ "钓鱼", "旅行" ], "score" : { "java" : 78.5, "c++" : 90 } }
{ "_id" : ObjectId("5a23e0239369d959a2ec17a1"), "name" : "LiShi", "nickname" : "李四", "age" : 28, "label" : [ "喝茶" ], "phone" : 13723458987 }
  • distinct 取出不重复的数据 db.runCommand({distinct:'user', key: 'age'})

聚合查询

主要用来对集合中的文档进行变换和组合，从而对数据进行分析加以利用。

语法结构

db.集合名称.aggregate(构件1, 构件...) 由于聚合的结果要返回客户端，因此聚合的结果必须限制在16M以内。

准备测试数据

```json
> for (var i = 0; i < 100; i++) {
...     for (var j = 0; j < 4; j++) {
...         db.scores.insert({userId:"s" + i, course:"课程" + j, score:Math.random()*100})
...     }
... }
WriteResult({ "nInserted" : 1 })
> db.scores.find().count()
400
```

查询方法示例

由于本次准备的测试数据过多，在返回数据较多行时会省略显示，并附加 Type it for more 表示数据有多行。
```json
# 查找所有80分以上的学生，仅使用一个构件match
> db.scores.aggregate( {KaTeX parse error: Expected '}', got 'EOF' at end of input: match: {score:{gte:80}}} )
Type “it” for more

# 将每个学生的名字投影出来，使用两个构件match和project
> db.scores.aggregate({$match:{score:{$gte:80}}}, {$project:{userId:1}})
Type "it" for more

# 对学生的名字分组，某个学生的名字出现一次就加1
> db.scores.aggregate({$match:{score:{$gte:80}}}, {$project:{userId:1}}, {$group:{_id:"$userId", count:{$sum:1}}})
{ "_id" : "s99", "count" : 1 }
{ "_id" : "s96", "count" : 1 }
{ "_id" : "s94", "count" : 1 }
Type "it" for more
# 对结果按照count进行降序
> db.scores.aggregate({$match:{score:{$gte:80}}}, {$project:{userId:1}}, {$group:{_id:"$userId", count:{$sum:1}}}, {$sort:{count:-1}})
Type "it" for more
# 只取前面三个
db.scores.aggregate({$match:{score:{$gte:80}}}, {$project:{userId:1}}, {$group:{_id:"$userId", count:{$sum:1}}}, {$sort:{count:-1}}, {$limit:3})
```

管道操作符

构件也即管理操作符，下面对其进行一个说明。
1. $match 对文档进行筛选，通常放到管道最前面的位置，在实际应用中要特别注意这一点，它可以显著优化查询性能。
1. $project 字段投影
1. 指定包含和排除字段 db.scores.aggregate({$project:{userId:1}})
1. 也可以重命名字段 db.scores.aggregate({$project:{userId2:"$userId"}})
1. $add $subtract $multiply $divice $mod 数学表达式

  • 例如给所有人加20分 db.scores.aggregate({$project:{userId2:"$userId", score:1,newScore:{$add:["$score", 10]}}}) 首先按条件匹配出集合，通过对集合的运算产生新字段并返回。
  • $year $month $week $dayOfMonth $dayOfWeek $dayOfYear $hour $minute $second 日期表达式，用于从指定字段中提取日期信息的表达式。使用方式不再赘述，可参考上面的示例。
  • $substr $concat $toLower $toUpper 字符串表达式，使用方式不再赘述，可参考上面的示例。
  • 逻辑表达式
    1. $cmp 比较两个表达式
    2. $strcasecmp 比较两个字符串
    3. $eq $ne $gt $gte $lt $lte
    4. $and $or $not
    5. $cond
    6. $ifNull
    7. $group 将文档依据特定的不同值进行分组。选定了分组字段过后，就可以把这些字段传递给 $group 函数的 _id 字段。
    db.scores.aggregate({$group:{_id:"$userId"}} )
db.scores.aggregate({$group:{_id:{"myUserId":"$userId"}}} );
db.scores.aggregate({$group:{_id:{"myUserId":"$userId"}, count:{$sum:1}}} ,{$sort:{count:-1}})
  • group支持的操作符 $sum $avg $max $min $first $last $addToSet $push
    1. $unwind 把数组中的每个值拆分成单独的文档 db.user.aggregate({$unwind:"$score"})
    2. $sort 如果要对大量文档进行排序，建议放到第一阶段以利用索引
    3. $count 用一返回集合中文档的数量
    4. $distinct 找出给定键的所有不同值，使用时必须指定集合和键

MapReduce

MongoDB也支持数据的并行计算，不过它并没有完整实现MapReduce的所有功能，但基本的功能可以满足一定的需求，可以简单了一下，虽然在实际项目中可能不会用到。

  • 找出集合中所有的键并统计每个键出现的次数
    > var map = function() {
...         for (var key in this) {
...                 emit(key, {"count": 1});
...         }
... };
> var reduce = function(key, emits) {
...         var total = 0;
...         for (var i in emits) {
...                 total += emits[i].count;
...         }
...         return {"count": total};
... };
> db.runCommand({mapreduce:'scores', map:map, reduce:reduce, out:'myout2'});
{
    "result" : "myout2",
    "timeMillis" : 464,
    "counts" : {
        "input" : 400,
        "emit" : 1600,
        "reduce" : 16,
        "output" : 4
    },
    "ok" : 1
}
> db.myout2.find()
{ "_id" : "_id", "value" : { "count" : 400 } }
{ "_id" : "course", "value" : { "count" : 400 } }
{ "_id" : "score", "value" : { "count" : 400 } }
{ "_id" : "userId", "value" : { "count" : 400 } }
>
TerrenceTian
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MongoDB查询之高级操作详解（多条件查询、正则匹配查询等）
Pandfson的专栏
06-30 8098
本文介绍了MongoDB中的高级查询操作，包括多条件查询、正则匹配查询和聚合查询。MongoDB提供了丰富的查询语法，包括多条件查询、正则匹配查询等高级操作，本文将介绍这些高级操作的详细用法。在MongoDB中，我们可以使用$and、$or、$nor等逻辑运算符来实现多条件查询。上述代码中使用了$group和$sum运算符，它将用户表按照gender字段进行分组，并计算每个性别的用户数量。除了上述常用的聚合管道操作，MongoDB还提供了许多其他的操作，例如$unwind、$lookup等。
MongoDB——视图操作
小志的博客
04-26 3172
目录一、MongoDB视图的概述二、MongoDB视图的作用三、数据准备四、创建视图4.1、创建视图的基本语法格式4.2、创建视图的语法解释4.3、单个集合创建视图的示例4.4、多个集合创建视图的示例五、修改视图5.1、修建视图的基本语法格式5.2、修建视图的语法解释5.3、修建视图的示例六、删除视图 一、MongoDB视图的概述 MongoDB视图是一个可查询的对象，它的内容由其他集合或视图上的聚合管道定义。 MongoDB不会将视图内容持久化到磁盘。 当客户端查询视图时，视图的内容按需计算。 Mong
深入探索 MongoDB：高级索引解析与优化策略
最新发布
欢迎来到技术蜜糖罐的IT角落！
05-29 1475
MongoDB 的高级索引提供了丰富的功能和选项，可以满足不同的数据查询需求。合理使用索引可以提高数据查询的效率和性能，但也需要注意索引的管理和维护。通过本文的介绍，相信你已经对 MongoDB 的高级索引有了更深入的了解，并可以在实际项目中灵活应用。
MongoDB高级查询详细
我飞故我在的专栏
04-06 498
1. 前言 前几篇，老玩家绕道即可，新手晚上闲着也是蛋疼，不如把命令敲一边，这样你就会对MongoDB有一定的掌握啦。如果没有安装MongoDB去看我的上一篇博客 MongoDB下载安装与简单增删改查 前奏：启动mongdb数据库服务，并进入shell界面 > mongo --进入shell界面 2. 常用命令 > show dbs -- 查看数据库列表 > us...
Mongodb 控制查询返回字段
威赞的专栏
01-22 697
使用关系型数据库时，用户在select命令后添加字段名称控制返回字段。mongodb中也支持对查询返回字段的控制。默认返回文档的所有字段。为了限制返回数据量，提高网络传输速率。用户可以通过投射（projection）来指定返回字段或在返回结果中排除一些字段。
分布式数据库NoSQL(三)——MongoDB 文档的高级查询操作
m0_64139004的博客
09-29 5395
通俗的说，游标不是查询结果，而是查询的返回资源，或者接口。通过这个接口，你可以逐条读取。就像 fopen 打开文件，得到一个资源一样，通过资源，可以一行一行的读文件。
MongoDB高级查询.doc
09-05
以下将详细介绍文档中提到的一些高级查询方法： 1. **比较操作符**： - `$gt`（大于）: 查询`field`值大于`value`的文档。 - `$lt`（小于）: 查询`field`值小于`value`的文档。 - `$gte`（大于等于）: 查询`...
MongoDB高级查询用法大全
06-05
MongoDB 高级查询用法大全 MongoDB 作为一个 NoSQL 数据库，提供了多种高级查询方式，以下是 MongoDB 高级查询用法大全： 一、比较运算符 在 MongoDB 中，比较运算符用于比较字段的值，常用的比较运算符有： * $...
MongoDB 高级查询 aggregate 聚合管道
12-14
使用聚合管道可以对集合中的文档进行变换和组合，常用于多表关联查询、数据的统计。 db.COLLECTION_NAME.aggregate() 方法用来构建和使用聚合管道，下图是官网给的实例，可以看出来聚合管道的用法还是比较简单的。 ...
MongoDB的查询方法
09-09
本文将详细介绍MongoDB的查询方法，包括基本查询操作和高级查询操作。 基本查询操作 ### 1. 查询所有博客 使用`find()`方法可以查询所有博客，例如： ``` db.blogs.find() ``` 或 ``` db.blogs.find({}) ``` 这两...
MongoDB高级查询
12-09
MongoDB高级查询,许多有用的查询函数，相信大家会用得到的
MongoDB常用28条查询语句(转)
热门推荐
Lucky小黄人的博客
07-03 4万+
转自：MongoDB常用28条查询语句 1、查询所有记录 db.userInfo.find(); 相当于： select* from userInfo; 默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；” 但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize= 50;这样每页就显示50条记录了。 2、查询去掉后...
MongoDB复杂Json数据的增删改查
qq_43511677的博客
09-29 2300
本文讲解了MongoDB在java语言下的复杂用法，并附带案例。替换目标位置数据：(替换scheduleLessons集合)时，会自动创建结构，可以使用这一方法，addToSet()查询比较简单就不写了；多层结构类似上面的例子。示例1：二层结构查询。示例2：三层结构查询。
mongoDB的高级查询和高级修改
西楚小羽的专栏
02-01 1699
Mongodb，分布式文档存储数据库，由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个高性能，开源，无模式的文档型数据库，是当前NoSql数据库中比较热门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式。Mongo使用C++开发。     MongoDB是一个基于分布式文件存储的数据库。MongoDB是一个介于关系数据库和非关系数据库之
mongodb根据_id查询数据
zzm628的专栏
09-22 1万+
db.courseRecord.findOne({"_id":ObjectId("55c70e51972a75fc8ae91ea7")}); 传入的参数一定为JSON格式
mongodb 根据主键id 删除数据
IT_Miles
03-02 1万+
命令行链接 [itsupport@uk-log ~]$ mongo MongoDB shell version: 1.8.1 connecting to: test  默认是test db > > use logs    //切换db 为logs switched to db logs > 由于mongodb 开启了验证授权 不经过验证是无法执行的，比如我们查一下 db的状态 >
MongoDB分组查询、聚合查询
一恍过去
01-26 3万+
MongoDB分组查询、聚合查询
MongoDB的高级查询aggregate聚合管道1
08-03
一、MongoDB 聚合管道（Aggregation Pipeline） 二、MongoDB Aggregation 管道操作符与表达式 三、 数据模拟

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值