MongoDB基础学习一 ---- MongoDB的基本使用

var dept = {
	"user" : "Java",
	"age" : 40,
	"sex" : "女",
	"地址" : "日本"
}

db.first.insert([
{"url" : "www.baidu.com"},
{"url" : "www.xina.com"},
{"url" : "www.huohu.com"}
])

for(var x = 0; x < 10;x ++){
	db.first.insert({"url" : "www.mzitu.com/" + x + ".html"});
}

db.student.insert({"name" : "吴一", "sex" : "男", "age" : 19, "score" : 100, "address" : "日本"})
db.student.insert({"name" : "孙二", "sex" : "女", "age" : 35, "score" : 80, "address" : "海南"})
db.student.insert({"name" : "张三", "sex" : "男", "age" : 27, "score" : 70, "address" : "新加坡"})
db.student.insert({"name" : "李四", "sex" : "男", "age" : 20, "score" : 60, "address" : "美国"})
db.student.insert({"name" : "王五", "sex" : "女", "age" : 46, "score" : 50, "address" : "俄罗斯"})
db.student.insert({"name" : "赵六", "sex" : "女", "age" : 58, "score" : 40, "address" : "加拿大"})
db.student.insert({"name" : "苗七", "sex" : "男", "age" : 32, "score" : 30, "address" : "中国"})
db.student.insert({"name" : "王八", "sex" : "男", "age" : 24, "score" : 20, "address" : "尼泊尔"})
db.student.insert({"name" : "刘九", "sex" : "女", "age" : 37, "score" : 10, "address" : "泰国"})
db.student.insert({"name" : "钱十", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南"})



# and 与语句
db.student.find(
	{
		"$and" : [
			{"sex" : "男"},
			{"score" : {
				"$gte" : 60
			}}
		]
	}
).pretty()
db.student.find({"sex" : "男", "score" : {"$gt" : 60}}).pretty()
db.student.find(
	{"age" : {"$gte" : 30, "$lte" : 60}}
).pretty()

# or 或语句
db.student.find({
	$or	: [
		{"sex" : "男", "score" : {"$gt" : 60}}
	]
}).pretty()
db.student.find(
	{"age" : {"$ne" : 30}}
).pretty()
db.student.find(
	{
		"$or" : [
			{"age" : {"$gt" : 19}},
			{"score" : {"$gt" : 90}}
		]
	}
).pretty()

# nor 非语句
db.student.find(
	{
		"$nor" : [
			{"age" : {"$gt" : 40}},
			{"score" : {"$gt" : 80}}
		]
	}
).pretty()
db.student.find(
	{
		"$not" : [
			{"age" : {"$gt" : 40}},
			{"score" : {"$gt" : 80}}
		]
	}
).pretty()

# and 语句 和 or 语句连用
db.student.find(
	{
		"sex" : {$ne : "男"},
		"$or" : [
			{"score" : {"$gt" : 60}},
			{"name" : {"$ne" : "吴一"}}
		]
	}
).pretty()



# 求模 {"$mod" : [数字, 余数]}
# 用集合中的对应字段去除以给定的数字，余数为给定的余数的所有情况
db.student.find(
	{"age" : {$mod : [30, 0]}}
).pretty();



# $in(在范围之内) 和 $nin(不在范围之内) 
db.student.find(
	{
		"name" :{"$in" : ["张三", "李四", "赵六"]}
	}
).pretty()
db.student.find(
	{
		"name" :{"$nin" : ["张三", "李四", "赵六"]}
	}
).pretty()



db.student.insert({"name" : "鬼谷子 - A", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "英语", "政治", "历史"]})
db.student.insert({"name" : "鬼谷子 - B", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "历史"]})
db.student.insert({"name" : "鬼谷子 - C", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["政治", "历史"]})
db.student.insert({"name" : "鬼谷子 - D", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["政治", "历史"]})
db.student.insert({"name" : "鬼谷子 - E", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "政治", "历史"]})



# $all 
# 查询所有的包含语文数学的学生
db.student.find(
	{"course" : {"$all" : ["语文", "数学"]}}
).pretty()

# 使用索引(index 从0开始)
# 范例：查询第二门课程是数学的情况
db.student.find(
	{"course.1" : "数学"}
).pretty()

# $size 数量控制
# 查询只选择两门课的学生
db.student.find(
	{"course" : {"$size" : 2}}
).pretty()

