常用命令，及其高级命令使用介绍
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
|
一：增删改查的高级应用详细介绍：
增：***插入的时候c1不在的话将自动创建***
不管插入那条记录都会自动给带个值id 自增主键唯一
insert
和 save（当id冲突是则修改，否则插入）
一:id主键不冲突的情况没区别
db.c1.
insert
({
name
:
"leyangjun"
});
db.c1.
insert
({
name
:
"leyangjun"
});
insert
插入的值id都是唯一的，不会主键id冲突
db.c1.save({
name
:
"leyangjun"
}); 和
insert
一样没区别插入记录的id都是唯一主键
二：id主键冲突的情况（冲突则更新）
db.c1.
insert
({_id:1,
name
:
"leyangjun2"
});
db.c1.
insert
({_id:1,
name
:
"leyangjun2"
}); 在插入同样的值就会报错
db.c1.save({_id:1,
name
:
"leyangjun3"
});
--就插入成功，id冲突则更新，把idname=leyangjun2 改成leyangjun3
还可以这么插入(很灵活)：
*最好别这么玩，这么的后果就是你在php程序里面用时取值就麻烦啦
db.c1.
insert
({
name
:
"user1"
,post:{tit:1,cnt:1111}});
--值是子JSON
db.c1.
insert
({
name
:
"user1"
,post:[1,2,3,4,5,6]});
--值是数组
既能是js的json还可以循环插入10条：
for
(i=1; i<=10; i++){
db.c1.
insert
({
name
:
"user"
+i});
}
删：
db.c1.remove(); 全部删除 ==({})空JSON，是json的就全删除
db.c1.remove({
name
:
"user1"
});
--指定删除
查：
db.c1.find(); ==({})查询所有
db.c1.find({
name
:
"user3"
}); 条件查询
场景：记录中有多列只要指定的列（但是_id会默认带上），要的为1，不要为0
db.c1.
insert
({
name
:
"leyangjun"
,age:23,sex:
"nan"
});
db.c1.find({
name
:
"leyangjun"
},
name
:1); 只取这条记录
name
这列
db.c1.find({
name
:
"leyangjun"
},
name
:1，age:1); 取
name
,age这个2列
db.c1.find({
name
:
"leyangjun"
},
name
:1,_id:0); 不要默认的_id列
条件表达式查询：
1): <,<=,>,>=
--$gt大于、$lt小于 、$gte大于等于、$lte小于等于
插入10做测试
for
(i=1; i<=10; i++){
db.c1.
insert
({
name
:
"user"
+i,age:1})
}
db.c1.find({age:$gt:5}); 年龄大于5的 $gt大于
db.c1.find({age:$lt:5}); 年龄小于5的 $lt小于
db.c1.find({age:$gte:5}); 年龄大于等于5的 $gte大于等于
db.c1.find({age:$lte:5}); 年龄小于等于5的 $lte小于等于
db.c1.find({age:5}); 年龄等于5的
db.c1.find({age:$ne:5}); 年龄不等于5的
统计里面有多少条记录：db.c1.
count
(); 或者 db.c1.find().
count
()；
排序：
db.c1.find().sort({age:1})
--- 1表示升序
db.c1.find().sort({age:-1})
--- -1是降序
limit和 结合 skip分页：
db.c1.find().limit(3);
---从0开始拿3条记录
db.c1.find().skip(1).limit(5);
---跳过一个拿出5条（也就是从第几个开始拿几个） 2,3,4,5,6
db.c1.find().sort({age:-1}).skip(1).limit(5).
count
(0);
---count统计默认是0，不会看前面写的条件，有几条就统计几条
db.c1.find().sort({age:-1}).skip(1).limit(5).
count
(1);
---按照前面的条件在统计记录数
2):$
all
,查出包含某个值
--主要针对数组来用
db.c1.
insert
({
name
:
"user"
},post:[1,2,3,4,5,6]);
db.c1.find({post:{$
all
:[1,2,3]}});
--找出post中包含1,2,3的，其中有值为假就查不出来
3):$exists 操作检查一个字段是否存在
db.c1.find({age:{$exists:1}});
---查看是否包含字段age
4):$mod 取余
db.c1.find({age:{$mod:[2,1]}});
---取对2 余1的 1,3,5,7,9.....
db.c1.find({age:{$mod:[2,0]}});
---取对2 余0的 2,4,6,8,10.....
5):$ne 不等于
db.c1.find({age:$ne:5}); 年龄不等于5的
6):$
in
和 $nin 类似于传统关系型数据库中的
in
,
not
in
db.c1.find({age:{$
in
:[1,3,5]}});
---age等于1,3,5的值（是不是数组是操作符）
b.c1.find({age:{$nin:[1,3,5]}});
---age不等于1,3,5的
*规律：查询的时候一般出现的[1,3,5]是操作符不是数组
7):$
or
、$nor（二者是相反的）
db.c1.find({$
or
:[{
name
:
"user2"
},{
name
:
"user3"
}]});
--找出name=user2 或者 name=user3的记录
db.c1.find({$nor:[{
name
:
"user2"
},{
name
:
"user3"
}]});
--过滤掉name=user2和user3的记录
db.c1.find({$
or
:[{
name
:
"user2"
},{age:8},{age:10}]});
--找出name=user2 或 age=8 或 age=10的记录
db.c1.find({$nor:[{
name
:
"user2"
},{age:8},{age:10}]});
----找出name!=user2 或 age!=8 或 age!=10的记录
8)：$
size
找出字段数组值的个数->专门正对数组的操作
db.c1.
insert
({
name
:
"user1"
,post:[1,2,3,4,5,6]}); 第一条记录
db.c1.
insert
({
name
:
"user1"
,post:[7,8,9]}); 第二条记录
db.c1.find({post:$
size
:3});
--就会找到第二条记录，post里面的的个数是3
9)****正则表达式*******
和js正则一样：
db.c1.find({
name
:/
user
/i});
---找出name值包含user的
10):
DISTINCT
类似关系数据库中的
distinct
db.c1.
insert
({
name
:
"leyangjun"
});
db.c1.
insert
({
name
:
"leyangjun"
});
db.c1.
distinct
(
"name"
);
---name值去重，查出一条记录
11):$elemMatch元素匹配
db.c3.
insert
({
name
:
"user1"
,post:[{tit:1},{tit:2},{tit:3}]});
db.c3.
insert
({
name
:
"user2"
,post:[{tit:
"aaa"
},{tit:
"bbb"
},{tit:
"ccc"
}]});
查找tit=2的记录
db.c3.find({
"post.tit"
:2});
--可以找到
db.c3.find({post:{$elemMatch:tit:2}});
--这种方式匹配
db.c3.find({post:{$elemMatch:tit:2,tit:3}});
--匹配tit=2 tit=3的记录
12):游标的概念（用的很少）
var x=db.c1.find();
x.hasNext();
--有没有值，返回的是true 和 false，true的话就去链接数据库拿值，否则链接数据库
x.
next
()
--取出来一条值
x.
next
()
x.
next
()
x.
next
()
---有值就一直往下取
x.hasNext();
---为FALSE也就没值啦
13)：
null
查询（没有值，值为空，值为
NULL
的）
匹配age=
null
的
db.c4.find({age:
null
});
---这个匹配是不准的，记录中没有age字段的也会被查出来
db.c4.find({age:{$exists:1,$
in
:[
null
]}});
--先判断过滤age是否存在，在匹配age=null的
或
db.c4.find({age:$type:10});
---10就是null 推荐使用这种查null
db.c4.find({age:$type:10,
name
:
"user1"
});
--age=null 并且 name=user1
14):$slice->只针对数组
db.c3.
insert
({
name
:
"user1"
,post:[{tit:1},{tit:2},{tit:3}]});
db.c3.find({
name
:
"user1"
,{post:$slice:2}});
---取name=user1,前2条贴，就是post字段的值 对应数组的：1,2
db.c3.find({
name
:
"user1"
,{post:$slice:-2}});
---取name=user1,后2条贴，就是post字段的值 对应数组的：2,3
db.c3.find({
name
:
"user1"
,{post:$slice:[1,2]}}),
--- 从第1条开始取2条贴 对应数组的：2,3
改：
update
语法介绍 默认是0,0
--后面2个参数值
db.collection.
update
(criteria,objNew,upsert,multi);
参数说明：
criteria：用于设置查询条件的对象
objnew：用于设置更新的内容对象
upsert：如果记录已经存在，更新它，否则新增一个记录
multi：如果有多个符合条件的记录，全部更新
注意：默认情况，只会更行第一个符合条件的记录哦
例子：
db.c1.
insert
({
name
:
"leyangjun"
,age:23);
db.c1.
update
({
name
:
"leyangjun"
},{sex:
"nan"
});
--这样会吧name,age删掉，记录只会留下sex字段值
db.c1.
update
({
name
:
"user6"
},{
name
:
"user66"
},1);
--1表示，user6存在则改成user66,否则user6不存在则增加新的记录name=user66
第4个参数只能配合魔术变量使用$
set
,批量更新
db.c1.
update
({
name
:
"user6"
},{$
set
:{
name
:
"user66"
}},0,1);
--将所有的name=user6的全部更新user66
2):$
set
增加字段，或批量修改字段值（存在则更新，不存在则增加）
db.c1.
update
({
name
:
"user6"
},{$
set
:{
name
:
"user66"
}},0,1);
--批量修改name值
db.c1.
update
({
name
:
"user10"
},{$
set
:{age:10}},0,1);
--将name=user1的全部加上 age字段，且值=10
3)：$inc
-->increment自增的意思,如果字段有则加减（自己定），没有则新增
场景：现在在大促了，想给没给会员赠送5个积分，但是：积分字段有的会员没有有的有的情况
现在想没有积分字段的会员也得加5分，$inc就能做到
db.c1.
insert
({
name
:
"leyangjun"
,age:23,score:11});
db.c1.
insert
({
name
:
"leyangjun"
,age:23,score:1});
db.c1.
insert
({
name
:
"leyangjun"
,age:23});
--加积分
db.c1.
update
({},{$inc:score:10},0,1);
--{}表示所有用户，都加10个积分，没有score字段的，$inc会统一加上
db.c1.
update
({
name
:
"user1"
},{$inc:score:10}); 加减都行
db.c1.
update
({
name
:
"user1"
},{$inc:score:-10});
*
set
和 $inc 都可以增加字段，但是$inc增加必须是整型
4)：$unset 删除字段（自带的_id字段是删不鸟的）
db.c5.
update
({},{$unset:{score:1},0,1);
--1表示true，将所有记录中的score字段删掉
db.c5.
update
({},{$unset:{score:1,age:1},0,1);
--删除多个
5)：$push 针对数组增加元素(更新的魔术方法一般在字段的外侧，查询是在内侧)
db.c3.
insert
({
name
:
"user1"
,arr:[1,2,3]});
db.c3.
update
({
name
:
"user1"
},{$push:{arr:4}});
--name=user1的arr增加元素，记住不能同时插入多个(可以压数组，就是不能同时压入多个值)
6)：$pop 将字段里的最后元素移除，针对数组
db.c3.
update
({
name
:
"user1"
},{$pop:{arr:1}});
--1表示最后一个，将arr里面的最后元素移除
db.c3.
update
({
name
:
"user1"
},{$pop:{arr:-1}});
-- -1表示删除第一个值
7):$pushAll 压入多个值
db.c3.
update
({
name
:
"user1"
},{$push:{arr:[4,5,6]}});
---压入多个值
8)：$addToSet 压入值是会去重复插入（如值里面有4，在这么插入里面只会有一个4）
db.c3.
update
({
name
:
"user1"
},{$addToSet:{arr:4}});
--如果值里面有4，是插入不进去的，没有重复的则插入
$addToSet 和 $each 配合使用插入多个：
db.c3.
update
({
name
:
"user1"
},{$addToSet:{arr:{$each:[7,8,9]}}});
--插多个
9)：$pull 删除数组里面的某个值，针对数组
db.c3.
update
({
name
:
"user1"
},{$pull:{arr:5}});
--删除数组中为5的值
10):$pullAll一次性删除多个
db.c3.
update
({
name
:
"user1"
},{$pullAll:{arr:[2,4]}});
--删除值为2,4
11)：$rename修改字段名
db.c3.
update
({
name
:
"user1"
},{$rename:{arr:
"post"
}}); 或
db.c3.
update
({
name
:
"user1"
},{$rename:{
"arr"
:
"post"
}});
12):特殊的操作符号 $
db.c3.
insert
({
name
:
"user1"
,arr:[{tit:
"php"
},{tit:
"java"
},{tit:
"linux"
}]});
把标题为linux的值改下：
db.c3.
update
({
"arr.tit"
:
"linux"
},{$
set
:{
"arr.$.cnt"
:
"linux is very good"
}});
*小结：
场景1：
db.c1.
insert
({
name
:
"leyangjun"
,age:23});
var x=find({
name
:
"user1"
});
x
--回车有值
x
--在回车没值了，所以find本身是带有游标的
场景2：
var x=findOne({
name
:
"user1"
});
x
--回车有数据 x是一个json，在mogodb客户端的时候输出你就能看看出来
x
--回车还有数据
x.sex=
"nan"
--可以加字段，但是这加的字段是不会直接加到数据记录
x.sex=
"score"
......
把x加字段，直接保存到数据库
db.c1.save(x);
--数据就加到里面去啦,
db.c1.
insert
({
name
:
"leyangjun"
,age:23});
---增
db.c1.remove();
---删（删除所有）
db.c1.remove({
"name"
:
"leyangjun"
});
--删除名字等于leyangjun的记录
db.c1.
update
({
name
:
"leyangjun"
},{
name
:
"lekey"
});
---改，（如果还有age值的话，会被删除，只留下name值）
db.c1.
update
({
name
:
"leyangjun"
},{$
set
:{
name
:
"lekey"
}});
--改，这个改会保留原有的值
db.c1.
update
({
name
:
"lekey"
},{$
set
:{sex:
"nan"
}});
--还可增加值，名字等于lekey记录增加字段值sex
db.c1.find();
---查
db.c1.find({
"name"
:
"leyangjun"
});
***普通集合 和 固定集合 的区别*****
普通集合：普通集合的空间是随着你的json对象的值增多而自动增大
固定集合：在32位机上一个append collection的最大值约483.5M，64位上只受系统大小的限制。
二：capped collection（固定集合）
小命令记住鸟：
show dbs;
--显示所有数据库
db
--显示当前数据库
show tables;
-- 显示当前库下的所有集合（也就是显示所有表）
db.c5.
drop
();
--删除c5集合
db.dropDatabase();
注意哈：mongodb当你插入和进入的时候会默认的给你创建数据库和集合（表）
db.createCollection(
"c1"
);
--手动创建c1集合（表）
db.c1.find();
db.c1.
drop
();
简单介绍：
capped collections是性能出色的有着固定大小的集合，以LRU(least recently used最近最少使用)
规则和插入顺序进行age-
out
(老化移出)处理，自动维护集合中对象的插入顺序，在创建时要预先执行大小
。如果空间用完，新添加的对象将会取代集合中最旧的对象。
永远保持最新的数据
功能特点：
可以插入及更新，但更新不能超出collection的大小，否则更新失败。
不允许删除，但是可以调用
drop
()删除集合中的所有行，但是
drop
后需要显示地重建集合。
在32位机上一个append collection的最大值约483.5M，64位上只受系统大小的限制（就是系统对文件大小的限制）。
属性及方法: 优点
属性1：对固定集合进行插入速度极快
属性2：按照插入顺序的查询输出速度极快
属性3：能够在插入最新数据时，淘汰最早的数据
用法1：存储日志信息
用法2：缓存一些少量的文档
创建固定集合：
createCollection命令来创建
--size是大小设置的是10M,如果你的文件超了10M之前的文件就会被自动删除（删除的规则是老的数据会被删除一次类推）
db.createCollection(
"my_collection"
,{cappend:
true
,
size
:10000000,
max
:5});
创建一个集合为：‘my_collection’的固定集合，大小为10000000字节。还可以限定文档个数。加上
max
：100属性。
注意：指定文档上限，必须指定大小。文档限制是在容量没满是进行淘汰，要是满了，就根据容量限制来进行淘汰。
当你创建集合后会自动给你创建对应的indexSize{
"_id_"
:xxxx}索引id，能后
db.system.indexs.find();
--这个里面就会自动为你刚才建立的集合形成主键索引 创建对应的ID在这里
db.c1.stats();
--查看集合C1的状态值，大小啊什么的，索引id什么的
注意有个属性：capped为1 说明是固定集合
普通集合转固定集合：
runCommand命令
db.runCommand({converToCapped:
"c2"
,
size
:10000000,
max
:3});
三：GridFS (大文件上传和下载,专门用来存储图片和视频)
介绍：GridFS是一种在mongodb中存储大二进制文件的机制，使用GridFS的原因以下几种：
->存储巨大的文件，比如视频、高清图片
->利用GridFS可以简化需求
->GridFS会直接利用已经建立的复制或分片机制，故障恢复和扩展都很容易
->GridFS可以避免用户上传内容的文件导致系统出现问题
->GridFS不产生磁盘碎片
GridFS使用两个表来存储数据：
files 包含元数据对象
chunks 包含其他一些相关信息的二进制块
* 为了使多个GridFS命名为一个单一的数据库，文件和块都有一个前缀，默认情况下，前缀是fs,
所以任何默认的GridFS存储将包含fs.files和fs.chunks。
各种第三房语言可以更改其前缀。
使用GridFS mongofiles（存文件的地方）
mongofiles 是从命理行操作GridFS的一种工具
三个命令：put(存储) get(获取，下载) list(列表)
例子：
./mongofiles -h
--查看支持的基本参数
./mongofiles list
--查看mongofiles 的所有文件
现在模拟一个文件丢到里面去
tar czf mongosniff.tar.gz mongosniff
--把mongosniff文件压缩成包
./mongofiles put mongosniff.tar.gz
--把包文件上传上去
能后你在进入mongo
./mongo
show tables;
--你会发现多了2个集合 fs.files 、fs.chunks
db.fs.files.find();
--查看
--出现对应的字段说明：
filename：存储的文件名
chunkSize: chunks分块的大小
uplodaDate:入库时间
md5：此文件的md5码
length：文件大小，单位”字节“
fs.files中存储的是一些基础的元数据信息，真正的内容在fs.chunks里面
db.fs.chunks.find();
--真正的文件是在这里面的哦
exit;
./mongofiles list
--就可以查看到我们穿上来的文件包
./mongofiles get mongosniff.tar.gz
--下载这个文件，下载到你当前执行命令的目录下
./mongofiles
delete
mongosniff.tar.gz
--删除该文件
*注意：当你删除mongofiles下的文件时候，fs.files 、fs.chunks表下也就没东西
四：性能
一：索引管理
mongodb提供了多样性的索引支持，索引信息被保存在system.indexs中，mongodb中的_id字段在
创建的时候，默认已经建立了索引，这个索引比较特殊，并且不可删除，不过capped collection列外。
1：建立索引
一：普通索引
for
(i=1;i<=10;i++){
db.c1.
insert
({
name
:
"user"
+i,age:i});
}
db.c1.find({
name
:
"user5"
}).explain();
--explain和MySQL一样解析一条语句，没索引就全表扫描这个可以看出来
1是升序(默认) -1是降序
db.c1.ensureIndex({
name
:1});
db.c1.ensureIndex({
name
:1},{background:
true
});
--如果数据较大耗时，放到后台执行，加上第二个参数即可，表示放到后台执行
db.c1.getIndexKeys();
--查看所有字段 简单信息
db.c1.getIndexes()
--查看表索引 详细信息
db.c1.find({
name
:
"user5"
}).explain();
--建立完索引后，你会发现只会扫描一行，不会全表扫描
二：唯一索引
db.c1.ensureIndex({age:1},
unique
:1);
--age字段建立唯一索引
db.c1.
insert
({
name
:
"user11"
,age:10});
--你会发现插不进去，以为age是唯一索引
2：查看索引
db.c1.getIndexKeys();
--查看所有字段 简单信息
db.c1.getIndexes()
--查看表索引 详细信息
3：删除索引
db.c1.dropIndexes();
--删除所有索引 _id删不掉哦
db.c1.dropIndex({
name
:1});
--指定删除name索引
二：性能优化
explain执行计划（看影响行数）
mongodb提供了一个explain命令让我们获知系统如何处理查询请求，利用explain命令
我们可以很好的观察系统如何使用索引来加快检索，同时可以针对性优化索引。
优化器profile(类似MySQL的慢查询日志)
默认是关闭的，且默认是100毫秒
db.getProfilingLevel();
--0 如果是0,说明没有开启慢查询日志
db.setProfilingLevel(1);
--1 表示开启记录慢查询（默认为100ms）
--2 表示记录所有命令
db.setProfilingLevel(1，1000);
--第一种方式：第二个参数是设置时间毫秒为单位
--第二种方式：启动mongodb时带上 --slowms 设置
mongodb优化方案：
1：创建索引
2：限定返回结果条数
3：查询使用到的字段，不查询所有字段
4：采用 capped collection
capped collections 比普通collections的读写效率高
5：采用profiling慢查询日志
三性能监控（自带的2个工具）
1：mongosniff 记载通讯记录
打开2个窗口
./mongosniff
--source net lo A窗口执行
./mongo
--B窗口链接mongodb，能后 ，A窗口就已经记录B的操作信息，登录啊退出啊什么的
2:mongostat 监控（谁访问，查删啊。。。。。）
./mongostat
--A窗口执行，会每一秒会刷新界面
./mongo
--B窗口链接mongodb， B执行的增删查的记录会在A窗口被监控到
|
3129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
