Mongo DB on the JVM - Brendan McAdams

MongoDB + the JVM
Integrating NoSQL with the JVM
Brendan McAdams
10gen, Inc.
brendan@10gen.com
@rit

Tuesday, October 16, 12

Let’s Face It ...

SQL Sucks.


Let’s Face It ...

SQL Sucks.

For some problems at least.


Stuffing an object graph into a relational model is
like fitting a square peg into a round hole.


Stuffing an object graph into a relational model is
like fitting a square peg into a round hole.

Databases should simplify application development - they
should present a model that fits naturally with our code


MongoDB as a Database



• MongoDB is designed to fit your application



• Flexible



• Flexible
• Fast



• Flexible
• Fast
• Sane



• Two crucial core concepts




• Document Oriented Data





• Scalability



• Instead of flat row structures, “document oriented”
data (similar to JSON)



• Instead of flat row structures, “document oriented”
data (similar to JSON)
• Rich: Embed other documents and arrays as values


Rich Documents Represent MongoDB Data

{
“title”: “Programming Erlang: Software for a Concurrent World”,
“author”: “Joe Armstrong”,
“publicationYear”: 2007,
“publisher”: “The Pragmatic Programmers, LLC”,
}



{
}

Like JSON , MongoDB Documents are made up of key and
value pairs.



{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
}
Values can be complex, such as embedded subdocuments...


{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“concurrent programming”,
“multicore”,
“programming”
]
Or even arrays!
}


Querying with MongoDB



• Querying in MongoDB is similar to a ‘query by example’
interface



interface

• Finding items by exact match via “key” = “value”



interface

• Finding items by exact match via “key” = “value”

• Built-in Query Expressions for more advanced
statements


Querying With MongoDB
> db.books.find({“author”: “Joe Armstrong”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
}


> db.books.find({“author”: “Joe Armstrong”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
}
Basic queries consist of “key” = “value”


> db.books.find({“price.currency”: “USD”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
}


> db.books.find({“price.currency”: “USD”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
} Embedded docs can be accessed by
“key.subkey” = “value”


> db.books.find({“tags”: “multicore”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
}


> db.books.find({“tags”: “multicore”})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
} Embedded arrays can be accessed by
matching just a single value from the array


> db.books.find({“price.discount”: {$lt: 25.00}})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
}


> db.books.find({“price.discount”: {$lt: 25.00}})
{
“price”: {
"currency": "USD",
"discount": 24.14,
"msrp": 36.95
},
“tags”: [
“erlang”,
“multicore”,
“programming”
]
} Finally, MongoDB provides a set of query expressions for
concepts such as greater than, less than, etc.



• Scalability



• Scalability
• Database should grow and scale with our application



• Scalability
• Replica Sets: Robust, modernized Replication Model with
automatic failover



• Scalability
• Replica Sets: Robust, modernized Replication Model with
automatic failover
• Sharding: n-scalable horizontal partitioning with automatic
management


MongoDB on the JVM


MongoDB on the JVM

• MongoDB has strong, wide support on the JVM


MongoDB on the JVM

• Java


MongoDB on the JVM

• Java
• Scala


MongoDB on the JVM

• Java
• Scala
• Hadoop


MongoDB on the JVM

• Java
• Scala
• Hadoop
• Also, fantastic work occurring in Clojure community
(see Monger - http://clojuremongodb.info/ )


MongoDB + Java


MongoDB + Java

• Java + MongoDB


MongoDB + Java

• Java + MongoDB
• “Core” MongoDB Driver (mongo-java-driver)


MongoDB + Java

• Java + MongoDB
• Manipulate MongoDB Docs as Map-like structures


MongoDB + Java

• Java + MongoDB
• “Object Document Mapping” (like Hibernate, but less
painful)


MongoDB + Java

• Java + MongoDB
painful)
• Morphia


MongoDB + Java

• Java + MongoDB
painful)
• Morphia
• Map domain objects to MongoDB with JPA-like
annotations


MongoDB + Java

• Java + MongoDB
painful)
• Morphia
annotations
• Spring Data


MongoDB + Java

• Java + MongoDB
painful)
• Morphia
annotations
• Spring Data
• Spring ODM for many NoSQL databases, supports
MongoDB


