mongodb基础知识

MrJson-架构师2024-11-18 22:19

认识mongodb

  • MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。
  • MongoDB中将数据存储为一个文档，文档由键值对(key=>value)组成，MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

docker 安装mongodb

拉取最新版本的MongoDB镜像

plain 复制代码 
docker pull mongo:latest

创建并运行一个MongoDB容器

plain 复制代码 
docker run -itd --name mongo-test -p 27017:27017 mongo --auth

参数说明：

  • **-itd：**其中，i是交互式操作，t是一个终端，d指的是在后台运行。
  • **--name mongo-test：**容器名称
  • -p 27017:27017 ：映射容器服务的 27017 端口到宿主机的 27017 端口。外部可以直接通过 宿主机 ip:27017 访问到 mongo 的服务。
  • --auth：需要密码才能访问容器服务（注意：安全问题，MongoDB默认是不开启权限验证的，不过设置了这里就相当于修改MongoDB的配置auth=ture启用权限访问）。

进入创建的MongoDB容器

plain 复制代码 
docker exec -it  mongo-test mongosh

MongoDB报错"ongoServerError: not authorized on admin to execute command"

MongoDB默认是不需要用户密码就可以连接的，如果使用命令报错"ongoServerError: not authorized on admin to execute command "，则表示当前登陆用户不具备相应权限。

解决办法：在admin数据库中通过创建一个用户，赋予用户root权限。

plain 复制代码 
# 进入admin数据库
use admin
# 创建一个超级用户
db.createUser(
    {
        user:"root",
        pwd:"123456",
        roles:[{role:"root",db:"admin"}]
    }
);#授权登录
db.auth('root','123456')

MongoDB用户权限管理

MongoDB添加用户命令说明

  • user字段，为新用户的名字。
  • pwd字段，用户的密码。
  • cusomData字段，为任意内容，例如可以为用户全名介绍。
  • roles字段，指定用户的角色，可以用一个空数组给新用户设定空角色。在roles字段,可以指定内置角色和用户定义的角色。
  • 超级用户的role有两种，userAdmin或者userAdminAnyDatabase(比前一种多加了对所有数据库的访问,仅仅是访问而已)。
  • db是指定数据库的名字，admin是管理数据库。
  • 不能用admin数据库中的用户登录其他数据库。注：只能查看当前数据库中的用户，哪怕当前数据库admin数据库，也只能查看admin数据库中创建的用户。

首先切换到admin数据库中

plain 复制代码 
# 进入admin数据库
use admin

创建admin超级管理员用户

plain 复制代码 
db.createUser(  
  { user: "admin",  
    customData：{description:"superuser"},
    pwd: "admin",  
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]  
  }  
)

创建一个不受访问限制的超级用户

plain 复制代码 
db.createUser(
    {
        user:"root",
        pwd:"123456",
        roles:[{role:"root",db:"admin"}]
    }
);

创建一个业务数据库管理员用户

只负责某一个或几个数据库的増查改删

plain 复制代码 
db.createUser({
    user:"user001",
    pwd:"123456",
    customData:{
        name:'jim',
        email:'jim@qq.com',
        age:18,
    },
    roles:[
        {role:"readWrite",db:"db001"},
        {role:"readWrite",db:"db002"},
        'read'// 对其他数据库有只读权限，对db001、db002是读写权限
    ]
})

MongoDB数据库角色说明

  • 数据库用户角色：read、readWrite；
  • 数据库管理角色：dbAdmin、dbOwner、userAdmin;
  • 集群管理角色：clusterAdmin、clusterManager、4. clusterMonitor、hostManage；
  • 备份恢复角色：backup、restore；
  • 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
  • 超级用户角色：root
  • 内部角色：__system

MongoDB中的role详解

  • Read：允许用户读取指定数据库
  • readWrite：允许用户读写指定数据库
  • dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile
  • userAdmin：允许用户向system.users集合写入，可以在指定数据库里创建、删除和管理用户
  • clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限
  • readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限
  • readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限
  • userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
  • dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限
  • root：只在admin数据库中可用。超级账号，超级权限

概念

  • 和关系型数据库一样，MongoDB存在数据库的概念，一个MongoDB可以创建多个数据库。
  • 多个键及其关联的值有序地放置在一起就是文档，文档时MongoDB中数据的基本单元，是MongoDB的核心概念，很类似关系数据库中的行（记录）。
  • 集合就是一组文档的组合，集合可以被看作关系型数据库中的表。
RDBMS(关系型数据库管理系统) MongoDB
Database（数据库） Database（数据库）
Table（表） Collection（集合）
Record（记录） Document（文档）

数据类型

以下为 MongoDB 中常用的几种数据类型：

  • String： 字符串，存储数据常用的数据类型。在 MongoDB 中，UTF-8 编码的字符串才是合法的。
  • Integer： 整型数值，用于存储数值。根据你所采用的服务器，可分为 32 位或 64 位。
  • Boolean： 布尔值，用于存储布尔值（true/false）。
  • Double： 双精度浮点值，用于存储浮点值。
  • Min/Max keys： 将一个值与 BSON（二进制的 JSON）元素的最低值和最高值相对比。
  • Array： 用于将数组或列表或多个值存储为一个键。
  • Timestamp： 时间戳。记录文档修改或添加的具体时间。
  • Object： 用于内嵌文档。
  • Null： 用于创建空值。
  • Symbol： 符号。该数据类型基本上等同于字符串类型，但不同的是，它一般用于采用特殊符号类型的语言。
  • Date： 日期时间，用 UNIX 时间格式来存储当前日期或时间。你可以指定自己的日期时间：创建 Date 对象，传入年月日信息。
  • Object ID： 对象 ID，用于创建文档的 ID。
  • Binary Data： 二进制数据，用于存储二进制数据。
  • Code： 代码类型，用于在文档中存储 JavaScript 代码。
  • Regular expression： 正则表达式类型，用于存储正则表达式。

判断id类型为objectId

javascript 复制代码 
db.collection.find({ "_id": { "$type": "objectId" } });

库级操作

python 复制代码 
use DATABASE			#切换/创建库		
show dbs				#查看所有数据库（空库不会显示）
db.dropDatabase()		#删除当前数据库
db						#查看当前所在库

#集合操作

python 复制代码 
db.createCollection(name, options)	#创建集合   用引号引起来

show collections				#查看当前数据库的集合

db.集合名称.drop()				#删除集合

文档操作

插入

python 复制代码 
db.集合名称.insert(document)	
#插入文档，    集合不存在会自动创建， 不能插入重复id的数
#_id 是12个字节十六进制数在一个集合的每个文档是唯一的。

db.student.insert({name:'句号'})
db.student.insert({name:'句号', age:18})

db.student.insert({_id:1, name:'句号', age:18})


db.student.insert([
    {name:'juhao', sex:'男', age:18},
    {name:'nanbei', sex:'男', age:19},
    {name:'budong', sex:'男', age:20},
])

查询

python 复制代码 
db.集合名称.find()				#查询所有
db.集合名称.find().pretty()		#结构化显示

db.student.find({name:'句号'})			where name = 'key'

db.student.find({name:{$ne:'句号'}})		where name != 'key'

db.student.find({age:{$gt:18}})			  where age > 18

db.student.find({age:{$gte:18}})			  where age => 18

db.student.find({age:{$lt:18}})    			where age < 18

db.student.find({age:{$lte:18}})    			where age <= 18	

# 类似于SQL语句：Select * from col where likes>100 AND  likes<200;
db.col.find({likes : {$lt :200, $gt : 100}})


#and逻辑,$and:默认可以不写
{$and:[{expression1}, {expression1}, ...]   }
#or逻辑
{$or:[{expression1}, {expression1}, ...]   }


#where sex='男' and age > 18
db.table.find({
    $and:[
        {sex:'男'}, {age:{$gt:18}}
    ]
})


#where sex='女' or age =18
db.table.find({
    $or:[
        {sex:'女'}, {age:18}
    ]
})

#AND 和 OR 联合使用  
#'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'
db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()

