¿Qué son las particiones y por qué son importantes en un proyecto?
Las particiones son fundamentales para la optimización y eficiencia de las bases de datos al manejar grandes volúmenes de información. Cuando se maneja mucha información en una sola tabla, las consultas pueden volverse lentas y el acceso a los datos puede ser ineficiente. Las particiones ayudan a superar esta limitación al dividir físicamente los datos en segmentos más pequeños, pero manteniendo la misma estructura lógica de la tabla original. Este proceso permite almacenar partes de una tabla en diferentes espacios de disco, lo que puede incluir incluso discos separados.
¿Cómo funcionan las particiones en una base de datos?
El uso de particiones permite crear tablas más manejables al dividir los datos en rangos lógicos. Por ejemplo, puedes crear una partición basada en fechas, donde cada segmento de la tabla se asocia a un rango específico de fechas. Esto significa que si realizas una consulta para buscar datos de una fecha específica, solo se accede al segmento relevante de la tabla, acelerando enormemente el tiempo de respuesta.
Cuando se manejan sistemas con consultas frecuentes y volúmenes de datos variables, las particiones no solo mejoran el rendimiento de las consultas, sino que también previenen que las tablas se saturen debido a un alto número de consultas simultáneas o modificaciones frecuentes.
¿Cómo crear una tabla particionada en PostgreSQL?
Ahora vamos a simular cómo crear una tabla particionada en PostgreSQL, teniendo en cuenta los conceptos mencionados. Aquí te presento un ejemplo simplificado:
-- Creamos la tabla principal que será particionadaCREATETABLE viajes ( id SERIALPRIMARYKEY, fecha DATENOTNULL)PARTITIONBY RANGE (fecha);-- Agregamos las particiones con base en el rango de fechasCREATETABLE viajes_2023_01 PARTITIONOF viajes
FORVALUESFROM('2023-01-01')TO('2023-02-01');CREATETABLE viajes_2023_02 PARTITIONOF viajes
FORVALUESFROM('2023-02-01')TO('2023-03-01');
Consideraciones al trabajar con tablas particionadas
Elección de campos de partición: La selección del campo sobre el cual se hace la partición es crucial. En este caso, usar fechas es común, pero podría ser cualquier otro campo que tenga sentido dividir lógicamente.
Nombres de tablas de partición: Es recomendable seguir un estándar en la nomenclatura para las tablas de partición. Por ejemplo, incluir el año y el mes facilita la identificación de la partición correspondiente.
Limitaciones: No se pueden usar llaves primarias en tablas particionadas, ya que estas están divididas. En lugar de ello, las referencias deben hacerse a las tablas que mantienen estas llaves.
Rangos de partición: Al definir los rangos, asegúrate de que son correctos y adecuados para las consultas que esperarías hacer en el futuro.
¿Cómo realizar consultas y modificaciones en tablas particionadas?
Las consultas en tablas particionadas se ejecutan de manera muy similar a las tablas regulares, con la diferencia de que el motor de base de datos solo busca en la partición relevante, lo que resulta en tiempos de respuesta más rápidos.
-- Ejemplo de inserción en tabla particionadaINSERTINTO viajes (fecha)VALUES('2023-01-15');-- Ejemplo de consulta en tabla particionadaSELECT*FROM viajes WHERE fecha ='2023-01-15';
Prueba de inserción y límites
Intentar insertar datos fuera del rango definido en las particiones resultará en un error, ya que el sistema no encontrará un espacio adecuado para el nuevo registro. Esto nos ayuda a mantener los datos organizados y dentro de los rangos esperados.
Recomendaciones para el uso de particiones
Si sabes que tu aplicación manejará un volumen significativo de datos históricos, considera implementar particiones desde el inicio. Esto no solo mejorará el rendimiento de tus consultas, sino que también hará que el sistema sea más escalable y fácil de administrar.
Crear particiones es ideal para manejar bitácoras u otras formas de almacenamiento de datos masivos. Así, siempre estarás un paso adelante en la optimización de tu sistema de bases de datos. ¡Anímate a probar esta técnica y verás cómo transformará la eficiencia de tus consultas en bases de datos grandes!
Ese color rojo me causa un tremendo conflicto interno ... 😅
Pensé que no lo dejaría pues había dicho que era incómodo jajaja
Es incómodo pero cuando estás trabajando sobre una base de datos de producción te mantiene más alerta ya que no ejecutas querys sin revisarlos dos veces.
Otra de las ventajas de las tablas particionadas es que puedes utilizar la sentencia TRUNCATE, la cual elimina toda la información de una tabla, pero a nivel partición. Es decir, si tienes una tabla con 12 particiones (1 para cada mes del año) y deseas eliminar toda la información del mes de Enero; con la sentencia ALTER TABLE tabla TRUNCATE PARTITION enero; podrías eliminar dicha información sin afectar el resto.
el comando que mencionas no me funcionó. El que sí fue
truncate <tabla particionada>;
gracias por la luz.
Saludos.
Excelente
Creando particiones
PARTITIONBYRANGE(fecha)WITH(OIDS=FALSE);ALTERTABLEpublic.bitacora_viajeOWNER to postgres;--Vamos a crear la particion
CREATETABLE bitacora_viaje201001 PARTITIONOFpublic.bitacora_viajeFORVALUESFROM('2010-01-01')TO('2020-04-24');--Insertamos un dato -->ERROR antes de crear la particions
INSERTINTOpublic.bitacora_viaje(id_viaje, fecha)VALUES(1,'2010-01-01');--Mostramos los valores de la tabla bitacora_viaje
SELECT*FROM bitacora_viaje;-- eliminamos la tabla bitacora_viaje y se eliminara la particion igualmente
DROPTABLE bitacora_viaje;```
No conocía la partición de tablas. Ni que podíamos asignar un rango a nuestros querys
HolaM
¡Comparto mi script de creación de tablas así como una imagen de mi modelo resultante!
1.- Modelo resultante
2.- Script de creación de tablas
/* SE CREA TABLA DE ESTACION */CREATETABLEpublic.estacion(id_estacion BIGSERIALPRIMARYKEY, nombre CHARACTERVARYING, direccion CHARACTERVARYING);/* SE CREA TABLA DE TREN */CREATETABLEpublic.tren(id_tren BIGSERIALPRIMARYKEY, modelo CHARACTERVARYING, capacidad INTEGER);/* SE CREA TABLA DE PASAJERO */CREATETABLEpublic.pasajero(id_pasajero BIGSERIALPRIMARYKEY, nombre CHARACTERVARYING, direccion CHARACTERVARYING, fecha DATE);/* SE CREA TABLA DE TRAYECTO */CREATETABLEpublic.trayecto(id_trayecto BIGSERIALPRIMARYKEY, id_estacion BIGINT, id_tren BIGINT, nombre CHARACTERVARYING);/* SE AGREGA LLAVE FORANEA ESTACION-TRAYECTO */ALTERTABLEpublic.trayectoADDCONSTRAINT estacion_trayecto_FK FOREIGNKEY(id_estacion)REFERENCESpublic.estacion(id_estacion);/* SE AGREGA LLAVE FORANEA TREN-TRAYECTO */ALTERTABLEpublic.trayectoADDCONSTRAINT tren_trayecto_FK FOREIGNKEY(id_tren)REFERENCESpublic.tren(id_tren);/* SE CREA TABLA DE VIAJE */CREATETABLEpublic.viaje(id_viaje BIGSERIALPRIMARYKEY, id_pasajero BIGINT, id_trayecto BIGINT, inicio DATE, fin DATE);/* SE AGREGA LLAVE FORANEA PASAJERO-VIAJE */ALTERTABLEpublic.viajeADDCONSTRAINT pasajero_viaje_FK FOREIGNKEY(id_pasajero)REFERENCESpublic.pasajero(id_pasajero);/* SE AGREGA LLAVE FORANEA TRAYECTO-VIAJE */ALTERTABLEpublic.viajeADDCONSTRAINT trayecto_viaje_FK FOREIGNKEY(id_trayecto)REFERENCESpublic.trayecto(id_trayecto);
Muy bueno su aporte.
Me podrá informar con que sofware realizó las tablas de entidades relación.Se ven muy bien
Excelente
Para los que vengan llegando, en las nuevas versiones se debe agregar comillas dobles al nombre de la tabla a la cual se esta particionando, si no tendran un Error que dice
Para realizar la creación de la partición, tuve que hacerlo de la siguiente forma:
CREATETABLEpublic.bitacora_viajes( id serial, id_viaje integer, fecha date
)PARTITIONBYRANGE(fecha);ALTERTABLEIFEXISTSpublic.bitacora_viajesOWNER to postgres;--PARTICIONDE bitacora_viajes
CREATETABLE bitacora_viajes_201001 PARTITIONOF bitacora_viajes
FORVALUESFROM('2010-01-01')TO('2010-02-01');
A diferencia del profesor, corregí el año al 2010, ya que esta tabla solo almacena información de ese mes; y puse la fecha hasta el primero de febrero puesto a que si intentabamos insertar información del 31 de enero, nos daba error.
En la clase el profe comete un error con las fechas del rango, al momento de poner 2010-01-01 to 2019-01-31, debería ser en realidad 2010-01-01 to 2010-01-31, por eso al momento en el que dice que la inserción del registro con la fecha 2012-01-01 va a fallar, no falla y muestra otro error que es el de la creación de la tabla particionada, en el que dice que la tabla ya existe. Espero que sirva de aclaración.
Ah ok. yo si decia porque no insertaba la fecha con 02 si en el rango establecido en el ejemplo, estan todos los meses ya que es un rando de 9 años. Gracias por la observación.
A mí no me funcionó la partición hasta que no le puse comillas al nombre de la bitácora.
Las particiones en PostgreSQL son una forma de dividir una tabla en múltiples partes lógicas, cada una con una estructura de datos y un almacenamiento separados
💽 Las particiones se utilizan para mejorar el rendimiento y la escalabilidad de la base de datos al permitir que los datos se dividan y distribuyan en varios nodos o discos.
Hay varios tipos de particiones en PostgreSQL, incluyendo:
Particiones por rango: En esta estrategia, los datos se dividen en partes basadas en un rango de valores en una columna clave.
Particiones por lista: En esta estrategia, los datos se dividen en partes basadas en una lista específica de valores en una columna clave.
Particiones por valor hash: En esta estrategia, los datos se dividen en partes basadas en el resultado de una función hash en una columna clave.
Particiones por fecha y hora: En esta estrategia, los datos se dividen en partes basadas en fechas o intervalos de tiempo en una columna clave.
El uso de particiones en PostgreSQL requiere una planificación cuidadosa y una buena comprensión de la estructura de los datos y las operaciones que se realizarán en la base de datos. Sin embargo, puede ser muy útil para mejorar el rendimiento y la escalabilidad de la base de datos en aplicaciones con grandes cantidades de datos y un alto nivel de actividad.
Creamos la tabla donde se alogaran los datos de la particion:
CREATETABLEpublic.bitacora_viaje( id serial, id_viaje integer, fecha date
)PARTITIONBYRANGE(fecha);ALTERTABLEIFEXISTSpublic.bitacora_viaje
OWNER to postgres;
Llegué un poco tarde, pero a los que no les salga la opción de partición deben hacer esto
Hay errores muy grandes en este vídeo. Desde la creación del script con un rango de 9 años, hasta la ejecución del mismo, donde no se seleccionan los pedazos correctos y se ejecutan otros distintos a los explicados.
Viene mal este curso hasta ahora, informacion con imprecisiones, poco dinamismo e interactividad. Nada que ver con el curso de Fundamentos de Bases de Datos que fue un 10/10
En que casos es recomendado usar el particionamiento de tablas?
En principio debes particionar tablas que tengan un alto movimiento de datos, muchas inserciones y consultas. Pero al final, si el proyecto llega a durar lo suficiente, terminarás con una cantidad enorme de datos que te obligarán a pariticionar casi todas las tablas de tu base de datos.
¿Las particiones están también para MySQL o es algo propio de PostgreSQL?
Sí se puede realizar particiones en MySQL, te invito a leer este artículo :D
¡Oh! está bastante bueno el artículo, muchas gracias.
¿Existe alguna forma que las particiones se creen dinamicamente en el momento que van ingresando nuevos datos?
Nosotros lo hacemos desde un cron, que llegando al último día del mes crea las particiones del mes siguiente, pero lo puedes hacer de muchas formas, por ejemplo, en un trigger.
La tabla se divide internamente en pequeñas partes o tablas en rangos o listas definido, que pueden ser: fechas u objetos. Existen dos tipos de particiones Particionamiento de rango (Range Partitioning) y Particionamiento de lista (List Partitioning)
