Algunos métodos CRUD que son necesarios conocer con MongoDB


MongoDB Stickers and Mug Siguiendo con el post anterior de MongoDB sobre Mis primeros pasos con MongoDB utilizando NodeJS, en esta ocasión vamos a ver algunos aspectos que nos vendrán bien para conocer bien por dónde debemos ir pasando para conseguir los datos de nuestros documentos. Vemos algunos cosas interesantes con respecto a la consola que nos proporciona mongo de la que vamos a poder interactuar con la shell de javascript. Un ejemplo, si creamos una variable doc en la que mentemos los siguientes datos:

> doc = {“name“:”Carlos”, “age“: 26, “profession“: “Dev”}

>db nos dice en que base de datos son encontramos activa

>show dbs nos dice las bases de datos que tenemos disponibles para interactuar

Recordatorio: para proporcionar los datos, accedemos a la db que es la base de datos que tenemos activa, people es el collection dentro de nuestra base de datos y .find() es el método para acceder a los datos. Por tanto si hacemos db.people.find() obtenemos:

> db.people.find() obtenemos todos los documentos de la base de datos 
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 26, “profession” : “Dev” }

Si no lo hemos insertado deberíamos haber hecho previamente, para ello utilizamos el método insert():

> db.people.insert(doc) siendo doc la variable de antes doc = {“name”:”Carlos”, “age”: 26, “profession”: “Dev”}

El método .insert() lo hace sobre una collections y el campo: valor de cada uno de ellos:

db.users.insert(    <—- Collections

{
name: “Alan Pie”, <—– field : value
age: 26, <—– field : value
status: “A” <—– field : value
}

)

En algún momento te preguntarás ¿qué colecciones tengo en mi base de datos que no me acuerdo?, pues para eso tenemos otro comando muy interesante:

> show collections nos porporciona los nombre de todos nuestro collections disponibles en nuestra base de datos.

Vemos cómo podemos proporcionar el resultado de los datos que nos interesan. Como veíamos antes si queremos que nos devuelva todos el método .find() es el adecuado, pero si necesitamos encontrar algún dato concreto debemos ir al método .findOne(). Recuerda que la diferencia entre ambos métodos de hacer .find() y hacer db.people.findOne() es:

> db.people.find();
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 26, “profession” : “Dev” }
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “age” : 30, “profession” : “Hacker” }

> db.people.findOne();
{
“_id” : ObjectId(“522323da16a738edcd927cd9”),
“name” : “Carlos”,
“age” : 26,
“profession” : “Dev”
}

Si ahora queremos que nos devuelva los datos de “Carlos” tendríamos que hacer la siguiente consulta:

> db.people.findOne({“name” : “Carlos”});
{
“_id” : ObjectId(“522323da16a738edcd927cd9”),
“name” : “Carlos”,
“age” : 26,
“profession” : “Dev”
}

Vale perfecto, pero ahora no me interesa que se vea el ID o algún que otro dato de nuestra collection, ¿cómo lo hago?:

> db.people.findOne({“name” : “Carlos”}, {“_id” : false, “profession” : true}); ===> le estamos diciendo, busca un nombre que sea igual a “Carlos”, pero me vas a dar como resultado, el campo profession pero el ID me lo ocultas, pero ¿por qué tenemos que decirle el ID false para que no salga y no le decimos nada sobre el campo “ege” por ejemplo? por la sencilla razón de que si no le dices que el “_id” : false por defecto, siempre devuelve el ID, pero para los campos, si le decimos que debe ser el campo “profession” : true únicamente nos proporciona lo que le hemos dicho, para el resto debemos especificarlo.
Resultado { “profession” : “Dev” }

> db.people.findOne({“name” : “Carlos”}, { “profession” : true});
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “profession” : “Dev” }

> db.people.findOne({“name” : “Carlos”}, { “age” : true});
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “age” : 26 }

> db.people.findOne({“name” : “Carlos”}, { “profession” : true, “age” : true});
{
“_id” : ObjectId(“522323da16a738edcd927cd9”),
“age” : 26,
“profession” : “Dev”
}

> db.people.findOne({“name” : “Carlos”}, { “_id” : false, “profession” : true, “age” : true});
{ “age” : 26, “profession” : “Dev” }

Otro método que nos resultar útil a la hora de ver los datos es .pretty(), veamos que nos proporciona:

> db.course.find()
{ “_id” : ObjectId(“520cf17800886b1da75683b1”), “class” : “algebra”, “student” : [ { “name” : “Susan”, “activities” : [ { “name” : “scooter”, “type” : “sport” }, { “name” : “band”, “type” : “music” } ] } ] }

El resultado es un poco complicado de ver así o de observar dichos datos, veamos utilizando el método .pretty() cómo nos puede ayudar y a la vista está, sin mayores explicaciones:

> db.course.find().pretty()
{

“_id” : ObjectId(“520cf17800886b1da75683b1”),
“class” : “algebra”,

“student” : [
{
“name” : “Susan”,

“activities” : [

{
“name” : “scooter”,
“type” : “sport”
},
{
“name” : “band”,
“type” : “music”
}

]

}

]

}

Vemos algunas consultas que son interesantes descubrir:

> db.users.find( { age: { $gt: 18 } }, { name: 1, address: 1 } ).limit(5)

analizamos las partes para enternderlas, primera db.users.find, ya sabemos que nos proporciona, los datos sobre un collectios (sería nuestro from table), pero vemos que dentro del paréntesis hay algo que no hemos visto, veamos. Si estamos pensando en una sentencia Query SQL tememos el selec * from Tabla where condición, ya hemos visto el from tabla, db.users.find, el primer parámetro, { age: { $gt: 35 } } sería nuestro where, le estamos diciendo: dame todos los que cumplan la condición cuya edad sea mayor que 35, campo = age, $gt mayor que y con un límite de proporcionar resultados de 5 cada vez. Los operadores más comunes:

$gt mayor que

$gte mayor o igual que

$lt menor que

$lte menor o igual que

Vemos que nos proporciona $all

> db.post.find( { tags: { $all: [ “tag1”, “tag2”, “tag3” ] } } ) nos selecciona todos los documentos que el campo tags contiene un array y contiene los elementos  [ “tag1”, “tag2”, “tag3” ]

Podríamos decir también que ambos casos obtenemos el mismo resultado:

> db.users.find( { age: { $all: [ 30 ] } } )
> db.users.find( { age: 30 } )

Para cuando necesitemos la negación, necesitamos decir que el {field: {$ne: value} }, nos selecciona los documentos en los que el valor del campo no es igual al valor especificado:

> db.people.find()
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 48, “profession” : “Dev” }
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “age” : 30, “profession” : “Hacker” }

> db.people.find( { age: { $ne: 30 } } )
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 48, “profession” : “Dev” }

Para actualizar tenemos el método .update(), le damos dos parámetros el primero el critero de la actualización y el segundo el qué queremos actualizar:

ANTES > db.people.find()

{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 26, “profession” : “Dev” }
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “age” : 30, “profession” : “Hacker” }

> db.people.update( { “name”: “Carlos” }, { $set: { age: 48 } } )

DESPUÉS > db.people.find()

{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 48, “profession” : “Dev” }
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “age” : 30, “profession” : “Hacker” }

o podemos actualizar el valor de sale a true en los que se cumpla que los tags contengan $in tag1 y tag2:

> db.post.update({ tags: { $in: [“tag1”, “tag2”] } }, { $set: { sale : true } })

En un caso podemos necesitar utilizar una lista que no esté incluida en el array $nin:

> db.post.update( { tags: { $nin: [“tag1”, “tag2”]  } }, { $set: { sale: false } } )

Para las actualizaciones disponemos del método .update():
db.users.update( <———- collection
{ age: { $gt: 18 } },  <———- Upadate criteria
{ $set: { status: “A” } }, <—– Upadate action
{ multi: true } <——— Upadate optional. Si se establece el valor a true, las actualizaciones se hacen sobre varios documentos que cumplen con los criterios de la consulta. Si se establece el valor a  false, actualiza un  único documento. El valor por defecto es false.
)
Para la ordenación podemos, utilizar el método .sort():

> db.people.find( { age: {$gt: 18}}).sort({age: 1})para descendente
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “agúnicoe” : 30, “profession” : “Hacker” }
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 48, “profession” : “Dev” }

> db.people.find( { age: {$gt: 18}}).sort({age: -1})para ascendente
{ “_id” : ObjectId(“522323da16a738edcd927cd9”), “name” : “Carlos”, “age” : 48, “profession” : “Dev” }
{ “_id” : ObjectId(“5223305016a738edcd927cda”), “name” : “Peter”, “age” : 30, “profession” : “Hacker” }

Para eliminar necesitamos el método .remove():

> db.users.remove( { status: “D” } )

Para terminar un comando interesante y necesario, la importación de datos mongoimport y eliminar una base de datos que ya no nos hace falta con el método .dropDatabase():

mongoimport -d school -c students < students.json Importar un fichero json -d nombre de la bse de datos -c nombre de la collections

mongoimport –type csv –headerline weather_data.csv -d weather -c data Importar un fichero csv -type el tipo de fichero a importar

mongo weather –eval “printjson(db.dropDatabase())” Eliminar una base de datos

Volveremos a hablar más sobre mongoBD en próximos post.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s