Creación y Gestión de Tablas en Bases de Datos con PGAdmin

Resumen

¿Cómo administrar tablas en una base de datos?

Las tablas son la pieza fundamental en cualquier base de datos, ya que contienen tanto la estructura como la información que deseamos almacenar. Entender cómo crear, modificar y borrar tablas es esencial para cualquier profesional que trabaje con bases de datos. En esta sección, exploraremos cómo manipular efectivamente las tablas utilizando comandos útiles como CREATE, ALTER y DROP.

¿Qué comandos básicos se utilizan para manejar tablas?

CREATE TABLE: Inicializa la estructura de una nueva tabla sin datos.
ALTER TABLE: Modifica una tabla existente, permitiéndote agregar o eliminar columnas, cambiar índices, o incluso establecer llaves primarias.
DROP TABLE: Borra una tabla junto con toda su información.

Veamos un ejemplo práctico de cómo comenzar con estas acciones.

¿Cómo crear y gestionar una base de datos desde cero?

Para comenzar a desarrollar nuestra base de datos, primero debemos activarla y configurarla:

Conéctate a la base de datos que deseas usar. Ten en cuenta que, por defecto, solo existe una base preconfigurada llamada postgres.
Crea una nueva base de datos desde el administrador gráfico PGAdmin. Haz clic derecho en Databases, selecciona Create y completa el formulario, poniendo especial atención al nombre.

A continuación, un ejemplo básico para crear una base de datos llamada transporte:

CREATE DATABASE transporte;

¿Cómo crear una tabla utilizando PGAdmin?

Ahora que tenemos nuestra base de datos, podemos crear una tabla:

Haz clic derecho en Tables y selecciona Create Table.
Completa el formulario que aparece, seleccionando el nombre de la tabla, los propietarios y agregando columnas.

Ejemplo de la creación de una tabla pasajero:

CREATE TABLE pasajero (
    id SERIAL PRIMARY KEY,
    nombre VARCHAR(100),
    direccion VARCHAR(255),
    fecha_nacimiento DATE
);

¿Cómo definir columnas de manera eficiente?

Cuando definas las columnas, considera el tipo de datos y la longitud adecuada para optimizar el uso de memoria. Por ejemplo:

ID: Un campo SERIAL que actúa como llave primaria.
Nombre: Un campo VARCHAR con una longitud máxima definida.
Dirección: Otro campo VARCHAR para almacenar direcciones.
Fecha de nacimiento: Utiliza el tipo de datos DATE.

¿Cómo insertar datos en una tabla?

La inserción de datos se puede automatizar usando scripts generados por PGAdmin:

INSERT INTO pasajero (nombre, direccion, fecha_nacimiento) VALUES 
('Juan Pérez', 'Dirección X', '2000-01-01');

Si deseas saber el formato exacto que utiliza tu sistema para fechas, puedes hacer una consulta rápida:

SELECT CURRENT_DATE;

¿Qué herramienta facilita la gestión de bases de datos?

PGAdmin es una solución gráfica que facilita significativamente la administración de bases de datos PostgreSQL, permitiendo automatizar consultas y visualización de comandos SQL ejecutados:

La pestaña SQL en PGAdmin muestra los comandos generados equivalentes a las acciones realizadas gráficamente.

Te animo a explorar las capacidades de PGAdmin para crear y manejar tablas adicionales, y a compartir tus experiencias.

Revisar y entender estas herramientas y comandos es fundamental para manejar bases de datos de manera efectiva. Con práctica y paciencia, cualquiera puede convertirse en un experto en la gestión de datos. ¡Sigue aprendiendo y construyendo tus habilidades!

John J. Meza

student•

PILAS.

Solo deben crear las columnas y PRIMARY KEYS. Más adelante en el curso les enseñan como insertar las FOREIGN KEYS.

Les va a ahorrar mucho tiempo.

Oscar Julian Layton Galindo

student•

Gracias por el aporte, ya estaba pensando en esto.

Andrea Maria Clavero Parra

student•

Gracias!!! se me complico con las fkey ya que no esta explicado en este video.-

Marco Antonio González Arellano

student•

Hice las tablas con pgadmin y también con sentencias SQL, aunque es claro de forma gráfica me gusta también comprender lo que pasa detrás y practicarlo.

CREATE TABLE pasajero(
	id serial,
	nombre character varying(100),
	direccion_residencia character varying,
	fecha_nacimiento date,
	CONSTRAINT pasajero_pkey PRIMARY KEY (id)
)
CREATE TABLE tren(
	id serial,
	modelo character varying(30),
	capacidad integer,
	CONSTRAINT tren_pkey PRIMARY KEY (id)
)
CREATE TABLE estacion(
	id serial,
	nombre character varying(30),
	direccion character varying(100),
	CONSTRAINT estacion_pkey PRIMARY KEY (id)
)
CREATE TABLE trayecto(
	id serial,
	id_tren integer,
	id_estacion integer,
	CONSTRAINT trayecto_pkey PRIMARY KEY (id),
	FOREIGN KEY (id_tren) REFERENCES estacion(id),
	FOREIGN KEY (id_estacion) REFERENCES tren(id)
)
CREATE TABLE viaje(
	id serial,
	id_pasajero integer,
	id_trayecto integer,
	inicio date,
	fin date,
	CONSTRAINT viaje_pkey PRIMARY KEY (id),
	FOREIGN KEY (id_pasajero) REFERENCES pasajero (id),
	FOREIGN KEY (id_trayecto) REFERENCES trayecto (id)
)

Andoni Alonso Tort

student•

Creo que te equivocaste en tu referencia en las llaves foráneas, id_tren debería estar referenciando a tren(id) y tienes ambas al revés

Marco Antonio González Arellano

student•

Cierto, muchas gracias. Debido a esto tenía problemas en las clases posteriores, y tuve que regresar a estas clases y hacer de nuevo la estructura de la BD. Afortunadamente se arregló y ya pude terminar el curso con éxito. Muchas gracias de nuevo!

Leandro Cosme Tomassini

student•

Modo OSCURO PGADMIN: Ir a File / Preferences / Themes / y elegir el tema Dark.

Mariana Ramirez

student•

¡Gracias por esto! ¡Me estaban sangrando los ojos!

Santiago Garcia Rojas

student•

Buenísimo este aporte

Carlos Delgado

student•

les dejo un código para crear el resto de las tablas:

create table public.estacion (
	id serial not null,
	nombre varchar not null,
	direccion varchar not null,
);

CREATE TABLE public.tren (
	id serial not NULL,
	modelo varchar NULL,
	capacidad int null,
	constraint tren_pk primary key (id)
);

CREATE TABLE public.trayecto (
	id serial not NULL,
	id_estacion integer not NULL,
	id_tren integer not null,
	name varchar null,
	constraint trayecto_pk primary key (id),
	constraint estacion_fk foreign key (id_estacion) references public.estacion,
	constraint tren_fk foreign key (id_tren) references public.tren
);

create table public.viaje (
	id serial not null,
	id_pasajero integer not null,
	id_trayecto integer not null,
	inicio time null,
	fin time null,
	constraint viaje_pk primary key (id),
	constraint pasajero_fk foreign key (id_pasajero) references public.pasajero,
	constraint trayecto_fk foreign key (id_trayecto) references public.trayecto
);

Mateo Posada

student•

muy bien

Miguel Torres

student•

Yo he hecho las tablas así hasta ahora. Me parece aún le faltan CONSTRAINTS porque los id de las relaciones externas de la tabla no están relacionadas.

--PASAJEROS


CREATE TABLE public.pasajeros
(
    id integer NOT NULL DEFAULT nextval('pasajeros_id_seq'::regclass),
    nombre character varying COLLATE pg_catalog.&quot;default&quot;,
    direccion_residencia character varying COLLATE pg_catalog.&quot;default&quot;,
    fecha_nacimiento date,
    CONSTRAINT pasajeros_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

ALTER TABLE public.pasajeros
    OWNER to postgres;


--ESTACIONES

CREATE TABLE public.estaciones
(
    id serial NOT NULL,
    nombre character varying(50) NOT NULL,
    direccion character varying(50),
    CONSTRAINT estaciones_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.estaciones
    OWNER to postgres;


--TRENES

CREATE TABLE public.trenes
(
    id serial NOT NULL,
    modelo character varying(50) NOT NULL,
    capacidad integer,
    CONSTRAINT trenes_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.trenes
    OWNER to postgres;


--TRAYECTOS

CREATE TABLE public.trayectos
(
    id serial NOT NULL,
    nombre character varying(50);
    id_estacion integer,
    id_tren integer,
    CONSTRAINT trayectos_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.trayectos
    OWNER to postgres;

--VIAJES

CREATE TABLE public.viajes
(
    id serial NOT NULL,
    id_pasajero integer,
    id_trayecto integer,
    inicio timestamp without time zone NOT NULL,
    fin timestamp without time zone NOT NULL,
    CONSTRAINT viajes_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.viajes
    OWNER to postgres;

Jerson Mosquera Pretelt

student•

Excelente, yo las hice utilizando solamente la consola!! Ejemplo:

transporte_tren=# CREATE TABLE trayectos(
transporte_tren(# id_trayecto serial,
transporte_tren(# id_tren integer,
transporte_tren(# id_estacion integer,
transporte_tren(# nombre_est character varying(50),
transporte_tren(# CONSTRAINT trayectos_pkey PRIMARY KEY(id_trayecto),
transporte_tren(# CONSTRAINT tren_fk FOREIGN KEY(id_tren) REFERENCES trenes(id_tren),
transporte_tren(# CONSTRAINT estacion_fk FOREIGN KEY(id_estacion) REFERENCES estaciones(id_estacion));

Jesús David Barraza Guzmán

student•

A mi me sale este error, me podrían decir que puse mal? ERROR: no existe el esquema «pasajeros» LINE 6: id integer NOT NULL DEFAULT nextval('pasajeros."pasajero...

Angel de Jesus Quintero Pereira

student•

Respuesta a que significa ¿WITH (OIDS = FALSE)? Básicamente es un indentificador de obajetos, esto sirve para identificar tuplas de manera única cuando estas son similares. https://stackoverflow.com/questions/5625585/sql-postgres-oids-what-are-they-and-why-are-they-useful

Christian Rangel

student•

Excelente gracias por aclarar mi duda

Juan Pablo Reina Gutierrez

student•

Este es el código con el que cree la base de datos y también está el arbol de las tablas

Jose Colmenares

student•

Igual al mio!

Jhon Mario Ochoa Lemus

student•

Dando el salto de fe de un estudiante que comento que por ahora no ingresemos las FK. Dejo mi código:

CREATE TABLE public.pasajero
(
    id serial,
    nombre character varying(100),
    direccion_residencia character varying,
    fecha_nacimiento date,
    CONSTRAINT pasajero_pkey PRIMARY KEY (id)
) WITH (OIDS = FALSE);

ALTER TABLE public.pasajero OWNER to postgres;
---------
CREATE TABLE public.tren
(
    id serial,
    modelo character varying,
    capacidad integer,
    CONSTRAINT tren_pkey PRIMARY KEY (id)
) WITH (OIDS = FALSE);

ALTER TABLE public.tren OWNER to postgres;
---------
CREATE TABLE public.estacion
(
    id serial,
    nombre character varying,
    direcion integer,
    CONSTRAINT estacion_pkey PRIMARY KEY (id)
) WITH (OIDS = FALSE);

ALTER TABLE public.estacion OWNER to postgres;
---------
CREATE TABLE public.trayecto
(
    id serial,
    id_tren integer,
    id_estacion integer,
    CONSTRAINT trayecto_pkey PRIMARY KEY (id)
) WITH (OIDS = FALSE);

ALTER TABLE public.trayecto OWNER to postgres;
---------
CREATE TABLE public.viaje
(
    id serial,
    id_pasajero integer,
    id_trayecto integer,
    inicio timestamp without time zone,
    fin timestamp without time zone,
    CONSTRAINT viaje_pkey PRIMARY KEY (id)
) WITH (OIDS = FALSE);

ALTER TABLE public.viaje OWNER to postgres;

Angel de Jesus Quintero Pereira

student•

El tipo de dato SERIAL en postgres es equivalente al AUTO_INCREMENT en MySQL

Jeisson Espinosa

student•

Información resumida de esta clase #EstudiantesDePlatzi

En las tablas encontramos la información y estructura de nuestra base de datos
Las acciones que podemos hacer dentro de una tabla son: Crear, modificar y borrar
El texto alfanumérico es más conocido como Character_varying
Cuando sabemos la longitud de caracteres que tiene nuestro dato podemos indicarlo para optimizar el espacio de memoria
Pkey = Primary key

Jessica Andrea Aquino Torrez

student•

Mi script para crear las otras tablas es el siguiente:

CREATE TABLE public.pasajeros
(
    id serial,
    nombre character varying(100),
    direccion_residencia character varying,
    fecha_nacimiento date,
    CONSTRAINT pasajero_pkey PRIMARY KEY (id)
);

CREATE TABLE public.estaciones
(
	id serial,
	nombre character varying(100),
	direccion character varying,

	CONSTRAINT estacion_pkey PRIMARY KEY(id)
);

CREATE TABLE public.trenes
(
	id serial,
	modelo character varying(100),
	capacidad integer,

	CONSTRAINT tren_pkey PRIMARY KEY(id)
);

CREATE TABLE public.trayectos
(
	id serial,
	id_tren integer,
	id_estacion integer,

	CONSTRAINT trayecto_pkey PRIMARY KEY(id),
	CONSTRAINT trayecto_trenes_fkey FOREIGN KEY(id_tren) REFERENCES public.trenes(id),
	CONSTRAINT trayecto_estaciones_fkey FOREIGN KEY(id_estacion) REFERENCES public.estaciones(id)
);

CREATE TABLE public.viajes
(
	id serial,
	id_pasajero integer,
	id_trayecto integer,
	inicio date,
	fin date,

	CONSTRAINT viaje_pkey PRIMARY KEY(id),
	CONSTRAINT viaje_pasajero_fkey FOREIGN KEY(id_pasajero) REFERENCES public.pasajeros(id),
	CONSTRAINT viaje_trayecto_fkey FOREIGN KEY(id_trayecto) REFERENCES public.trayectos(id)
);


ALTER TABLE IF EXISTS public.pasajeros
    OWNER to postgres;

ALTER TABLE IF EXISTS public.estaciones
    OWNER to postgres;

ALTER TABLE IF EXISTS public.trenes
    OWNER to postgres;

ALTER TABLE IF EXISTS public.trayectos
    OWNER to postgres;

ALTER TABLE IF EXISTS public.viajes
    OWNER to postgres;

Isay Humberto Lucas Hernandez

student•

Me parece muy interesante que postgres permita insertar fechas con solamente introducir el valor tipo "YYYY-MM-DD". En otros motores de base de datos es necesario especificar una función con su respectivo valor y máscara.

Por ejemplo: TO_DATE('1991-05-25','YYYY-MM-DD')

Verónica Rodríguez

student•

Para la primary key no deberia activar tambien el not null?

Cristopher Rojas Salas

student•

Por orden, se puede activar el indicador, pero para PGADMIN si se indica que es un Primary Key se añade la restricción de NOT NULL internamente, lo puedes confirmar haciendo la prueba y en la pestaña SQL de la tabla despues de creada puedes ver la indicación NOT NULL.

Martín Alejandro Vera

student•

Si. de hecho lo hace automaticamente pgadmin, un pk siempre es not null, buena observación, ya que creo devería aclrarlo el profesor al hacerlo

Andoni Alonso Tort

student•

Falto explicar cómo se puede crear una llave foránea en pgAdmin para poder realizar las relaciones desde ahí :c

Mario David Herrera Vásquez

student•

yo lo hice de esta forma y me funciono

nombre de la tabla
agregamos los atributos a nuestra tabla

3.agregamos nuestra llave primaria

agregamos nuestras llaves foraneas para estacion y tren

en codigo sql quedaria asi
como ultimo paso para corroborar que la tabla este bien relacionada es insertar datos en la tabla estación, y tren, y luego insertamos datos en la tabla trayecto, por ejemplo, lo hice de esta forma:
insertar datos estacion
insertar datos tren
3.insertar datos trayecto
despues de haber insertado datos en nuestras 3 tablas corroboramos que los datos insertados en la tabla trayecto devuelvan los datos correctos que hayamos insertado, entonces realizamos una consulta para corroborar que los datos sean los correctos y ahi comprobaremos que nuestra relación fue realizada con exito
y si devuelve lo datos correctos entonces nuestra relacion si esta bien hecha

Carlos Augusto Sánchez Seminario

student•

Gracías, capo!

Juan Andres Quiroz Franco

student•

Mmm, no sé si me estoy enredando más de lo que debería, pero si la cardinalidad de viaje y trayecto es N a N, entonces se debería tener una tabla intermedia para manejar las relaciones entre estas, por eso hice mi estructura de esta forma:

Edgar Contreras

student•

Compañer@s, les comparto el código de pgAdmin para la creación de mis tablas:

-- Creating the database
CREATE DATABASE transporte
    WITH
    OWNER = postgres
    ENCODING = 'UTF8'
    CONNECTION LIMIT = -1
    IS_TEMPLATE = False;

-- CREATION OF TABLES
-- Table 'pasajeros'
CREATE TABLE public.passengers
(
    id serial,
    name character varying(60),
    address character varying(60),
    birth_date date,
    CONSTRAINT passengers_pkey PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.passengers
    OWNER to postgres;

-- Table 'trains'
CREATE TABLE public.trains
(
    id serial,
    model character varying(60),
    capacity integer,
    CONSTRAINT trains_pkey PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.trains
    OWNER to postgres;

-- Table 'stations'
CREATE TABLE public.stations
(
    id serial,
    name character varying(60),
    address character varying(80),
    CONSTRAINT stations_pkey PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.stations
    OWNER to postgres;

-- Table 'travels'
CREATE TABLE public.travels
(
    id serial,
    start_station character varying(60) NOT NULL,
    end_station character varying(60) NOT NULL,
    passenger_id integer,
    CONSTRAINT travel_pkey PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.travels
    OWNER to postgres;

-- Table 'routes'
CREATE TABLE public.routes
(
    id serial,
    name character varying(60) NOT NULL,
    CONSTRAINT routes_pkey PRIMARY KEY (id)
);

ALTER TABLE IF EXISTS public.routes
    OWNER to postgres;

Hasta el momento no he agregado las FK.

luis felipe castro calderón

student•

Pregunta: ¿Cuál es la diferencia entre los datos que son por ejemplo date y los que son date[]?

Tiene que ver algo con listas

Sergio Alejandro Trejo Cuxim

student•

Desde PostgreSQL 10 + es recomendado utilizar IDENTITY En lugar de serial, te anexo el ejemplo:

CREATE TABLE color (
    color_id INT GENERATED ALWAYS AS IDENTITY,
    color_name VARCHAR NOT NULL
);

La nueva sintaxis IDENTITY se ajusta al estándar SQL. Crear columnas de incremento automático ha sido un área notoria de incompatibilidad entre diferentes implementaciones de SQL. Sin embargo, algunos han estado adoptando últimamente la sintaxis SQL estándar. Entonces, ahora puede mover el código entre, por ejemplo, PostgreSQL, DB2 y Oracle sin ningún cambio (en esta área) gracias a Identity

La razón completa: https://wiki.postgresql.org/wiki/Don't_Do_This#Don.27t_use_serial Como usar Identity: https://www.postgresqltutorial.com/postgresql-identity-column/

Jeinfferson Bernal G

student•

Las tablas son elementos que contiene la informacion y estructura de la BD. Las acciones que se pueden realizar sobre ellas son muy sencillas:

CREATE: sirve para inicializar la estructura de la tabla sin ningun tipo de datos.
ALTER: sirve para hacer modificaciones sobre la tabla: cambiar indices, agregar o eliminar columnas, agregar llaves primarias…
DROP: Permite borrar la tabla con toda su informacion.

David Jonatan Mora Bejarano

student•

se puede usar powerdesigner para hacer el diagrama y la misma herramienta nos permite generar los scripts para crear la base de datos, eso he hecho en ocasiones con otros motores, hice una prueba a Postgresql, si funciono.