Una invitación a MySQL Workbench

Objetivo: presentar MySQL Workbench, una herramienta gráfica integral para nuestro día a día con MySQL.

Hasta el momento hemos estado interactuando con el servidor MySQL a través de la línea de comandos. Aunque, en última instancia, se trata siempre de la forma más poderosa de acceso, deberíamos agradecer la existencia de herramientas gráficas que nos facilitaran nuestro trabajo cotidiano.

Esas herramientas existen y este artículo es una invitación para que, si no lo has hecho aún, visites nuevamente el site de MySQL y descargues e instales la más inmediata de ellas: MySQL Workbench, disponible para Linux, Windows o Mac OS X.

Tradicionalmente se ha dividido el trabajo con bases de datos en varios roles: el diseñador, encargado de modelar y diseñar las tablas y sus relaciones; el desarrollador, que interactúa con la base de datos a través del lenguaje SQL y, finalmente, el administrador, que cuida de la instalación, mantenimiento y optimización del servidor de bases de datos. Estos roles, naturalmente, pueden coincidir en la misma persona, aunque en un entorno profesional suele tratarse de figuras distintas.

MySQL Workbench es un todo en uno pensado para asistir tanto al diseñador como al desarrollador o al administrador de bases de datos MySQL.

MySQL Workbench
La nueva interfaz sobria de MySQL Workbench

El administrador dispone de un repositorio centralizado desde el que puede gestionar sus servidores: arranque, parada, gestión de usarios, copias de seguridad, etc., y todo ello desde la comodidad de una interfaz gráfica.

El diseñador cuenta con herramientas visuales que le asistirán en el modelado, como la creación de diagramas ER (Entity-Relationship, de los que nos ocuparemos más adelante), con los que representará una abstracción del problema que podrá ser revisada y refinada por las distintas partes antes de su implementación física.

Si has leído los artículos anteriores, en los que hemos estado más centrados en la perspectiva del desarrollador, creando tablas, insertando, modificando o consultando datos, apreciarás lo engorroso que puede resultar el trabajo con SQL desde la línea de comandos, con limitadas capacidades de edición. MySQL Workbench te ofrece un entorno de desarrollo con las capacidades similares a un IDE en otros lenguajes de programación, como son la auto compleción, el uso de colores en el código o la capacidad de almacenar y recuperar nuestras queries. Dispone, además, de herramientas visuales con las que podemos visualizar y actuar sobre los objetos de nuestra base de datos (creación de tablas, modificación de su estructura, etc.).

Trabajar con queries desde la línea de comandos no tiene color (esto es literal) comparado a cómo se hace desde MySQL Workbench. Visitaremos esta herramienta a menudo en los próximoss artículos; no obstante, es tan intuitiva que puedes sacarle partido en apenas un minuto sin necesidad de leer complejos manuales. Te invito a descubrirla.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2014/06/una-invitacion-a-mysql-workbench/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL: Polvo somos y en polvo nos convertiremos

Objetivo: revisar los comandos de creación y destrucción de bases de datos, tablas y registros en MySQL.

Con toda nuestra ilusión y repletos de esperanza, creamos una base de datos:

mysql> CREATE DATABASE circunstancias;
Query OK, 1 row affected (0.01 sec)

Una más en la familia:

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| cdcol              |
| circunstancias     |
| mysql              |
| performance_schema |
| phpmyadmin         |
| test               |
| webauth            |
+--------------------+
8 rows in set (0.01 sec)

Para trabajar con ella, primero la seleccionamos:

mysql> USE circunstancias;
Database changed

Dándole sentido a nuestra existencia, poblamos la incipiente base de datos con tablas a doquier:

mysql> CREATE TABLE anhelos
    -> (
    -> deseo VARCHAR(50),
    -> fecha DATE
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> CREATE TABLE objetivos
    -> (
    -> objetivo VARCHAR(50),
    -> fecha DATE
    -> );
Query OK, 0 rows affected (0.05 sec)

Nos autocomplacemos contemplando la estructura de nuestras posesiones:

mysql> DESC anhelos;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| deseo | varchar(50) | YES  |     | NULL    |       |
| fecha | date        | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.02 sec)

mysql> DESC objetivos;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| objetivo | varchar(50) | YES  |     | NULL    |       |
| fecha    | date        | YES  |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+
2 rows in set (0.01 sec)

mysql> SHOW TABLES;
+--------------------------+
| Tables_in_circunstancias |
+--------------------------+
| anhelos                  |
| objetivos                |
+--------------------------+
2 rows in set (0.00 sec)

Y empezamos a coleccionar, a acumular datos sin ton ni son y nos engañamos creyendo que eso da sentido a nuestras vidas:

mysql> INSERT INTO anhelos VALUES
    -> ('Viajar a Marte', '2015-12-31'),
    -> ('Aprender la receta  de las patatas bravas', '2013-7-31');
Query OK, 2 rows affected (0.06 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM anhelos;
+-------------------------------------------+------------+
| deseo                                     | fecha      |
+-------------------------------------------+------------+
| Viajar a Marte                            | 2015-12-31 |
| Aprender la receta  de las patatas bravas | 2013-07-31 |
+-------------------------------------------+------------+
2 rows in set (0.01 sec)

Pero, ¿por qué engañarme? Nunca iré a Marte; nunca aprenderé la receta de la salsa de las patatas bravas.

Y nada es eterno. Ni nuestros datos:

mysql> DELETE FROM anhelos;
Query OK, 2 rows affected (0.05 sec)

mysql> SELECT * FROM anhelos;
Empty set (0.00 sec)

Ni nuestras tablas:

mysql> DROP TABLE anhelos;
Query OK, 0 rows affected (0.03 sec)

mysql> DROP TABLE objetivos;
Query OK, 0 rows affected (0.03 sec)

mysql> SHOW TABLES;
Empty set (0.00 sec)

Ni nuestra base de datos:

mysql> DROP DATABASE circunstancias;
Query OK, 2 rows affected (0.13 sec)

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| cdcol              |
| mysql              |
| performance_schema |
| phpmyadmin         |
| test               |
| webauth            |
+--------------------+
7 rows in set (0.01 sec)

Ni nosotros mismos:

mysql> quit
Bye

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/12/mysql-polvo-somos-y-en-polvo-nos-convertiremos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL: Modificando los datos de una tabla

Objetivo: aprender lo fundamental para poder modificar datos en tablas MySQL.

Llevo toda la mañana con el gusanillo de escribir algo sobre MySQL y estaba deseando llegar a casa para ponerme a hacerlo. No suelo decidir con antelación a qué dedicaré el siguiente artículo del blog hasta el mismo día en que he de escribirlo. Mis motivaciones pueden ser diferentes: últimamente he escrito bastante sobre Python porque estoy desarrollando mis propias herramientas de productividad empleando ese lenguaje y me resulta mucho más cómodo no desconectar y seguir con lo mismo que dar un brusco requiebro (la programación es como el ajedrez y las matemáticas: monopoliza tu atención y energía); otras veces tomo en consideración los comentarios que me hacen llegar los que me leen (particularmente de modo habitual) e intento ayudarlos preferentemente; y, desde luego, también está el remordimiento, que por ejemplo me está martirizando recordándome que llevo varios meses sin decir ni pío sobre Knoppix (entre otros temas).

Sea lo que sea, es el momento de aplicar una nueva mano de pintura sobre MySQL.

Si echas un vistazo al índice general de artículos dedicados al tema (los más recientes son los de arriba) verás qué ya sabemos hacer bastantes cosas: crear tablas, rellenarlas, agregar nuevos datos, eliminarlos… Hoy veremos cómo cambiar datos ya existentes.

Tomemos una tabla de ejemplo, como esta que me he encontrado de artículos anteriores:

mysql> select * from consumibles;
+------------+---------------------+-------+
| referencia | impresora           | stock |
+------------+---------------------+-------+
| ACME2598X  | ACME INKJET Ultra   |     5 |
| ACME4501Y  | ACME PseudoJET Plus |    12 |
+------------+---------------------+-------+
2 rows in set (0.00 sec)

Se trata de una sencilla tabla para mantener el stock de consumibles de impresión. Agregaremos algunas filas para tener más juego, a la vez que nos servirá para repasar conceptos:

mysql> INSERT INTO consumibles VALUES
    -> ('WG31', 'WALNUT InkJetPrad', 2);
Query OK, 1 row affected (0.13 sec)

mysql> INSERT INTO consumibles VALUES
    -> ('WG40', 'WALNUT LaserGROVE', 10);
Query OK, 1 row affected (0.06 sec)

Tras lo cual consumibles ofrece el siguiente aspecto:

mysql> SELECT * FROM consumibles;
+------------+---------------------+-------+
| referencia | impresora           | stock |
+------------+---------------------+-------+
| ACME2598X  | ACME INKJET Ultra   |     5 |
| ACME4501Y  | ACME PseudoJET Plus |    12 |
| WG31       | WALNUT InkJetPrad   |     2 |
| WG40       | WALNUT LaserGROVE   |    10 |
+------------+---------------------+-------+

Imagina a continuación que colocamos un tóner de la LaserGROVE y otro de la PseudoJET, disminuyendo su stock en una unidad. ¿Cómo reflejaríamos estos cambios en la tabla de consumibles?

Comencemos por la LaserGROVE. Presta mucha atención al siguiente comando:

mysql> UPDATE consumibles SET stock = 9
    -> WHERE referencia = 'WG40';
Query OK, 1 row affected (0.07 sec)
Rows matched: 1  Changed: 1  Warnings: 0

El comando es UPDATE, seguido del nombre de la tabla. A continuación, con SET, indicamos la columna o columnas que queremos modificar, junto con su valor. La claúsula WHERE, que ya conociste en el artículo dedicado a cómo eliminar registros, nos sirve para indicar en qué filas realizaremos los cambios.

Has de ser muy cuidadoso con WHERE, pues, tal como está escrito el comando, se actualizarán todas las filas que cumplan la condición del filtro. En caso de duda, no hubiese estado de más comprobar mediante un SELECT cuál sería el ámbito de actuación antes de realizar la modificación:

mysql> SELECT * FROM consumibles WHERE referencia = 'WG40';
+------------+-------------------+-------+
| referencia | impresora         | stock |
+------------+-------------------+-------+
| WG40       | WALNUT LaserGROVE |    10 |
+------------+-------------------+-------+
1 row in set (0.00 sec)

Como puedes observar, sólo aparece la fila sobre la que queremos actuar.

Fíjate cómo queda la tabla consumibles tras la actualización del stock de la LaserGrove:

mysql> Smysql> SELECT * FROM consumibles;
+------------+---------------------+-------+
| referencia | impresora           | stock |
+------------+---------------------+-------+
| ACME2598X  | ACME INKJET Ultra   |     5 |
| ACME4501Y  | ACME PseudoJET Plus |    12 |
| WG31       | WALNUT InkJetPrad   |     2 |
| WG40       | WALNUT LaserGROVE   |     9 |
+------------+---------------------+-------+
4 rows in set (0.00 sec)

Podríamos emplear un comando similar para actualizar el stock de la PseudoJET, pero prefiero mostrarte una nueva técnica:

mysql> UPDATE consumibles SET stock = stock - 1
    -> WHERE referencia = 'ACME4501Y';
Query OK, 1 row affected (0.15 sec)
Rows matched: 1  Changed: 1  Warnings: 0

En lugar de indicar directamente el contenido del campo stock hemos utilizado una expresión aritmética que se ocupa de decrementar en una unidad su valor.

Creo que es suficiente por hoy: las unidades de información han de ser pequeñas pero significativas, de modo que no se deje de percibir sensación de avance tras su estudio.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/08/mysql-modificando-los-datos-de-una-tabla/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL: Eliminación de datos en una tabla

Objetivo: presentar el comando que permite la eliminación de datos de una tabla en MySQL.

En las dos últimas entregas aprendimos los fundamentos para insertar datos en tablas MySQL mediante el comando INSERT. Pero, una vez creados, ¿cómo los eliminamos?, ¿cómo los modificamos? En el artículo de hoy daremos respuesta a la primera pregunta.

Recuperemos la tabla fichajes y observemos su contenido:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-07 | 07:15:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
8 rows in set (0.00 sec)

Suponte que queremos eliminar el registro del día 7 de julio. MySQL pone a nuestra disposición el comando DELETE, que usaremos del siguiente modo:

DELETE FROM tabla WHERE condición

Algo que podríamos leer como “borra de la tabla indicada aquello que cumpla cierta condición”.

¿Cuál es la condición que determinará que se borre el registro? Que el campo fecha tenga por valor ‘2012-07-07’. Así pues:

mysql> DELETE FROM fichajes WHERE fecha = '2012-07-07';
Query OK, 1 row affected (0.14 sec)

Constatemos que el comando ha cumplido su misión:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
7 rows in set (0.00 sec)

Como puedes comprobar, el registro de fecha 7 de julio ha sido eliminado de la tabla.

Es necesario que extremes la precaución siempre que uses DELETE. Si la condición de la claúsula WHERE se cumple en varios registros, serán eliminados todos ellos.

Por eso, una buena práctica consiste en ejecutar previamente un comando SELECT, bajo los mismos términos, para obtener el listado de registros afectados.

Imagina, por ejemplo, que queremos eliminar de la tabla fichajes los registros cuya hora de entrada sea superior o igual a las 7:45. Antes de proceder con el comando DELETE es interesante asegurarnos de que los registros que se van a borrar son precisamente los que queremos:

mysql> SELECT * FROM fichajes WHERE entrada >= '07:45:00';
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
3 rows in set (0.00 sec)

Observa el uso de la claúsula WHERE también en la sentencia SELECT para filtrar las filas a presentar.

Comprobamos que, efectivamente, esos son los únicos registros que deseamos eliminar. Podemos lanzar ya DELETE sin miedo:

mysql> DELETE FROM fichajes WHERE entrada >= '07:45:00';
Query OK, 3 rows affected (0.03 sec)

Así es como queda nuestra tabla tras esta eliminación:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
+------------+----------+----------+
4 rows in set (0.00 sec)

¿Y si quisiéramos eliminar todos los registros de la tabla fichajes?

Exactamente igual, con la salvedad de que sobra el WHERE, pues no hay nada que filtrar, ya que no se salvará ninguno:

mysql> DELETE FROM fichajes;
Query OK, 4 rows affected (0.04 sec)

Así de simple.

mysql> SELECT * FROM fichajes;
Empty set (0.01 sec)

Nada que presentar, la tabla está más pelada que el ropero de Tarzán.

Utilizaremos la claúsula WHERE condición en numerosos contextos. Considera el artículo de hoy como un pequeño barniz…

Javier Montero Gabarró


MySQL: Eliminación de datos en una tabla


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL: Insertando datos sin facilitar todos los campos

Objetivo: mostrar cómo insertar filas en una tabla MySQL sin facilitar todos los campos, es decir, decidiendo selectivamente cuáles rellenaremos.

En el artículo anterior aprendimos a insertar un registro en una tabla MySQL con el comando:

INSERT INTO nombre_tabla VALUES (lista de valores separados por comas)

Vimos que la lista de valores debía coincidir, en número y orden, con los campos de la tabla.

Pero, ¿y si no quisiéramos rellenar la fila completamente? Quizás no tengamos los datos completos y nos gustaría tener la posibilidad de agregarlos posteriormente.

MySQL permite que agreguemos filas indicando selectivamente qué columnas queremos rellenar.

Recuperemos alguna de las tablas de la sesión anterior, como la de fichajes:

mysql> DESC fichajes;
+---------+------+------+-----+---------+-------+
| Field   | Type | Null | Key | Default | Extra |
+---------+------+------+-----+---------+-------+
| fecha   | date | YES  |     | NULL    |       |
| entrada | time | YES  |     | NULL    |       |
| salida  | time | YES  |     | NULL    |       |
+---------+------+------+-----+---------+-------+
3 rows in set (0.00 sec)

en la que ya teníamos algunos datos:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
+------------+----------+----------+
3 rows in set (0.00 sec)

Imaginemos que queremos introducir datos para el día 4 de julio, pero sólo conocemos la hora de entrada. Observa la nueva versión de INSERT:

mysql> INSERT INTO fichajes (fecha, entrada) VALUES ('2012-07-04', '07:25');
Query OK, 1 row affected (0.09 sec)

A continuación del nombre de la tabla indicamos, entre paréntesis, el nombre de los campos en los que vamos a introducir datos. En la lista VALUES facilitamos los datos correspondientes a esos campos, en el mismo orden en el que están referenciados.

Veamos nuestra nueva fila:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
+------------+----------+----------+
4 rows in set (0.00 sec)

Observa que el dato que no hemos indicado se rellena con NULL, que es el valor por defecto que tiene el campo salida (observa más arriba la estructura de la tabla tras DESC). Más adelante veremos cómo indicar valores por defecto a la hora de crear una tabla.

El orden de los datos en VALUES no tiene por qué ser el que les corresponde naturalmente. La única condición es que coincida con el especificado en la lista de campos.

Por ejemplo, vamos a agregar un nuevo registro, pero esta vez indicaremos la entrada antes que la fecha:

mysql> INSERT INTO fichajes (entrada, fecha) VALUES ('07:45', '2012-07-05');
Query OK, 1 row affected (0.05 sec)

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
+------------+----------+----------+
5 rows in set (0.00 sec)

Naturalmente, también podemos agregar varias filas en una única operación, tal como explicamos en el artículo anterior:

mysql> INSERT INTO fichajes (entrada, fecha) VALUES
    -> ('07:30', '2012-07-06'),
    -> ('07:15', '2012-07-07'),
    -> ('08:01', '2012-07-08');
Query OK, 3 rows affected (0.11 sec)
Records: 3  Duplicates: 0  Warnings: 0

La única condición, como vemos, es separar los registros, rodeados entre paréntesis, mediante comas.

Comprueba que las tres filas insertadas aparecen correctamente:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
| 2012-07-04 | 07:25:00 | NULL     |
| 2012-07-05 | 07:45:00 | NULL     |
| 2012-07-06 | 07:30:00 | NULL     |
| 2012-07-07 | 07:15:00 | NULL     |
| 2012-07-08 | 08:01:00 | NULL     |
+------------+----------+----------+
8 rows in set (0.00 sec)

Esta ha sido la pieza de hoy. Tú decides qué hacer con ella…

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/07/mysql-insertando-datos-sin-facilitar-todos-los-campos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

Insertando datos en nuestras tablas MySQL

Objetivo: aprender a agregar datos a una tabla en MySQL.

Hemos dedicado varios artículos a describir los distintos tipos de datos que existen en MySQL. Desde luego que aún nos quedan bastantes, pero he juzgado interesante hacer un pequeño alto en el camino para cambiar de tercio y darle más vidilla al aprendizaje.

A lo largo de esta serie, practicando los diversos tipos de datos, hemos creado muchas tablas de ejemplo. Pero las tablas vacías son como colegios sin niños, carentes de sentido.

Ha llegado el momento de que demos vida a nuestras tablas y aprendamos a insertar datos en ellas. Para ello, nada mejor que utilizar los ejemplos que ya creamos.

Recuperemos la tabla de consumibles, con la siguiente estructura:

mysql> DESC consumibles;
+------------+-------------+------+-----+---------+-------+
| Field      | Type        | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| referencia | varchar(15) | YES  |     | NULL    |       |
| impresora  | varchar(20) | YES  |     | NULL    |       |
| stock      | int(11)     | YES  |     | NULL    |       |
+------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Como puedes observar, la tabla consta de tres campos, dos de tipo VARCHAR para albergar cadenas de texto y otro de tipo INT para almacenar un número entero.

Vamos a agregar el primer registro. Presta atención al siguiente comando:

mysql> INSERT INTO consumibles VALUES ( 'ACME2598X', 'ACME INKJET Ultra', 5 );
Query OK, 1 row affected (0.12 sec)

El comando es INSERT INTO, seguido del nombre de la tabla y de la palabra VALUES que, entre paréntesis, contiene una lista con todos los campos de que consta el registro. Como siempre, no olvides el punto y coma final.

Atiende cuidadosamente: todos los campos de que consta el registro y, además, en el mismo orden en que aparecen en la estructura de la tabla.

Ya veremos qué hay más formas de introducir datos, pero primero debes manejarte bien con esta.

¡Qué emoción, verdad? Ya hay datos. Apuesto a que estás deseando verlos.

Aunque hablaremos de SELECT a su debido momento, quédate por ahora con el siguiente comando, que viene a significar algo así como “muéstrame todo el contenido de la tabla consumibles”:

mysql> SELECT * FROM consumibles;
+------------+-------------------+-------+
| referencia | impresora         | stock |
+------------+-------------------+-------+
| ACME2598X  | ACME INKJET Ultra |     5 |
+------------+-------------------+-------+
1 row in set (0.00 sec)

¡Ahí la tenemos, nuestra flamante primera fila de la tabla!

Durante muchos años, todo lo que he sabido de SQL se reducía a este simple comando SELECT.

Seguro que no puedes esperar al momento de introducir el segundo registro. Ejecutamos un nuevo comando INSERT INTO:

mysql> INSERT INTO consumibles VALUES ( 'ACME4501Y', 'ACME PseudoJET Plus', 12 );
Query OK, 1 row affected (0.05 sec)

Venga, veamos cómo ha crecido la tabla:

mysql> SELECT * FROM consumibles;
+------------+---------------------+-------+
| referencia | impresora           | stock |
+------------+---------------------+-------+
| ACME2598X  | ACME INKJET Ultra   |     5 |
| ACME4501Y  | ACME PseudoJET Plus |    12 |
+------------+---------------------+-------+
2 rows in set (0.00 sec)

¡Impresionante! Sigue añadiendo filas hasta que te canses….

Vamos a rellenar otra de las tablas con la que hemos estado trabajando recientemente:

mysql> DESC fichajes;
+---------+------+------+-----+---------+-------+
| Field   | Type | Null | Key | Default | Extra |
+---------+------+------+-----+---------+-------+
| fecha   | date | YES  |     | NULL    |       |
| entrada | time | YES  |     | NULL    |       |
| salida  | time | YES  |     | NULL    |       |
+---------+------+------+-----+---------+-------+
3 rows in set (0.05 sec)

El propósito de esta tabla es registrar los momentos de fichaje en una empresa. Agreguemos el primer registro:

mysql> INSERT INTO fichajes VALUES ('2012-07-01', '07:32', '17:14');
Query OK, 1 row affected (0.08 sec)

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
+------------+----------+----------+
1 row in set (0.00 sec)

También es posible agregar varias filas en una única operación. Observa cómo lo hago:

mysql> INSERT INTO fichajes VALUES
    -> ('2012-07-02', '08:15', '17:57'),
    -> ('2012-07-03', '07:31', '16:30');
Query OK, 2 rows affected (0.04 sec)
Records: 2  Duplicates: 0  Warnings: 0

He pulsado ENTER después de VALUES para hacer el comando más legible. Observa que cada registro está contenido entre paréntesis, separando uno de otro mediante una coma.

Ejecutemos el comando estrella de SQL y veamos nuestra tabla con sus nuevos datos:

mysql> SELECT * FROM fichajes;
+------------+----------+----------+
| fecha      | entrada  | salida   |
+------------+----------+----------+
| 2012-07-01 | 07:32:00 | 17:14:00 |
| 2012-07-02 | 08:15:00 | 17:57:00 |
| 2012-07-03 | 07:31:00 | 16:30:00 |
+------------+----------+----------+
3 rows in set (0.00 sec)

mysql> exit
Bye

Javier Montero Gabarró


Insertando datos en nuestras tablas MySQL


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL – Ha llegado la hora

Objetivo: presentar en MySQL el tipo de datos TIME, adecuado tanto para registrar horas como para el tiempo transcurrido entre dos eventos.

En el artículo anterior tratamos el tipo de datos DATE para registrar fechas (año, mes y día). Aunque, como veremos pronto, existen también tipos para indicar fecha y hora en el mismo campo, MySQL dispone de uno específico para almacenar horas: TIME.

Hay varias maneras de introducir la hora y es preciso conocer algunas sutilezas.

Comencemos por el formato básico:

‘HH:MM:SS’

Indicamos la hora, seguida de los minutos y de los segundos. Por ejemplo:

'07:30:46'
'13:46:00'
'23:59:59'

No olvides las comillas y ten en cuenta que la hora se indica en formato 24 horas (no 12, con am y pm).

Una hora escrita con sus tres pares (horas, minutos y segundos), puede indicarse también sin el delimitador de los dos puntos. De este modo, los tres ejemplos anteriores puedes escribirlos así:

'073046'
'134600'
'235959'

o incluso como números, sin las comillas:

073046
134600
235959

Si empleamos el delimitador, podemos prescindir de los ceros a la izquierda. Las siguientes horas son equivalentes:

'05:05:05'
'5:5:5'

Pero ten presente que, sin delimitadores, esa hora no podría escribirse como '555', sino ‘050505'.

También podemos expresar horas en formato más corto:

‘HH:MM’

'13:30' es equivalente a '13:30:00'.

Puedes usar el formato corto sin delimitadores, pero con una precaución importante que puede prestarse a confusión.

Siempre que facilitas una hora sin delimitadores (con comillas o sin ellas) MySQL intenta formar los pares de derecha a izquierda. Por ejemplo:

‘1330’ es equivalente a '00:13:30' y NO '13:30:00', como sucedía antes.

'759' es equivalente a '00:07:59'

'10' es equivalente a '00:00:10'.

Tenlo siempre presente a la hora de emplear delimitadores o no.

El tipo TIME puede utilizarse no sólo para registrar horas, sino también para indicar el espacio de tiempo entre dos sucesos, siempre y cuando entre ellos no existan más de 35 días.

35 días (aproximadamente), he dicho bien.

Pero, ¿cómo representamos hasta 35 días en un formato HH:MM:SS?

‘HHH:MM:SS’

Es decir, empleando tres cifras para la hora:

'100:45:15'

que se corresponde a 100 horas, cuarenta y cinco minutos y quince segundos.

También puedes expresar medidas temporales negativas:

'-100:45:15'

El rango temporal permitido está comprendido entre -838:59:59 y 838:59:59.

839 horas son aproximadamente 35 días.

Este otro formato también es válido:

‘D HHH:MM:SS’

donde D representa el número de días:

'5 15:20:40'

significa 5 días, 15 horas, 20 minutos y 40 segundos.

O este otro:

'20 100:34:45'

Pero aunque lo introduzcamos así, MySQL nos lo presentará con los días pasados a horas:

'580:34:45'.

Este otro valor resultaría en error:

'20 500:00:00'

ya que, si conviertes los días a horas te queda que es equivalente a

'980:00:00'

y ya sabes que el límite es

838:59:59

Empleando días también está disponible esta otra sintaxis:

‘D HHH’

Por ejemplo,

'20 5'

que equivale a 20 días y 5 horas, es decir, lo mismo que:

'485:00:00'

Para finalizar, como aplicación práctica, vamos a diseñar una tabla MySQL, denominada fichajes, en la que registraremos los fichajes de entrada y salida en una empresa.

mysql> CREATE TABLE fichajes
    -> (
    -> fecha DATE,
    -> entrada TIME,
    -> salida TIME
    -> );
Query OK, 0 rows affected (0.11 sec)

mysql> DESC fichajes;
+---------+------+------+-----+---------+-------+
| Field   | Type | Null | Key | Default | Extra |
+---------+------+------+-----+---------+-------+
| fecha   | date | YES  |     | NULL    |       |
| entrada | time | YES  |     | NULL    |       |
| salida  | time | YES  |     | NULL    |       |
+---------+------+------+-----+---------+-------+
3 rows in set (0.05 sec)

Nada más; son las 18:34:46, hora ya de publicar este artículo…

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/06/mysql-ha-llegado-la-hora/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL – Un tipo de datos para almacenar fechas

Objetivo: presentar el tipo de datos DATE para la introducción de fechas en MySQL.

En ocasiones necesitarás almacenar fechas en tus tablas. La fecha de nacimiento de tus contactos, el vencimiento de una tarea, el día en que adquiriste un determinado libro de tu biblioteca, son algunos ejemplos de usos típicos.

MySQL tiene unos cuantos tipos para manejar fechas y horas. Hoy voy a mostrarte uno especializado en las primeras (es decir, sin incluir información horaria): el tipo DATE.

A la hora de trabajar con fechas debes tener en cuenta el formato que MySQL maneja, tanto para la introducción como para la visualización de datos.

Se indica primero el año, seguido del mes y terminando por el día, como en el siguiente ejemplo:

'2012-10-25'  -->  25 de octubre de 2012

Quédate con la copla: 'AAAA-MM-DD'. Si introduces una fecha errónea, MySQL se la tragará, pero la guardará como '0000-00-00'.

Cuando digo fecha errónea no me refiero únicamente a que cruces los campos. Fíjate en esto:

'2012-02-29'

es perfectamente válido, pues este año es bisiesto. Pero lo siguiente es erróneo,

'2011-02-29'

y MySQL lo almacenaría en la tabla como '0000-00-00'.

Veremos más adelante que podemos configurar MySQL para que no sea tan estricto a la hora de comprobar fechas. Pero no olvides que, por defecto, no te pasará ni una.

Observa también que las fechas las introducimos entre comillas, al igual que hacemos con los datos de tipo VARCHAR (no importa si son simples o dobles). Si se te olvidan, obtendrás un 0000-00-00; advertido quedas.

MySQL te permite cierta flexibilidad a la hora de introducir fechas:

'2012-4-5' es equivalente a '2012-04-05'.

Y para el año podemos registrar tan sólo las dos últimas cifras:

'12-10-5' es equivalente a '2012-10-5'.

Pero claro, esto presenta un problema: ¿cómo sé, en el ejemplo anterior, si me estoy refiendo a 2012 en vez de 1912?

MySQL sigue el siguiente protocolo a la hora de traducir fechas con sólo dos cifras en el año:

Si el año está comprendido entre 00 y 69, ambos incluidos, lo precede con un 20.

En caso contrario, es decir, entre 70 y 99, es precedido por 19.

MySQL también permite flexibilidad a la hora de elegir el separador entre los campos. Puedes usar otros signos de puntuación, aparte del guión. Por ejemplo, las siguientes fechas son equivalentes:

'2012-7-31'
'2012/7/31'
'2012#7#31'
'2012:7:31'

Para finalizar, vamos a practicar creando una tabla, denominada contactos, en la que registraremos el nombre, apellido y la fecha de nacimiento de nuestros conocidos:

mysql> CREATE TABLE contactos
    -> (
    -> nombre VARCHAR(20),
    -> apellidos VARCHAR(30),
    -> f_nacimiento DATE
    -> );
Query OK, 0 rows affected (0.38 sec)

Comprobemos su estructura:

mysql> DESC contactos;
+--------------+-------------+------+-----+---------+-------+
| Field        | Type        | Null | Key | Default | Extra |
+--------------+-------------+------+-----+---------+-------+
| nombre       | varchar(20) | YES  |     | NULL    |       |
| apellidos    | varchar(30) | YES  |     | NULL    |       |
| f_nacimiento | date        | YES  |     | NULL    |       |
+--------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Y eso es todo, en 'Sevilla' a '2012-06-07'.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/06/mysql-un-tipo-de-datos-para-almacenar-fechas/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL – Datos numéricos de coma fija

Objetivo: Introducir el tipo DECIMAL para la representación de datos numéricos de coma fija en MySQL.

Hemos tratado ya el tipo INTEGER para la introducción de datos numéricos enteros en una tabla MySQL. Pero supongamos que tenemos que definir un campo para almacenar el precio exacto en euros de un determinado artículo; es obvio que necesitamos otro tipo de representación que permita introducir los decimales de los céntimos.

Para poder almacenar numeros con cifras decimales exactas, también conocidos de coma fija (en oposición a los de coma flotante para números reales en general, que trataremos más adelante), MySQL dispone del tipo de datos DECIMAL, que puede simplificarse como DEC.

Su sintaxis es DECIMAL(m,n), donde m es el número máximo de cifras en total (incluyendo la parte decimal) y n es el número de cifras después de la coma.

Por ejemplo; imagínate que sabes que el precio de un artículo en euros siempre será inferior a 100 euros. Es decir, el precio máximo sería 99’99 euros. ¿Cómo representaríamos este tipo de columna?

El número máximo de cifras es cuatro, dos de ellas decimales, por lo que el campo puede definirse como

DECIMAL(4,2)

Esta definición incluye a los números negativos, de modo que el rango de cifras completo que abarca es desde -99’99 hasta 99’99.

Vamos a crear una sencilla tabla de ejemplo para almacenar pedidos en la que incluiremos el nombre de un artículo, la cantidad a pedir y el precio unitario (que acotaremos por debajo de los 1000 euros).

mysql> CREATE TABLE pedidos
    -> (
    -> articulo VARCHAR(25),
    -> cantidad INT,
    -> precio DEC(5,2)
    -> );
Query OK, 0 rows affected (0.06 sec)

Observa cómo he definido el campo precio: he puesto 5 porque es el total de cifras (las tres antes de la coma y las dos después de ella).

Repasemos su estructura:

mysql> DESC pedidos;
+----------+--------------+------+-----+---------+-------+
| Field    | Type         | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| articulo | varchar(25)  | YES  |     | NULL    |       |
| cantidad | int(11)      | YES  |     | NULL    |       |
| precio   | decimal(5,2) | YES  |     | NULL    |       |
+----------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Con todo lo que hemos visto ya, aunque nos faltan más tipos de campos aún, puedes hacer tus pinitos diseñando tablas. En breve estaremos introduciendo datos ya a esas estructuras vacías…

Javier Montero Gabarró


MySQL – Datos numéricos de coma fija


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


¡Accede al índice con todos los artículos sobre MySQL!

MySQL – Datos numéricos enteros

Recientemente asistimos con emoción a la creación de la primera tabla en MySQL. Aprendimos a utilizar el tipo de datos VARCHAR para campos con texto de longitud variable y vimos el comando para mostrar la estructura de la tabla recién creada.

Tan sólo con el tipo VARCHAR podríamos modelar buena parte de nuestros datos. Los campos de texto son, indudablemente, una abrumadora mayoría. Incluso podríamos llegar a representar datos numéricos empleando simplemente texto. ¿Qué me impediría, por ejemplo, almacenar un número de teléfono, o el número de cartuchos que tengo en stock de un determinado modelo de impresora, en un campo de tipo VARCHAR?

Es cierto que un número de teléfono podría registrase en un VARCHAR sin mayor problema, pero no así el stock de consumibles. Si entrego un cartucho, ¿cómo decremento en una unidad esa cantidad si estoy en un campo que es de tipo texto?

Para almacenar datos susceptibles a que se realicen sobre ellos operaciones matemáticas necesitamos emplear tipos numéricos.

Vamos a presentar hoy el tipo INTEGER, con el que almacenaremos valores numéricos enteros.

El tipo INTEGER, que puede resumirse como INT, ocupa un espacio de 4 bytes (32 bits), por lo que nos permite almacenar enteros positivos y negativos comprendidos entre -2^{31} hasta 2^{31}-1. Es decir, en el rango comprendido entre

-2147483648 … +2147483647

Una buena amplitud, desde luego, tratándose de enteros, aunque más adelante veremos que puede aumentarse aún más.

Vamos a crear, a título de ejemplo, una tabla para almacenar el stock disponible de consumibles de nuestros dispositivos de impresión.

mysql> CREATE TABLE consumibles
    -> (
    -> referencia VARCHAR(15),
    -> impresora VARCHAR(20),
    -> stock INT
    -> );
Query OK, 0 rows affected (0.36 sec)

En referencia almacenaremos el código identificativo del tipo de cartucho o tóner; en impresora, el modelo de la máquina al que se asocia y en stock el número cartuchos que tenemos en almacén.

Veamos la estructura de la tabla recién creada:

mysql> DESC consumibles;
+------------+-------------+------+-----+---------+-------+
| Field      | Type        | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| referencia | varchar(15) | YES  |     | NULL    |       |
| impresora  | varchar(20) | YES  |     | NULL    |       |
| stock      | int(11)     | YES  |     | NULL    |       |
+------------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)

El tipo INTEGER es un tipo estándar de SQL para representar números enteros. MySQL ha extendido el número de opciones a otros cuantos más de los que hablaremos más adelante, diferenciándose en el número de bytes que ocupan. Veremos también que podemos incluso especificar que los enteros sean rigurosamente sin signo (es decir, números no negativos). Hasta entonces, apuesta por la compatibilidad plena: INTEGER (o INT) es el tipo entero por excelencia.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/05/mysql-datos-numericos-enteros/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta