Super Querys

“Dale con la coma” jejejeje…

Llevo años usando MySQL y este curso a mejorado notablemente mis competencias, precisamente hoy requerí crear una matriz y lo hice directamente desde la BD con SQL y no desde la capa de programacion, me ahorro multiples query uno por cada columna de la tabla.

Resumen de la clase:

-- SUM(), para sumar cada valor(1) en una tupla
SELECT 
  COUNT(book_id), 
  SUM(IF(year < 1950, 1, 0)) AS `<1950`,
  SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS `<1990`,
  SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS `<2000`,
  SUM(IF(year >= 2000, 1, 0)) AS `<hoy`
FROM books;

-- Agrupar el query anterior y mostrar su nacionalidad
SELECT 
  nationality,
  COUNT(book_id), 
  SUM(IF(year < 1950, 1, 0)) AS `<1950`,
  SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS `<1990`,
  SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS `<2000`,
  SUM(IF(year >= 2000, 1, 0)) AS `<hoy`
FROM books AS b
JOIN authors AS a
  ON a.author_id = b.author_id
WHERE a.nationality IS NOT NULL
GROUP BY nationality;

Creo que para este ejemplo quizás hubiese sido más elegante utilizar el operador between:

SELECT COUNT(book_id), 
SUM(IF(year < 1950, 1,0)) as '<1950', 
SUM(IF(year between 1950 and 1990, 1,0)) as '<1990', 
SUM(IF(year between 1990 and 2000,1,0)) as '<2000', 
SUM(IF(year between 2000 and YEAR(NOW()),1,0)) as '<hoy' 
FROM books;

+----------------+-------+-------+-------+------+
| count(book_id) | <1950 | <1990 | <2000 | <hoy |
+----------------+-------+-------+-------+------+
|            197 |   186 |     1 |     8 |    2 |
+----------------+-------+-------+-------+------+

Query:

en el error del profesor en el 10:40 cuando corrige solo como comentario, no era la coma, era los parentesis, abrió 2 parentesis y le faltaba cerrar 1, los parentesis funcionan como en excel, si abres 4 tienes que cerrar los 4.

“Y dale con la coma” El día a día de todo programador jajajaja

sin duda la clase que mas me impresiono, con unas cuantas lineas nuevas de comando, en sql se puede crear un análisis tremendo de los datos , y eso sin contar que no estamos trabajando con la tabla transacciones, por que con esa tabla se podrian sacar cosas del tipo, que mes se venden mas libros, de que autores suelen comprar los adolecentes , y si la base de datos es lo suficientemente grande , se pueden sacar conclusiones del tipo “los generos de libros que conocemos en la adolecencia se quedan para siempre?” o cuantos usuarios compran el mismo libro pero en diferentes idiomas etc

select name, sum(if(year(birthdate) < 1990, 1, 0)) AS "viejos",
    sum(if(year(birthdate) < 1990, 0, 1)) AS "jovenes"
    from clients
    group by name
    order by name ASC;```
se que es rebuscado ver quienes nacen antes  y despues de 1990 pero lo importante es el codigo!!

La verdad que este curso hace ver sql como algo que se puede llevar mas alla.

Tremenda energía Alberto Alcocer ¡ =)

Yo trabajé en este otro query con el fin de saber el inventario por nacionalidad:
SELECT A.nationality, SUM(B.copies) AS ‘INVENTARIO’,
SUM(IF(B.year < 1950, B.copies, 0)) AS ‘<1950’,
SUM(IF(B.year >= 1950 AND B.year < 1990, B.copies, 0)) AS ‘<1990’,
SUM(IF(B.year >= 1990 AND B.year < 2000, B.copies, 0)) AS ‘<2000’,
SUM(IF(B.year >= 2000, B.copies, 0)) AS 'HOY’
FROM books AS B
JOIN authors AS A
ON B.author_id = A.author_id
GROUP BY A.nationality
ORDER BY INVENTARIO DESC;

Consultas tan elaboradas como esta y que pueden llegar a ser muy repetidas conviene guardaralas en una vista.
Las vistas generan tablas a partir de las sentencias de SQL, y pueden ejecutarse a partir de su nombre unicamente.

-- Con esto puedes crear la vista que quedará guardada.
CREATE VIEW books_nationality_year AS
    SELECT a.nationality, COUNT(book_id) AS 'Total', 
        SUM(IF(year < 1950, 1, 0)) as `< 1950`,  
        SUM(IF(year < 1990 and year >= 1950, 1, 0)) as `< 1990`, 
        SUM(IF(year < 2000 and year >= 1990, 1, 0)) as `< 2000`, 
        SUM(IF(year >= 2000, 1, 0)) as `hoy`
    FROM books as b
    JOIN authors as a 
    ON b.author_id = a.author_id
    WHERE a.nationality IS NOT NULL
    GROUP BY nationality;
-- Con esto ejecutas la vista
SELECT * FROM books_nationality_year;

-- con este query pueden saber cuantos vendidos y cuantos no
select COUNT(book_id) AS Total, 
	SUM(IF(sellable = 0, 1, 0)) AS No_vendido, 
	SUM(IF(sellable = 1, 1, 0)) AS Vendido
FROM books;```

