初识MongoDB

数据库分类

关系型

SQL Server MySQL Access ORACLE

数据库 –> 表 –> 记录

非关系型

MongoDb 文档型的非关系数据库

安装

官网下载合适版本
不停的下一步，下一步
增加环境变量，以便直接在 shell 中使用
数据库 –> 集合 –> 文档 database –> collection –> document

存储格式 BSON 类似于 JSON

每一个 {}称为一条文档

{ ​ “name” : “小明”, ​ “age” : 18, ​ “hobby”: [“睡觉”, “吃饭”] }

命令操作

创建数据库

mongod:
mongod --dbpath dir # 打开或新建一个数据库 # mongod --dbpath E:\mongodb\mydb
mongo:
use dbname # 新建叫做 dbname 的数据库， 同时进入 dbname
初步操作

show dbs # 查看所有的数据库
show collections # 查看当前库下所有的 集合

## 在叫做 collectionName 的集合中插入一条文档，如果集合不存在，则新建该集合
db.collectionName.insert(obj)
## 查找名为 collectionName 集合的所有文档
db.collectionName.find()

导入数据

假设 C:\user\db\test.json 是 1000 条文档

mongoimport --db test --collection user --drop --file C:\user\db\test.json

## 以上操作会把 test.json 里的文档全部导入到 数据库 test -> 集合 user 中

    --db 导入到哪个库
    --collection 导入到哪个集合
    --drop 清空集合中原有文档
    --file 要导入的文件路径

CRUD

假设集合名叫 user

## 查询所有文档
db.user.find()

# 查询 k 的值为 v 的所有文档
db.user.find({k: v})

# and 操作
# 查询 k1 的值为 v1 且 k2 的值为 v2 的所有文档
db.user.find({k1: v1, k2: v2})

# or 操作
# 查询 k1 的值为 v1 或 k2 的值为 v2 的所有文档
db.user.find({$or: [{k1: v1}, {k2: v2}]})

# 比较(大于，小于)
db.user.find({k: {$gt: v}}) # 查询 k 的值大于 v 的文档
db.user.find({k: {$lt: v}}) # 查询 k 的值小于 v 的文档
# $gt 大于
# $lt 小于

# 组合
db.user.find({k: {$gt: v1, $lt: v2}}) # 查询 k 的值大于 v1 同时小于 v2 的文档
# 更新
db.user.update(
{k: v1},  # 查询条件
{
    $set: {k: v2} # 把查到的 k 改为 v2
}
)
# 更新详细语法
db.user.update(
   <query>, # 查询条件
   <update>, # 更新方式，如 $set, $inc 等
   {
     multi: <boolean>, # (可选)默认为 false，只匹配找到的第一条， 如果为 true, 所有满足条件的都匹配
   }
)
# 删除
db.dropDatabase() # 删除当前所在数据库
db.user.drop() # 删除名为 user 的集合
db.user.remove({k: v}) # 删除匹配到的所有 k 值为 v 的文档
db.user.remove({k: v}, {justOne: true}) # 删除第一个匹配到的所有 k 值为 v 的文档
db.user.remove({}) # 清空 user 集合
排序
db.user.find({查询条件}).sort({k1: 1}, {k2: -1})

# 按照 k1 来排序， 如果 k1 的值相同，按照 k2 来排序

# 1 升序, -1 降序

node 里简单封装增删改查

// node mongodb 版本 v3.1.13 适用
const MongoClient = require('mongodb').MongoClient;
const log = console.log.bind(console);

class Dao {
  /**
   * 构造函数
   * @param {string} url
   * @param {string} dbname
   * @param {string} colname
   */
  constructor(url, dbname, colname) {
    this.url = url;
    this.dbname = dbname;
    this.colname = colname;
  }

  /**
   * 连接数据库
   */
  _connect() {
    return new Promise((resolve, reject) => {
      MongoClient.connect(this.url, { useNewUrlParser: true }, (err, client) => {
        if (err) {
          reject(err);
        } else {
          resolve(client);
        }
      });
    });
  }

  /**
   * 插入文档
   * @param {arr || object} documents
   * @param {boolean} insertMany
   * 使用 insertMany(arr), 在 arr === [] 时，会报错
   */
  insert(documents, insertMany = false) {
    return new Promise((resolve, reject) => {
      this._connect()
        .then(client => {
          let col = client.db(this.dbname).collection(this.colname);
          if (insertMany) {
            col
              .insertMany(documents)
              .then(res => {
                resolve(res);
              })
              .catch(err => {
                log(err);
              });
            client.close();
          } else {
            col
              .insertOne(documents)
              .then(res => {
                resolve(res);
              })
              .catch(err => {
                log(err);
              });
            client.close();
          }
        })
        .catch(err => {
          reject(err);
        });
    });
  }

  /**
   * 查询
   * @param {object} document
   */
  query(document, pageConfig) {
    document = document || {};
    pageConfig = pageConfig || {};
    let page = pageConfig.page;
    let amount = pageConfig.amount;
    const resData = [];

    return new Promise((resolve, reject) => {
      this._connect()
        .then(client => {
          let col = client.db(this.dbname).collection(this.colname);
          let cursor = col
            .find(document)
            .limit(amount)
            .skip((page - 1) * amount);
          cursor.each((err, data) => {
            if (err) {
              reject(err);
              client.close();
            } else if (data !== null) {
              resData.push(data);
            } else {
              resolve(resData);
              client.close();
            }
          });
        })
        .catch(err => {
          log(err);
        });
    });
  }

  /**
   * 删除集合中的数据
   * @param {object} query
   * @param {boolean} deleteMany
   */
  delete(query, deleteMany = false) {
    return new Promise((resolve, reject) => {
      this._connect()
        .then(client => {
          let col = client.db(this.dbname).collection(this.colname);
          if (deleteMany) {
            col.deleteMany(query).then(res => {
              resolve(res);
              client.close();
            });
          } else {
            col.deleteOne(query).then(res => {
              resolve(res);
              client.close();
            });
          }
        })
        .catch(err => {
          log(err);
        });
    });
  }

  /**
   * 更新
   * @param {obj} filter
   * @param {obj} updater
   */
  update(filter, updater) {
    let uptaterCpy = { $set: updater };

    return new Promise((resolve, reject) => {
      this._connect()
        .then(client => {
          let col = client.db(this.dbname).collection(this.colname);
          col.updateMany(filter, uptaterCpy).then(res => {
            resolve(res);
            client.close();
          });
        })
        .catch(err => {
          log(err);
        });
    });
  }
}

//
let url = 'mongodb://localhost:27017';
let dbname = 'test';
let colname = 'user';
let dao = new Dao(url, dbname, colname);

let arr = [];
for (let i = 0; i < 20; i++) {
  arr.push({
    userid: '234',
    age: i,
  });
}