No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de PostgreSQL

Curso de PostgreSQL

Oswaldo Rodr铆guez Gonz谩lez

Oswaldo Rodr铆guez Gonz谩lez

Particiones

13/32
Recursos

Aportes 129

Preguntas 60

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Ese color rojo me causa un tremendo conflicto interno 鈥 馃槄

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.

Creando particiones
![](

Hola, creo que hay un error en las fechas鈥 La partici贸n deber铆a ser en enero del mismo a帽o 2010鈥 No de 2010 a 2019. De resto todo bien!

Es importante recalcar que en la fecha final de nuestro rango de d铆as el motor de bases de datos excluye el valor de nuestro 煤ltimo d铆a es decir, si el mes termina en 31 entonces en nuestro rango debe terminar en 32

Informaci贸n resumida de esta clase
#EstudiantesDePlatzi

  • Las particiones consisten en la separaci贸n f铆sica de datos conservando la estructura l贸gica, esto ayuda a acelerar nuestras consultas

  • Si la tabla que vamos a crear es particionada debemos indicarlo en la pesta帽a general

  • No es posible crear llaves primarias en tablas particionadas

Particiones
- Separacion fisica de datos
- Estructura logica

-- Tabla bitacora_viaje
CREATE TABLE public.bitacora_viaje(
    id serial,
    id_viaje integer,
    fecha date
) PARTITION BY RANGE (fecha) WITH (OIDS = FALSE);
ALTER TABLE public.bitacora_viaje OWNER to postgres;

-- Vamos a crear la particion
CREATE TABLE bitacora_viaje201001 PARTITION OF public.bitacora_viaje
FOR VALUES FROM ('2010-01-01') TO  ('2020-04-24');

-- Insertamos un dato --> ERROR antes de crear la particions
INSERT INTO public.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
DROP TABLE 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 */
CREATE TABLE public.estacion(id_estacion    BIGSERIAL PRIMARY KEY,
                             nombre         CHARACTER VARYING,
                             direccion      CHARACTER VARYING);

/* SE CREA TABLA DE TREN */
CREATE TABLE public.tren(id_tren    BIGSERIAL PRIMARY KEY,
                         modelo     CHARACTER VARYING,
                         capacidad  INTEGER);

/* SE CREA TABLA DE PASAJERO */
CREATE TABLE public.pasajero(id_pasajero BIGSERIAL PRIMARY KEY,
                             nombre      CHARACTER VARYING,
                             direccion   CHARACTER VARYING,
                             fecha       DATE);


/* SE CREA TABLA DE TRAYECTO */
CREATE TABLE public.trayecto(id_trayecto    BIGSERIAL PRIMARY KEY,
                             id_estacion    BIGINT,
                             id_tren        BIGINT,
                             nombre         CHARACTER VARYING);

/* SE AGREGA LLAVE FORANEA ESTACION-TRAYECTO */
ALTER TABLE public.trayecto
    ADD CONSTRAINT estacion_trayecto_FK FOREIGN KEY (id_estacion) REFERENCES public.estacion(id_estacion);

/* SE AGREGA LLAVE FORANEA TREN-TRAYECTO */
ALTER TABLE public.trayecto
    ADD CONSTRAINT tren_trayecto_FK FOREIGN KEY (id_tren)   REFERENCES public.tren(id_tren);

/* SE CREA TABLA DE VIAJE */
CREATE TABLE public.viaje(id_viaje    BIGSERIAL PRIMARY KEY,
                          id_pasajero BIGINT,
                          id_trayecto BIGINT,
                          inicio      DATE,
                          fin         DATE);

/* SE AGREGA LLAVE FORANEA PASAJERO-VIAJE */
ALTER TABLE public.viaje
    ADD CONSTRAINT pasajero_viaje_FK FOREIGN KEY (id_pasajero) REFERENCES public.pasajero(id_pasajero);

/* SE AGREGA LLAVE FORANEA TRAYECTO-VIAJE */
ALTER TABLE public.viaje
    ADD CONSTRAINT trayecto_viaje_FK FOREIGN KEY (id_trayecto) REFERENCES public.trayecto(id_trayecto);


Llegu茅 un poco tarde, pero a los que no les salga la opci贸n de partici贸n deben hacer esto

Para realizar la creaci贸n de la partici贸n, tuve que hacerlo de la siguiente forma:

CREATE TABLE public.bitacora_viajes
(
    id serial,
    id_viaje integer,
    fecha date
) PARTITION BY RANGE (fecha);

ALTER TABLE IF EXISTS public.bitacora_viajes
    OWNER to postgres;

--PARTICION DE bitacora_viajes

CREATE TABLE bitacora_viajes_201001 PARTITION OF bitacora_viajes
FOR VALUES FROM ('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.

A m铆 no me funcion贸 la partici贸n hasta que no le puse comillas al nombre de la bit谩cora.

CREATE TABLE "Bitacora_viajes201001" PARTITION OF "Bitacora_viajes"
FOR VALUES FROM ('2010-01-01') TO ('2010-01-31');

En que casos es recomendado usar el particionamiento de tablas?

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

error relation bitacora_viajes does not exist

AQUI la solucion:

CREATE TABLE BITACORA_VIAJES201001 PARTITION OF "BITACORA_VIAJES"
FOR VALUES FROM ('2010-01-01') TO ('2010-01-31');

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)

Si les marca error cambien el orden:

CREATE TABLE bitacora_viaje201001 PARTITION OF bitacora_viaje
FOR VALUES FROM ('2010-01-01') TO ('2010-01-31');
	
INSERT INTO public.bitacora_viaje(
	id_viaje, fecha)
	VALUES (1, '2010-01-01');

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.

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.

Codigo

CREATE DATABASE transporte
    WITH 
    OWNER = postgres
    ENCODING = 'UTF8'
    LC_COLLATE = 'C.UTF-8'
    LC_CTYPE = 'C.UTF-8'
    TABLESPACE = pg_default
    CONNECTION LIMIT = -1;
CREATE TABLE public.estacion
(
    id integer NOT NULL DEFAULT nextval('estacion_id_seq'::regclass),
    nombre character varying(100) COLLATE pg_catalog."default",
    direccion character varying(100) COLLATE pg_catalog."default",
    CONSTRAINT estacion_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.estacion
    OWNER to postgres;
CREATE TABLE public.pasajero
(
    id integer NOT NULL DEFAULT nextval('pasajero_id_seq'::regclass),
    nombre character varying(100) COLLATE pg_catalog."default",
    direccion_residencia character varying COLLATE pg_catalog."default",
    fecha_nacimeinto date,
    CONSTRAINT pasajero_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.pasajero
    OWNER to postgres;
CREATE TABLE public.trayecto
(
    id integer NOT NULL DEFAULT nextval('trayecto_id_seq'::regclass),
    id_tren integer NOT NULL,
    id_estacion integer NOT NULL,
    CONSTRAINT trayecto_pkey PRIMARY KEY (id),
    CONSTRAINT trayecto_id_estacion_fkey FOREIGN KEY (id_estacion)
        REFERENCES public.estacion (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID,
    CONSTRAINT trayecto_id_tren_fkey FOREIGN KEY (id_tren)
        REFERENCES public.tren (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.trayecto
    OWNER to postgres;

-- Table: public.tren

-- DROP TABLE public.tren;

CREATE TABLE public.tren
(
    id integer NOT NULL DEFAULT nextval('tren_id_seq'::regclass),
    modelo character varying(50) COLLATE pg_catalog."default",
    capacidad integer,
    CONSTRAINT tren_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.tren
    OWNER to postgres;

CREATE TABLE public.viaje
(
    id integer NOT NULL DEFAULT nextval('viaje_id_seq'::regclass),
    id_pasajero integer NOT NULL,
    id_trayecto integer NOT NULL,
    inicio date,
    fin date,
    CONSTRAINT viaje_pkey PRIMARY KEY (id),
    CONSTRAINT viaje_id_pasajero_fkey FOREIGN KEY (id_pasajero)
        REFERENCES public.pasajero (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID,
    CONSTRAINT viaje_id_trayecto_fkey FOREIGN KEY (id_trayecto)
        REFERENCES public.trayecto (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.viaje
    OWNER to postgres;

No pude poner en practica esta clase, espero no sea tan fundamental, por ningun sitio me aparecio la opcion de particion al crear una tabla, sea una tabla nueva o vieja no aparece.

Particiones en PostgreSQL


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:

  1. Particiones por rango: En esta estrategia, los datos se dividen en partes basadas en un rango de valores en una columna clave.
  2. Particiones por lista: En esta estrategia, los datos se dividen en partes basadas en una lista espec铆fica de valores en una columna clave.
  3. 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.
  4. 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:

CREATE TABLE public.bitacora_viaje
(
    id serial,
    id_viaje integer,
    fecha date
) PARTITION BY RANGE (fecha);

ALTER TABLE IF EXISTS public.bitacora_viaje
    OWNER to postgres;

Creamos la particion de la tabla bitacora_viaje

CREATE TABLE FECHA_202302 PARTITION OF "FECHA" 
FOR VALUES FROM ('2023-02-01') TO ('2023-02-28');

Para crear al modelo entidad relaci贸n
seleccionan Tables, en el men煤 seleccionan Tool -> new ERD Project.
Si ya tienen las tablas creadas solo las arrastran sino hay un icono que les permite crear las tablas.

Las particiones se usan para optimizar las b煤squedas de la informaci贸n

Las particiones,
Cuando haya mucha informaci贸n en un table.
Dos factores importantes.
Separacion fisica de datos.
Estructura l贸gica

Es bastante interesante el tema de las particiones. Aqu铆 dejo una lectura con informaci贸n b谩sica y clara. Tambi茅n est谩 la documentaci贸n oficial

uisssh. esto esta brutal

A mi me quedo de esta forma 馃槂

CREATE TABLE IF NOT EXISTS public.bitacora_viaje
(
    id serial NOT NULL,
    id_viaje integer NOT NULL,
    fecha date NOT NULL
) PARTITION BY RANGE (fecha);

-- Partitions SQL
CREATE TABLE public.bitacora_viaje201001 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-01-01') TO ('2010-02-01');
	
CREATE TABLE public.bitacora_viaje201002 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-02-01') TO ('2010-03-01');
	
CREATE TABLE public.bitacora_viaje201003 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-03-01') TO ('2010-04-01');
	
CREATE TABLE public.bitacora_viaje201004 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-04-01') TO ('2010-05-01');
	
CREATE TABLE public.bitacora_viaje201005 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-05-01') TO ('2010-06-01');
	
CREATE TABLE public.bitacora_viaje201006 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-06-01') TO ('2010-07-01');
	
CREATE TABLE public.bitacora_viaje201007 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-07-01') TO ('2010-08-01');
	
CREATE TABLE public.bitacora_viaje201008 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-08-01') TO ('2010-09-01');
	
CREATE TABLE public.bitacora_viaje201009 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-09-01') TO ('2010-10-01');
	
CREATE TABLE public.bitacora_viaje201010 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-10-01') TO ('2010-11-01');
	
CREATE TABLE public.bitacora_viaje201011 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-11-01') TO ('2010-12-01');
	
CREATE TABLE public.bitacora_viaje201012 PARTITION OF public.bitacora_viaje
    FOR VALUES FROM ('2010-12-01') TO ('2011-01-01');

Siento que tratando de explicar la partici贸n enred贸 mas la pita poniendo incialmente un script y luego modificarlo. Hace que uno se confunda y al final no se entienda que se est谩 haciendo.

Si les llega a aparecer el error: 鈥淓RROR: unique constraint on partitioned table must include all partitioning columns鈥

En la configuraci贸n realizada en el minuto 3:57, deben dar click el icono de 鈥+鈥 en partitions, agregar como name "bitacora_viaje202001 y dar click a 鈥渄efault鈥 (Esto 煤ltimo no es lo m谩s correcto, pues no les dar谩 el rango que maneja el maestro, pero con eso ya pueden seguir con la clase)

Me encant贸, pude hacer dos particiones con dos meses diferentes;

Al momento de crear la tabla particionada, no hicimos uso de llaves primarias, esto es porque NO es posible crear llaves primarias en tablas particionadas, ya que toda la informaci贸n est谩 dividida. Normalmente, el uso de las tablas particionadas es para guardar informaci贸n en masa, como bit谩cora, y esta informaci贸n debe hacer referencia a las tablas que S脥 tienen las llaves primarias.

Seria bueno como crear el desencadenante para que se vayan actualizando

<create table  passengers(
     id serial  --#un default de autoincrement 
    nombre character varyng(100)   --buenas practicas de manejo de memoria
    direccion_residencia character varying(100)
    fecha_nacimiento date
    constraint pasajero_pkey PRIMARY KEY (id)  --restriccion  llave primaria  tratamos de seguir el defaul _pkeycrea


--PARTICIONAR TABLAS 

    CREATE TABLE public.bitacora_viaje
(
    id serial,
    id_viaje integer,
    fecha date 
) PARTITION BY RANGE (fecha); -- EL RANGO POR EL CUAL VAMOS A DEFINIR LA PARTICION


--#para hacer un insert a la tabla o registrar datos es neseario crear la tabla con el rango especifico

create table bitacora_viaje201001 partition of bitacora_viaje
    for values from ('2010-01-01')to('2010-01-31');> 

Particiones: hace una separaci贸n f铆sica de los datos, pero conserva la misma estructura l贸gica.
O sea: se guardan diferentes partes de la tabla en distintas partes del disco (u otros discos). Lo que hace la partici贸n es definir peque帽as nuevas tablas con un rango definido. Esto ayuda mucho a la performance de las querys

Las particiones tienen muchos m谩s componentes interesantes como subparticionamiento, Mantenimiento De Particiones,practicas recomendas que podemos consultar en la documentaci贸n

No he podido lograr configurar la particion en pgadmin4, por ende no cree tabla con particion. Alguien sabra si es por la version? es 9.5.8

No entend铆 algo donde se hacen las particiones y se crea el rango, en el video el profe coloc贸 FROM (鈥2010-01-01鈥) TO (鈥2019-01-31鈥)

Habia dicho que por a帽o, pens茅 que ser铆a algo como:
FROM (鈥2010-01-01鈥) TO (鈥2010-12-31鈥)

Pero cuando el hace la prueba de una segunda inserci贸n con a帽o 2012, esta arroja error, no se por que?

Como se podria realizar particiones de manera dinamica? Con el metodo visto en el video, seria necesario cada cierto tiempo crear varias particiones para todas las tablas y de esa manera que la data se continue guardando correctamente

Este es un tema muy importante que toma fuerza en entornos productivos transaccionales, ya que los volumenes de datos pueden llegar a ser muy extensos y, por la naturaleza de los mismos, no ser谩 posible llevarlos a un sitio de respaldo.
Yo soy DBA y el motor con el que mas trabajo es Oracle. Ah铆, la opci贸n de particionamiento es una utilidad enterprise (es decir, debes pagar una especie de licenciamiento adicional).
En Oracle, existen particionamientos por rangos (como se vio en la clase en fechas, pero de igual forma puede tratarse de rangos num茅ricos, por ejemplo), por valores (algo as铆 como un tipo de indice de valor espec铆fico) y existe una opci贸n muy interesante que particiona por referencia, es decir, por medio de registros que corresponden a llaves for谩neas.

Habra que revisar las opciones de postgres y, de antemano, saber que se cuenta con la ventaja de que son utilidades de c贸digo abierto, eso esta genial.

Saludos!

Guardar Script
Para poder guardar un script, en la barra superior en el icono guardan y asignan un nombre. Esto se guardar谩 en el servidor, luego no vamos a las pesta帽as

Tools>Storage Manager>Seleccionan el Archivo>Icono de Guardar

Necesito ayuda. En pgAdmin no aparece el tab de partition. Busque en el archivo postgresql.conf y no encontre nada. En la web de pgAdmin solo aparece que desde la versi贸mn 10 en adelante esta opci贸n ser谩 visible. Mi versi贸n es: PostgreSQL 11.6, compiled by Visual C++ build 1914, 64-bit.

No sabia esto de las particiones. Esto va a ayudar a que al hacer consultas en una base de datos, el tiempo de ejecuci贸n quiz谩 no le tome tanto tiempo a que toda la informaci贸n est茅 en una sola tabla

entonces igual se hace la busqueda entre rangos? y cuando encuentra el rango hace la busqueda entre elementos?

Muy interesante.

que interesante el tema de las particiones

Este curso es muy 煤til y me encanta, pero hay muchas cosas que no tienen sentido est茅n desde el comienzo, pues solo confunden

鈥 tabla Estacion
create table Estacion(
id_estacion varchar(20),
nombre_estacion varchar (20),
direccion varchar (20),
primary key (id_estacion)
);

鈥 tabla Tren
create table Tren(
id_tren varchar(20),
modelo_tren varchar (20),
capacidad_tren varchar (20),
primary key (id_tren)
);

鈥 tabla pasajero
create table pasajero(
id_pasajero varchar (20),
nombre_pasajero varchar (20),
direccion_pasajero varchar (20),
primary key (id_pasajero)
);

鈥 tabla Trayecto
create table Trayecto(
id_trayecto varchar (20),
nombre_trayecto varchar (20),
id_estacion varchar (20),
id_tren varchar (20),
constraint fk_Estacion foreign key (id_estacion) references Estacion (id_estacion),
constraint fk_Tren foreign key (id_tren) references Tren (id_tren),
primary key (id_trayecto)
);

鈥 Tabla Viaje
create table Viaje(
id_viaje varchar (20),
inicio_viaje varchar (20),
fin_viaje varchar (20),
id_pasajero varchar (20),
id_trayecto varchar (20),
constraint fk_pasajero foreign key (id_pasajero) references pasajero (id_pasajero),
constraint fk_Trayecto foreign key (id_trayecto) references Trayecto (id_Trayecto),
primary key (id_viaje)
);

insert into Viaje(
id_viaje,inicio_viaje,fin_viaje)
values(鈥1鈥,鈥2023-05-25鈥,鈥2023-05-25鈥)

create table Viaje partition of Viaje
for values from (鈥2023-05-24鈥) to (鈥2023-05-26鈥);

鈥搒elects

select * from Estacion;
select * from Tren;
select * from pasajero;
select * from Trayecto;
select * from Viaje;

en el proyecto simultaneo que realice, me resulto mejor realizar una particion por lista, espero que les ayude mi aporte

-- Crear la tabla lines si a煤n no existe
CREATE TABLE IF NOT EXISTS public.lines
(
    -- Definimos las columnas de la tabla
    id serial NOT NULL, -- ID de la l铆nea
    name character varying(50) NOT NULL, -- Nombre de la l铆nea
    color character varying(30) NOT NULL, -- Color de la l铆nea
    zone character varying(15), -- Zona de la l铆nea
    active boolean NOT NULL DEFAULT TRUE, -- Indica si la l铆nea est谩 activa o no
    create_at timestamp with time zone NOT NULL DEFAULT NOW(), -- Fecha y hora de creaci贸n del registro
    update_at timestamp with time zone DEFAULT NOW(), -- Fecha y hora de la 煤ltima actualizaci贸n del registro
    
    -- Agregamos un constraint de clave primaria en la columna "id"
    CONSTRAINT lines_pkey PRIMARY KEY (id)
) 
-- Particionamos la tabla por listas utilizando la columna "color" como clave de partici贸n
PARTITION BY LIST (color);

-- Cambiamos el propietario de la tabla a "postgres"
ALTER TABLE IF EXISTS public.lines
    OWNER to postgres;

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "rosa" en la columna "color"
CREATE TABLE public.linea_rosa PARTITION OF public.lines
    FOR VALUES IN ('rosa');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "azul" en la columna "color"
CREATE TABLE public.linea_azul PARTITION OF public.lines
    FOR VALUES IN ('azul');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "verde_olivo" en la columna "color"
CREATE TABLE public.linea_verde_olivo PARTITION OF public.lines
    FOR VALUES IN ('verde_olivo');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "cian" en la columna "color"
CREATE TABLE public.linea_cian PARTITION OF public.lines
    FOR VALUES IN ('cian');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "amarillo" en la columna "color"
CREATE TABLE public.linea_amarillo PARTITION OF public.lines
    FOR VALUES IN ('amarillo');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "rojo" en la columna "color"
CREATE TABLE public.linea_rojo PARTITION OF public.lines
    FOR VALUES IN ('rojo');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "naranja" en la columna "color"
CREATE TABLE public.linea_naranja PARTITION OF public.lines
    FOR VALUES IN ('naranja');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "verde" en la columna "color"
CREATE TABLE public.linea_verde PARTITION OF public.lines
    FOR VALUES IN ('verde');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "cafe" en la columna "color"
CREATE TABLE public.linea_cafe PARTITION OF public.lines
    FOR VALUES IN ('cafe');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "morado" en la columna "color"
CREATE TABLE public.linea_morado PARTITION OF public.lines
    FOR VALUES IN ('morado');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "verde_y_gris" en la columna "color"
CREATE TABLE public.linea_verde_y_gris PARTITION OF public.lines
    FOR VALUES IN ('verde_y_gris');

-- Creamos una tabla de partici贸n para almacenar filas con un valor de "oro" en la columna "color"
CREATE TABLE public.linea_oro PARTITION OF public.lines
    FOR VALUES IN ('oro');

-- Agregamos una partici贸n predeterminada para almacenar filas con valores que no coinciden con ninguna de las particiones existentes
CREATE TABLE public.linea_desconocido PARTITION OF public.lines
    FOR VALUES IN (DEFAULT);

Muy buena clase y excelente para comenzar en este mundo SQL

En PostgreSQL, una partici贸n es una t茅cnica que permite dividir una tabla grande en secciones m谩s peque帽as y manejables, llamadas particiones. Cada partici贸n es una tabla independiente con su propio conjunto de datos y definici贸n de esquema, pero todas las particiones juntas forman una sola tabla l贸gica.

Las particiones pueden ser horizontales o verticales. Las particiones horizontales dividen una tabla en varias subtablas en funci贸n de un criterio espec铆fico, como una columna de fecha o un rango de valores. Por otro lado, las particiones verticales dividen una tabla en varias subtablas en funci贸n de las columnas, lo que significa que cada subtabla contiene solo un subconjunto de las columnas de la tabla original.

Particiones

Llegar谩 el momento en que nuestra base de datos sea muy grande y al momento de consultarla la BD tendr谩 que hacer el recorrido de todos los datos para encontrar lo que buscamos.

  • Separaci贸n f铆sica de datos - guardar varias partes de la misma tabla en diferentes espacios de disco, funcionando el mismo select. Podr铆amos crear una partici贸n para un determinado mes, de tal manera que si queremos consultar datos de ese mes, la BD solo recorrer谩 los datos de ese mes y no de todo la tabla
  • Se mantiene la estructura l贸gica.

No hacemos uso de llaves primarias. El uso de las tablas particionaras para guardar informaci贸n hist贸rica de manera de bit谩cora.


create table nombre_particion partition of nombre_de_tabla
fro values from ('aaaa-mm-dd') to ('aaaa-mm-dd')

insert into public.nombre_de_tabla(id_viaje, feha)
values(1,'2010-01-10')

驴Y porque sigue usando ese color rojo de fondo?. Es incomodo. No se ve a donde pertenece cada item

el particionamiento en PostgreSQL es una t茅cnica 煤til para mejorar el rendimiento y la escalabilidad de las tablas grandes. Las particiones pueden ser horizontales o verticales, y se pueden crear utilizando varias estrategias de particionamiento.

Con la version 14 ahora s铆 es posible crear tablas particionadas con PK

hay errores en esta clase 馃槮

PostgreSQL 15.1

CREATE TABLE FECHA_202302 PARTITION OF "FECHA" 
FOR VALUES FROM ('2023-02-01') TO ('2023-02-28');

CREATE TABLE FECHA_202303 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-03-01') TO ('2023-03-31');

CREATE TABLE FECHA_202304 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-04-01') TO ('2023-04-28');

CREATE TABLE FECHA_202305 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-05-01') TO ('2023-05-31');

CREATE TABLE FECHA_202306 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-06-01') TO ('2023-06-30');

CREATE TABLE FECHA_202307 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-07-01') TO ('2023-07-31');

CREATE TABLE FECHA_202308 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-08-01') TO ('2023-08-31');

CREATE TABLE FECHA_202309 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-09-01') TO ('2023-09-29');

CREATE TABLE FECHA_202310 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-10-01') TO ('2023-10-31');

CREATE TABLE FECHA_202311 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-11-01') TO ('2023-11-30');

CREATE TABLE FECHA_202312 PARTITION OF "FECHA"
FOR VALUES FROM ('2023-12-01') TO ('2023-12-29');

Creamos la tabla donde va las segmentaciones.

CREATE TABLE public.bitacora_viaje
(
    id serial,
    id_viaje integer,
    fecha date
) PARTITION BY RANGE (fecha);

ALTER TABLE IF EXISTS public.bitacora_viaje
    OWNER to postgres;

Creamos la particion de la tabla bitacora_viaje

CREATE TABLE bitacora_viaje_2010_enero PARTITION OF "bitacora_viaje"
FOR VALUES FROM ('2010-01-01') TO ('2010-02-01');

CREATE TABLE bitacora_viaje_2010_febrero PARTITION OF "bitacora_viaje"
FOR VALUES FROM ('2010-02-01') TO ('2010-03-01');

INSERT INTO public.bitacora_viaje(
	id_viaje, fecha)
	VALUES (1, '2010-01-31');

INSERT INTO public.bitacora_viaje(
	id_viaje, fecha)
	VALUES (2, '2010-02-28');
	
SELECT * FROM bitacora_viaje_2010_enero;	
SELECT * FROM bitacora_viaje_2010_febrero;
SELECT * FROM bitacora_viaje;

hice dos segmentaciones, para que tome el ultimo dia del mes del rango tomo el primer dia del mes siguiente.
En la consulta bitacora_viaje me sale las dos segmentaciones.

como que la clase relacionada no tiene nada que ver o.o acabo de descubrir Svelte jejeje.

Aqui comparto el c贸digo de la tabla bitacora_viaje

INSERT INTO public.bitacora_viaje(
id_viaje, fecha)
VALUES (1,鈥2010-01-10鈥);

select * from bitacora_viaje;

create table bitacora_viaje201001 partition of bitacora_viaje
for values from (鈥2010-01-01鈥) to (鈥2019-01-31鈥);

Separaci贸n F铆sica de Datos

Significa guardar varias partes de la misma tabla en diferentes espacios de disco duro, e incluso en otros discos.

Conserva Estructura L贸gica

Significa que puede acceder a esas particiones de tablas con el mismo comando SELECT de siempre.

  • Internamente lo que hace es que con el mismo nombre de la tabla asigna otras peque帽as tablas que tienen un rango definido.
  • Un rango definido pueden ser las 鈥淔echas鈥 u 鈥淗oras鈥.
    Ejemplo:
    Una partici贸n para el mes de Julio del presente a帽o, otra partici贸n para el mes de Agosto y as铆 sucesivamente.

**### Particiones
**
Las particiones es hacer una separacion fisica (En diferentes espacios del disco duro) de los datos pero manteniendo las misma estructura logica.

Ej: Si nuestros datos estan por fecha y son muchos, uan particion hara que los divida los datos en tablas m谩s peque帽as y la divida por mes, y si buscas una fecha no lo hara en toda la base de datos, si no solo en la fecha asignada.

Creaci贸n de partici贸n

No es posible crear llaver primarias "Primary key" en tablas particionadas

No se puede hacer un script de insert cuando la particion esta vacia

Si est谩n atorados por el error del inicio, solo ejecuten primero la secuencia CREATE PARTITION 鈥 primero y luego la secuencia INSERT INTO鈥

Para la versi贸n 10.5 de Postgres, si deja insertar tantos meses en la misma tabla y en la misma partici贸n.

Resumen de la clase usando la consola:
Se crea la tabla:

transporte_tren=# CREATE TABLE bitacora_viaje(
transporte_tren(# id serial,
transporte_tren(# id_viaje integer,
transporte_tren(# fecha date)
transporte_tren-# PARTITION BY RANGE (fecha);

Se crea ahora la partici贸n:

transporte_tren=# CREATE TABLE bitacora_viaje_201001 PARTITION OF bitacora_viaje
transporte_tren-# FOR VALUES FROM ('2010-01-01') TO ('2019-01-31');

Se inserta valores:

transporte_tren=# INSERT INTO bitacora_viaje(
transporte_tren(# id_viaje, fecha)
transporte_tren-# VALUES (1, '2010-01-10');

Se lee valores:

transporte_tren=# SELECT * FROM bitacora_viaje;
 id | id_viaje |   fecha
----+----------+------------
  2 |        1 | 2010-01-10
(1 fila)

Las particiones son importantes a la hora de hacer una consulta y las tablas poseen grandes cantidades de informacion

鈥淧articionar es el proceso donde tablas muy grandes son divididas en m煤ltiples partes m谩s peque帽as. Al separar una tabla grande en tablas individuales m谩s peque帽as, las consultas que acceden s贸lo a una fracci贸n de los datos pueden correr m谩s r谩pido porque hay menos datos que escanear.鈥

-sqlshack

me parece que el instructor va muy rapido, y cambia las cosas sin explicar, 0 puntos para este video

驴Qu茅 son las particiones?

驴Por qu茅 las tablas con particiones no tienen llaves primarias?

Rango de las particiones

驴Qu茅 haremos est谩 clase?

No es posible crear llaves primarias en tablas particionadas, ya que la info est谩 toda dividida.

Entendi el concepto de la tabla particionada, pero me gustaria ver un caso de uso en un ambiente 鈥渞eal鈥, espero mas adelante en el curso este ese tema

No se me habia ocurrido lo de las particiones, claro que puede mejorar el rendimiento de las busquedas

Excelente Oswaldo explicando!

Las particiones hacen una separaci贸n f铆sica de datos pero conservan la misma estructura l贸gica.
Separaci贸n f铆sica de datos significa que es posible guardar varias partes de la misma tabla en diferentes espacio de disco e incluso en otros discos.
La misma estructura l贸gica significa que la consulta SQL no cambia. Va a ser la misma sea o no una tabla particionada.
Internamente separa la tabla en peque帽as tablas que tienen un rango definido de alguna columna. Por ejemplo si decidimos particionar por el tiempo: podemos particionar la tabla por mes. Es decir cada partici贸n corresponder谩 a un mes.
Cuando se ejecuta el SELECT de la tabla particionada directamente va a buscar a la partici贸n que corresponde al rango de el mes consultado.
Ventajas:

  • Se evita recorrer una sola tabla con toda la informaci贸n, lo cual acelera enormemente las consultas
  • evita que la tabla se pueda bloquear porque est谩 siendo muy consultada y modificada al mismo tiempo.
    Procedimiento: creamos una tabla y la configuramos como particionada. Adem谩s indicamos cu谩l va a ser la columna donde armaremos los rangos para armar las particiones. Posteriormente generamos las distintas particiones definiendo para cada caso el rango y la referencia a la tabla particionada.
    Si hacemos una consulta SQL a una tabla particionada para una partici贸n que no existe nos tira error.
    Al momento de crear la tabla particionada no hacemos usos de llaves primarias. No es posible crear llaves primarias en tablas particionadas ya que la informaci贸n est谩 toda dividida. Las tablas que s铆 tienen las llaves primarias son las particiones (las tablas referidas.)

Muy bueno para reafirmar conceptos de SQL

Listo!

Comparto mis apuntes hasta esta clase PostgreSQL apuntes Espero sea de utilidad 馃槈

muy bueno de un video con una sola tabla 鈥 al siguiente con tener todas las tablas relacionadas 鈥 jajaja esto es muy art atack che 鈥

Este tipo de tablas se podr铆a usar para almacenar logs.

puedes quitarle el color rojo no deja visualizar bien

Para los que usan MYSQL, tambien se puede hacer aqui les dejo el link: https://dev.mysql.com/doc/refman/5.7/en/partitioning-types.html

No es posible crear llaves primarias en tablas particionadas esto debido a que la informaci贸n se encuentra dividida.

La segunda vez que corre el Script para otra fecha no selecciona la parte del INSERT y el error que se muestra es porque esta tratando de ingresar de nuevo todo, incluso la partici贸n. Recomiendo poner desde el inicio el rango de 鈥2010-01-01鈥 hasta el 鈥2010-02-01鈥. Este rango solo cubrir谩 el mes de enero ya que excluir谩 el primer d铆a de febrero.

Tengo una consulta. 驴Qu茅 semejanzas existen entre las tablas particionadas y las tablas temporales?

me daba error, al aprecer ejecuta todo el codigo como insert esta primero da error y no crea la tabla, lo unico que hice fue hacer los codigos por separado, osea primero hice la parte de CRCEATE ejecute luego puse la parte de INSERT

Comenzando

INSERT INTO public.trip_binnacle(id_trip, created_at) VALUES (1,鈥2010-01-15鈥);

SELECT * FROM trip_binnacle;

CREATE TABLE trip_binnacle_2010_01 PARTITION OF trip_binnacle
FOR VALUES FROM (鈥2010-01-01鈥) TO (鈥2010-01-31鈥);

Excelente ejemplo

Creaci贸n de una partici贸n con pgAdmin

Wow, qu茅 buena explicaci贸n. Hab铆a utilizado postgres por muchos a帽os sin entrar a los detalles, es genial lo que estoy aprendiendo en este curso. Gracias!

Hubo un peque帽o error. Al crear la partici贸n la crea de enero del 2010 a final de enero del 2019

Buenas tardes, queria consultarles porque no me aparece la solapa partition cuando intento crear la tabla. es una tabla nueva pero no me aparece

Se puede indexar las particiones鈥

create table bitacora_viaje_20100102 partition of bitacora_viaje
for
values
from (鈥2018-01-01鈥) to (鈥2018-01-30鈥);

create index bt_0102 on bitacora_viaje_20100102 (id_viaje);

las particiones en Postgres son como a MySQL las Vistas?