MongoDB入門教程（包含安裝、常用命令、相關概念、使用技巧、常見操作等）

2020-03-14 13:26:30

字體：大中小

來源：轉載

供稿：網友

這篇文章主要介紹了MongoDB入門教程,包含安裝、常用命令、相關概念、使用技巧、常見操作等,是一篇比較好的入門文章,需要的朋友可以參考下

一、安裝和配置

MongoDB 的官方下載站是 http://www.mongodb.org/downloads，可以去上面下載最新的安裝程序

Windows 平臺的安裝

● 步驟一: 下載 MongoDB
點擊上方官方下載地址，并下載 Windows 版本

● 步驟二: 設置 MongoDB 程序存放目錄
下載完成后，解壓到自定義文件夾，例: D:/mongodb/

● 步驟三: 設置數據文件存放目錄
在 D:/mongodb/ 目錄下創建 db 和 logs 文件夾 (和 bin 目錄同級)，
隨后在 logs 文件夾內創建 mongodb.log 日志文件

● 步驟四: 啟動 MongoDB 服務, 作為 Windows 服務

復制代碼代碼如下:

		
		//進入 cmd 控制臺
		D:/mongodb/bin>mongod.exe --logpath D:/mongodb/logs/mongodb.log --logappend
		                          --dbpath D:/mongodb/db 
		                          --directoryperdb 
		                          --serviceName MongoDB 
		                          --install
		--directoryperdb 指定每個DB都會新建一個目錄

安裝完成后，就可以在 cmd 下用命令 net start MongoDB 和 net stop MongoDB 來啟動和停止 MongoDB 了

● 步驟五: 客戶端連接驗證
打開 cmd 輸入: D:/mongodb/bin>mongo.exe

復制代碼代碼如下:

		
		D:/mongodb/bin>mongo.exe
		MongoDB shell version: 2.4.8
		connecting to: test
		>

Linux 平臺的安裝

● 步驟一: 下載 MongoDB
點擊上方官方下載地址，并下載 Linux 版本

● 步驟二: 設置 MongoDB 程序存放目錄
下載完成后，解壓到自定義文件夾，例: /usr/local/mongo

● 步驟三: 設置數據文件存放目錄
創建 /data/db 和 /data/logs 文件夾，隨后在 logs 文件夾內創建 mongodb.log 日志文件

● 步驟四: 啟動 MongoDB 服務, 作為 Linux 服務隨機啟動

復制代碼代碼如下:

		
		vi /etc/rc.local //使用vi 編輯器打開配置文件，并在其中加入下面一行代碼
		 
		/usr/local/mongo/bin/mongod --dbpath=/data/db/ --logpath=/data/logs/mongodb.log --logappend&

安裝完成后，可以使用 pkill mongod 來結束

二、數據邏輯結構

● MongoDB 的文檔（document），相當于關系數據庫中的一行記錄。
● 多個文檔組成一個集合（collection），相當于關系數據庫的表。
● 多個集合（collection），邏輯上組織在一起，就是數據庫（database）。
● 一個 MongoDB 實例支持多個數據庫（database）。
● 默認端口: 27017

三、常用命令

選擇數據庫

復制代碼代碼如下:

use persons

顯示當前數據庫

復制代碼代碼如下:

db || db.getName()

刪除當前數據庫

復制代碼代碼如下:

db.dropDatabase()

顯示當前數據庫下的集合 Collections

復制代碼代碼如下:

show tables || show collections

顯示當前 system.profile

復制代碼代碼如下:

show profile

顯示當前數據庫下的用戶 Users

復制代碼代碼如下:

show users

添加用戶

復制代碼代碼如下:

db.addUser(username, password)

刪除用戶

復制代碼代碼如下:

db.removeUser(username)

四、索引 ensureIndex()

