Mandango al descubierto

Mandango
al descubierto
Pablo Díez
1ª Meetup Symfony Madrid - 26 de marzo de 2011

sábado 26 de marzo de 2011

¿MongoDB?


humongous


NOSQL

• No SQL Not Only SQL
• Necesidades de rendimiento
• Especialmente webs
• Gran cantidad de datos
• Gran cantidad de lecturas y escrituras


MongoDB
• Alto rendimiento
• Escalable
• Orientada a documentos
• Esquema libre
• Extremadamente sencilla
• Índices
• Código abierto
• Continua evolución


MongoDB es la base de datos NOSQL más
similar en conceptos a las SQL


Base de datos == Base de datos
Tabla == Colección
Registro ~= Documento


Documentos
Simplemente datos representados en JSON


{
username: pablodip,
email: pablodip@gmail.com
}


Documentos
En arrays en PHP


array(
'username' => 'pablodip',
'email' => 'pablodip@gmail.com',
)


Documentos embebidos
Documentos dentro de otros documentos


array(
'profile' => array(
'first_name' => 'Pablo',
'last_name' => 'Díez',
),
)


array(
'title' => 'MongoDB Rocks!',
'content' => 'blah blah blah',
'tags' => array('mongodb', 'databases'),
'comments' => array(
array(
'name' => 'pablodip',
'text' => 'blah',
),
array(
'name' => 'barbelith',
'text' => 'blah',
),
),
)


Al vuelo
Las bases de datos y colecciones se crean
automáticamente la primera vez que se usan


$mongo = new Mongo('mongodb://localhost:27017');
$database = $mongo->selectDatabase('symfony2');
$collection = $database->selectCollection('user');


Esquema libre
Cada documento puede usar los campos que quiera
incluso en la misma colección


array(
'city' => 'Zamora',
'odm' => 'Mandango',
)

array(
'username' => 'barbelith',
'country' => 'Valladolid',
'database' => 'book',
'phones' => array('806XXX', '902XXX')
)


Sencillo
Guardar arrays, consultar arrays


$pablodip = array(
);
$collection->save($pablodip);


$criteria = array(
'username' => 'pablodip'
);
$pablodip = $collection->findOne($criteria);

$pablodip['city'] = 'Zamora';
$collection->save($pablodip);


Sencillo
Consultas realmente sencillas


// SELECT * FROM article
$articles = $db->article->find();

// SELECT * FROM article WHERE is_active="true"
$articles = $db->article->find(array('is_active' => true));

// SELECT id, title FROM article WHERE author='pablodip'
$criteria = array('author' => 'pablodip');
$fields = array('_id' => 1, 'title' => 1);
$articles = $db->article->find($criteria, $fields);


// SELECT * FROM article ORDER BY date ASC
$articles = $db->article->find()->sort(array('date' => 1));
// DESC
$articles = $db->article->find()->sort(array('date' => -1));

// SELECT * FROM article LIMIT 10, 2
$articles = $db->article->find()->limit(10)->skip(2);


// un resultado
$article = $db->article->findOne();

// criteria, fields
$article = $db->article->findOne($criteria, $fields);


Actualizaciones parciales
Muy eﬁcientes


$criteria = array('username' => 'pablodip');
$update = array('$set' => array('city' => 'Oxford'));
$db->article->update($criteria, $update);


Conclusiones
• MongoDB es una base de datos ultrarápida
• MongoDB comparte muchos conceptos con bases
de datos relacionales
• MongoDB es extremadamente sencilla de usar
• Creación de bases de datos y colecciones al
vuelo
• Esquema libre (sin migraciones)
• Consultas sencillas


MongoDB -

• Sin integridad referencial
• Transacciones sólo a nivel de documento


Puedes usar MongoDB en cualquier proyecto,
simplemente si necesitas integridad referencial o
transacciones a nivel de colección o base de datos
necesitas combinarla con una base de datos relacional.


¡Pero queremos objetos!


ODM
Object Document Mapper


DoctrineMongo

¿Ein?

Mondongo...


Demasiados Mondongos por Google y
Twitter ;)


¡Mejor
Mandangos!

Mandango es a los ODMs lo que
MongoDB a las bases de datos


Mandango
• Sencillo
• Fácil de usar
• Potente
• Referencias, embebidos, relaciones
• Unit of Work
• Sistema de Queries
• Behaviors, índices, eventos
• ...
• Ultrarápido

Fácil de usar
Mismos conceptos que cualquier mapeador.
Sin magia, todo el código es generado.
Autocompletado IDE +


$article = new Article();
$article->setTitle('foo');
$article->setContent('bar');
$article->save();


Fácil de usar
Interfaz ﬂuida


$article = Article::create()
->setTitle('foo')
->setContent('bar')
->save()
;


Fácil de usar
Sencillo uso de namespaces.
Convención: Model...


$mandango = ModelArticle::mandango();
$repository = ModelArticle::repository();
$query = ModelArticle::query();
$article = ModelArticle::find($id);
$collection = ModelArticle::collection();


Referencia, embebidos
Automáticamente; embebidos profundos


// references one
$article->setAuthor($author);
$author = $article->getAuthor();

// references many
$article->getCategories()->add($category);
$article->getCategories()->remove($category);
$categories = $article->getCategories()->saved();
foreach ($article->getCategories()) {
// ...
}


// embeddeds one
$article->setSource($source);
$source = $article->getSource();

// embeddeds many
$article->getComments()->add($comment);
$article->getComments()->remove($comment);
$comments = $article->getComments()->saved();
foreach ($article->getComments() as $comment) {
// ...
}


Unit of Work
¡Todo a la vez!


$article = ModelArticle::create()->setTitle('foo');
$mandango->persist($article);

$author = ModelAuthor::create()->setName('bar');
$mandango->persist($author);

$user = ModelUser::query()->one();
$mandango->remove($user);

$category = ModelCategory::query()->one();
$category->setName('foobar');
$mandango->persist($category);

// todo es enviado a la base de datos aquí
$mandango->flush();


Sistema (simple) de Queries
Orientado a objetos.
Mismos conceptos que Mongo.


$query = ModelArticle::query();

$query
->criteria($criteria)
->field($fields)
->sort($sort)
->limit($limit)
->skip($skip)
;

$query = ModelArticle::query($criteria);


Perezoso

No consulta a la base de datos
hasta que no se necesita.


// lógica SIN consultar la base de datos
$query = ModelArticle::query($criteria);

if ($sort) {
$query->sort($sort);
}

if ($limit) {
$query->limit($limit);
}


/*
* Consulta a la base de datos.
*/

// todos
$articles = $query->all();
foreach ($query as $article) {
// ...
}

// uno
$article->one();

// contar
$articles->count();


Referencias


MongoDB no tiene Joins

$query->joins(array('author' => 1));


¿Tenemos que hacer una consulta
por referencia entonces?

$article1->getAuthor();
$article2->getAuthor();
// ...


$in

Mandango consulta los documentos
referenciados en una sola query.

$query->references(array('author'));


En referencias a uno y a muchos.

$query->references(array(
'author',
'categories',
));


Campos


$query->fields(array());

Consultar todos los campos de los
documentos es muy lento para la
base de datos y los objetos (hydrate!),
sobre todo con documentos y campos
grandes.


$query->fields(array(
'title' => 1,
'content' => 1,
));

Seleccionar todos los campos que se
usan en todos los sitios es cansado.


$article->getUser()->getUsername();

En las referencias es imposible.


$firstName = $user->getProfile()->getFirstName();
$comments = $article->getComments();

En los embebidos es incluso peor.


$article = ModelArticle::find($id);
$article->delete();

Y quizás no necesitemos ningún campo.


¿Soluciones?
• Usar documentos más pequeños
• Perdemos potencia del esquema libre
• Usar menos embebidos
• Perdemos potencia de usar documentos
• Tener moral y seleccionar a mano todos los
campos que se usan.
• Pff...
• O...


Mandango
Query Fields Cache


Consulta sólo lo que
usas
automáticamente


$article = ModelArticle::query()->one();

// fields
array(
'_id' => 1,
);


$article->getTitle();
$article->getContent();

// fields
array(
'_id' => 1,
'title' => 1,
'content' => 1,
);


$article->getAuthor()->getName();

// article fields
array(
'_id' => 1,

);
'title' => 1,
Referencias
// author fields
array(
'_id' => 1,
'name' => 1,
);


$article->getSource()->getUrl();

// article fields
array(
'_id' => 1, Embebidos
'title' => 1,
'source.url' => 1,
);


Se acabó el preocuparse
por el tamaño de los
documentos


¿Cómo?
Mandango por defecto no consulta ningún campo.

Consulta perezosamente la primera vez, y guarda los
campos que usas en cache para consultarlos a partir de
la segunda petición.

No importa si cambias el código y usas más campos, se
van añadiendo.


¿Killer feature?
Yo sólo se que es extremadamente eﬁciente ;)


¿Cuán rápido es Mandango
entonces?


3-4x comparado con
DoctrineMongo
en casos normales


50

37.5
Time (ms)

25
Mandango
DoctrineMongo

12.5

0
Insert Update Delete Hydrate

4-5-6-7-8-+x en casos de
usar pocos campos en
documentos complejos


Y además usa 2-3x menos
de memoria ;)


sfMandangoPlugin


MandangoBundle


¿Preguntas?


Mandango al descubierto

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Empfohlen

Empfohlen (20)

Mandango al descubierto