MongoDB. copyright 2011 Trainologic LTD

Transcription

1 MongoDB

2 MongoDB MongoDB is a document-based open-source DB. Developed and supported by 10gen. MongoDB is written in C++. The name originated from the word: humongous. Is used in production at: Disney, FourSquare, SAP, SourceForge, NY Times and many more ( yments). 2

3 Main Features MongoDB s main features are: Documents are stored in Rich querying syntax. BSON (a binary JSON-like In-place updates. format). Support for Map-Reduce. Can create an index for any GridFS for file storage. document attribute (just like ole RDBMS). High-availability by replication. Automated Sharding (partitioning). 3

4 BSON BSON is the binary format for the documents in MongoDB. Clients will generally use the JSON syntax and it will be converted to the BSON format. BSON provides some extended data-types that are not supported in JSON (e.g., timestamp, regex). BSON adds indexing data to the serialized format to provide fast decoding and traversal. Note that BSON documents will, in many cases, be slightly larger than the corresponding JSON docs. 4

5 Schema Design There are no joins in MongoDB. So, if you have two(or more) related documents, you can either embed or link. This is a very important decision. Let s discuss it 5

6 Embedding vs. Linking Embedding a document means that you will provide its data within another document. Like a pre-join. MongoDB provides rich nested documents query syntax so you can access the embedded document with ease. Linking a document means that we store a reference in one document to another. The client must use a follow-up query for retrieving the linked document. 6

7 Collections A collection in MongoDB is like a table in an RDBMS. Usually, documents in a collection will have the same structure. However, this is not mandatory. Collections are schema-less and new fields can be introduced without any alter table cost. 7

8 ACID Operations MongoDB doesn t provide ACID transactions. However, atomic operations are supported on a single document. This is relevant to the schema design, as we need to synchronize between out document structure and our atomic operations. 8

9 Sharding A document in MongoDB will reside only on one shard! However, collections can be sharded according to a shard key. Choosing the right shard key is very important from performance and scaling POV. Altering the shard key later, is very difficult (need to dump the DB and re-import it). 9

10 Hello World Let s see how to work with MongoDB. Although there are drivers for many languages, we will use in our examples the interactive shell. Here is an example of inserting a document to the messages collection: > db.messages.insert( { msg:"hello World" } ) > db.messages.findone() { "_id" : ObjectId("4f0e05fdee21df3d666c5131"), "msg" : "Hello World" }

11 Discussion As you can see, MongoDB added an _id field to our document. This is a mandatory field (which is generated if absent) that serve as the unique object key. Can be of almost any type (prefer immutable natural primary key if exists). The BSON ObjectId type is used by default and is automatically generated based on the combination of: time, machine, pid and counter

12 Indexing Creating an index is done with the ensureindex() function. Example: > db.messages.ensureindex( {msg:1}) > db.messages.getindexes() [ { "v" : 1, "key" : {"_id" : 1 }, "ns" : "test.messages", "name" : "_id_" }, {"v" : 1, "key" : { "msg" : 1 },"ns" : "test.messages", "name" : "msg_1" } ]

13 Discussion We created an index on the msg field with direction ascending (doesn t matter for single field indexes). Note that there is an automatic index on the _id field. Now, find operations by the msg field will perform very fast. Remember that indexes provide logarithmic-based scale up. Indexes in MongoDB are case-sensitive

14 Index Properties When creating an index, you can provide a second document parameter for configuring index properties. The supported properties are: background should the index be created in the background (has problems with replicas). unique should the index enforce uniqueness. dropdups whether documents with duplicate index value will be dropped. sparse the index will not contain documents missing this index fields

15 Removing an Index You can use the dropindex or dropindexes commands to remove indexes. Example: > db.messages.dropindex( {msg:1}) { "nindexeswas" : 2, "ok" : 1 }

16 Querying Querying in MongoDB is done by the find method. You can provide a selector for document matching. The empty selector will match every document. Example: > db.messages.find() { "_id" : ObjectId("4f0e05fdee21df3d666c5131"), "msg" : "Hello World" }

17 Cursors Actually, a find() invocation returns a DB cursor. The cursor can be iterated to retrieve the result. Many MongoDB drivers (including Java) provide the toarray() method that will load the results into the memory. Use with care as it can cause OOME on large result-sets. Note that in the Java driver, the method length() also loads all the results into an array

18 Selectors You can provide a selector to the find() method. The selector will match document according to the provided properties. E.g.: db.messages.find({msg: "Hello World"}) { "_id" : ObjectId("4f0e05fdee21df3d666c5131"), "msg" : "Hello World" } { "_id" : ObjectId("4f0eeac d2159"), "msg" : "Hello World", "x" : "y" } >

19 Availability MongoDB provides high-availability and fail-over through its Replica-Set feature. A replica set contains several MongoDB nodes which are replicas (copies). In a replica set, only one node is available to write. The MongoDB drivers will automatically recognize and be aware to the write node

20 When to Use You should use a replica set for one or more of the following reasons: Redundancy (have copies for your data). High availability. Distributed read operations

21 Distributed Reads By default, the primary node in a replica set is the node used for read and write operations. Although in MongoDB only one node (primary) is used for write operations, you can configure the clients to use secondary nodes for reads. Done with the slaveokay() method. Let s see how to create a replica set

22 Arbiters There should be an odd number of nodes in a replica set (for primary election votes). If you have an even number of nodes, introduce an arbiter node (as opposed to a full node) for voting purposes. An arbiter node doesn t have a replica of the data and can t serve as a primary or secondary slave for reading

23 Creating a Replica Set When you start the node (with the mongod process) provide the following command line options: --rest to provide rest interface (default is port 28017). --replset name to define the replica set name (should be the same for all nodes). If starting a the same machine (usually for demo), provide the --port and --dbpath arguments to differ from already running processes

24 Initialize You should now connect to one node in the set and perform rs.initiate(). This command make the existing data on the node the initial data on the replica set. Adding nodes to the set is done with rs.add() command. Adding an arbiter is done with the rs.addarb() command. These command take a host:optional port parameter

25 Journaling On 64-bit platform, mongodb is using journaling by default. Journaling means that a write operation is being logged into a redo log. This provides fast crash recovery and durability. You can enable/disable it by using --journal/--nojournal respectively

26 getlasterror By default, write operations do not return a status code. They return immediately. If you want to make sure that the write operation has been replicated, you can use the getlasterror command for checking on the status. You should use it only for critical writes, as it incurs blocking on the connection

27 Sharding MongoDB Sharding provides horizontal scalability through partitioning. Sharding means that the MongoDB collection is split between different shards according to a shard key. Choosing the shard key is one of the most important aspects of schema design

28 Shard Key A sharded collection is made of chunks. A chunk is a continuous range on a shard key. When a chunk reaches a predefined limit (by default 64mb) it is split and the chunks will be re-arrange in the shards. Beware of choosing a shard key that will result in very large chunks. It will make the chunk migration between the shards to work very slow

29 Chunk Information A chunk in a collection has the min_key and max_key properties associated with it. Chunk meta-data is stored in Config DB processes which hold the complete chunk information. When chunks are re-distributed, the config processes are updated in a 2 phase commit. If a config server process has failed. The cluster will not distribute the chunks until it is up again

30 Operations A query that includes the shard key will target a small amount of servers (often a single server). Same for update/remove