feed twitter facebook LinkedIn facebook

MongoDB » Ordenaciones en MongoDB

febrero 7, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

A la hora de realizar una consulta podemos encontrarnos la necesidad de realizar una ordenación de los datos. Ya que si no decimos nada las consultas en MongoDB devolverán los datos tal cual se encuentren almacenados en la base de datos, es decir, con su orden de inserción.

Así si queremos realizar ordenaciones en MongoDB deberemos de utilizar el método .sort(). La sintaxis del método MongoDB .sort() es la siguiente:

  1. db.coleccion.find(filtro).sort(ordenacion);

En la ordenación indicaremos el campo o los campos por los cuales queremos ordenar. De ifual forma indicaremos el tipo de ordenación que queremos: ordenación ascendente u ordenación ascendente.

La estructura de la ordenación es la siguiente:

.sort({campo1:tipoordencion,campo2:tipoordenacion,...,campoN:tipoordenacion});

Dónde los tipos de ordenación y sus valores son:

  • Ascendente: 1
  • Descendente: -1

Así que partiendo de nuestra colección de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Podemos realizar las siguientes ordenaciones en MongoDB. Si queremos ordenar las ciudades de forma ascendente escribiremos:

  1. cursor = db.ciudades.find().sort({ciudad:1});

Por el contrario, si queremos ordenar las ciudades de forma descendente:

  1. cursor = db.ciudades.find().sort({ciudad:-1});

Las ordenaciones en MongoDB solo se pueden realizar con tamaños menores a 32Mb. En caso contrario hay que utilizar el método .limit() para acortarlas.

La consulta realizada con el método .find() puede tener un filtro:

  1. cursor = db.ciudades.find({ciudad:/^M/}).sort({ciudad:-1});

En este caso se ordenaria el subconjunto de documentos devueltos por la consulta filtrada.

Podemos establecer varios campos de ordenación, los cuales se ejecutarían en el orden en el que están establecidos:

  1. cursor = db.ciudades.find().sort({ciudad:-1,habitantes:1});

De igual manera podemos seguir concatenando métodos en la consulta y podemos limitar el número de documentos a devolver después de haber utilizado el método .sort().

  1. cursor = db.ciudades.find().sort({ciudad:1}).limit(4);

Eso sí, la final no se te olvide recorrer el cursor para mostrar el contenido del mismo:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

Ya sabemos como realizar ordenaciones en MongoDB.

MongoDB » Operador MongoDB IN

febrero 6, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

El operador MongoDB IN es un operador que nos sirve para simular un operador MongoDB OR con una lista de posibles valores. Es decir, nos evitaría el escribir OR filtro 1 OR filtro 2... Eso sí, siempre y cuando sea sobre el mismo campo del documento.

La estructura de un operador MongoDB IN es la siguiente:

  1. db.coleccion.find({campo:{$in:['valor1','valor2',...,'valorN']}});

Vemos que la primera parte del filtro es el campo sobre el que queremos aplicar el operador MongoDB, mientras que la otra el el operador MongoDB en si mismo.

Si vemos la parte del operador MongoDB IN podemos observar que es sencilla ya que es un array de los valores sobre los que aplicaremos el filtro separados por comas.

Si volvemos a nuestra colección de ejemplo de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Vamos a atacar el campo ciudad indicando una lista de posibles valores. De esta forma la consulta MongoDB IN se quedaría de la siguiente forma:

  1. cursor = db.ciudades.find({ciudad:{$in:['Avila','Zamora','Madrid']}});

Ya solo nos queda ver el resultado de la consulta recorriendo el cursor:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

Ya hemos visto en este sencillo ejemplo como utilizar el operador MongoDB IN para consultar por varios valores de un campo.

MongoDB » Total de registros con MongoDB count

febrero 5, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Cuando realizamos consultas en MongoDB una de las cosas que querremos saber es el número total de registros de una colección o el número total de registros afectados por una consulta. Para ello tenemos el método MongoDB count.

El método MongoDB count se puede aplicar directamente sobre una colección o sobre una consulta y nos devolverá dicha información.

La ejecución del método MongoDB count devuelve un número con el número de documentos contados.

La sintaxis sobre una colección es la siguiente:

  1. db.coleccion.count();

De esta manera, en nuestra colección de ejemplo de ciudades, escribiríamos lo siguiente:

  1. db.ciudades.count();

Esto devolvería el número total de documentos que componen una colección. Que al fin y al cabo podría escribirse también como:

  1. db.ciudades.find().count();

Es decir, contar una consulta que recupera todos los documentos. Y es que esta es la base para contar registros parciales de consultas con MongoDB count. La sintaxis será:

  1. db.coleccion.find({filtros}).count();

En este sentido, si estamos consultando nuestra colección de documentos de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Si consultamos ciudades que empiecen por M y queremos saber cuantas existen, podemos utilizar el método MongoDB count.

  1. db.ciudades.find({ciudad:/^M/}).count();

Como podéis ver el uso del método MongoDB count es muy sencillo. Otra cosa es el coste en tiempo y rendimiento, pero eso ya es cuestión de otro artículo. :-D

MongoDB » Operador MongoDB OR

febrero 4, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya hemos visto el funcionamiento del Operador MongoDB AND en el cual podíamos realizar operaciones en la cuales se cumpliesen dos condiciones o filtros. En este caso vamos a ver como realizar operaciones que se pueden realizar cuando se cumpla un campo u otro. Para ello vamos revisar el uso del operador MongoDB OR.

La estructura es muy similar al operador MongoDB AND, pero en este caso vamos a utilizar el elemento $or. La estructura del operador MongoDB es la siguiente:

  1. db.coleccion.find({$or:[{filtro1},{filtro2},...{filtroN}]});

De esta forma si, de nuestra colección de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Queremos sacar ciudades que bien empiecen por M o bien empiecen por Z tendremos que utilizar nuestro operador MongoDB OR de la siguiente forma:

  1. cursor = db.ciudades.find({$or:[{ciudad:/^M/},{ciudad:/^Z/}]});

Vemos que cada una de las opciones que queramos concatenar con el operador MongoDB OR van dentro del array separadas por comas.

Ya solo tenemos que mostrar el resultado recorriendo el cursor:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

Como podéis comprobar el uso del operador MongoDB OR es muy sencillo. Solo hay que tener cuidado con el uso de las llaves, como en todo MongoDB ;-).

MongoDB » Operador MongoDB AND

febrero 3, 2014 por Víctor Cuervo 2 Comentarios Imprimir Imprimir

Cuando estemos realizando consultas MongoDB es fácil que necesitemos concatenar filtros en las consultas. Es decir necesitemos realizar el operador MongoDB AND.

Por ejemplo, en nuestra colección de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Podemos querer el consultar por el nombre de la ciudad y por el número de habitantes. Lo que buscaremos realizar con el operador MongoDB AND es filtrar por ciudades que empiecen por una letra y cuyos habitantes sean mayor de un número indicado.

El operador MongoDB AND tiene la siguiente estructura:

  1. db.coleccion.find({$and:[{filtro1},{filtro2},...{filtroN}]});

Dónde los filtros podrán ser de cualquier tipo de los que soporta MongoDB.

De esta forma, para poder escribir el filtro con el operador MongoDB AND que hemos comentado antes tendremos la siguiente sentencia:

  1. cursor = db.ciudades.find({$and:
  2. [{ciudad:/^M/},{habitantes:{$lt:1000000}}]});

Vemos que dentro del documento asociado al AND va un array con los filtros, que a su vez tienen la estructura BSON. Todos ellos separados por comas.

Aunque MongoDB tiene otros operadores adicionales como $or, $eq, $neq,... El operador MongoDB AND o $and se puede asumir en la propia consulta, de forma implicita, en una secuencia de filtros. Es decir, que podríamos escribir la consulta .find() de la siguiente forma:

  1. db.coleccion.find({filtro1,filtro2,...filtroN});

Por lo que reescribiendo el anterior uso del operador MongoDB AND tendríamos lo siguiente de forma implicita:

  1. cursor = db.ciudades.find({ciudad:/^M/,habitantes:{$lt:1000000}});

Como en todos los ejemplos, al dejar el resultado de los documentos sobre un cursor, solo nos queda el volcar el cursor:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

MongoDB » Consultas MongoDB Like

febrero 2, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Cuando accedemos a los datos de los campos de un documento en MongoDB podemos encontrarnos la necesidad de realizar consultas MongoDB like. Es decir, realizar consultas por cadenas similares de texto. Por ejemplo, nombres que empiecen por una letra o letras, palabras que contengan una cierta cadena de caracteres,...

Las consultas MongoDB like se resuelven mediante expresiones regulares. Lo que realizaremos mediante la siguinte sintaxis:

  1. db.coleccion.find({campo:expresión_regular});

Para los patrones de las expresiones regulares MongoDB utiliza “Perl Compatible Regular Expressions” (PCRE). De esta forma tendremos las siguientes similitudes con los patrones LIKE.

cadena% /^cadena/
%cadena% /cadena/
%cadena /cadena$/

De esta forma la sentencia para realizar consultas MongoDB like será la siguiente:

  1. cursor = db.ciudades.find({ciudad:/^M/});

En este caso hemos realizado un filtro LIKE de ciudades que empiecen por M.

A la hora de utilizar las expresiones regulares, los índices solo se utilizarán de forma eficiente cuando utilizemos la forma /^cadena/

Otros podrían ser ciudades que contengan una "r":

  1. cursor = db.ciudades.find({ciudad:/r/});

O ciudades que acaben en d:

  1. cursor = db.ciudades.find({ciudad:/d$/});

Ya solo nos quedará recorrer con un cursor el resultado para volcar los documentos devueltos por la expresión regular:

  1. while (cursor.hasNext()) {
  2. printjson(cursor.next());
  3. }

De esta forma vemos que es sencillo realizar consultas MongoDB Like.

MongoDB » Consultas MongoDB con límite de documentos

febrero 1, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Cuando estamos realizando consultas en MongoDB podemos tener la necesidad de establecer un límite en el número de documentos a devolver. En este artículo vamos a ver como podemos realizar consultas MongoDB con límite de documentos.

Lo primero que repasaremos será la forma de realizar una consulta mediante el método .find()

  1. cursor = db.ciudades.find();
  2.  
  3. while (cursor.hasNext()) {
  4. printjson(cursor.next());
  5. }

El método .find() se lanza sobre la colección que queremos consultar. En el caso del ejemplo sobre la colección ciudades. Dentro del método .find podemos establecer los filtros que necesitemos para realizar la consulta.

Cuando el cursor recorra todos los datos de la colección devolverá todos aquellos que contemplen el filtro. Si no ponemos nada, nos devuelve todos.

Así, si tenemos la colección ciudades como:

{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5b"),
	"ciudad" : "Madrid",
	"habitantes" : 3233527
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5c"),
	"ciudad" : "Barcelona",
	"habitantes" : 1620943
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5d"),
	"ciudad" : "Valencia",
	"habitantes" : 797028
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5e"),
	"ciudad" : "Sevilla",
	"habitantes" : 702355
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5f"),
	"ciudad" : "Zaragoza",
	"habitantes" : 679624
}

Nos devolverá todos esos documentos.

Para realizar consultas MongoDB con límite de documentos utilizaremos el método .limit(). El método .limit() tiene como parámetro el número de documentos a los que queremos limitar la respuesta. Es decir, que aunque haya más documentos que cumplen la condición, solo se devolverán tantos como indique el parámetro de .limit()

El código será el siguiente:

  1. cursor = db.ciudades.find().limit(2);
  2.  
  3. while (cursor.hasNext()) {
  4. printjson(cursor.next());
  5. }

En este caso el código limita a dos resultados como respuesta. Así, si partimos de la anterior colección, el resultado será el siguiente:

{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5b"),
	"ciudad" : "Madrid",
	"habitantes" : 3233527
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5c"),
	"ciudad" : "Barcelona",
	"habitantes" : 1620943
}

Lógicamente el uso del método .limit() a la hora de realizar consultas MongoDB con límite de documentos permite una optimización en el tiempo de respuesta de las consultas. Ya que la base de datos MongoDB solo recorrerá los documentos a los que nos hemos limitado y no todos.

Java » Convertir una Lista en un Array

enero 31, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya vimos en su momento como podíamos convertir, de una forma sencilla, un array en una lista en Java. En este caso vamos a ver la operación contraria que será convertir una lista en un array con Java.

Lo primero será definir una Lista. Para ello utilizamos el interface List implementado mediante una clase ArrayList. Hay que recordar que cuando utilicemos colecciones tenemos que indicar el tipo de colección que estamos utilizando. En nuestro caso vamos a crear una lista de cadenas o String.

  1. List<String> milista = new ArrayList<String>();

Para insertar cada uno de los elementos en la lista utilizamos el método .add().

  1. milista.add("Elemento 1");
  2. milista.add("Elemento 2");

Lo siguiente será crear el array sobre el que vamos volcar el contenido de la lista. A la hora de crear el array deberemos de asignarle el tamaño que tenga la lista. Para saber el tamaño de una lista en java utilizamos el método .size()

  1. String[] miarray = new String[milista.size()];

El interface List tiene un método .toArray() este es el método clave que nos va a convertir una lista en un array con Java. Así que simplemente invocamos el método indicando como parámetro el array sobre el que queremos volcar el contenido.

  1. miarray = milista.toArray(miarray);

