MongoDB

支持的数据类型

操作数据库

use dbName		// 切换或创建数据库
show dbs		// 查看当前数据库
db.stats()		// 查看当前数据库的信息
db.dropDatabase()		// 删除当前数据库
db.getCollectionNames()	// 查询当前数据库下所有集合名称

操作集合

// 创建集合
db.createCollection(name, options)
db.createCollection("mySet", {capped:true,size:6142800, max :10000 })
// 重命名
db.coll.renameCollection("myColl2")
// 删除
db.myColl2.drop()

创建集合的选项

操作数据

插入

// 插入，集合不存在时自动创建
insertOne()
insertMany()
db.myColl.insert(
	{"name":"value"}/[{"name1":"value1"}, {"name2":"value2"}]
	{
		writenConcern:<document>, // 自定义写出错的级别
	 	ordered:<boolean> // 为 true 有序插入，一个出错终止插入，默认
    					  // 为 false 无序插入，出错后继续
	 }
）

引用

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

更新

db.collection.update(
    <query>,			// 参数设置查询条件
    <update>,			// 更新操作符
    {
        upsert,			// 为true，在不存在update记录时插入新文档
        multi,			// 为false，只更新找到的的第一条记录，否则更新全部
        writeConcern,	// 出错级别
        collation		// 指定语言
    }
)
db.test.update(			// 更新{item: "card", qty: 36}
    {item:"card"}, 
    {$set: {qty: 35}}
)
db.test.save(obj)		// 已存在相同"_id"记录时覆盖，用insert会报错

// 只更新第一条记录：
db.col.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } );
// 全部更新：
db.col.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true );
// 只添加第一条：
db.col.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false );
// 全部添加进去:
db.col.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true );
// 全部更新：
db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
// 只更新第一条记录：
db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

删除

db.collection.remove(
    <query>,				// 删除的过滤条件
    {
        justOne: <boolean>, // 默认false
    	writeConcern: <document>
    }
)
db.test.remove({"title": "MongoDB"})
db.repairDatabase() // 使用remove后用此命令才能释放磁盘
db.test.deleteOne({"tetle": "A"})
db.test.deleteMany({"title": "B"})

查询

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

// 顺序是 sort -> skip -> limit
db.test.find({tags:[‘MongoDB‘, ‘NoSQL‘, ‘database‘]}).limit(3) // 限制
db.test.find({tags: {$size: 3}}).skip(1)	// 略过第一个
db.test.find({name: "value3"}).sort({"price": 1}) // 1是升序 -1降序
db.test.find({tags: {$regex: "MongoDB"}})		// 正则
db.test.find({"title" : {$type : ‘string‘}}) // 获取 title 为 String 的数据

查询条件

游标

1. 调用find后不立即查询，获取结果时才查询
2. 游标的多数方法都返回游标本身，可链式调用
3. 使用游标输出时，若不将find()函数返回的游标赋给局部变量，默认游标会迭代20次。若赋值，则可以使用游标的函数手动迭代
4. 使用清空后的游标，迭代输出时，显示的内容为空

>var cursor = db.test.find()
>while (cursor.hasNext()){
    var doc = cursor.next();
    print(doc.name);  //把每一条数据都单独拿出来进行逐行的控制
    print(doc);  //将游标数据取出来后，其实每行数据返回的都是一个［object BSON］型的内容
    printjson(doc);  //将游标获取的集合以JSON的形式显示
}

索引

db.col.createlndex ( { key: 1 } )  //1 为升序，-1 为降序
db.col.find({score:1034}).explain()		// 可查看查询过程
db.col.createIndex ({ <key1> : <type>, <key2> : <type2>, ...}) // 复合索引
db.col.getIndexes()		// 查看索引
db.col.totalIndexSize()
db.col.dropIndex({"score"： 1})	// 删除score的升序索引
db.col.dropIndexes() // 删除索引

聚合查询

聚合管道查询

select cust_id as _id, sum(amount) as total 
from orders 
where status like "%A%" 
group by cust_id;
//类似
db.collection.aggregate([
	{$match : {< query >},}
	{$group: {< fieldl >: < field2 >}}
])

select by_user as _id, count(*) as num_tutorial
from mycol 
group by by_user;
//类似
db.mycol.aggregate([
	{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}
])

map-reduce 方法

db.collection.mapReduce(
    function() { emit(key,value); },
    function(key, values) { return reduceFunction }
    { query: document, out: collection }
)

备份与恢复

mongodump -h dbhost -d dbname -o dbdirectory
mongorestore -h <hostname><:port> -d dbname <path>

监控

mongostat
mongotop

集群

1. 主从复制 Master-Slaver 不再推荐，而是后两则结合使用
2. 副本集 ReplicaSet 复制多份保存
3. 分片模式 Sharding 将数据分开存储

主从复制

建立一个主节点和一个或多个从节点，一个主节点提供所有的增、删、改、查，从节点不提供服务，可通过设置使从节点提供查询服务。

另外，每个从节点要知道主节点的地址，主节点记录在其上的所有操作，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。

在主从复制的集群中，当主节点出现故障时，只能人工介入，指定新的主节点，从节点不会自动升级为主节点。同时，在这段时间内，该集群架构只能处于只读状态。

副本集

可以说，MongoDB 的副本集是自带故障转移功能的主从复制。区别在于：主节点发生故障时，副本集可以自动投票，并引导其余从节点连接新节点，过程相对透明。

