Curso de MariaDB Desde la Consola/Select
Ir a la navegación
Ir a la búsqueda
Select
Sintaxis
1 SELECT
2 [ALL | DISTINCT | DISTINCTROW]
3 [HIGH_PRIORITY]
4 [STRAIGHT_JOIN]
5 [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
6 [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
7 select_expr [, select_expr ...]
8 [ FROM table_references [PARTITION (partition_list)]
9 [{USE|FORCE|IGNORE} INDEX [FOR {JOIN|ORDER BY|GROUP BY}] ([index_list]) ]
10 [WHERE where_condition]
11 [GROUP BY {col_name | expr | position} [ASC | DESC], ... [WITH ROLLUP]]
12 [HAVING where_condition]
13 [ORDER BY {col_name | expr | position} [ASC | DESC], ...]
14 [LIMIT {[offset,] row_count | row_count OFFSET offset}]
15 [PROCEDURE procedure_name(argument_list)]
16 [INTO OUTFILE 'file_name' [CHARACTER SET charset_name] [export_options]
17 | INTO DUMPFILE 'file_name' | INTO var_name [, var_name] ]
18 [FOR UPDATE | LOCK IN SHARE MODE] ]
19
20 export_options:
21 [{FIELDS | COLUMNS}
22 [TERMINATED BY 'string']
23 [[OPTIONALLY] ENCLOSED BY 'char']
24 [ESCAPED BY 'char']
25 ]
26 [LINES
27 [STARTING BY 'string']
28 [TERMINATED BY 'string']
29 ]
30
31 SELECT se utiliza para recuperar filas seleccionados de una
32 o más tables, y puede incluir UNION declaraciones y subconsultas.
33
34 Cada expresión select_expr indica una columna o datos que desea
35 recuperar. Usted debe tener al menos una expresión de SELECT.
36 Ver Select Expresions continuación.
37
38 La FROM cláusula indica la table o tables desde las que recuperar
39 filas. Utilice un solo nombre de tabla o un JOIN expresión.
40 Ver JOIN para más detalles. Si no hay ninguna tabla está
41 involucrado, FROM DUAL puede ser especificado.
42
43 MariaDB comenzando con 10,0
44
45 La cláusula PARTITION se introdujo en MariaDB 10.0.
46
47 Cada tabla también se puede especificar como db_name . tabl_name
48 Cada columna también se puede especificar como tbl_name . col_name
49 o incluso db_name . tbl_name . col_name Esto permite escribir
50 consultas que implican varias bases de datos.
51
52 El WHERE cláusula, si se da, indica la condición o condiciones que
53 cada registro debe cumplir para ser seleccionados. where_condition
54 es una expresión que se evalúa como verdadera para cada fila a
55 seleccionar. La declaración selecciona todas las filas si no hay
56 cláusula WHERE.
57
58 En el WHERE cláusula, puede utilizar cualquiera de las funciones
59 y operadores que MariaDB apoya, a excepción de las funciones de
60 agregación (resumen).
61
62 Utilice el ORDER BY cláusula para ordenar los resultados.
63
64 Utilice el LIMIT cláusula le permite restringir los resultados de
65 sólo un cierto número de filas, opcionalmente con un desplazamiento.
66
67 Utilice el GROUP BY y HAVING cláusulas a las filas del grupo juntos
68 cuando tienen columnas o valores calculados en común.
69
70 SELECT también se puede utilizar para recuperar filas computados sin
71 referencia a ninguna table.
72
73 Consejos Optimizer
74
75 Algunas opciones están disponibles para afectar el plan de ejecución.
76 HIGH PRIORITY
77
78 HIGH_PRIORITY da la declaración de mayor prioridad. Si la table está
79 bloqueada, HIGH PRIORITY SELECTs se ejecutará tan pronto como se
80 libera el bloqueo, incluso si otros estados están en queue. HIGH_PRIORITY
81 se aplica sólo si el motor de almacenamiento sólo es compatible con
82 bloqueo a nivel de table (MyISAM, MEMORY, MERGE).
83
84 SQL_CACHE / SQL_NO_CACHE
85
86 Si el query_cache_type variable del sistema se establece en 2 o DEMAND
87 y el estado actual es cacheable, SQL_CACHE hace que la consulta para
88 ser almacenado en caché y SQL_NO_CACHE hace que la consulta no debe
89 ser almacenado en caché. Para UNIONs, SQL_CACHE o SQL_NO_CACHE deben
90 especificarse para la primera consulta.
91
92 SQL_BUFFER_RESULT
93
94 SQL_BUFFER_RESULT obliga al optimizador de utilizar una tabla temporal
95 para procesar el resultado. Esto es útil para cerraduras libres tan
96 pronto como sea posible.
97
98 SQL_SMALL_RESULT / SQL_BIG_RESULT
99
100 SQL_SMALL_RESULT y SQL_BIG_RESULT dicen al optimizador si el resultado
101 es muy grande o no. Por lo general, GROUP BY y DISTINCT operaciones se
102 realizan utilizando una tabla temporal. Sólo si el resultado es muy
103 grande, usando una tabla temporal no es conveniente. El optimizador
104 sabe automáticamente si el resultado es demasiado grande, pero puede
105 forzar al optimizador a utilizar una tabla temporal con SQL_SMALL_RESULT
106 o evitar la tabla temporal utilizando SQL_BIG_RESULT
107
108 STRAIGHT_JOIN
109
110 STRAIGHT_JOIN aplica a los JOIN consultas, y le dice al optimizador
111 que las tablas deben leerse en el orden en que aparecen en el SELECT
112 Para const y system table de esta opción es a veces ignorados.
113
114 SQL_CALC_FOUND_ROWS
115
116 SQL_CALC_FOUND_ROWS se aplica sólo cuando se utiliza el LIMIT cláusula.
117 Si se utiliza esta opción, MariaDB contará cuántas filas se
118 correspondería con la consulta, sin el LIMIT cláusula. Ese número puede
119 ser recuperada en la próxima consulta, utilizando FOUND_ROWS ().
120
121 USE / FORCE / IGNORE ÍNDEX
122
123 USE INDEX FORCE INDEX y IGNORE INDEX restringen la planificación
124 consulta a un índice específico.
125
126 Select Expresiones
127
128 Un SELECT declaración debe contener uno o más select expresiones,
129 separadas por comas. Cada expresión de select puede ser uno de
130 los siguientes:
131
132 El nombre de una columna.
133 Cualquier expresión usando funciones y operadores.
134 * Para seleccionar todas las columnas de todas las tablas en
135 el FROM cláusula.
136 tbl_name.* para seleccionar todas las columnas de sólo el
137 tbl_name table.
138
139 Al especificar una columna, puede utilizar sólo el nombre de la
140 columna o calificar el nombre de la columna con el nombre de la
141 table con tbl_name.col_name La forma calificada es útil si se está
142 uniendo a varias tablas en el FROM cláusula. Si usted no califica
143 los nombres de columna al seleccionar de varias tables, MariaDB
144 tratará de encontrar la columna en cada table. Es un error si
145 existe ese nombre de columna en varias tables.
146
147 Puede citar nombres de columna utilizando back ticks.
148 Si usted está calificando nombres de columna con los nombres de
149 table, cita cada parte por separado como `tbl_name`.`col_name`
150
151 Si utiliza las funciones de agrupación en cualquiera de las
152 expresiones select, todas las filas de sus resultados se
153 agrupan de forma implícita, como si se hubiera usado
154 GROUP BY NULL
155
156 DISTINCT
157
158 Una consulta puede producir algunas filas idénticas. Por defecto,
159 todas las filas se recuperan, incluso cuando sus valores son los
160 mismos. Para especificar explícitamente que quiere recuperar filas
161 idénticas, utilice el ALL opción. Si desea duplicados para ser
162 retirados del conjunto de resultados, utilice el DISTINCT opción.
163 DISTINCTROW es sinónimo de DISTINCT.
164
165 INTO
166
167 El INTO cláusula se utiliza para especificar que los resultados de
168 la consulta deben ser escritos en un archivo o variable.
169
170 SELECT INTO OUTFILE - formatear y escribir el resultado en un
171 archivo externo.
172 SELECT INTO DUMPFILE - escritura binaria de fallos de los
173 resultados sin formato a un archivo externo.
174 SELECT INTO Variable - la selección y definición de variables.
175
176 El reverso de SELECT INTO OUTFILE es LOAD DATA.
177
178 ORDER BY
179
180 Utilice el ORDER BY cláusula para ordenar los resultados que se
181 devuelven de un SELECT comunicado. Puede especificar sólo una
182 columna o utilizar cualquier expresión con funciones. Si está
183 utilizando el GROUP BY cláusula, puede utilizar las funciones
184 de agrupación en ORDER BY Orden se realiza después de la agrupación.
185
186 Puede utilizar varias expresiones de pedidos, separados por comas.
187 Las filas se ordenarán por la primera expresión, y luego por la
188 segunda expresión si tienen el mismo valor para la primera, y así
189 sucesivamente.
190
191 Puede utilizar la palabra clave ASC y DESC después de cada expresión
192 de ordenar a la fuerza ese ordenamiento ser ascendente o descendente,
193 respectivamente. Orden está ascendiendo de forma predeterminada.
194
195 También puede utilizar un solo entero como la expresión de pedido.
196 Si utiliza un entero n, los resultados se ordenarán por la enésima
197 columna en la expresión de selección.
198
199 Cuando se comparan los valores de cadena, se comparan como si por el
200 STRCMP función. STRCMP ignora espacios en blanco y puede normalizar
201 personajes e ignorar caso, dependiendo de la colación en uso.
202
203 MariaDB empezando 05/05/35
204
205 A partir de MariaDB 05/05/35 duplican entradas en el ORDER BY cláusula
206 se eliminan. MySQL 5.6 también elimina campos duplicados.
207
208 LIMIT
209
210 Utilice el LIMIT cláusula para restringir el número de filas
211 devueltas. Cuando se utiliza un único entero n con LIMIT se
212 devolverán las primeras n filas. Utilice el ORDER BY cláusula
213 para controlar qué filas son lo primero. También puede
214 seleccionar un número de filas después de un desplazamiento
215 utilizando cualquiera de los siguientes:
216
217 LIMIT offset, row_count
218 LIMIT row_count OFFSET offset
219
220 Cuando usted proporciona un m compensado con un límite de n,
221 los primeros m filas serán ignorados, y se devolverán los
222 siguientes n filas.
223
224 Actualizaciones con el LIMIT cláusula no son seguros para la
225 replicación.
226
227 MariaDB empezando 10.0.11
228
229 Desde MariaDB 10.0.11, LIMIT 0 ha sido una excepción a esta
230 regla (ver MDEV-6170).
231
232 MariaDB a partir de 05/05/21
233
234 A partir de MariaDB 5/5/21, hay un LIMIT ROWS EXAMINED
235 optimización que proporciona los medios para poner fin a la
236 ejecución de SELECT declaraciones que examinan demasiadas filas,
237 y por lo tanto utilizar demasiados recursos. Ver las
238 LIMIT ROWS EXAMINED página para obtener más detalles.
239
240 GROUP BY
241
242 Utilice el GROUP BY cláusula para agrupar filas que tienen el
243 mismo valor en una o más columnas, o el mismo valor calculado
244 utilizando expresiones con las funciones y operadores, excepto
245 las funciones de agrupación. Cuando se utiliza un GROUP BY
246 cláusula, obtendrá una fila de resultado individual para cada
247 grupo de filas que tienen el mismo valor para la expresión dada
248 en GROUP BY
249
250 Al agrupar las filas, los valores de agrupación se comparan como
251 si por el = operador. Para valores de cadena, el = operador ignora
252 espacios en blanco y puede normalizar personajes e ignorar caso,
253 dependiendo de la colación en uso.
254
255 Puede utilizar cualquiera de las funciones de agrupación en su
256 select expresión. Sus valores se calcularán sobre la base de todas
257 las filas que han sido agrupados por cada fila de resultados. Si
258 selecciona una columna no agrupado o un valor calculado a partir de
259 una columna no agrupados, que no está definido qué fila el valor
260 devuelto es tomado de. Esto no se permite si el
261 ONLY_FULL_GROUP_BY sql_mode se utiliza.
262
263 Puede utilizar varias expresiones en el GROUP BY cláusula, separados
264 por comas. Las filas se agrupan si coinciden en cada una de las
265 expresiones.
266
267 También puede utilizar un solo entero como la expresión de agrupación.
268 Si utiliza un entero n, los resultados se agrupan por la enésima
269 columna en la expresión de selección.
270
271 El WHERE cláusula se aplica antes del GROUP BY cláusula. Filtra filas
272 no agregados antes de que las filas se agrupan. Para filtrar filas
273 agrupadas basado en valores agregados, utilice el HAVING cláusula.
274 El HAVING cláusula toma cualquier expresión y lo evalúa como un valor
275 lógico, al igual que el WHERE cláusula. Puede utilizar las funciones de
276 agrupación en el HAVING cláusula. Al igual que con la expresión de
277 selección, si hace referencia a columnas no agrupados en el HAVING
278 cláusula, el comportamiento es indefinido.
279
280 Por defecto, si un GROUP BY cláusula está presente, las filas en la
281 salida se ordenarán por las expresiones utilizadas en el GROUP BY
282 También puede especificar ASC o DESC (ascendente, descendente) después
283 de esas expresiones, como en ORDER BY El valor predeterminado es ASC
284
285 Si desea que las filas que se pueden ordenar por otro campo, se puede
286 añadir una explícita ORDER BY Si no desea que el resultado que se
287 ordenó, usted puede agregar ORDER BY NULL
288
289 CON ROLLUP
290
291 El WITH ROLLUP modificador agrega filas adicionales para el conjunto de
292 resultados que representan resúmenes super-agregados. Para una
293 descripción completa con ejemplos, vea SELECT con ROLLUP.
Ejemplo
1 MariaDB [Prueba1]> insert into inven
2 -> ( id, nombre, descrip, precio, cantidad )
3 -> values
4 -> ( 1, 'Manzanas', 'Mediano Granny-Smith.', 0.25, 1000 );
5 Query OK, 1 row affected (0.32 sec)
6
7 MariaDB [Prueba1]> select * from inven;
8 +----+----------+-----------------------+--------+----------+
9 | id | nombre | descrip | precio | cantidad |
10 +----+----------+-----------------------+--------+----------+
11 | 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
12 +----+----------+-----------------------+--------+----------+
13 1 row in set (0.00 sec)
14
15 MariaDB [Prueba1]> insert into inven values ( 2, 'Uvas', 'Sin Semillas', 2.99, 500 );
16 Query OK, 1 row affected (0.03 sec)
17
18 MariaDB [Prueba1]> select * from inven;
19 +----+----------+-----------------------+--------+----------+
20 | id | nombre | descrip | precio | cantidad |
21 +----+----------+-----------------------+--------+----------+
22 | 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
23 | 2 | Uvas | Sin Semillas | 2.99 | 500 |
24 +----+----------+-----------------------+--------+----------+
25 2 rows in set (0.00 sec)
26
27 MariaDB [Prueba1]> insert into inven values
28 -> ( 'Agua', 'Bot. - 250 ml.' , 0.89, 259 );
29 ERROR 1136 (21S01): Column count doesn"'"t match value count at row 1
30
31 MariaDB [Prueba1]> insert into inven values
32 -> ( '', 'Agua', 'Bot. - 250 ml.' , 0.89, 259 );
33 Query OK, 1 row affected, 1 warning (0.07 sec)
34
35 MariaDB [Prueba1]> insert into inven
36 -> ( nombre, descrip, precio, cantidad )
37 -> values ( 'AguaMineral', 'Bot. - 600 ml.' , 0.50, 350 );
38 Query OK, 1 row affected (0.07 sec)
39
40 MariaDB [Prueba1]> select * from inven;
41 +----+-------------+-----------------------+--------+----------+
42 | id | nombre | descrip | precio | cantidad |
43 +----+-------------+-----------------------+--------+----------+
44 | 1 | Manzanas | Mediano Granny-Smith. | 0.25 | 1000 |
45 | 2 | Uvas | Sin Semillas | 2.99 | 500 |
46 | 3 | Agua | Bot. - 250 ml. | 0.89 | 259 |
47 | 4 | AguaMineral | Bot. - 600 ml. | 0.5 | 350 |
48 +----+-------------+-----------------------+--------+----------+
49 4 rows in set (0.00 sec)
50
51 MariaDB [Prueba1]> select id, nombre, cantidad from inven;
52 +----+-------------+----------+
53 | id | nombre | cantidad |
54 +----+-------------+----------+
55 | 1 | Manzanas | 1000 |
56 | 2 | Uvas | 500 |
57 | 3 | Agua | 259 |
58 | 4 | AguaMineral | 350 |
59 +----+-------------+----------+
60 4 rows in set (0.00 sec)
61
62 MariaDB [Prueba1]> select id, nombre, cantidad from inven
63 -> order by nombre;
64 +----+-------------+----------+
65 | id | nombre | cantidad |
66 +----+-------------+----------+
67 | 3 | Agua | 259 |
68 | 4 | AguaMineral | 350 |
69 | 1 | Manzanas | 1000 |
70 | 2 | Uvas | 500 |
71 +----+-------------+----------+
72 4 rows in set (0.00 sec)
73
74 MariaDB [Prueba1]> select id, nombre, cantidad from inven
75 -> order by cantidad;
76 +----+-------------+----------+
77 | id | nombre | cantidad |
78 +----+-------------+----------+
79 | 3 | Agua | 259 |
80 | 4 | AguaMineral | 350 |
81 | 2 | Uvas | 500 |
82 | 1 | Manzanas | 1000 |
83 +----+-------------+----------+
84 4 rows in set (0.00 sec)
85
86 MariaDB [Prueba1]> select id, nombre, cantidad from inven
87 -> order by cantidad
88 -> limit 3;
89 +----+-------------+----------+
90 | id | nombre | cantidad |
91 +----+-------------+----------+
92 | 3 | Agua | 259 |
93 | 4 | AguaMineral | 350 |
94 | 2 | Uvas | 500 |
95 +----+-------------+----------+
96 3 rows in set (0.00 sec)
97
98 MariaDB [Prueba1]> select id, nombre, cantidad from inven
99 -> order by cantidad
100 -> limit 0, 3;
101 +----+-------------+----------+
102 | id | nombre | cantidad |
103 +----+-------------+----------+
104 | 3 | Agua | 259 |
105 | 4 | AguaMineral | 350 |
106 | 2 | Uvas | 500 |
107 +----+-------------+----------+
108 3 rows in set (0.00 sec)
109
110 MariaDB [Prueba1]> select id, nombre, cantidad from inven
111 -> order by cantidad
112 -> limit 2, 3;
113 +----+----------+----------+
114 | id | nombre | cantidad |
115 +----+----------+----------+
116 | 2 | Uvas | 500 |
117 | 1 | Manzanas | 1000 |
118 +----+----------+----------+
119 2 rows in set (0.00 sec)
120
121 MariaDB [Prueba1]> select id, nombre, cantidad from inven
122 -> order by cantidad
123 -> limit 5, 3;
124 Empty set (0.00 sec)
125
126 MariaDB [Prueba1]>
127
128 Considere la siguiente table que registra el número de veces
129 que cada usuario ha jugado y ganado un partido:
130
131 MariaDB [Prueba1]> CREATE TABLE Competiciones
132 ( Nomber VARCHAR(16),
133 Competiciones MediumINT,
134 Triumfos MediumINT );
135 Query OK, 0 rows affected (0.25 sec)
136
137 MariaDB [Prueba1]> INSERT INTO Competiciones VALUES
138 ("Juan", 20, 5),
139 ("Roberto", 22, 8),
140 ("Wanda", 32, 8),
141 ("Susana", 17, 3);
142 Query OK, 4 rows affected (0.06 sec)
143 Records: 4 Duplicates: 0 Warnings: 0
144
145 MariaDB [Prueba1]> select * from Competiciones;
146 +---------+---------------+----------+
147 | Nomber | Competiciones | Triumfos |
148 +---------+---------------+----------+
149 | Juan | 20 | 5 |
150 | Roberto | 22 | 8 |
151 | Wanda | 32 | 8 |
152 | Susana | 17 | 3 |
153 +---------+---------------+----------+
154 4 rows in set (0.00 sec)
155
156 MariaDB [Prueba1]> select * from Competiciones order by Triumfos;
157 +---------+---------------+----------+
158 | Nomber | Competiciones | Triumfos |
159 +---------+---------------+----------+
160 | Susana | 17 | 3 |
161 | Juan | 20 | 5 |
162 | Roberto | 22 | 8 |
163 | Wanda | 32 | 8 |
164 +---------+---------------+----------+
165 4 rows in set (0.00 sec)
166
167 MariaDB [Prueba1]> select * from Competiciones
168 order by Triumfos DESC;
169 +---------+---------------+----------+
170 | Nomber | Competiciones | Triumfos |
171 +---------+---------------+----------+
172 | Roberto | 22 | 8 |
173 | Wanda | 32 | 8 |
174 | Juan | 20 | 5 |
175 | Susana | 17 | 3 |
176 +---------+---------------+----------+
177 4 rows in set (0.00 sec)
178
179 MariaDB [Prueba1]> select * from Competiciones
180 WHERE Competiciones > 20
181 order by Triumfos DESC;
182 +---------+---------------+----------+
183 | Nomber | Competiciones | Triumfos |
184 +---------+---------------+----------+
185 | Roberto | 22 | 8 |
186 | Wanda | 32 | 8 |
187 +---------+---------------+----------+
188 2 rows in set (0.00 sec)
189
190 Obtener una lista de cuentas ganadoras junto con
191 un recuento:
192
193 MariaDB [Prueba1]> SELECT Competiciones, COUNT(*)
194 FROM Competiciones
195 GROUP BY Triumfos;
196 +---------------+----------+
197 | Competiciones | COUNT(*) |
198 +---------------+----------+
199 | 17 | 1 |
200 | 20 | 1 |
201 | 22 | 2 |
202 +---------------+----------+
203 3 rows in set (0.00 sec)
204
205 El GROUP BY expresión puede ser un valor calculado,
206 y se puede hacer referencia a un identificador
207 especificado con AS Obtenga una lista de los promedios
208 del triunfo junto con un recuento:
209
210 MariaDB [Prueba1]> SELECT ( Triumfos / Competiciones) AS Promedia,
211 COUNT(*) FROM Competiciones
212 GROUP BY Promedia;
213 +----------+----------+
214 | Promedia | COUNT(*) |
215 +----------+----------+
216 | 0.1765 | 1 |
217 | 0.2500 | 2 |
218 | 0.3636 | 1 |
219 +----------+----------+
220 3 rows in set (0.00 sec)
221
222 Se puede utilizar cualquier función de la agrupación en la
223 expresión de selección. Por cada victoria promedio que el
224 anterior, obtener una lista de la cuenta promedio de juego
225 necesario para conseguir que la media:
226
227 MariaDB [Prueba1]> SELECT (Triumfos / Competiciones) AS Promedia,
228 AVG(Competiciones) FROM Competiciones
229 GROUP BY Promedia;
230 +----------+--------------------+
231 | Promedia | AVG(Competiciones) |
232 +----------+--------------------+
233 | 0.1765 | 17.0000 |
234 | 0.2500 | 26.0000 |
235 | 0.3636 | 22.0000 |
236 +----------+--------------------+
237 3 rows in set (0.03 sec)
238
239 Puedes realizar un filtrado de la información agregada mediante
240 el HAVING cláusula. El HAVING cláusula se aplica después de
241 GROUP BY y le permite filtrar los datos agregados que no está
242 disponible a la WHERE cláusula. Restringir el ejemplo anterior
243 con los resultados que implican un número promedio de más
244 de 20 jugadas:
245
246 MariaDB [Prueba1]> SELECT (Triumfos / Competiciones) AS Promedia,
247 AVG(Competiciones)
248 FROM Competiciones
249 GROUP BY Promedia HAVING AVG(Competiciones) > 20;
250 +----------+--------------------+
251 | Promedia | AVG(Competiciones) |
252 +----------+--------------------+
253 | 0.2500 | 26.0000 |
254 | 0.3636 | 22.0000 |
255 +----------+--------------------+
256 2 rows in set (0.00 sec)