復制代碼代碼如下:

		
		//普通索引
		db.persons.ensureIndex({name:1});
		 
		db.factories.insert({name: "xyz", metro: {city: "New York", state: "NY"}});
		//文檔式索引
		db.factories.ensureIndex({metro : 1});
		 
		//嵌入式索引
		db.factories.ensureIndex({"metro.city": 1});
		 
		//組合索引
		db.things.ensureIndex({name: -1, qty: 1});
		 
		//唯一索引
		db.user.ensureIndex({firstname: 1, lastname: 1}, {unique: true});
		 
		/* 當一個記錄被插入到唯一性索引文檔時，缺失的字段會以null為默認值被插入文檔 */
		db.things.save({lastname: "Smith"}); 
		//下面這個操作將會失敗，因為 firstname 上有唯一性索引，值為 null
		db.things.save({lastname: "Jones"});
		 
		//查看索引
		db.persons.getIndexes();
		 
		//刪除所有索引
		db.collection.dropIndexes();
		 
		//刪除單個索引
		db.collection.dropIndex({x: 1, y: -1});

五、增刪改查等

復制代碼代碼如下:

		
		//定義文檔 
		>doc = { 
		    "_id"      : 1, 
		    "author"   : "sam", 
		    "title"    : "i love you", 
		    "text"     : "this is a test", 
		    "tags"     : [ "love", "test" ], 
		    "comments" : [ 
		                   { "author" : "jim", "comment" : "yes" }, 
		                   { "author" : "tom", "comment" : "no" } 
		                 ] 
		} 
		 
		//插入文檔 
		> db.posts.insert(doc);
		 
		//查找文檔 
		> db.posts.find({'comments.author':'jim'});

查詢 Query

復制代碼代碼如下:

		//查詢集合中的所有記錄：
		db.users.find({})
		 
		//查詢出所有 “last_name” 屬性值為 “Smith” 的文檔記錄
		db.users.find({'last_name': 'Smith'})

查詢選項

復制代碼代碼如下:

		//返回除了 age 字段外的所有字段
		> db.user.find( {},{ age : 0 } ); 
		 
		//返回 tags=tennis 除了 comments 的所有列 
		> db.posts.find( { tags : 'tennis' }, { comments : 0 } ); 
		 
		//返回 userid=16 的 name 字段 
		> db.user.find( { userid : 16 },{ name : 1 } ); 
		//返回結果: 
		{ "_id" : 16, "name" : "user16" } 
		 
		//返回 x=john 的所有 z 字段 
		> db.things.find( { x : "john" }, { z : 1 } );
		 
		//注： _id字段始終都會被返回，哪怕沒有明確指定

條件表達式

1) <, <=, >, >=

復制代碼代碼如下:

		
		// 大于: field > value 
		> db.collection.find( { "field" : { $gt : value } } );
		 
		//小于：field < value 
		> db.collection.find( { "field" : { $lt : value } } ); 
		 
		//大于等于: field >= value 
		> db.collection.find( { "field" : { $gte : value } } ); 
		 
		//小于等于：field <= value 
		> db.collection.find( { "field" : { $lte : value } } );
		 
		//區間查詢  5 < field <= 10
		> db.collection.find( { "field" : { $gt : 5, $lte : 10 } } );

$all 操作類似 $in 操作，但是不同的是，$all操作要求數組里面的值全部被包含在返回的記錄里面

復制代碼代碼如下:

		> use test; 
		switched to db test 
		> db.things.insert( { a : [ 1, 2, 3 ] } ); 
		 
		> db.things.find(); 
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $all : [ 2, 3 ] } } );
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $all : [ 1, 2, 3 ] } } ); 
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $all : [ 1 ] } } ); 
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $all : [ 1, 2, 3, 4 ] } } ); 
		>
		>

$exists 操作檢查一個字段是否存在

復制代碼代碼如下:

		
		//userid 字段存在
		> db.user.find( { userid : { $exists : true } } ).limit(1);
		{ "_id" : 1, "name" : "user1", "userid" : 1, "age" : 20 }
		//sex 字段不存在 
		> db.user.find( { sex : { $exists : true } } ).limit(1); 
		>
		>

