Particiones

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);

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');

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.

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.

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');

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');

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');

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.

En que casos es recomendado usar el particionamiento de tablas?

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)

Veo mucho inconformismo con este curso y la verda que siento lo mismo. No veo pedagogia, los ejemplos se desarrollan con errores y esto crea una conceptualización errada.

Definitivamente este es un curso que debe si o si ser actualizado y reasignado a otro profesional.

PgAdmin 4 DarkMode

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.

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

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.

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

Creo que esta clase no era necesaria en este punto, tal vez mas adelante, pero ponerla en este punto siento que solo metio complejidad innecesaria

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');

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.

Creación de Tablas

Basandonos en la estructura Diagrama:

Diagrama en OneNote

hay que crear

ESTACION

CREATE TABLE public.estacion
(
    id serial,
    nombre character varying,
    direccion character varying,
    PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.estacion
    OWNER to postgres;

TREN

CREATE TABLE public.tren
(
    id serial,
    modelo character varying[],
    capacidad integer,
    PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.tren
    OWNER to postgres;

TRAYECTO

no estoy seguro como es el asunto de las llaves foraneas id_…

CREATE TABLE public.trayecto
(
    id_estacion serial,
    id_tren serial,
    nombre character varying
);

ALTER TABLE IF EXISTS public.trayecto
    OWNER to postgres;

VIAJE

CREATE TABLE public.viaje
(
    id serial,
    id_pasajero serial,
    id_trayecto serial,
    inicio time with time zone,
    fin time with time zone,
    PRIMARY KEY (id_pasajero)
);

ALTER TABLE IF EXISTS public.viaje
    OWNER to postgres;

Ando aprendiendo PostgreSQL y me esta gustando mucho estoy entendiendo, excelente profesor amo las consolas y su interfaz una nota

Por una parte postgreSQL se ve facil pero como que el profesor no es el adecuado, cada dia me pierdo mas 😪😪

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 “Fechas” u “Horas”.
  Ejemplo: Una partición para el mes de Julio del presente año, otra partición para el mes de Agosto y así sucesivamente.

Si les llega a aparecer el error: “ERROR: 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 “default” (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

esto es un super dato

Las particiones en PostgreSQL son una característica que te permite dividir físicamente una tabla en múltiples segmentos más pequeños llamados particiones. Cada partición puede almacenar un conjunto específico de datos según un criterio definido, como un rango de valores. Esto puede mejorar el rendimiento y facilitar la gestión de grandes conjuntos de datos

Adjunto aporte sobre las particiones creadas.

– 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’);

–selects

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’);

**### 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

“Particionar 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 “real”, 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 😉