MongoDB + Java

• Java + MongoDB
painful)
• Morphia
annotations
• Spring Data
• Spring ODM for many NoSQL databases, supports
MongoDB
• GA Release announced today


Core MongoDB + Java


Core MongoDB + Java
The Mongo class represents a connection pool

com.mongodb.Mongo m = new Mongo();


Core MongoDB + Java


The DB class represents a Database context

com.mongodb.DB db = m.getDB( "bookstore" );


Core MongoDB + Java


The DB class represents a Database context

com.mongodb.DB db = m.getDB( "bookstore" );

The DBCollection class represents a Collection
(Mongo’s version of a table) handle

com.mongodb.DBCollection coll = db.getCollection( "books" );


Core MongoDB + Java
Documents are represented by DBObject

com.mongodb.DBObject q = new BasicDBObject();
q.put( “tag”, “scala” );
q.put( “price”, new BasicDBObject( “$lt”, 40.00 ) );


Core MongoDB + Java
Documents are represented by DBObject

com.mongodb.DBObject q = new BasicDBObject();
q.put( “tag”, “scala” );
q.put( “price”, new BasicDBObject( “$lt”, 40.00 ) );

Queries return a DBCursor, which is both
Iterator<DBObject> and Iterable<DBObject>

for ( DBObject doc : coll.find( q ) ) {
// ...
}


Core MongoDB + Java

There is also a QueryBuilder helper class for
querying

DBObject q = QueryBuilder.start( “price” ).lessThan( 40.00 ).
and( “tag” ).is( “scala” ).get();


Core MongoDB + Java

There is also a QueryBuilder helper class for
querying

DBObject q = QueryBuilder.start( “price” ).lessThan( 40.00 ).
and( “tag” ).is( “scala” ).get();

If you don’t fancy doing everything by hand, you
can use tools like Morphia to map domain objects
automatically...


Object Mapping Java via Morphia


Morphia uses JPA-like Annotations to mark up
domain objects for MongoDB persistence

@Entity("books") // Book classes persist to / from “books”
class Book {}



class Book {}
Any field can be tagged as the primary key via the
@Id annotation

@Id private ObjectId id;



class Book {}
Any field can be tagged as the primary key via the
@Id annotation

@Id private ObjectId id;

List fields are automatically persisted as
MongoDB arrays

private List<String> tags = new ArrayList<String>();


Complex sub-objects can be marked to either
“embed” or “reference” automatically

/**
* Could also use "reference", which are stored to
* their own collection and loaded automatically
*
* Morphia uses the field name for where to store the value,
*/
@Embedded private Price price;


Complex sub-objects can be marked to either
“embed” or “reference” automatically

/**
* Could also use "reference", which are stored to
* their own collection and loaded automatically
*
* Morphia uses the field name for where to store the value,
*/
@Embedded private Price price;

It’s trivial to name a field one thing in MongoDB
and another in our Morphia model

/**
* Can rename a field for how stored in MongoDB
*/
@Property("publicationYear") private int year;


MongoDB + Scala


MongoDB + Scala
• Scala + MongoDB


MongoDB + Scala
• Scala + MongoDB
• “Core” MongoDB Driver (casbah)


MongoDB + Scala
• Scala + MongoDB
•Wraps the Java driver, provides strong Scala API


MongoDB + Scala
• Scala + MongoDB
•Documents manipulated in a 2.8+ collections Map structure including
Builder, Factory and CanBuildFrom


MongoDB + Scala
• Scala + MongoDB
•ODMs


MongoDB + Scala
• Scala + MongoDB
•ODMs
• Salat - Case class mapping with some optional annotations, very
fast and lightweight


MongoDB + Scala
• Scala + MongoDB
•ODMs
• Lift - Popular Scala web framework includes a MongoDB ODM
layer based on the ActiveRecord pattern


MongoDB + Scala
• Scala + MongoDB
•ODMs
•Next-Generation Drivers (async focus) [Pure rewrites of driver]


MongoDB + Scala
• Scala + MongoDB
•ODMs
• Hammersmith - my pet project, Netty + Akka.IO interfaces, strongly
functional and callback based


MongoDB + Scala
• Scala + MongoDB
•ODMs
• Hammersmith - my pet project, Netty + Akka.IO interfaces, strongly
functional and callback based
• ReactiveMongo - from the amazing team @ Zenexity who brought us
the Play! Framework - new, but very promising


Basic MongoDB + Scala via Casbah


Casbah’s version of a Document is
MongoDBObject, which is a full Scala MapLike
collection

case class Book(id: ObjectId, author: Seq[Author], isbn: String,
price: Price, publicationYear: Int, tags: Seq[String],
title: String, publisher: String, edition: Option[String]) {

def toDBObject = MongoDBObject(
"author" -> author.map { a => a.name },
"_id" -> id,
"isbn" -> isbn,
"price" -> price.toDBObject,
"publicationYear" -> publicationYear,
"tags" -> tags,
"title" -> title,
"publisher" -> publisher,
"edition" -> edition
)

}


Because it is a full Collection implementation,
construction Builder style is easy as well
val b = MongoDBObject.newBuilder
b += "foo" -> "bar"
b += "x" -> 5
b += "map" -> Map("spam" -> 8.2, "eggs" -> "bacon")
val dbObj = b.result


Because it is a full Collection implementation,
construction Builder style is easy as well
val b = MongoDBObject.newBuilder
b += "foo" -> "bar"
b += "x" -> 5
b += "map" -> Map("spam" -> 8.2, "eggs" -> "bacon")
val dbObj = b.result

It’s even easy to start with a blank DBObject

val dbObj = MongoDBObject.empty

dbObj must beDBObject
dbObj must have size (0)


While Casbah wraps the Java Driver for the
Mongo protocol, its API aims to be as Scala pure
as possible

val mongo: MongoCollection = MongoConnection()("bookstore")("books")


While Casbah wraps the Java Driver for the
Mongo protocol, its API aims to be as Scala pure
as possible

val mongo: MongoCollection = MongoConnection()("bookstore")("books")

Casbah’s Cursors can easily be iterated in
standard Scala style

def findAll() = for ( book <- mongo.find() ) yield newBook(book)

findAll().foreach(b => println("<Book> " + b))


Leveraging Scala’s great support for composable
DSLs, Casbah provides a Query DSL that feels
natural to a MongoDB user...

val q: DBObject = ("price" $lt 40.00) ++ ("tag" -> "scala")


Leveraging Scala’s great support for composable
DSLs, Casbah provides a Query DSL that feels
natural to a MongoDB user...

val q: DBObject = ("price" $lt 40.00) ++ ("tag" -> "scala")

Like with Java, the Scala MongoDB Community
has created a few ways of mapping Objects as
well...


Object Mapping in Scala via Lift



Lift uses an ActiveRecord style API for mapping
MongoDB + Scala

class Book private() extends BsonRecord[Book] with ObjectIdPk[Book]
{ }


Fields in Lift-Mongo are declared as objects
implementing a special typed trait.

object isbn extends StringField(this, 64)




Fields can be declared optional by overriding a
trait attribute

object edition extends StringField(this, 32) {
override def optional_? = true
}




Fields can be declared optional by overriding a
trait attribute

object edition extends StringField(this, 32) {
override def optional_? = true
}

And Lists can be automatically handled via a
MongoListField
object author extends MongoListField[Book, String](this)


Embedding objects represented by another entity
is easy as well
object price extends BsonRecordField(this, Price)

class Price private() extends BsonRecord[Price] {
// ...
object currency extends StringField(this, 3)
object discount extends DoubleField(this)
object msrp extends DoubleField(this)
}


Embedding objects represented by another entity
is easy as well
object price extends BsonRecordField(this, Price)

class Price private() extends BsonRecord[Price] {
// ...
object currency extends StringField(this, 3)
object discount extends DoubleField(this)
object msrp extends DoubleField(this)
}

