mongodb

mongodb

安装1

• 安装依赖
  • sudo apt-get install libcurl3 openssl
• 下载安装包
  • wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu1604-4.2.8.tgz
  • tar -zxvf mongodb-linux-x86_64-ubuntu1604-4.2.8.tgz
  • mv mongodb-src-r4.2.8 /usr/local/mongodb4
• 配置环境变量
  • vim ~/.bashrc
  • export PATH=$PATH:/usr/local/mongodb4
• 创建数据库目录
  • 数据存储目录：sudo mkdir -p /var/lib/mongo
    • 权限：sudo chmod 777 /var/lib/mongo
  • 日志文件目录：sudo mkdir -p /var/log/mongodb
    • 权限：sudo chmod 777 /var/log/mongodb
• 启动
  • 启动服务：mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongodb.log --fork
  • 启动数据库：mongo
• 停止
  • mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongodb.log --shutdown

安装2

• 安装
  • sudo apt install mongodb-server
• 启动
  • 启动服务：sudo service mongodb start
  • 启动数据库：mongo
• 关闭
  • sudo service mongodb stop

创建数据库

#当数据不存在时创建，数据库存在时切换到相应的数据库
use 数据库名=>use database_lianxi

#查看所有的数据库
show dbs

#创建数据库：1.use database_lianxi,2.db.database_lianxi.insert({"name":"小明"})
#通过use创建一个数据库之后必须插入一个集合才算创建完成

删除数据库

#查看所有的数据库
show dbs

#切换到相应的数据库
use database_name

#查看当前数据库
db

#删除当前数据库
db.dropDatabase()


#删除集合
db.collection.drop()  => collection集合名

创建集合

#创建集合=>相当于数据库中的表
db.creataCollection("obj") => obj集合名

#当向集合中插入数据，而当前集合不存在时，集合会自动创建
db.obj.insert({"name":"xiaoming"})

删除集合

#删除集合
db.collection.drop()  => collection集合名

插入集合

#插入文档
db.collection.insert({name:"小明",sex:"男"})

#插入一个变量
#1.document=({name:"1",sex:10})
#2.db.collection.insert(document)

修改集合

#query查询条件;update修改内容
db.collection.update(<query>,<update>,{upsert: <boolean>,multi: <boolean>,writeConcern: <document>})
db.obj.update({"username":"xiaoming"},{$set:{"password":1,sex:"男"}})

#一次修改多条数据
db.obj.update({"username":"xiaoming"},{$set:{"password":1,sex:"男"}},{mulyi:true})

#document是一个文档，当文档的_id已经在集合中存在，就更新相应的数据，否则向集合中插入一个文档
db.obj.save(document)

删除文档

#删除匹配到的多个文档，第一个参数是查询条件
db.collection.remove({"title":"男"})

#删除匹配到的一个文档，第一个参数是查询条件
db.collection.remove({"title":"男"},1)

#删除所有的文档
db.collection.remove({})

查询文档

#query查询条件
db.collection.find(query,projection)=>db.obj.find({num:100})

#格式化输出
db.obj.find({num:100}).pretty()

#多条件查询
db.obj.find({num:100,sex:"男"}).pretty()

#or查询
db.obj.find(
	{
		$or:[
				{num:100},{"name":"小明"}
			]
	}
)

#查询提定的属性列,{name:1}:“1”代表显示name属性，“0”代表不显示name属性
db.obj.find({num:100},{name:1})

条件操作符

符号	mongodb	含义
>	$gt	大于
<	$lt	小于
>=	$gte	大于等于
<=	$lte	小于等于
	$type	根据类型查询数据

#查询num>100 and num<103的数据
db.obj.find({num:{$gt:100,$lt:103}}).pretty()

limit()方法和skip()方法实现分页查询

#返回指定条数的结果
db.obj.find().limit(2)#返回2条数据

#跳过指定的条数
db.obj.find().limit(2).skip(2)

sort({field:1或-1})方法

#对结果集进行排序,1代表升序，-1代表降序
db.obj.find().sort({num:1})

创建索引

#title和num是用于创建索引的属性列，1代表按照升序创建索引，-1代表按照降序创建索引
db.obj.createIndex({title:1,num:-1})

#删除所有的索引
db.obj.dropIndexs()

#删除特定的索引
db.obj.dropIndex("指定的索引名称")

node操作mongodb

/**
 * 获取数据库连接对象
 */
const mongoClient=require("mongodb").MongoClient

let url="mongodb://localhost"

let dbName="database"

/**
 * 连接mongodb数据库
 */
function connetMongodb(){
    return new Promise(async (resolve,reject)=>{
        try{
            let conn=await mongoClient.connect(url,{ useUnifiedTopology: true })
            const db = conn.db(dbName);
            resolve(db)
        }catch(err){   
            reject(err)
        }
        
    })
}

/**
 * 查询数据库中特定集合的数据
 * @param {查询参数} query 
 * @param {查询集合} collection_name 
 */
async function findMongodb(query,collection_name){
    try{
        let db=await connetMongodb()
        let collection=db.collection(collection_name)
        return new Promise((resolve,reject)=>{
            collection.find(query).toArray((err,result)=>{
                if(err){
                    return reject(err)
                }
                resolve(result)
            })
        })
    }catch(err){
        console.log(err)
    }
}

/**
 * 向数据库集合中插入若干条文档
 * @param {插入的数据集} documens 
 * @param {待操作的集合} collection_name 
 */
async function insertMongodb(documens,collection_name){
    try{
        let db=await connetMongodb()
        let collection=db.collection(collection_name)
        return new Promise((resolve,reject)=>{
            collection.insertMany(documens,(err,result)=>{
                if(err){
                    return reject(err)
                }
                if(result.result.ok){
                    resolve(true)
                }
            })
        })
        
    }catch(err){
        console.log(err)
    }
}

/**
 * 删除集合中的数据
 * @param {查询参数} query 
 * @param {待操作的集合} collection_name 
 */
async function removeMongodb(query,collection_name){
    try{
        let db=await connetMongodb()
        let collection=db.collection(collection_name)
        return new Promise((resolve,reject)=>{
            collection.deleteMany(query,(err,result)=>{
                if(err){
                    return reject(err)
                }
                if(result.result.ok){
                    resolve(true)
                }
            })
        })
    }catch(err){
        console.log(err)
    }
}

/**
 * 修改集合的文档
 * @param {查询参数} query 
 * @param {修改参数} set 
 * @param {待操作的集合} collection_name 
 */
async function updateMongodb(query,set,collection_name){
    try{
        let db=await connetMongodb()
        let collection=db.collection(collection_name)
        return new Promise((resolve,reject)=>{
            collection.updateMany(query,set,(err,result)=>{
                if(err){
                    return reject(err)
                }
                if(result.result.ok){
                    resolve(true)
                }
            })
        })
    }catch(err){
        console.log(err)
    }
}