MongoDB 高手课

tar -xvf dump.tar.gz
mongorestore --uri="mongodb://root:root@10.130.0.12/?&authMechanism=SCRAM-SHA-1"

// 插入
db.fruit.insertOne({ name: "apple" })
db.fruit.insertMany([{ name: "apple" }, { name: "pear" }, { name: "orange" }])

// 查询
db.customers.find({ username: "fmiller", name: "Elizabeth Ray" })
db.customers.find({ username: /^f/ })
db.customers.find({ $or: [{ username: /^f/ }, { name: /^E/ }] })

// 投影（projection）
db.customers.find({ username: /^f/ }, { name: 0, email: 0 })   // 排除
db.customers.find({ username: /^f/ }, { _id: 1, name: 1 })     // 仅返回

// 删除
db.customers.remove({ username: "abrown" })

// 更新
db.customers.updateOne({ username: "fmiller" }, { $set: { from: "China" } })
db.customers.updateMany({ username: "fmiller" }, { $set: { from: "China" } })

// 表 / 库管理
db.fruit.drop()
show collections
db.dropDatabase()
show dbs

pipeline = [stage1, stage2, ...]
db.<collection>.aggregate(pipeline, { option })

// 全集合总计
db.orders.aggregate([
    { $group: { _id: null, total: { $sum: "$total" } } }
])
// { _id: null, total: NumberDecimal("44019609") }

// 2019 Q1 已完成订单总金额（订单金额 + 运费）和订单数
db.orders.aggregate([
    {
        $match: {
            status: "completed",
            orderDate: { $gte: ISODate("2019-01-01"), $lt: ISODate("2019-04-01") }
        }
    },
    {
        $group: {
            _id: null,
            total: { $sum: "$total" },
            shippingFee: { $sum: "$shippingFee" },
            count: { $sum: 1 }
        }
    },
    {
        $project: {
            grandTotal: { $add: ["$total", "$shippingFee"] },
            count: 1,
            _id: 0
        }
    }
])
// { count: 5875, grandTotal: NumberDecimal("2636376") }

mkdir -p runtime/data_db{1,2,3} \
      && mkdir -p runtime/data_configdb{1,2,3}

hostname -f

rs.status()

db.contacts.aggregate([
  { $lookup: {
      from: "groups",
      localField: "groups_ids",
      foreignField: "groups_id",
      as: "groups"
  }}
])

{ w: <value>, j: <boolean>, wtimeout: <number> }

db.test.insert({ count: 2 }, { writeConcern: { w: "majority" } })
db.test.insert({ count: 2 }, { writeConcern: { w: 3 } })
db.test.insert({ count: 2 }, { writeConcern: { w: 4 } })
// [Error] 100 - Not enough data-bearing nodes

// 配置延迟节点（5s 延迟、不参选）
conf = rs.conf()
conf.members[2].slaveDelay = 5
conf.members[2].priority = 0
rs.reconfig(conf)

db.test.insert({ count: 2 }, { writeConcern: { w: 3 } })
// → 等待 5s 才返回

db.test.insert({ count: 5 }, { writeConcern: { w: 3, wtimeout: 3000 } })
// → writeConcernError: waiting for replication timed out

// 主节点
db.test.insert({ count: 2 }, { writeConcern: { w: 3 } })  // 三副本确认
db.test.find({}).readPref("secondary")                    // 1 line

// 从节点 1、2
db.fsyncLock()                                             // 锁住写入

// 主节点
db.test.insert({ count: 3 })                              // 只写主
db.test.find({})                                          // 2 lines
db.test.find().readPref("secondary")                      // 1 line ← 从未同步

// 从节点 1、2
db.fsyncUnlock()
// 主节点
db.test.find().readPref("secondary")                      // 2 lines ← 已同步

// 从节点 1、2 锁定写入，模拟主从不一致
db.fsyncLock()
// 主节点
db.test.insert({ count: 3 })

db.test.find().readConcern("local")     // 可能脏读（若该写操作后被回滚）
db.test.find().readConcern("majority")  // 避免脏读

db.tx.drop();
db.tx.insertMany([{ x: 1 }, { x: 2 }]);

var session = db.getMongo().startSession();
session.startTransaction();
var coll = session.getDatabase('test').getCollection('tx');
coll.updateOne({ x: 2 }, { $set: { y: 1 } });

coll.find();    // 事务内：{x:1}, {x:2, y:1}
db.tx.find();   // 事务外：{x:1}, {x:2}             ← 隔离

session.commitTransaction();
db.tx.find();   // {x:1}, {x:2, y:1}

db.tx.drop();
db.tx.insertMany([{ x: 1 }, { x: 2 }]);

var session = db.getMongo().startSession();
session.startTransaction({
  readConcern: { level: "snapshot" },
  writeConcern: { w: "majority" }
});
var coll = session.getDatabase('test').getCollection('tx');
coll.findOne({ x: 1 });                  // 首次读

// 事务外的更新
db.tx.updateOne({ x: 1 }, { $set: { y: 1 } });

coll.findOne({ x: 1 });                  // 仍是首次的快照
session.abortTransaction();

// shell 1、2 同时开事务
session.startTransaction({
  readConcern: { level: "snapshot" },
  writeConcern: { w: "majority" }
});

// shell 1
coll.updateOne({ x: 1 }, { $set: { y: 1 } });   // ok

// shell 2
coll.updateOne({ x: 1 }, { $set: { y: 1 } });
// MongoServerError: WriteConflict — 须 retry 或 abort

# 1 配置域名解析
# 2 准备分片目录

# 3 创建第 1 个分片复制集 member1:27010 member3:27010 member5:27010
mongod --bind_ip_all --replSet shard1 --shardsvr --wiredTigerCacheSizeGB 1
# --shardsvr               标注为分片节点
# --wiredTigerCacheSizeGB  缓存大小

# 4 初始化分片复制集

# 5 创建 config server 复制集 member1:27019 member3:27019 member5:27019
mongod --bind_ip_all --replSet config --configsvr --wiredTigerCacheSizeGB 1
# --configsvr              标注为配置节点

# 6 初始化 config server 复制集

# 7 搭建 mongos
mongos --bind_ip_all --configdb config/member1:27019,member3:27019,member5:27019

# 连接 mongos 添加分片
sh.addShard("shard1/member1:27010,member3:27010,member5:27010")

# 8 创建分片表
sh.enableSharding("foo");
sh.shardCollection("foo.bar", {_id: "hashed"});
sh.status();

# 插入测试数据
use foo
for (var i = 0; i < 10000; i++) {
  db.bar.insert({ i: i })
}

# 9~11 创建并加入第 2 个分片复制集
sh.addShard("shard2/member2:27011,member4:27011,member6:27011")

db.serverStatus()              // 从上次启动到现在
db.serverStatus().opcounters
db.isMaster()
mongostat                      // CLI 工具

db.createRole({
   role: "readWriteRole",
   privileges: [{
      resource: { db: "myDatabase", collection: "sample" },
      actions: [ "find", "insert", "update", "remove" ]
   }],
   roles: [{ role: 'read', db: 'sampledb' }]
})

db.createUser({
  user: 'sampleUser',
  pwd: 'pwd',
  roles: [{ role: 'readWriteRole', db: 'admin' }]
})

mongod --noscripting   # 禁止脚本执行
mongod --auth          # 强制鉴权

db.member.createIndex({ city: 1 }, { background: true })