1. Not only NoSQL!
RDB
- PostgreSQL
MongoDB 20110730
@choplin

2. Why Mongo?

3. http://www.mongodb.org/display/DOCS/Introduction

4. Document-oriented
http://www.mongodb.org/display/DOCS/Introduction

5. Document-oriented
High performance
http://www.mongodb.org/display/DOCS/Introduction

6. Document-oriented
High performance
High availability
http://www.mongodb.org/display/DOCS/Introduction

7. Document-oriented
High performance
High availability
Easy scalability
http://www.mongodb.org/display/DOCS/Introduction

8. Document-oriented
High performance
High availability
Easy scalability
Rich query language
http://www.mongodb.org/display/DOCS/Introduction

9. http://www.mongodb.org/display/DOCS/Introduction

10. Document-oriented
http://www.mongodb.org/display/DOCS/Introduction

11. Document-oriented
Documents (objects) map nicely to
programming language data types
http://www.mongodb.org/display/DOCS/Introduction

12. Document-oriented
Documents (objects) map nicely to
programming language data types
Embedded documents and arrays reduce
need for joins
http://www.mongodb.org/display/DOCS/Introduction

13. Document-oriented
Documents (objects) map nicely to
programming language data types
Embedded documents and arrays reduce
need for joins
Dynamically-typed (schemaless) for easy
schema evolution
http://www.mongodb.org/display/DOCS/Introduction

14. Document-oriented
Documents (objects) map nicely to
programming language data types
Embedded documents and arrays reduce
need for joins
Dynamically-typed (schemaless) for easy
schema evolution
No joins and no multi-document
transactions for high performance and
easy scalability
http://www.mongodb.org/display/DOCS/Introduction

15. http://www.mongodb.org/display/DOCS/Introduction

16. High performance
http://www.mongodb.org/display/DOCS/Introduction

17. High performance
No joins and embedding makes reads
and writes fast
http://www.mongodb.org/display/DOCS/Introduction

18. High performance
No joins and embedding makes reads
and writes fast
Indexes including indexing of keys from
embedded documents and arrays
http://www.mongodb.org/display/DOCS/Introduction

19. High performance
No joins and embedding makes reads
and writes fast
Indexes including indexing of keys from
embedded documents and arrays
Optional asynchronous writes
http://www.mongodb.org/display/DOCS/Introduction

20. Point
No Relation (No Join)
No Transaction

21. Point
No Relation (No Join)
No Transaction
Solved many problems!

22. Join bother me...

23. How good?

24. Exapmple

25. Exapmple
Date

26. Exapmple
Date
Title

27. Exapmple
Date
Title
Tag

28. Exapmple
Date
Title
Tag
body

29. No Join!
> use blog
switched to db blog
> db.post.insert({
title: " 4 Sugamo.vim ..."
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
})

30. No Join!
> use blog
switched to db blog
> db.post.insert({
title: " 4 Sugamo.vim ..."
It’s embedded!!
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
})

31. Array and Object
> db.post.insert({
title: " 4 Sugamo.vim ..."
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
,comment: [
{
name: “vimmer”
,comment: “vim is great!”
}
,{}...
]
})

32. Array and Object
> db.post.insert({
title: " 4 Sugamo.vim ..." Array
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
,comment: [
{
name: “vimmer”
,comment: “vim is great!”
}
,{}...
]
})

33. Array and Object
> db.post.insert({
title: " 4 Sugamo.vim ..." Array
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
,comment: [
Objects in array
{
name: “vimmer”
,comment: “vim is great!”
}
,{}...
]
})

34. Embedded

35. Embedded
Reduce join

36. Embedded
Reduce join
Better performance

37. Embedded
Reduce join
Better performance
Join itself (executer)

38. Embedded
Reduce join
Better performance
Join itself (executer)
Query plan (optimizer)

39. Embedded
Reduce join
Better performance
Join itself (executer)
Query plan (optimizer)
Reduce impedance mismatch between db
and apps

40. Embedded
Reduce join
Better performance
Join itself (executer)
Query plan (optimizer)
Reduce impedance mismatch between db
and apps
Also easy to understand :)

41. Embedded
Reduce join
Better performance
Join itself (executer)
Query plan (optimizer)
Reduce impedance mismatch between db
and apps
Also easy to understand :)
but, still have to consider a lot ...

42. Things to be considered

43. Things to be considered
Document size limitation (16MB)

44. Things to be considered
Document size limitation (16MB)
Write / Read ratio

45. Things to be considered
Document size limitation (16MB)
Write / Read ratio
Type of query

46. Things to be considered
Document size limitation (16MB)
Write / Read ratio
Type of query
In-place update

47. Things to be considered
Document size limitation (16MB)
Write / Read ratio
Type of query
In-place update
etc.

48. More detail
Official : Schema design
http://www.mongodb.org/display/DOCS/Schema+Design
MongoDB Schema Design - MongoSF 2011
http://speakerdeck.com/u/kbanker/p/mongodb-schema-design-
mongosf-2011
MongoDB Schema Design : myNoSQL
http://nosql.mypopescu.com/post/907003504/mongodb-schema-
design
MongoDB Relation
http://d.hatena.ne.jp/masa_w/20101130/1291084939

49. More detail
Schema Design ?

50. Anyway,

51. Great Feature!

52. Wait!

53. I can!

54. Array
blog=# CREATE TABLE post (
id int
,title text
,postDate date
,tag text[]
,body text
);

55. Array
blog=# CREATE TABLE post (
id int
,title text Array of text
,postDate date
,tag text[]
,body text
);

56. Array
blog=# INSERT INTO post VALUES
(
1
,’ 4 Sugamo.vim ...’
,’2011/7/19’
,ARRAY[‘ ’, ‘vim’]
,’Sugamo.vim 7/19 ...’
);

57. Array
blog=# INSERT INTO post VALUES
(
1
,’ 4 Sugamo.vim ...’
Array literal
,’2011/7/19’
,ARRAY[‘ ’, ‘vim’]
,’Sugamo.vim 7/19 ...’
);

58. Array
blog=# SELECT tag FROM post
tag
--------------
{ ,vim}
(1 row)

59. has Array!
※SQL Standard (SQL99)

60. Difference

61. Difference
Dynamically typed
{
tag : [1, ‘two’, new Date()]
}

62. Difference
Dynamically typed
{
tag : [1, ‘two’, new Date()]
}
Statically typed
SELECT ARRAY[1, 2, 3]::int[]

63. Array utilities

64. Array to string
> db.post.findOne({tag:"vim"}).tag.join(',')
,vim

65. Array to string
blog=# SELECT array_to_string(tag, ',') FROM post;
array_to_string
-----------------
,vim
(1 row)

66. String to array
> db.post.findOne{tag:"vim"}).body.split(' ')
[ "Sugamo.vim", "7/19", "..." ]

67. String to array
blog=# SELECT string_to_array(body, ' ') FROM post;
string_to_array
----------------------
{Sugamo.vim,7/19,..}
(1 row)

68. array to row
blog=# SELECT unnest(body, ' ') FROM post;
unnest
--------
vim
(2 rows)

69. row to array
blog=# SELECT array_agg(v) FROM (
SELECT unnest(tag, ' ') v FROM post
) t;
array_agg
--------------
{ ,vim}
(1 row)

70. Indexing an array

71. Indexing
> db.post.ensureIndex({tag:1});
> db.post.find({tag:"vim"}).explain()
{
"isMultiKey" : true,
! "cursor" : "BtreeCursor
! "indexOnly" : false,
tag_1",
! "indexBounds" : {
! "nscanned" : 1,
! ! "tag" : [
! "nscannedObjects" : 1,
! ! ! [
! "n" : 1,
! ! ! ! "vim",
! "millis" : 0,
! ! ! ! "vim"
! "nYields" : 0,
! ! ! ]
! "nChunkSkips" : 0,
! ! ]
!
! }
}
http://www.slideshare.net/matsuou1/20110514-mongo-db

72. Indexing
blog=# CREATE INDEX on post USING gin(tag);
※Gin : Generalized Inverted Index

73. Indexing
blog=# set enable_seqscan = off;
blog=# EXPLAIN SELECT * FROM post WHERE tag @> ARRAY['vim']
QUERY PLAN
---------------------------------------------------------------------------
Bitmap Heap Scan on post (cost=4.26..8.27 rows=1 width=104)
Recheck Cond: (tag @> '{vim}'::text[])
-> Bitmap Index Scan on post_tag_idx (cost=0.00..4.26 rows=1 width=0)
Index Cond: (tag @> '{vim}'::text[])
(4 rows)

74. Both use
Inverted Index

75. Inverted Index
Data Index
T0 = "it is what it is", "a": {2}
T1 = "what is it", "banana": {2}
T2 = "it is a banana" "is": {0, 1, 2}
"it": {0, 1, 2}
"what": {0, 1}
http://ja.wikipedia.org/wiki/%E8%BB%A2%E7%BD%AE
%E3%82%A4%E3%83%B3%E3%83%87%E3%83%83%E3%82%AF%E3%82%B9

76. Inverted Index
Data Index
T0 = "it is what it is", "a": {2}
T1 = "what is it", "banana": {2}
T2 = "it is a banana" "is": {0, 1, 2}
"it": {0, 1, 2}
"what": {0, 1}
key
http://ja.wikipedia.org/wiki/%E8%BB%A2%E7%BD%AE
%E3%82%A4%E3%83%B3%E3%83%87%E3%83%83%E3%82%AF%E3%82%B9

77. Inverted Index
Data Index
T0 = "it is what it is", "a": {2}
T1 = "what is it", "banana": {2}
T2 = "it is a banana" "is": {0, 1, 2}
"it": {0, 1, 2}
"what": {0, 1}
posting list
key
/bucket
http://ja.wikipedia.org/wiki/%E8%BB%A2%E7%BD%AE
%E3%82%A4%E3%83%B3%E3%83%87%E3%83%83%E3%82%AF%E3%82%B9

78. Inner Structure
key tree

79. Inner Structure
posting tree
key tree
/bucket tree

80. Inner Structure
posting tree
key tree
/bucket tree
※ Wanted!
More precise info
at MongoReading :)

81. Aggregate

82. Map/Reduce
map = function() {
if (!this.tags) {
return;
}
for (index in this.tags) {
emit(this.tags[index], 1);
}
}
http://cookbook.mongodb.org/patterns/count_tags/

83. Map/Reduce
reduce = function(previous, current) {
var count = 0;
for (index in current) {
count += current[index];
}
return count;
}
http://cookbook.mongodb.org/patterns/count_tags/

84. Map/Reduce
> result = db.runCommand({
... "mapreduce" : "posts",
... "map" : map,
... "reduce" : reduce,
... "out" : "tags"})
> db.tags.find()
{ "_id" : "vim", "value" : 1 }
{ "_id" : " ", "value" : 1 }
http://cookbook.mongodb.org/patterns/count_tags/

85. Group By
blog=# SELECT tag, count(tag) FROM (
SELECT unnest(tag, ' ') tag FROM post
)t
GROUP BY tag;
tag | count
--------+-------
| 1
vim | 1
(2 rows)

86. Semi-structured

87. Object
> db.post.insert({
title: " 4 Sugamo.vim ..."
,postDate: new Date(2011, 6, 19)
,tag: [" ", "vim"]
,body: "Sugamo.vim 7/19 ..."
,comment: [
{
Object
name: “vimmer”
,comment: “vim is great!”
}
,{}...
]
})

88. Some choice

89. contrib/hstore
# SELECT ‘a => 1, b => 2’::hstore
"a"=>"1", "b"=>"2"
Type for group of (key => value)
Can be indexed with Gin/GiST
Can’t be nested ....

90. XML Type
<book>
<title> </title>
<author> </author>
<author> </author>
<publisher> </publisher>
</book>
http://lets.postgresql.jp/documents/tutorial/xml/1/

91. XML Type
testdb=# CREATE TABLE t_books(books xml);
testdb=# INSERT INTO t_books(books) VALUES('
testdb'# <book>
testdb'# <title> </title>
testdb'# <author> </author><author> </author>
testdb'# <publisher> </publisher>
testdb'# </book>
testdb'# ');
http://lets.postgresql.jp/documents/tutorial/xml/1/

92. XML Type
testdb=# SELECT
xpath('/book[author/text()=" "/title', books)
FROM
t_books;
xpath
---------------------------------------------
{<title> </title>}
(1 rows)
http://lets.postgresql.jp/documents/tutorial/xml/1/

93. XML Type
Access element with xpath()
Can be indexed with xpath/Functional Index
http://lets.postgresql.jp/documents/tutorial/xml/1/

94. JSON Type
Being implemented ...
9.2?

95. hardly get along with
relational model ...

96. Why Mongo?

97. The Scripting Language
of Databases
$m = new Mongo();
$m->test->formResults->insert($_POST);
print_r($m->test->formResults->findOne());
http://www.snailinaturtleneck.com/blog/2011/04/06/the-scripting-language-of-databases/

98. Philosophy
http://www.mongodb.org/display/DOCS/Philosophy

99. My Opinion
Use Mongo instead of ORM!
(or write SQL directly)
ORM 11
http://tech.a-listers.jp/2011/06/16/orm_is_an_antipattern/

100. Thank you !