一些東東: mongodb howto

前言:

前幾天看中視60分鐘談雲端談大數據

使己想找找去年作的mongodb筆記

竟没有在記憶中的目錄

一度以為是因年初換硬碟時有操作失誤而錯漏

心多跳了一下下, 覺得還是在網上放一份較保險

不過對節目裡那郭中研院的講要求資料100%正確...有點怪怪的(或許是剪輯造成的誤解),

對資料一致性的要求因雲端而從傳統ACID的強一致跳到 BASE的軟狀態與最終一致(or弱一致)

在很多情況, 依照使用情形的不同, 在當下取用狀態就是不一致 i.e.非100%正確

例如一些社交性的軟體在某些日常社交資料, 大數據統計某些偏好趨勢等

簡而言之, 資料正確百分百不算是雲端資料庫的必要條件

2016/3/9

-----------------------------------------------------------------------------------

MongoDB - 較適合對資料庫與程設已有基礎者

MongoDB 屬NoSQL(Not only SQL, 雲端常用)中的文件資料庫

MongoDB的collection 由文件(documents) 組成, collection 類似關聯式資料庫的table

雖亦有field(s), 但不為其預先定義schema

如多數文件資料庫般支援JSON格式; 亦同時支援二進位的BSON格式

安裝:

urpmi mongodb # 安裝 client

urpmi mongodb-server # 安裝 server

設定：

最原先的mongodb是將資料預設存於 /data/db/

然所用的rpm已改預設至 /var/lib/mongo/ 中 (設定檔 /etc/mongod.conf 內可改預設)

啟動server: <註一>

systemctl start mongod.service # 舊法 service mongod start 或仍可用

預設為單機，故 netstat -antup 有類似下行顯示其中：

tcp 0 0 127.0.0.1:27017 0.0.0.0:* LISTEN 29100/mongod

mongo - MongoDB Shell: mongo is an interactive JavaScript shell interface to MongoDB <ref.1>

啟動 mongo - 於同上已執行server的主機上執行 mongo 進入 MongoDB Shell 來與上面啟動之server交談:

> show dbs // 檢視現有資料庫 '>' 為 MongoDB Shell 的提示符號

> use <資料庫名> // 切換資料庫

> exit // 離開 MongoDB Shell

注意！最初啟動時有行訊息為：connecting to: test 表預設連接至資料庫名test之資料庫

但用 show dbs 時卻看不到 test資料庫的存在，這是因為mongodb的資料庫是自動(隱式)建立,

多是當第一次揷入資料物件於collection時, 自動建立資料庫與collection

最初雖然已切換至 test資料庫, 然而由於尙未執行操作，此時 test資料庫實際上並不存在，

故用 show dbs 自然看不到它; 同理以 use 來切換資料庫時亦然

而collection與index的情況與上類似 e.g.當第一次對collection操作時自動建立collection; index亦然

底下皆在 MongoDB Shell 中操作，一些例參考<ref.2>:

// 於Shell內可用諸如help/db.help()/db.mycoll.help()/db.mycoll.find().help()等等來參考說明

// 當直接輸入省略()的方法名，會出現其方法的原始程式，亦為不錯的參考資訊

> use mydb // 不用預設資料庫test, 切換至資料庫mydb

switched to db mydb

> j={name:"mongo"} // 建立一資料物件j, 其中field名為name, field值為mongo (<自>亦可視field為資料物件的屬性)

{ "name" : "mongo" }

> k=j // 由於是 JavaScript shell, 故j,t的內涵實則是指向資料物件的指標(pointer), 故 k與j指向同一個資料物件

{ "name" : "mongo" }

> k.name="hahaha" // 將 name屬性的值改成hahaha 注意：(資料)物件的屬性亦即為資料物件field

hahaha

> j // 因隱含性質是指標(pointer), 故j與k的顯示的結果相同

{ "name" : "hahaha" }

> k.name="mongo" // 改回 "mongo"

> j // 結果一様與k同

{ "name" : "mongo" }

> show dbs // 檢視現有資料庫, 因上面所建資料物件尙未儲存, 故資料庫mydb尙未建立

local 0.078GB // 注意 0.078GB 僅為參考, 會因版本等相異情況而有所不同

> db.things.save(j) // 將j的資料物件插入至collection things中

> show dbs // 由此可知，上一指令除建立collection things外，亦自動建立資料庫mydb

local 0.078GB

mydb 0.078GB

> show collections // 顯示當下用的資料庫(此處為mydb)中有那些collections

system.indexes // <--- 此collections即是系統為於此資料庫mydb 自動建立index的存放處 (index結構為B-tree)

things

> t={x:3} // 建立一資料物件t 注意！因t,j為local, 故exit後t,j定義消失, 即使作了底下的db...save()亦然

{ "x" : 3 } // 注意一開始定義時只有屬性x (亦即field x), 尙無field _id

> db.things.save(t) // 將資料物件t增至collection things 中

WriteResult({ "nInserted" : 1 })

> db.things.find() // 顯示collection things 的 documents <註二>

{ "_id" : ObjectId("..........略............"), "name" : "mongo" }

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

> t // 即 t 於上面.save(t)後方有field _id, 且_id與以.save(t)增添至things內的document所產生的_id相同

{ "x" : 3, "_id" : ObjectId("556b87c341e6e4838babbdc1") }

// 若前面是用db.things.insert(t), 則上行仍只為 { "x" : 3 }

> use test // 切換至資料庫test

switched to db test

> db.things.save(t) // 類似上，只不過現在於資料庫test上操作, 此行亦自動建立資料庫test與其內的colleciton things

WriteResult({ "nInserted" : 1 })

> db.things.find() // 由於已有 t._id 故.save(t)時以沿用其_id來增添document (注意與 mydb內document 為個別的實體)

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

> show dbs

local 0.078GB

mydb 0.078GB

test 0.078GB

> db.things.insert({x:7}) // 效果同 db.things.save({x:7}) 亦相當於SQL的 INSERT INTO things VALUES (7);

WriteResult({ "nInserted" : 1 })

> db.things.find()

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

{ "_id" : ObjectId("556b87c341e6e4838babbdc2"), "x" : 7 }

// 注意! 下行remove()中若未加參數或以空文件{}當參數, 則會將所有collection中的documents全部刪除! 用時須謹慎

> db.things.remove({x:3}) // 類似於SQL的 DELETE FROM things WHERE x=3; (另外，可利用field _id刪除所指定document)

WriteResult({ "nRemoved" : 1 })

> db.things.find() // 顯示結果資料庫test的 collection things 中只剰一document

{ "_id" : ObjectId("556b87c341e6e4838babbdc2"), "x" : 7 }

> db.things.remove({x:7}) // 相當於SQL的 DELETE FROM things WHERE x=7; 即當中有field x為7者皆刪除

WriteResult({ "nRemoved" : 1 })

> db.things.find() // 資料庫test的 collection things 中已無資料

> show collections // 然而資料庫test 中的things仍存在，顯示雖mongo會自動建立collection,但不會自動刪除

system.indexes

things

> db.things.drop() // 於資料庫test中刪除collection things

true

> show collections // 資料庫test中顯示已無things

system.indexes

> show dbs // 同上理資料庫test 仍存在

local 0.078GB

mydb 0.078GB

test 0.078GB

> db.dropDatabase() // 刪除目前所在資料庫 i.e.資料庫test

{ "dropped" : "test", "ok" : 1 }

> show dbs // 顯示已無資料庫test

local 0.078GB

mydb 0.078GB

> use mydb // 切換回到資料庫mydb

switched to db mydb

> for (var i=1; i<=20; i++) db.things.save({x:4,j:i}) // 利用JavaScript的for loop來增添資料, 注意此處x,j是field名

WriteResult({ "nInserted" : 1 })

> db.things.find() // 因資料過多而只顯示前面部份

{ "_id" : ObjectId("..........略............"), "name" : "mongo" }

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 1 }

......

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 18 }

Type "it" for more

> it // 打 it 方接續顯示上面未顯示的部份

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 19 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 20 }

> db.things.find().limit(5).skip(2) // 跳過前兩筆後顯示五筆; 相當於SQL的 SELECT * from things LIMIT 5 SKIP 2;

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 1 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 2 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 3 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 4 }

{ "_id" : ObjectId("..........略............"), "x" : 4, "j" : 5 }

> db.things.find({x:3}) // 相當於SQL的 SELECT * from things WHERE x=3;

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

> db.things.find({x:3},{_id:1}) // 類似上一個結果，然只顯示field _id

{ "_id" : ObjectId("556b87c341e6e4838babbdc1") }

> db.things.distinct("x") // 相當於SQL的 SELECT DISTINCT x from things;

[ 4, 3 ]

> db.things.find({$or:[{name:"mongo"},{x:3}]}) // 相當於SQL的 SELECT * from things WHERE name="mongo" OR x=3;

{ "_id" : ObjectId("..........略............"), "name" : "mongo" }

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

> var tstcursor=db.things.find() // 宣告變數tstcursor為 db...find()傳回的object cursor

> while (tstcursor.hasNext()) printjson(tstcursor.next()) // <註三>

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

......

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 20 }

// 下行相當於SQL的 SELECT * from things;

> db.things.find().forEach(printjson) // .forEach(func)為cursor method 相當於上兩行scripts的總效果

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

.....

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 20 }

> db.things.find({x:{$ne:4}}) // 排除field x為4的documents; 相當於SQL的 SELECT * from things WHERE x!=4;

{ "_id" : ObjectId("..........略............"), "name" : "mongo" }

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 3 }

> db.things.find({name:/ng/}) // 相當於SQL的 SELECT * from things WHERE name LIKE '%ng%';

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

> db.things.find({name:/^mon/}) // 相當於SQL的 SELECT * from things WHERE name LIKE 'mon%';

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

> db.things.find({x:4,j:10}) // 相當於SQL的 SELECT * from things WHERE x=4 AND j=10;

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 10 }

// 下行效果同 db.things.count() // 相當於SQL的 SELECT COUNT(*) FROM things;

> db.things.find().itcount() // 傳回collection things中 documents 個數 (此處22個資料物件,故顯示22)

> db.things.find({j:{$exists:true}}).count() // 相當於SQL的 SELECT COUNT(j) FROM things; 即有field j者方計數

> var tstcursor=db.things.find() // 重新定義tstcursor於things開頭

> printjson(tstcursor[0]) // 由此可知cursor可如同陣列般操作，陣列開頭註標為0 <註四>

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

> printjson(tstcursor[21]) // 由於有22個資料物件,故 tstcursor[21] 為最後一個

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 20 }

> printjson(tstcursor[22]) // 最後一個之後的皆視為未定義

undefined

> db.things.find({name:"mongo"}).forEach(printjson) // 相當於SQL的 SELECT * from things WHERE name="mongo";

{ "_id" : ObjectId("......略......"), "name" : "mongo" }

> db.things.find({x:4}).forEach(printjson) // 相當於SQL的 SELECT * from things WHERE x=4;

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 1 }

......

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 20 }

// 下行的true換成1亦可 i.e. 下行 <=> db.things.find({x:4},{j:1}).forEach(printjson)

> db.things.find({x:4},{j:true}).forEach(printjson) // 相當於SQL的 SELECT j from things WHERE x=4;

{ "_id" : ObjectId("......略......"), "j" : 1 }

......

{ "_id" : ObjectId("......略......"), "j" : 20 }

> db.things.findOne({x:4}) // <=> db.things.find({x:4}).limit(1) 而SQL為 SELECT * from things WHERE x=4 LIMIT 1;

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 1 }

> var tstdoc=db.things.findOne({x:4}) // 與上類似，然將變數tstdoc定義成db...findOne()傳回的document <註五>

> tstdoc

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 1 }

> db.things.find({x:4}).limit(3) // 由傳回結果易知，當limit()內參數>1 時傳回的不再是document而是cursor <註六>

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 1 }

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 2 }

{ "_id" : ObjectId("......略......"), "x" : 4, "j" : 3 }

> db.things.update({x:3},{$set:{x:1}}) // 相當於SQL的 UPDATE things SET x=1 WHERE x=3; (若有相同亦只改最前頭)

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.things.find({x:{$gte:1,$lte:3}}) // 由此顯示結果可知，x=3的資料物件成功改成x=1

{ "_id" : ObjectId("556b87c341e6e4838babbdc1"), "x" : 1 }

> var dmongo=db.things.findOne({name:"mongo"})

> dmongo // <=> print(tojson(dmongo))

{ "_id" : ObjectId("556ae901b81b03c8400c2c04"), "name" : "mongo" }

> dmongo.type="database" // 增一field於資料物件dmongo中 (其field名為type, field值為database)

database

> dmongo

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database"

}

> db.things.findOne({name:"mongo"}) // 因尙未save(), 故db未更動

{ "_id" : ObjectId("556ae901b81b03c8400c2c04"), "name" : "mongo" }

> db.things.save(dmongo) // 以.save()來更新document資料 (注意若dmongo的_id於things中找不到,則是增添新document)

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.things.findOne({name:"mongo"}) // 由結果亦知：因collection things中能找到與dmongo相同的_id, 故是更新document

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database"

}

// 嵌入文件 (已設資料物件dmongo開始如上定義, 且collection things中已有相同document)

> dmongo.newtstd={a:1,b:2} // 對資料物件dmongo 再增一field ,此一新field名newtstd, 其值{a:1,b:2}又為一document

{ "a" : 1, "b" : 2 }

> db.things.save(dmongo) // 以dmongo來更新資料庫mydb中things裡的document

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.things.findOne({name:"mongo"}) // 由查詢顯示可知：子文件 {a:1,b:2} 被嵌入至父文件中

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database",

"newtstd" : {

"a" : 1,

"b" : 2

}

> db.things.findOne({"newtstd.b":2}) // 內嵌文件之查詢例

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database",

"newtstd" : {

"a" : 1,

"b" : 2

}

// 參考(reference) 例 - 設操作延續上面

> var other={s:"other thing",n:1} // 建一資料物件other, 其有s,n兩fields

> db.otherthings.save(other) // 自動建立collection otherthings, 並將上行document增添其中

WriteResult({ "nInserted" : 1 })

> db.otherthings.find()

{ "_id" : ObjectId("556d98fe41e6e4838babbdd6"), "s" : "other thing", "n" : 1 }

> var mongo=db.things.findOne({name:"mongo"})

> mongo

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database",

"newtstd" : {

"a" : 1,

"b" : 2

}

// 下下行於資料物件mongo增一field otherdata,其值為一reference, 此reference用來參考otherthings中的某特定document

// 注意上面.save(other)已定other._id為ObjectId("556d98fe41e6e4838babbdd6"), 故reference知道要參考哪個document

> mongo.otherdata=new DBRef('otherthings',other._id)

DBRef("otherthings", ObjectId("556d98fe41e6e4838babbdd6"))

> mongo