$mod 操作可以讓我們簡單的進行取模操作

復制代碼代碼如下:

		//where子句
		> db.user.find( "this._id%10==1" ).limit(5);
		 
		//$mod操作 
		> db.user.find( { _id : { $mod : [ 10, 1 ] } } ).limit(5);

$ne 意思是不等于（not equal）

復制代碼代碼如下:

		> db.user.find().limit(2); 
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 20 } 
		{ "_id" : 1, "name" : "user1", "userid" : 1, "age" : 20 }
		 
		> db.user.find( { _id : { $ne : 0 } } ).limit(2); 
		{ "_id" : 1, "name" : "user1", "userid" : 1, "age" : 20 }

$in 操作類似于傳統關系數據庫中的IN

復制代碼代碼如下:

		//數據庫中有所有數組對應的記錄 
		> db.user.find( { _id : { $in : [ 2, 3 ] } } ).limit(5); 
		{ "_id" : 2, "name" : "user2", "userid" : 2, "age" : 20 } 
		{ "_id" : 3, "name" : "user3", "userid" : 3, "age" : 20 }

$nin 跟 $in 操作相反

復制代碼代碼如下:

		
		//扣掉 _id = 1/2/3/4 的記錄 
		> db.user.find( { _id : { $nin : [ 1, 2, 3, 4 ] } } ).limit(5); 
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 20 } 
		{ "_id" : 5, "name" : "user5", "userid" : 5, "age" : 20 } 
		{ "_id" : 6, "name" : "user6", "userid" : 6, "age" : 20 }

$or

復制代碼代碼如下:

		> db.user.find( { $or : [ { _id : 2 }, { name : 'user3' }, { userid : 4 } ] } ).limit(5); 
		{ "_id" : 2, "name" : "user2", "userid" : 2, "age" : 20 } 
		{ "_id" : 3, "name" : "user3", "userid" : 3, "age" : 20 } 
		{ "_id" : 4, "name" : "user4", "userid" : 4, "age" : 20 } 
		>

$nor 跟 $or 相反

復制代碼代碼如下:

		> db.user.find( { $nor : [ { _id : 2 }, { name : 'user3' }, { userid : 4 } ] } ).limit(4); 
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 20 } 
		{ "_id" : 1, "name" : "user1", "userid" : 1, "age" : 20 }
		{ "_id" : 5, "name" : "user5", "userid" : 5, "age" : 20 } 
		{ "_id" : 6, "name" : "user6", "userid" : 6, "age" : 20 } 
		>

$size 操作將會查詢數組長度等于輸入參數的數組

復制代碼代碼如下:

		> db.things.find(); 
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $size : 3 } } ); 
		{ "_id" : ObjectId("4de73360059e7f4bdf907cfe"), "a" : [ 1, 2, 3 ] } 
		 
		> db.things.find( { a : { $size : 2 } } ); 
		>
		> db.things.find( { a : { $size : 1 } } );
		>

$where

復制代碼代碼如下:

		> db.mycollection.find( { $where : function() { return this.a == 3 || this.b == 4; } } ); 
		//同上效果 
		> db.mycollection.find( function() { return this.a == 3 || this.b == 4; } );

$type 將會根據字段的 BSON 類型來檢索數據

復制代碼代碼如下:

		
		//返回 a 是字符串的記錄 
		> db.things.find( { a : { $type : 2 } } );
		 
		//返回 a 是 int 類型的記錄 
		> db.things.find( { a : { $type : 16 } } );

類型名稱映射

● Double : 1
● String : 2
● Object : 3
● Array : 4
● Binary data : 5
● Object id ：7
● Boolean ：8
● Date ：9
● Null : 10
● Regular expression : 11
● JavaScript code : 13
● Symbol : 14
● JavaScript code with scope : 15
● 32-bit integer : 16
● Timestamp : 17
● 64-bit integer : 18
● Min key : 255
● Max key : 127

Mongodb同樣支持正則表達式進行檢索

復制代碼代碼如下:

		
		//檢索name屬性是以 u 開頭，4 結尾的所有用戶 
		> db.user.find( { name : /u.*4$/i } ).limit(2); 
		{ "_id" : 4, "name" : "user4", "userid" : 4, "age" : 20 } 
		{ "_id" : 14, "name" : "user14", "userid" : 14, "age" : 20 }
		 
		//同樣效果的查詢語句 
		> db.user.find( { name : { $regex : 'u.*4$', $options : 'i' } } ).limit(2); 
		{ "_id" : 4, "name" : "user4", "userid" : 4, "age" : 20 } 
		{ "_id" : 14, "name" : "user14", "userid" : 14, "age" : 20 }
		 
		//配合其他操作一起使用
		> db.user.find( { name : { $regex : 'u.*4$', $options : 'i', $nin : [ 'user4' ] } } ).limit(2); 
		{ "_id" : 14, "name" : "user14", "userid" : 14, "age" : 20 }
		 

排序

按照 last_name 屬性進行升序排序返回所有文檔

復制代碼代碼如下:

		
		//1表示升序，-1表示降序 
		db.users.find( {} ).sort( { last_name : 1 } );

Group

復制代碼代碼如下:

		//語法：
		db.coll.group( { 
		       cond     : {filed：conditions}, 
		       key      : {filed: true}, 
		       initial  : {count: 0, total_time:0}, 
		       reduce   : function(doc, out){ }, 
		       finalize : function(out){} 
		} );
		 
		參數說明： 
		   Key         ：對那個字段進行
		   Group Cond  ：查詢條件 
		   Initial     ：初始化group計數器 
		   Reduce      ：通常做統計操作 
		   Finalize    ：通常都統計結果進行進一步操作，例如求平均值 Keyf：用一個函數來返回一個替代 KEY 的值
		    
		//例子
		> db.test.group( { 
		       cond     : { "invoked_at.d" : { $gte : "2009-11", $lt : "2009-12" } },
		       key      : {http_action: true}, 
		       initial  : {count: 0, total_time:0}, 
		       reduce   : function( doc, out ){ out.count++; out.total_time += doc.response_time }, 
		       finalize : function(out){ out.avg_time = out.total_time / out.count } } );
		    
		[ 
		  { 
		    "http_action" : "GET /display/DOCS/Aggregation", 
		    "count"       : 1, 
		    "total_time"  : 0.05, 
		    "avg_time"    : 0.05 
		  } 
		]
		 

去重類似于關系數據庫中的 Distinct

復制代碼代碼如下:

		> db.addresses.insert( { "zip-code" : 10010 } ) 
		> db.addresses.insert( { "zip-code" : 10010 } ) 
		> db.addresses.insert( { "zip-code" : 99701 } ) 
		> 
		> db.addresses.distinct("zip-code"); 
		[ 10010, 99701 ] 
		>
		> //command 模式: 
		> db.runCommand( { distinct: 'addresses', key: 'zip-code' } ) 
		{ "values" : [ 10010, 99701 ] }
		> 
		> db.comments.save( { "user" : { "points" : 25 } } ) 
		> db.comments.save( { "user" : { "points" : 31 } } ) 
		> db.comments.save( { "user" : { "points" : 25 } } ) 
		> db.comments.distinct("user.points"); 
		[ 25, 31 ]

Mongodb 支持 skip 和 limit 命令來進行分頁查詢

復制代碼代碼如下:

		//跳過前10條記錄 
		> db.user.find().skip(10); 
		//每頁返回8條記錄 
		> db.user.find().limit(8); 
		//跳過前20條記錄，并且每頁返回10條記錄 
		> db.user.find().skip(20).limit(8); 
		//下面這個語句跟上一條一樣，只是表達不夠清晰 
		> db.user.find({}, {}, 8, 20);

$elemMatch

