Rrc: /* Ejemplo */

2015-10-22T19:21:21Z

‎Ejemplo

Página nueva

__NOTOC__
* [[:#Select | Select]]
* [[:#Sintaxis |     Sintaxis]]
* [[:#Ejemplo |     Ejemplo]]

= Select =
== Sintaxis ==

<syntaxhighlight lang="sql" line="GESHI_FANCY_LINE_NUMBERS">
SELECT
[ALL | DISTINCT | DISTINCTROW]
[HIGH_PRIORITY]
[STRAIGHT_JOIN]
[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
select_expr [, select_expr ...]
[ FROM table_references [PARTITION (partition_list)]
[{USE|FORCE|IGNORE} INDEX [FOR {JOIN|ORDER BY|GROUP BY}] ([index_list]) ]
[WHERE where_condition]
[GROUP BY {col_name | expr | position} [ASC | DESC], ... [WITH ROLLUP]]
[HAVING where_condition]
[ORDER BY {col_name | expr | position} [ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]
[PROCEDURE procedure_name(argument_list)]
[INTO OUTFILE 'file_name' [CHARACTER SET charset_name] [export_options]
| INTO DUMPFILE 'file_name' | INTO var_name [, var_name] ]
[FOR UPDATE | LOCK IN SHARE MODE] ]

export_options:
[{FIELDS | COLUMNS}
[TERMINATED BY 'string']
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char']
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]

SELECT se utiliza para recuperar filas seleccionados de una
o más tables, y puede incluir UNION declaraciones y subconsultas.

Cada expresión select_expr indica una columna o datos que desea
recuperar. Usted debe tener al menos una expresión de SELECT.
Ver Select Expresions continuación.

La FROM cláusula indica la table o tables desde las que recuperar
filas. Utilice un solo nombre de tabla o un JOIN expresión.
Ver JOIN para más detalles. Si no hay ninguna tabla está
involucrado, FROM DUAL puede ser especificado.

MariaDB comenzando con 10,0

La cláusula PARTITION se introdujo en MariaDB 10.0.

Cada tabla también se puede especificar como db_name . tabl_name
Cada columna también se puede especificar como tbl_name . col_name
o incluso db_name . tbl_name . col_name Esto permite escribir
consultas que implican varias bases de datos.

El WHERE cláusula, si se da, indica la condición o condiciones que
cada registro debe cumplir para ser seleccionados. where_condition
es una expresión que se evalúa como verdadera para cada fila a
seleccionar. La declaración selecciona todas las filas si no hay
cláusula WHERE.

En el WHERE cláusula, puede utilizar cualquiera de las funciones
y operadores que MariaDB apoya, a excepción de las funciones de
agregación (resumen).

Utilice el ORDER BY cláusula para ordenar los resultados.

Utilice el LIMIT cláusula le permite restringir los resultados de
sólo un cierto número de filas, opcionalmente con un desplazamiento.

Utilice el GROUP BY y HAVING cláusulas a las filas del grupo juntos
cuando tienen columnas o valores calculados en común.

SELECT también se puede utilizar para recuperar filas computados sin
referencia a ninguna table.

Consejos Optimizer

Algunas opciones están disponibles para afectar el plan de ejecución.
HIGH PRIORITY

HIGH_PRIORITY da la declaración de mayor prioridad. Si la table está
bloqueada, HIGH PRIORITY SELECTs se ejecutará tan pronto como se
libera el bloqueo, incluso si otros estados están en queue. HIGH_PRIORITY
se aplica sólo si el motor de almacenamiento sólo es compatible con
bloqueo a nivel de table (MyISAM, MEMORY, MERGE).

SQL_CACHE / SQL_NO_CACHE

Si el query_cache_type variable del sistema se establece en 2 o DEMAND
y el estado actual es cacheable, SQL_CACHE hace que la consulta para
ser almacenado en caché y SQL_NO_CACHE hace que la consulta no debe
ser almacenado en caché. Para UNIONs, SQL_CACHE o SQL_NO_CACHE deben
especificarse para la primera consulta.

SQL_BUFFER_RESULT

SQL_BUFFER_RESULT obliga al optimizador de utilizar una tabla temporal
para procesar el resultado. Esto es útil para cerraduras libres tan
pronto como sea posible.

SQL_SMALL_RESULT / SQL_BIG_RESULT

SQL_SMALL_RESULT y SQL_BIG_RESULT dicen al optimizador si el resultado
es muy grande o no. Por lo general, GROUP BY y DISTINCT operaciones se
realizan utilizando una tabla temporal. Sólo si el resultado es muy
grande, usando una tabla temporal no es conveniente. El optimizador
sabe automáticamente si el resultado es demasiado grande, pero puede
forzar al optimizador a utilizar una tabla temporal con SQL_SMALL_RESULT
o evitar la tabla temporal utilizando SQL_BIG_RESULT

STRAIGHT_JOIN

STRAIGHT_JOIN aplica a los JOIN consultas, y le dice al optimizador
que las tablas deben leerse en el orden en que aparecen en el SELECT
Para const y system table de esta opción es a veces ignorados.

SQL_CALC_FOUND_ROWS

SQL_CALC_FOUND_ROWS se aplica sólo cuando se utiliza el LIMIT cláusula.
Si se utiliza esta opción, MariaDB contará cuántas filas se
correspondería con la consulta, sin el LIMIT cláusula. Ese número puede
ser recuperada en la próxima consulta, utilizando FOUND_ROWS ().

USE / FORCE / IGNORE ÍNDEX

USE INDEX FORCE INDEX y IGNORE INDEX restringen la planificación
consulta a un índice específico.

Select Expresiones

Un SELECT declaración debe contener uno o más select expresiones,
separadas por comas. Cada expresión de select puede ser uno de
los siguientes:

El nombre de una columna.
Cualquier expresión usando funciones y operadores.
* Para seleccionar todas las columnas de todas las tablas en
el FROM cláusula.
tbl_name.* para seleccionar todas las columnas de sólo el
tbl_name table.

Al especificar una columna, puede utilizar sólo el nombre de la
columna o calificar el nombre de la columna con el nombre de la
table con tbl_name.col_name La forma calificada es útil si se está
uniendo a varias tablas en el FROM cláusula. Si usted no califica
los nombres de columna al seleccionar de varias tables, MariaDB
tratará de encontrar la columna en cada table. Es un error si
existe ese nombre de columna en varias tables.

Puede citar nombres de columna utilizando back ticks.
Si usted está calificando nombres de columna con los nombres de
table, cita cada parte por separado como `tbl_name`.`col_name`

Si utiliza las funciones de agrupación en cualquiera de las
expresiones select, todas las filas de sus resultados se
agrupan de forma implícita, como si se hubiera usado
GROUP BY NULL

DISTINCT

Una consulta puede producir algunas filas idénticas. Por defecto,
todas las filas se recuperan, incluso cuando sus valores son los
mismos. Para especificar explícitamente que quiere recuperar filas
idénticas, utilice el ALL opción. Si desea duplicados para ser
retirados del conjunto de resultados, utilice el DISTINCT opción.
DISTINCTROW es sinónimo de DISTINCT.

INTO

El INTO cláusula se utiliza para especificar que los resultados de
la consulta deben ser escritos en un archivo o variable.

SELECT INTO OUTFILE - formatear y escribir el resultado en un
archivo externo.
SELECT INTO DUMPFILE - escritura binaria de fallos de los
resultados sin formato a un archivo externo.
SELECT INTO Variable - la selección y definición de variables.

El reverso de SELECT INTO OUTFILE es LOAD DATA.

ORDER BY

Utilice el ORDER BY cláusula para ordenar los resultados que se
devuelven de un SELECT comunicado. Puede especificar sólo una
columna o utilizar cualquier expresión con funciones. Si está
utilizando el GROUP BY cláusula, puede utilizar las funciones
de agrupación en ORDER BY Orden se realiza después de la agrupación.

Puede utilizar varias expresiones de pedidos, separados por comas.
Las filas se ordenarán por la primera expresión, y luego por la
segunda expresión si tienen el mismo valor para la primera, y así
sucesivamente.

Puede utilizar la palabra clave ASC y DESC después de cada expresión
de ordenar a la fuerza ese ordenamiento ser ascendente o descendente,
respectivamente. Orden está ascendiendo de forma predeterminada.

También puede utilizar un solo entero como la expresión de pedido.
Si utiliza un entero n, los resultados se ordenarán por la enésima
columna en la expresión de selección.

Cuando se comparan los valores de cadena, se comparan como si por el
STRCMP función. STRCMP ignora espacios en blanco y puede normalizar
personajes e ignorar caso, dependiendo de la colación en uso.

MariaDB empezando 05/05/35

A partir de MariaDB 05/05/35 duplican entradas en el ORDER BY cláusula
se eliminan. MySQL 5.6 también elimina campos duplicados.

LIMIT

Utilice el LIMIT cláusula para restringir el número de filas
devueltas. Cuando se utiliza un único entero n con LIMIT se
devolverán las primeras n filas. Utilice el ORDER BY cláusula
para controlar qué filas son lo primero. También puede
seleccionar un número de filas después de un desplazamiento
utilizando cualquiera de los siguientes:

LIMIT offset, row_count
LIMIT row_count OFFSET offset

Cuando usted proporciona un m compensado con un límite de n,
los primeros m filas serán ignorados, y se devolverán los
siguientes n filas.

Actualizaciones con el LIMIT cláusula no son seguros para la
replicación.

MariaDB empezando 10.0.11

Desde MariaDB 10.0.11, LIMIT 0 ha sido una excepción a esta
regla (ver MDEV-6170).

MariaDB a partir de 05/05/21

A partir de MariaDB 5/5/21, hay un LIMIT ROWS EXAMINED
optimización que proporciona los medios para poner fin a la
ejecución de SELECT declaraciones que examinan demasiadas filas,
y por lo tanto utilizar demasiados recursos. Ver las
LIMIT ROWS EXAMINED página para obtener más detalles.

GROUP BY

Utilice el GROUP BY cláusula para agrupar filas que tienen el
mismo valor en una o más columnas, o el mismo valor calculado
utilizando expresiones con las funciones y operadores, excepto
las funciones de agrupación. Cuando se utiliza un GROUP BY
cláusula, obtendrá una fila de resultado individual para cada
grupo de filas que tienen el mismo valor para la expresión dada
en GROUP BY

Al agrupar las filas, los valores de agrupación se comparan como
si por el = operador. Para valores de cadena, el = operador ignora
espacios en blanco y puede normalizar personajes e ignorar caso,
dependiendo de la colación en uso.

Puede utilizar cualquiera de las funciones de agrupación en su
select expresión. Sus valores se calcularán sobre la base de todas
las filas que han sido agrupados por cada fila de resultados. Si
selecciona una columna no agrupado o un valor calculado a partir de
una columna no agrupados, que no está definido qué fila el valor
devuelto es tomado de. Esto no se permite si el
ONLY_FULL_GROUP_BY sql_mode se utiliza.

Puede utilizar varias expresiones en el GROUP BY cláusula, separados
por comas. Las filas se agrupan si coinciden en cada una de las
expresiones.

También puede utilizar un solo entero como la expresión de agrupación.
Si utiliza un entero n, los resultados se agrupan por la enésima
columna en la expresión de selección.

El WHERE cláusula se aplica antes del GROUP BY cláusula. Filtra filas
no agregados antes de que las filas se agrupan. Para filtrar filas
agrupadas basado en valores agregados, utilice el HAVING cláusula.
El HAVING cláusula toma cualquier expresión y lo evalúa como un valor
lógico, al igual que el WHERE cláusula. Puede utilizar las funciones de
agrupación en el HAVING cláusula. Al igual que con la expresión de
selección, si hace referencia a columnas no agrupados en el HAVING
cláusula, el comportamiento es indefinido.

Por defecto, si un GROUP BY cláusula está presente, las filas en la
salida se ordenarán por las expresiones utilizadas en el GROUP BY
También puede especificar ASC o DESC (ascendente, descendente) después
de esas expresiones, como en ORDER BY El valor predeterminado es ASC

Si desea que las filas que se pueden ordenar por otro campo, se puede
añadir una explícita ORDER BY Si no desea que el resultado que se
ordenó, usted puede agregar ORDER BY NULL

CON ROLLUP

El WITH ROLLUP modificador agrega filas adicionales para el conjunto de
resultados que representan resúmenes super-agregados. Para una
descripción completa con ejemplos, vea SELECT con ROLLUP.

</syntaxhighlight>

== Ejemplo ==

<syntaxhighlight lang="sql" line="GESHI_FANCY_LINE_NUMBERS">

MariaDB [Prueba1]> insert into inven
-> ( id, nombre, descrip, precio, cantidad )
-> values
-> ( 1, 'Manzanas', 'Mediano Granny-Smith.', 0.25, 1000 );
Query OK, 1 row affected (0.32 sec)

MariaDB [Prueba1]> select * from inven;
+----+----------+-----------------------+--------+----------+
| id | nombre | descrip | precio | cantidad |
+----+----------+-----------------------+--------+----------+
| 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
+----+----------+-----------------------+--------+----------+
1 row in set (0.00 sec)

MariaDB [Prueba1]> insert into inven values ( 2, 'Uvas', 'Sin Semillas', 2.99, 500 );
Query OK, 1 row affected (0.03 sec)

MariaDB [Prueba1]> select * from inven;
+----+----------+-----------------------+--------+----------+
| id | nombre | descrip | precio | cantidad |
+----+----------+-----------------------+--------+----------+
| 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
| 2 | Uvas | Sin Semillas | 2.99 | 500 |
+----+----------+-----------------------+--------+----------+
2 rows in set (0.00 sec)

MariaDB [Prueba1]> insert into inven values
-> ( 'Agua', 'Bot. - 250 ml.' , 0.89, 259 );
ERROR 1136 (21S01): Column count doesn"'"t match value count at row 1

MariaDB [Prueba1]> insert into inven values
-> ( '', 'Agua', 'Bot. - 250 ml.' , 0.89, 259 );
Query OK, 1 row affected, 1 warning (0.07 sec)

MariaDB [Prueba1]> insert into inven
-> ( nombre, descrip, precio, cantidad )
-> values ( 'AguaMineral', 'Bot. - 600 ml.' , 0.50, 350 );
Query OK, 1 row affected (0.07 sec)

MariaDB [Prueba1]> select * from inven;
+----+-------------+-----------------------+--------+----------+
| id | nombre | descrip | precio | cantidad |
+----+-------------+-----------------------+--------+----------+
| 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
| 2 | Uvas | Sin Semillas | 2.99 | 500 |
| 3 | Agua | Bot. - 250 ml. | 0.89 | 259 |
| 4 | AguaMineral | Bot. - 600 ml. | 0.5 | 350 |
+----+-------------+-----------------------+--------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven;
+----+-------------+----------+
| id | nombre | cantidad |
+----+-------------+----------+
| 1 | Manzanas | 1000 |
| 2 | Uvas | 500 |
| 3 | Agua | 259 |
| 4 | AguaMineral | 350 |
+----+-------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by nombre;
+----+-------------+----------+
| id | nombre | cantidad |
+----+-------------+----------+
| 3 | Agua | 259 |
| 4 | AguaMineral | 350 |
| 1 | Manzanas | 1000 |
| 2 | Uvas | 500 |
+----+-------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by cantidad;
+----+-------------+----------+
| id | nombre | cantidad |
+----+-------------+----------+
| 3 | Agua | 259 |
| 4 | AguaMineral | 350 |
| 2 | Uvas | 500 |
| 1 | Manzanas | 1000 |
+----+-------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by cantidad
-> limit 3;
+----+-------------+----------+
| id | nombre | cantidad |
+----+-------------+----------+
| 3 | Agua | 259 |
| 4 | AguaMineral | 350 |
| 2 | Uvas | 500 |
+----+-------------+----------+
3 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by cantidad
-> limit 0, 3;
+----+-------------+----------+
| id | nombre | cantidad |
+----+-------------+----------+
| 3 | Agua | 259 |
| 4 | AguaMineral | 350 |
| 2 | Uvas | 500 |
+----+-------------+----------+
3 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by cantidad
-> limit 2, 3;
+----+----------+----------+
| id | nombre | cantidad |
+----+----------+----------+
| 2 | Uvas | 500 |
| 1 | Manzanas | 1000 |
+----+----------+----------+
2 rows in set (0.00 sec)

MariaDB [Prueba1]> select id, nombre, cantidad from inven
-> order by cantidad
-> limit 5, 3;
Empty set (0.00 sec)

MariaDB [Prueba1]>

Considere la siguiente table que registra el número de veces
que cada usuario ha jugado y ganado un partido:

MariaDB [Prueba1]> CREATE TABLE Competiciones
( Nomber VARCHAR(16),
Competiciones MediumINT,
Triumfos MediumINT );
Query OK, 0 rows affected (0.25 sec)

MariaDB [Prueba1]> INSERT INTO Competiciones VALUES
("Juan", 20, 5),
("Roberto", 22, 8),
("Wanda", 32, 8),
("Susana", 17, 3);
Query OK, 4 rows affected (0.06 sec)
Records: 4 Duplicates: 0 Warnings: 0

MariaDB [Prueba1]> select * from Competiciones;
+---------+---------------+----------+
| Nomber | Competiciones | Triumfos |
+---------+---------------+----------+
| Juan | 20 | 5 |
| Roberto | 22 | 8 |
| Wanda | 32 | 8 |
| Susana | 17 | 3 |
+---------+---------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select * from Competiciones order by Triumfos;
+---------+---------------+----------+
| Nomber | Competiciones | Triumfos |
+---------+---------------+----------+
| Susana | 17 | 3 |
| Juan | 20 | 5 |
| Roberto | 22 | 8 |
| Wanda | 32 | 8 |
+---------+---------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select * from Competiciones
order by Triumfos DESC;
+---------+---------------+----------+
| Nomber | Competiciones | Triumfos |
+---------+---------------+----------+
| Roberto | 22 | 8 |
| Wanda | 32 | 8 |
| Juan | 20 | 5 |
| Susana | 17 | 3 |
+---------+---------------+----------+
4 rows in set (0.00 sec)

MariaDB [Prueba1]> select * from Competiciones
WHERE Competiciones > 20
order by Triumfos DESC;
+---------+---------------+----------+
| Nomber | Competiciones | Triumfos |
+---------+---------------+----------+
| Roberto | 22 | 8 |
| Wanda | 32 | 8 |
+---------+---------------+----------+
2 rows in set (0.00 sec)

Obtener una lista de cuentas ganadoras junto con
un recuento:

MariaDB [Prueba1]> SELECT Competiciones, COUNT(*)
FROM Competiciones
GROUP BY Triumfos;
+---------------+----------+
| Competiciones | COUNT(*) |
+---------------+----------+
| 17 | 1 |
| 20 | 1 |
| 22 | 2 |
+---------------+----------+
3 rows in set (0.00 sec)

El GROUP BY expresión puede ser un valor calculado,
y se puede hacer referencia a un identificador
especificado con AS Obtenga una lista de los promedios
del triunfo junto con un recuento:

MariaDB [Prueba1]> SELECT ( Triumfos / Competiciones) AS Promedia,
COUNT(*) FROM Competiciones
GROUP BY Promedia;
+----------+----------+
| Promedia | COUNT(*) |
+----------+----------+
| 0.1765 | 1 |
| 0.2500 | 2 |
| 0.3636 | 1 |
+----------+----------+
3 rows in set (0.00 sec)

Se puede utilizar cualquier función de la agrupación en la
expresión de selección. Por cada victoria promedio que el
anterior, obtener una lista de la cuenta promedio de juego
necesario para conseguir que la media:

MariaDB [Prueba1]> SELECT (Triumfos / Competiciones) AS Promedia,
AVG(Competiciones) FROM Competiciones
GROUP BY Promedia;
+----------+--------------------+
| Promedia | AVG(Competiciones) |
+----------+--------------------+
| 0.1765 | 17.0000 |
| 0.2500 | 26.0000 |
| 0.3636 | 22.0000 |
+----------+--------------------+
3 rows in set (0.03 sec)

Puedes realizar un filtrado de la información agregada mediante
el HAVING cláusula. El HAVING cláusula se aplica después de
GROUP BY y le permite filtrar los datos agregados que no está
disponible a la WHERE cláusula. Restringir el ejemplo anterior
con los resultados que implican un número promedio de más
de 20 jugadas:

MariaDB [Prueba1]> SELECT (Triumfos / Competiciones) AS Promedia,
AVG(Competiciones)
FROM Competiciones
GROUP BY Promedia HAVING AVG(Competiciones) > 20;
+----------+--------------------+
| Promedia | AVG(Competiciones) |
+----------+--------------------+
| 0.2500 | 26.0000 |
| 0.3636 | 22.0000 |
+----------+--------------------+
2 rows in set (0.00 sec)

</syntaxhighlight>

[[Category:MariaDB Desde la Consola]]
[[Category: CursoMatiaDB]]

Curso de MariaDB Desde la Consola/Select - Historial de revisiones

Rrc: /* Ejemplo */