Sigueme por RSS! RSS

Consultas comunes en MySQL


MySQL, en resumen, es un DBMS (Database Management System ó sistema de administración de bases de datos) para bases de datos relacionales. Es una aplicación que permite gestionar archivos destinados a albergar cierta data, utiliza múltiples tablas para almacenar y organizar la información.

Algunas de las consultas o casos más comunes que nos podemos encontrar, son los siguientes:

01 - Concatenar valores
02 - Contar registros
03 - Limitar el número de registros a obtener de una tabla
04 - Mostrar registros aleatoriamente
05 - Valor máximo o mínimo de un determinado campo
06 - Consultas rápidas y filtradas
07 - Modificar la estructura de una tabla
08 - Seleccionar partes de un campo
09 - Condiciones dentro de la consulta
10 - Buscando campos dentro de la base de datos



1.- Concatenar valores
En algunos casos necesitaremos unir dos o mas resultados, eso lo haremos con la función CONCAT. La coma "," será el carácter que usaremos para las concatenaciones.

Ejemplo: mostrar el nombre completo y la fecha de nacimiento concatenados en una sola columna:
SELECT idpersona,
CONCAT("Nombre completo: ",apellidos," ",nombres,", nacido(a) el: ",fecha_nacimiento) 
as resultado_concatenado FROM personas;
+----------+---------------------------------------------------------------------------+
|idpersona | resultado_concatenado                                                     |
+----------+---------------------------------------------------------------------------+
|        1 | Nombre completo: pacheco ramirez ana maria, nacido(a) el: 1992-11-24      | 
|        2 | Nombre completo: ramirez ortega cecilia ines, nacido(a) el: 1990-02-24    | 
|        3 | Nombre completo: arjona blanco luis fernando, nacido(a) el: 1985-12-03    | 
|        4 | Nombre completo: arcia zambrota eugenio jose, nacido(a) el: 1987-03-23    | 
|        5 | Nombre completo: cassano nimezzi alexander raul, nacido(a) el: 1981-12-12 | 
|        6 | Nombre completo: rodriguez mesa kimberly sofia, nacido(a) el: 1992-01-12  | 
|        7 | Nombre completo: romero forlan maria jose, nacido(a) el: 1992-10-02       | 
|        8 | Nombre completo: materazzi leonardo edward, nacido(a) el: 1996-04-16      | 
|        9 | Nombre completo: alvarado gonzales mariangelica, nacido(a) el: 1986-07-18 | 
|       10 | Nombre completo: martin cabello isabel, nacido(a) el: 1994-05-03          | 
+----------+---------------------------------------------------------------------------+

Ejemplo: teniendo una tabla con los siguientes datos:
campo1 campo2
juan españa
juan peru
maria mexico
juan argentina
maria paris

Mostrar el resultado1 de la siguiente manera:
juan | españa,peru,argentina
maria | mexico,paris

Para este ejemplo usaremos la función GROUP_CONCAT (junto con la que vimos anteriormente), que retorna una cadena con los valores no NULL concatenados de un grupo (por defecto los separa con una coma):
SELECT CONCAT(campo1," | ",GROUP_CONCAT(campo2)) AS resultado FROM ejemplos 
GROUP BY campo1;
+-------------------------------+
| resultado                     |
+-------------------------------+
| juan  | espana,peru,argentina |
| maria | mexico,paris          |
+-------------------------------+


2 - Contar registros
Para este caso usaremos la función Count.

Ejemplo: mostrar cuantas personas hay por cada sexo:
select sexo, count(*) from personas group by sexo;
+------+----------+
| sexo | count(*) |
+------+----------+
| f    |        6 | 
| m    |        4 | 
+------+----------+

Ejemplo: mostrar cuantas personas hay por sexo y profesión:
select profesion,sexo, count(*) from personas group by profesion,sexo;
+----------------+------+----------+
| profesion      | sexo | count(*) |
+----------------+------+----------+
| ingeniero (a)  | f    |        1 | 
| ingeniero (a)  | m    |        2 | 
| licenciado (a) | f    |        3 | 
| licenciado (a) | m    |        1 | 
| profesor (a)   | f    |        2 | 
| profesor (a)   | m    |        1 | 
+----------------+------+----------+

La clausula Group by permite agrupar filas en la salida de una sentencia según los distintos valores de una columna.

Ejemplo: mostrar el total de registros de una tabla:
select count(*) from personas;
+----------+
| count(*) |
+----------+
|       10 | 
+----------+


3 - Limitar el número de registros a obtener de una tabla
Limit es una clausula que permite restringir los resultados retornados por la sentencia SELECT, es muy usada a la hora de hacer paginaciones de resultados.

Ejemplo: mostrar los primeros 5 registros de una tabla --> limit 5:
select * from personas limit 5;
+------------+------------------+-----------------+------+------------------+-----------+
| idpersona  | nombres          | apellidos       | sexo | fecha_nacimiento | profesion |
+------------+------------------+-----------------+------+------------------+-----------+
|          1 | ana maria        | pacheco ramirez | f    | 1992-11-24       | lic (a)   | 
|          2 | cecilia carolina | ramirez ortega  | f    | 1990-02-24       | ing (a)   | 
|          3 | luis fernando    | arjona blanco   | m    | 1985-12-03       | ing (a)   | 
|          4 | eugenio jose     | arcia zambrota  | m    | 1987-03-23       | ing (a)   | 
|          5 | alexander raul   | cassano nimezzi | m    | 1981-12-12       | lic (a)   | 
+------------+------------------+-----------------+------+------------------+-----------+

Ejemplo: mostrar cinco (5) registros a partir del ID tres (3) --> limit 3,5:
select * from personas limit 3,5;
+------------+-----------------+-----------------+------+------------------+-----------+
| idpersona  | nombres         | apellidos       | sexo | fecha_nacimiento | profesion |
+------------+-----------------+-----------------+------+------------------+-----------+
|          4 | eugenio jose    | arcia zambrota  | m    | 1987-03-23       | ing (a)   | 
|          5 | alexander raul  | cassano nimezzi | m    | 1981-12-12       | lic (a)   | 
|          6 | kimberly sofia  | rodriguez mesa  | f    | 1992-01-12       | prof (a)  | 
|          7 | maria jose      | romero forlan   | f    | 1992-10-02       | prof (a)  | 
|          8 | leonardo edward | materazzi       | m    | 1996-04-16       | prof (a)  | 
+------------+-----------------+-----------------+------+------------------+-----------+


4- Mostrar registros aleatoriamente.
La función Rand usada junto con la clausula Group By permite mostrar X cantidad de registros tomados aleatoriamente.

Ejemplo: mostrar dos (2) registros tomados al azar:
SELECT * FROM personas ORDER BY Rand() LIMIT 2;
+------------+-----------------+-----------------+------+------------------+-----------+
| idpersona  | nombres         | apellidos       | sexo | fecha_nacimiento | profesion |
+------------+-----------------+-----------------+------+------------------+-----------+
|          8 | leonardo edward | materazzi       | m    | 1996-04-16       | prof (a)  | 
|          5 | alexander raul  | cassano nimezzi | m    | 1981-12-12       | lic (a)   | 
+------------+-----------------+-----------------+------+------------------+-----------+

Si no hacemos uso de la clausula Limit nos arrojará todos los registros ordenados aleatoriamente.


5 - Valor máximo o mínimo de un determinado campo
Las funciones MAX y MIN devuelven el valor máximo y mínimo de determinado campo respectivamente.

Ejemplo: Mostrar el valor máximo y mínimo de los campos IdPersonas y Fecha_nacimiento:
select min(idpersona),max(idpersona),min(fecha_nacimiento),max(fecha_nacimiento) 
from personas;
+-----------------+-----------------+-----------------------+-----------------------+
| min(idpersona)  | max(idpersona)  | min(fecha_nacimiento) | max(fecha_nacimiento) |
+-----------------+-----------------+-----------------------+-----------------------+
|               1 |              10 | 1981-12-12            | 1996-04-16            | 
+-----------------+-----------------+-----------------------+-----------------------+


