Mongodb学习笔记

 

一、CentOS安装mongodb

二、mongodb的三个元素

三、Bson Types

四、Sql与Mogondb对比

五、比较运算符

六、逻辑运算符

七、元素查询运算符

八、评估查询运算符

九、数组查询操作符

十、更新操作结构

十一、字段更新操作符

十二、数组更新

十三、位更新操作

十四、CURD 

十五、索引

十六、分布式文件系统GridFS

十七、重量级聚合框架

十八、轻量级聚合框架group

十九、distinct

二十、mapReduce

二十一、master-slave

二十二、ReplicaSet集群

二十三、mongodb分片（未完成）

二十四、驱动链接mongodb

 

一、CentOS安装mongodb

1，下载并安装mongodb

①下载地址：https://www.mongodb.com/download-center?jmp=nav#community

Mongodb学习笔记

将下载的mongodb-linux-x86_64-3.6.2.tgz放置在centos的usr目录下

网盘下载：https://pan.baidu.com/s/1c4dcdig

②解压：mongodb-linux-x86_64-3.6.2.tgz

进入mongodb-linux-x86_64-3.6.2文件夹创建一个db文件夹

③启动mongodb

命令：bin/mongod --dbpath=db

默认端口号：27017

2，下载并安装robomongo可视化工具

①下载地址：https://robomongo.org/

网盘下载：https://pan.baidu.com/s/1oAl5kT0

Mongodb学习笔记

 

3，连接mongodb服务器

mongodb客户端一直连接不上centos的mongodb服务器
启动mongodb服务须加上--bind_ip_all（例如：bin/mongod --dbpath=db --auth --bind_ip_all）

给mongodb服务器设置密码：
①./mongo 连接mongodb服务器（./mongo --port 27017 -u "userAdmin" -p "123" --authenticationDatabase "admin"）
②use admin 切换至admin数据库
③db.createUser({user: "userAdmin",pwd: "123",roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]}) 创建管理员用户，并指定其权限

 

二、mongodb的三个元素

mongodb   对应   sqlserver

database=》database

collection=》table

document=》row

1，基本操作

①创建database

②创建collection

③创建document

1，capped collection（固定集合）

①可视化设置固定集合

两种存储引擎：wiredtiger，mmap

Mongodb学习笔记

②代码创建固定集合

1)简单创建固定集合

db.createCollection("log", { capped : true, size : 5242880, max : 5000 } )

2)复杂创建固定集合

db.createCollection(<name>,
 { capped: <boolean>,
    autoIndexId: <boolean>,
    size: <number>,
    max: <number>,
    storageEngine: <document>,
    validator: <document>,
    validationLevel: <string>,
    validationAction: <string>,
    indexOptionDefaults: <document> 
} )

3)将集合转换为固定集合

db.runCommand({"convertToCapped": "mycoll", size: 100000});

4)查看collection的状态

db.log.stats()

5)倒序查询

db.log.find().sort( { $natural: -1 } )

 

三、Bson Types

参考文档：https://docs.mongodb.com/manual/reference/bson-types/

Type Number Alias Notes
Double 1 “double”  
String 2 “string”  
Object 3 “object”  
Array 4 “array”  
Binary data 5 “binData”  
Undefined 6 “undefined” Deprecated.
ObjectId 7 “objectId”  
Boolean 8 “bool”  
Date 9 “date”  
Null 10 “null”  
Regular Expression 11 “regex”  
DBPointer 12 “dbPointer” Deprecated.
JavaScript 13 “javascript”  
Symbol 14 “symbol” Deprecated.
JavaScript (with scope) 15 “javascriptWithScope”  
32-bit integer 16 “int”  
Timestamp 17 “timestamp”  
64-bit integer 18 “long”  
Decimal128 19 “decimal” New in version 3.4.
Min key -1 “minKey”  
Max key 127 “maxKey”  

1，通过find操作，用undefined做作为比较条件

printjson(db.mycollection.find({"name":{$type:6}}).toArray());
printjson(db.mycollection.find({"name":{$type:'undefined'}}).toArray());

2，Timestamps

var a = new Timestamp();
db.test.insertOne( { ts: a } );

 

四、Sql与Mogondb对比

