Tabla de contenidos
AUTO_INCREMENT
Este capítulo le brinda una introducción de aprendizaje a MySQL, a través del uso de mysql, el programa cliente de MySQL para crear y utilizar una base de datos simple. mysql (a veces denominado “monitor de terminal” o solamente “monitor”) es un programa interactivo que le permite conectarse a un servidor de bases de datos MySQL, ejecutar consultas, y ver los resultados. mysql puede usarse también en modo por lotes: se colocan las consultas en un archivo previamente armado, y se le dice a mysql que ejecute el contenido del archivo. En este capítulo se tratan ambas formas de uso.
Para ver una lista de las opciones utilizadas con
mysql, ejecútelo con la opción
--help
:
shell> mysql --help
Este capítulo asume que mysql está instalado en el ordenador y que está disponible un servidor MySQL al cual conectarse. Si no es así, consulte con su administrador MySQL. (Si Usted es el administrador, necesitará consultar otras secciones de este manual).
Se describe el proceso de configurar y utilizar una base de datos. Si sólo le interesa acceder a una base de datos existente, es posible que quiera omitir las secciones que muestran cómo crear una base de datos y las tablas que contiene.
Dado que este capítulo es una guía de aprendizaje, muchos detalles son necesariamente omitidos. Para información detallada sobre los temas que se tratan, consulte las secciones relevantes del manual.
Para conectarse al servidor, generalmente se le porporcionará a mysql un nombre de usuario y una contraseña. Si el servidor se está ejecutando en un ordenador distinto a donde está estableciendo la conexión, también se deberá especificar el nombre de host. Consulte con su administrador para saber los parámetros de conexión (nombre de usuario, contraseña y host) que debe emplear. Una vez que conozca los parámetros apropiados, debería poder conectarse de este modo:
shell> mysql -hhost
-uuser
-p Enter password: ********
host
y user
representan el
nombre del ordenador donde se está ejecutando el servidor de
bases de datos MySQL y el nombre de usuario de la cuenta que se
usará para conectarse. Reemplácelos por los valores apropiados
para elcaso. Los asteriscos (********
)
representan la contraseña, debe ingresarse cuando
mysql muestra Enter
password:
.
Si todo funciona bien, se verá una información de ingreso
seguida por el prompt mysql>
:
shell> mysql -hhost
-uuser
-p Enter password: ******** Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 25338 to server version: 5.0.9-beta-standard Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>
El prompt anuncia que mysql está listo para procesar comandos.
Algunas instalaciones de MySQL permiten conectarse como usuario anónimo (sin nombre) si el servidor se está ejecutando en el ordenador local. Si esto sucede en su caso, deberia poder conectarse al servidor ejecutando mysql sin ningún parámetro:
shell> mysql
Después de haberse conectado, puede desconectarse en cualquier
momento escribiendo QUIT
(o
\q
) en el prompt mysql>
:
mysql> QUIT Bye
En Unix, también puede desconectarse presionando Control-D.
La mayoría de los ejemplos en las secciones siguientes asumen que
ya se ha conectado al servidor. Por eso muestran el prompt
mysql>
.
Cerciórese de haberse conectado al servidor, tal como se describe en la sección anterior. Esto en sí mismo no selecciona ninguna base de datos para trabajar. En este punto es más importante aprender un poco más acerca de cómo realizar consultas que ir directamente a crear tablas, cargar datos, y recuperarlos. Esta sección describe los principios básicos del ingreso de comandos, empleando varias consultas que puede realizar para familiarizarse con la forma en que funciona mysql.
Aquí tiene un comando simple que ordena al servidor que muestre
su número de versión y la fecha actual. Ingréselo a
continuación del prompt mysql>
y presione
Enter:
mysql> SELECT VERSION(), CURRENT_DATE; +----------------+--------------+ | VERSION() | CURRENT_DATE | +----------------+--------------+ | 5.0.7-beta-Max | 2005-07-11 | +----------------+--------------+ 1 row in set (0.01 sec) mysql>
Esta consulta le muestra varias cosas acerca de mysql:
Un comando normalmente consiste en una sentencia SQL seguida
de punto y coma. (Hay excepciones donde el punto y coma puede
omitirse. QUIT
, mencionado anteriormente,
es una de ellas. Luego conocerá otras.)
Cuando ingresa un comando, mysql lo envía
al servidor para ser ejecutado e imprime los resultados. A
continuación muestra de nuevo el prompt
mysql>
para informarle que está listo
para otro comando.
mysql imprime los resultados de la consulta en forma tabulada (filas y columnas). La primera fila contiene etiquetas para las columnas. Las filas siguientes son los resultados de la consulta. Generalmente, el nombre de cada columna es el nombre del campo que trae desde la base de datos. Si está trayendo el valor de una expresión, en lugar del contenido de un campo o columna de una tabla (como en el ejemplo anterior), mysql etiqueta la columna usando el texto de la expresión.
mysql informa cuántas filas fueron devueltas y cuánto tiempo le tomó ejecutarse a la consulta, lo cual da una idea aproximada del rendimiento del servidor. Estos valores son imprecisos porque representan tiempo de reloj corriente (no tiempo de CPU), y además porque están afectados por factores como la carga del servidor o la latencia de red. (Para simplificar los ejemplos de este capitulo, a partir de ahora no se mostrará la línea “rows in set”.)
Las palabras clave pueden ingresarse en cualquier combinación de minúsculas y mayúsculas. Las siguientes consultas son equivalentes:
mysql> SELECT VERSION(), CURRENT_DATE; mysql> select version(), current_date; mysql> SeLeCt vErSiOn(), current_DATE;
Aqui tiene otra consulta que demuestra que mysql puede usarse como calculadora:
mysql> SELECT SIN(PI()/4), (4+1)*5; +------------------+---------+ | SIN(PI()/4) | (4+1)*5 | +------------------+---------+ | 0.70710678118655 | 25 | +------------------+---------+ 1 row in set (0.02 sec)
Las consultas mostradas hasta ahora han sido relativamente cortas, sentencias de una sola línea. Se puede inclusive ingresar múltiples sentencias en una misma línea. Solamente deben separarse con punto y coma:
mysql> SELECT VERSION(); SELECT NOW(); +----------------+ | VERSION() | +----------------+ | 5.0.7-beta-Max | +----------------+ 1 row in set (0.00 sec) +---------------------+ | NOW() | +---------------------+ | 2005-07-11 17:59:36 | +---------------------+ 1 row in set (0.00 sec)
No es necesario que un comando sea ingresado en una sola línea, de ese modo, comandos extensos que requieren varias lineas no son un problema. mysql determina cuando una sentencia ha llegado a l final observando si termina en un punto y coma, no si se llegó al final de la línea física. (En otras palabras, mysql acepta un formato libre para las entradas: recolecta lineas pero no las ejecuta hasta que encuentra el punto y coma.)
Aqui tiene una sentencia de múltiples líneas:
mysql> SELECT -> USER() -> , -> CURRENT_DATE; +---------------+--------------+ | USER() | CURRENT_DATE | +---------------+--------------+ | jon@localhost | 2005-07-11 | +---------------+--------------+ 1 row in set (0.00 sec)
Observe en este ejemplo que el prompt cambia de
mysql>
a ->
después
que se ha ingresado la primera línea de una consulta de
múltiples líneas. Esta es la forma en que
mysql advierte que no se ha completado la
sentencia y aún espera por el resto. El prompt es un aliado,
puesto que suministra información valiosa. Si se emplea, siempre
se sabrá lo que mysql está esperando.
Si durante el ingreso de un comando decide que no quiere
ejecutarlo, cancélelo tipeando \c
:
mysql> SELECT -> USER() -> \c mysql>
Una vez más observe el prompt. Cambia a
mysql>
después de que ingresa
\c
, informándole que mysql
está listo para un nuevo comando.
La siguiente tabla muestra cada uno de los indicadores que podrá ver y sintetiza lo que dicen acerca del estado en que se encuentra mysql:
Prompt | Significado |
mysql> | Listo para un nuevo comando. |
-> | Esperando la siguiente línea en un comando de múltiples líneas. |
'> | Esperando la siguiente línea, se encuentra abierta una cadena que
comienza con apostrofo ('' '). |
"> | Esperando la siguiente línea, se encuentra abierta una cadena que
comienza con comillas dobles
('" '). |
`> | Esperando la siguiente línea, se encuentra abierta una cadena que
comienza con tilde ('` '). |
/*> | Esperando la siguiente línea, se encuentra abierto un comentario que
comienza con /* . |
El prompt /*>
fue introducido en la serie
5.0 a partir de MySQL 5.0.6.
Es frecuente que se origine una sentencia de múltiples lineas cuando accidentalmente le da entrada a un comando de una sola línea pero olvida terminarlo con punto y coma. En ese caso, mysql aguarda por más caracteres:
mysql> SELECT USER() ->
Si esto le ocurre (considera que ha ingresado una sentencia
completa pero solamente obtiene un prompt
->
), la mayoría de las veces es porque
mysql está esperando por el punto y coma. Si
no advierte lo que el indicador trata de decirle, podría demorar
un buen tiempo en hacer lo que necesita. Ingrese un punto y coma
para completar la sentencia, y mysql la
ejecutará:
mysql> SELECT USER() -> ; +--------------------+ | USER() | +--------------------+ | joesmith@localhost | +--------------------+
Los prompts '>
y
">
aparecen durante el ingreso de
cadenas. Puede escribir cadenas delimitadas por
''
' o '"
' (por ejemplo,
'hola'
o "adios"
),
y mysql le permite ingresar cadenas divididas
en múltiples líneas. Cuando ve un prompt
'>
o ">
significa
que ha comenzado a ingresar una cadena comenzando con
''
' o '"
' pero no ha
ingresado el correspondiente caracter de terminación. A menudo
esto significa que inadvertidamente omitió este carácter. Por
ejemplo:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30; '>
Si ingresa esta sentencia SELECT
, presiona
ENTER y espera por el resultado, nada ocurrirá. En lugar de
asombrarse por el tiempo que consume la consulta, note lo que el
prompt '>
le está diciendo. Indica que
mysql espera por el final de una cadena
inconclusa. (¿Ve el error en la sentencia? La cadena
'Smith
no tiene el apóstrofo de cierre.)
¿Qué hacer llegado a este punto? Lo más simple es cancelar el
comando. No obstante, no puede simplemente tipear
\c
en este caso, ¡porque
mysql interpretará que es parte de la cadena
que está ingresando!. En lugar de eso, tipee el caracter de
cierre que falta y entonces ingrese \c.>:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30; '> '\c mysql>
El prompt cambia de nuevo a mysql>
,
informando que mysql está listo para un nuevo
comando.
El prompt `>
es similar a
'>
y ">
, pero
informa que está pendiente de completar un identificador
delimitado por tildes.
Es importante conocer el significado de estos indicadores, ya que
si por error se ingresa una cadena incompleta, todo lo que se
ingrese posteriormente será aparentemente ignorado por
mysql — incluyendo el comando
QUIT
. Esto puede ser sumamente desconcertante,
en particular si no se conoce lo que debe hacer para terminar la
línea y cancelar el comando.
Una vez que se sabe la forma de ingresar comandos, es el momento de acceder a una base de datos.
Suponga que en su hogar posee varias mascotas y desea registrar distintos tipos de información sobre ellas. Puede hacerlo si crea tablas para almacenar sus datos e introduce en ellas la información deseada. Entonces, podrá responder una variedad de preguntas acerca de sus mascotas recuperando datos desde las tablas. Esta sección le muestra como:
Crear una base de datos
Crear una tabla
Introducir datos en la tabla
Recuperar datos desde la tabla de varias maneras
Emplear múltiples tablas
La base de datos menagerie (en inglés significa "colección de animales") se ha hecho deliberadamente simple, pero no es difícil imaginar situaciones del mundo real donde podría usarse un tipo similar de base de datos. Por ejemplo, para un granjero que desee hacer el seguimiento de su hacienda, o para los registros de los pacientes de un veterinario. En el sitio web de MySQL pueden descargarse archivos de texto con datos de ejemplo y algunas de las sentencias empleadas en las siguientes secciones. Se encuentran disponibles en formato tar (http://www.mysql.com/Downloads/Contrib/Examples/menagerie.tar.gz) y Zip (http://www.mysql.com/Downloads/Contrib/Examples/menagerie.zip).
Mediante la sentencia SHOW
se encuentran las
bases de datos que existen actualmente en el servidor:
mysql> SHOW DATABASES; +----------+ | Database | +----------+ | mysql | | test | | tmp | +----------+
Probablemente la lista obtenida sea distinta en su ordenador, pero
es casi seguro que tendrá las bases de datos
mysql
y test
. La base de
datos mysql
es necesaria porque es la que
describe los privilegios de acceso de los usuarios. La base de
datos test
se provee para que los usuarios
hagan pruebas.
Tenga en cuenta que si no tiene el privilegio SHOW
DATABASES
, no podrá ver todas las bases de datos que
hay en el servidor. Consulte Sección 13.5.1.3, “Sintaxis de GRANT
y REVOKE
”.
Si la base de datos test
existe, intente
acceder a ella:
mysql> USE test Database changed
Advierta que, al igual que QUIT
,
USE
no necesita que ponga un punto y coma al
final (aunque puede hacerlo si lo desea). La sentencia
USE
tiene otra particularidad: debe escribirse
en una sola linea.
Puede colocar los ejemplos siguientes en la base de datos
test
, si tiene acceso a ella, pero si trabaja
en un ambiente compartido, lo que deposite allí puede ser
fácilmente borrado por alguien más que tenga el acceso. Por este
motivo, debería pedirle a su administrador permiso para usar una
base de datos propia. Suponga que quiere llamarla
menagerie
. El administrador necesitará
ejecutar un comando como este:
mysql> GRANT ALL ON menagerie.* TO 'su_nombre_mysql'@'su_host_cliente';
Donde su_nombre_mysql
es el nombre de usuario
que se le asignó, y su_host_cliente
es el host
u ordenador desde donde se conectará.
Si el administrador crea su base de datos en el mismo momento que le otorga privilegios, puede comenzar a utilizarla, de lo contrario necesitará crearla:
mysql> CREATE DATABASE menagerie;
En ambientes Unix, los nombres de las bases de datos son case
sensitive (al contrario que las palabras clave), de modo que
siempre debe referirse a su base de datos como
menagerie
, y no Menagerie
,
MENAGERIE
, o una variante similar. Esto
también se aplica a los nombres de tablas. Esta restricción no
existe en Windows, aunque puede utilizar el mismo esquema de
mayúsculas cuando se refiera a bases de datos y tablas en una
consulta dada.
Al crear una base de datos, ésta no se selecciona para su uso,
debe hacerlo explicitamente. Para convertir a
menagerie
en la base de datos actual, use
este comando:
mysql> USE menagerie Database changed
Las bases de datos sólo necesitan ser creadas una sola vez,
pero deben ser seleccionadas cada vez que se inicia una sesión
de mysql. Puede hacerse a través del comando
USE
como se muestra en el ejemplo, o puede
indicar la base de datos en la linea de comandos al ejecutar
mysql. Simplemente debe indicar el nombre de
la base de datos a continuación de los parámetros que necesite
ingresar. Por ejemplo:
shell> mysql -hhost
-uuser
-p menagerie Enter password: ********
Advierta en el comando anterior que menagerie
no es la contraseña. Si se
quisiera suministrar la contraseña en la linea de comandos,
después de la opción -p
, debe hacerse sin
dejar espacios en blanco (por ejemplo,
-pmypassword
, no -p
mypassword
). De todos modos, colocar la contraseña en
la linea de comandos no es recomendable porque lo expone a la
vista de otros usuarios.
La creación de la base de datos ha sido una tarea sencilla,
pero hasta ahora permanece vacía, como le muestra SHOW
TABLES
:
mysql> SHOW TABLES; Empty set (0.00 sec)
La parte difícil es decidir cómo debería ser la estructura de su base de datos: qué tablas necesitará, y qué columnas habrá en cada tabla.
Querrá una tabla para contener un registro por cada mascota.
Esta tabla puede llamarse pet
, y debería
contener, como mínimo, el nombre de cada animal. Dado que el
nombre no es muy relevante por sí mismo, tendría que tener
más información. Por ejemplo, si más de una persona en su
familia tendrá mascotas, querrá listar también el dueño de
cada animal. Y algunos otros datos descriptivos básicos, como
especie y sexo.
¿Qué hacer con la edad? Podría ser de interés, pero no es un buen dato para almacenar en una base de datos. La edad cambia a medida que pasa el tiempo, lo cual significa que debería actualizar la base de datos a menudo. En lugar de esto, es mejor almacenar un valor fijo, como la fecha de nacimiento. De este modo, cada vez que requiera saber la edad, podrá calcularla como la diferencia entre la fecha de nacimiento y la fecha actual. MySQL provee funciones para realizar cálculos con fechas, por lo que no es dificultoso. Almacenar la fecha de nacimiento en lugar de la edad tiene otras ventajas:
Puede usar la base de datos para tareas como generar recordatorios para los próximos cumpleaños de mascotas. (Si piensa que este tipo de consultas no es importante, considere que es lo mismo que haría en un contexto de base de datos de negocios para identificar aquellos clientes a los que habrá que enviar una tarjeta por su cumpleaños, para conseguir ese toque personal con la asistencia del ordenador).
Puede calcular edades en relación a otras fechas además de la actual. Por ejemplo, almacenar la fecha de muerte de una mascota le posibilita calcular la edad que tenía a ese momento.
Probablemente pensará en otros tipos de información que
resultarían útiles dentro de la tabla pet
pero los identificados hasta ahora son suficientes: name
(nombre), owner (propietario), species (especie), sex (sexo),
birth (nacimiento) y death (muerte).
Debe usar la sentencia CREATE TABLE
para
especificar la estructura de una tabla:
mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20), -> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);
El tipo de dato VARCHAR
es una buena
elección para las columnas name
,
owner
, y species
porque
los datos que allí se almacenan no son de longitud uniforme. En
realidad no es necesario que todas estas columnas tengan la
misma longitud ni que ésta sea 20
. En MySQL
5.0.3 y versiones posteriores, normalmente se puede adoptar
cualquier longitud entre 1
y
65535
, según lo que se crea más razonable.
(Nota: Anteriormente a MySQL
5.0.3, el límite de longitud era 255.) Si en el futuro debiera
aumentar la longitud de estos campos, MySQL tiene la sentencia
ALTER TABLE
.
Hay varios tipos de datos que podrían usarse para representar
el sexo en los registros de animales, tal como
'm'
y 'f'
, o
'male'
(masculino) y
'female'
(femenino). Lo más simple es usar
los caracteres 'm'
y 'f'
.
Es obvio el uso del tipo de dato DATE
para
las columnas birth
y
death
.
Luego de crear una tabla, SHOW TABLES
debería producir una salida:
mysql> SHOW TABLES; +---------------------+ | Tables in menagerie | +---------------------+ | pet | +---------------------+
Para verificar que la tabla ha sido creada en la forma esperada,
utilice la sentencia DESCRIBE
:
mysql> DESCRIBE pet; +---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | name | varchar(20) | YES | | NULL | | | owner | varchar(20) | YES | | NULL | | | species | varchar(20) | YES | | NULL | | | sex | char(1) | YES | | NULL | | | birth | date | YES | | NULL | | | death | date | YES | | NULL | | +---------+-------------+------+-----+---------+-------+
DESCRIBE
puede ser utilizada en cualquier
momento, por ejemplo, si olvida los nombres o el tipo de dato de
las columnas de la tabla.
Luego de crear la tabla, necesitará completarla con datos. Para
esto, le serán de utilidad las sentencias LOAD
DATA
e INSERT
.
Suponga que los registros de mascotas fueran como los mostrados
a continuación. (Observe que MySQL espera que las fechas tengan
el formato 'AAAA-MM-DD'
, esto puede ser
diferente a lo que acostumbra utilizar).
name | owner | species | sex | birth | death |
Fluffy | Harold | cat | f | 1993-02-04 | |
Claws | Gwen | cat | m | 1994-03-17 | |
Buffy | Harold | dog | f | 1989-05-13 | |
Fang | Benny | dog | m | 1990-08-27 | |
Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 |
Chirpy | Gwen | bird | f | 1998-09-11 | |
Whistler | Gwen | bird | 1997-12-09 | ||
Slim | Benny | snake | m | 1996-04-29 |
Dado que está comenzando con una tabla vacía, una forma fácil de completarla es creando un fichero de texto que contenga una línea por cada animal, y luego insertando el contenido del fichero en la tabla mediante una sola sentencia.
Para esto, debería crear un fichero de texto llamado
pet.txt
, conteniendo un registro por linea,
con cada valor separado por un carácter de tabulación, y
dispuestos en el orden en el cual se especificaron las columnas
en la sentencia CREATE TABLE
. Para valores
ausentes (como sexo desconocido o fechas de muerte de animales
con vida), puede usar valores NULL
. Para
representar estos valores en el archivo de texto, utilice
\N
(barra diagonal y N mayúscula). Por
ejemplo, el registro de Whistler se vería del modo siguiente
(el espacio en blanco entre cada valor es un solo carácter de
tabulación):
name | owner | species | sex | birth | death |
Whistler | Gwen | bird | \N | 1997-12-09 | \N |
Para cargar el fichero pet.txt
dentro de la
tabla pet
, utilice este comando:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet;
Si trabaja en Windows, con un editor que emplea
\r\n
(retorno de carro + nueva linea) como
caracteres de fin de línea, debería usar:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet -> LINES TERMINATED BY '\r\n';
(En un ordenador Apple bajo OS X, probablemente quiera utilizar
LINES TERMINATED BY '\r'
.)
Opcionalmente puede especificar en la sentencia LOAD
DATA
los caracteres que actuarán como separador de
campo y fin de línea, pero los valores por defecto son
tabulación y nueva línea. Estos son suficientes para que la
sentencia lea correctamente el fichero
pet.txt
Si ocurre un error al ejecutar la sentencia, probablemente se
deba a que su instalación de MySQL no tiene habilitada por
defecto la capacidad de manejar archivos locales. Consulte
Sección 5.5.4, “Cuestiones relacionadas con la seguridad y LOAD DATA LOCAL
” para obtener información
sobre cómo cambiar esto.
Cuando lo que desea es agregar nuevos registros de a uno por
vez, la sentencia INSERT
resulta de utilidad.
De esta sencilla manera, se suministran valores para cada
columna, dispuestos en el orden en el cual se especificaron las
columnas en la sentencia CREATE TABLE
statement. Suponga que Diane obtiene un nuevo hamster llamado
"Puffball". Se podría agregar un nuevo registro,
usando la sentencia INSERT
de este modo:
mysql> INSERT INTO pet -> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);
Observe que las cadenas alfanuméricas y las fechas son
representados como cadenas delimitadas por apóstrofos.
También, con INSERT
, se pueden insertar
valores NULL
directamente, para indicar un
valor ausente. No se debe utilizar \N
como se
hace con LOAD DATA
.
A partir de este ejemplo queda demostrado que lleva mucho más
trabajo realizar una carga inicial de registros empleando varias
sentencias INSERT
que si se hace mediante la
sentencia LOAD DATA
.
La sentencia SELECT
es utilizada para traer
información desde una tabla. La sintaxis general de esta
sentencia es:
SELECTseleccionar_Esto
FROMdesde_tabla
WHEREcondiciones
;
seleccionar_esto
es lo que se quiere
ver. Puede ser una lista de columnas, o *
para indicar “todas las columnas.”
desde_tabla
indica la tabla donde
están los datos a recuperar. La cláusula
WHERE
clause is optional. es opcional. Si
está presente, condiciones
representa las condiciones que cada registro debe cumplir para
retornar como resultado.
La forma más simple de SELECT
recupera
todo lo que hay en la tabla:
mysql> SELECT * FROM pet; +----------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+--------+---------+------+------------+------------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Fang | Benny | dog | m | 1990-08-27 | NULL | | Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 | | Chirpy | Gwen | bird | f | 1998-09-11 | NULL | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | | Slim | Benny | snake | m | 1996-04-29 | NULL | | Puffball | Diane | hamster | f | 1999-03-30 | NULL | +----------+--------+---------+------+------------+------------+
Esta forma de SELECT
es útil si se quiere
revisar la tabla completa, por ejemplo, despues de haberla
cargado con un conjunto de datos inicial. Por ejemplo, puede
ocurrir que la fecha de nacimiento de Bowser no parezca
correcta. Consultando los papeles de pedigri, se descubre que
el año correcto de nacimiento es 1989, no 1979.
Existen al menos dos formas de solucionarlo:
Editando el fichero pet.txt
para
corregir el error, vaciando la tabla y volviendola a
llenar con los datos. Para esto se usan las sentencias
DELETE
y LOAD DATA
:
mysql> DELETE FROM pet; mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet;
No obstante, si opta por esto, deberá volver a cargar el registro de Puffball.
Corrigiendo únicamente el registro erróneo. Para esto se
usa la sentencia UPDATE
:
mysql> UPDATE pet SET birth = '1989-08-31' WHERE name = 'Bowser';
UPDATE
modifica solo el registro en
cuestión y no requiere que se vuelva a llenar la tabla.
Como se ha visto en la sección anterior, es fácil recuperar
una tabla en su totalidad. Sólo debe omitir la cláusula
WHERE
en la sentencia
SELECT
. Pero, generalmente, no se desea ver
la tabla completa, especialmente cuando alcanza un gran
tamaño. En cambio, usualmente, se tiene interés en obtener
una respuesta para una consulta en particular, en cuyo caso se
especifican algunas restricciones para la información que se
traerá. A continuación se verán algunas consultas que
responden preguntas acerca de las mascotas.
Se pueden seleccionar sólo algunos registros de la tabla. Por ejemplo, si quisiera verificar los cambios realizados sobre la fecha de nacimiento de Bowser, seleccione el registro de Bowser de esta manera:
mysql> SELECT * FROM pet WHERE name = 'Bowser'; +--------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+-------+---------+------+------------+------------+ | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+-------+---------+------+------------+------------+
La salida confirma que el año fue correctamente registrado como 1989, ya no es 1979.
Normalmente, las comparaciones de cadenas no son case
sensitive, por eso puede escribir el nombre como
'bowser'
, 'BOWSER'
, etc.
El resultado de la consulta será el mismo.
Se pueden indicar condiciones a cumplir por cualquier columna,
no solamente por name
. Por ejemplo, si
quisiera saber qué animales han nacido luego de 1998,
necesita evaluar la columnabirth
:
mysql> SELECT * FROM pet WHERE birth > '1998-1-1'; +----------+-------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+-------+ | Chirpy | Gwen | bird | f | 1998-09-11 | NULL | | Puffball | Diane | hamster | f | 1999-03-30 | NULL | +----------+-------+---------+------+------------+-------+
Se pueden combinar condiciones, por ejemplo para localizar perros hembra:
mysql> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
La consulta anterior emplea el operador lógico
AND
. También existe el operador
OR
:
mysql> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird'; +----------+-------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+-------+ | Chirpy | Gwen | bird | f | 1998-09-11 | NULL | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | | Slim | Benny | snake | m | 1996-04-29 | NULL | +----------+-------+---------+------+------------+-------+
AND
and OR
pueden ser
combinadas, si bien AND
tiene mayor
precedencia que OR
. Si utiliza ambos
operadores, es buena idea emplear paréntesis para indicar
explicitamente la forma en que las condiciones deben
agruparse:
mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm') -> OR (species = 'dog' AND sex = 'f'); +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
Si no se quieren ver filas completas, solo hace falta indicar
las columnas en las que se está interesado, separadas por
comas. Por ejemplo, si desea saber cuándo nació cada animal,
seleccione las columnas name
y
birth
:
mysql> SELECT name, birth FROM pet; +----------+------------+ | name | birth | +----------+------------+ | Fluffy | 1993-02-04 | | Claws | 1994-03-17 | | Buffy | 1989-05-13 | | Fang | 1990-08-27 | | Bowser | 1989-08-31 | | Chirpy | 1998-09-11 | | Whistler | 1997-12-09 | | Slim | 1996-04-29 | | Puffball | 1999-03-30 | +----------+------------+
Para saber quien posee mascotas, utilice esta consulta:
mysql> SELECT owner FROM pet; +--------+ | owner | +--------+ | Harold | | Gwen | | Harold | | Benny | | Diane | | Gwen | | Gwen | | Benny | | Diane | +--------+
Observe que esta sentencia retorna el campo
owner
de cada registro, y algunos de ellos
aparecen más de una vez. Para reducir la salida, recupere
solamente una vez cada registro repetido, agregando la palabra
clave DISTINCT
:
mysql> SELECT DISTINCT owner FROM pet; +--------+ | owner | +--------+ | Benny | | Diane | | Gwen | | Harold | +--------+
Puede emplearse una clásula WHERE
para
combinar la selección de ciertas filas y de ciertas columnas.
Por ejemplo, para obtener únicamente la fecha de nacimiento
de perros y gatos, ejecute esta consulta:
mysql> SELECT name, species, birth FROM pet -> WHERE species = 'dog' OR species = 'cat'; +--------+---------+------------+ | name | species | birth | +--------+---------+------------+ | Fluffy | cat | 1993-02-04 | | Claws | cat | 1994-03-17 | | Buffy | dog | 1989-05-13 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | +--------+---------+------------+
Quizá advirtió, en los ejemplos anteriores, que las filas
resultantes se mostraron sin ningún orden en particular. A
menudo es más fácil examinar la salida de una consulta
cuando las filas se ordenan de algún modo significativo. Para
ordenar un resultado, se usa la clásula ORDER
BY
.
Aqui tiene las fechas de cumpleaños de los animales, ordenadas por fecha:
mysql> SELECT name, birth FROM pet ORDER BY birth; +----------+------------+ | name | birth | +----------+------------+ | Buffy | 1989-05-13 | | Bowser | 1989-08-31 | | Fang | 1990-08-27 | | Fluffy | 1993-02-04 | | Claws | 1994-03-17 | | Slim | 1996-04-29 | | Whistler | 1997-12-09 | | Chirpy | 1998-09-11 | | Puffball | 1999-03-30 | +----------+------------+
Por lo general, cuando se trata de columnas de tipo carácter,
la ordenación, — al igual que otras operaciones de
comparación — no es case-sensitive. Significa que el
orden permanece indefinido para las columnas que son
idénticas excepto por sus mayúsculas y minúsculas. Puede no
obstante forzar a que una columna se ordene en forma sensible
a mayúsculas empleando el modificador
BINARY
: ORDER BY BINARY
columna
.
El sentido de ordenación, por defecto, es ascendente, con los
valores más pequeños primero. Para ordenar en sentido
inverso (descendente), agregue la palabra clave
DESC
luego del nombre de la columna por la
que ordena:
mysql> SELECT name, birth FROM pet ORDER BY birth DESC; +----------+------------+ | name | birth | +----------+------------+ | Puffball | 1999-03-30 | | Chirpy | 1998-09-11 | | Whistler | 1997-12-09 | | Slim | 1996-04-29 | | Claws | 1994-03-17 | | Fluffy | 1993-02-04 | | Fang | 1990-08-27 | | Bowser | 1989-08-31 | | Buffy | 1989-05-13 | +----------+------------+
Puede ordenar basándose en varias columnas, y cada columna en un sentido diferente. Por ejemplo, para ordenar por tipo de animal en sentido ascendente y, dentro de cada tipo, ordenar por nacimiento en sentido descendente (los animales más jóvenes primero) utilice la siguiente consulta:
mysql> SELECT name, species, birth FROM pet -> ORDER BY species, birth DESC; +----------+---------+------------+ | name | species | birth | +----------+---------+------------+ | Chirpy | bird | 1998-09-11 | | Whistler | bird | 1997-12-09 | | Claws | cat | 1994-03-17 | | Fluffy | cat | 1993-02-04 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | | Buffy | dog | 1989-05-13 | | Puffball | hamster | 1999-03-30 | | Slim | snake | 1996-04-29 | +----------+---------+------------+
Advierta que la palabra clave DESC
se
aplica sobre la columna inmediatamente anterior
(birth
); no afecta el sentido de
ordenación de la columna species
.
MySQL provee varias funciones que se aplican a cálculos entre fechas, por ejemplo, para calcular edades u obtener partes de una fecha.
Para determinar cuántos años de edad tiene cada mascota, hay que calcular la diferencia entre el año de la fecha actual y el de la fecha de nacimiento, y luego restar 1 al resultado si el dia y mes actuales son anteriores al día y mes indicados por la fecha de nacimiento. La siguiente consulta devuelve, para cada mascota, el nombre, la fecha de nacimiento, la fecha actual, y la edad en años.
mysql> SELECT name, birth, CURDATE(), -> (YEAR(CURDATE())-YEAR(birth)) -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5)) -> AS age -> FROM pet; +----------+------------+------------+------+ | name | birth | CURDATE() | age | +----------+------------+------------+------+ | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | +----------+------------+------------+------+
En el ejemplo anterior, YEAR()
trae la
parte correspondiente al año de una fecha, y
RIGHT()
trae los 5 primeros caracteres
contando desde la derecha, que representan la parte
MM-DD
de la fecha. La porción de la
expresión que compara los valores MM-DD
devuelve 1 o 0, lo cual se corresponde con la diferencia de 1
año a restar de la edad si el dia de la fecha devuelto por
CURDATE()
ocurre antes que la fecha de
nacimiento birth
. La expresión completa es
un tanto confusa para usar como encabezado, por lo que se
emplea un alias (age
)
para que el encabezado sea más comprensible.
La consulta funciona bien, pero los resultados podrían
revisarse más fácilmente si las filas se presentaran en
algún orden. Esto puede hacerse agregando la cláusula
ORDER BY name
para ordenar por nombre la
salida:
mysql> SELECT name, birth, CURDATE(), -> (YEAR(CURDATE())-YEAR(birth)) -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5)) -> AS age -> FROM pet ORDER BY name; +----------+------------+------------+------+ | name | birth | CURDATE() | age | +----------+------------+------------+------+ | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | +----------+------------+------------+------+
Para ordenar la salida por edad (age
) en
lugar de por nombre (name
), solo hay que
utilizar una cláusula ORDER BY
diferente:
mysql> SELECT name, birth, CURDATE(), -> (YEAR(CURDATE())-YEAR(birth)) -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5)) -> AS age -> FROM pet ORDER BY age; +----------+------------+------------+------+ | name | birth | CURDATE() | age | +----------+------------+------------+------+ | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | +----------+------------+------------+------+
Una consulta similar se utiliza para determinar la edad a la
fecha de muerte de los animales. Se determinan los animales
que han muerto verificando si el valor de la columna
death
es NULL
. Entonces,
para todos los valores no NULL
calcula la
diferencia entre las fechas de muerte
(death
) y nacimiento
(birth
):
mysql> SELECT name, birth, death, -> (YEAR(death)-YEAR(birth)) - (RIGHT(death,5)<RIGHT(birth,5)) -> AS age -> FROM pet WHERE death IS NOT NULL ORDER BY age; +--------+------------+------------+------+ | name | birth | death | age | +--------+------------+------------+------+ | Bowser | 1989-08-31 | 1995-07-29 | 5 | +--------+------------+------------+------+
La consulta utiliza la expresión death IS NOT
NULL
en lugar de death <>
NULL
porque NULL
es un valor
especial, que no puede ser comparado mediante los operadores
lógicos habituales. Este tema se trata más extensamente más
adelante. Consultar Sección 3.3.4.6, “Trabajar con valores NULL
”.
¿Qué tal si se quisiera saber qué animales cumplen años el
próximo mes? Para esta clase de cálculos, el año y el día
son irrelevantes; simplemente se desea extraer de la columna
birth
la parte correspondiente al mes.
MySQL cuenta con varias funciones para extraer partes de
fechas, como YEAR()
,
MONTH()
, y DAYOFMONTH()
.
MONTH()
es la función apropiada para este
caso. Para verla en funcionamiento, ejecute una consulta que
muestra tanto el valor de birth
como el de
MONTH(birth)
:
mysql> SELECT name, birth, MONTH(birth) FROM pet; +----------+------------+--------------+ | name | birth | MONTH(birth) | +----------+------------+--------------+ | Fluffy | 1993-02-04 | 2 | | Claws | 1994-03-17 | 3 | | Buffy | 1989-05-13 | 5 | | Fang | 1990-08-27 | 8 | | Bowser | 1989-08-31 | 8 | | Chirpy | 1998-09-11 | 9 | | Whistler | 1997-12-09 | 12 | | Slim | 1996-04-29 | 4 | | Puffball | 1999-03-30 | 3 | +----------+------------+--------------+
Encontrar los animales que cumplen años el mes siguiente es
también sencillo. Suponga que el mes actual es abril. De modo
que su número es 4
, y se buscan los
animales nacidos en Mayo (mes 5
), de esta
forma:
mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5; +-------+------------+ | name | birth | +-------+------------+ | Buffy | 1989-05-13 | +-------+------------+
Esto se complica ligeramente cuando el mes actual es
Diciembre. No se puede simplemente sumarle 1 al número del
mes (12
) y buscar animales nacidos en el
mes 13
, porque no existe tal mes. En lugar
de eso, se debe buscar por animales nacidos en Enero (mes
1
).
Se puede incluso escribir la consulta de forma que funcione
sin importar cual es el mes actual. Así, no se necesitará
indicar un mes en particular en la consulta.
DATE_ADD()
sirve para sumar un intervalo de
tiempo a una fecha dada. Si se adiciona un mes al valor de
CURDATE()
, y se extrae el mes mediante
MONTH()
, el resultado será el mes en el
que se buscarán cumpleaños:
mysql> SELECT name, birth FROM pet -> WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));
Una manera alternativa de alcanzar el mismo resultado es sumar
1
al mes actual para obtener el mes
siguiente (después de emplear la función módulo
(MOD
) para dejar el número de mes en
0
si resultara ser 12
:
mysql> SELECT name, birth FROM pet -> WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;
Advierta que MONTH
devuelve un número
entre 1
and 12
. Y
MOD(algun_valor,12)
devuelve un número
entre 0
y 11
. La suma
debe ser realizada luego de MOD()
, en otro
caso se estaría pasando de Noviembre (11
)
to Enero (1
).
El valor NULL
puede resultar un poco
desconcertante hasta que se comienza a utilizar.
Conceptualmente, NULL
significa valor
inexistente o desconocido, y es tratado de forma diferente a
otros valores. Para verificar que un valor es
NULL
, no se pueden emplear operadores de
comparación aritmética como =
,
<
, o <>
. Para
comprobar esto, intente la siguiente consulta:
mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL; +----------+-----------+----------+----------+ | 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL | +----------+-----------+----------+----------+ | NULL | NULL | NULL | NULL | +----------+-----------+----------+----------+
Claramente, no se obtienen valores significtivos a partir de
estas comparaciones. Use en su lugar los operadores
IS NULL
y IS NOT NULL
:
mysql> SELECT 1 IS NULL, 1 IS NOT NULL; +-----------+---------------+ | 1 IS NULL | 1 IS NOT NULL | +-----------+---------------+ | 0 | 1 | +-----------+---------------+
Observe que en MySQL, 0
o
NULL
se intepretan como falso, y cualquier
otro valor, como verdadero. El valor por defecto para una
operación booleana es 1
.
Este tratamiento especial de NULL
es debido
a que, en la sección anterior, fue necesario determinar qué
animales ya no estaban vivos utilizando death IS NOT
NULL
en lugar de death <>
NULL
.
Dos valores NULL
son considerados iguales
por la cláusula GROUP BY
.
Cuando se realiza un ORDER BY
, los valores
NULL
se presentan en primer lugar si se
emplea ORDER BY ... ASC
, y al final si se
ordena con ORDER BY ... DESC
.
Un error muy común cuando se trabaja con valores
NULL
es asumir que es imposible insertar un
valor cero o una cadena vacía en una columna definida como
NOT NULL
, pero no es así. Los mencionados
son efectivamente valores, mientras que
NULL
significa "no hay un valor".
Puede comprobar esto fácilmente empleando IS [NOT]
NULL
como se muestra aquí:
mysql> SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL; +-----------+---------------+------------+----------------+ | 0 IS NULL | 0 IS NOT NULL | '' IS NULL | '' IS NOT NULL | +-----------+---------------+------------+----------------+ | 0 | 1 | 0 | 1 | +-----------+---------------+------------+----------------+
Por lo tanto, es totalmente posible insertar cadenas vacias o
ceros en columnas marcadas como NOT NULL
,
ya que son valores NOT NULL
. Consultar
Sección A.5.3, “Problemas con valores NULL
”.
MySQL posee capacidades estándar para utilizar patrones así
como también una forma de patrones basada en expresiones
regulares extendidas similares a las que se encuentran en
utilidades de UNIX, como ser vi
,
grep
, y sed
.
Los patrones SQL permiten emplear el caracter
'_
' para representar coincidencia con un
carácter individual y '%
' En MySQL, por
defecto, los patrones SQL no son case-sensitive. Abajo se
muestran algunos ejemplos. Advierta que no se emplean los
operadores =
o <>
para trabajar con patrones SQL, en lugar de eso se usan los
operadores de comparación LIKE
o
NOT LIKE
.
Para encontrar nombres que comiencen con
'b
':
mysql> SELECT * FROM pet WHERE name LIKE 'b%'; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+
Para encontrar nombres que terminen con
'fy
':
mysql> SELECT * FROM pet WHERE name LIKE '%fy'; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+
Para encontrar nombres que contengan 'w
':
mysql> SELECT * FROM pet WHERE name LIKE '%w%'; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | +----------+-------+---------+------+------------+------------+
Para encontrar nombres que contengan exactamente 5 caracteres,
use 5 veces el caracter patrón '_
':
mysql> SELECT * FROM pet WHERE name LIKE '_____'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
Los otros patrones que pueden emplearse con MySQL usan
expresiones regulares extendidas. Cuando busque coincidencias
con este tipo de patrones, use los operadores
REGEXP
y NOT REGEXP
(o
bien los sinónimos RLIKE
y NOT
RLIKE
).
Algunas características de las expresiones regulares extendidas:
'.
' detecta coincidencia con cualquier
carácter individual.
Una clase de carácter '[...]
' detecta
coincidencia con cualquier caracter entre los corchetes.
Por ejemplo, '[abc]
' coincidirá con
'a
', 'b
', o
'c
'. Para hacer referencia a un rango
de caracteres, use un guión. '[a-z]
'
detecta coincidencia con cualquier letra, mientras que
'[0-9]
' lo hace con cualquier dígito.
'*
' detecta coincidencia con cero o
más apariciones de los caracteres que lo preceden. Por
ejemplo, 'x*
' detecta cualquier número
de caracteres 'x
',
'[0-9]*
' detecta cualquier cantidad de
dígitos, y '.*
' coincidirá con
cualquier número de cualquier carácter.
REGEXP
tendrá éxito si el patrón
suministrado encuentra coincidencia en cualquier parte del
valor examinado (esto difiere de LIKE
en que este último solo tiene éxito si el patrón
concuerda con todo el valor).
Para lograr que un patrón detecte coincidencias solamente
al principio o al final del valor examinado, utilice
'^
' al principio o
'$
' al final del patrón.
Para demostrar el funcionamiento de las expresiones regulares
extendidas, las consultas con LIKE
expuestas anteriormente se han reescrito utilizando
REGEXP
.
Para hallar nombres que comiencen con 'b
',
use '^
' para buscar coincidencia al
principio del valor:
mysql> SELECT * FROM pet WHERE name REGEXP '^b'; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+
En MySQL 5.0, si realmente quiere forzar a que la comparación
realizada por REGEXP
sea case sensitive,
utilice la palabra clave BINARY
para
convertir a una de las cadenas en una cadena binaria. Esta
consulta solamente encontrará coincidencia con
'b
' minúsculas al comienzo de un nombre:
mysql> SELECT * FROM pet WHERE name REGEXP BINARY '^b';
Para hallar nombres finalizados en 'fy
',
emplee '$
' para buscar la coincidencia en
el final del nombre:
mysql> SELECT * FROM pet WHERE name REGEXP 'fy$'; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+
Para encontrar nombres conteniendo una 'w
',
utilice esta consulta:
mysql> SELECT * FROM pet WHERE name REGEXP 'w'; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | +----------+-------+---------+------+------------+------------+
Debido a que un patrón de expresión regular encuentra coincidencia sin importar el lugar del valor donde se produce, en la consulta previa no es necesario colocar un comodín a cada lado del patrón para obtener coincidencia en cualquier parte del valor, como hubiera sucedido de utilizar un patrón SQL
Para hallar nombres conteniendo exactamente cinco caracteres,
use '^
' y '$
' para
obligar a que la coincidencia deba estar al principio y al
final del nombre, y cinco instancias de '.
'
entre ellas.
mysql> SELECT * FROM pet WHERE name REGEXP '^.....$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
La consulta anterior también se podría haber escrito
empleando el operador '{n}
'
“repetir-n
-veces”:
mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+
Una pregunta frecuente que deben responder las bases de datos es: “¿qué tan a menudo aparece en la tabla un cierto tipo de dato?” Por ejemplo, se podría querer averiguar la cantidad de mascotas de que se dispone, o cuantas mascotas tiene cada propietario, o varios otros recuentos sobre los animales.
Contar la cantidad total de animales es la misma pregunta que
“¿cuántos registros hay en la tabla
pet
?”, ya que hay un registro por
mascota. COUNT(*)
cuenta el número de
filas, por ello, la consulta para contar animales luce así:
mysql> SELECT COUNT(*) FROM pet; +----------+ | COUNT(*) | +----------+ | 9 | +----------+
Anteriormente se recuperaban los nombres de la gente que
poseía mascotas. Se puede usar COUNT()
para hallar cuantas mascotas tiene cada propietario:
mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner; +--------+----------+ | owner | COUNT(*) | +--------+----------+ | Benny | 2 | | Diane | 2 | | Gwen | 3 | | Harold | 2 | +--------+----------+
Observe el uso de GROUP BY
para agrupar
todos los registros de cada propietario. Sin dicha cláusula,
todo lo que se hubiera obtenido sería un mensaje de error:
mysql> SELECT owner, COUNT(*) FROM pet; ERROR 1140 (42000): Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause
COUNT()
y GROUP BY
son
útiles para presentar datos en varias formas. Los siguientes
ejemplos muestran diferentes operaciones:
Cantidad de animales por especies:
mysql> SELECT species, COUNT(*) FROM pet GROUP BY species; +---------+----------+ | species | COUNT(*) | +---------+----------+ | bird | 2 | | cat | 2 | | dog | 3 | | hamster | 1 | | snake | 1 | +---------+----------+
Cantidad de animales por sexo:
mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex; +------+----------+ | sex | COUNT(*) | +------+----------+ | NULL | 1 | | f | 4 | | m | 4 | +------+----------+
(En esta salida, NULL
indica "sexo
desconocido")
Cantidad de animales por combinación de especies y sexo:
mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT(*) | +---------+------+----------+ | bird | NULL | 1 | | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---------+------+----------+
No es necesario examinar una tabla entera cuando se emplea
COUNT()
. Por ejemplo, la consulta anterior,
se podria limitar a perros y gatos de esta manera:
mysql> SELECT species, sex, COUNT(*) FROM pet -> WHERE species = 'dog' OR species = 'cat' -> GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT(*) | +---------+------+----------+ | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | +---------+------+----------+
O si desea la cantidad de animales de cada sexo contando solamente los que tienen sexo conocido:
mysql> SELECT species, sex, COUNT(*) FROM pet -> WHERE sex IS NOT NULL -> GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT(*) | +---------+------+----------+ | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---------+------+----------+
La tabla pet
mantiene el registro de las
mascotas que se poseen. Si quisiera registrar otros datos
acerca de ellas, como eventos de su vida tales como visitas al
veterinario o nacimiento de crías, necesitaría otra tabla.
¿Cómo debería ser esta tabla? Se necesita:
Un campo con el nombre de la mascota para saber a quien pertenece cada evento registrado.
La fecha en que ocurrió el evento.
Un campo con la descripción del evento.
Un campo con el tipo de evento, a fin de poder clasificarlo.
Teniendo en cuenta estas consideraciones, la sentencia
CREATE TABLE
para la tabla
event
("eventos", en inglés) podría ser
así:
mysql> CREATE TABLE event (name VARCHAR(20), date DATE, -> type VARCHAR(15), remark VARCHAR(255));
Como se hizo con la tabla pet
, es más
fácil realizar la carga inicial de datos si se crea un
archivo de texto delimitado con tabulaciones que contenga la
información a agregar:
name | date | type | remark |
Fluffy | 1995-05-15 | litter | 4 kittens, 3 female, 1 male |
Buffy | 1993-06-23 | litter | 5 puppies, 2 female, 3 male |
Buffy | 1994-06-19 | litter | 3 puppies, 3 female |
Chirpy | 1999-03-21 | vet | needed beak straightened |
Slim | 1997-08-03 | vet | broken rib |
Bowser | 1991-10-12 | kennel | |
Fang | 1991-10-12 | kennel | |
Fang | 1998-08-28 | birthday | Gave him a new chew toy |
Claws | 1998-03-17 | birthday | Gave him a new flea collar |
Whistler | 1998-12-09 | birthday | First birthday |
Los registros se cargan así:
mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;
Con base en lo que se ha aprendido a partir de las consultas
efectuadas sobre la tabla pet
, se debería
poder recuperar registros de la tabla
event
; los principios son los mismos. Pero
en un momento dado la tabla event
por sí
sola es insuficiente para responder las preguntas que pueden
formularse.
Suponga que se desea saber a qué edad tuvo sus crías cada
mascota. Anteriormente se aprendió a calcular edades a partir
de dos fechas. La fecha en que la mascota tuvo sus crias está
en la tabla event
, pero para calcular su
edad, se necesita su fecha de nacimiento, la cual está
localizada en la tabla pet
. Esto significa
que la consulta requiere ambas tablas:
mysql> SELECT pet.name, -> (YEAR(date)-YEAR(birth)) - (RIGHT(date,5)<RIGHT(birth,5)) AS age, -> remark -> FROM pet, event -> WHERE pet.name = event.name AND event.type = 'litter'; +--------+------+-----------------------------+ | name | age | remark | +--------+------+-----------------------------+ | Fluffy | 2 | 4 kittens, 3 female, 1 male | | Buffy | 4 | 5 puppies, 2 female, 3 male | | Buffy | 5 | 3 puppies, 3 female | +--------+------+-----------------------------+
Hay varias cosas para observar en esta consulta:
La cláusula FROM
menciona dos tablas
porque la consulta necesita traer datos de ambas
Cuando se combina (también se denomina join -unión, en
inglés-) información desde múltiples tablas, se
necesita indicar qué registro de una tabla se combinará
con qué registro de la otra. Esto es sencillo porque
ambas tablas tienen una columna name
.
La consulta emplea la cláusula WHERE
para hacer coincidir registros de las dos tablas
basándose en el valor de name
.
Dado que la columna name
aparece en
ambas tablas, se debe especificar a cuál tabla pertenece
la columna al hacer referencia a ella. Esto se hace
anteponiendo el nombre de la tabla al nombre de la
columna.
No es necesario tener dos tablas diferentes para establecer
una unión. A veces es útil combinar una tabla consigo misma,
si se desea comparar entre sí registros de una misma tabla.
Por ejemplo, para formar parejas de mascotas para
reproducción, podría unir la tabla pet
consigo misma para generar pares de animales macho y hembra de
la misma especie:
mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species -> FROM pet AS p1, pet AS p2 -> WHERE p1.species = p2.species AND p1.sex = 'f' AND p2.sex = 'm'; +--------+------+--------+------+---------+ | name | sex | name | sex | species | +--------+------+--------+------+---------+ | Fluffy | f | Claws | m | cat | | Buffy | f | Fang | m | dog | | Buffy | f | Bowser | m | dog | +--------+------+--------+------+---------+
En la consulta anterior se especificaron alias para la tabla con el fin de indicar a qué instancia de la tabla pertenece cada columna referenciada.
¿Qué tal si no se recuerda el nombre de una base de datos o una tabla, o cómo es su estructura (por ejemplo, nombres de columnas)? MySQL aborda este problema a través de varias sentencias que proveen información acerca de las bases de datos y tablas que soporta.
Ya se ha visto SHOW DATABASES
, la cual informa
las bases de datos gestionadas por el servidor. Para conocer la
base de datos actualmente seleccionada, se utiliza la funcion
DATABASE()
:
mysql> SELECT DATABASE(); +------------+ | DATABASE() | +------------+ | menagerie | +------------+
Si aún no se hubiese seleccionado ninguna base de datos, el
resultado sería NULL
.
Para conocer las tablas contenidas en la base de datos actual (por ejemplo, si no se está seguro del nombre de una tabla) se usa el siguiente comando:
mysql> SHOW TABLES; +---------------------+ | Tables in menagerie | +---------------------+ | event | | pet | +---------------------+
Si lo que se desea es ver la estructura de una tabla, el comando
DESCRIBE
es útil; muestra información acerca
de cada columna de la tabla:
mysql> DESCRIBE pet; +---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | name | varchar(20) | YES | | NULL | | | owner | varchar(20) | YES | | NULL | | | species | varchar(20) | YES | | NULL | | | sex | char(1) | YES | | NULL | | | birth | date | YES | | NULL | | | death | date | YES | | NULL | | +---------+-------------+------+-----+---------+-------+
Field
contiene el nombre de la columna,
Type
es el tipo de dato,
NULL
señala si la columna puede contener
valores NULL
, Key
indica si
la columna está indexada, y Default
informa el
valor por defecto de la columna.
Si una tabla tiene índices, SHOW INDEX FROM
muestra información
sobre ellos.
tbl_name
En las secciones previas mysql fue utilizado interactivamente para ejecutar consultas y ver resultados. También se lo puede ejecutar en un modo por lotes. Para hacer esto, los comandos que se desean ejecutar deben colocarse en un archivo, y posteriormente indicarle a mysql que acepte como entrada el contenido del mismo.
shell> mysql < batch-file
Si está ejecutando mysql en Windows y el archivo contiene algunos caracteres causantes de problemas, el comando es así:
C:\> mysql -e "source batch-file
"
Si se necesitara incluir parámetros de conexión en la línea de comandos, el comando podría verse así:
shell> mysql -hhost
-uuser
-p <batch-file
Enter password: ********
Cuando se procede de este modo lo que se está haciendo es crear un archivo script, que luego es ejecutado.
Si se desea que el script continúe su ejecución aún si alguna
de sus sentencias produce errores, se debería usar la opción de
línea de comandos --force
.
¿Porqué usar scripts? Algunas razones:
Si se utiliza una consulta repetidamente (como ser, cada dia o cada semana), hacer un script evitará volver a tipearla cada vez que se desea ejecutarla.
Se pueden crear nuevas consultas a partir de otras existentes que se le parezcan, copiando y editando el archivo de script.
El modo por lotes también puede ser útil cuando se está creando una consulta, en especial si tiene comandos de múltiples lineas o múltiples sentencias. Si se comete un error, no se necesita retipear todo. Solamente editar el script, para corregir el error, y volver a ejecutarlo mediante mysql.
Si se ejecuta una consulta que produce una salida muy extensa, se puede ejecutar a traves de un paginador en lugar de verla desaparecer rápidamente por la parte superior de la pantalla:
shell> mysql < batch-file
| more
Se puede enviar la salida a un archivo, para posterior proceso:
shell> mysql < batch-file
> mysql.out
Se puede distribuir el script a otras personas, para que puedan tambien ejecutar los comandos.
Algunas situaciones no permiten la interactividad, por ejemplo, cuando se ejecuta una consulta a través de una tarea de cron (en Unix). En este caso, debe emplearse el modo por lotes.
El formato de salida es más breve cuando se usa modo por lotes
que cuando se utiliza mysql interactivamente.
Por ejemplo, la salida devuelta para SELECT DISTINCT
species FROM pet
se ve así cuando se ejecuta en modo
interactivo:
+---------+ | species | +---------+ | bird | | cat | | dog | | hamster | | snake | +---------+
Mientras que, en modo por lotes, presenta este aspecto:
species bird cat dog hamster snake
Si desea obtener el formato por lotes para una salida producida
interactivamente, utilice mysql -t
. Para
incluir en la salida los comandos que se ejecutan, utilice
mysql -vvv
.
También pueden ejecutarse archivos de script desde el prompt
mysql utilizando los comandos
source
o \.
mysql> source filename; mysql> \. filename
AUTO_INCREMENT
Aquí tiene ejemplos de como resolver algunos problemas comunes mediante MySQL.
Algunos de los ejemplos emplean la tabla shop
para contener el precio de cada artículo (número de item) para
ciertos distribuidores (dealers). Suponiendo que cada distribuidor
tiene un único precio fijo por cada artículo, entonces
(article
, dealer
) es una
clave primaria para los registros.
Inicie la utilidad de línea de comandos mysql y seleccione una base de datos:
shell> mysql base-de-datos
(En la mayoría de las instalaciones de MySQL, podrá emplear la
base de datos test
).
Puede crear e ingresar datos a la tabla del ejemplo utilizando estas sentencias:
mysql> CREATE TABLE shop ( -> article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL, -> dealer CHAR(20) DEFAULT '' NOT NULL, -> price DOUBLE(16,2) DEFAULT '0.00' NOT NULL, -> PRIMARY KEY(article, dealer)); mysql> INSERT INTO shop VALUES -> (1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45), -> (3,'C',1.69),(3,'D',1.25),(4,'D',19.95);
Luego de ejecutar estas sentencias, la tabla debería tener el siguiente contenido:
mysql> SELECT * FROM shop; +---------+--------+-------+ | article | dealer | price | +---------+--------+-------+ | 0001 | A | 3.45 | | 0001 | B | 3.99 | | 0002 | A | 10.99 | | 0003 | B | 1.45 | | 0003 | C | 1.69 | | 0003 | D | 1.25 | | 0004 | D | 19.95 | +---------+--------+-------+
“¿Cuál es el número de ítem más alto?”
SELECT MAX(article) AS article FROM shop; +---------+ | article | +---------+ | 4 | +---------+
Tarea: Encontrar el número, distribuidor y precio del artículo más costoso.
En MySQL 5.0 (y en SQL estándar), esto se hace fácilmente con una subconsulta:
SELECT article, dealer, price FROM shop WHERE price=(SELECT MAX(price) FROM shop);
Otra solución es ordenar las columnas por precio, en forma
descendente, y obtener solamente el primer registro utilizando
la cláusula LIMIT
, específica de MySQL:
SELECT article, dealer, price FROM shop ORDER BY price DESC LIMIT 1;
Nota: Si hubiera varios
artículos que presenten el precio más alto, cada uno a 19.95,
la solución LIMIT
sólo mostraría el
primero de ellos.
Tarea: Encontrar el precio más alto por artículo.
SELECT article, MAX(price) AS price FROM shop GROUP BY article +---------+-------+ | article | price | +---------+-------+ | 0001 | 3.99 | | 0002 | 10.99 | | 0003 | 1.69 | | 0004 | 19.95 | +---------+-------+
Tarea: Para cada artículo, encontrar el o los distribuidores con el precio más alto.
En MySQL 5.0 (y en SQL estándar), este problema puede resolverse con una subconsulta como esta:
SELECT article, dealer, price FROM shop s1 WHERE price=(SELECT MAX(s2.price) FROM shop s2 WHERE s1.article = s2.article);
Se pueden emplear variables de usuario de MySQL para retener resultados sin necesidad de almacenarlos en variables del lado del cliente. (Consulte Sección 9.3, “Variables de usuario”.)
Por ejemplo, para encontrar los artículos con el precio más alto y más bajo se puede hacer lo siguiente:
mysql> SELECT @min_price:=MIN(price),@max_price:=MAX(price) FROM shop; mysql> SELECT * FROM shop WHERE price=@min_price OR price=@max_price; +---------+--------+-------+ | article | dealer | price | +---------+--------+-------+ | 0003 | D | 1.25 | | 0004 | D | 19.95 | +---------+--------+-------+
En MySQL, las tablas InnoDB
soportan
restricciones de claves foráneas. Consulte
Capítulo 15, El motor de almacenamiento InnoDB
. Consulte también
Sección 1.7.5.5, “Claves foráneas (foreign keys)”.
No se requiere una restricción de clave foránea para
simplemente unir dos tablas. Para otros tipos de tabla que no
sean InnoDB
, es posible, al momento de
definir una columna, utilizar una cláusula
REFERENCES
, la cual no
tiene efecto real y funciona solamente como un
recordatorio o comentario de que la columna que se está
definiendo está dirigida a hacer referencia a una columna en
otra tabla. Al emplear esta sintaxis es muy
importante comprender que:
tbl_name
(col_name
)
MySQL no efectúa ningún tipo de CHECK
o
comprobación para asegurarse de que
col_name
realmente existe en
tbl_name
(o incluso que
tbl_name
existe).
MySQL no realiza ningún tipo de acción sobre
tbl_name
tal como borrar filas en
respuesta a acciones ejecutadas sobre filas en la tabla que
se está definiendo; en otras palabras, esta sintaxis no
produce por sí misma un comportamiento ON
DELETE
u ON UPDATE
. (Inclusive
cuando se puede escribir una cláusula ON
DELETE
u ON UPDATE
como parte
de la cláusula REFERENCES
, estas son
también ignoradas).
Esta sintaxis crea una columna; no crea ninguna clase de índice o campo clave.
Esta sintaxis causará un error si se la emplea durante la
definición de una tabla InnoDB
.
Una columna creada de esta forma se puede utilizar como columna de unión, como se muestra aquí:
CREATE TABLE person ( id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, name CHAR(60) NOT NULL, PRIMARY KEY (id) ); CREATE TABLE shirt ( id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT, style ENUM('t-shirt', 'polo', 'dress') NOT NULL, color ENUM('red', 'blue', 'orange', 'white', 'black') NOT NULL, owner SMALLINT UNSIGNED NOT NULL REFERENCES person(id), PRIMARY KEY (id) ); INSERT INTO person VALUES (NULL, 'Antonio Paz'); SELECT @last := LAST_INSERT_ID(); INSERT INTO shirt VALUES (NULL, 'polo', 'blue', @last), (NULL, 'dress', 'white', @last), (NULL, 't-shirt', 'blue', @last); INSERT INTO person VALUES (NULL, 'Lilliana Angelovska'); SELECT @last := LAST_INSERT_ID(); INSERT INTO shirt VALUES (NULL, 'dress', 'orange', @last), (NULL, 'polo', 'red', @last), (NULL, 'dress', 'blue', @last), (NULL, 't-shirt', 'white', @last); SELECT * FROM person; +----+---------------------+ | id | name | +----+---------------------+ | 1 | Antonio Paz | | 2 | Lilliana Angelovska | +----+---------------------+ SELECT * FROM shirt; +----+---------+--------+-------+ | id | style | color | owner | +----+---------+--------+-------+ | 1 | polo | blue | 1 | | 2 | dress | white | 1 | | 3 | t-shirt | blue | 1 | | 4 | dress | orange | 2 | | 5 | polo | red | 2 | | 6 | dress | blue | 2 | | 7 | t-shirt | white | 2 | +----+---------+--------+-------+ SELECT s.* FROM person p, shirt s WHERE p.name LIKE 'Lilliana%' AND s.owner = p.id AND s.color <> 'white'; +----+-------+--------+-------+ | id | style | color | owner | +----+-------+--------+-------+ | 4 | dress | orange | 2 | | 5 | polo | red | 2 | | 6 | dress | blue | 2 | +----+-------+--------+-------+
Cuando se usa de esta manera, la cláusula
REFERENCES
no es mostrada en la salida de
SHOW CREATE TABLE
o
DESCRIBE
:
SHOW CREATE TABLE shirt\G *************************** 1. row *************************** Table: shirt Create Table: CREATE TABLE `shirt` ( `id` smallint(5) unsigned NOT NULL auto_increment, `style` enum('t-shirt','polo','dress') NOT NULL, `color` enum('red','blue','orange','white','black') NOT NULL, `owner` smallint(5) unsigned NOT NULL, PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=latin1
El uso de REFERENCES
como comentario o
"recordatorio" en la definición de una columna
funciona en tablas MyISAM
y
BerkeleyDB
.
Un OR
empleando una única clave es bien
optimizado, como es el manejo de AND
El único caso difícil es la búsqueda sobre dos diferentes
claves combinadas con OR
:
SELECT field1_index, field2_index FROM test_table WHERE field1_index = '1' OR field2_index = '1'
Esto se ha optimizado a partir de MySQL 5.0.0. Consulte Sección 7.2.6, “Index Merge Optimization”.
En MySQL 5.0 tambien se puede resolver eficientemente este
problema utilizando una UNION
que combine la
salida de dos sentencias SELECT
separadas.
Consulte Sección 13.2.7.2, “Sintaxis de UNION
”.
Cada sentencia SELECT
busca en solamente una
clave y puede ser optimizada:
SELECT field1_index, field2_index FROM test_table WHERE field1_index = '1' UNION SELECT field1_index, field2_index FROM test_table WHERE field2_index = '1';
El siguiente ejemplo muestra cómo se pueden utilizar las funciones de bits para calcular la cantidad de dias de un mes que un usuario ha visitado una página Web.
CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL, day INT(2) UNSIGNED ZEROFILL); INSERT INTO t1 VALUES(2000,1,1),(2000,1,20),(2000,1,30),(2000,2,2), (2000,2,23),(2000,2,23);
La tabla del ejemplo contiene valores de año, mes y dia que representan las visitas de los usuarios a la página. Para determinar en cuántos días diferentes del mes se produjeron las visitas, se emplea esta consulta:
SELECT year,month,BIT_COUNT(BIT_OR(1<<day)) AS days FROM t1 GROUP BY year,month;
La cual devuelve:
+------+-------+------+ | year | month | days | +------+-------+------+ | 2000 | 01 | 3 | | 2000 | 02 | 2 | +------+-------+------+
La consulta calcula cuantos días diferentes aparecen en la tabla para cada combinación de año y mes, removiendo automáticamente las entradas duplicadas.
El atributo AUTO_INCREMENT
puede utilizarse
para generar un identificador único para cada nueva fila:
CREATE TABLE animals ( id MEDIUMINT NOT NULL AUTO_INCREMENT, name CHAR(30) NOT NULL, PRIMARY KEY (id) ); INSERT INTO animals (name) VALUES ('dog'),('cat'),('penguin'), ('lax'),('whale'),('ostrich'); SELECT * FROM animals;
Lo cual devuelve:
+----+---------+ | id | name | +----+---------+ | 1 | dog | | 2 | cat | | 3 | penguin | | 4 | lax | | 5 | whale | | 6 | ostrich | +----+---------+
Para obtener el valor AUTO_INCREMENT
más
recientemente generado se puede utilizar la funcion SQL
LAST_INSERT_ID()
o la función del API de C
mysql_insert_id()
. Estas funciones son
específicas de cada conexión, de modo que su valor de retorno
no es afectado por las inserciones realizadas a través de otras
conexiones.
Nota: Para una inserción de múltiples filas,
LAST_INSERT_ID()
/mysql_insert_id()
retornan el valor AUTO_INCREMENT
de la
primera de las filas
insertadas. Esto permite que las inserciones de múltiples filas
sean reproducidas correctamente en otros servidores en una
configuración de replicación.
Para tablas MyISAM
y BDB
se puede especificar AUTO_INCREMENT
sobre una
columna secundaria en un índice de múltiples columnas. En este
caso, el valor generado para la columna
AUTO_INCREMENT
es calculado como
MAX(auto_increment_column)+1 WHERE
prefix=given-prefix
. Esto es útil cuando se desea
colocar datos en grupos ordenados.
CREATE TABLE animals ( grp ENUM('fish','mammal','bird') NOT NULL, id MEDIUMINT NOT NULL AUTO_INCREMENT, name CHAR(30) NOT NULL, PRIMARY KEY (grp,id) ); INSERT INTO animals (grp,name) VALUES('mammal','dog'),('mammal','cat'), ('bird','penguin'),('fish','lax'),('mammal','whale'), ('bird','ostrich'); SELECT * FROM animals ORDER BY grp,id;
Lo cual devuelve:
+--------+----+---------+ | grp | id | name | +--------+----+---------+ | fish | 1 | lax | | mammal | 1 | dog | | mammal | 2 | cat | | mammal | 3 | whale | | bird | 1 | penguin | | bird | 2 | ostrich | +--------+----+---------+
Nótese que en este caso (cuando la columna
AUTO_INCREMENT
es parte de un índice de
múltiples columnas), los valores
AUTO_INCREMENT
son reutilizados si se elimina
la fila con el valor AUTO_INCREMENT
más alto
en cualquier grupo. Esto ocurre incluso para tablas
MyISAM
, en las que los valores
AUTO_INCREMENT
normalmente no son
reutilizados
Si la columna AUTO_INCREMENT
es parte de
varios índices, MySQL generará valores secuenciales empleando
el índice que comienza con la columna
AUTO_INCREMENT
, si hay uno. Por ejemplo, si
la tabla animals
contiene los índices
PRIMARY KEY (grp, id)
e INDEX
(id)
, MySQL ignoraría el índice PRIMARY
KEY
al generar valores secuenciales. Como resultado,
la tabla contendría una secuencia simple, sin considerar el
valor grp
.
En Analytikerna y Lentus, hemos estado realizando los sistemas y el trabajo de campo para un gran proyecto de investigación. Este proyecto es en colaboración entre el Institute of Environmental Medicine del Karolinska Institutet Stockholm y la Sección de Investigación Clínica sobre Envejecimiento y Psicología de la Universidad de California del Sur.
El proyecto comprende una parte de selección, en la cual se entrevista por teléfono a todos los gemelos de Suecia mayores de 65 años. Aquellos que satisfacen ciertos criterios son pasados a la siguiente etapa. En esta, los gemelos que desean participar son visitados por un equipo de médico y enfermera. Algunos de los éxamenes practicados son físico, neuropsicológico, laboratorio, diagnóstico neurológico por imágenes, evaluación de estado psicológico, y recolección de la historia familiar. Adicionalmete, se recogen datos sobre factores de riesgo médicos y ambientales.
Se puede ver más información sobre estudio de Gemelos en: http://www.mep.ki.se/twinreg/index_en.html
La última parte del proyecto es administrada mediante una interface Web escrita usando Perl y MySQL.
Cada noche, los datos de las entrevistas son volcados en una base de datos MySQL.
La siguiente consulta es empleada para determinar quiénes pasan a la segunda parte del proyecto:
SELECT CONCAT(p1.id, p1.tvab) + 0 AS tvid, CONCAT(p1.christian_name, ' ', p1.surname) AS Name, p1.postal_code AS Code, p1.city AS City, pg.abrev AS Area, IF(td.participation = 'Aborted', 'A', ' ') AS A, p1.dead AS dead1, l.event AS event1, td.suspect AS tsuspect1, id.suspect AS isuspect1, td.severe AS tsevere1, id.severe AS isevere1, p2.dead AS dead2, l2.event AS event2, h2.nurse AS nurse2, h2.doctor AS doctor2, td2.suspect AS tsuspect2, id2.suspect AS isuspect2, td2.severe AS tsevere2, id2.severe AS isevere2, l.finish_date FROM twin_project AS tp /* For Twin 1 */ LEFT JOIN twin_data AS td ON tp.id = td.id AND tp.tvab = td.tvab LEFT JOIN informant_data AS id ON tp.id = id.id AND tp.tvab = id.tvab LEFT JOIN harmony AS h ON tp.id = h.id AND tp.tvab = h.tvab LEFT JOIN lentus AS l ON tp.id = l.id AND tp.tvab = l.tvab /* For Twin 2 */ LEFT JOIN twin_data AS td2 ON p2.id = td2.id AND p2.tvab = td2.tvab LEFT JOIN informant_data AS id2 ON p2.id = id2.id AND p2.tvab = id2.tvab LEFT JOIN harmony AS h2 ON p2.id = h2.id AND p2.tvab = h2.tvab LEFT JOIN lentus AS l2 ON p2.id = l2.id AND p2.tvab = l2.tvab, person_data AS p1, person_data AS p2, postal_groups AS pg WHERE /* p1 gets main twin and p2 gets his/her twin. */ /* ptvab is a field inverted from tvab */ p1.id = tp.id AND p1.tvab = tp.tvab AND p2.id = p1.id AND p2.ptvab = p1.tvab AND /* Just the screening survey */ tp.survey_no = 5 AND /* Skip if partner died before 65 but allow emigration (dead=9) */ (p2.dead = 0 OR p2.dead = 9 OR (p2.dead = 1 AND (p2.death_date = 0 OR (((TO_DAYS(p2.death_date) - TO_DAYS(p2.birthday)) / 365) >= 65)))) AND ( /* Twin is suspect */ (td.future_contact = 'Yes' AND td.suspect = 2) OR /* Twin is suspect - Informant is Blessed */ (td.future_contact = 'Yes' AND td.suspect = 1 AND id.suspect = 1) OR /* No twin - Informant is Blessed */ (ISNULL(td.suspect) AND id.suspect = 1 AND id.future_contact = 'Yes') OR /* Twin broken off - Informant is Blessed */ (td.participation = 'Aborted' AND id.suspect = 1 AND id.future_contact = 'Yes') OR /* Twin broken off - No inform - Have partner */ (td.participation = 'Aborted' AND ISNULL(id.suspect) AND p2.dead = 0)) AND l.event = 'Finished' /* Get at area code */ AND SUBSTRING(p1.postal_code, 1, 2) = pg.code /* Not already distributed */ AND (h.nurse IS NULL OR h.nurse=00 OR h.doctor=00) /* Has not refused or been aborted */ AND NOT (h.status = 'Refused' OR h.status = 'Aborted' OR h.status = 'Died' OR h.status = 'Other') ORDER BY tvid;
Algunas explicaciones:
CONCAT(p1.id, p1.tvab) + 0 AS tvid
Se desea ordenar por la concatenación de
id
y tvab
en orden
numérico. El agregado de 0
al resultado
provoca que MySQL lo trate como un número.
columna id
Identifica una pareja de gemelos. Es un campo clave en todas las tablas.
columna tvab
Identifica a un gemelo en una pareja. Toma un valor de
1
o 2
.
columna ptvab
Es lo inverso de tvab
. Cuando
tvab
. vale 1
, este
vale 2
, y viceversa. El motivo de su
existencia es para ahorrar tipeo y facilitarle a MySQL la
optimización de la consulta.
Esta consulta muestra, entre otras cosas, cómo realizar
búsquedas en una tabla a partir de la misma tabla con una
unión (p1
y p2
). En el
ejemplo, esto se usa para verificar cuándo una pareja de
gemelos murieron antes de cumplir los 65 años. Si sucede eso,
la fila no se devuelve.
Todo lo mencionado anteriormente existe en todas las tablas con
información relativa a gemelos. Hay un índice definido sobre
los campos id,tvab
(en todas las tablas) y
sobre id,ptvab
(person_data
) para realizar las consultas
más rápidamente.
En nuestra máquina de producción (un UltraSPARC a 200Mhz), esta consulta devuelve cerca de 150-200 filas y toma menos de un segundo.
La cantidad actual de registros en las tablas usadas en la consulta:
Table | Rows |
person_data | 71074 |
lentus | 5291 |
twin_project | 5286 |
twin_data | 2012 |
informant_data | 663 |
harmony | 381 |
postal_groups | 100 |
Cada entrevista termina con un código de estado llamado
event
. La consulta mostrada aquí se emplea
para mostrar una tabla sobre todas las parejas de gemelos
combinadas por evento. Esto indica en cuantas parejas ambos
gemelos llegaron al final, en cuantas uno llego y el otro fue
rechazado, etc.
SELECT t1.event, t2.event, COUNT(*) FROM lentus AS t1, lentus AS t2, twin_project AS tp WHERE /* We are looking at one pair at a time */ t1.id = tp.id AND t1.tvab=tp.tvab AND t1.id = t2.id /* Just the screening survey */ AND tp.survey_no = 5 /* This makes each pair only appear once */ AND t1.tvab='1' AND t2.tvab='2' GROUP BY t1.event, t2.event;
Existen programas que permiten autenticar usuarios a partir de una base de datos MySQL y también escribir ficheros de log en una tabla MySQL.
Se puede modificar el formato de logging de Apache para que MySQL pueda interpretarlo, colocando lo siguiente en el fichero de configuración de Apache:
LogFormat \ "\"%h\",%{%Y%m%d%H%M%S}t,%>s,\"%b\",\"%{Content-Type}o\", \ \"%U\",\"%{Referer}i\",\"%{User-Agent}i\""
Para cargar dentro de MySQL un fichero de log en dicho formato, se puede emplear una sentencia como esta:
LOAD DATA INFILE '/local/access_log
' INTO TABLEtbl_name
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' ESCAPED BY '\\'
La tabla destino debería ser creada de forma que contenga las
columnas tal como las especifica la línea
LogFormat
.
Ésta es una traducción del manual de referencia de MySQL, que puede encontrarse en dev.mysql.com. El manual de referencia original de MySQL está escrito en inglés, y esta traducción no necesariamente está tan actualizada como la versión original. Para cualquier sugerencia sobre la traducción y para señalar errores de cualquier tipo, no dude en dirigirse a mysql-es@vespito.com.