6 - Consultas rápidas y filtradas
Uno de los operadores mas usado para las búsquedas es LIKE, se usa para hacer comparaciones entre cadenas y patrones. El resultado es verdadero (1) si la cadena se ajusta al patrón y falso (0) en caso contrario.

Hay muchas combinaciones posibles, para los casos a continuación usaremos el carácter especial "%".
%cadena_a_buscar% --> Colocado a ambos lados de la cadena a buscar, examinara dicho valor en todo el campo.
%campo --> Colocado al inicio, buscara si el campo termina con ese valor.
campo% --> Colocado al final, buscara si el campo comienza con ese valor.

Ejemplo: Mostrar los registros que contengan en el campo "Nombres" la cadena "Maria".
SELECT idpersona,nombres,apellidos FROM personas WHERE nombres LIKE '%maria%';
+------------+--------------------+-----------------+
| idpersona  | nombres            | apellidos       |
+------------+--------------------+-----------------+
|          1 | ana maria          | pacheco ramirez | 
|          7 | maria jose         | romero forlan   | 
|         12 | ana maria fernanda | gonzales valdes | 
+------------+--------------------+-----------------+

SELECT idpersona,nombres,apellidos FROM personas WHERE nombres LIKE '%maria';
+------------+-----------+-----------------+
| idpersona  | nombres   | apellidos       |
+------------+-----------+-----------------+
|          1 | ana maria | pacheco ramirez | 
+------------+-----------+-----------------+

SELECT idpersona,nombres,apellidos FROM personas WHERE nombres LIKE 'maria%';
+------------+------------+---------------+
| idpersona  | nombres    | apellidos     |
+------------+------------+---------------+
|          7 | maria jose | romero forlan | 
+------------+------------+---------------+

Con el operador Not Like podemos obtener los registros que no tengan cierta cadena de caracteres en determinado campo.

Ejemplo: Mostrar registros que NO contengan el nombre "Maria" en el campo "Nombres":
SELECT idpersona,nombres,apellidos FROM personas WHERE nombres NOT LIKE '%maria%';
+------------+------------------+-------------------+
| idpersona  | nombres          | apellidos         |
+------------+------------------+-------------------+
|          2 | cecilia carolina | ramirez ortega    | 
|          3 | luis fernando    | arjona blanco     | 
|          4 | eugenio jose     | arcia zambrota    | 
|          5 | alexander raul   | cassano nimezzi   | 
|          6 | kimberly sofia   | rodriguez mesa    | 
|          8 | leonardo edward  | materazzi         | 
|          9 | angelica susana  | alvarado gonzales | 
|         10 | isabel           | martin cabello    | 
+------------+------------------+-------------------+

Con BETWEEN podemos conseguir que nuestra consulta devuelva resultados que estén entre un valor y otro en determinado campo.

Ejemplo: Mostrar los registros donde la fecha de nacimiento sea mayor a "1990-01-01" y menor a "2000-01-01":

select idpersona,nombres,apellidos,fecha_nacimiento from personas 
where fecha_nacimiento between '1990-01-01' and '2000-01-01' 
order by fecha_nacimiento asc;
+------------+------------------+-----------------+------------------+
| idpersona  | nombres          | apellidos       | fecha_nacimiento |
+------------+------------------+-----------------+------------------+
|          2 | cecilia carolina | ramirez ortega  | 1990-02-24       | 
|          6 | kimberly sofia   | rodriguez mesa  | 1992-01-12       | 
|          7 | maria jose       | romero forlan   | 1992-10-02       | 
|          1 | ana maria        | pacheco ramirez | 1992-11-24       | 
|         10 | isabel           | martin cabello  | 1994-05-03       | 
|          8 | leonardo edward  | materazzi       | 1996-04-16       | 
+------------+------------------+-----------------+------------------+

Se ha usado la clausula Where, ya que permite hacer uso de condiciones como es el caso de (Between '1990-01-01' AND '2000-01-01'). También se ha hecho uso de la clausula Order By para ordenar los resultados por fecha de nacimiento, en este caso de manera ascedente (ASC).


7 - Modificar la estructura de una tabla
En muchas ocasiones requeriremos de alterar la organización, disposición, de una tabla. La sentencia Alter table permite justamente eso.

Podemos por ejemplo:
- añadir o eliminar columnas.
- crear y destruir índices.
- cambiar el tipo de una columna existente o renombrar columnas.
- cambiar el nombre de la tabla..

Ejemplo: Cambiar el nombre de la tabla "Personas" por "Usuarios".
alter table personas rename usuarios;

Ejemplo: Eliminar el campo "Profesion" de la tabla "Personas".
ALTER TABLE usuarios DROP profesion;

select * from usuarios limit 5;
+-----------+------------------+-----------------+------+------------------+
| idpersona | nombres          | apellidos       | sexo | fecha_nacimiento |
+-----------+------------------+-----------------+------+------------------+
|         1 | ana maria        | pacheco ramirez | f    | 1992-11-24       | 
|         2 | cecilia carolina | ramirez ortega  | f    | 1990-02-24       | 
|         3 | luis fernando    | arjona blanco   | m    | 1985-12-03       | 
|         4 | eugenio jose     | arcia zambrota  | m    | 1987-03-23       | 
|         5 | alexander raul   | cassano nimezzi | m    | 1981-12-12       | 
+-----------+------------------+-----------------+------+------------------+


8 - Seleccionar partes de un campo
Para seleccionar parte del contenido de un campo podemos hacer uso de las siguientes funciones:
- SUSBTRING: devuelve una subcadena de la 'cadena' empezando en la 'posicion'. Si se pasa como argumento longitud devuelve una subcadena de X caracteres desde la cadena, comenzando en la 'posición indicada.

Ejemplo: Mostrar los primeros 4 caracteres de la cadena devuelta del campo "fecha_nacimiento" correspondiente al registro de id 1.
SELECT SUBSTRING(usuarios.fecha_nacimiento,1,4) from usuarios where idpersona=1;
+------------------------------------------+
| SUBSTRING(usuarios.fecha_nacimiento,1,4) |
+------------------------------------------+
| 1992                                     | 
+------------------------------------------+

- SUBSTRING es equivalente a Mid.

- LEFT y RIGHT: La primera devuelve X caracteres extraidos desde la izquierda de la 'cadena', mientras que la ultima lo hace desde la derecha.

Ejemplo:
SELECT LEFT('esto es un ejemplo', 4) as cadena_izquierda,right('esto es un ejemplo',7) 
as cadena_derecha;
+------------------+----------------+
| cadena_izquierda | cadena_derecha |
+------------------+----------------+
| esto             | ejemplo        | 
+------------------+----------------+


9 - Condiciones dentro de la consulta

Un caso que se nos puede presentar, es la necesidad de mostrar un mensaje dependiendo del valor de un campo, ejemplo:
SELECT (CASE WHEN estatus='t' THEN 'Activo' ELSE 'Inactivo' END) AS estatus FROM mi_tabla
+----------+
| estatus  |
+----------+
| Activo   |
| Inactivo |
| Activo   |
+----------+

Ese mismo ejemplo puede ser aplicado en otros manejadores de base de datos.


10 - Buscar campos dentro de la base de datos
SELECT TABLE_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE COLUMN_NAME LIKE '%id_area%';


Para estar al día con la sintaxis, funciones, clausulas, etc. de MySQL, hay que consultar la documentación oficial.

0 comentarios: Suscribete a los comentarios por RSS

Publicar un comentario

- Los comentarios están siendo moderados y serán publicados en la brevedad posible.