Upload
suwon-chae
View
142
Download
12
Embed Size (px)
DESCRIPTION
Citation preview
진행목표
- 쉽게
- 학습 시간 단축
- 기초를 닦아서 발판을 마련
- Use ME!!
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 2����������� ������������������
NoSQL
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 3����������� ������������������
Think about DATABASE
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 4����������� ������������������
in recently
• 충분히 • 필요한 만큼 • 적절하게 • 잘 살아오고 있었다.
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 5����������� ������������������
1983, DEC microcomputer (128kb ram)
• Not Only SQL • 데이터 스토어 • 비 관계형을 지향 • 대용량 처리를 목표
NoSQL
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 6����������� ������������������
Q> 구글은 어느 회사 DB를 쓸까? 직접 만들어서 쓰나?
CAP 이론 cap theorem
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 7����������� ������������������
TELEPHONE SECRETARY Tales about…
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 8
Data Models
• Relational • Key-value • Column-oriented
– Table no joins • Document-oriented
– JSON or XML like, no joins
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 9����������� ������������������
Consistent, Available (CA) Systems
• 전통적인 RDBMS • Vertica (column-oriented) • Aster Data (relational) • Greenplum (relational)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 10����������� ������������������
Consistent, Partition-Tolerant (CP) Systems
• BigTable (column-oriented/tabular) • Hypertable (column-oriented/tabular) • HBase (column-oriented/tabular) • MongoDB (document-oriented) • Redis (key-value) • MemcacheDB (key-value) • Berkeley DB (key-value)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 11����������� ������������������
Available, Partition-Tolerant (AP) Systems
• Dynamo (key-value) amazon
• Tokyo Cabinet (key-value) • KAI (key-value) • Cassandra (column-oriented) facebook p2p
• CouchDB (document-oriented) • SimpleDB (document-oriented)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 12����������� ������������������
라이선스 및 구현 비교 정리
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 13����������� ������������������
*출처 : 10gen slide “No SQL, No problem”
소개
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 14����������� ������������������
몽고DB란?
• MongoDB (from "humongous")는 확장가능하고, 고성능을 지향하는 도큐먼트 기반의 오픈소스 데이터 베이스.
• C++로 작성되었음
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 15����������� ������������������
by
• Document-oriented storage – JSON 스타일의 documents – 간결하고 강력한 동적 스키마 구성
• Full Index Support – 어느 속성에나 인덱스 설정 가능
• Replication & High Availability – LAN과 WAN을 이용한 미러링
특징
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 16����������� ������������������
• Auto-Sharding – 기능 손실 없는 수평 확장
• Querying – 풍부한 문서기반의 쿼리 지원
• Fast In-Place Updates – 성능문제를 일으키지 않는 정교한 수정
• Map/Reduce – 유연한 데이터 수집과 처리
특징 (계속)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 17����������� ������������������
• GridFS – 다양한 크기의 파일을 쉽게 저장
• Commercial Support – 기술 지원 기업이 존재, 교육, 컨설팅 지원 (
but 북미 이야기;;;) • 고성능 • 간편한 관리
특징 (계속)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 18����������� ������������������
시작하기
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 19����������� ������������������
실습
• 데이터의 기본 단위는 Document • 컬렉션은 Document의 집합 • 자바스크립트 쉘 내장 • 스키마가 없다.
MongoDB 개요
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 20����������� ������������������
• 데이터베이스 스키마는 데이터베이스에서 자료의 구조, 자료의 표현 방법, 자료 간의 관계를 정의한 것을 말하는 전산학 용어이다.
• 데이터베이스 관리 시스템(DBMS)이 주어진 설정에 따라 데이터베이스 스키마를 만들어 내며, 데이터베이스 사용자가 자료를 저장, 조회, 삭제, 변경할 때 DBMS는 그것이 생성한 데이터베이스 스키마를 참조하여 명령을 수행한다.
Schema
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 21����������� ������������������
• key:value 쌍으로 이루어진 JSON-like
도큐먼트Document
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 22����������� ������������������
{ "id": 1, "name": "Foo", "price": 123, "tags": ["Bar","Eek"] }
{ “hello” : “world” } ß 문서 { “이름” : “채수원”, ß 또 다른 문서 “직업” : “무직”, “나이” : 5 }
도큐먼트Document
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 23����������� ������������������
• document의 모음 • schema-free • system으로 시작하는 이름은 사용불가(예약어)
• db.컬렉션이름.명령어 – db.blog.insert(…)
컬렉션 Collection
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 24����������� ������������������
실습
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 25
• mongod --dbpath ./data/db • mongo
서버 실행
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 26����������� ������������������
하나의 데이터 베이스는 자체 권한을 가지고 있으며 각각 파일로 존재한다. • admin
– root DB • local
– 복제 제외 DB • config
– 샤드(shard)정보 저장
Database
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 27����������� ������������������
• Interactive console • JavaScript 기반
MongoDB shell
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 28����������� ������������������
• insert() – insert( {“name” : “world” } )
• find() • findOne() • update() • remove()
– remove( {“name” : “world” } )
기본CRUD(create, retrieve, update, delete)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 29����������� ������������������
> help > db.help() > db.mycollection.help() > db.mycollection.find().help()
Shell Help
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 30����������� ������������������
db.mycollection.help??
> db.version() > var titles = ["blog", "cafe", "message"]; > db.blog.insert( titles ); > for ( i in titles) { print( db.blog[ titles[i] ]); }
Shell database관련
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 31����������� ������������������
> db.version() > use 데이터베이스_이름 > show collections
Shell database관련
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 32����������� ������������������
• null • boolean • 32비트 정수 • 64비트 정수 • 64비트 부동소수점형 • 문자열 • 심볼형
Data Types
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 33����������� ������������������
• 객체ID – ObjectId()
• 날짜 – Date(), 1/1000초 단위
• 정규표현식 – { "a" : /wo/i }
Data Types (이어서)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 34����������� ������������������
• 코드형 – { "a” : function() { … } }
• 이진데이터형 • 최대값형 • 최소값형 • undefined • 배열 • embedded document
Data Types (이어서)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 35����������� ������������������
• Shell에서 모든 숫자는 더블double형으로 취급 --> floating-point로 취급
숫자
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 36����������� ������������������
Embedded Document
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 37����������� ������������������
{ "name" : "John Doe", "address" : {
"street" : "123 Street", "city" : ”Hamton",
"state" : "NY" } }
문제점은?
_id
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 38����������� ������������������
• ObjectId() • o = new ObjectId() • o.getTimestamp()
{"things" : ["pie", 3.14]}
Array
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 39����������� ������������������
• db.getCollectionNames() • document 생성 : 영화제목, 장르 • db.getCollectionNames() • db.system.indexes.find()
Collections 문서작성실습
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 40����������� ������������������
• db.foo.insert( document ); • batch insert <-- fast!!
– but one collection only • document size는 16M 까지 • BSON
– Object.bsonsize( db.blog )
insert
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 41����������� ������������������
• var robin = db.blog.findOne( {"name" : "robin" } );
• robin.age = 18; • db.blog.update( {"name" : "robin"}, robin
); • delete robin.age
update
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 42����������� ������������������
• $inc – db.blog.update( {"name" : "robin" }, {"$inc"
: {"age" : 1 } } ) – db.blog.update( {"name" : "robin" }, {"$inc"
: {"exp" : 1 } } )
update이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 43����������� ������������������
• $set – db.blog.update( {"name" : "robin" }, {"$set"
: {"pow" : 10 } } ) • $unset
update이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 44����������� ������������������
• $rename – db.blog.update( {"name" : "robin" }, {"$rena
me" : {"pow" : "pwr" } } )
update이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 45����������� ������������������
• upsert >db.blog.update( {"name" : "robin" }, robin, true
); • multi
– db.blog.update( { }, {"$set" : {"level" : "1" } }, false, true );
update이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 46����������� ������������������
• $push > db.movie.insert({ "title" : "dark knight" }) > db.movie.update({ "title" : "dark knight"} , {$push : { "character" : "batman" } } );
• $addToSet • db.getLastError()
update이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 47����������� ������������������
>db.mycollection.save(x); >db.mycollection.update( { _id: x._id }, x, /
*upsert*/ true );
save vs update
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 48����������� ������������������
> db.blog.remove( fake ); > db.blog.drop();
drop vs remove
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 49����������� ������������������
{ "_id" : ObjectId(), "status" : state, "priority" : N
}
get-and-set
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 50����������� ������������������
get-and-set 이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 51����������� ������������������
ps = db.processes.find({"status" : "READY").sort({"priority" : -1}) .limit(1).next()
db.processes.update({"_id" : ps._id}, {"$set" : {"status" : "RUNNING"}}) do_something(ps); db.processes.update({"_id" : ps._id}, {"$set" : {"status" : "DONE"}})
get-and-set 이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 52����������� ������������������
> ps = db.runCommand({"findAndModify" : "processes", "query" : {"status" : "READY"}, "sort" : {"priority" : -1}, "update" : {"$set" : {"status" : "RUNNING"}})
{ "ok" : 1, "value" : { "_id" : ObjectId("4b3e7a18005cab32be6291f7"), "priority" : 1, "status" : "READY" } }
• 형식 – findAndModify – query – sort – update / remove – new
• 오직 존재하는 문서만 갱신가능
get-and-set 이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 53����������� ������������������
• fire-and-forget
Fastest Write Mechanism
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 54����������� ������������������
• getLastError()
Safe Operations
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 55����������� ������������������
질의query
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 56����������� ������������������
> db.users.find({"age" : 27}) > db.users.find({"username" : "joe", "age" : 27}) > db.users.find({}, {"username" : 1, "email" : 1})
Query
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 57����������� ������������������
• db.stock.find({"in_stock" : "stock.no"})
제약사항
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 58����������� ������������������
> db.users.find({"age" : {"$gte" : 18, "$lte" : 30}}) > start = new Date("01/01/2007") > db.users.find({”D-day" : {"$lt" : start}}) > db.users.find({”name" : {"$ne" : "joe"}})
Query 조건문
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 59����������� ������������������
> db.raffle.find({"ticket_no" : {"$in" : [725, 542, 390]}}) > db.raffle.find({"ticket_no" : {"$nin" : [725, 542, 390]}}) > db.raffle.find({"$or" : [{"ticket_no" : 725}, {"winner" : true}]})
OR
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 60����������� ������������������
> db.users.find({"id_num" : {"$mod" : [5, 1]}}) > db.users.find({"id_num" : {"$not" : {"$mod" : [5, 1]}}})
Not
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 61����������� ������������������
> db.users.find( {"age" : {"$lt" : 30, "$gt" : 20}})
조건 규칙
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 62����������� ������������������
null
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 63����������� ������������������
> db.c.find() { "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null } { "_id" : ObjectId("4ba0f0dfd22aa494fd523622"), "y" : 1 } { "_id" : ObjectId("4ba0f148d22aa494fd523623"), "y" : 2 } > db.c.find({"y" : null}) { "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null } > db.c.find({"z" : null}) { "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null } { "_id" : ObjectId("4ba0f0dfd22aa494fd523622"), "y" : 1 } { "_id" : ObjectId("4ba0f148d22aa494fd523623"), "y" : 2 }
> db.users.find({"name" : /joe/i}) > db.users.find({"name" : /joey?/i})
정규표현식Regular Expressions
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 64����������� ������������������
배열검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 65����������� ������������������
> db.food.insert({"fruit" : ["apple", "banana", "peach"]}) > db.food.find({"fruit" : "banana"})
배열검색$all
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 66����������� ������������������
> db.food.insert({"_id" : 1, "fruit" : ["apple", "banana", "peach"]}) > db.food.insert({"_id" : 2, "fruit" : ["apple", "kumquat", "orange"]}) > db.food.insert({"_id" : 3, "fruit" : ["cherry", "banana", "apple"]}) > db.food.find({fruit : {$all : ["apple", "banana"]}}) {"_id" : 1, "fruit" : ["apple", "banana", "peach"]} {"_id" : 3, "fruit" : ["cherry", "banana", "apple"]} > db.food.find({"fruit" : ["apple", "banana"]}) > db.food.find({"fruit.2" : "peach"})
배열검색$size
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 67����������� ������������������
> db.food.find({"fruit" : {"$size" : 3}}) > db.food.update({"$push" : {"fruit" : "strawberry"}, "$inc" : {"size" : 1}}) > db.food.find({"size" : {"$gt" : 3}})
배열검색$slice
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 68����������� ������������������
> db.blog.posts.findOne(criteria, {"comments" : {"$slice" : 10}}) > db.blog.posts.findOne(criteria, {"comments" : {"$slice" : -10}}) > db.blog.posts.findOne(criteria, {"comments" : {"$slice" : [23, 10]}})
{ "_id" : ObjectId("4b2d75476cc613d5ee930164"), "title" : "A blog post", "content" : "...", "comments" : [ {
"name" : "joe",
"email" : "[email protected]",
"content" : "nice post." }, {
"name" : "bob",
"email" : "[email protected]",
"content" : "good post." } ] }
{ "name" : { "first" : "Joe", "last" : "Schmoe" }, "age" : 45
}
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 69����������� ������������������
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 70����������� ������������������
> db.people.find({"name" : {"first" : "Joe", "last" : "Schmoe"}}) > db.people.find({"name.first" : "Joe", "name.last" : "Schmoe"})
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 71����������� ������������������
> db.blog.find() { "content" : "...", "comments" : [
{ "author" : "joe", "score" : 3, "comment" : "nice post" }, { "author" : "mary", "score" : 6, "comment" : "terrible post" } ]
}
• 내장 문서는 전체 문서가 다 일치해야 한다! ç 문제발생!!
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 72����������� ������������������
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 73����������� ������������������
• > db.blog.find({"comments" : {"$elemMatch" : {"author" : "joe", "score" : {"$gte" : 5}}}})
> db.blog.find( {"comments" : {"$elemMatch" : {"aut
hor" : "joe”,"score" : {"$gte" : 5} }} } )
Embedded Documents 검색
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 74����������� ������������������
$where
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 75����������� ������������������
> db.foo.insert({"apple" : 1, "banana" : 6, "peach" : 3}) > db.foo.insert({"apple" : 8, "spinach" : 4, "watermelon" : 4}) > db.foo.find({"$where" : "this.x + this.y == 10"}) > db.foo.find({"$where" : "function() { return this.x + this.y == 10; }"})
> for(i=0; i<100; i++) { ... db.c.insert({x : i}); ... } > var cursor = db.collection.find(); > while (cursor.hasNext()) { ... obj = cursor.next(); ... // do stuff ... }
커서cursor
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 76����������� ������������������
> var cursor = db.people.find(); > cursor.forEach(function(x) { ... print(x.name); ... });
커서cursor
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 77����������� ������������������
> db.c.find().limit(3) > db.c.find().skip(3) > db.c.find().sort({username : 1, age : -1}) > db.stock.find({"desc" : "mp3"}).limit(50).sort({"price" : -1})
Limits, Skips, Sorts
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 78����������� ������������������
skip 피하기
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 79����������� ������������������
> var page1 = db.foo.find(criteria).limit(100) > var page2 = db.foo.find(criteria).skip(100).limit(100) > var page3 = db.foo.find(criteria).skip(200).limit(100) var latest = null; while (page1.hasNext()) { latest = page1.next();
display(latest); } var page2 = db.foo.find({"date" : {"$gt" : latest.date}}); page2.sort({"date" : -1}).limit(100);
random
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 80����������� ������������������
> var total = db.foo.count() > var random = Math.floor(Math.random()*total) > db.foo.find().skip(random).limit(1) > db.people.insert({"name" : "joe", "random" : Math.random()}) > db.people.insert({"name" : "john", "random" : Math.random()}) > db.people.insert({"name" : "jim", "random" : Math.random()}) > var random = Math.random() > result = db.foo.findOne({"random" : {"$gt" : random}})
cursor = db.foo.find(); while (cursor.hasNext()) {
var doc = cursor.next(); doc = process(doc); db.foo.save(doc);
}
쿼리 결과의 일관성 유지
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 81����������� ������������������
var cursor = db.foo.find().snapshot(); var cursor = db.foo.find( { $query :{}, $snapshot : true } );
$snapshot
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 82����������� ������������������
인덱스index
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 83����������� ������������������
case1 {user : 1, date : -1} vs {date : -1, user : 1} case2 index for sort
인덱스
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 84����������� ������������������
> db.people.find({"username" : "mark"}) > db.people.ensureIndex({"username" : 1})
인덱스 설정
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 85����������� ������������������
case1 {user : 1, date : -1} vs {date : -1, user : 1} case2 index for sort
인덱스 전략
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 86����������� ������������������
• keyname1_dir1_keyname2_dir2… • 인덱스 이름 변경
db.foo.ensureIndex( {“a”:1…}, {“name”:”myindex”} )
index name
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 87����������� ������������������
db.people.ensureIndex( {“username”:1}, {“unique”:true} )
• use getLastError
예) db.getLastError() • _id :default unique index • compound unique index도 가능함
unique index
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 88����������� ������������������
db.people.ensureIndex( {“username”:1}, {“unique”:true, “dropDups”: true} )
중복 제거
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 89����������� ������������������
• db.things.ensureIndex( {firstname: 1}, {unique: true}); db.things.save({lastname: "Smith"});
• db.things.save({lastname: "Jones"}); à error!!
missing key
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 90����������� ������������������
• system.indexes 컬렉션
Index 관리
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 91����������� ������������������
• db.runcommand({“dropIndexes”:”people”, “index”:”myIndex”} )
• db.runcommand( {“dropIndexes”:”people”,“index”:”*”} )
• db.collection.dropIndexes();
Index 삭제
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 92����������� ������������������
• db.myCollection.reIndex() • db.runCommand( { reIndex : 'myCollecti
on' } )
Index Rebuild
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 93����������� ������������������
• db.collectionName.find(…).explain() • db.collectionName.find(…).hint()
explain, hint
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 94����������� ������������������
> db.people.ensureIndex({title : 1}, {sparse : true}) > db.people.save({name:"Jim"}) > db.people.save({name:"Sarah", title:"Princess"}) > db.people.find()
{ "_id" : ObjectId("4de6abd5da558a49fc5eef29"), "name" : "Jim" } { "_id" : ObjectId("4de6abdbda558a49fc5eef2a"), "name" : "Sarah", "title" : "Princess" }
> db.people.find().sort({title:1}) // only 1 doc returned because sparse { "_id" : ObjectId("4de6abdbda558a49fc5eef2a"), "name" : "Sarah", "title" : "Princess" }
sparse index
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 95����������� ������������������
뒤로 이어서…
> db.people.dropIndex({title : 1}) { "nIndexesWas" : 2, "ok" : 1 }
> db.people.find().sort({title:1}) // no more index, returns all documents { "_id" : ObjectId("4de6abd5da558a49fc5eef29"), "name" : "Jim" } { "_id" : ObjectId("4de6abdbda558a49fc5eef2a"), "name" : "Sarah", "title" : "Princess" }
sparse index (계속)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 96����������� ������������������
• db.places.ensureIndex( { loc : "2d" } ) • 2d documents
{ loc : [ 50 , 30 ] } { loc : { x : 50 , y : 30 } } { loc : { foo : 50 , y : 30 } } { loc : { long : 40.739037, lat: 73.992964 } }
• only 1 geospatial index per collection
2D Geospatial indexes
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 97����������� ������������������
• Query db.places.find( { loc : [50,50] } ) db.places.find( { loc : { $near : [50,50] } } ) db.places.find( { loc : { $near : [50,50] } } ).li
mit(20) db.places.find( { loc : { $near : [50,50] , $
maxDistance : 5 } } ).limit(20)
2D Geospatial indexes (계속)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 98����������� ������������������
• within > polygonA = [ [ 10, 20 ], [ 10, 40 ], [ 30, 40 ], [ 30, 20 ] ] > polygonB = { a : { x : 10, y : 20 }, b : { x : 15, y : 25 }, c : { x :
20, y : 20 } } > db.places.find(
{ "loc" : { "$within" : { "$polygon" : polygonA } } }) > db.places.find(
{ "loc" : { "$within" : { "$polygon" : polygonB } } })
2D Geospatial indexes (계속)
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 99����������� ������������������
• 일반적으로 ‘인덱스’가 갖는 특징을 동일하게 갖는다.
• 쿼리 결과 반환비율 • CUD 부하 • Cardinality • 공간차지 • 인덱스 생성시의 부하
주의사항
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 100����������� ������������������
집계Aggregation
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 101����������� ������������������
• db.movie.count() • db.movie.count( {“title” : “shark”} )
• db.pageviews.count({date: {'$gte': new Date("Nov 1, 2009"), '$lt': new Date("Dec 1, 2009")}})
count
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 102����������� ������������������
{"name" : "Ada", "age" : 20} {"name" : "Fred", "age" : 35} {"name" : "Susan", "age" : 60} {"name" : "Andy", "age" : 35} > db.runCommand({"distinct" : "people", "key" : "age"})
distinct
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 103����������� ������������������
select a,b,sum(c) csum from coll where active=1 group by a,b
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 104����������� ������������������
db.coll.group({ key: { a:true, b:true }, cond: { active:1 }, reduce: function(obj, prev) { prev.csum += obj.c; }, initial: { csum: 0 }
});
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 105����������� ������������������
{"day" : "2010/10/03", "price" : 4.23} {"day" : "2010/10/04", "price" : 4.27} {"day" : "2010/10/03", "price" : 4.10} {"day" : "2010/10/06", "price" : 4.30} {"day" : "2010/10/04”, "price" : 4.01}
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 106����������� ������������������
db.stocks.group({ "key" : {"day" : true }, "initial" : {"sum" : 0}, "$reduce" : function(doc, prev) { prev.sum += doc.price; }
})
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 107����������� ������������������
"ns" "key" "initial” "$reduce" "condition"
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 108����������� ������������������
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 109����������� ������������������
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 110����������� ������������������
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 111����������� ������������������
group
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 112����������� ������������������
> db.posts.group( {"ns" : "posts", "$keyf" : function(x) { return x.category.toLowerCase(); }, "initializer" : ... })
Group $keyf
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 113����������� ������������������
- Google - 페타바이트 이상의 대용량 데이터를 신뢰할 수 없는 컴퓨터로 구성된 클러스터 환경에서 병렬 처리를 지원하기 위해서 개발
- map, reduce 함수로 구성
MapReduce
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 114����������� ������������������
map = function () { for (var key in this) { emit(key, {count:1}); } }
MapReduce map
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 115����������� ������������������
reduce = function (key, emits) { total = 0; for (var i in emits) { total += emits[i].count; } return {count:total}; }
MapReduce reduce
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 116����������� ������������������
MapReduce
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 117����������� ������������������
db.runCommand({"mapreduce" : ”blog", "map" : map, "reduce" : reduce}) db.blog.mapReduce(map, reduce, {out: { inline : 1}})
기타등등miscellaneous
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 118����������� ������������������
• http://www.mongodb.org/display/DOCS/SQL+to+Mongo+Mapping+Chart
RDBMS유저를 위한 Query 비교
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 119����������� ������������������
• very high performance – 빠른 입력 – 바른 출력
• auto-FIFO age-out 기능 • Logging • 입력순서 자동유지 • Caching • Automatic Age Out
Capped Collections
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 120����������� ������������������
• circular queues • update, remove불가 • No index • tailable지원
Capped Collections이어서
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 121����������� ������������������
Capped Collections
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 122����������� ������������������
• db.createCollection(”blog", {capped:true, size:100000})
• db.createCollection(”blog", {capped:true, size:100000, max: 100})
• db. blog.find().sort({"$natural" : -1})
GridFS
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 123����������� ������������������
• 리플리케이션 설정시, 자동으로 파일 백업 • 한 디렉터리내에 수백만개의 파일 저장가능 • 파일과 함께 관련된 데이터 저장가능 (수정한 사람, 다운로드 수, 설명등등)
• document당 1개만 첨부가능
{ "_id" : <unspecified>, "length" : data_number, "chunkSize" : data_number, "uploadDate" : data_date, "md5" : data_string }
GridFS fs.files
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 124����������� ������������������
• {"$ref" : collection, "$id" : id_value} • {"$ref" : collection, "$id" : id_value, "$db
" : database}
DBref
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 125����������� ������������������
• startup/shutdown • monitoring
– web – mongostat
DB관리
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 126����������� ������������������
> db.addUser("root", "1234"); > db.addUser("read_only", "4321", true); > db.auth("root", "1234"); > db.system.users.remove({"user" : "test_
user"});
인증 Authentication
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 127����������� ������������������
http://kkovacs.eu/cassandra-vs-mongodb-vs-couchdb-vs-redis
NoSQL 비교자료
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 128����������� ������������������
백업/복구
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 129����������� ������������������
• $ ./mongodump -d test -o backup • $ ./mongorestore -d foo --drop backup/t
est/
mongodump/mongorestore
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 130����������� ������������������
> db.runCommand({"fsync" : 1, "lock" : 1});
> db.$cmd.sys.unlock.findOne();
fsync
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 131����������� ������������������
> db.repairDatabase() > mongod --dbpath=/data/db --repair
repairDatabase
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 132����������� ������������������
분산복제 replication
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 133����������� ������������������
master-slave
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 134����������� ������������������
• $ mkdir -p ~/dbs/master • $ ./mongod --dbpath ~/dbs/master --port 10000 --master • $ mkdir -p ~/dbs/slave • $ ./mongod --dbpath ~/dbs/slave --port 10001 --slave --source localhos
t:10000
• --only • --slavedelay • --fastsync • --autoresync • --oplogSize
master의 oplog size 지정(MB)
master-slave
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 135����������� ������������������
master-slave 추가/제거
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 136����������� ������������������
• $ ./mongod --slave --dbpath ~/dbs/slave --port 27018
> use local > db.sources.insert({"host" : "localhost:27017"}) > db.sources.find() > db.sources.insert({"host" : "prod.example.com:27017"}) > db.sources.remove({"host" : "localhost:27017"})
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 137����������� ������������������
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 138����������� ������������������
• $ cat /etc/hostname • $ mkdir -p ~/dbs/node1 ~/dbs/node2
• $ ./mongod --dbpath ~/dbs/node1 --port 10001 --replSet blog/earth:10002
• $ ./mongod --dbpath ~/dbs/node2 --port 10002 --replSet blog/earth:10001
• $ ./mongod --dbpath ~/dbs/node3 --port 10003 --replSet blog/earth:10001
• $ ./mongod --dbpath ~/dbs/node3 --port 10003 --replSet blog/earth:10001,morton:10002
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 139����������� ������������������
• $ ./mongo morton:10001/admin
>db.runCommand({"replSetInitiate" : { "_id" : "blog", "members" : [ { "_id" : 1, "host" : "earth:10001" },
{ "_id" : 2, "host" : "earth:10002" } ]}})
• standard – 일반노드.투표에 참여. 주 노드가 될 수 있음
• passive – 전체 데이터를 가지고 있음
• arbiter – 투표에만 참여. 복제본(X)
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 140����������� ������������������
> members.push({ ... "_id" : 3, ... "host" : "earth:10003", ... "priority" : 40 ... });
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 141����������� ������������������
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 142����������� ������������������
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 143����������� ������������������
레플리카 셋replica sets
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 144����������� ������������������
oplog
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 145����������� ������������������
• operation log • oplog.$main
> db.slaves.find() >db.sources.find() > db.runCommand({getLastError: 1, w: N}); > db.printReplicationInfo();
샤딩 sharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 146����������� ������������������
• 현재 장비에 디스크 공간이 부족할 때 • 단인 mongod가 처리할 때 보다 빠르게 데이터를 쓰고 싶을 때
• 성능 향상을 위해 더 많은 데이터를 메모리에 올려 두고 싶을 때
Sharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 147����������� ������������������
Sharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 148����������� ������������������
• name • timestamp • category • local • level type • etc
Shard key
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 149����������� ������������������
• Shard • mongos • config server
Autosharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 150����������� ������������������
Autosharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 151����������� ������������������
• 설정서버 시작 • $ mkdir -p ~/dbs/config • $ ./mongod --dbpath ~/dbs/config --port 20000
• mongos 기동 • $ ./mongos --port 30000 --configdb localhost:20000
Autosharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 152����������� ������������������
• 샤드추가 • $ mkdir -p ~/dbs/shard1 • $ ./mongod --dbpath ~/dbs/shard1 --port 10000
• $ ./mongo localhost:30000/admin > db.runCommand({addshard : "localhost:10000", allowLocal : true}) • 컬렉션을 샤딩으로 지정 > db.runCommand({"enablesharding" : "foo"}) > db.runCommand({"shardcollection" : "foo.bar", "key" : {"_id" : 1}})
Autosharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 153����������� ������������������
• $ mkdir -p ~/dbs/config1 ~/dbs/config2 ~/dbs/config3 • $ ./mongod --dbpath ~/dbs/config1 --port 20001 • $ ./mongod --dbpath ~/dbs/config2 --port 20002 • $ ./mongod --dbpath ~/dbs/config3 --port 20003
• $ ./mongos --configdb localhost:20001,localhost:20002,localhost:20003
Autosharding
MongoDB로����������� ������������������ 배우는����������� ������������������ NoSQL����������� ������������������ 154����������� ������������������
> db.shards.find() > db.databases.find() > db.chunks.find() > db.printShardingStatus() > db.runCommand({"removeshard" : "localhost:10000"}); > db.runCommand({"removeshard" : "localhost:10000"});