另外，从节点会定时轮询读取 oplog 日志，根据日志内容同步更新自身的数据，保持与主节点一致

副本集中的各节点会通过心跳信息来检测各自的健康状况，当主节点出现故障时，多个从节点会触发一次新的选举操作，并选举其中一个作为新的主节点。为了保证选举票数不同，副本集的节点数保持为奇数。

# 主机上运行
mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
rs.add(HOST_NAME:PORT)
db.isMaster()	# 判断是否为主节点

分片

副本集可以解决主节点发生故障导致数据丢失或不可用的问题，但遇到需要存储海量数据的情况时，副本集机制就束手无策了。副本集中的一台机器可能不足以存储数据，或者说集群不足以提供可接受的读写吞吐量。这就需要用到 MongoDB 的分片（Sharding）技术，这也是 MongoDB 的另外一种集群部署模式。

分片是指将数据拆分并分散存放在不同机器上的过程。有时也用分区来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以存储更多的数据，处理更大的负载。

MongoDB 支持自动分片，可以使数据库架构对应用程序不可见，简化系统管理。对应用程序而言，就如同始终在使用一个单机的 MongoDB 服务器一样。

MongoDB 的分片机制允许创建一个包含许多台机器的集群，将数据子集分散在集群中，每个分片维护着一个数据集合的子集。与副本集相比，使用集群架构可以使应用程序具有更强大的数据处理能力。

构建一个 MongoDB 的分片集群，需要三个重要的组件，分别是分片服务器（Shard Server）、配置服务器（Config Server）和路由服务器（Route Server）。

Shard Server

每个 Shard Server 都是一个 mongod 数据库实例，用于存储实际的数据块。整个数据库集合分成多个块存储在不同的 Shard Server 中。

在实际生产中，一个 Shard Server 可由几台机器组成一个副本集来承担，防止因主节点单点故障导致整个系统崩溃。

Config Server

这是独立的一个 mongod 进程，保存集群和分片的元数据，在集群启动最开始时建立，保存各个分片包含数据的信息。

Route Server

这是独立的一个 mongos 进程，Route Server 在集群中可作为路由使用，客户端由此接入，让整个集群看起来像是一个单一的数据库，提供客户端应用程序和分片集群之间的接口。

Route Server 本身不保存数据，启动时从 Config Server 加载集群信息到缓存中，并将客户端的请求路由给每个 Shard Server，在各 Shard Server 返回结果后进行聚合并返回客户端。

集群部署

java 操作

import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.dient.MongoCollection;

    public class App {
        public static void main(String[] args) {
            try {
                //连接MongoDB服务器，端口号为27017
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                //连接数据库
                MongoDatabase mDatabase = mongoClient.getDatabase("test");  //test可选
                System.out.printin("Connect to database successfully!");
                System.out.printIn("MongoDatabase inof is : "+mDatabase.getName());
            } catch (Exception e) {
                System.err.printIn(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    }
// 切换集合
MongoCollection collection = database.getCollection("myTestCollection");
// 定义文档
Document document = new Document("name", "value")
                        .append("name1", "value1")
                        .append("number", 30);
// 插入文档
collection.insertOne(document);
List<Document> documents = new ArrayList<Document>();
documents.add(document1);
collection.insertMany(documents);

// 删除文档
collection.deleteOne(document);
collection.deleteMany(new Document ("likes", 30));

// 更新数据
collection.updataOne (eq ("likes", 30), new Document ("$set", new Document ("likes", 50)));

// 查询数据
import com.mongodb.client.MongoCursor;
document Doc = (Document)collection.find(eq("likes", 30)).iterator();
MongoCursor<Document> cursor =collection.find().iterator();
try{
    while (cursor.hasNext()){
        System.out.printin(cursor.next().toJson());
    }
} finally{
    Cursor.close();
}

// 删除数据库或集合
mDatabase.drop();
collection.drop();

// 关闭连接
mongoClient.close();

python操作

pymongo

import pymongo

Client = MongoClient(host= ‘127.0.0.1‘, port=27017)
Client=MongoClient(host=‘10.90.9.101: 27018, 10.90.9.102: 27018,10.90.9.103: 27018‘) # 连接集群

# 获取所有集合
db.list_collection_names()

db = client.myDB  # 或 client["myDB"]
coll = db.test_collection # db["test-collection"]

# 插入文档
coll = db.get_collection("myCollection")
post_data = {
    ‘item‘ : ‘book1‘,
    ‘qty‘ : 18 }
result = coll.insert_one(post_data)

# 插入多个文档
result = coll.insert_many([post_1, post_2, post_3])

# 查询
find_post = coll.find_one({‘item‘ : ‘book‘})
find_posts = coll.find({‘item‘ : ‘book1‘})
doc = client.db.collection.find_one({‘_id‘:‘‘})

# counting
c = colls.count_documents({})

# 索引
result = db.profiles.create_index([(‘user_id‘, pymongo.ASCENDING)], unique=True)

# 更新
condition = {‘item‘ : ‘book‘}
pty{‘$set‘ : {‘pty‘ : 22}}
result = col.update(condition, pty)

# 删除
result = coll.remove({‘item‘ : ‘book‘})
result = coll.delete_one({‘item‘ : ‘book‘})
resuIt = collection.delete_many({‘item‘ : book1})

mongodb