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 – Creando la primera tabla

Ha llegado el momento, al fin, de un acontecimiento trascendental y que difícilmente se olvida: la creación de la primera tabla en MySQL.

Ya sabes que la información se organiza en estructuras denominadas tablas. Conceptualmente son como cualquier tipo de tabla con datos que ya conoces, con sus filas y columnas. En el mundo de las bases de datos a las columnas también se las conoce como campos, y a las filas como registros.

El diseño correcto de las tablas y de las relaciones entre ellas es una habilidad crítica en el mundo de las bases de datos relacionales. Factores como la agilidad, usabilidad o la integridad de una base de datos están supeditados a unas tablas bien diseñadas.

Una base de datos no es más que un modelo que trata de abstraer una realidad determinada. Todo el tiempo que inviertas planificando, analizando y diseñando ese modelo será siempre poco.

Dejaremos las cuestiones de optimización de diseño para cuando hayamos presentado todas las herramientas. Vamos a crear hoy una simple tabla para almacenar datos personales. En el camino presentaremos el tipo de datos VARCHAR y aprenderemos a mostrar la estructura de nuestra tabla recién creada.

Para crear una tabla primero, obviamente, deberás haber creado la base de datos, el contenedor al cual pertenece (con el comando CREATE DATABASE que vimos en una entrega anterior). Pero no basta con que la base de datos exista; además, deberás indicar, con el comando USE, que vas a trabajar con esa base de datos en particular.

Vamos a crear una tabla, denominada personas, perteneciente a la base de datos contactos, y que contendrá tres campos: el nombre, los apellidos y un posible alias con el que podremos referirnos opcionalmente a esa persona.

Lo primero que debes determinar es el tipo de datos de cada campo y su tamaño máximo. En este sencillo ejemplo estamos ante tres campos que contendrán texto. Estimamos que para indicar el nombre nos baste con 20 caracteres, 40 para los apellidos y otros 20 para el alias.

Existe un tipo de datos en MySQL perfecto para este tipo de contenidos: VARCHAR.

VARCHAR permite campos de texto de hasta 65.532 caracteres (255 si estás usando una versión de MySQL anterior a la 5.0.3). Esos son muchos caracteres. Y lo bueno del tipo VARCHAR es que sólo va ocupar lo que realmente esté ocupando cada valor (salvo uno o dos bytes más que emplea para almacenar la longitud exacta).

No esperemos más, metámosle mano a la tabla ya.

Si la base de datos contactos no existe, créala con

CREATE DATABASE contactos;

O emplea cualquier otra que prefieras, da igual. Lo importante aquí es que aprendas ahora el comando para crear tablas, no resolver ninguna necesidad en concreto.

Indica que vas a operar sobre contactos con

USE contactos;

El comando para crear una tabla no podía ser otro: CREATE TABLE. Obsérvalo detalladamente:

mysql> CREATE TABLE personas
    -> (
    -> nombre VARCHAR(20),
    -> apellidos VARCHAR(40),
    -> alias VARCHAR(20)
    -> );
Query OK, 0 rows affected (0.04 sec)

Un comando no termina hasta que no se incluye el punto y coma final. Por lo tanto, el efecto de ir pulsando ENTER es que simplemente abre una nueva línea (señalizada con el cursor ->), hecho que utilizo para dejar el comando con un aspecto más presentable que si lo hubiera escrito todo contiguo en una sola línea:

mysql> CREATE TABLE personas(nombre VARCHAR(20), apellidos VARCHAR(40), alias VARCHAR(20));

Es importante que observes algunos detalles…

En primer lugar, fíjate como todo el conjunto aparece entre un par de paréntesis.

Por otro lado, observa el uso de VARCHAR después del nombre del campo, indicando entre paréntesis el tamaño máximo que ocupará.

Date cuenta, también, de que cada pareja nombre – tipo, viene separada de la siguiente por una coma.

Y, finalmente, no te olvides del punto y coma final, tras el paréntesis de cierre de CREATE TABLE, indicando que tu comando está visto para sentencia.

Ya está la tabla creada. Pero ahora, ¿cómo visualizamos su estructura?

El comando MySQL para conocer la estructura de una tabla es DESCRIBE, que puedes acortar con DESC.

mysql> DESC personas;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| nombre    | varchar(20) | YES  |     | NULL    |       |
| apellidos | varchar(40) | YES  |     | NULL    |       |
| alias     | varchar(20) | YES  |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

¡Qué buena pinta tiene esto! Vemos el nombre del campo y su tipo. El YES, en la columna Null, indica que puede aceptar valores nulos (es decir, que dejes el contenido en blanco). El NULL en Default corresponde al valor por defecto: si a la hora de introducir datos no especificas un contenido se sobreentiende que dejas el campo en blanco. Ya hablaremos de esto, así como de las otras columnas que aparecen, a su debido momento.

Y esto es todo por hoy, que no es poco. Puedes entretenerte creando otras tablas para afianzar estos conocimientos. O puedes usar alguna de las bases de datos que incluye ya MySQL y hurgar entre la estructura de sus tablas con el comando DESCRIBE.

Javier Montero Gabarró


MySQL – Creando la primera 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

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies