mongodb學習記錄

在啓動mongod的時候會出錯，有個地方是由於/data/db的權限是錯的，由於要建立該目錄須要root權限，建立完了以後須要chown xxx /data把該目錄修改爲當前用戶，不然啓動會報錯，或者用sudo啓動也能夠，可是不推薦。

在啓動Mongo的時候會出錯，connection refused有多是由於你把mongod關掉了，須要開啓mongod服務才能進入shell。

鏈接數據庫

./mongod --dbpath=xxx

數據庫操做

use database_name

若是數據庫存在則切換倒該數據庫，不存在則建立並切換倒該數據庫

show dbs

查看全部數據庫

db.dropDatabase()

刪除當前數據庫

db.site.drop()

刪除當前數據庫中site集合

新建集合(表)

增刪改查

插入數據

db.col.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一個 Nosql 數據庫',
    by: '菜鳥教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})
往col集合中插入數據

插入文檔你也可使用 db.col.save(document) 命令。若是不指定 _id 字段 save() 方法相似於 insert() 方法。若是指定 _id 字段，則會更新該 _id 的數據。

修改數據

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)

db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})

參數說明：

• query : update的查詢條件，相似sql update查詢內where後面的。
• update : update的對象和一些更新的操做符（如$,$inc...）等，也能夠理解爲sql update查詢內set後面的
• upsert : 可選，這個參數的意思是，若是不存在update的記錄，是否插入objNew,true爲插入，默認是false，不插入。
• multi : 可選，mongodb 默認是false,只更新找到的第一條記錄，若是這個參數爲true,就把按條件查出來多條記錄所有更新。
• writeConcern :可選，拋出異常的級別。

db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)

參數說明：

• document : 文檔數據。
• writeConcern :可選，拋出異常的級別。

刪除數據

db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

參數說明：

• query :（可選）刪除的文檔的條件。
• justOne : （可選）若是設爲 true 或 1，則只刪除一個文檔。
• writeConcern :（可選）拋出異常的級別。

查看數據

db.collection.find(query, projection)

• query ：可選，使用查詢操做符指定查詢條件
• projection ：可選，使用投影操做符指定返回的鍵。查詢時返回文檔中全部鍵值， 只需省略該參數便可（默認省略）。

or條件

db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

 如下摘自腳本之家http://www.jb51.net/article/51514.htm

三、經常使用命令

 
選擇數據庫

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)

 

4、索引 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});

 

5、增刪改查等

//定義文檔 
>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 ]  }