Instalación: Descargar mongodb para windows

setear variable de entorno path y agragar ruta bin del mongo

Ejecutar en una consola de comandos:

1.- md \data
2.- md \data\db
3.- mongod

Abrir otra consola de comandos:

1.-mongo

Para importar data dump

mongorestore -d video -c reviews reviews.bson

importar JSON
mongoimport --db students --collection students --type json --file seed.json

1.-
-db.names.insert({'name':'Seba'});
WriteResult({ "nInserted" : 1 })
-db.names.find();
{ "_id" : ObjectId("57ff7f78cddc715f74d0b872"), "name" : "Seba" }

JSON
1.-Tipos de datos contemplados en JSON:
-Object
-Array
-String
-Number

**No soporta Date

BSON(Binary JSON)
Los datos que se transmiten entre el driver y la BD Mongo
-Ligeros
-Desplazable
-Eficiente

MONGO CRUD (Create, Read, Update, Delete)

-Los Documents se guardan en Collections
-show dbs (Muestra las bases de datos disponibles)
-use video (Crear o cambiar de BD a "video" en este caso)
-db.movies.insertOne({"title":"Jaws","year": 1975,"imdb":"tt0073195"})
-db.movies.insertOne({"title":"StartWars","year": 1980,"imdb":"tt0071111"})
-db.movies.find().pretty() (pretty muestra en orden los JSON)
-db.movies.find({}).pretty() (trae todos los objetos ya que no se le ha
especificado el filtro)
-db.movies.find({"title":"Jaws"}).pretty() (Se aplica filtro correspondiente)

crear objetos
-var c = db.movies.find()
-c.hasNext() (Valida si tiene valores)
-c.next() (Retorna el valor del primer valor encontrado)
Creando un Proyecto Maven
-mvn archetype:generate
-enter
-enter (opcion 6)
-nombre del package
-nombre del proyecto
-version (enter)
-package (enter)

Entrar a la carpeta del proyecto creado

Para ejecutar la clase por defecto del maven
mvn clean compile exec:java -Dexec.mainClass=com.mongodb.App

Utilizar un IDe para el proyecto

-importar jar
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>2.10.1</version>
</dependency>

Modeling Mongo Blog