#比较操作符
$gt 大于
$gte 大于等于
$lt 小于
$lte 小于等于
$ne 不等于
$eq 等于的另一种写法

更新

python 复制代码 
db.table.insert({
    name: 'juhao', 
    age: 18,
    height: 180,
    sex:'男',
    virtue: ['帅', '帅', '帅'],
})

#前面查询的条件也可以用在这里, wherer sex=男 and age>18
db.table.update(
	{$and:[{sex:'男'}, {age:{$gt:18}}]}, 
    {$set:{age:666}},
    {multi:true}
)


db.table.update({sex:'男'},[{age:20},{height:180}])	
#更新第一条找到的文档全部值  无multi

db.table.update({sex:'男'}, {$set:{age:666, agee:6666}}) 
#修改第一条找到的文档， key不存在就添加

db.table.update({sex:'男'}, {$set:{sex:'女'}}, {multi:true})	#更新全部

删除

python 复制代码 
db.集合名称.remove( <query>, <justOne> )
db.table.remove({age:18})		#删除所有满足条件的
db.table.remove({sex:'男'}, {justOne:true})	#删除一条

#where sex='男' and age>18
db.table.remove({
    $and:[
        {sex:'男'}, {age:{$gt:18}}
    ]
})

程序操作mongodb

python 复制代码 
import pymongo

# 建立连接,指定mongodb服务器ip及端口
connection = pymongo.MongoClient(host='120.77.37.34', port = 27017)

#指定数据库
db = connection['student']            #选择student数据库。没有就自动创建


#选择集合
collection = db['table']         #使用集合db。table


connection.database_names() 	 #获取数据库列表
db.collection_names()		#获得集合列表



# 插入操作
result = collection.insert({'name':'juhao','age': 18,})	

# 查询操作
for data in collection.find():		#查找全部
    	print(data)
        
collection.find_one()			#获取一条记录

# 删除操作
result = collection.remove({'name': 'juhao'})# 删除全部
collection.delete_one({'name':'juhao'})	#删除一条， 不存在不做任何操作
collection.delete_many({'name':'juhao'})	#删除所有满足条件的

#修改
collection.update({'name':'juhao'}, {'$set':{'age':'20'}})	#只能修改一条
collection.update_one({'name':'juhao'}, {'$set':{'age':20}})

update_many({'name':'juhao'}, {'age':20})	
#报错，必须要{'$set':{'age':20}}

MongoDB 操作符 - $type 实例

如果想获取 "col" 集合中 title 为 String 的数据，你可以使用以下命令：

bash 复制代码 
db.col.find({"title" : {$type : 2}})
或
db.col.find({"title" : {$type : 'string'}})

MongoDB Limit与Skip方法

MongoDB Limit() 方法

如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。

语法

limit()方法基本语法如下所示：

bash 复制代码 
>db.COLLECTION_NAME.find().limit(NUMBER)

实例：

bash 复制代码 
db.col.find({},{"title":1,_id:0}).limit(2)

MongoDB Skip() 方法

我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。

语法

skip() 方法脚本语法格式如下：

plain 复制代码 
>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

实例

以下实例只会显示第二条文档数据

bash 复制代码 
db.col.find({},{"title":1,_id:0}).limit(1).skip(1)

**注:**skip()方法默认参数为 0 。

MongoDB 排序

MongoDB sort() 方法

在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

语法

sort()方法基本语法如下所示：

plain 复制代码 
>db.COLLECTION_NAME.find().sort({KEY:1})

实例

col 集合中的数据如下：

bash 复制代码 
{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "mongodb" ], "likes" : 100 }

以下实例演示了 col 集合中的数据按字段 likes 的降序排列：

bash 复制代码 
>db.col.find({},{"title":1,_id:0}).sort({"likes":-1})
{ "title" : "PHP 教程" }
{ "title" : "Java 教程" }
{ "title" : "MongoDB 教程" }
>

MongoDB 聚合

MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值，求和等)，并返回计算后的数据结果。

有点类似 SQL 语句中的 count(*)。

aggregate() 方法

MongoDB中聚合的方法使用aggregate()。

语法

aggregate() 方法的基本语法格式如下所示：

plain 复制代码 
>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

实例

集合中的数据如下：

bash 复制代码 
{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

现在我们通过以上集合计算每个作者所写的文章数，使用aggregate()计算结果如下：

bash 复制代码 
> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "runoob.com",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

以上实例类似sql语句：

plain 复制代码 
 select by_user, count(*) from mycol group by by_user
表达式 描述 实例
$sum 计算总和。 db.mycol.aggregate([{by_user", num_tutorial : {likes"}}}])
$avg 计算平均值 db.mycol.aggregate([{by_user", num_tutorial : {likes"}}}])
$min 获取集合中所有文档对应值得最小值。 db.mycol.aggregate([{by_user", num_tutorial : {likes"}}}])
$max 获取集合中所有文档对应值得最大值。 db.mycol.aggregate([{by_user", num_tutorial : {likes"}}}])
$push 将值加入一个数组中，不会判断是否有重复的值。 db.mycol.aggregate([{by_user", url : {url"}}}])
$addToSet 将值加入一个数组中，会判断是否有重复的值，若相同的值在数组中已经存在了，则不加入。 db.mycol.aggregate([{by_user", url : {url"}}}])
$first 根据资源文档的排序获取第一个文档数据。 db.mycol.aggregate([{by_user", first_url : {url"}}}])
$last 根据资源文档的排序获取最后一个文档数据 db.mycol.aggregate([{by_user", last_url : {url"}}}])

MongoDB 数据库引用

使用 DBRefs

DBRef 的语法形式如下：

bash 复制代码 
{ $ref : value, $id : value, $db : value }

DBRefs 中有以下三个字段：

  • $ref：此字段用来指定要引用文档所在的集合；
  • $id：此字段用来指定要引用文档的 _id 字段值；
  • $db：可选字段，用来指定要引用文档所在的数据库名称；
  • value：表示各个字段所对应的值。

在下面示例的 users 文档中，address 字段就使用了 DBRefs：

json 复制代码 
{
    "_id" : ObjectId("603c93f2f2c28d0fdf74ae7b"),
    "phone" : "15011226666",
    "pincode" : "01-01-1991",
    "name" : "bianchengbang",
    "address": {
        "$ref": "address_home",
        "$id": ObjectId("603c9355f2c28d0fdf74ae79"),
        "$db": "bianchengbang"
    }
}

上面的 address 字段指定了引用的文档位于"bianchengbang"数据库下的"address_home"集合中，文档的 _id 值为 603c9355f2c28d0fdf74ae79。

下面通过一个具体的示例来演示 DBRefs 的使用：

bash 复制代码 
> var user = db.users.findOne({"name":"bianchengbang"})
> var dbRef = user.address
> db[dbRef.$ref].findOne({"_id":(dbRef.$id)})
{
        "_id" : ObjectId("603c9355f2c28d0fdf74ae79"),
        "place" : "22 A, Indiana Apt",
        "postcode" : 123456,
        "city" : "Los Angeles",
        "country" : "California"
}

上面的示例代码中 $ref 参数指定了集合的名称（本例中是 address_home），并在其中动态查找 _id 为 DBRef 中 $id 参数指定的文档。

MongoDB 覆盖索引查询

官方的MongoDB的文档中说明，覆盖查询是以下的查询：

  • 所有的查询字段是索引的一部分
  • 所有的查询返回字段在同一个索引中

由于所有出现在查询中的字段是索引的一部分， MongoDB 无需在整个数据文档中检索匹配查询条件和返回使用相同索引的查询结果。

因为索引存在于RAM中，从索引中获取数据比通过扫描文档读取数据要快得多。

使用覆盖索引查询

为了测试覆盖索引查询，使用以下 users 集合:

bash 复制代码 
{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

我们在 users 集合中创建联合索引，字段为 gender 和 user_name :

bash 复制代码 
>db.users.createIndex({gender:1,user_name:1})

**注：**5.0 之前版本可以使用 db.collection.ensureIndex() ，但 ensureIndex() 在 5.0 版本后已被移除，使用 createIndex() 代替。

现在，该索引会覆盖以下查询：

plain 复制代码 
>db.users.find({gender:"M"},{user_name:1,_id:0})

也就是说，对于上述查询，MongoDB的不会去数据库文件中查找。相反，它会从索引中提取数据，这是非常快速的数据查询。

由于我们的索引中不包括 _id 字段，_id在查询中会默认返回，我们可以在MongoDB的查询结果集中排除它。

下面的实例没有排除_id，查询就不会被覆盖：

plain 复制代码 
>db.users.find({gender:"M"},{user_name:1})

最后，如果是以下的查询，不能使用覆盖索引查询：

  • 所有索引字段是一个数组
  • 所有索引字段是一个子文档

MongoDB 查询分析常用函数有：explain() 和 hint()。

find 返回的数据类型是数组，findOne 返回的数据类型是对象

class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

tag:string 元素代表的数据种类。

text:string 元素的内容。

tail:string 元素的尾形。

attrib:dictionary 元素的属性字典。

＃针对属性的操作

clear() 清空元素的后代、属性、text和tail也设置为None。

get(key, default=None) 获取key对应的属性值，如该属性不存在则返回default值。

items() 根据属性字典返回一个列表，列表元素为(key, value）。

keys() 返回包含所有元素属性键的列表。

set(key, value) 设置新的属性键与值。

＃针对后代的操作

append(subelement) 添加直系子元素。

extend(subelements) 增加一串元素对象作为子元素。＃python2.7新特性

find(match) 寻找第一个匹配子元素，匹配对象可以为tag或path。

findall(match) 寻找所有匹配子元素，匹配对象可以为tag或path。

findtext(match) 寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path。

insert(index, element) 在指定位置插入子元素。

iter(tag=None) 生成遍历当前元素所有后代或者给定tag的后代的迭代器。＃python2.7新特性

iterfind(match) 根据tag或path查找所有的后代。

itertext() 遍历所有后代并返回text值。

remove(subelement) 删除子元素。

class xml.etree.ElementTree.ElementTree(element=None, file=None)

element如果给定，则为新的ElementTree的根节点。

_setroot(element)：用给定的element替换当前的根节点。慎用。

＃ 以下方法与Element类中同名方法近似，区别在于它们指定以根节点作为操作对象。

find(match)

findall(match)

findtext(match, default=None)

iter(tag=None)

iterfind(match)

parse(source, parser=None) 装载xml对象，source可以为文件名或文件类型对象

getroot() 获取根节点

write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None,method="xml")

数据库的CRUD操作:

插入数据

插入一条数据

- db.collectionName.insertOne( {name:'liu'} ) 
    * db表示的是当前操作的数据库
    * collectionName表示操作的集合，若没有，则会自动创建
    * 插入的文档如果没有手动提供_id属性，则会自动创建一个
  • 插入多条数据
    • db.collectionName.insertMany( [ {name:'liu5'} , {name:'liu6'} ] )
      • 需要用数组包起来
  • 万能API：db.collectionName.insert()
shell 复制代码 
#添加两万条数据
for(var i=0;i<20000;i++){
	db.users.insert({username:'liu'+i}) #需要执行20000次数据库的添加操作
}
db.users.find().count()//20000


#优化：
var arr=[];
for(var i=0;i<20000;i++){
	arr.push({username:'liu'+i})
}
db.user.insert(arr) #只需执行1次数据库的添加操作，可以节约很多时间

查询数据

db.collectionName.find() 或db.collectionName.find({})

- 查询集合所有的文档，即所有的数据。
- 查询到的是整个**数组**对象。在最外层是有一个对象包裹起来的。
- db.collectionName.count()或db.collectionName.length()   统计文档个数
  • db.collectionName.find({_id:222})
    • 条件查询。注意：结果返回的是一个数组
  • db.collectionName.findOne() 返回的是查询到的对象数组中的第一个对象
    • 注意：
plain 复制代码 
> db.students.find({_id:222}).name  //错误
> db.students.findOne({_id:222}).name //正确
shell 复制代码 
# 1.mongodb支持直接通过内嵌文档的属性值进行查询
# 什么是内嵌文档：hobby就属于内嵌文档
{
	name:'liu',
	hobby:{
		movies:['movie1','movie2'],
		cities:['zhuhai','chengdu']
	}
}

db.users.find({hobby.movies:'movie1'}) //错误
db.users.find({"hobby.movies":'movie1'})//此时查询的属性名必须加上引号



#2.查询操作符的使用
#比较操作符
$gt 大于
$gte 大于等于
$lt 小于
$lte 小于等于
$ne 不等于
$eq 等于的另一种写法

db.users.find({num:{$gt:200}}) #大于200
db.users.find({num:{$gt:200,$lt:300}}) #大于200小于300

$or 或者
db.users.find(
    {
        $or:[
            {num:{$gt:300}},
            {num:{$lt:200}}
        ]
    }
) #大于300或小于200


#3.分页查询
db.users.find().skip(页码-1 * 每页显示的条数).limit(每页显示的条数)

db.users.find().limit(10) #前10条数据
db.users.find().skip(50).limit(10) #跳过前50条数据，即查询的是第61-70条数据，即第6页的数据


#4.排序
db.emp.find().sort({sal:1}) #1表示升序排列，-1表示降序排列
db.emp.find().sort({sal:1,empno:-1}) #先按照sal升序排列，如果遇到相同的sal，则按empno降序排列

#注意：skip,limit,sort可以以任意的顺序调用，最终的结果都是先调sort，再调skip，最后调limit

#5.设置查询结果的投影，即只过滤出自己想要的字段
db.emp.find({},{ename:1,_id:0}) #在匹配到的文档中只显示ename字段

修改数据

shell 复制代码 
# 1.替换整个文档
# db.collectionName.update(condiction,newDocument)

> db.students.update({_id:'222'},{name:'kang'})


# 2.修改对应的属性，需要用到修改操作符，比如$set,$unset,$push,$addToSet
db.collectionName.update(
	# 查询条件
	{_id:222},
	{
		#修改对应的属性
		$set:{ 
			name:'kang2',
			age:21
		}
		#删除对应的属性
		$unset:{
			gender:1 //这里的1可以随便改为其他的值，无影响
		}
		
	}
)

# 3.update默认与updateOne()等效，即对于匹配到的文档只更改其中的第一个
# updateMany()可以用来更改匹配到的所有文档
db.students.updateMany(
	{name:'liu'},
	{
		$set:{
			age:21,
			gender:222
		}
	}
)


# 4.向数组中添加数据
db.users.update({username:'liu'},{$push:{"hobby.movies":'movie4'}})

#如果数据已经存在，则不会添加
db.users.update({username:'liu'},{$addToSet:{"hobby.movies":'movie4'}})


# 5.自增自减操作符$inc
{$inc:{num:100}} #让num自增100
{$inc:{num:-100}} #让num自减100
db.emp.updateMany({sal:{$lt:1000}},{$inc:{sal:400}}) #给工资低于1000的员工增加400的工资

删除数据

shell 复制代码 
# 1. db.collectionName.remove() 
# remove默认会删除所有匹配的文档。相当于deleteMany()
# remove可以加第二个参数，表示只删除匹配到的第一个文档。此时相当于deleteOne()
db.students.remove({name:'liu',true})

# 2. db.collectionName.deleteOne()
# 3. db.collectionName.deleteMany()
db.students.deleteOne({name:'liu'})

# 4. 删除所有数据：db.students.remove({})----性格较差，内部是在一条一条的删除文档。
# 可直接通过db.students.drop()删除整个集合来提高效率。

# 5.删除集合
db.collection.drop()

# 6.删除数据库
db.dropDatabase()

# 7.注意：删除某一个文档的属性，应该用update。   remove以及delete系列删除的是整个文档

# 8.当删除的条件为内嵌的属性时：
db.users.remove({"hobby.movies":'movie3'})

文档之间的关系：

一对一

一对多

shell 复制代码 
#用户与订单：
db.users.insert([
{_id:100,username:'liu1'},
{_id:101,username:'liu2'}
])
db.orders.insert([
{list:['apple','banana'],user_id:100},
{list:['apple','banana2'],user_id:100},
{list:['apple'],user_id:101}
])

查询liu1的所有订单：
首先获取liu1的id: var user_id=db.users.findOne({name:'liu1'})._id;
根据id从订单集合中查询对应的订单： db.orders.find({user_id:user_id})

多对多

shell 复制代码 
#老师与学生
db.teachers.insert([
    {
        _id:100,
        name:'liu1'
    },
    {
        _id:101,
        name:'liu2'
    },
    {
    	_id:102,
    	name:'liu3'
    }
])

db.students.insert([
	{
		_id:1000,
		name:'xiao',
		tech_ids:[100,101]
	},
	{
		_id:1001,
		name:'xiao2',
		tech_ids:[102]
	}
])

MongoDB的count()函数完整攻略

1. count()函数的作用

count()是MongoDB中的一个函数，用于统计集合中满足条件的文档数量。

2. count()函数的使用方法

count()函数可以接受一个查询条件作为参数，统计满足条件的文档数量。

示例1：统计集合中所有文档的数量

plain 复制代码 
db.collection.count()

示例2：统计集合中包含"gender"属性值为"male"的文档数量

plain 复制代码 
db.collection.count({gender: "male"})

3. count()函数的返回值

count()函数返回一个整数值，表示满足查询条件的文档数量。

4. 注意事项

  • count()函数会扫描整个集合，因此对于大数据集合，建议使用limit()函数限制查询数量，以提高性能。
  • 如果需要获取集合中文档数量的精确值，可以使用estimatedDocumentCount()函数，该函数会快速估算出集合中文档的数量，但结果可能会略有偏差。

5. 示例说明

示例1：统计集合中所有文档的数量

假设有一个名为"users"的集合，包含一些用户的信息。我们可以使用如下方法统计该集合中所有文档的数量：

plain 复制代码 
db.users.count()

示例2：统计集合中包含"gender"属性值为"male"的文档数量

我们也可以指定一个查询条件，统计集合中包含"gender"属性值为"male"的文档数量：

plain 复制代码 
db.users.count({gender: "male"})
plain 复制代码 
db.scores.aggregate(
  [
    {
      $match: {
        score: {
          $gt: 80
        }
      }
    },
    {
      $count: "passing_scores"
    }
  ]
)

mongodb中的in和notin的查询

plain 复制代码 
{$in:["VM","STORAGE_EFS","STORAGE"]}
{$nin:["VM","STORAGE_EFS","STORAGE"]}
相关推荐
woshilys20 分钟前
sql server 查询对象的修改时间
运维·数据库·sqlserver
Hacker_LaoYi20 分钟前
SQL注入的那些面试题总结
数据库·sql
建投数据1 小时前
建投数据与腾讯云数据库TDSQL完成产品兼容性互认证
数据库·腾讯云
Hacker_LaoYi2 小时前
【渗透技术总结】SQL手工注入总结
数据库·sql
岁月变迁呀2 小时前
Redis梳理
数据库·redis·缓存
独行soc2 小时前
#渗透测试#漏洞挖掘#红蓝攻防#护网#sql注入介绍06-基于子查询的SQL注入（Subquery-Based SQL Injection）
数据库·sql·安全·web安全·漏洞挖掘·hw
你的微笑，乱了夏天3 小时前
linux centos 7 安装 mongodb7
数据库·mongodb
工业甲酰苯胺3 小时前
分布式系统架构：服务容错
数据库·架构
独行soc4 小时前
#渗透测试#漏洞挖掘#红蓝攻防#护网#sql注入介绍08-基于时间延迟的SQL注入（Time-Based SQL Injection）
数据库·sql·安全·渗透测试·漏洞挖掘
White_Mountain4 小时前
在Ubuntu中配置mysql，并允许外部访问数据库
数据库·mysql·ubuntu
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程