terminando el curso a poner en práctica todo lo aprendido, gracias Alberto Alcocer!

La razón por la que aparece ARG en el min 13:27 es porque somos los campeones del mundo!

Excelente explicación, yo soy uno de los que en php obtengo un listado de resultados y los recorro en un each, foreach … y modifico, creo o calculo, filas para mostrar, pero sabiendo aprovechar las funciones o trucos en sql, optimiza muchísimo el tiempo de respuesta.

realmente el valor en esta clase es analogo al del curso de javascript, en donde tu puedes traer toda la infor y usar un for para organizarla, o puedes usar funciones como map y filter.

Es asi que, tu puedes traer toda la info y analizarla usando un backend language, pero son mas lineas de codigo y mas trabajo qeu te puedes ahorrar desde el query

Excelente

SELECT DISTINCT nationality FROM authors;

UPDATE authors SET nationality = 'GBR' WHERE nationality = 'ENG';

SELECT COUNT(*) FROM books;

SELECT COUNT(book_id) FROM books;

SELECT COUNT(book_id) , SUM(1) FROM books;

SELECT SUM(price) FROM books WHERE sellable = 1; 

SELECT SUM(price*copies) FROM books WHERE sellable = 1;

SELECT sellable, SUM(price*copies) FROM books GROUP BY sellable;

SELECT COUNT(book_id) , SUM(IF(YEAR < 1950,1,0)) AS '< 1950' FROM books;

SELECT COUNT(book_id)   FROM books WHERE YEAR < 1950;

SELECT COUNT(book_id) , SUM(IF(YEAR < 1950,1,0)) AS '< 1950' , SUM(IF(YEAR <= 1950,0,1)) AS '>= 1950'  FROM books;

SELECT COUNT(book_id) , SUM(IF(YEAR < 1950,1,0)) AS '< 1950' , SUM(IF(YEAR >= 1950 AND YEAR < 1990,1,0)) AS '< 1990',  
SUM(IF(YEAR >= 1990 AND YEAR < 2000,1,0)) AS '< 2000'
FROM books; 

SELECT COUNT(book_id) , SUM(IF(YEAR < 1950,1,0)) AS '< 1950' , SUM(IF(YEAR >= 1950 AND YEAR < 1990,1,0)) AS '< 1990',  
SUM(IF(YEAR >= 1990 AND YEAR < 2000,1,0)) AS '< 2000' , SUM(IF(YEAR >= 2000 ,1,0)) AS '> 2000' 
FROM books; 

SELECT nationality,COUNT(book_id) , SUM(IF(YEAR < 1950,1,0)) AS '< 1950' , SUM(IF(YEAR >= 1950 AND YEAR < 1990,1,0)) AS '< 1990',  
SUM(IF(YEAR >= 1990 AND YEAR < 2000,1,0)) AS '< 2000' , SUM(IF(YEAR >= 2000 ,1,0)) AS '> 2000' 
FROM books AS b INNER JOIN authors AS a ON
b.author_id = a.author_id
WHERE nationality IS NOT NULL
GROUP BY nationality ;  

De los mejores cursos!

one little detail, Great Britain is not the same as England

el súper query:

select `nationality`, count(`book_id`) as `total_books`,
    sum(
        if(`year` < 1950, 1, 0)
    ) as `< 1950`,
    sum(
        if(`year` < 1990 and `year` >= 1950 , 1, 0)
    ) as `< 1990`,
    sum(
        if(`year` < 2000 and `year` >= 1990, 1, 0)
    ) as `< 2000`,
    sum(
        if(`year` > 2000, 1, 0)
    ) as `< today`
from books
inner join authors
    on authors.author_id = books.author_id
where authors.nationality is not null
group by `nationality`
order by `total_books` desc
;

Resumen de la Clase:
Tips:

• Buscamos darle inteligencia a las columnas.

Código:

-- Clase 20 Super Querys

--Cambiamos ENG por GBR en la nacionalidad de los autores
SELECT DISTINCT nationality from authors;

UPDATE authors set nationality = 'GBR' WHERE nationality = 'ENG';

SELECT count(book_id), sum(1) from books;

--Colocamos operaciones en las columnas
SELECT sum(price) from books WHERE sellable =1;
SELECT sum(price*copies) from books WHERE sellable =1;
SELECT sellable, sum(price*copies) from books GROUP BY sellable;

SELECT count(book_id), sum(if(year < 1950, 1, 0)) as '<1950' from books;
SELECT count(book_id) from books WHERE year < 1950;

SELECT count(book_id), 
    sum(if(year < 1950, 1, 0)) as '<1950', 
    sum(if(year < 1950, 0, 1)) as '>1950' 
FROM books;

SELECT count(book_id), 
    sum(if(year < 1950, 1, 0)) as '<1950', 
    sum(if(year >= 1950 and year < 1990, 1, 0)) as '<1990',
    sum(if(year >= 1990 and year < 2000, 1, 0)) as '<2000',
    sum(if(year >= 2000, 1, 0)) as '<hoy' 
FROM books;

SELECT nationality, count(book_id), 
    sum(if(year < 1950, 1, 0)) as '<1950', 
    sum(if(year >= 1950 and year < 1990, 1, 0)) as '<1990',
    sum(if(year >= 1990 and year < 2000, 1, 0)) as '<2000',
    sum(if(year >= 2000, 1, 0)) as '<hoy' 
FROM books as b
JOIN authors as a
    ON a.author_id = b.author_id
GROUP BY a.nationality
HAVING a.nationality IS NOT NULL;```

El error es que le falto colocar los paréntesis en la linea 3 y 4 no es la coma

UPDATE authors SET nationality = 'GBR' 
WHERE nationality LIKE 'ENG';



SELECT nationality, COUNT(book_id),
       SUM(IF(year < 1950, 1, 0)) AS '<1950',
       SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS '<1990',
       SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS '<2000',
       SUM(IF(year >= 2000, 1, 0)) AS '< HOY'
FROM books AS B
JOIN authors AS A
ON A.author_id = B.author_id
WHERE A.nationality IS NOT NULL
GROUP BY A.nationality

INTERESANTE CLASE

Toca entrenar la lógica con SQL para poder sacar muy buenos query, pero me gustó el curso.
¿Alguien sabe de libros donde siga con esto?

Buen curso estoy cada vez mas preparado, gracias profesor Alberto Alcocer.

para los que somos del futuro y les marque ‘You have an error in your SQL syntax’ por su versión,

Pueden probar esto:

SELECT COUNT(book_id),
SUM(if(year<1950,1,0)) AS ‘0-1950’,
SUM(if(year>=1950 AND year<1970,1,0)) AS ‘1950-1970’,
SUM(IF(year>=1970 AND year<1980,1,0)) AS ‘1970-
1980’,
SUM(IF(year>=1980,1,0)) AS "1980-2021"
from book;

Panchólares ( $P )

Creo que esta forma de consultar información filtrada por grupos me será muy útil, por ejemplo para ver cuantos usuarios nuevos hay por cada mes en mi aplicación

Muy potente

Así me quedo mi Super Query al final

SELECT nationality, COUNT(book_id) AS numero_de_libros,
SUM(IF(year < 1950, 1, 0)) AS `<1950`,
SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS `<1990`,
SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS `<2000`,
SUM(IF(year >= 2000, 1, 0)) AS `>2000`
FROM books AS b
JOIN authors AS a
ON a.author_id = b.author_id
WHERE 
a.nationality IS NOT NULL
GROUP BY nationality
ORDER BY numero_de_libros DESC, nationality;

Les recomiendo probar este:

SELECT a.nationality AS nacionalidad,
       COUNT(b.book_id) AS total, 
       SUM(IF(b.year < 1950,1,0)) AS 'año<1950', 
       SUM(IF(b.year < 1950,0,1)) AS 'año>=1950' 
FROM books AS b 
LEFT JOIN authors AS a 
       ON a.author_id = b.author_id 
GROUP BY a.nationality 
ORDER BY total DESC, a.nationality ASC;

comparto con usted que "no es lo mismo", y se suma a la buena prácticas; el * lee primero la estructura de la tabla antes de hacer el COUNT(). En el curso de fundamentos de BD esto ni se comenta!

Entendí esa referencia jaja

Creo que esta clase, es la que mas me ha sorprendido del curso, es sorprendente como puedes modelar los datos, directamente en la base de datos.
Muchas Gracias

Muestra la cantidad de libros por rango de años

SELECT COUNT(book_id),
SUM(IF(year < 1950, 1, 0)) AS 'Menores a 1950',
SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS 'Entre 1950 y 1989',
SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS 'Entre 1990 y 1999',
SUM(IF(year >= 2000, 1, 0)) AS 'Año 2000 en adelante'
FROM books;

Si la consulta resulta ser rápida. Entonces mi opinión personal este tipo de responsabilidad la delego al modelo (base de datos)

SELECT nationality, COUNT(book_id) AS 'Cantidad Total',
SUM(IF(year < 1950, 1, 0)) AS 'Menores a 1950',
SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS 'Entre 1950 y 1989',
SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS 'Entre 1990 y 1999',
SUM(IF(year >= 2000, 1, 0)) AS 'Año 2000 en adelante'
FROM books AS libro
JOIN authors AS autor
USING(author_id)
WHERE autor.nationality IS NOT NULL
GROUP BY nationality;

Esta clase se me hizo corta, estuvo bastante interesante…

SELECT nationality, COUNT(book_id),
	SUM(IF(year < 1950, 1, 0)) AS `<1950`,
	SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS `<1990`,
	SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS `<2000`,
	SUM(IF(year >= 2000, 1, 0)) AS `<hoy`
FROM books AS b
JOIN authors AS a
	ON a.author_id = b.author_id
WHERE
	a.nationality IS NOT NULL
GROUP BY nationality;

muy buenas querys, me ayudaron bastante

mira ese potencial.jpg

Clase con mucho valor 😃

Excelente , es grandioso lo que se puede hacer con los super querys.
😄

Yo opino que si la capa de negocio no necesita toda la información es mejor que la capa de base de datos provea de una vez la información útil y procesada. Esto lo hace más rápido sobre todo si no conviven en el mismo lugar ambas capas y reduce la cantidad de datos transferidos.

Excelentes los super querys, ayudan bastante

muy buena clase y explicación, tengo una buena base, con la practica saldra de manera mas natural

La mejor clase sin duda

Excelente clase Poniendo en practica mucho de lo aprendido y a pensar en el negocio

Super Query

Como alternativa para filtrar los autores con nationality = NULL, en lugar de un WHERE antes de la agrupación, podemos utilizar un HAVING después de haber realizado la agrupación, de la siguiente manera, creo que es bueno tenerlo en cuenta:

SELECT a.nationality AS Nacionalidad, COUNT(b.book_id) AS Libros, SUM(IF(year < 1950, 1, 0)) AS '<1950',
	SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS '<1990',
    SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS '<2000',
    SUM(IF(year >= 2000, 1, 0)) AS '<Hoy'
 FROM books as b
 INNER JOIN authors AS a
	 ON b.author_id = a.author_id
 GROUP BY a.nationality
 HAVING a.nationality IS NOT NULL
 ORDER BY Libros DESC;

Esto está de lujo, desde hace años que estaba buscando como hacer una tabla de doble entrada en sql

Primeros Pasos:

mysql> SELECT nationality,
        COUNT(book_id) AS 'Cant_Books',
        SUM(IF(year < 1950, 1, 0 )) AS '<1950', 
        SUM(IF(year >= 1950 AND year < 1990, 1, 0)) AS '<1990',
        SUM(IF(year >= 1990 AND year < 2000, 1, 0)) AS '<2000',
        SUM(IF(year >= 2000, 1, 0)) AS '<hoy'
 FROM books AS b
 JOIN authors AS a
    ON a.author_id = b.author_id
 WHERE a.nationality IS NOT NULL
 GROUP BY a.nationality
  ORDER BY 2 DESC;
+-------------+------------+-------+-------+-------+------+
| nationality | Cant_Books | <1950 | <1990 | <2000 | <hoy |
+-------------+------------+-------+-------+-------+------+
| USA         |         36 |    34 |     0 |     0 |    2 |
| ENG         |         16 |    16 |     0 |     0 |    0 |
| SWE         |         11 |     3 |     0 |     8 |    0 |
| RUS         |          9 |     9 |     0 |     0 |    0 |
| IND         |          8 |     8 |     0 |     0 |    0 |
| AUT         |          4 |     4 |     0 |     0 |    0 |
| GBR         |          3 |     3 |     0 |     0 |    0 |
| FRA         |          3 |     3 |     0 |     0 |    0 |
| AUS         |          2 |     2 |     0 |     0 |    0 |
| MEX         |          1 |     0 |     1 |     0 |    0 |
| JAP         |          1 |     1 |     0 |     0 |    0 |
| ESP         |          1 |     1 |     0 |     0 |    0 |
| DEU         |          1 |     1 |     0 |     0 |    0 |
+-------------+------------+-------+-------+-------+------+
13 rows in set (0.00 sec)

Excelente profesor, ahora me doy cuenta de la sencilles de trabajar con comandos desde la terminal:)

Excelente clase.

La explicación es muy bueno, aunque creo que hay funciones que NO se pueden utilizar dentro de los SELECT que se usan común mente en el WHERE.
Los buscaré y les doy retro

select nationality, count(book_id),
sum(if(year < 1950, 1, 0)) as '<1950',
sum(if(year >= 1950 and year < 1990, 1,0)) as '<1990',
sum(if(year >= 1990 and year < 2000, 1, 0)) as '<2000',
sum(if(year >= 2000, 1, 0)) as '<hoy'
from books as b
join authors as a
  on a.author_id = b.author_id
where a.nationality is not null
group by a.nationality;

Super Querys = Super Poder, así como lo dice Alberto el límite para aplicar esto es infinito, todo depende de lo que necesitemos.

Lo que cuesta cada libro: https://www.google.com/search?q=pancholas&oq=pancholas&aqs=chrome..69i57.2363j0j1&sourceid=chrome&ie=UTF-8

"Super Querys"
UPDATE authors SET nationality 
FROM authors
;

SELECT COUNT(book_id) 
FROM books 
;

SELECT COUNT(book_id), SUM(1) 
FROM books 
;

SELECT SUM(price*copies)
FROM books
GROUP BY selleable 
;

SELECT COUNT(book_id), 
SUM(if(year < 1950, 1 , 0)) 
    AS '<1950'
FROM books
;

SELECT nationality, COUNT(book_id), 
SUM(if(year < 1950, 1 , 0)) 
    AS '<1950'
SUM(if(year >= 1950 AND year <1990, 1 , 0)) 
    AS '<1990'
SUM(if(year >=  1990 AND year <2000, 1 , 0)) 
    AS '<2000'
SUM(if(year >= 2000,1,0))
    AS '<today'
FROM books AS b 
JOIN authors AS a 
ON a.author_id = b.author_id
WHERE 
    a.nationality IS NOT NULL 
; 

UPDATEauthors
SET nationality = "GBR"
WHERE nationality = "ENG";

UPDATEauthors
SET nationality = "GBR"
WHERE nationality = "ENG";
SELECT nationality, COUNT(book_id),
  SUM(IF(year < 1950, 1, 0)) AS"<1950",
  SUM(IF(year >= 1950andyear < 1990, 1, 0)) AS"<1990",
  SUM(IF(year >= 1990andyear < 2000, 1, 0)) AS"<2000",
  SUM(IF(year >= 2000, 1, 0)) AS"<hoy"
FROM books AS b
JOINauthorsAS a
ON a.author_id = b.author_id
WHERE a.nationality ISNOTNULL
GROUPBY nationality;```

Pues como muchos comentarios dicen, esta cla se alucino.

buenas clases

Utilizandolo de forma correcta MySQL es una herramienta muy poderosa.

Excelente clase y el super querys muy bien explicada la estructura explicada y replicada

¿Alguien sabe como se usa el IF en un query de ORACLE?

No conocía la etiqueta DISTINCT gran aporte !!!

Una clase muy interesante, usando condicionales dentro de las queries de MySQL, muy buenos ejemplos!

Excelente clase.

excelente herramienta la de los condicionales dentro de un sum

Incredible querys!

Muy bueno, soy estudiante de ingeniería de sistemas, así que me quedo muy claro la mayoría, muchas gracias!!

En esta clase si aprendí algo nuevo, muy bueno, y reforce otras que tuve que aprender a prueba y error, gracias.

y dale con la coma

Cual es la diferencia entre usar el if y case? lo digo por que yo, siempre uso el case.

Excelente

No soy experto en MySQL pero con esta inteligencia de columnas se me ocurre crear algunas Vistas o Views con cierta información ya digerida para la capa de negocio.

select nationality,count(book_id),
sum(if(year < 1950, 1, 0)) as ‘<1950’ ,
sum(if(year >= 1950 and year <1990, 1, 0)) as ‘>1990’ ,
sum(if(year >= 1990 and year <2000, 1, 0)) as ‘>2000’,
sum(if(year >= 2000, 1, 0)) as '>Hoy’
from books as b
join authors as a
on a.author_id=b.author_id
where
a.nationality is not null
group by nationality;

Una consulta estos tipos de querys : superquerys ejm: price(if…) eso no baja el performace del mysql ?’

Excelente curso, no se por qué lo eliminaron de la carrera de Data Science.

Buenas, tengo una consulta ya que con el codigo que pueden ver debajo al ejectuar me arroja el ‘Error:1175 You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column. To disable safe mode, toggle the option in Preferences’ Que podra ocurrir .

UPDATE authors
SET nationality = 'GBR'
WHERE nationality = 'ENG'
;

Saludos!

Les escribo aquí un código algo grande, en el que agrupo los mismos datos por medio de sum, lo ordeno por décadas, pero en esa misma columna, se le agrega el nombre de qué personas son.
Al final la única forma en la que lo logré hacer es que me queden las décadas en una columna, y la suma de las personas con sus nombres en otra columna.

Si alguien más lo pudo hacer de forma más fácil, puede adjuntarlo aquí.

<code>
SELECT  MIN(YEAR(BIRTHDATE)) AS DECADA,  
concat(sum(if(year(birthdate) between 1950 and 1959, 1, 0)), 
group_concat(" (", name, ")")) 
AS 'Numero de Clientes y sus Nombres'
FROM clients
WHERE year(birthdate) < 1960
UNION
SELECT  MIN(YEAR(BIRTHDATE)),  
concat(sum(if(year(birthdate) between 1960 and 1969, 1, 0)), 
group_concat(" (", name, ")")) 
FROM clients
WHERE year(birthdate) >= 1960 and year(birthdate) < 1970
UNION
SELECT  MIN(YEAR(BIRTHDATE)),  
concat(sum(if(year(birthdate) between 1970 and 1979, 1, 0)), 
group_concat(" (", name, ")")) 
FROM clients
WHERE year(birthdate) >= 1970 and year(birthdate) < 1980
UNION
SELECT  MIN(YEAR(BIRTHDATE)),  
concat(sum(if(year(birthdate) between 1980 and 1989, 1, 0)), 
group_concat(" (", name, ")")) 
FROM clients
WHERE year(birthdate) >= 1980 and year(birthdate) < 1990
UNION
SELECT  MIN(YEAR(BIRTHDATE)),  
concat(sum(if(year(birthdate) between 1990 and 1999, 1, 0)), 
group_concat(" (", name, ")")) 
FROM clients
WHERE year(birthdate) >= 1990 and year(birthdate) < 2000
UNION
SELECT  MIN(YEAR(BIRTHDATE)),  
concat(sum(if(year(birthdate) between 2000 and 2009, 1, 0)), 
group_concat(" (", name, ")")) 
FROM clients
WHERE year(birthdate) >= 2000 and year(birthdate) < 2010
;

Pregunta
¿Una vez que generé una matriz de información con un súper Query puedo imprimirlo o guardarlo en algún archivo tipo documento? o ¿Cómo se hace para exportar esa tabla creada en particular?

Excelente clase, Los super Querys es para realmente sacarle jugo a los datos