# $slice 控制返回的数量
# 范例：返回年龄为30，只返回前两门参加的课程
db.student.find(
	{"age" : 30},
	{
		"course" : {
			"$slice" : 2
		}
	}
).pretty()
# 范例：后两门
db.student.find(
	{"age" : 30},
	{
		"course" : {
			"$slice" : -2
		}
	}
).pretty()

# {"$slice" : [n, m]} 跳过 n 个，返回 m 个
db.student.find(
	{"age" : 30},
	{
		"course" : {
			"$slice" : [1, 2]
		}
	}	
).pretty()



db.student.insert({"name" : "王大拿 - A", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "英语", "政治", "历史"], 
	"parents" : [{"name" : "王大拿 - A（父亲）", "age" : 50, "job" : "教练"},{"name" : "王大拿 - B（母亲）", "age" : 46, "job" : "工人"}]
})
db.student.insert({"name" : "王大拿 - B", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "历史"],
	"parents" : [{"name" : "王大拿 - B（父亲）", "age" : 50, "job" : "处长"},{"name" : "王大拿 - B（母亲）", "age" : 46, "job" : "工人"}]
})
db.student.insert({"name" : "王大拿 - C", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["政治", "历史"],
	"parents" : [{"name" : "王大拿 - C（父亲）", "age" : 50, "job" : "局长"},{"name" : "王大拿 - B（母亲）", "age" : 46, "job" : "工人"}]
})
db.student.insert({"name" : "王大拿 - D", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["政治", "历史"],
	"parents" : [{"name" : "王大拿 - D（父亲）", "age" : 50, "job" : "工人"},{"name" : "王大拿 - B（母亲）", "age" : 46, "job" : "教师"}]
})
db.student.insert({"name" : "王大拿 - E", "sex" : "男", "age" : 30, "score" : 46, "address" : "越南", "course" : ["语文", "数学", "政治", "历史"],
	"parents" : [{"name" : "王大拿 - E（父亲）", "age" : 50, "job" : "组长"},{"name" : "王大拿 - B（母亲）", "age" : 46, "job" : "工人"}]
})



# 使用$elemMatch查询嵌套集合
db.student.find(
	{
		"$and" : [
			{"age" : {"$gte" : 30}},
			{"parents" : {
				"$elemMatch" : {"job" : "教师"}
			}}
		]
	}
).pretty()



# $exists 判断某个字段是否存在
db.student.find(
	{
		"parents" : {"$exists" : true}
	}
).pretty()
db.student.find(
	{
		"course" : {"$exists" : false}
	}
).pretty()



# $where 条件过滤
db.student.find(
	{"$where" : "this.age > 30"}
).pretty()
db.student.find(
	"this.age > 30"
).pretty()
db.student.find(function(){
	return "this.age > 30";
}
).pretty()
db.student.find({"$where" : function(){
	return "this.age > 30";
}}
).pretty()

db.student.find(
	{
		"$and" : [
			{"$where" : "this.age > 30"},
			{"$where" : "this.age < 40"},
		]
	}
).pretty()



# $regex
# 查询名称中带有谷的字段,不加引号，加引号都变为字符串了
db.student.find(
	{"name" : /谷/}
).pretty()
# i 不区分大小写
# 查询名字中带有A的情况
db.student.find(
	{"name" : /a/i}
).pretty()
# 加 $regex 关键词
db.student.find(
	{"name" : {"$regex" : /a/i}}
).pretty()
# 查询数组内容
db.student.find(
	{"course" : {"$regex" : /英/i}}
).pretty()



# 集合中元素排序
# 使用 sort() 函数, 1 升序； -1 降序
db.student.find().sort(
	{"score" : -1}
).pretty()
# $natural 自然排序
# 按照查询顺序排序
db.student.find().sort(
	{"$natural" : -1}
).pretty()



# 分页显示
	|- skip(n) 表示跨过多少数据行
	|- limit(n) 取出的数据行的限制个数
# 第一页
db.student.find().skip(0).limit(5).sort({"age" : -1}).pretty()
# 第二页
db.student.find().skip(5).limit(5).sort({"age" : -1}).pretty()



# 数据更新操作 (update 和 save)
# update
|- 语法如下：db.集合.update(更新条件, 新的对象数据(更新操作符), upsert, multi)
	|- upsert 如果要更新的数据不存在，则增加一条新的内容(true 增加， false 不增加)
	|- multi 表示是否只更新满足条件的第一行记录。如果设置为false，只更新第一个；如果为true，全部更新
# 范例：把年龄为30岁的成绩都更新为100
|- 更新存在的数据
	|- 只更新一条
db.student.update(
	{"age" : 30},
	{"$set" : {"score" : 100}},
	false,
	false
)

# 查询记录
db.student.find(
	{"age" : 30}
).skip(0).limit(10).sort(
	{"natural" : 1}
).pretty()

	|- 更新全部记录
db.student.update(
	{"age" : 30},
	{"$set" : {"score" : 100}},
	false,
	true
)

|- 更新不存在的数据
# 相当于文档的创建
db.student.update(
	{"name" : "不存在"},
	{"$set" : {"name" : "确实不存在"}},
	true,
	false
)


# save
db.student.save(
	{"_id" : ObjectId("58b2455524dd9e3990acee12"), "age" : 50}
)
db.student.save(
	{"_id" : ObjectId("58b2455524dd9e3990acee12"), "score" : 80}
)
# 当前id不存在
db.student.save(
	{"_id" : ObjectId("58b2455524dd9f3990acee12"), "change" : 80}
)
# 由于此时对应的id字段存在，所以就变为了更新操作，但是如果要保存的数据不存在,
# 那么就变为增加操作


# 由于save更新的时候要找到id字段，相比较来说建议使用update操作


# 首先贴出一个每次修改完以后都会使用的语句：查询
db.student.find(
	{"name" : "对应的姓名"}
).skip(0).limit(5).sort(
	{"$natural" : -1}
).pretty()
# 修改器
# 对于MongoDB数据库而言，数据的修改会牵扯到内容的变更，结构的变更（可能含有数组），所以在MongoDB设计的时候，
# 就提出了一系列的修改器的应用，像之前使用的"$set" 就是一种修改器
# 一共提供了十种修改器

1. $inc : 主要针对于一个数字字段，增加或减少某个数字字段的数据内容
	|- 语法 {"$inc" : {"成员" : "内容"[, "成员" : "内容"]}}
# 范例：将年龄为30岁的学生，成绩一律减少30分，年龄减1
db.student.update(
	{"age" : 30},
	{"$inc" : {"score" : -30, "age" : -1}}, # 年龄减1， 分数减30
	false,
	true
)

2. $set : 进行内容的重新设置
	|- 语法 {"set" : {"成员" : "新内容"[, "成员" : "新内容"]}}
# 范例：将年龄为29岁的人的成绩修改为80分，年龄设置为30
db.student.update(
	{"age" : 29},
	{"$set" : {"score" : 80, "age" : 30}}, # 年龄修改为30， 成绩修改为80
	false,
	true
)

3. #unset : 删除某个成员的内容
	|- 语法 {"$unset" : {"成员" : 1[,"成员" : 1]}}
范例：删除张三的年龄和分数字段
db.student.update(
	{"name" : "张三"},
	{"$unset" : {"age" : 1, "score" : 1}}, # 执行之后这两个字段就被删除了
	true,
	false
)

4. $push : 相当于将内容追加到指定的成员之中(基本上是数组)；
	|- 语法 {"$push" : {"成员" : "内容"}}
范例：给张三添加课程信息，添加数组形式(注意观察这个例子的结果)
db.student.update(
	{"name" : "张三"},
	{"$push" : {"course" : ["语文", "数学"]}}, # 执行之后追加了一个课程字段，会重新创建一个数组，把这个数组放在重新创建的数组中
	true,
	false
)
# 范例：给李四添加课程信息，非数组
db.student.update(
	{"name" : "李四"},
	{"$push" : {"course" : "数学"}}, # 创建一个数组，把数据放在数组中
	true,
	false
)
# 范例：向 王大拿 - E 中添加美术课程
db.student.update(
	{"name" : "王大拿 - E"},
	{"$push" : {"course" : "美术"}}, # 由于有course 字段，所以在尾部追加内容
	true, 
	false
)
# 通过观察上面的几组数据可以发现：$push 就是进行数组的添加操作使用的，如果没有数组则进行一个新的数组的创建，
# 如果有数组，则在数组里面追加

5. $pushAll : 与 "$push" 类似，可以一次追加多个内容到数组中
	|- 语法 {"$pushAll" : {"成员" : ["内容1", "内容2"]}}
范例：向王五的信息中添加多个课程内容
db.student.update(
	{"name" : "王五"},
	{"$pushAll" : {"course" : ["美术", "音乐", "素描"]}}, 
	true,
	false
)

