La tabla dinámica es una forma útil de analizar una gran cantidad de datos organizándolos en un formato más manejable. Aquí se explica cómo crear una tabla dinámica en PostgreSQL. En otras palabras, crearemos una tabla de referencias cruzadas en PostgreSQL.
Cómo crear una tabla dinámica en PostgreSQL
Hay al menos un par de formas de crear una tabla dinámica en PostgreSQL. Uno es donde cambiamos filas a columnas en PostgreSQL usando la instrucción CASE, y otro es un ejemplo simple de la función de tabulación cruzada de PostgreSQL.
Digamos que tienes la siguiente tabla
CREATE TABLE Meeting
(
ID INT,
Meeting_id INT,
field_key VARCHAR(100),
field_value VARCHAR(100)
);
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (1, 1,'first_name' , 'Alec');
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (2, 1,'last_name' , 'Jones');
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (3, 1,'occupation' , 'engineer');
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (4,2,'first_name' , 'John');
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (5,2,'last_name' , 'Doe');
INSERT INTO Meeting(ID,Meeting_id,field_key,field_value)
VALUES (6,2,'occupation' , 'engineer');
+------+------------+------------+-------------+
| ID | Meeting_id | field_key | field_value |
+------+------------+------------+-------------+
| 1 | 1 | first_name | Alec |
| 2 | 1 | last_name | Jones |
| 3 | 1 | occupation | engineer |
| 4 | 2 | first_name | John |
| 5 | 2 | last_name | Doe |
| 6 | 2 | occupation | engineer |
+------+------------+------------+-------------+
Supongamos que desea crear una tabla dinámica en PostgreSQL, de modo que se cree una nueva columna para cada valor único en field_key columna, es decir (nombre, apellido, ocupación) como se muestra a continuación
+------------+-------------+-------------+-------------+ | Meeting_id | first_name | last_name | occupation | +------------+-------------+-------------+-------------+ | 1 | Alec | Jones | engineer | | 2 | John | Doe | engineer | +------------+-------------+-------------+-------------+
Crear una tabla dinámica en PostgreSQL usando la instrucción CASE
Puede transponer fácilmente filas en columnas en la tabla anterior usando la instrucción CASE,
postgresql> select meeting_Id,
max(case when (field_key='first_name') then field_value else NULL end) as first_name,
max(case when (field_key='last_name') then field_value else NULL end) as last_name,
max(case when (field_key='occupation') then field_value else NULL end) as occupation
from meeting
group by meeting_Id
order by meeting_Id;
+------------+------------+-----------+------------+
| meeting_Id | first_name | last_name | occupation |
+------------+------------+-----------+------------+
| 1 | Alec | Jones | engineer |
| 2 | John | Doe | engineer |
+------------+------------+-----------+------------+
En la declaración anterior, la field_key de cada fila se comprueba el valor y, en consecuencia, se rellenan las columnas. Por ejemplo, si field_key el valor es 'first_name' luego first_name se completa la columna, y así sucesivamente.
Una vez que crea una tabla dinámica en PostgreSQL, puede usar una herramienta de informes para trazarla en una tabla. Aquí hay un ejemplo de tabla dinámica creada con Ubiq. ¿Sabías que Ubiq te permite crear tablas dinámicas sin escribir SQL?
Lectura adicional: Cómo calcular el total acumulado en Redshift
Crear tabla dinámica en PostgreSQL usando la función Crosstab
PostgreSQL también proporciona una función Crosstab integrada que le permite crear fácilmente una tabla dinámica en PostgreSQL. Sin embargo, debe instalar table_func extensión para habilitar la función Crosstab.
postgresql> CREATE EXTENSION IF NOT EXISTS tablefunc;
Digamos que tienes la siguiente tabla.
CREATE TABLE exams (
id int(11) NOT NULL auto_increment,
name varchar(15),
exam int,
score int,
PRIMARY KEY (id)
);
insert into exams (name,exam,score) values ('Bob',1,70);
insert into exams (name,exam,score) values ('Bob',2,77);
insert into exams (name,exam,score) values ('Bob',3,71);
insert into exams (name,exam,score) values ('Bob',4,70);
insert into exams (name,exam,score) values ('Sue',1,89);
insert into exams (name,exam,score) values ('Sue',2,87);
insert into exams (name,exam,score) values ('Sue',3,88);
insert into exams (name,exam,score) values ('Sue',4,89);
mysql> select * from exams;
+------+------+------+-------+
| id | name | exam | score |
+------+------+------+-------+
| 1 | Bob | 1 | 70 |
| 2 | Bob | 2 | 77 |
| 3 | Bob | 3 | 71 |
| 4 | Bob | 4 | 70 |
| 5 | Sue | 1 | 89 |
| 6 | Sue | 2 | 87 |
| 7 | Sue | 3 | 88 |
| 8 | Sue | 4 | 89 |
+------+------+------+-------+
Supongamos que desea girar la tabla anterior por Examen columna, de modo que para cada estudiante obtenga 1 fila, con todos los puntajes de los exámenes en columnas separadas, como se muestra a continuación.
name | exam1 | exam2 | exam3 | exam4 ------+-------+-------+-------+------- Bob | 70 | 77 | 71 | 70 Sue | 89 | 87 | 88 | 89
Dado que hemos habilitado la función Crosstab para nuestra base de datos, puede usar la siguiente consulta para crear una tabla cruzada en PostgreSQL.
postgres=# SELECT * FROM crosstab('select name, exam, score from exams order by 1,2')
AS ct (name varchar(15),exam1 int, exam2 int, exam3 int, exam4 int);
name | exam1 | exam2 | exam3 | exam4
------+-------+-------+-------+-------
Bob | 70 | 77 | 71 | 70
Sue | 89 | 87 | 88 | 89
Crosstab funciona con una consulta SELECT como parámetro de entrada que debe cumplir con 3 requisitos
- Debe devolver 3 columnas
- La primera columna es el identificador de fila para su tabla dinámica final, por ejemplo, nombre
- La segunda columna es la columna de categoría que se pivotará, por ejemplo, examen
- La tercera columna es la columna de valor que desea pivotar, por ejemplo, puntuación
La tabulación cruzada tomará el resultado de su consulta SELECT y creará una tabla dinámica a partir de ella, en función de las columnas que mencione para su tabla dinámica. En la consulta anterior, la tabla dinámica se almacena en una tabla temporal ct(name varchar(15),exam1 int, exam2 int, exam3 int, exam4 int). Debe definir los nombres de las columnas y los tipos de datos de su tabla dinámica final.
Lectura adicional: Cómo calcular la media móvil en corrimiento al rojo
En nuestra opinión, si desea crear una tabla dinámica en PostgreSQL, encontramos que el método Crosstab es más difícil que usar la declaración CASE, principalmente porque Crosstab arroja errores si no define correctamente los tipos de datos de columna de la tabla dinámica final.
Sin embargo, ahora conoce dos formas de crear una tabla dinámica en PostgreSQL. Puede personalizarlos según sus necesidades.
¿Sabías que puedes crear tablas dinámicas en Ubiq simplemente arrastrando y soltando?
Por cierto, si desea crear tablas dinámicas, gráficos y paneles a partir de la base de datos PostgreSQL, puede probar Ubiq. Ofrecemos una prueba gratuita de 14 días.