Ahora, para comprobar que hemos realizado bien el proceso de convertir una lista en un array con Java vamos a recorrer el contenido del array y ver que es el mismo que insertamos en la lista.

  1. for(String s : miarray)
  2. System.out.println(s);

Y hasta aquí nuestro ejemplo de como convertir una lista en un array con Java. Esperamos que os haya ayudado.

Java » Números repetidos en un array Java

enero 30, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Los ejercicios de manipulación de arrays son muy recomendables para aprender la lógica de programación Java, así como sus estructuras. De esta forma tenemos algunos ejemplos como encontrar el primer número repetido, encontrar el número mayor y su posición,...

En este caso vamos a ver como podemos encontrar los números repetidos en un array Java. Es decir, la idea es partir de un primer array que contenga los números a buscar.

  1. int numeros[] = {1,2,3,4};

Y tener un segundo array que contenga la lista sobre la que buscamos.

  1. int lista[]= {2,4,5,2,4,4,4,3,4,2,3};

Una solución rápida sería realizar dos bucles for, el primero que recorra el primer array Java y el segundo que recorra el segundo array Java.

  1. for (int x=0;x<numeros.length;x++) {
  2. for (int y=0;y<lista.length;y++) {
  3. if (numeros[x]==lista[y])
  4. System.out.println("El número "+numeros[x]+" está repetido");
  5. }
  6. }

La verdad que este código funcionaría ya que al recorrer los dos arrays Java chequearíamos todos los números. Si bien vamos a intentar que sea un poco más óptimo en la búsqueda. Y es que la idea es en primer lugar ir recorriendo el array de números (igual que hacíamos antes).

  1. for (int x=0;x<numeros.length;x++) {
  2. ....
  3. }

Pero en la búsqueda sobre la lista vamos a utilizar un bucle while de Java. Este bucle contendrá dos condiciones, por un lado la del límite del array y por otro un flag que nos diga si hemos encontrado el número, ya que en este caso no hace falta buscar más y podremos parar la búsqueda.

El código sería el siguiente:

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {...}
  6. }

Vemos que hemos utilizado un flag encontrado que estará a "false" mientras no encuentre el número, será en este momento cuando cambiemos su valor para salir del bucle.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10. }

Ya solo nos quedará preguntar por la variable encontrado para ver si se ha encontrado el número.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10.  
  11. if (encontrado)
  12. System.out.println (numeros[x] + " es un número repetido. Encontrado en " + iter + " búsquedas");
  13. else
  14. System.out.println (numeros[x] + " no está en la lista. No encontrado en " + iter + " búsquedas");
  15. }

Adicionalmente vemos que en la variable iter tenemos el número de búsquedas que hemos realizado en el segundo array Java. Con esto ya tenemos resuelto como buscar números repetidos en un array Java.

JavaScript » Acceder al hash de la URL con Javascript

enero 29, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Si miras una URL el fina de esta puede contener una palabra separada por un símbolo de almohadilla (#). Esto es lo que se conoce como elemento hash de la URL y nos sirve para posicionarnos dentro de una parte determinada de la página. Esto lo conseguimos de forma sencilla mediante HTML.

La URL miweb.html#elemento se va a posicionar en la página allí dónde utilicemos el siguiente código:

  1. <a name="elemento"></a>

Si quieres más información al respecto puedes leer el artículo Enlace a una parte concreta de la página el cual te resolverá todas tus dudas.

Pero, ¿cómo podemos acceder al hash de la URL con Javascript? Es decir, qué hacer si queremos controlar cuando el usuario llegue con una URL que contenga una etiqueta o elemento de hash.

La solución es bastante sencilla y es que en Javascript tenemos el objeto location, el cual hace referencia a la URL que maneja el navegador, este objeto nos va a facilitar acceder al hash de la URL con Javascript.

  1. locatio

En concreto tenemos una propiedad del objeto location llamada .hash (el nombre que ni pintado) que nos devuelve el hash de la URL.

  1. //Volvar el hash a la consola
  2. console.log(location.hash;)

Como podemos ver, el uso de la propiedad location.hash nos facilita el acceso al hash de la URL con Javascript. Eso sí, solo tenemos que tener cuidado con una cosa, y es que no nos devuelve el elemento correspondiente con el hash, si no que nos devuelve el elemento precedido de la almohadilla.

Así de la URL

http://lineadecodigo.com/#acerca-de

El objeto location.hash nos devolverá:

#acerca-de

Ahora ya solo queda decidir qué hacer con el hash. Por ejemplo mostrar un contenido u otro, mostrar una pestaña u otra,... ¿qué más casos se te ocurren para utilizar la propiedad hash en Javascript?