MongoDB实战项目与重点总结

作者: 叫我老村长 | 来源:发表于2018-11-05 23:44 被阅读6次

about-BY-gentle.jpg

ｍｏｎｇｏｄｂ特点其一：
自动分片：支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额外的机器
集群定义：
拥有很多服务器，共同工作，避免了一台服务器有限的资源，这样可以分多个服务器去执行，期间存在主从备份，从站对主站的备份．整体是树状结构，致使可以无限扩大添加（节点），因此不怕丢失
成为非关系数据库的特点。

ｍｏｎｇｏｄｂ，没表概念，是集合。
不是ｍｙｓｑｌ关系数据库的表与表的关系，是文档和文档之间的关系

非关系数据库：
ｒｅｄｉｓ基于内存存储，键值存储
ｍｏｎｇｏｄｂ　文档型

ｍｏｎｇｏｄｂ　储存类型
储存的是ｂｓｏｎ文件类型，和ｊｓｉｏｎ类似．
ｊｓｏｎ二种数据格式
数组　　别的地方叫做列表
字典

主从切换
主服务器挂，备份下的从服务器，立马变为主服务器．

不建议二进制文件放到数据库，因为太大了．也就是存个链接．

注意：
mysql table joins
表连接,MongoDB不支持
集合之间不能链接．

MongoDB
不设置主键，默认生成主键．根据时间戳生成．因为时间唯一的，达到唯一性．

db.stats()
查状态

db.dropDatabase()
当前字哪里，删除的就是谁．

show collections
显示所有集合．

ｕｓｅ切换数据库　也代表创建了　但是看不到．

size判断后　执行ｍａｘ

name:集合的名字
capped:是否启用集合限制，如果开启需要制定一个限制条件，默认为不启用，这个参数没有实际意义
size:限制集合使用空间的大小，默认为没有限制
max:集合中最大条数限制，默认为没有限制
autoIndexId:是否使用_id作为索引，默认为使用(true或false)
size的优先级比max要高

常用方法介绍：
1、一般来说，我们创建集合用db.createCollection(name),如：db.createCollection("log"),创建一个名字为log的集合，没有任何的大小，数量限制，使用_id作为默认索引；

2、限制集合空间的大小：db.createCollection("log",{size:1024})或db.createCollection("log",{capped:true,size:1024}),创建一个名字为log集合，限制它的空间大小为1M，如果超过1M的大小，则会删除最早的记录；
3、限制集合的最大条数：db.createCollection("log",{max:1024})，创建一个名字为log集合，最大条数为1024条，超过1024再插入数据的话会删除最早的一条记录。这个不能使用capped:true，否则会报错；
4、即限制最大条数有限制使用空间大小：db.createCollection("log",{size:1024,max:1024})或db.createCollection("log",{capped:true,size:1024,max:1024})，限制集合最大使用空间为1M，最大条数为1024条

以上是参考官方文档和实际测试得出的，也可以看出capped参数没有什么用处，用不用都可以。

db.student.update({name:'王干'},{$set:{age:30}})

{ "_id" : ObjectId("5b7bc337492da74efcdeb628"), "name" : "王干", "age" : 30 }
{ "_id" : ObjectId("5b7bc34b492da74efcdeb629"), "name" : "王干", "age" : 20, "gender" : 1 }

db.student.update({name:'王干'},{age:50})
全文档更新
{ "_id" : ObjectId("5b7bc337492da74efcdeb628"), "age" : 50 }
{ "_id" : ObjectId("5b7bc34b492da74efcdeb629"), "name" : "王干", "age" : 20, "gender" : 1 }

db.student.update({name:'王干'},{$set:{age:30}},{multi:true})
全部更新　　　　　　　条件！！ｄａｎｃ

找不到数据插入一条，并且修改，默认ｆａｌｓｅ

db.student.update({name:'李三'},{name:'李八'},{upsert:true})
WriteResult({
"nMatched" : 0,
"nUpserted" : 1,
"nModified" : 0,
"_id" : ObjectId("5b7cb61ff5d047b9471c8092")
})
db.student.find()
{ "_id" : ObjectId("5b7cb61ff5d047b9471c8092"), "name" : "李八" }

和ｕｐｄａｔｅ写法区别：ｓａｖｅ在同一个｛｝中用ｉｄ查找
ｓａｖｅ全文档更新．通过ｉｄ去查找，

db.student.save({_id:ObjectId("5b7bc337492da74efcdeb628"),name:'xx'})
{ "_id" : ObjectId("5b7bc337492da74efcdeb628"), "name" : "xx" }

ｉｄ不存在，新插入数据，ｉｄ自己设的
db.student.save({_id:2018,name:'xx'})
{ "_id" : 2018, "name" : "xx" }

不跟ｉｄ，相当于插入条数据，自动生成新的ｉｄ
ｓａｖｅ先遍历在插，效率低．

db.student.save({name:'xx'})

{ "_id" : ObjectId("5b7cb837492da74efcdeb635"), "name" : "xx" }

删除，全部name:"李八"

db.student.remove({name:"李八"})

删除，一个name:"xx"　　　后面接１　　ＴＲＵＥ
db.student.remove({name:"xx"}，｛ｊｕｓｔＯｎｅ：ｔｒｕｅ］)

db.student.remove({name:"xx"},1)

删除指定ｉｄ

db.student.remove({_id:2018})

查询
所有

db.student.find()
db.student.find({})
指定
db.student.find({条件})

ａｎｄ

db.student.find({name:'zz',age:25})　　相当ａｎｄ
{ "_id" : ObjectId("5b7cbada492da74efcdeb639"), "name" : "zz", "age" : 25, "gender" : "女" }

小于

db.student.find({name:'zz',age:81})
db.student.find({age:{$lt:20}})
{ "_id" : ObjectId("5b7cbada492da74efcdeb638"), "name" : "1zz", "age" : 12, "gender" : "女" }

$({$ or:[{age:10},{age:22}]})
ｏｒ　相当于ｉｎ范围　　查找符合二者条件中任意符合的一条．

db.student.find({$or:[{age:10},{age:22}]})
{ "_id" : ObjectId("5b7cba98492da74efcdeb636"), "name" : "zzz", "age" : 22, "gender" : "女" }
{ "_id" : ObjectId("5b7cbada492da74efcdeb63a"), "name" : "fzz", "age" : 22, "gender" : "男" }

ｉｎ查找１２，２２　　查找年龄在哪个范围
({age:{$in:[12,22]}})

db.student.find({age:{$in:[12,22]}})
{ "_id" : ObjectId("5b7cba98492da74efcdeb636"), "name" : "zzz", "age" : 22, "gender" : "女" }
{ "_id" : ObjectId("5b7cbada492da74efcdeb638"), "name" : "1zz", "age" : 12, "gender" : "女" }
{ "_id" : ObjectId("5b7cbada492da74efcdeb63a"), "name" : "fzz", "age" : 22, "gender" : "男" }

不在范围内

db.student.find({age:{$nin:[12,22]}})
{ "_id" : ObjectId("5b7bc34b492da74efcdeb629"), "name" : "王干", "age" : 30, "gender" : 1 }
{ "_id" : ObjectId("5b7bc40a492da74efcdeb62a"), "name" : "cc" }
{ "_id" : "20180821", "name" : "x" }
{ "_id" : ObjectId("5b7bc4ea492da74efcdeb62b"), "name" : "vv" }
{ "_id" : ObjectId("5b7bc547492da74efcdeb62c"), "name" : "xvv" }
{ "_id" : ObjectId("5b7bc547492da74efcdeb62d"), "age" : 81 }
{ "_id" : ObjectId("5b7cb837492da74efcdeb635"), "name" : "xx" }
{ "_id" : ObjectId("5b7cbada492da74efcdeb637"), "name" : "zgg", "age" : 32, "gender" : "女" }
{ "_id" : ObjectId("5b7cbada492da74efcdeb639"), "name" : "zz", "age" : 25, "gender" : "女" }

正则
//

db.student.find({name:/.*z/})
$ｒｅｇｅｘ db.student.find({gender:{$ regex:'男|女'}})

自定义查询

db.student.find({$where:function(){return this.gender=='女'}})

type查找指定类型文档

db.student.find({$where:function(){return this.gender=='女'}})

limit限制查询
跳过前二，返回之后二
skip跳过行数

db.student.find().limit(2).skip(2)
跳过放在ｌｉｎｉｔ前后都可以．

格式化显示结果

db.student.find().pretty()　　　　pretty [ˈprɪti]
{
"_id" : ObjectId("5b7cba98492da74efcdeb636"),
"name" : "zzz",
"age" : 22,
"gender" : "女"
}
{
"_id" : ObjectId("5b7cbada492da74efcdeb637"),
"name" : "zgg",
"age" : 32,
"gender" : "女"
}
{
"_id" : ObjectId("5b7cbada492da74efcdeb638"),
"name" : "1zz",
"age" : 12,
"gender" : "女"
}
{
"_id" : ObjectId("5b7cbada492da74efcdeb639"),
"name" : "zz",
"age" : 25,
"gender" : "女"
}
{
"_id" : ObjectId("5b7cbada492da74efcdeb63a"),
"name" : "fzz",
"age" : 22,
"gender" : "男"
}

查询语句
类型数字备注
Double 1 双精度浮点数 - 此类型用于存储浮点值
String 2 字符串 - 这是用于存储数据的最常用的数据类型。MongoDB中的字符串必须为UTF-8
Object 3 对象 - 此数据类型用于嵌入式文档
Array 4 数组 - 此类型用于将数组或列表或多个值存储到一个键中
Binary data 5 二进制数据 - 此数据类型用于存储二进制数据
Undefined 6 已废弃
Object id 7 对象ID - 此数据类型用于存储文档的ID
Boolean 8 布尔类型 - 此类型用于存储布尔值(true / false)值
Date 9 日期 - 此数据类型用于以UNIX时间格式存储当前日期或时间。可以通过创建日期对象并将日，月，年的日期进行指定自己需要的日期时间
Null 10 Null - 此类型用于存储Null值
Regular 11 正则表达式 - 此数据类型用于存储正则表达式
JavaScript 13 代码 - 此数据类型用于将JavaScript代码存储到文档中
Symbol 14 符号 - 该数据类型与字符串相同；但是，通常保留用于使用特定符号类型的语言
JavaScript (with scope) 15 代码 - 此数据类型用于将带作用域的JavaScript代码存储到文档中
32-bit integer 16 32位整型 - 此类型用于存储数值
Timestamp 17 时间戳 - 当文档被修改或添加时，可以方便地进行录制
64-bit integer 18 64位整型 - 此类型用于存储数值
Min key 255 最小键 - 此类型用于将值与最小BSON元素进行比较
Max key 127 最大键 - 此类型用于将值与最大BSON元素进行比较

输入整型，不写默认浮点

db.student.insert({name:'李啊',age:NumberInt(20)})

查看数字类型
db.student.find({age:{$type:'number'}})

排序

db.student.find().sort({age:1})
db.student.find().sort({age:-1})
先ａｇｅ降在升
db.student.find().sort({age:-1,_id:1})

去重

db.student.distinct('gender',{})
db.集合名称.distinct('去重字段',{条件})
db.student.distinct('age',{name:/.*1/})

投影
指定返回的字段（ｍｙｓｑｌ中的检索列功能）

１显示，０不显示

这样就会返回ｎａｍｅ，在ｎａｍｅ下，没有ａｇｅ字段，所以报错

db.student.find({},{name:1,age:0})

只显示不为０的．
注意：find({},{age:0})

db.student.find({},{age:0})
注意０１区别

ＣＯＵＮＴ
统计数量
查找一共出现次数

db.student.find().count()
15
db.student.count()
15

ｃｏｕｎｔ后跟条件．

db.student.count({age:{ $gt:20}}) 7 这样设置，后面的ＣＯＵＮＴ就会失效 db.student.find().count({age:{$ gt:20}})
15
解决办法，在ｆｉｎｄ上加条件，返回结果，在统计次数．
db.student.find({age:{$gt:20}}).count()
7

db.books.aggregate([{ $group:{_id:'$ by_user',count:{$sum:1}}}])
{ "_id" : "Neo4j", "count" : 1 }
{ "_id" : "w3cschool.cc", "count" : 3 }

？ $sum:1相当于count/$ sum:"$字段名"相当于sum()

做ｉｄ分组了
ｓｕｍ　１　　相当倍数

相当于ｃｏｎｃａｔ，返回一个数组

db.books.aggregate([{ $group:{_id:'$ by_user',push:{ $first:'$ push'}}}])
{ "_id" : "Neo4j", "push" : null }
{ "_id" : "w3cschool.cc", "push" : null }

原句
{ "_id" : ObjectId("5b7d0c632bffdb5c10d72577"), "title" : "Neo4j Overview", "description" : "Neo4j is no sql database", "by_user" : "Neo4j", "url" : "http://www.neo4j.com",
"tags" : [ "neo4j", "database", "NoSQL" ],
"likes" : 750 }

$unwind 将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。

db.books.aggregate([{ $unwind:'$ tags'}])
执行效果
{ "_id" : ObjectId("5b7d0c632bffdb5c10d72577"), "title" : "Neo4j Overview", "description" : "Neo4j is no sql database", "by_user" : "Neo4j", "url" : "http://www.neo4j.com",
"tags" : "neo4j",
"likes" : 750 }
{ "_id" : ObjectId("5b7d0c632bffdb5c10d72577"), "title" : "Neo4j Overview", "description" : "Neo4j is no sql database", "by_user" : "Neo4j", "url" : "http://www.neo4j.com",
"tags" : "database",
"likes" : 750 }
{ "_id" : ObjectId("5b7d0c632bffdb5c10d72577"), "title" : "Neo4j Overview", "description" : "Neo4j is no sql database", "by_user" : "Neo4j", "url" : "http://www.neo4j.com",

"tags" : "NoSQL",
"likes" : 750 }

push补充

db.jobdesc.aggregate([{ $group:{_id:'$ jobname',needpople:{ $push:'$ needpople'}}}])
区别：,needpople:{ $push:'$ needpople'}}}])

{ "_id" : "python2", "needpople" : [ 5 ] }
{ "_id" : "java", "needpople" : [ 1 ] }
{ "_id" : "ios", "needpople" : [ 2 ] }
{ "_id" : "python", "needpople" : [ 3, 2 ] }

db.jobdesc.aggregate([{ $group:{_id:'$ jobname',needpople:{ $push:'$$ROOT'}}}]) 区别：,needpople:{$ push:'$$ROOT'}}}])

{ "_id" : "python2", "needpople" : [ { "_id" : ObjectId("5b7d4cc01eba872641d89f80"), "jobname" : "python2", "workyears" : 5, "tags" : "[python,scrapy]", "needpople" : 5, "age" : 24 } ] }
{ "_id" : "java", "needpople" : [ { "_id" : ObjectId("5b7d4cc01eba872641d89f7f"), "jobname" : "java", "workyears" : "2", "tags" : "[java, mysql]", "needpople" : 1, "age" : 23 } ] }
{ "_id" : "ios", "needpople" : [ { "_id" : ObjectId("5b7d4c10c2f51973c02e326f"), "jobname" : "ios", "workyears" : "3", "tags" : "[OS,mysql,mongodb]", "needpople" : 2, "age" : 25 } ] }
{ "_id" : "python", "needpople" : [ { "_id" : ObjectId("5b7d4b14c2f51973c02e326e"), "jobname" : "python", "workyears" : "3", "tags" : "[python,scrapy,mongodb]", "needpople" : 3, "age" : 20 }, { "_id" : ObjectId("5b7d4cc01eba872641d89f81"), "jobname" : "python", "workyears" : "2", "tags" : "[scrapy,mongodb]", "needpople" : 2, "age" : 30 } ] }

全文索引相当于模糊索引
unique　　会遍历全文，效率低

查看所有索引

db.jobdesc.getIndexes()

创建索引

db.jobdesc.createIndex({jobname:1})

查到索引

db.jobdesc.find({jobname:'python'})

查看当前使用索引信息

db.jobdesc.find({jobname:'python'}).explain()

多条件，复合索引

查数组，要写全，顺序一一对应（要按照顺序弄），才能查到

全文索引teｘｔ文本格式
通过空格分开
特殊符号也能分割．

dropDups
３．ｘ以后就被废弃了．

稀疏索引
sparse

未加稀疏的时候，对于没有的字段默认创建字段，值默认为空ｎｕｌｌ．加稀疏以后，不会索引没有ｋｅｙ的值．

小于６０按６０算
TTL日期索引

删除过后，删除不干净．存在
碎片的索引，没有删除干净，这时，可以，删除然后再重新在建立．
重置索引

索引是存在内存的，数据是放在磁盘的．

对那个数据库操作权限
db:'admin'

ｅｔｃ开安全
31 security:
32 authorization: enabled

ａｄｍｉｎ自己设置的数据库
cc@cc-Inspiron-3542:~$ mongo -u 'cc' -p '12345' --authenticationDatabase admin

ｓｏｒｔ　　无$

db.jobdesc.find({'age1':null}).explain()
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "jobs1.jobdesc",
"indexFilterSet" : false,
"parsedQuery" : {
"age1" : {
" $eq" : null } }, "winningPlan" : { "stage" : "COLLSCAN", "filter" : { "age1" : { "$ eq" : null
}
},
"direction" : "forward"
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "cc-Inspiron-3542",
"port" : 27017,
"version" : "4.0.1",
"gitVersion" : "54f1582fc6eb01de4d4c42f26fc133e623f065fb"
},
"ok" : 1
}

db.jobdesc.find({'age1':null}).explain()
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "jobs1.jobdesc",
"indexFilterSet" : false,
"parsedQuery" : {
"age1" : {
" $eq" : null } }, "winningPlan" : { "stage" : "FETCH", "filter" : { "age1" : { "$ eq" : null
}
},
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : {
"age1" : 1
},

            "indexName" : "age1_1",
            "isMultiKey" : false,
            "multiKeyPaths" : {
                "age1" : [ ]
            },
            "isUnique" : false,
            "isSparse" : false,
            "isPartial" : false,
            "indexVersion" : 2,
            "direction" : "forward",
            "indexBounds" : {
                "age1" : [
                    "[null, null]"
                ]
            }
        }
    },
    "rejectedPlans" : [ ]
},
"serverInfo" : {
    "host" : "cc-Inspiron-3542",
    "port" : 27017,
    "version" : "4.0.1",
    "gitVersion" : "54f1582fc6eb01de4d4c42f26fc133e623f065fb"
},
"ok" : 1

}

db.jobdesc.find({'age1':null}).explain()
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "jobs1.jobdesc",
"indexFilterSet" : false,
"parsedQuery" : {
"age1" : {
" $eq" : null } }, "winningPlan" : { "stage" : "FETCH", "filter" : { "age1" : { "$ eq" : null
}
},
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : {
"age1" : 1
},
"indexName" : "age1_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"age1" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"age1" : [
"[null, null]"
]
}
}
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "cc-Inspiron-3542",
"port" : 27017,
"version" : "4.0.1",
"gitVersion" : "54f1582fc6eb01de4d4c42f26fc133e623f065fb"
},
"ok" : 1
}

多权限 ?
roles:[{role:''},{role:''}]
roles:[{role:''}}]

全文索引
全文索引的查找:
1：使用全文索引查询不需要指定全文索引的字段名字——直接使用 $text,$ search即可
2：在MongoDB中每个数据集合只允许创建一个全文索引，不过这个全文索引可以针对一个、多个、全部的数据集合的字段来创建。
3：查询多个关键词，可以使用空格将多个关键词分开——空格——或的关系
4：指定不包含的字段使用-来表示—— -:非的关系
5：引号包括起来代表与的关系—— \”\”:与的关系

db.articles.find({ $text:{$ search:"coffee"}})
db.articles.find({ $text:{$ search:"aa bb cc"}}) #空格代表或操作，aa或bb或cc
db.articles.find({ $text:{$ search:"aa bb -cc"}}) #-号为非操作，即不包含cc的
db.articles.find({ $text:{$ search: ""aa" "bb" "cc""}}) #加双引号可以提供与关系

外接
间隙索引与唯一约束

在唯一索引中，唯一索引会把null当做值，也就是说为null的通常只能有一个。后面的null将无法插入。
//下面创建一个带有唯一约束的稀疏索引
> db.scores.createIndex( { score: 1 } , { sparse: true, unique: true } )
{
        "ok" : 0,
        "errmsg" : "Index with name: score_1 already exists with different options",
        "code" : 85
}

//由于score列上已经存在一个索引了，因此提示我们，需要先删除，再创建

> db.scores.dropIndex("score_1")
{ "nIndexesWas" : 2, "ok" : 1 }                  

> db.scores.createIndex( { score: 1 } , { sparse: true, unique: true } )
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

//下面尝试插入一些带有score键以及不带有score键的文档，如下，可以成功插入
> db.scores.insert( { "userid": "AAAAAAA", "score": 43 } )
WriteResult({ "nInserted" : 1 })
> db.scores.insert( { "userid": "CCCCCCC" } )
WriteResult({ "nInserted" : 1 })

//下面插入一些score相关的文档，提示重复，如下示例
> db.scores.insert( { "userid": "AAAAAAA", "score": 82 } )
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 11000,
                "errmsg" : "E11000 duplicate key error collection: test.scores index: score_1 dup key: { : 82.0 }"
        }
})
> db.scores.insert( { "userid": "BBBBBBB", "score": 90 } )
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 11000,
                "errmsg" : "E11000 duplicate key error collection: test.scores index: score_1 dup key: { : 90.0 }"
        }
}

本地ｉｐ可不写
mongodump -o '/home/cc/桌面/backup'

json后面可以不加-f默认导出所有字段
mongoexport -d dbname -c collectionname -o file --type json/csv -f field

导出
mongoexport -d class1804 -c books -o '/home/cc/桌面/backup/books.csv' --type csv -f '_id,title,url'

数据库不用先创建
集合相反

MongoDB实战项目与重点总结

索引是存在内存的，数据是放在磁盘的．

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读