Totalizar datos / Alias de campos

Dejemos de lado por ahora los tipos de datos y sus operaciones para abordar un recurso de SQL de gran potencia que resulta muy interesante: totalizar datos. Supongamos entonces que nos piden lo siguiente: ¿Cuál es el salario medio de los empleados?

Recordemos las preguntas de construcción que tanto nos ayudan para construir consultas en SQL:

- ¿Qué datos nos piden?

- ¿Dónde están los datos?

- ¿Qué requisitos deben cumplir los registros?

A la pregunta: ¿Dónde están los datos?, se nos plantea una duda. El dato que nos piden es: “el salario medio de los empleados”, pero este dato no está en ninguna tabla, entonces ¿Cómo resolvemos el problema? Afortunadamente SQL nos permite calcularlo. Para calcular el salario medio basta con sumar todos los salarios y dividirlo por el número de empleados. Esto es posible hacerlo mediante la funciones SUM(suma) y COUNT(contar) de SQL.

CONTINUES...

H.

Code::Blocks

Code::Blocks 16.01

Code::Blocks es a mi juicio, uno de los mejores IDE's para desarrollar aplicaciones en C o C++. A continuación te dejo una guía paso a paso de cómo instalarlo en tu PC:

Primero, nos dirigiremos a la página oficial de CodeBlocks, http://www.codeblocks.org/ y haremos click en la pestaña “Downloads”.

Aparecerán 3 opciones de descarga, seleccionaremos la primera (Download the binary release).

Nos pedirá el Sistema Operativo que poseemos (en mi caso es Windows 8.1).

Una vez elegido el Sistema Operativo, debemos descargar la versión que incluye “mingw” (segunda opción) ya que sin esta herramienta, no podrás ejecutar los programas. Por último, elegimos cualquiera de las opciones de descarga (BerliOS o Sourceforge).

Una vez elegida la opción, comenzará la descarga del programa. Instalarlo es muy sencillo, sólo debemos hacer click en Next, elegir el lugar de destino en caso de querer cambiar el asignado por defecto, ¡Y listo!

Una vez terminada la instalación, ya puedes ejecutar el programa.

Primeros pasos

Para que comiences a familiarizarte un poco con el software, crearemos nuestra primera aplicación: el famoso "Hola Mundo".

Lo primero que debemos hacer es ejecutar CodeBlocks. Una vez abierto el programa nos dirigiremos a "New", "File" y luego "Empty File"; o simplemente presionamos las teclas Ctrl + Shift + N.

Se abrirá una hoja en blanco, donde escribiremos el código del programa. La ejecución de los programas que escribirás en este software será en una pequeña ventana con fondo negro.

Escribimos el código (no te preocupes si no entiendes nada, ya que el fin de este tutorial es aprender a utilizar el software y no a programar).

Luego, iremos a la barra de herramientas de Code::Blocks y presionaremos el botón que dice "Build and run" (Compilar y ejecutar).

El software nos pedirá que guardemos el proyecto. Podemos darle el nombre que queramos, lo importante es definir la extensión, es decir, si el código está escrito en lenguaje C o C++; para ello, agregaremos ".c", si es C, o ".cpp", si es C++, al final del nombre que le demos al programa. Para este caso debe ser .cpp ya que de eso trata el curso (Proyecto.cpp).

Una vez guardado nuestro proyecto, podremos visualizar su ejecución.

Cualquier duda que tengas escríbela en la caja de comentarios que está un poco más abajo, trataré de responderla a la brevedad.

Ruby on Rails

Cabe destacar que la instalación de Ruby y Rails se realiza en un ambiente Linux, específicamente Ubuntu 14.04.

Ruby 2.2

Lo primero que haremos es instalar ciertas librerías y otras dependencias necesarias a futuro.

sudo apt-get install build-essential libssl-dev libyaml-dev libreadline-dev openssl curl git-core zlib1g-dev bison libxml2-dev libxslt1-dev libcurl4-openssl-dev

Crearemos un directorio y luego, dentro de ese mismo directorio vamos a descargar la versión 2.2 de ruby.

mkdir ~/ruby

cd ~/ruby

wget http://cache.ruby-lang.org/pub/ruby/ruby-2.2.2.zip

unzip ruby-2.2.2.zip

cd ruby-2.2.2

