feed twitter facebook LinkedIn facebook

XML » Atributo con valor por defecto en XML

febrero 14, 2014 por xhrist14n Sin Comentarios Imprimir Imprimir

Cuando definimos un atributo XML dentro de un DTD podemos hacer que el atributo tenga un valor por defecto en XML.

Lo primero es recordar que para definir un atributo XML:

  1. <!ATTLIST element-name attribute-name attribute-type default-value>

Donde tenemos el elemento sobre el que queremos definir el atributo, el nombre y tipo del atributo, y por último el valor por defecto.

Así podríamos definir el siguiente DTD con un atributo con valor por defecto en XML:

  1. <!ELEMENT square EMPTY>
  2. <!ATTLIST square width CDATA "0">

Hemos creado un atributo width, sobre un elemento square, del tipo CDATA y cuyo valor por defecto en XML será "0".

De esta forma podríamos crear el siguiente XML válido:

  1. <square width="100" />

En este ejemplo, el elemento “square" esta definido para ser un elemento vacío con un atributo “width" de tipo CDATA. Si no se asigna un atributo width, el valor por defecto en XML será 0.

Como podéis ver es muy sencillo el definir un atributo con un valor por defecto en XML.

XML » Definir atributos en XML DTD

febrero 12, 2014 por xhrist14n 1 Comentario Imprimir Imprimir

Siguiendo con XML, tomamos ahora el tema de definir atributos en XML DTD los cuales son útiles para poder tener atributos a usar en las etiquetas XML.

Lo primero que se necesita para poder usar atributos en XML DTD dentro de nuestras etiquetas XML es definir estos atributos en ATTLIST en nuestro archivo de definición de etiquetas XML, para conseguir esto debemos seguir el formato adecuado para declaración de atributos XML:

  1. <!ATTLIST element-name attribute-name attribute-type default-value>

Donde se denota ATTLIST como palabra clave de definición de atributos luego el nombre del elemento en el cual se generaran los atributos, luego todo esto se completa con el nombre del atributo a generarse, un tipo de atributo y un valor por defecto a asignarse automáticamente en caso de no tener ningún valor definido para el atributo.

Tipos de atributo XML

Los tipos de atributo XML que se puede usar en un DTD son los siguientes:

Tipo Descripción
CDATA El valor es una cadena de caracteres
(en1|en2|..) El valor debe ser uno de los enumerados en la lista
ID El valor es un ID único
IDREF El valor es el id de otro elemento
IDREFS El valor es uno de la lista de los otros ids
NMTOKEN El valor es un nombre XML valido
NMTOKENS El valor es una lista de los nombres XML validos
ENTITY El valor es una entidad
ENTITIES El valor es una lista de entidades
NOTATION El valor es un nombre de una notación
xml: El valor es un valor xml predefinido

El valor por defecto puede ser uno de estos:

valor explicación
valor El valor por defecto del atributo
#REQUIRED El atributo es requerido
#IMPLIED El atributo no es requerido
#FIXED valor El valor del atributo es fijo

Ejemplo de atributos en XML DTD

Un ejemplo puede ser el siguiente:

  1. <!ATTLIST payment type CDATA "check">

Lo que estamos diciendo es que el elemento payment, tiene un atributo llamado type del tipo CDATA y cuyo valor por defecto es "check".

Podemos indicar que el atributo sea obligatorio, en este caso tendríamos que escribir lo siguiente:

  1. <!ATTLIST payment type CDATA #REQUIRED "check">

Si queremos utilizar el atributo en un documento XML sería de la siguiente forma:

  1. <payment type="check" />

Groovy » Crear una clase en Groovy

febrero 10, 2014 por ARIEL Sin Comentarios Imprimir Imprimir

En esta ocasión crearemos una clase en Groovy, al igual que en Java se debe usar la palabra class.

Clase en Groovy

  1. class Computadora{
  2. ...
  3. ...
  4. }

Nuestra clase en Groovy tendrá dos atributos:

  1. String marca
  2. String modelo

Por defecto estos atributos serán accesibles desde cualquier otra clase en Groovy. Si quiero crear otra clase en Groovy que acceda a esos atributos tengo que usar la palabra extends.

  1. class Computadora_Portatil extends Computadora{
  2. ...
  3. ...
  4. }

A esta nueva clase en Groovy le coloco otros dos atributos:

  1. String memoria
  2. String procesado

El código de ambas clases en Groovy quedaría de la siguiente forma:

  1. //clase base
  2. class Computadora{
  3. String marca
  4. String modelo
  5. }
  6.  
  7. //clase hija
  8. class Computadora_Portatil extends Computadora{
  9. String memoria
  10. String procesador
  11. }

Constructor de una clase en Groovy

Podemos crear un constructor para cada clase en Groovy:

  1. //clase base
  2. class Computadora{
  3. //constructor
  4. Computadora(){}
  5. }
  6.  
  7. //clase hija
  8. class Computadora_Portatil extends Computadora{
  9. //constructor
  10. Computadora_Portatil(){}
  11. }

Método main de una clase en Groovy

Ahora escribimos el "main" de nuestra clase en Groovy:

  1. static main(args){
  2. //nota: no es necesario
  3. }

Instancia de una clase en Groovy

  1. static main(args){
  2. def miPC=new Computadora()
  3. }

También podemos hacerlo de esta forma:

  1. static main(args){
  2. def miPC= new Computadora(marca:"DELL",modelo:"1501")
  3.  
  4. //mostramos los valores
  5. println "Mi PC:"
  6. println "marca >> ${miPC.marca} , modelo >> ${miPC.modelo}"
  7.  
  8. }

