mongodb使用总结02 - CURD

具体详细函数请参阅MongoDB文档

数据库

• 创建以及切换数据库(第一次创建数据库并不真正的创建数据库, 只有插入第一条数据之后数据库才会真正创建)

use DATABASE_NAME

• 查看当前数据库

db

• 查看所有数据库

show dbs

• 删除数据库(要切换到对应的数据库下)

db.dropDatabase()

> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
> 
> use testoob
switched to db testoob
> 
> db
testoob
> 
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
>
> 
> db.testoob.insertOne({})
{
    \"acknowledged\" : true,
    \"insertedId\" : ObjectId(\"5c1b52afb00d4fb0d9ef58a7\")
}
> 
> 
> show dbs
admin    0.000GB
config   0.000GB
local    0.000GB
test     0.000GB
testoob  0.000GB
> 
> db
testoob
> 
> db.dropDatabase()
{ \"dropped\" : \"testoob\", \"ok\" : 1 }
>

集合

• 创建集合

1. db.createCollection(name, options)
2. db.COLLECTION_NAME.insert({}) --> 当你插入一些文档时，MongoDB 会自动创建集合。

• 查看已有集合

show collections / show tales

• 删除集合

db.COLLECTION_NAME.drop()

> 
> use test
switched to db test
> 
> show tables
> 
> show collections
> 
> db.createCollection(\"user01\")
{ \"ok\" : 1 }
> 
> show tables
user01
> 
> db.createCollection(\"user02\",{capped:true, autoIndexId: true, size: 6142800, max:10000})
{
    \"note\" : \"the autoIndexId option is deprecated and will be removed in a future release\",
    \"ok\" : 1
}
> 
> show tables
user01
user02
> 
> db.user01.drop()
true
> 
> db.user02.drop()
true
> 

文档

• 插入文档(insert)

db.COLLECTION_NAME.insertOne(
   <document>,
   {
      writeConcern: <document>
   }
)

writeConcern :可选, 事务相关写入关注, 如果使用事务 不要使用这个字段, 请参阅 事务选项（读取关注/写入关注/读取首选项)

db.COLLECTION_NAME.insert(
   <document or array of documents>,
   {
     writeConcern: <document>,
     ordered: <boolean>
   }
)

ordered :

可选的。如果true，在数组中执行文档的有序插入，并且如果其中一个文档发生错误，MongoDB将返回而不处理数组中的其余文档。

如果false执行无序插入，并且如果其中一个文档发生错误，则继续处理阵列中的其余文档。

• 插入文档(save)

db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)

writeConcern :可选, 事务相关写入关注, 如果使用事务 不要使用这个字段, 请参阅 事务选项（读取关注/写入关注/读取首选项)

区别: save() 方法如果不指定 _id 字段类似于 insert() 方法。如果指定 _id 字段，则会更新 匹配 该 _id 的数据。

> 
> db.users.insert({name:\"user001\", age:18})
WriteResult({ \"nInserted\" : 1 })
> 
> 
> db.users.find()
{ \"_id\" : ObjectId(\"5c1b610eb00d4fb0d9ef58ab\"), \"name\" : \"user001\", \"age\" : 18 }
> 
> db.users.save({\"_id\": 123114, \"name\":\"user001\", age:18})
WriteResult({ \"nMatched\" : 0, \"nUpserted\" : 1, \"nModified\" : 0, \"_id\" : 123114 })
> 
> db.users.find()
{ \"_id\" : ObjectId(\"5c1b610eb00d4fb0d9ef58ab\"), \"name\" : \"user001\", \"age\" : 18 }
{ \"_id\" : 123114, \"name\" : \"user001\", \"age\" : 18 }
>
> db.users.save({\"_id\": 123114, \"name\":\"user003\", age:18})
WriteResult({ \"nMatched\" : 1, \"nUpserted\" : 0, \"nModified\" : 1 })
> 
> db.users.find()
{ \"_id\" : ObjectId(\"5c1b610eb00d4fb0d9ef58ab\"), \"name\" : \"user001\", \"age\" : 18 }
{ \"_id\" : 123114, \"name\" : \"user003\", \"age\" : 18 }
>
> 
> db.users.insert({\"name\":\"user004\", \"name\":\"user005\"})
WriteResult({ \"nInserted\" : 1 })
> 
> db.users.find()
{ \"_id\" : ObjectId(\"5c1b610eb00d4fb0d9ef58ab\"), \"name\" : \"user001\", \"age\" : 18 }
{ \"_id\" : 123114, \"name\" : \"user003\", \"age\" : 18 }
{ \"_id\" : ObjectId(\"5c1b61d7b00d4fb0d9ef58ac\"), \"name\" : \"user005\" }
> 
>
> db.users.insert({\"name\":\"user006\",\"NAME\":\"user007\"})
WriteResult({ \"nInserted\" : 1 })
> 
> db.users.find()
{ \"_id\" : ObjectId(\"5c1b610eb00d4fb0d9ef58ab\"), \"name\" : \"user001\", \"age\" : 18 }
{ \"_id\" : 123114, \"name\" : \"user003\", \"age\" : 18 }
{ \"_id\" : ObjectId(\"5c1b61d7b00d4fb0d9ef58ac\"), \"name\" : \"user005\" }
{ \"_id\" : ObjectId(\"5c1b626db00d4fb0d9ef58ad\"), \"name\" : \"user006\", \"NAME\" : \"user007\" }
> 

注意:

1. 同一文档中不能存在相同的 key, 存在相同的key后面的数据会把前面的数据覆盖掉
2. 文档中键值区分大小写

• 查询

db.collection.findOne(query, projection).pretty()
db.collection.find(query, projection).pretty()

query : 可选, 指定的查询条件

projection : 可选, 使用投影操作符返回制定的键, 当查询全部键值可以忽略 1: 返回 0: 忽略

pretty() : 以格式化的方式显示所有文档

db.users.findOne({name:\"user001\"},{name:1}) √
db.users.findOne({name:\"user001\"},{_id : 0}) √
db.users.find({name:\"user001\"},{name:1, age: 0}) × projection不能混合使用

查询条件

AND 条件

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。类似于 RDBMS 中的 WHERE key1 = value1 AND key2 = value2

语法格式如下：

db.COLLECTION_NAME.find({key1:value1, key2:value2}).pretty()

OR 条件

MongoDB OR 条件语句使用了关键字 $or,类似于RDBMS 中的 WHEHRE key1 = value1 OR key2 = value2
语法格式如下：

db.COLLECTION_NAME.find({$or[{kay1:value1},{key2:value2}]}).pretty()

• 删除

删除一个

db.collection.deleteOne(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

writeConcern :可选, 事务相关写入关注, 如果使用事务 不要使用这个字段, 请参阅 事务选项（读取关注/写入关注/读取首选项)

collation : 可选, 要用于操作的排序规则, 详情请参阅排序文档。

collation: {
	locale: <string>,
 	caseLevel: <boolean>,
	caseFirst: <string>,
	strength: <int>,
	numericOrdering: <boolean>,
	alternate: <string>,
	maxVariable: <string>,
	backwards: <boolean>
}

删除多个

db.collection.deleteMany(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

删除一个或多个

db.collection.remove(
   <query>,
   <justOne>
)

justOne :<boolean> true : 只删除第一个 false :删除多个

db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>,
     collation: <document>
   }
)

justOne :<boolean> true : 只删除第一个 false :删除多个

writeConcern :可选, 事务相关写入关注, 如果使用事务 不要使用这个字段, 请参阅 事务选项（读取关注/写入关注/读取首选项)

collation : 可选, 要用于操作的排序规则, 详情请参阅排序文档。

• 更新

db.collection.update(
	<query>,
	<update>,
	{
 		upsert: <boolean>,
 		multi: <boolean>,
 		writeConcern: <document>,
 		collation: <document>,
 		arrayFilters: [ <filterdocument1>, ... ]
	}
)

query: 查询条件

udpate: 更新字段 $set, $uset, $inc, 如果替换所有都不加

upsert: 可选,如果upsert是true且没有文档与查询条件匹配，则update()插入单个文档, 如果upsert是true且存在与查询条件匹配的文档，则update()执行更新。如果 upsert为true 时, 最好添加唯一索引

**multi **: 可选的,如果设置为true，则更新符合query 条件的多个文档。如果设置为false，则更新一个文档。默认值为false。有关其他信息，请参阅多参数。

writeConcern :可选, 事务相关写入关注, 如果使用事务 不要使用这个字段, 请参阅 事务选项（读取关注/写入关注/读取首选项)

collation : 可选, 要用于操作的排序规则, 详情请参阅排序文档。

arrayFilters: 可选的,一组过滤器文档，用于确定要为阵列字段上的更新操作修改哪些数组元素。对文档内的列表进行筛选.

##更新元素匹配arrayFilters条件
db.students.insert([
   { \"_id\" : 1, \"grades\" : [ 95, 92, 90 ] },
   { \"_id\" : 2, \"grades\" : [ 98, 100, 102 ] },
   { \"_id\" : 3, \"grades\" : [ 95, 110, 100 ] }
])
---------------------------------------------------------
db.students.update(
   { grades: { $gte: 100 } },
   { $set: { \"grades.$[element]\" : 100 } },
   {
     multi: true,
     arrayFilters: [ { \"element\": { $gte: 100 } } ]
   }
)
---------------------------------------------------------
{ \"_id\" : 1, \"grades\" : [ 95, 92, 90 ] }
{ \"_id\" : 2, \"grades\" : [ 98, 100, 100 ] }
{ \"_id\" : 3, \"grades\" : [ 95, 100, 100 ] }

##更新文档数组的特定元素
{
   \"_id\" : 1,
   \"grades\" : [
      { \"grade\" : 80, \"mean\" : 75, \"std\" : 6 },
      { \"grade\" : 85, \"mean\" : 90, \"std\" : 4 },
      { \"grade\" : 85, \"mean\" : 85, \"std\" : 6 }
   ]
}
{
   \"_id\" : 2,
   \"grades\" : [
      { \"grade\" : 90, \"mean\" : 75, \"std\" : 6 },
      { \"grade\" : 87, \"mean\" : 90, \"std\" : 3 },
      { \"grade\" : 85, \"mean\" : 85, \"std\" : 4 }
   ]
}
-------------------------------------------------------
db.students2.update(
   { },
   { $set: { \"grades.$[elem].mean\" : 100 } },
   {
     multi: true,
     arrayFilters: [ { \"elem.grade\": { $gte: 85 } } ]
   }
)
--------------------------------------------------------
{
   \"_id\" : 1,
   \"grades\" : [
      { \"grade\" : 80, \"mean\" : 75, \"std\" : 6 },
      { \"grade\" : 85, \"mean\" : 100, \"std\" : 4 },
      { \"grade\" : 85, \"mean\" : 100, \"std\" : 6 }
   ]
}
{
   \"_id\" : 2,
   \"grades\" : [
      { \"grade\" : 90, \"mean\" : 100, \"std\" : 6 },
      { \"grade\" : 87, \"mean\" : 100, \"std\" : 3 },
      { \"grade\" : 85, \"mean\" : 100, \"std\" : 4 }
   ]
}