Seguramente te preguntarás que hiciste en esas 5 líneas, la respuesta es sencilla. Primero creamos un directorio en el home y luego entramos, una vez dentro del directorio descargamos la versión 2.2 de ruby con el comando wget (si tienes algún error al ingresar este comando, prueba instalando wget en otra terminal para no tener problemas con la instalación de ruby), en la cuarta línea de comandos lo que estamos haciendo es descomprimir el zip de ruby para luego, en la quinta y última línea de comandos ingresar al directorio que contiene el archivo zip.

Ahora, haremos correr el script “configure” (tener en cuenta que este demora un tanto).

./configure

Luego, ejecutaremos la utilidad Make, que utilizará el Makefile para generar el programa ejecutable (esto también demorará un poco, como el comando anterior)

make

Lo que necesitamos ahora es copiar los binarios compilados en el directorio /usr/local/bin/, para ello utilizaremos el comando sudo para darle más "permisos".

sudo make install

¡Y listo! Ya tenemos Ruby 2.2 instalado en nuestro computador. Ahora podemos borrar el directorio ruby con todo su contenido (si así lo quieren).

cd ..

rm -rf ~/ruby

Rails 4.2

Comencemos ahora con Rails:

sudo gem install --no-rdoc --no-ri rails

Con esa línea de comando basta para poder comenzar a trabajar en Rails. Ten en cuenta de que demorará varios minutos así que se paciente.

Primeros pasos

Para comenzar a utilizar el Framework Rails, debes tener en cuenta que necesitas un motor de base de datos, en este caso trabajaremos con MySQL (si no lo tienes, ve a la pestaña "Programas" para instalarlo). Una vez instalada la base de datos podemos comenzar.

rails new proy -d mysql

El comando "new" se utiliza para generar un nuevo proyecto en Rails; "proy" corresponde al nombre que nosotros le hemos asignado a nuestro proyecto (puede ser cualquier otro nombre). Por último, "-d mysql", genera un ficheco llamado "database.yml", que se alojará dentro del directorio config/ y agregará la gema "mysql2".

Creo que hemos utilizado algunos términos que te causarán dudas, por ejemplo "gema". Las gemas vendrían siendo una especie de librerías, las cuales se guardan dentro de un fichero llamado "Gemfile" (es el caso de la gema "mysql2").

Antes de ver a Rails en acción, debemos hacer 2 cosas muy importantes: la primera es crear un usuario en MySQL y la segunda es configurar el proyecto con el usuario que acabamos de crear en la base de datos (ya que no utilizaremos el usuario root). Antes de comenzar con el paso 1 es necesario ingresar a MySQL.

mysql -u root -p

Una vez dentro, crearemos el usuario y le daremos los permisos para manipular la base de datos 'proy_development' y 'proy_test'. Estas bases de datos no existen aún, Rails se encargará de ellas más adelante.

GRANT ALL ON proy_development.* TO proy@localhost IDENTIFIED BY 'proy123';
GRANT ALL ON proy_test.* TO proy@localhost IDENTIFIED BY 'proy123';

Luego de crear al usuario con éxito iremos al directorio donde se encuentra nuestro proyecto.

rake db:create

Lo que Rails ha hecho en esa línea de código es crear las dos bases de datos que anteriormente le dijimos al usuario que podía manipular ("proy").

Para estar seguros de que todo marcha a la perfección, ingresaremos a MySQL pero, esta vez lo haremos con el usuario que creamos anteriormente.

mysql -uproy -pproy123

Dentro de MySQL deberían estar alojadas las dos bases de datos que creamos con la ayuda de Rails: 'proyecto_development' y 'proyecto_test'. Para ello utilizaremos el comando "show" (si no puedes vizualizar las bases de datos, intenta crearlas nuevamente).

show databases;

Para poder continuar sin inconvenientes, es necesario explicar dos de los comandos más utilizados: rails y rake. En el caso de rails, utilizaremos 4:

- rails generate o rails g: genera ficheros tales como assets, model, controller, helper, migration y scaffold, entre otros.

- rails console o rails c: llama a la consola de ruby para manipular las clases del proyecto.

- rails server o rails s: inicia el servidor de rails que, por defecto, corre en el puerto 3000.

- rails dbconsole o rails db: se conecta a la base de datos con la que estamos trabajando (si no ingresamos ningún argumento correrá con la base de datos development).

Pensemos por un momento que nuestro proyecto contará con productos, los cuales tendrán asociada una categoría (una categoría tendrá muchos productos y, un producto pertenecerá a una y solo una categoría). De los productos se desea registrar su código de barra, nombre, precio de compra y categoria a la que pertenece. Lo primero que debemos hacer en Rails es crear el MVC (Modelo-Vista-Controlador) con el CRUD (Create-Read-Update-Delete) para cada tabla.

rails g scaffold categoria nombre:string

rails g scaffold producto nombre:string p_compra:float categoria_id

Lo que acabamos de hacer en esas dos líneas de comando es crear el modelo, el controlador, la vista (bajo la lógica DRY, don't repeat yourself) y lo más importante de todo: la migración. Las migraciones corresponden a una herramienta que se encarga de crear las tablas, brindando una enorme flexibilidad a la hora de querer cambiar el motor de base de datos ya que, la migración depende de la gema "mysql2" y del fichero "database.yml". El fichero de migración podemos encontrarlo en db/migrate/aaaammddhhcreate_table.rb (el nombre de la tabla varía según lo que coloquemos).

Para terminar con la creación de las tablas categoria y producto, debemos migrarlas o crearlas.

rake db:migrate

Cualquier duda que tengas escríbela en la caja de comentarios que está un poco más abajo, trataré de responderla a la brevedad.

Operadores

Lo que se pretende abordar en este capítulo principalmente es la lógica booleana, que es la que nos permite establecer condiciones.

Recordemos la primera consulta de este curso:

SELECT Nombre, Apellidos

FROM Empleados

WHERE Salario > 1350

Cuando indicábamos en la cláusula WHERE: Salario > 1350 (¿Es Salario mayor a 1350?), estábamos estableciendo una expresión booleana donde: ">" es el operador, "Salario" es un operando variable, que tomará valores de cada registro de la tabla Empleados, y "1350" es un operando constante. El resultado de esta expresión depende del valor que tome la variable Salario, pero en cualquier caso sólo puede dar dos posibles resultados, o verdadero o falso. Por lo tanto diremos que una expresión booleana sólo tiene dos posibles resultados.

El motor SQL evalúa la expresión booleana de la cláusula WHERE para cada registro de la tabla, y el resultado determina si el registro que se está tratando se tomará en consideración. Lo hará si el resultado de evaluar la expresión es verdadero, y lo ignorará si el resultado es falso.

Ejemplo de expresiones booleanas:

- "4 > 3": ¿Es cuatro mayor que tres?

- "3 = 12": ¿Es tres igual a doce?

Notar que los operandos son del mismo tipo, en este caso tipo INT. Sin embargo el resultado obtenido no es un dato de tipo INT, sino booleano, sus posibles valores son verdadero o falso.

(4 > 3) = verdadero

(3 = 12) = falso

Operadores

Un operador corresponde a un símbolo matemático que nos indica que debe ser llevada a cabo una operación especificada. Al construir expresiones con estos operadores, los dos operandos deben ser del mismo tipo, ya sean números, cadenas o fechas. Existen tres tipos de operadores:

1.- Aritméticos: realizan operaciones matemáticas con dos expresiones de uno o más de los tipos de datos numéricos.

2.- Comparación: dan como resultado valores booleanos. Cuando al menos uno de los operadores es NULL (nulo), el resultado final es NULL.

3.- Lógicos: comprueban la veracidad de una condición. Éstos, así como los operadores de comparación, devuelven el tipo de dato boolean.

- AND: "A and B" devuelve verdadero si A y B son verdaderos, y falso en cualquier otro caso.

- OR: "A or B" devuelve verdadero si A o B son verdaderos, y falso únicamente cuando tanto A como B son falsos.

- NOT: "not A" devuelve falso si A es verdadero, y verdadero si A es falso.

Veamos una aplicación en el mundo cotidiano:

Supongamos que tu jefe quiere contratar a una persona para repartir genero, solamente pueden optar a la vacante aquellos candidatos que tengan vehículo propio y licencia de conducir. Como candidatos tenemos a Ángela, que tiene licencia pero no tiene vehículo. A Salomé, que tiene licencia y vehículo. Y a Teresa, que tiene vehículo pero de momento no tiene licencia. ¿Quiénes pueden pasar al proceso de selección?

Convertimos el anunciado en una expresión booleana:

Sea C: pasa al proceso de selección.

Sea A: tiene vehículo propio.

Sea B: tiene licencia de conducir.

Entonces para que un candidato satisfaga C, se debe dar A y B:

C = A and B

Resolvamos la expresión para cada candidato:

Aplicado a Ángela: C = (A and B) = (falso and verdadero) = falso.

Aplicado a Salomé: C = (A and B) = (verdadero and verdadero) = verdadero.

Aplicado a Teresa: C = (A and B) = (verdadero and falso) = falso.

Luego, Salomé pasa al proceso de selección.

Veamos ahora esto mismo aplicado en SQL:

Consideremos ahora la tabla Personas, donde hemos guardado una "S" en el campo "Rubia" si la persona es rubia y una "N" en caso contrario, análogamente se ha aplicado el mismo criterio para "Alta" y "Gafas", es decir, para indicar si es alta y si lleva gafas.

El operador AND

Como ya hemos dicho, el operador AND devuelve verdadero si ambas expresiones son ciertas, y falso en cualquier otro caso.

Supongamos que queremos saber ¿Qué personas son rubias y altas?, para ello construimos la siguiente consulta SQL:

SELECT Nombre

FROM Personas

WHERE (Rubia = 'S') AND (Alta = 'S') 

Resultado:

Evaluar RUBIA = 'S' da como resultado verdadero o falso, al igual que evaluar ALTA = 'S'; son de echo los dos operandos booleanos del operador AND. Si para un registro ambos son verdaderos el resultado es verdadero, y se mostrarán los datos de ese registro que indica la cláusula SELECT.

En el caso de tener una expresión de la forma: "A and B and D" la expresión se evalúa por partes por orden de aparición:

Primero se evalúa (A and B) = E y finalmente (E and D)

Si todos los operadores de la expresión son AND, entonces todas las expresiones deben ser verdaderas para que el resultado sea verdadero.

El operador OR

Con el operador OR basta que uno de los dos operandos sea verdadero para que el resultado sea verdadero.

Supongamos que queremos saber las personas que son rubias o bien altas, es decir, queremos que si es rubia la considere con independencia de su altura, y a la inversa, también queremos que la seleccione si es alta independientemente del color de pelo. La consulta sería la siguiente:

SELECT Nombre

FROM Personas

WHERE (Rubia = 'S') OR (Alta = 'S') 

Resultado:

Si todos los operadores de la expresión son OR, por ejemplo "A or B or C", entonces todas las expresiones deben ser falsas para que el resultado sea falso, basta que una sea verdadera para que el resultado sea verdadero.

Supongamos que se quieren seleccionar tres registros concretos de la tabla Empleados para ver sus datos, interesan los registros con identificador 1, 2 y 4. Para esta situación, se debe usar el operador OR, puesto que la consulta debe establecer la condición "que el identificador sea 1, 2 o 4":

SELECT *

FROM Empleados

WHERE Id_Empleado = 1 OR Id_Empleado = 2 OR Id_Empleado = 4

Resultado:

El asterisco (*) presente en la cláusula SELECT equivale a indicar todos los campos de la tabla.

Notar que en la consulta anterior, para cualquier registro de la tabla Empleados donde el campo Id_Empleado contenga un valor distinto a 1, 2 o 4, el resultado de evaluar la expresión será falso, puesto que todas las expresiones booleanas darán falso, pero con que una de ellas sea verdadera, el registro será seleccionado.

Un modo de simplificar la consulta anterior es mediante la palabra clave IN, donde se establece una lista de valores posibles que debe contener el campo indicado para que el registro sea seleccionado. La palabra clave IN equivale a establecer condiciones sobre un mismo campo conectadas por el operador OR.

SELECT *

FROM Empleados

WHERE Id_Empleado IN (1,2,4) 

Resultado:

El operador NOT

Este operador tiene solo un operando, el resultado es negar el valor del operando de modo que:

"(4 > 3) = verdadero", luego "not (4 > 3) = falso"

Si negamos dos veces una expresión booleana es equivalente a la expresión original:

"(4 > 3) = verdadero", luego "not (not (4 > 3)) = verdadero"

Ejemplo:

SELECT Nombre

FROM Personas

WHERE (Rubia = 'S') AND NOT(Alta = 'S') AND (Gafas = 'S')

Resultado:

El uso de paréntesis

Los paréntesis se comportan como en matemáticas, no es lo mismo "5 + 4 / 3" donde primero se calculará la división y después se sumará 5, que "(5 + 4) / 3" donde primero se resolverá la suma y el resultado parcial se dividirá por 3. Sin paréntesis la división tiene prioridad sobre la suma, con paréntesis forzamos a que la operación se realice en el orden deseado.

Los operadores AND y OR tienen la misma prioridad de modo que se evalúa la expresión por orden de aparición:

No es lo mismo: "Rubia and Alta or Gafas" = "(Rubia and Alta) or Gafas" que, "Rubia and (Alta or Gafas)". En el primer caso estamos diciendo: "que sea rubia y alta, o bien lleve gafas", y en el segundo "que sea rubia y, sea alta o lleve gafas".

SELECT Nombre

FROM Personas

WHERE Rubia = 'S' AND Alta = 'S' OR Gafas = 'S'

Resultado:

SELECT Nombre

FROM Personas

WHERE Rubia = 'S' AND (Alta = 'S' OR Gafas = 'S')

Resumen

En esta lección se ha descrito como construir expresiones booleanas y como trabajar con ellas para establecer condiciones en la cláusula WHERE de una consulta SQL.

Las expresiones booleanas con operadores de comparación (tales como >, =, !=, etc.) precisan operandos de tipo número, cadena o fecha, y el resultado de evaluar la expresión devuelve siempre verdadero o falso.

Ejemplo: Salario > 1350

Las expresiones con operadores lógicos (tales como AND, OR y NOT) precisan expresiones booleanas como operandos, el conjunto es una nueva expresión booleana que al evaluarla devolverá siempre verdadero o falso.

Ejemplo: Rubia = 'S' AND Alta = 'S'

El uso de paréntesis garantiza que, en una expresión compleja las expresiones simples que la forman se evalúen en el orden que uno desea.

Ejemplo: NOT((Rubia = 'S' OR Alta = 'S') AND (Alta ='N' OR Gafas = 'S'))

Ejercicios propuestos

1.- Cree una consulta SQL que devuelva las personas que son altas, o bien son rubias con gafas.

2.- Cree una consulta SQL que devuelva los empleados que son de sexo femenino y cobran más de 1300 euros (en la tabla empleados se guarda una "H" en el campo SEXO para indicar que es hombre, o una "M" para indicar que es mujer).

Tipos de datos

Antes de seguir desarrollando las consultas SQL debemos hacer un alto en el camino y hablar de los tipos de datos, asunto que trataremos a continuación, y de los operadores, que veremos en la próxima lección. Es importante entender bien estos conceptos.

Tipos de datos

Los tipos de datos son un concepto propio de la informática, presente en cualquier lenguaje de programación, donde cada entorno de programación tiene su modo particular de definirlos. Los hay muy diversos, clasificados por grupos, definidos por el usuario, etc. En este caso vamos a considerar solamente estos cuatro tipos:

- Cadenas (cadenas de texto o alfanuméricas)

- Números enteros (sin decimales)

- Números decimales (parte entera + parte decimal)

- Fechas

Como ya se ha dicho, cada entorno tiene su modo particular de definir los tipos de dato, aunque todos ellos se rigen en mayor o menor medida por un estándar. Veamos como se define cada uno ellos en SQL Server:

1.- Cadena: VARCHAR(Tamaño)

Las cadenas de texto son de tipo VARCHAR, y su tamaño máximo para un campo concreto se especifica indicando su longitud entre paréntesis. Por ejemplo: al diseñar la tabla Empleados, se debe valorar que longitud máxima se establece para el campo Nombre, de manera que pueda albergar cualquier nombre de persona que se pueda dar.

En el caso de la tabla Empleados, se decidió que como mucho un nombre no sobrepasara las 30 letras o caracteres, de modo que el tipo de dato para este campo se definirá como: VARCHAR(30); es decir, en el campo Nombre de la tabla Empleados se puede guardar cualquier cadena alfanumérica de hasta 30 caracteres. Notar que al hablar de tamaño máximo, estamos hablando de la ubicación para muchos posibles datos, no del dato en sí. 

Cuando indicamos constantes en una consulta SQL, las cadenas de texto a diferencia de los números (ahora estamos hablando del dato en sí y no del tipo) siempre irán entre comillas simples para indicar al SGBD que se trata de una dato de tipo cadena y no de un dato de tipo número. Esto es muy importante y es necesario que quede bien entendido.

Por ejemplo, supongamos que queremos saber el salario que tiene Elena Rubio Cuestas. Un modo de hacerlo es realizar una consulta SQL que filtre por los apellidos, para tal propósito estableceremos una constante alfanumérica en la cláusula WHERE, exigiendo que sea igual al campo Apellidos (esta debe ir entre comillas).

SELECT Salario
FROM Empleados
WHERE Apellidos = 'Rubio Cuestas'

Notar que ahora no hablamos de tamaño máximo, pero podemos hablar del tamaño concreto del dato. En el caso de la constante 'Rubio Cuestas', su tamaño es 13.

De hecho existen mas tipos de dato para cadenas, cada uno con diferentes prestaciones, pero con el tipo VARCHAR nos sobra por ahora, así que asumiremos que es el único que existe.

2.- Número entero: INT

A diferencia del tipo VARCHAR, donde establecemos el tamaño máximo, para los números enteros existen varios tipos de dato de tamaño fijo, elegiremos uno u otro en función del tamaño máximo que necesitamos establecer. Cuando tratamos números es más correcto hablar de rango que de tamaño, es decir, bajo que rango de valores( máximo y mínimo) podemos operar con ese tipo. Como hicimos con el tipo cadena, nos quedaremos con uno para simplificar: el tipo INT.

El valor máximo y mínimo que puede alcanzar un número de este tipo es suficientemente alto y bajo como para no preocuparse por ello en el contexto de este curso. Recuerda que a diferencia de las cadenas, un entero no debe ir entre comillas en las consultas SQL cuando aparezca como constante.

Ejemplo de número entero: 3467

3.- Número decimal: FLOAT (coma flotante)

Para los números decimales también existen varios tipos de datos con diferentes rango de valores posibles. La parte entera la separamos por un punto de la parte decimal. Asumiremos que sólo existe el tipo FLOAT, con un rango de valores posibles suficientemente amplio. Al igual que los números enteros, los decimales no deben ir entre comillas en las consultas SQL.

Ejemplo de número decimal: 3467.00

4.- Fecha: DATE

El tipo DATE tiene el tamaño apropiado para registrar un dato de: año + mes + día. Existe también el tipo DATETIME, por ejemplo, que además del día registra la hora, y algunos más que no vamos a considerar por ahora.

Un dato de tipo DATE y/o DATETIME se expresa en forma de cadena con un formato determinado, de modo que quien procesa ese dato sabe cual es el año, el día o el mes en función de la posición que ocupa en la cadena alfanumérica.

Por ejemplo, tenemos el siguiente dato: 4 de noviembre de 2006. Para expresar este dato debemos hacerlo de la siguiente forma: 'aaaammdd' donde aaaa indica cuatro dígitos para el año, mm dos dígitos para el mes y dd dos dígitos para el día. De modo que el 4 de noviembre de 2006 lo expresaríamos así: '20061104' (también es válida la expresión '2006-11-04').

Al expresarse en forma de cadena, debe ir siempre entre comillas simples cuando aparece como constante en una consulta SQL. Existen otros modos de trabajar con datos de tipo DATE, pero por el momento supondremos que es el único modo que tenemos.

Ejemplo

Para finalizar la lección, echemos un vistazo a los tipos de datos bajo la columna llamada Type, de cada uno de los campos de la de la tabla Empleados:

Resumen

Cualquier dato es de un tipo concreto y tiene un tamaño determinado, en consecuencia cuando diseñamos una tabla, diseñaremos sus campos para ubicar un tipo de dato concreto y estableceremos un tamaño máximo para cada campo.

El tamaño máximo o rango de valores puede ir implícito en el propio tipo de dato, como es el caso del tipo INT, o bien debe especificarse en tiempo de diseño como ocurre con el tipo VARCHAR.

Los datos de tipo VARCHAR o cadenas de texto van siempre entre comillas simples, a diferencia de los números (INT y FLOAT).

Las fechas o datos de tipo DATE, se expresan en forma de cadena con un formato determinado, concretamente: 'aaaammdd' donde aaaa es el año, mm es el mes y dd es el día. Al ser cadenas deben ir siempre entre comillas simples.

Ejercicio propuesto

Defina de que tipo de dato crearía los campos, para almacenar los siguientes datos:

a) 'Hola mundo'

b) 9.36

c) 4564

d) 'Esto es un ejercicio de tipos de datos'

e) 8 de enero de 1998

Consultas II

En la lección anterior hemos construido con éxito nuestra primera consulta:

SELECT Nombre, Apellidos

FROM Empleados

WHERE Salario > 1350

Las tres cláusulas y las preguntas de construcción

Fijémonos ahora en las tres cláusulas de la consulta SQL anterior y que relación guardan con las preguntas de construcción:

1.- Cláusula SELECT: donde indicamos los campos de la tabla que queremos obtener, separados por comas. Responde a la pregunta: ¿Qué datos nos piden?

2.- Cláusula FROM: donde indicamos en que tabla se encuentran estos campos. Responde a la pregunta: ¿Dónde están los datos?

3.- Cláusula WHERE: donde establecemos la condición que deben cumplir los registros de la tabla que serán seleccionados. Responde a la pregunta: ¿Qué requisitos deben cumplir lo registros? Es de hecho donde se establece el filtro de registros, es decir, que registros serán considerados para mostrar sus datos y cuales no.

Modificando la cláusula WHERE

Imaginemos ahora la siguiente cuestión: ¿Qué empleados tienen un sueldo comprendido entre 1350 y 1450?

Si nos hacemos las preguntas de construcción:

1.- ¿Qué datos nos piden?

2.- ¿Dónde están los datos?

3.- ¿Qué requisitos deben cumplir los registros?

Observamos que para las dos primeras preguntas las respuestas son idénticas a la anterior cuestión, pero para la tercera es distinta. Esto nos indica que las cláusulas SELECT y FROM no van a cambiar respecto a la anterior consulta, y sólo lo hará la cláusula WHERE, así que podemos tomar la anterior consulta como patrón y modificarla para adaptarla a lo que se nos pide ahora.

SELECT Nombre, Apellidos

FROM Empleados

WHERE Salario > 1350

Antes el salario debía ser mayor a 1350, ahora debe estar comprendido entre 1350 y 1450, ambos inclusive. La cláusula WHERE la construiremos de la siguiente manera:

WHERE Salario >= 1350 AND Salario <= 1450

Y se lee así: donde el salario sea mayor o igual a 1350 y menor o igual a 1450. La consulta entonces quedaría:

SELECT Nombre, Apellidos

FROM Empleados

WHERE Salario >= 1350 AND Salario <= 1450

Si comparamos las dos consultas, se observa que difieren únicamente en la cláusula WHERE.

El operador BETWEEN

Existe otro modo de obtener el mismo resultado anterior aprovechando más los recursos de SQL mediante el operador BETWEEN (entre). La consulta es equivalente y quedaría de la siguiente manera:

SELECT Nombre, Apellidos

FROM Empleados

WHERE Salario BETWEEN 1350 AND 1450

Es decir: donde el salario esté entre 1350 y 1450, ambos inclusive.

Y el resultado que nos devuelve el SGBD es:

El motor SQL

Aunque en la lección anterior se dijo que SQL nos permite desentendernos de como se reúnen los datos, en un futuro nos vendrá bien entender de forma lógica su manera de proceder. Veamos como ejecuta esta consulta el motor SQL del SGBD. Primero seleccionará los registros que cumplen la condición de la cláusula WHERE, para ello debe recorrer todos los registros de la tabla y decidir, en función de la condición, si lo toma en consideración o no. Al final reunirá los campos indicados en la cláusula SELECT de la tabla indicada en la cláusula FROM cuyos registros han sido seleccionados por la clausula WHERE.

Resumen

Hemos dividido una consulta SQL concreta en tres cláusulas, se ha relacionado cada cláusula con las preguntas de construcción, hemos tomado como patrón una consulta para modificarla y adaptarla a los nuevos requisitos.

Ejercicio propuesto

Intenta hallar una consulta que devuelva el Nombre y Apellidos de los Empleados que cobren menos de 1350 euros.

Consultas I

Empecemos directamente con lo que será la tónica de este curso: las consultas SQL. Es en esta parte donde está lo esencial de SQL, y no será hasta el final que veremos la creación de tablas y cómo modificar su información. Después de todo no tiene sentido aprender primero a crear tablas si no sabemos que hacer con ellas.

Consultas SQL

Abordemos las consultas SQL con un caso práctico. Sobre la tabla Empleados se plantea la siguiente cuestión: ¿Qué empleados tienen un salario mayor a 1350?

La respuesta es simple: José y Carlos tiene un salario mayor a 1350, pero si tuviésemos 500 empleados nos llevaría más tiempo responder, y al final tampoco tendríamos la certeza de no habernos equivocado. SQL nos permite responder estas preguntas de forma rápida y fiable, excepto si existe algún error al construir la consulta o en los propios datos.

Vamos a construir la consulta que nos permita responder a esta cuestión.

Preguntas de Construcción

Para construir una consulta SQL debemos hacernos como mínimo tres preguntas:

1.- ¿Qué datos nos están pidiendo?
En este caso, el nombre y los apellidos de los empleados.

2.- ¿Dónde están esos datos? 
Obviamente están en la tabla empleados.

3.- ¿Qué requisitos deben cumplir los registros?
En este caso, que el sueldo del empleado sea superior a 1350.

Vamos a suponer por un momento que el SGBD (que es quien intermedia entre el usuario y la BD) fuese una persona; la BD un archivo de papel, y el jefe pide lo siguiente: "Necesito saber ¿qué empleados cobran más de 1350 euros?" Tu, que conoces bien el archivo (tablas) y los datos que contiene la ficha de un empleado (campos de la tabla Empleados), mentalmente comienzas a hacerte las preguntas de construcción y le dices a tu ayudante que siempre espera ordenes concretas:

Seleccioname el Nombre y los Apellidos
del archivo Empleados
cuyo Salario sea mayor a 1350

El ayudante sirve la petición y te la entrega para que finalmente tu se la facilites al jefe. ¿Qué papel ocuparían hoy en una empresa moderna? El jefe sigue siendo el jefe, eso está claro, pero tu has pasado a ser el informático, y tu ayudante el SGBD.

Sintaxis SQL

En SQL la forma de operar es parecida, esta información se obtiene mediante la siguiente consulta:

SELECT Nombre, Apellidos
FROM Empleados
WHERE Salario > 1350

Y el resultado que nos devuelve el SGBD es:

Parecido a lo que te entregaría tu ayudante en el archivo, una lista con la respuesta o solución a la cuestión planteada. Como puedes ver, tanto el modo de solicitar la información al SGBD, sea clásico y informatizado, como el modo en que este nos muestra la información son muy similares (al menos en este caso). No podemos afirmar lo mismo del tiempo en que uno y otro tardan en facilitarnos la información solicitada.

Forma general

En general una consulta SQL simple tendrá la siguiente forma:

SELECT <Campos> (Separados por comas)
FROM <Tabla>
WHERE <Condición>

SQL permite al usuario desentenderse de como el SGBD ejecuta la consulta, al igual que tu te desentiendes de como tu ayudante se las ingenia para facilitarte la información. Tu esperarás pacientemente a que tu ayudante prepare el pedido y te entregue los datos. Dicho de otro modo, basta con saber como pedir la información y no como proceder a reunirla.

Resumen

Hemos visto como construir una consulta SQL simple y concreta, que nos da la solución a una cuestión concreta.

Se ha definido la forma general de una consulta SQL simple:

SELECT <Campos> (Separados por comas)
FROM <Tabla>
WHERE <Condición>

Destacar también la utilidad de las preguntas de construcción para ayudarnos a construir la consulta:
1.- ¿Qué datos nos piden?
2.- ¿Dónde están los datos?
3.- ¿Qué requisitos debe cumplir los registros?

En una empresa moderna un informático cumple la función de encargado del archivo, y sus ayudantes son hoy los sistemas informatizados (SGBD).

Ejercicio propuesto

Intenta hallar una consulta que devuelva el Nombre, Apellidos y la Fecha de nacimiento de aquellos Empleados que cobren más de 1350 euros.