6. $addToSet : 向数组里面增加新的内容，只有当这个内容不存在的时候才会增加
	|- 语法 {"$addToSet" : {"成员" : "内容"}}
范例：向王五的课程信息中添加一个美术课，美术课此时已经存在
db.student.update(
	{"name" : "王五"},
	{"$addToSet" : {"course" : "美术"}}, # 向该数组中添加一个已经存在的字段，没有变化
	true,
	false
)
范例：向王五的课程信息中添加一个不存在的课程字段
db.student.update(
	{"name" : "王五"},
	{"$addToSet" : {"course" : "街舞"}}, # 再次查找的时候多了一个街舞课程
	true,
	false
)
# 通过观察上面的两种情况可以发现：此时会判断要增加的内容在数组里面是否已经存在了，如果不存在在向数组中追加内容
# 如果存在了，则不做任何的修改操作

7. $pop : 删除数组内的数据
	|- 语法 {"$pop" : {"成员" : 内容}} # 内容如果设置为-1，删除第一个；设置为1的话，删除最后一个
范例：删除王五的第一个课程
db.student.update(
	{"name" : "王五"},
	{"$pop" : {"course" : -1}},
	true,
	false
)

8. $pull : 从数组内删除指定内容的数据
	|- 语法 {"$pull" : {"成语" : "数据"}} # 数据是用来进行数据比对的，如果是此数据，则删除；如果不是，不进行任何操作
范例：删除王五的音乐课程(此时王五并没有选择音乐这门课)，执行完以后可以发现并没有进行修改
db.student.update(
	{"name" : "王五"},
	{"$pull" : {"course" : "音乐"}},
	true,
	false
)
# 删除王五的街舞课程(观察结果可以发现成功删除)
db.student.update(
	{"name" : "王五"},
	{"$pull" : {"course" : "街舞"}},
	true,
	false
)

9. $pullAll : 一次性删除多个内容 
	|- 语法 {"成员" : ["数据1", "数据2", ...]}
范例：删除 王大拿 - A 中的三门课程
db.student.update(
	{"name" : "王大拿 - A"},
	{"$pullAll" : {"course" : ["语文", "政治", "历史"]}},
	true,
	false
)

10. $rename : 为成员名称重命名
	|- 语法 {"$rename" : {"旧的成员名称" : "新的成员名称"}}
范例：将张三的 "name" 修改为 "姓名"
db.student.update(
	{"name" : "张三"},
	{"$rename" : {"name" : "姓名"}},
	true,
	false
)

# 总结：在MongoDB数据库中，提供的修改器的支持很到位。



# 删除数据
# db.集合.remove()
# 带有两个可选项
	|- "删除条件" ： 满足条件的被删除
	|- "是否只删除一个数据" ： 如果设置为true，则只删除一个
# 删除姓名为李四的数据
db.student.remove({"name" : /李/})
# 删除姓名为王..的数据，只删除一个
db.student.remove({"name" : /王/}, true)
# 通过观察上面的两种情况可以发现：删除操作里面仍然需要使用限定查询的相关操作



# 游标
# 所谓的游标就是指数据可以一行行的进行操作
# 在MongoDB数据库中对游标的控制非常简单，只需要使用find()函数就可以返回游标了。
# 对于返回的游标如果要想进行操作，使用两个函数
	|- 判断是否有下一行数据，hasNext()
	|- 取出当前的数据
var cursor = db.student.find()
cursor.hasNext() # 判断是否有下一个数据
cursor.next() # 获取当前数据
# 以上是游标的操作形式，但是实际上不可能这么去用，因为必须利用循环才可以大量输出内容

# 范例：具体的操作代码
var cursor = db.student.find();
while (cursor.hasNext()){
	var doc = cursor.next();
	# print (doc.name);
	# print (doc) # 输出为[object BSON]
	printjson (doc);
}
# 相当于每一个数据都单独拿出来进行逐行的控制
# 当游标数据取出来之后，实际上每行数据返回的都是一个[object BSON]型的内容
# 如果要是数据按照json的形式出现，则可以使用printjson()函数完成

# 综上所述：MongoDB数据库的游标操作起来相当简单直接

# 范例：使用游标来修改年龄
# 通过游标来实现对年龄的修改
var cursor = db.student.find();
while (cursor.hasNext()){
	var doc = cursor.next();
	db.student.update({"name" : doc.name}, {"$inc" : {"age" : +100}})
	printjson (doc);
}