[posts: {"title":"Free online Class","body":"asdsda","author":"seba","date":"13-10-

2016","comments":[{}]}]

Es imposible embedir data en un document cuando la data embedida excede los 16MB
(limite de mongo)

Week 2

CRUD(Create, read, update, delete)

--------------------------------------

db.moviesScratch.insertOne({"title":"Rocky","year":"1976","imdb":"tt0075145"})
{
"acknowledged" : true,
"insertedId" : ObjectId("5806570448549b6c8dc147d4")
}

//Se ve que devuelve el mismo _id (identificador unico del documento)

db.moviesScratch.find().pretty();
{
"_id" : ObjectId("5806570448549b6c8dc147d4"),
"title" : "Rocky",
"year" : "1976",
"imdb" : "tt0075145"
}

Vamos a insertar un valor al _id manualmente

db.moviesScratch.insertOne({"title":"Rocky","year":"1976","_id":"tt0075145"})
R: { "acknowledged" : true, "insertedId" : "tt0075145" }
Puedes tener documentos con la misma data, pero distinto objectId

Insertar multiples documentos

db.moviesScratch.insertMany(
[
{
"_id" : "tt0084726",
"title": "Star Trek II: The Wrath of Khan",
"year" : 1982,
"type" : "movie"
},
{
"_id" : "tt0084711",
"title": "Star Trek",
"year" : 2009,
"type" : "movie"
},
{
"_id" : "tt0084726",
"title": "Star Trek II: The Wrath of Khan",
"year" : 1982,
"type" : "movie"
},
{
"_id" : "tt0084101",
"title": "Star Trek Into Darkness",
"year" : 2013,
"type" : "movie"
},
{
"_id" : "tt0084731",
"title": "Star Trek First Contact",
"year" : 1996,
"type" : "movie"
}
]
);

db.moviesScratch.drop(); //limpiar documento

Insert many inserta documentos de arriba hacia abajo, hasta que se produzca el
error. Por ejemplo un _id duplicado

Ahora se realizara lo mismo

db.moviesScratch.insertMany(
[
{
"_id" : "tt0084726",
"title": "Star Trek II: The Wrath of Khan",
"year" : 1982,
"type" : "movie"
},
{
"_id" : "tt0084711",
"title": "Star Trek",
"year" : 2009,
"type" : "movie"
 },
{
"_id" : "tt0084726",
"title": "Star Trek II: The Wrath of Khan",
"year" : 1982,
"type" : "movie"
},
{
"_id" : "tt0084101",
"title": "Star Trek Into Darkness",
"year" : 2013,
"type" : "movie"
},
{
"_id" : "tt0084731",
"title": "Star Trek First Contact",
"year" : 1996,
"type" : "movie"
}
],
{
"ordered": false
}
);

Inserta todos los que pueda

Creating documents
-insertOne()
-insertMany()
-update Commands("upserts") Si existe hace update, si no insert

_id (ObjectId)
-----------------------
-Todas las colecciones tienen un _id unico
-por defecto el ObjectId se crea a partir de

ObjectId: DATE | MAC ADDR | PID | Counter

_ _ _ _ _ _ _ _ _ _ _ _
12-BYTE Hex String
(divididos en los bytes correspondientes (guines bajos))

Reading Documents
---------------------
-db.movieDetails.find({rated: "PG-13"}).count();
152
-db.movieDetails.find({rated: "PG-13", year: 2009}).count();
8
-db.movieDetails.find({"tomato.meter" : 100}).count();
34
-db.movieDetails.find({"tomato.meter" : 100}).pretty();

-db.movieDetails.find({tomato.meter : 100}).count();//SyntaxError
para acceder a variables detro de un objeto es necesario usar comillas al referirse
a la variable
-db.movieDetails.find({"tomato.meter" : 100}).count();//SyntaxError
Equality Matches on Arrays
----------------------------
-On the entire array
-Based on any element
-Based on a specific element
-More complex matches using operators (discussed in another lesson)

-db.movieDetails.find({"writers":["John Lasseter", "Andrew Stanton","Lee

Unkrich","Michael Arndt"]}).count()
1
El orden de la busqueda importa

Ahora invertimos el orden de los escritores

-db.movieDetails.find({"writers":["John Lasseter", "Andrew Stanton","Michael

Arndt","Lee Unkrich"]}).count()
0

-db.movieDetails.find({"actors":"Tom Hanks"}).pretty() (Devuelve datos

perfectamente)
4 datos
-db.movieDetails.find({"actors.1":"Tom Hanks"}).pretty() (Especifica la posicion en
la cual se deberia encontrar dentro del array)
2 datos

**********db.movieDetails.find({"countries.1":"Sweden"}).count()//buscar en
posicion

Equality Matches
-----------------
-Scalars
-Embedded Documents
-Arrays

-Cursors
-----------

var c = db.movieDetails.find();
var doc = function() { return c.hasNext() ? c.next() : null;}
c.objsLeftInBatch(); (Validar numero de objectos en la lista despues de los c.next)

doc() (muestra sgte object del array, si no existe muestra null como se especifico)
c.objsLeftInBatch(); devuelve cero al recorrer cada next del array

-Projection
---------------

-db.movieDetails.find({rated: "G"},{title:1}).pretty()
la consulta busca los titulos de todas las peliculas con rate "G" y que al menos
tengan 1 titulo
{ "_id" : ObjectId("5692a15524de1e0ce2dfcfa3"), "title" : "Toy Story 3" }
-db.movieDetails.find({rated: "G"},{title:1, _id: 0}).pretty()
El ObjectId siempre se devuelve por defecto, si uno lo quiere omitir puede usar
(_id:0)

-db.movieDetails.find({rated: "G"},{writers: 0, actors: 0, _id: 0}).pretty()

Si solo se excluyen datos, el resultado sera el objecto completo menos los
excluidos

***Solo se puede excluir e incluir al mismo tiempo si la exclusion es el _id

Comparison Operators
----------------------

-db.movieDetails.find({ runtime: { $gt: 90}}).pretty();

elementos con runtime mayor a 90

-db.movieDetails.find({ runtime: { $gt: 90, $lt: 120}}).pretty();

elementos con runtime mayor a 90 y menor que 120

-db.movieDetails.find({ runtime: { $gte: 90, $lte: 120}}).pretty();

elementos con runtime mayor o igual a 90 y menor o igual que 120

-db.movieDetails.find({ runtime: { $gte: 90, $lte: 120}}, {title: 1, runtime: 1,

_id: 0}).pretty();
esta es la sintaxis completa

-db.movieDetails.find({ "tomato.meter": { $gte: 90, $lte: 120}}, {title: 1,

runtime: 1, _id: 0}).pretty();

-db.movieDetails.find({ "tomato.meter": { $gte: 95}, runtime:{$gt: 100}}, {title:

1, runtime: 1, _id: 0}).pretty();

-db.movieDetails.find({rated:{$ne: "UNRATED"}}).count()

-db.movieDetails.find({rated:{$ne: "UNRATED"}},{title: 1, runtime: 1, _id:

0}).pretty()

-db.movieDetails.find({rated:{$in: ["G","PG"]}}).pretty()

Element Operators
------------------

$exists
-db.movieDetails.find({"tomato.meter" : { $exists : true }})
Devuelve el find si lo encuentra, no devuelve valores si no lo encuentra

$type
-db.moviesScratch.find({ "_id" : { $type: "number"}}).pretty()

-db.moviesScratch.find({ "_id" : { $type: "string"}}).pretty()

Logical Operators
-------------------------

$or (ó)
-db.movieDetails.find({ $or : [{ "tomato.meter" : { $gt: 100 }}, { "metacritic" :
{$gt : 88 }} ]}).pretty()

$and (y)
-db.movieDetails.find({ $and : [{ "tomato.meter" : { $gt: 90 }}, { "metacritic" :
{$gt : 80 }}]}).pretty()
-db.movieDetails.find({ $and : [{ "metacritic" : { $ne : null}},{ "metacritic" :
{ $exists : true }}]})

$not (no contiene)

$nor (devuelve todos los valores que no corresponden a la consulta)

Regex Operators
-------------------

-db.movieDetails.find({} , {"awards.text" : 1, _id: 0} ).pretty()

-db.movieDetails.find({ "awards.text" : { $regex : /^Won\s.*/}}).pretty()

//regex para filtrar por donde inicio con "Won"

-db.movieDetails.find({ "awards.text" : { $regex : /^Won\s.*/}},{ title:1, "awards"

: 1, _id : 0})

Array Operators
------------------------

$all
-db.movieDetails.find({ genres: { $all : [ "Animation" , "Adventure",
"Comedy"]}}).pretty()
//debe contener las 3 condiciones

$elemMatch
####db.moviesArrays.insert({boxOffice: [ { "country": "USA", "revenue": 41.3 },
{ "country": "Australia", "revenue": 2.9 },{ "country": "UK", "revenue": 10.1 },
{ "country": "Germany", "revenue": 4.3 },{ "country": "France", "revenue":
3.5 } ]})

-db.moviesArrays.find({ boxOffice : { country : "USA", revenue : {$lt : 100}}})

//no devuelve los datos necesarios
-db.moviesArrays.find({ boxOffice : { $elemMatch : { country : "USA", revenue :
{$lt : 100}}}}) //devuelve todos los documentos que cumplan todas las condiciones

$size
-db.movieDetails.find({ countries : { $size : 1 }}).pretty();
//devuelve todos los documentos donde exista un solo pais
Updating Documents
---------------------------
db.movieDetails.find().pretty();

updateOne:
-db.movieDetails.updateOne({ title : "Toy Story 3"}, { $set : { poster : "nueva
imagen"}})
-db.movieDetails.updateOne({ title : "Toy Story 3"}, { $set : { "tomato.meter" :
100}})
//solo actualizará el primero que encuentre dado el "criteria"

Otros tipos de Update:

$inc (incrementar)
-db.movieDetails.updateOne({ title : "Toy Story 3"}, { $inc : { "tomato.reviews" :
3, "tomato.userReviews" : 25}})

$addToSet
//agrega elementos a un array solo si no existen

$push (agregar elemento a un arreglo)

-each permite que se agrege a cada "pelicula del array", si no se pone each, se
agregara solo al primer elemento del array, este realiza $push y $addToSet(Si el
elemento existe no lo inserta)
-db.movieDetails.updateOne({title: "Toy Story 3"},
{$push: { reviews:
{ $each: [
{ rating: 0.5,
date: ISODate("2016-01-12T07:00:00Z"),
reviewer: "Yabo A.",
text: "comentario"},
{ rating: 5,
date: ISODate("2016-01-12T09:00:00Z"),
reviewer: "Kristina Z.",
text: "comentario"},
{ rating: 2.5,
date: ISODate("2015-10-26T04:00:00Z"),
reviewer: "Matthew Samuel",
text: "comentario"},
{ rating: 4.5,
date: ISODate("2015-12-13T03:00:00Z"),
reviewer: "Eugene B",
text: "comentario"},
{ rating: 4.5,
date: ISODate("2015-10-22T00:00:00Z"),
reviewer: "Jens S",
text: "comentario"},

{ rating: 4.5,
date: ISODate("2016-01-12T09:00:00Z"),
reviewer: "Spencer H.",
text: "comentario"} ] } } } )

$slice permite acortar el array al numero de slice asignado, y actualizar el primer

elemento que sea distinto, un slice negativo para comenzar de al final del array
-db.movieDetails.updateOne({ title: "Toy Story 3" },
{$push: { reviews:
{ $each: [
{ rating: 0.5,
date: ISODate("2016-01-13T07:00:00Z"),
reviewer: "Shannon B.",
text: "Enjoyed watching with my
kids!" } ],
$position: 0,
$slice: 5 } } } )

updateMany: Modifica todos los documentos que cumplan la condicion

-db.movieDetails.find({rated : null}).pretty()
-db.movieDetails.find({rated : "G"}).pretty()

-Actualiza todos los documentos que posean rated "g" por "UNRATED"
-db.movieDetails.updateMany( { rated: "G" },
{ $set : { rated: "UNRATED" } } )

// Could do this, but it's probably the wrong semantics.

db.movieDetails.updateMany( { rated: null },
{ $set : { rated: "UNRATED" } } )

// Better to do this.
db.movieDetails.updateMany( { rated: null },
{ $unset: { rated: "" } } )

replaceOne:

Upserts
----------------
Si el documento no es encontrado, se crea

var detail = {
"title" : "The Martian",
"year" : 2015,
"rated" : "PG-13",
"released" : ISODate("2015-10-02T04:00:00Z"),
"runtime" : 144,
"countries" : [
"USA",
"UK"
],
"genres" : [
"Adventure",
"Drama",
"Sci-Fi"
],
"director" : "Ridley Scott",
"writers" : [
"Drew Goddard",
"Andy Weir"
],
"actors" : [
"Matt Damon",
"Jessica Chastain",
"Kristen Wiig",
 "Jeff Daniels"
],
"plot" : "During a manned mission to Mars, Astronaut Mark Watney is presumed
dead after a fierce storm and left behind by his crew. But Watney has survived and
finds himself stranded and alone on the hostile planet. With only meager supplies,
he must draw upon his ingenuity, wit and spirit to subsist and find a way to signal
to Earth that he is alive.",
"poster" :
"http://ia.media-imdb.com/images/M/MV5BMTc2MTQ3MDA1Nl5BMl5BanBnXkFtZTgwODA3OTI4NjE@
._V1_SX300.jpg",
"imdb" : {
"id" : "tt3659388",
"rating" : 8.2,
"votes" : 187881
},
"tomato" : {
"meter" : 93,
"image" : "certified",
"rating" : 7.9,
"reviews" : 280,
"fresh" : 261,
"consensus" : "Smart, thrilling, and surprisingly funny, The Martian offers a
faithful adaptation of the bestselling book that brings out the best in leading man
Matt Damon and director Ridley Scott.",
"userMeter" : 92,
"userRating" : 4.3,
"userReviews" : 104999
},
"metacritic" : 80,
"awards" : {
"wins" : 8,
"nominations" : 14,
"text" : "Nominated for 3 Golden Globes. Another 8 wins & 14 nominations."
},
"type" : "movie"
};

//Actualiza cada pelicula que tenga el imdb igual al detail, y si no la crea

(upsert)
db.movieDetails.updateOne(
{"imdb.id": detail.imdb.id},
{$set: detail},
{upsert: true});

//replace one toma un filtro "imbd", e reemplaza el que encuentra, esto solo ocurre
si lo encuentra , si no no hace nada
db.movies.replaceOne(
{"imdb": detail.imdb.id},
detail);

Blog Internals
-------------------
view - ftl - freemarker

controller/model-java/spark

db.movieDetails.updateMany({{"imdb.votes":{$lt:10000}},{"year":{ $gt: 2010, $lt:

2013}},{"tomato.consensus":{$eq:null}}},
{$unset:{"tomato.consensus":1}})

MongoDB Schema Design

------------------------

-Application-driven schema (3ra forma normal)

*Rich Documents (mongo soporta documentos complejos)

*PreJoin/Embed Data
*No Mongo Joins
*No constraints
*Atomic Operations
*No declared Schema

Goals of Normalization
-------------------------
*Free the database of modification anomalies (actualizar el mail no implica que lo
vaya actualizar en todos los documentos)
*Minimize the redesign when extending the database
*Avoid bias toward a particular access pattern (evitar cualquier tendencia a un
patron de acceso de datos)

Atomic Operations (mongo no tiene transacciones) ACID

------------------------------------------------------
Restructure
implement software
tolerate

One to One Relations

---------------------
-Es mejor que los datos esten embedidos (todos en un documento) que hacer 2
documentos que se realicionen entre si, permite atomicidad de datos para funcionar
de forma transaccional

One to Many Relations

----------------------
-Requiere 2 collections para que no haya redundancia de datos

Many to Many Relations

-------------------------
-se hacen relaciones utilizando arrays dentro de los documentos involucrados
db.students.insertMany([
{"_id":0, "name":"Alumno 0", "teachers": [0,1]},
{"_id":1, "name":"Alumno 1", "teachers": [0,1,3]},
{"_id":2, "name":"Alumno 2", "teachers": [1,2,3]},
{"_id":3, "name":"Alumno 3", "teachers": [0,3]}
])

db.teachers.insertMany([
{"_id":0, "name":"Profe 0"},
{"_id":1, "name":"Profe 1"},
{"_id":2, "name":"Profe 2"},
{"_id":3, "name":"Profe 3"}
])

db.students.ensureIndex({'teachers':1})

db.students.find({'teachers':{$all:[0,1]}})

que es una ODM

---------------
ODM permite la comunicacion entre una aplicacion y el Mongo java driver

lazy permite dejar una propiedas en demanda, no se llenara hasta que se llame el
primer getter