{

"_id" : ObjectId("556ae901b81b03c8400c2c04"),

"name" : "mongo",

"type" : "database",

"newtstd" : {

"a" : 1,

"b" : 2

"otherdata" : DBRef("otherthings", ObjectId("556d98fe41e6e4838babbdd6"))

}

> db.things.save(mongo) // 使資料庫內的docuement 亦更新

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

// 由下行可知，我們已可經由 things中某一特定document的field otherdata 參考到 otherthings中某一特定document

> db.things.findOne({name:"mongo"}).otherdata.fetch()

{

"_id" : ObjectId("556d98fe41e6e4838babbdd6"),

"s" : "other thing",

"n" : 1

}

> other.n=3

> db.otherthings.save(other) // 更新collection otherthings中此一特定document

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> db.otherthings.find()

{ "_id" : ObjectId("556d98fe41e6e4838babbdd6"), "s" : "other thing", "n" : 3 }

> db.things.findOne({name:"mongo"}).otherdata.fetch() // 從 things 中亦可得知 otherthings 中的更新

{

"_id" : ObjectId("556d98fe41e6e4838babbdd6"),

"s" : "other thing",

"n" : 3

}

> db.things.getIndexes() // 查看於collection things已建之索引 (此為系統為field _id自動建的遞增索引)

[

{

"v" : 1,

"key" : {

"_id" : 1

"name" : "_id_",

"ns" : "mydb.things"

}

]

> db.otherthings.getIndexes() // 查看於collection otherthings已建之索引 (此亦為系統為field _id自動建的)

[

{

"v" : 1,

"key" : {

"_id" : 1

"name" : "_id_",

"ns" : "mydb.otherthings"

}

]

> db.system.indexes.find() // 此可列出當前資料庫於各collection所建的全部部索引

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

// 下行相當於SQL的 CREATE INDEX <自設索引名> ON things(j DESC)

> db.things.ensureIndex({j:-1}) // 對 things中的field j建立遞減索引 (-1表遞減; 1表遞增) <註七>

{

"createdCollectionAutomatically" : false,

"numIndexesBefore" : 1,

"numIndexesAfter" : 2,

"ok" : 1

}

> db.system.indexes.find()

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

{ "v" : 1, "key" : { "j" : -1 }, "name" : "j_-1", "ns" : "mydb.things" }

> db.things.find({j:{$gt:15}}).count() // 相當於SQL的 SELECT COUNT(*) FROM things WHERE j>15; 理論上index後會較快

> db.things.find().sort({j:-1}) // 以field j遞減方式顯示結果,相當於SQL的 SELECT * FROM things ORDER BY j DESC;

{ "_id" : ObjectId("556ba28e41e6e4838babbdd5"), "x" : 4, "j" : 20 }

......

{ "_id" : ObjectId("556ba28d41e6e4838babbdc2"), "x" : 4, "j" : 1 }

......

> db.things.find().sort({j:1}) // 以field j 遞增方式顯示結果; 因是建立遞減索引, 故此應比上面慢 (此例不明顯,須很多data方能看出)

......

{ "_id" : ObjectId("556ba28d41e6e4838babbdc2"), "x" : 4, "j" : 1 }

......

{ "_id" : ObjectId("556ba28e41e6e4838babbdd5"), "x" : 4, "j" : 20 }

> db.things.find({j:{$gte:11}},{j:1}).sort({j:-1}) // 相當於SQL的 SELECT j FROM things WHERE j>=11 ORDER BY j DESC;

{ "_id" : ObjectId("556ba28e41e6e4838babbdd5"), "j" : 20 }

......

{ "_id" : ObjectId("556ba28d41e6e4838babbdcc"), "j" : 11 }

> db.things.find({j:{$lte:7}},{j:1}).sort({j:-1}) // 相當於SQL的 SELECT j FROM things WHERE j<=7 ORDER BY j DESC;

{ "_id" : ObjectId("556ba28d41e6e4838babbdc8"), "j" : 7 }

......

{ "_id" : ObjectId("556ba28d41e6e4838babbdc2"), "j" : 1 }

> db.things.find({j:{$gt:7,$lt:11}},{j:1}).sort({j:-1}) // SELECT j FROM things WHERE j>7 AND j<11 ORDER BY j DESC;

{ "_id" : ObjectId("556ba28d41e6e4838babbdcb"), "j" : 10 }

{ "_id" : ObjectId("556ba28d41e6e4838babbdca"), "j" : 9 }

{ "_id" : ObjectId("556ba28d41e6e4838babbdc9"), "j" : 8 }

> db.things.ensureIndex({"newtstd.b":1}) // 以newtstd.b為key,對things.newtstd內嵌文件建立遞增索引

{

"createdCollectionAutomatically" : false,

"numIndexesBefore" : 2,

"numIndexesAfter" : 3,

"ok" : 1

}

> db.system.indexes.find()

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

{ "v" : 1, "key" : { "j" : -1 }, "name" : "j_-1", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "newtstd.b" : 1 }, "name" : "newtstd.b_1", "ns" : "mydb.things" }

// 下行所建索引以field j作遞增排序，當j相同情況下, 按照name作遞減排序, 若前二field皆相同, 以 newtsd.b 作遞減排序

> db.things.ensureIndex({j:1, name:-1, "newtstd.b":1}) // 多columns又含內嵌文件的索引例

{

"createdCollectionAutomatically" : false,

"numIndexesBefore" : 3,

"numIndexesAfter" : 4,

"ok" : 1

}

> db.system.indexes.find()

...

{ "v" : 1, "key" : { "newtstd.b" : 1 }, "name" : "newtstd.b_1", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "j" : 1, "name" : 1, "newtstd.b" : -1 }, "name" : "j_1_name_1_newtstd.b_-1", "ns" : "mydb.things" }

> db.things.update({x:4},{$inc:{j:10}},false,true) // 相當於SQL的 UPDATE things SET j=j+10 WHERE x=4;

WriteResult({ "nMatched" : 20, "nUpserted" : 0, "nModified" : 20 })

> db.things.reIndex() // 重建索引

> db.things.find({x:4},{j:1}).sort({j:-1})

{ "_id" : ObjectId("556ba28e41e6e4838babbdd5"), "j" : 30 }

......

{ "_id" : ObjectId("556ba28d41e6e4838babbdc2"), "j" : 11 }

> db.things.dropIndex({j:-1}) // 刪除一特定索引，field(s)須全符合方刪除其索引

{ ... , "ok" : 1 }

> db.system.indexes.find() // 由結果知刪除成功

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

{ "v" : 1, "key" : { "newtstd.b" : 1 }, "name" : "newtstd.b_1", "ns" : "mydb.things" }

......

// 下行以runCommand模式刪除索引：效果相當於 db.things.dropIndex({"newtstd.b":1})

> db.runCommand({dropIndexes:'things', index: {"newtstd.b":1}})

{ ... , "ok" : 1 }

> db.system.indexes.find() // 由結果知刪除成功

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

......

> db.things.dropIndexes() // 除預設的 _id 索引外，其餘的collection things中索引全都刪除

{

"nIndexesWas" : 2,

"msg" : "non-_id indexes dropped for collection",

"ok" : 1

}

> db.system.indexes.find()

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.things" }

{ "v" : 1, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "mydb.otherthings" }

> db.things.reIndex() // 重建索引, 注意!! 重建"不能"復原刪除！只是把既有index重建索引, 故.indexes.find() 結果同上

// map/reduce: 注意map輸出與reduce的輸入兩者的資料型態須相等

// added in 2016/3/12

I.法

db.things.mapReduce(

function() {

var x = this.x;

emit(x, this.j);

} ,

function (key, vals) {

var total = 0;

for (var i = 0; i < vals.length; i++) {

total += vals[i];

}

return total;

}, { out : { inline : 1 } } )

輸出如下:

{

"results" : [

{ // { "_id" : ObjectId(...), "z" : 15 } and the last document

"_id" : null,

"value" : 0

{ // { "_id" : ObjectId(...), "x" : 1 }

"_id" : 1,

"value" : null

{ // { "_id" : ObjectId(...), "j" : 11~30, "x" : 4 }

"_id" : 4,

"value" : 410 // 11+12+...+30 = 410

}

"timeMillis" : 2,

"counts" : {

"input" : 23,

"emit" : 23,

"reduce" : 2,

"output" : 3

"ok" : 1,

}

II.法

db.things.mapReduce(

function() {

var x = this.x;

emit(x, {count: 1, j: this.j} );

} ,

function(key, values) {

var result = {count: 0, j: 0};

values.forEach(function(value) {

result.count += value.count;

result.j += value.j;

} );

return result;

}, { out : { inline : 1 } } )

輸出如下: // 結果類似I.法, 唯此處加了計數器

{

"results" : [

{

"_id" : null,

"value" : {

"count" : 2,

"j" : 0

}

{

"_id" : 1,

"value" : {

"count" : 1,

"j" : null

}

{

"_id" : 4,

"value" : {

"count" : 20,

"j" : 410

}

"timeMillis" : 3,

"counts" : {

"input" : 23,

"emit" : 23,

"reduce" : 2,

"output" : 3

"ok" : 1,

}

<註一>

一開始啟動server發現有問題無法啟動, 以 systemctl -l status mongod.service 查詢:

情況<i> 當含有如下錯誤訊息:

...warning... servers don't have journaling enabled by default. Please use --journal if you want durability.

......

...mongod... ERROR: child process failed, exited with error number 1

經查發現自己的 mongodb-server 的設定檔/etc/mongod.conf內的log設定與其所預建的log目錄不符:

/etc/mongod.conf 中預設是 logpath=/var/log/mongodb/mongod.log

然urpmi mongodb-server 安裝時是建 /var/log/mongo/mongod.log

故產生錯誤

自行解決方式：

經查google後發現置於 /var/log/mongodb/mongod.log 的數量遠大於 /var/log/mongo/mongod.log

本想改以 /var/log/mongodb/mongod.log 為主

然為求未來rpm update 的方便，還是改/etc/mongod.conf 設定成 logpath=/var/log/mongo/mongod.log

然未來新版本若更動亦不排除再改設定

情況<ii>

然若 systemctl -l status mongod.service 查詢出現

...

...ERROR: child process failed, exited with error number 100

...

則查看看/var/lib/mongo/ 目錄中是否有mongod.lock

若server没啟動而此竟然有此當存在, 則表其為先前的程序,

很可能是先前有不正常結束的情況(e.g.當機)而未淸,

此時刪此mongod.lock後通常再執行systemctl start mongod.service即可

若mongodb內先前已存有data, 則一進入後先執行db.repairDatabase()來修復會較保險

b.更新時有問題，出現

ERROR: 'script' failed for mongodb-server-3.0.4-1-omv2014.0.i586:

error: %post(mongodb-server-3.0.4-1.i586) 短命令稿執行失敗，離開狀態 1

亦不能啟動server

為排除變因，先

]# mv /var/lib/mongo /var/lib/mongo.old

]# mkdir /var/lib/mongo

]# chown mongod.mongod /var/lib/mongo

其後用 urpmi --replacefiles --replacepkgs mongodb-server 再重裝, 雖安裝没再出現錯誤，然執行仍core dump,

或許從2.x更新至新版3.0.4有啥問題... (己没找到解決方式,故改回用2.x)

<註二>

傳回結果開頭總會是field "_id"

ObjectId未定義時為系統自動分配，依情況而不同，此處從略

由 db.things.find() 顯示查詢結果亦知，資料庫是以_id為名的field 來存ObjectId(), 其亦具SQL的primary key性質

由help的db...find() 說明 list objects in collection 可知

我們可視db....find() 所顯示的一{...} 即為一資料物件，此物件以 "_id":ObjectId("......略......") 屬性作為開頭

而於MongoDB中，此一資料物件即為一document

雖單用db.things.find()所顯示的是查詢結果，然實際上是一object cursor(DBCursor), 故之後有例將變數定義成此cursor

例中剛開始定義j等資料物件{...}最初可視為尙無field _id的document(s), 當第一次.save(j)後才有_id

field _id 的亦有SQL中 primary key 的效果

但若是用db.thing.insert(j) 則直接打j時{...}將無field _id, 而db.things.find()仍有此物件_id就是

i.e. 兩方法僅使local變數相異, 內部儲存資料物件兩方法皆必有物件_id就是

注意！雖然多數可以對應SQL, 然而多數情況應最好同時將{...}視為(資料)物件，較符合物件導向精神

<註三>

利用while loop與object cursor顯示things中所有資料 (i.e. iterator方式)

tstcursor.hasNext() 與 tstcursor.next() 為Cursor methods

方法printjson()以JSON形式顯示資料

<自>我們可視object cursor本身即為一物件,其內部有一指標成員(pointer)最初指向 collection第一個待顯示資料物件的前一位,

方法hasNext()是讀此指標成員來判斷cursor下一位是否有資料物件;

方法next()是先顯示cursor下一位的資料物件後再將cursor內部的指標成員移至此資料物件

<註四>

注意當cursor一用陣列來操作時，

cursor將停止如<註三>般的iterator方式 (<註三>的<自>中所說的內部指標，相當於指向 cursor[0]的前一位)

且cursor會把註標所指的資料物件皆載入記憶體，若查詢結果較大，有可能因此耗盡記憶體而發生記憶體溢位

故應依自身情況選擇: 當cursor用iterator方式時，可隨時改用陣列方式，而cursor[0]會成為改用當時尙未顯示的第一個資料物件

然若是已用陣列操作時想換用iterator方式, 只能重新定義cursor

<註五>

注意! 傳回結果實際上是與 database資料隔離的新資料物件, 而tstdoc指向此新物件

故未經諸如.save()存入/更新時, 改此物件是不會更動到database的

<註六>

注意用limit()限制查詢結果個數可減輕資料庫與網路的負荷，因而增加效率，改善效能

<註七>

注意索引的遞增遞減是指索引建存遞增遞減，與用.find()所顯示的不見得同向，

顯示是用諸如.find().sort()來控制顯示時呈現出來的遞增遞減

ref.0 MongoDB Manual - http://www.mongodb.org/display/DOCS/Manual

ref.1 man mongo

ref.2 挑戰大數據第二版 - http://datasearch.ruc.edu.cn/NoSQL/

書中p.11-52 表11-10 為 SQL與MongoDB查詢敍述比較

此書可能是人民大學的學生上Big Data相關課程的内容彙整,

也許因課程繁重而筆記匆匆, 以致書印錯誤一些些

且又没索引; 某部份中文用詞若能保留英文應該會比較好，

例如常用的'行'與'列'恰與己所學相反

以前所學 column譯為行而 row譯為列 - i.e.直行橫列

然書中把 column譯為列而 row譯為行

再例如程設裡指標一般是pointer，而書中把資料庫的cursor翻成指標,

之前没碰過資料庫程設的讀者有可能會在這個地方產生混淆

若能自行校對，那麼此本仍是很不錯的中文雲端參考書 (注意"能校對"前提!)

一些東東

2016年3月9日星期三

mongodb howto

沒有留言:

張貼留言

2016年3月9日 星期三

mongodb howto

沒有留言:

張貼留言

2016年3月9日星期三