復制代碼代碼如下:

		> t.find( { x : { $elemMatch : { a : 1, b : { $gt : 1 } } } } ) 
		{ "_id" : ObjectId("4b5783300334000000000aa9"), "x" : [ { "a" : 1, "b" : 3 }, 7, { "b" : 99 }, { "a" : 11 } ] } 
		 
		//同樣效果 
		> t.find( { "x.a" : 1, "x.b" : { $gt : 1 } } )

count()方法返回查詢記錄的總數

復制代碼代碼如下:

		
		db.orders.count( { ord_dt : { $gt : new Date('01/01/2012') } } )
		//同樣效果
		db.orders.find( { ord_dt : { $gt : new Date('01/01/2012') } } ).count()
		 
		//當查詢語句用到了 skip() 和 limit() 方法的時候，
		//默認情況下 count() 會忽略這些方法，如果想要計算這些方法，
		//需要給 count() 方法傳一個 true 作為參數
		> db.user.find( { _id : { $lt : 20 } } ).skip(3).limit(9).count(); 
		20 
		> db.user.find( { _id : { $lt : 20 } } ).skip(3).limit(9).count(true); 
		9
		>

$slice

復制代碼代碼如下:

		
		db.posts.find({}, {comments:{$slice: 5}}) // 前5條評論 
		db.posts.find({}, {comments:{$slice: -5}}) //后5條評論 
		db.posts.find({}, {comments:{$slice: [20, 10]}}) // 跳過20條, limit 10 
		db.posts.find({}, {comments:{$slice: [-20, 10]}}) // 后20條, limit 10
		 

刪除 Delete

Remove 操作用于從集合中刪除記錄

復制代碼代碼如下:

		
		//刪除一條記錄 
		> db.stu.remove( { _id : 17 } );
		 
		//刪除所有記錄
		> db.stu.remove( {} );
		 
		//某些情況下，當你在對一個記錄執行 remove 操作的時候，
		//可能會有 update 操作在這個記錄上，這樣就可能刪除不掉這個記錄，
		//如果你覺得這不盡人意，那么你可以在 remove 操作的時候加上 $atomic：
		db.stu.remove( { rating : { $lt : 3.0 }, $atomic : true } );

更新 Update

復制代碼代碼如下:

db.collection.update( criteria, objNew, upsert, multi )

參數說明：
    Criteria ：用于設置查詢條件的對象
    Objnew   ：用于設置更新內容的對象
    Upsert   ：如果記錄已經存在，更新它，否則新增一個記錄
    Multi    ：如果有多個符合條件的記錄，全部更新注意：默認情況下，只會更新第一個符合條件的記錄

save()

復制代碼代碼如下:

		
		//如果存在更新它，如果不存在，新增記錄 
		db.mycollection.save( { name : 'shawn' } );

$inc

復制代碼代碼如下:

		
		{ $inc : { field : value } } //把field的值加一個value
		 
		> db.user.findOne( { _id : 0 } );
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 22 }
		> db.user.update( { _id : 0 }, { $inc : { age : 1 } } );
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 23 }

$set

復制代碼代碼如下:

		
		{ $set : { field : value } }  
		// 把field的值設置成value，當field不存在時，增加一個字段，
		// 類似SQL的set操作，value支持所有類型
		 
		// 把上面的 age 改回到 20
		> db.user.update( { _id : 0 }, { $set : { age : 20 } } );
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 20 }
		 
		// 當 field 不存在時，增加一個字段
		> db.user.update( { _id : 0 }, { $set : { sex : 'boy' } } );
		{ "_id" : 0, "sex" : "boy", "name" : "user0", "userid" : 0, "age" : 20 }

$unset

復制代碼代碼如下:

		
		{ $unset : { field : 1} } // 刪除給定的字段field
		 
		//刪除上一步增加的sex字段
		> db.user.update( { _id : 0 }, { $unset : { sex : 1 } } );
		{ "_id" : 0, "name" : "user0", "userid" : 0, "age" : 20 }

$push

復制代碼代碼如下:

		
		{ $push : { field : value } }
		// 如果 filed 是一個已經存在的數組，那么把 value 追加給 field
		// 如果 field 原來不存在，那么新增 field 字段，把value的值賦給field
		// 如果 field 存在，但是不是一個數組，將會出錯
		 
		> db.sport.update( { _id : 0 }, { $push : { aihao : 'football' } } );

$pushAll

復制代碼代碼如下:

		
		{ $pushAll : { field : value_array } }
		// 功能同$push，只是這里的 value 是數組，相當于對數組里的每一個值進行 $push 操作

$addToSet

復制代碼代碼如下:

		
		{ $addToSet : { field : value } }
		// 如果 filed 是一個已經存在的數組，并且 value 不在其中，那么把 value 加入到數組
		// 如果 filed 不存在，那么把 value 當成一個數組形式賦給 field
		// 如果 field 是一個已經存在的非數組類型，那么將會報錯

$pop

復制代碼代碼如下:

		
		{ $pop : { field : 1 } }   //刪除數組中最后一個元素
		 
		{ $pop : { field : -1 } }  //刪除數組中第一個元素

$pull

復制代碼代碼如下:

		
		{ $pull : { field : _value } } 
		// 如果 field 是一個數組，那么刪除符合 _value 檢索條件的記錄
		// 如果 field 是一個已經存在的非數組，那么會報錯

$pullAll

復制代碼代碼如下:

		
		{ $pullAll : { field : value_array } } //同$push類似，只是value的數據類型是一個數組

$rename

復制代碼代碼如下:

		
		{ $rename : { old_field_name : new_field_name }  
		// 重命名指定的字段名稱，從1.7.2版本后開始支持
		 
		> db.user.update( { _id : 0 } , { $rename : { 'quantity' : 'qty'}});

特殊操作符：$

$ 操作符代表查詢記錄中第一個匹配條件的記錄項

復制代碼代碼如下:

		
		//例1
		> db.t.find()
		{ 
		  "_id"      : ObjectId("4b97e62bf1d8c7152c9ccb74"), 
		  "title"    : "ABC", 
		  "comments" : [ 
		                 { "by" : "joe", "votes" : 3 }, 
		                 { "by" : "jane", "votes" : 7 } 
		               ] 
		} 
		> db.t.update( { 'comments.by' : 'joe' }, { $inc : { 'comments.$.votes' : 1 } }, false, true )
		> db.t.find()
		{ 
		  "_id"      : ObjectId("4b97e62bf1d8c7152c9ccb74"), 
		  "title"    : "ABC", 
		  "comments" : [ 
		                 { "by" : "joe", "votes" : 4 }, 
		                 { "by" : "jane", "votes" : 7 } 
		               ] 
		} 
		 
		//例2
		> db.t.find(); 
		{ 
		  "_id" : ObjectId("4b9e4a1fc583fa1c76198319"), 
		  "x"   : [ 1, 2, 3, 2 ] 
		} 
		> db.t.update( { x : 2 }, { $inc : { "x.$": 1 } }, false, true);
		> db.t.find(); 
		{ 
		  "_id" : ObjectId("4b9e4a1fc583fa1c76198319"), 
		  "x"   : [ 1, 3, 3, 2 ] 
		}
		 
		//在數組中用 $ 配合 $unset操作 符的時候，效果不是刪除匹配的元素，而是把匹配的元素變成了null，如：
		> db.t.insert( { x: [ 1, 2, 3, 4, 3, 2, 3, 4 ] } ) 
		> db.t.find() 
		{ 
		  "_id" : ObjectId("4bde2ad3755d00000000710e"), 
		  "x"   : [ 1, 2, 3, 4, 3, 2, 3, 4 ] 
		} 
		> db.t.update( { x : 3 }, { $unset : { "x.$" : 1 } } ) 
		> t.find() 
		{ 
		  "_id" : ObjectId("4bde2ad3755d00000000710e"), 
		  "x"   : [ 1, 2, null, 4, 3, 2, 3, 4 ] 
		}