Curso de MariaDB Desde la Consola/Select

De WikiCabal
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)