To make working with Lift + MongoDB as easy as
possible, Foursquare has created a fantastic
Query DSL called Rogue:
https://github.com/foursquare/rogue



The downside to Lift is the need to use specially
structured objects. For those who want a less
formal API, Salat makes it easy...


Object Mapping in Scala via Salat


Salat uses Scala’s case classes as the core of
their model (immutability is good!)
case class Book(id: ObjectId, author: Seq[Author], isbn: String,
price: Price, publicationYear: Int, tags: Seq[String],
title: String, publisher: String, edition: Option[String])

case class Author(name: String)

case class Price(currency: String, discount: Double, msrp: Double)

val authors = Seq( Author("Timothy Perrett") )
val price = Price("USD", 39.99, 39.99)

val tags = Seq("functional programming", "scala",
"web development", "lift", "#legendofklang")

val liftInAction = Book(new ObjectId, authors, "9781935182801",
price, 2011, tags,
"Lift in Action",
"Manning Publications Co.", Some("First"))


Persistence is made simple (through Scala
reflection) via the Grater object
/**
* The Salat Grater uses runtime Scala type reflection to
* generate a MongoDB Object.
*/
val dbo = grater[Book].asDBObject(liftInAction)

mongo.save(dbo)


Persistence is made simple (through Scala
reflection) via the Grater object
/**
* The Salat Grater uses runtime Scala type reflection to
* generate a MongoDB Object.
*/
val dbo = grater[Book].asDBObject(liftInAction)

mongo.save(dbo)

Some annotations are available to mark indexed
fields, etc but the core ideas in Salat are elegantly
simple


MongoDB + Clojure


MongoDB + Clojure

• Clojure + MongoDB


MongoDB + Clojure

• “Core” MongoDB Driver (monger)


MongoDB + Clojure

• Fairly new, similarities to Casbah, including a “native”
Query API


MongoDB + Clojure

Query API
• Not officially supported


MongoDB + Clojure

Query API
• Not officially supported
• The Monger team was nice enough to share some
snippets (my Clojure is a bit rusty)...


Basic MongoDB + Clojure via Monger


Basic MongoDB + Clojure via Monger
Monger’s version of a Document is a simple
Clojure data structure

A Query API similar to Casbah’s is supported, and
very fluid

(monger.collection/find-maps collection {:price.discount {$lt 25.00}})

(monger.collection/update "things" { :_id oid } { $set { :weight 20.5 } })


MongoDB + Hadoop


MongoDB + Hadoop
• Hadoop + MongoDB


MongoDB + Hadoop
• Hadoop integration with MongoDB is one of my key projects
at 10gen


MongoDB + Hadoop
at 10gen
• Feed MongoDB data directly (“live”) into MapReduce jobs & save
MapReduce results directly to MongoDB


MongoDB + Hadoop
at 10gen
• Coming Soon: Read/Write “archived BSON” (basically, MongoDB
Backup Files)


MongoDB + Hadoop
at 10gen
Backup Files)
• Support for “Core MapReduce” as well as the wider Hadoop
ecosystem


MongoDB + Hadoop
at 10gen
Backup Files)
ecosystem
• Pig


MongoDB + Hadoop
at 10gen
Backup Files)
ecosystem
• Pig
• Streaming


MongoDB + Hadoop
at 10gen
Backup Files)
ecosystem
• Pig
• Streaming
• Hive & Scoobi (coming soon)


MongoDB + Hadoop
at 10gen
Backup Files)
ecosystem
• Pig
• Streaming
• Hive & Scoobi (coming soon)
• See http://api.mongodb.org/hadoop to learn more


[Want to Know More About MongoDB?]
Free Online Classes, Starting in October!
http://education.10gen.com

[Docs]
http://mongodb.org
http://api.mongodb.org/

*Contact Me*
brendan@10gen.com
(twitter: @rit)


Mongo DB on the JVM - Brendan McAdams

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Mongo DB on the JVM - Brendan McAdams

Ähnlich wie Mongo DB on the JVM - Brendan McAdams (20)

Mehr von JAX London

Mehr von JAX London (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Mongo DB on the JVM - Brendan McAdams