1，创建和更改表

SQL Mongodb 
CREATE TABLE people (
    id MEDIUMINT NOT NULL
        AUTO_INCREMENT,
    user_id Varchar(30),
    age Number,
    status char(1),
    PRIMARY KEY (id)
)
 
db.people.insertOne( {
    user_id: "abc123",
    age: 55,
    status: "A"
 } )
或者
db.createCollection("people")
 
ALTER TABLE people
ADD join_date DATETIME
   
db.people.updateMany(
    { },
    { $set: { join_date: new Date() } }
)
 
ALTER TABLE people
DROP COLUMN join_date
   
db.people.updateMany(
    { },
    { $unset: { "join_date": "" } }
)
 
CREATE INDEX idx_user_id_asc
ON people(user_id)
  db.people.createIndex( { user_id: 1 } ) 
CREATE INDEX
       idx_user_id_asc_age_desc
ON people(user_id, age DESC)
  db.people.createIndex( { user_id: 1, age: -1 } ) 
DROP TABLE people
  db.people.drop()

2，插入数据

SQL Mongodb 
INSERT INTO people(user_id,
                  age,
                  status)
VALUES ("bcd001",
        45,
        "A")
 
db.people.insertOne(
   { user_id: "bcd001", age: 45, status: "A" }
)
 

3，查询数据

 

SQL Mongodb 
SELECT *
FROM people
 
db.people.find()

 

 
SELECT id,
       user_id,
       status
FROM people
   
db.people.find(
    { },
    { user_id: 1, status: 1 }
)
 
SELECT user_id, status
FROM people
   
db.people.find(
    { },
    { user_id: 1, status: 1, _id: 0 }
)
 
SELECT *
FROM people
WHERE status = "A"
   
db.people.find(
    { status: "A" }
)
 
SELECT user_id, status
FROM people
WHERE status = "A"
   
db.people.find(
    { status: "A" },
    { user_id: 1, status: 1, _id: 0 }
)
 
SELECT *
FROM people
WHERE status != "A"
   
db.people.find(
    { status: { $ne: "A" } }
)
 
SELECT *
FROM people
WHERE status = "A"
AND age = 50
   
db.people.find(
    { status: "A",
      age: 50 }
)
 
SELECT *
FROM people
WHERE status = "A"
OR age = 50
   
db.people.find(
    { $or: [ { status: "A" } ,
             { age: 50 } ] }
)
 
SELECT *
FROM people
WHERE age > 25
   
db.people.find(
    { age: { $gt: 25 } }
)
 
SELECT *
FROM people
WHERE age < 25
   
db.people.find(
   { age: { $lt: 25 } }
)
 
SELECT *
FROM people
WHERE age > 25
AND   age <= 50
   
db.people.find(
   { age: { $gt: 25, $lte: 50 } }
)
 
SELECT *
FROM people
WHERE user_id like "%bc%"
   
db.people.find( { user_id: /bc/ } )
db.people.find( { user_id: { $regex: /bc/ } } )
 
SELECT *
FROM people
WHERE user_id like "bc%"
 
db.people.find( { user_id: /^bc/ } )
db.people.find( { user_id: { $regex: /^bc/ } } )
 
SELECT *
FROM people
WHERE status = "A"
ORDER BY user_id ASC
  db.people.find( { status: "A" } ).sort( { user_id: 1 } ) 
SELECT *
FROM people
WHERE status = "A"
ORDER BY user_id DESC
  db.people.find( { status: "A" } ).sort( { user_id: -1 } ) 
SELECT COUNT(*)
FROM people
   
db.people.count()
db.people.find().count()
 
SELECT COUNT(user_id)
FROM people
   
db.people.count( { user_id: { $exists: true } } )
db.people.find( { user_id: { $exists: true } } ).count()
 
SELECT COUNT(*)
FROM people
WHERE age > 30
   
db.people.count( { age: { $gt: 30 } } )
db.people.find( { age: { $gt: 30 } } ).count()
 
SELECT DISTINCT(status)
FROM people
   
db.people.aggregate( [ { $group : { _id : "$status" } } ] )
db.people.distinct( "status" )
 
SELECT *
FROM people
LIMIT 1
   
db.people.findOne()
db.people.find().limit(1)
 
SELECT *
FROM people
LIMIT 5
SKIP 10
  db.people.find().limit(5).skip(10) 
EXPLAIN SELECT *
FROM people
WHERE status = "A"
  db.people.find( { status: "A" } ).explain()

4，修改数据

SQL Mongodb 
UPDATE people
SET status = "C"
WHERE age > 25
 
db.people.updateMany(
   { age: { $gt: 25 } },
   { $set: { status: "C" } }
)
 
UPDATE people
SET age = age + 3
WHERE status = "A"
   
db.people.updateMany(
   { status: "A" } ,
   { $inc: { age: 3 } }
)

5，删除数据

SQL Mongodb 
DELETE FROM people
WHERE status = "D"
 
db.people.deleteMany( { status: "D" } )
 
DELETE FROM people
   
db.people.deleteMany({})

 

五、比较运算符

比较运算符 备注 说明 用法
$eq = equal 
{ <field>: { $eq: <value> } }
相当于{ field: <value> }
$gt > greater than {field: {$gt: value} }
$gte >= greater than equal {field: {$gte: value} }
$lt < less than 
{field: {$lt: value} }
$lte <= less than equal { field: { $lte: value} }
$ne != not equal  {field: {$ne: value} }
$in in   
{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }
$nin !in not in { field: { $nin: [ <value1>, <value2> ... <valueN> ]} }

1，测试数据

db.inventory.insert([
{ _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] },
{ _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: [ "B" ] },
{ _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: [ "A", "B" ] },
{ _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: [ "B", "A" ] },
{ _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }])

2，案例

①查询qty>=20的数据

db.inventory.find({"qty":{$gte:20}})

②查询item对象中的name为ab的数据

db.inventory.find({"item.name":{$eq:"ab"}})
db.inventory.find({"item.name":"ab"})

③查询tags集合中包含C的数据

db.inventory.find({tags:{$in:["C"]}})

④查询出tags集合为[ [ "A", "B" ], "C" ]的数据

db.inventory.find({tags:{$eq:[["A","B"],"C"]}})

 

六、逻辑运算符

1，$and

①使用方法： { $and: [ { <expression1> }, { <expression2> } , ... , {<expressionN> } ] } 

②案例

db.inventory.find( { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } )
db.inventory.find( {
    $and : [
        { $or : [ { price : 0.99 }, { price : 1.99 } ] },
        { $or : [ { sale : true }, { qty : { $lt : 20 } } ] }
    ]
} )

2，$not

①使用方法：  { field: { $not: { <operator-expression> } } } 

②案例

db.inventory.find( { price: { $not: { $gt: 1.99 } } } )
db.inventory.find( { item: { $not: /^p.*/ } } )

3，$nor（or的反向）

①使用方法： { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] } 

②案例

db.inventory.find( { $nor: [ { price: 1.99 }, { sale: true } ]  } )
db.inventory.find( { $nor: [ { price: 1.99 }, { qty: { $lt: 20 } }, { sale: true } ] } )

4，$or

①使用方法： { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } 

②案例

db.inventory.find( { $or: [ { quantity: { $lt: 20 } }, { price: 10 } ] } )

 

七、元素查询运算符

1，$exists（判断存不存在字段）

①使用方法： { field: { $exists: <boolean> } } 

②案例

db.inventory.find( { qty: { $exists: true, $nin: [ 5, 15 ] } } )

2，$type

①使用方法： { field: { $type: <BSON type> } } 

②案例

db.addressBook.find( { "zipCode" : { $type : "number" } } )

 

八、评估查询运算符

1，$expr【允许在查询语言中使用聚合表达式。】

①使用方法： { $expr: { <expression> } } 

②案例

1）查询花费大于预算

{ "_id" : 1, "category" : "food", "budget": 400, "spent": 450 }
{ "_id" : 2, "category" : "drinks", "budget": 100, "spent": 150 }
{ "_id" : 3, "category" : "clothes", "budget": 100, "spent": 50 }
{ "_id" : 4, "category" : "misc", "budget": 500, "spent": 300 }
{ "_id" : 5, "category" : "travel", "budget": 200, "spent": 650 }
数据

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode