Tras aprender a definir la estructura de la base de datos y a cargar, borrar o actualizar, los datos en las tablas, nos queda aprender como consultar los datos. Esto lo haremos con los comandos SQL para la recuperación de datos, las conocidas como consultas de selección, donde el comando SELECT resulta fundamental.
La sintaxis básica es:
SELECT [ALL | DISTINCT] <lista de campos> FROM <lista de tablas>
[WHERE ….]
[GROUP BY…]
[HAVING….]
[ORDER BY…]
En este post vamos a estudiar los principales comandos SQL para modificar los datos de las tablas de nuestra base de datos. Básicamente tenemos tres comandos para realizar las tres operaciones básicas:
INSERT INTO
Escribir un dato nuevo.
Sintaxis:
INSERT INTO <Tabla> [(campo1,campo2…..)]
VALUES (valor1, valor2, …)
La instrucción debe tener tantos valores como campos se pretenden rellenar y dichos valores deben ser del tipo que almacena el campo destino. En caso de no ser compatible el tipo de dato que queremos almacenar con el tipo del campo destino, se produciría un error y no se completaría la escritura de los datos.
UPDATE
Modificar el valor de un dato: Hay que indicar la tabla y los campos que se quieren actualizar. También podemos indicar un criterio que deben de cumplir los registros para que se produzca la actualización, pero esto es opcional.
Sintaxis
UPDATE tabla
SET campo1 = valor1, campo2 = valor 2,…
WHERE <criterio>
DELETE
Borrar un dato: Con esta instrucción, eliminamos los registros de la tabla indicada tras el comando FROM, y que cumplan los criterios definidos tras el comando WHERE
Sintaxis
DELETE FROM tabla
WHERE <criterios>
Y para practicar estos comandos, realizaremos el ejercicio siguiente:
Ejemplo: Manipulación de datos con SQL
Partimos de la BBDD ProveedoresSQL, que creamos en el post anterior. En ella ya tenemos creadas las dos tablas con las que de momento estamos funcionando: Proveedores y Productos. Pero estas están vacías, todavía no hemos cargado ningún dato.
Paso 1: Sentencias SQL para la carga de datos en la tabla proveedores.
Pongamos que primero vamos a cargar los datos en la Tabla proveedores. Las tres primeras sentencias para cargar los tres primeros registros serían:
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(1,"Arroces La Cigala","Maria Alvarez","677889922");
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(2,"Arroces La Cigala","Maria Alvarez","677889924");
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(3,"Azucarera Sevillana","Rodrigo Mendez","622525885");
En el módulo que creamos en el ejercicio anterior, y que bautizamos con el nombre “PracticasConSQL”, creamos el siguiente procedimiento para ejecutar estas sentencias SQL:
Estas sentencias SQL, al ser sentencias de modificación de datos que no afectan a la estructura de la BBDD, podríamos haberla ejecutado desde la vistaSQL en el interfaz de Access. No obstante, vemos como hacerlo por código en VBA, por si tuviéramos muchos datos y tuviéramos que leerlos de un fichero.
Paso 2: Borrando registros erroneos
Inmediatamente después de la carga nos damos cuenta que el segundo registro en realidad está duplicado, tenía el campo del Teléfono mal. Decidimos eliminar el registro completo, lo cual hacemos ejecutando la siguiente sentencia SQL:
DELETE Proveedores.idProveedor, Proveedores.NombreProveedor, Proveedores.ContactoProveedor, Proveedores.Telefono
FROM Proveedores
WHERE (Proveedores.idProveedor=2);
En esta ocasión, lo hacemos desde la vistaSQL de Access.
Paso 3: Actualizando datos
Ya hemos visto como cargar un registro nuevo en una tabla y como borrarlo completamente, nos queda aprender a actualizar el valor de un campo, sin afectar al resto del registro.
Supongamos que Rodrigo Mendez, el contacto de Azucarera Sevillana nos llama para decirnos que ha cambiado el teléfono, que su nuevo numero es 698527414.
Tendríamos que actualizar el número de teléfono de este contacto, para lo que podemos usar la siguiente sentencia SQL:
UPDATE Proveedores SET Proveedores.Telefono = "698527414"
WHERE (Proveedores.ContactoProveedor="Rodrigo Mendez");
Si ejecutamos ahora esta sentencia SQL, veremos como se nos actualiza el valor del teléfono de Rodrigo Mendez. He establecido la condición por el nombre del contacto, pero podía haberlo hecho por el número de registro (el 3).
NOTA:
Este post es parte de la colección “Sistemas de acceso y almacenamiento de datos”. Puedes ver el índice de esta colección aquí.
SQL significa Structured Query Language, que puede ser traducido como lenguaje de consultas estructuradas. Luego se trata de un lenguaje de programación que emplearemos para hacer consultas. Y es el lenguaje de programación más ampliamente usado para trabajar con bases de datos relacionales.
¿Qué es SQL?
Por tanto, podemos definir SQL como un lenguaje de programación que emplearemos para gestionar las bases de datos relacionales.
En este apartado, vamos a ver como pasar los datos de un fichero a una base de datos relacional, y de esta manera organizar nuestros datos de manera más eficiente y evitar errores. Para verlo en la práctica, trasladaremos los datos del fichero de proveedores de Antonio a una base de datos Access.
Paso 1: Creamos una base de datos
Creamos una base de datos nueva, le ponemos el nombre que queramos, por ejemplo: Proveedores
Paso 2: Creamos una tabla con todos los datos del fichero
Lo primero que haremos, será traernos todos los datos de nuestro fichero de proveedores a una única tabla. Lógicamente, en esta tabla vamos a tener mucha información redundante, ya que sencillamente vamos a copiar la estructura de nuestro fichero.
Para poder explicar adecuadamente el proceso, he generado algunos datos más, e introducido algunos errores que perfectamente podrían haberse cometido al registrar la información en un fichero y repetir ciertos datos varias veces. Nuestros datos de partida serían:
Tabla de datos
Paso 3: Definiendo las estructuras de las nuevas tablas
Estudiando la estructura de nuestros datos, vemos que hay cierta información, la relativa a los datos del proveedor, que se repite varias veces en varios registros. Por el contrario, la información de producto varia de un registro a otro, incluso cuando el producto es el mismo, pueden tener distinto precio.
En esta situación, lo que tiene sentido es crear una tabla para los datos de proveedores con los siguientes campos: NombreProveedor, ContactoProveedor y Telefono. Y una segunda tabla con los datos Producto y Precio.
Tabla1:
NombreProveedor.
ContactoProveedor.
Telefono
Tabla2:
Producto.
Precio.
Paso 4: Relación entre las tablas creadas
No obstante, si sencillamente separamos los datos, y los colocamos en tablas independientes, estaríamos perdiendo información muy valiosa, no sabríamos que producto con que precio corresponde a cada proveedor.
Tenemos que establecer una relación entre las dos tablas creadas, de forma que no se pierda información, que sepamos que producto corresponde a cada proveedor. Necesitamos por tanto un campo en la Tabla2 que identifique de forma univoca al proveedor. Este campo, lo tenemos que tener también en la Tabla1 para poder establecer la relación.
Escogemos NombreProveedor de Tabla1 como campo para la relación. Podríamos haber escogido cualquier otro, siempre que no tuviera valores repetidos, ya que si los tuviera, ese duplicado representaría a dos proveedores, y no tendríamos forma en Tabla2 de saber a cual de los dos nos referimos.
La estructura definida para nuestra BBDD tendría el siguiente aspecto:
Relaciones entre tablas
Paso 5: Chequeando y mejorando la calidad de los datos
Antes de proceder a la creación de las nuevas tablas, debemos chequear la calidad de los datos. Para ello vamos a realizar diversas consultas sobre la tabla de partida que contiene todos los datos:
Consulta_1: Calidad_NombreProveedor
Para chequear los datos de los nombres de Proveedores. Agrupamos los nombres de los proveedores y contamos las veces que aparecen.
El código SQL de la consulta sería:
SELECT FicheroInicialProveedores.NombreProveedor, Count(FicheroInicialProveedores.NombreProveedor) AS CuentaDeNombreProveedor
FROM FicheroInicialProveedores
GROUP BY FicheroInicialProveedores.NombreProveedor
ORDER BY FicheroInicialProveedores.NombreProveedor;
Más adelante introduciremos el lenguaje SQL, de momento, para esta práctica, sencillamente crearemos una consulta en Access y, en la vistaSQL, copiaremos la sentencia SQL de la consulta.
Ejecutamos la consulta y obtenemos el siguiente resultado:
Resultado de la consulta cuenta de proveedores
Podemos observar que hay dos registros “sospechosos”:
“Azucarera Sevilana” seguramente es erróneo y corresponde a “Azucarera Sevillana”, sencillamente nos comimos una “l” al introducir dicho registro.
De igual forma, “Frutas Gutierez” es erróneo, en realidad es “Frutas Gutierrez”, en este caso nos comimos una “r”.
Consulta_2: Corrección_NombreProveedor
Al manejar tan pocos datos en esta practica, podríamos estar tentados de actualizar los datos directamente en los registros afectados. Pero en una situación real, con muchísimos más registros, estas actualizaciones no podemos realizarlas de manera manual una a una, sino que las realizaríamos mediante consultas de actualización.
La primera de las consultas de actualización sería:
UPDATE FicheroInicialProveedores SET FicheroInicialProveedores.NombreProveedor = "Azucarera Sevillana"
WHERE (((FicheroInicialProveedores.NombreProveedor)="Azucarera Sevilana"));
Si ejecutamos la consulta, buscamos los registros que tengan nombre de proveedor: “Azucarera Sevilana” y le cambiamos el valor a “Azucarera Sevillana”.
Lógicamente, la consulta para corregir el nombre de Frutas Gutierez sería la misma con otros literales:
UPDATE FicheroInicialProveedores SET FicheroInicialProveedores.NombreProveedor = "Frutas Gutierrez"
WHERE (((FicheroInicialProveedores.NombreProveedor)="Frutas Gutierez"));
Tras ejecutar estas dos consultas de actualización, ejecutamos la anterior consulta: Consulta_1: Calidad_NombreProveedor
El resultado que obtenemos ahora es el siguiente:
Consulta cuenta de proveedores
Donde ya no detectamos registros de NombreProveedor que sean erróneos.
Consulta_3:Calidad_ContactoProveedor:
Realizamos una operación similar para los datos del campo: ContactoProveedor y veremos que en este caso no detectamos errores.
Consulta_4: Calidad_Tabla1
Y finalmente, realizamos la consulta sobre todos los datos de la que sería nuestra Tabla1, con la información de proveedores.
En este caso si detectamos errores, hay algunos contactos que aparecen con más de un número de teléfono, lo que es erróneo, se produce porque nos hemos equivocado cuando introducimos los datos.
La sentencia SQL de esta consulta sería:
SELECT FicheroInicialProveedores.NombreProveedor, FicheroInicialProveedores.ContactoProveedor, FicheroInicialProveedores.Telefono, Count(FicheroInicialProveedores.NombreProveedor) AS CuentaDeNombreProveedor
FROM FicheroInicialProveedores
GROUP BY FicheroInicialProveedores.NombreProveedor, FicheroInicialProveedores.ContactoProveedor, FicheroInicialProveedores.Telefono;
Si la ejecutamos, obtendríamos el resultado:
Consulta que muestra los errores de introducción
Donde podemos ver dos resultados con cuenta 1, que probablemente sean erróneos. Para aquellos proveedores que tienen más de un número de teléfono, habría que asegurarse de cual de ellos es el correcto, y actualizar los datos en la tabla vía consultas de actualización.
Tras corregir estos errores, si ejecutamos de nuevo la Consulta_4: Calidad_Tabla1, obtendremos:
Consulta que muestra que se han corregido los errores
Donde ya no detectamos errores.
NOTA: La información de producto también convendría repasarla e intentar mejorar la calidad de los datos. No obstante, eso queda fuera del objetivo de esta práctica
Paso 6: Generando las nuevas tablas
Una vez hemos revisado la tabla con todos los datos de proveedores, y corregido los errores detectados, vamos a crear las nuevas tablas definidas en el Paso 4.
Consulta_5: Creación_Tabla1
Ejecutamos la siguiente consulta para generar la tabla de proveedores:
SELECT FicheroInicialProveedores.NombreProveedor, FicheroInicialProveedores.ContactoProveedor, FicheroInicialProveedores.Telefono INTO Proveedores
FROM FicheroInicialProveedores
GROUP BY FicheroInicialProveedores.NombreProveedor, FicheroInicialProveedores.ContactoProveedor, FicheroInicialProveedores.Telefono
ORDER BY FicheroInicialProveedores.NombreProveedor;
Tras su ejecución, veremos que hemos creado la Tabla Proveedores que corresponde a la Tabla1 de nuestra estructura.
A continuación, generaremos la otra tabla de nuestra estructura, la que contiene la información de Productos. Hay que recordar que en esta tabla necesitamos tener también el campo NombreProveedor, ya que será el que usemos para establecer la relación con la Tabla1.
Consulta_6: Creación_Tabla2
Ejecutamos la siguiente instrucción SQL para generar la Tabla2:
SELECT FicheroInicialProveedores.NombreProveedor, FicheroInicialProveedores.Producto, FicheroInicialProveedores.Precio INTO ProductosEnProveedores
FROM FicheroInicialProveedores
ORDER BY FicheroInicialProveedores.NombreProveedor;
Tras ejecutar ambas consultas, tendremos dos nuevas tablas: Proveedores y ProductosEnProveedores. Estas tablas se relacionarán por medio del campo NombreProveedor:
Nuevas relaciones
Paso 7: Accediendo a los datos
Mediante la relación definida entre los campos NombreProveedor de ambas tablas, podremos acceder a los datos de ambas tablas de manera combinada.
Imaginemos que queremos saber que proveedores nos pueden suministrar Naranjas. En este caso podríamos emplear únicamente la Tabla “ProductosEnProveedores” porque en ella tenemos toda la información que estamos buscando.
Pero si queremos que también nos aparezca en la consulta el contacto del proveedor y el teléfono, porque estamos buscando los proveedores que nos pueden suministrar Naranjas para realizar un pedido. En este caso, necesitamos recuperar datos de ambas tablas de manera coordinada.
Consulta_7: Naranjas
Ejecutamos la siguiente instrucción SQL para obtener la información de los proveedores que suministran Naranjas y poder hacerles un pedido.
SELECT Proveedores.NombreProveedor, Proveedores.ContactoProveedor, Proveedores.Telefono, ProductosEnProveedores.Producto, ProductosEnProveedores.Precio
FROM Proveedores INNER JOIN ProductosEnProveedores ON Proveedores.NombreProveedor = ProductosEnProveedores.NombreProveedor
WHERE (((ProductosEnProveedores.Producto)="Naranja"));
La instrucción INNER JOIN es la que define la relación entre ambas tablas, pero esto lo veremos más adelante cuando aprendamos SQL.
Si ejecutamos la consulta, obtendríamos el siguiente resultado:
Consulta relacionando datos de distintas tablas
Paso 8: Conclusiones
Repasemos lo que hemos hecho para entender el cambio de paradigma que supuso la irrupción de las bases de datos relacionales.
Previamente almacenábamos los datos en ficheros y registrábamos toda la información cada vez que insertábamos una nueva información. En nuestro ejemplo, teníamos que introducir de nuevo todos los datos del proveedor, aunque sólo quisiéramos registrar un nuevo producto para un proveedor ya conocido y registrado. Esto al final ocasionaba muchos errores y una perdida importante de calidad en los datos.
Con las bases de datos relacionales, estructuramos los datos en tablas y definíamos relaciones entre ellas que nos permitían recuperar todos los datos que necesitáramos. De esta forma evitábamos introducir la misma información muchas veces, minimizábamos errores y contribuíamos a mantener la calidad de nuestros datos.
Además, definíamos una estructura de datos que era independiente del soporte físico que almacenaba los datos, dejando a los gestores de BBDDs (software) gestionar la interacción de nuestra estructura con el soporte físico de los datos. Por supuesto, este nivel de abstracción facilita enormemente el trabajo con los datos y reduce el número de errores.
NOTA:
Este post es parte de la colección “Sistemas de acceso y almacenamiento de datos”. Puedes ver el índice de esta colección aquí.
La base de datos relacional vino a dar respuesta a la necesidad de estructurar la información que se venía manejando en distintos ficheros. La creciente cantidad de datos con los que se trabajaba hacía que cada vez se crearan más ficheros con datos y forzó a encontrar una manera eficiente de estructurar toda esa información.
¿Qué es una base de datos relacional?
En realidad, una base de datos relacional no es otra cosa que un software que nos permite manejar estructuras de datos entre las que se crean relaciones. De esta forma, los datos no están aislados en las distintas estructuras, sino que están relacionados a través de las relaciones que se crean entre partes de estas estructuras.
Las estructuras en una base de datos relacional son las tablas, compuestas de varias columnas y filas. Las columnas representan los atributos de los datos que queremos almacenar, que normalmente denominaremos campos. Y en cada fila registramos un conjunto de valores para los distintos atributos, conformando lo que denominaremos un registro.
Probablemente, todos sabemos lo que es un escáner y para qué sirve, aunque quizás no tengamos tan claro su funcionamiento. En este post, explico como funciona el escáner y espero aportar un poco luz sobre este tema.
Empleamos un escáner para digitalizar imágenes o textos que podemos tener en distintos soportes analógicos: fotografías, papeles, etc. Dicho así, puede sonar como una cámara digital, como la que tenemos en nuestro móvil, y ciertamente es muy parecido.
Ambos dispositivos, escáner y cámara, emplean un sensor CCD (Charge Coupled Device) que es un dispositivo capaz de transformar la luz que sobre él incide, en señales eléctricas. Posteriormente, otro elemento llamado DAC (Digital to Analogue converter) traduce dichas señales eléctricas a bits, conjuntos de unos y ceros.
El sensor CCD está compuesto por una matriz de puntos sensibles, cada uno de los cuales genera una señal eléctrica que depende de la intensidad y color de la luz que sobre él incida. De esta forma, podemos conocer el color y brillo de cada punto.
Empleando el DAC, convertimos las señales eléctricas generadas en cada punto en una señal digital, y juntando las lecturas de todos los puntos tenemos nuestra imagen digitalizada.
¿Cuáles son entonces las diferencias entre una cámara y un escáner? En la primera, el sensor CCD está fijo y mediante un juego de lentes hacemos que indica sobre él, la luz reflejada por los objetos, controlando la cantidad de luz y el tiempo de exposición. En el segundo, recorremos la imagen que queremos escanear, iluminándola y haciendo que la luz reflejada incida sobre el CCD. Lo más habitual es que el sensor este fijo y se desplace la fuente de iluminación y un juego de espejos que será el que conduzca la luz reflejada al sensor que permanecerá fijo. Podéis apreciarlo en la siguiente figura:
En este post, os propongo algunos ejercicios con arrays en Java para practicar lo explicado en el post anterior en el que contaba como trabajar con los arrays. Como siempre digo, existen varias soluciones posibles para resolver un mismo problema, unas más eficientes que otras. Aquí podéis ver una solución posible para cada ejercicio propuesto.
Ejercicio 1: Numero veces letra en texto
Escribe un programa que pida al usuario que introduzca un texto y una letra. Después el programa tiene que calcular y presentar por pantalla, cuantas veces aparece la letra en el texto.
Continuando con las notas de Java, vamos a ver cómo trabajar con los Arrays en Java. Un array o arreglo, es un grupo de varias variables del mismo tipo que se agrupan bajo un mismo nombre.
Los arrays son útiles porque permiten trabajar con muchos datos de un mismo tipo sin tener que declarar cada variable individualmente. En lugar de crear una variable para cada valor, creamos un array y accedemos a cada dato empleando un número (llamado indice) que indica la posición del dato en el array.
En los arrays, los elementos están ordenados de forma secuencial, y cada posición se identifica con un índice. Los índices del array empiezan siempre con el valor 0 que apunta a la posición 1, el indice de valor 1 apunta a la posición 2 y así sucesivamente.
Accedemos a cada elemento del array utilizando el índice. Por ejemplo, si queremos acceder al elemento del array que ocupa la posición 5, tendríamos que referenciarlo usando el valor 4 para el índice, ya que empezamos a contar desde cero.
Declarar un array
Para poder trabajar con un array, lo primero que tenemos que hacer es declararlo.
Cuando declaramos un array, definimos el tipo de las variables que almacenaremos en el array (recordad que son todas del mismo tipo). A continuación, abrimos y cerramos corchetes, y después escribimos el nombre del array. La sintaxis sería la siguiente:
<type>[] variable_name
Por ejemplo, la declaración de un array de enteros llamado misNumeros y de un array de textos llamado nombres sería:
int[ ] misNumeros
String[ ] nombres
Sin embargo, para acabar de crear el array y reservar espacio en memoria para sus valores, hay que especificar el tamaño del mismo. Es decir, cuantas variables del tipo declarado va a contener. La sintaxis es:
variable_name = new type[size]
Para los dos arrays anteriores (misNumeros y nombres), suponiendo que el primero va a contener 7 números enteros y el segundo 5 nombres, las instrucciones para crearlos serían:
La herencia es un proceso mediante el cual heredamos una serie de características de nuestros antecesores. La herencia en Java la podemos definir como un mecanismo para definir una clase nueva a partir de otra ya existente. La clase nueva hereda de la existente sus parámetros y métodos, que no hace falta definirlos de nuevo, sencillamente los hereda. Además, dicha clase nueva puede incluir nuevos parámetros y métodos propios, extendiendo la clase ya existente.
Se denomina clase padre o superclass a la clase existente de la que hereda la nueva clase que es conocida como clase hija.
Para entender y practicar con la herencia de clases, vamos a emplear el siguiente esquema:
Herencia en Java
En este esquema, la superclase es “Vehículo rodado”, de la que heredan dos clases: “Coche” y “Bicicleta”. Además, tenemos otras dos clases: “Descapotable” y “Sedan”, que heredan de la clase “Coche”, que para aquellas dos clases sería la superclase.