Existe también la alternativa de usar la palabra with para llenar los atributos de la clase en Groovy:

  1. static main(args){
  2. //en este caso usamos la clase hija
  3. def miPortatil=new Computadora_Portatil()
  4. miPortatil.with{
  5. memoria="1.7GiB"
  6. procesador="AMD V120 Processor"
  7. }
  8.  
  9. //mostramos los valores
  10. println "Mi PC portatil:"
  11. println "memoria >> ${miPortatil.memoria} , procesador >> ${miPortatil.procesador}"
  12.  
  13. }

Espero que os haya gustado el artículo sobre cómo crear una clase en Groovy.

Conversación » Conversaciones sobre Programación. Build 2014.02

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

Segundo resumen de nuestros grupos de conversaciones sobre programación. Su "nombre de guerra" Build 2014.02. Un buen puñado de enlaces sobre Java, Javascript, HTML5,... por tener hasta tenemos un vídeo sobre como montar CGIs en Perl.

Queremos resaltar el trabajo del Blog return(GiS); por la cantidad y la calidad de los enlaces que se comparten en los grupos. Nos alegra mucho encontrar blog de programación en español de tanta calidad como return(GiS);

Por favor, leer y comentar a la gente que hay una serie de normas de comportamiento para los grupos de conversaciones sobre programación que se deben de acatar.

Aunque hace mucho que no creamos un grupo de conversación nuevo, ya tenemos unos cuantos. En breve tendremos algunas novedades.

Las cosas interesantes que hemos visto en los grupos de conversaciones sobre programación son:

Si quieres que tu enlace esté aquí, solo tienes que crear contenido de calidad, compartirlo en los grupos de conversación o indicarlo en los comentarios.

Y hoy nos despedimos con un poco de amor informático...

amor_informatico

Más en el próximo resumen. Mientras, seguir utilizando los grupos de conversación.

MongoDB » MongoDB Skip: Omitir resultados

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

Cuando realizamos una consulta MongoDB Find, esta, nos devuelve el conjunto de documentos que cumplen la búsqueda. Si bien, mediante MongoDB Skip podemos omitir resultados y no recuperar ciertos documentos.

Pero vamos por pasos. Lo primero será realizar una consulta:

  1. db.coleccion.find(filtro);

A esta consulta con el método .find() le podemos añadir el método MongoDB Skip.

La sintaxis del método MongoDB Skip es muy sencilla:

  1. db.coleccion.find(filtro).skip(numero_elementos);

Lo que le pasamos como parámetro al método MongoDB Skip es el número de elementos que queremos omitir antes de devolver el contenido.

El método MongoDB Skip puede ser costoso ya que aunque omitamos los documentos, estos están siendo leidos de la base de datos, con su consecuente coste. Así que intenta siempre acceder a los documentos acotados que necesites.

Así que si al realizar una consulta sobre nuestra colección de ciudades, si queremos omitir dos elementos escribiremos lo siguiente:

  1. cursor = db.ciudades.find().skip(2);

Al recorrer el cursor veremos que los dos primeros documentos que cumplan el filtro (en este caso, todos los documentos), no aparecen.

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

Muy sencillo el uso del método MongoDB Skip para omitir documentos en las consultas.

MongoDB » MongoDB Projection: Seleccionar campos de un documento

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

Si realizamos una consulta MongoDB Find lo que retornara dicha consulta es el conjunto de documentos que correspondan a dicha consulta. Se devolverán los documentos completos con todos sus campos. Si bien podemos realizar MongoDB Projection, que es seleccionar los campos de un documento que queremos devuelva la consulta.

Para especificar el MongoDB Projection dentro del método .find() deberemos de hacerlo como último parámetro del método. La sintaxis para el MongoDB Projection será la siguiente:

  1. db.coleccion.find({filtros},{projection});

Asumiento que ya sabes realizar filtros... o échale un ojo a nuestros ejemplos del método MongoDB Find. Vamos a revisar como se haría el MongoDB Projection.

Si queremos seleccionar varios campos simplemente tenemos que indicar el nombre del campo seguido de un 1. O bien utilizar un 0 para eliminar los campos a mostrar.

  1. db.coleccion.find({filtros},{campo1:0|1,campo2:'0|1,...,campoN:0|1});

De esta forma 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 }

Si queremos mostrar solo el nombre de la ciudad, ejecutaremos la siguiente consulta:

  1. cursor = db.ciudades.find({habitantes:{$gt:1000000}},{ciudad:1});

Curiosamente el resultado será el siguiente:

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

Vaya, queríamos mostrar solo la ciudad y resulta que nos muestra también el ObjectID.

En MongoDB Projection el campo ObjectID se mostrará siempre a no ser que indiquemos que no se tiene que mostrar.

Así que para eliminar el ObjectID tendremos que ejecutar la siguiente consulta:

  1. cursor = db.ciudades.find({habitantes:{$gt:1000000}},{ciudad:1,_id:0});

Podemos conseguir el mismo efecto de devolver solo el nombre de la ciudad si eliminamos la aparición del campo habitantes, es decir, asignandole un 0 en el MongoDB Projection.

  1. cursor = db.ciudades.find({habitantes:{$gt:1000000}},{habitantes:0,_id:0});

Ya hemos visto como manipular de forma sencilla los campos a mostrar en la consulta mediante el MongoDB

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 ;-).