Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de PostgreSQL

Curso de PostgreSQL

Oswaldo Rodríguez González

Oswaldo Rodríguez González

Creación de Tablas

12/32
Recursos

Aportes 120

Preguntas 17

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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.

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

Comparto a la comunidad mis notas de este curso en un repositorio, espero les sean de mucha utilidad, recuerden hacer buen uso

https://github.com/rb-one/Curso_PostgreSQL/blob/master/Notes/notes.md

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

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

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."default",
    direccion_residencia character varying COLLATE pg_catalog."default",
    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;






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

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

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

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;

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

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:

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.

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/

Hola ingreso los vales en la inserción de datos pero me arroja este error

INSERT INTO public.“Pasajeros”(
“NOMBRE”, “DIRECCIÒN_RESIDENCIA”, “FECHA NACIMIENENTO”)
VALUES (‘Primer_Pasajero’,‘Direccion x’ , ’ ’ );

SELECT current_date;

ERROR: no existe la columna «FECHA_NACIMIENENTO» en la relación «Pasajeros»
LINE 2: “NOMBRE”, “DIRECCIÒN_RESIDENCIA”, “FECHA_NACIMIENENTO”)
^
SQL state: 42703
Character: 69

Por aqui dejo el modelo ER de mi solución.

Hola, aqui el capture de la creación de mis tablas, con consultas desde la terminal… Debo hacerles unas modificaciones en la estructura, lo haré más adelante.

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

Si alguien tiene duda que significa el OIDS = false es por lo siguiente:

Los OID básicamente le otorgan una identificación única global incorporada para cada fila, contenida en una columna del sistema (a diferencia de una columna de espacio de usuario). Es útil para las tablas en las que no tiene una clave principal, tiene filas duplicadas, etc. Por ejemplo, si tiene una tabla con dos filas idénticas y desea eliminar la más antigua de las dos, puede hacerlo utilizando el columna oid.

Listo. Se creo la base transporte y la tabla pasajero.

-- Database: transporte

-- DROP DATABASE transporte;

CREATE DATABASE transporte
    WITH 
    OWNER = postgres
    ENCODING = 'UTF8'
    LC_COLLATE = 'Spanish_Venezuela.1252'
    LC_CTYPE = 'Spanish_Venezuela.1252'
    TABLESPACE = pg_default
    CONNECTION LIMIT = -1;

COMMENT ON DATABASE transporte
    IS 'Base de dato que se encarga de manejar la el funcionamiento de transporte entre estaciones de trenes.';

--Creación de tabla pasajero
CREATE TABLE public.pasajero
(
    id                      serial NOT NULL,
    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;



--
--Creación de tabla tren
--
CREATE TABLE public.tren
(
    id serial NOT NULL,
    modelo character varying(50),
    capacidad integer,
    CONSTRAINT tren_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.tren
    OWNER to postgres;
COMMENT ON TABLE public.tren
    IS 'Registra los datos de tren, esta tabla guarda el modelo y capacidad del tren';


--
--Creación de tabla estacion
--
CREATE TABLE public.estacion
(
    id serial NOT NULL,
    nombre character varying(100),
    direccion character varying,
    CONSTRAINT estacion_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.estacion
    OWNER to postgres;
COMMENT ON TABLE public.estacion
    IS 'Esta tabla registra la información de la estación como: su identificador, nombre, dirección';


--
-- Creación de la tabla trayecto
--
CREATE TABLE public.trayecto
(
    id serial NOT NULL,
    id_tren integer,
    id_estacion integer,
    CONSTRAINT trayecto PRIMARY KEY (id_tren),
    CONSTRAINT trayecto_tren_fkey FOREIGN KEY (id_tren)
        REFERENCES public.tren (id) MATCH SIMPLE
        ON UPDATE CASCADE
        ON DELETE CASCADE
        NOT VALID,
    CONSTRAINT trayecto_estacion_fkey FOREIGN KEY (id_estacion)
        REFERENCES public.estacion (id) MATCH SIMPLE
        ON UPDATE CASCADE
        ON DELETE CASCADE
        NOT VALID
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.trayecto
    OWNER to postgres;
COMMENT ON TABLE public.trayecto
    IS 'Registra los trayectos que pueden hacer los trenes entre estaciones';

COMMENT ON CONSTRAINT trayecto_tren_fkey ON public.trayecto
    IS 'Referencia al  ID de la tabla tren';
COMMENT ON CONSTRAINT trayecto_estacion_fkey ON public.trayecto
    IS 'Referencia al ID de la tabla  estacion';


--
--Creación de la tabla  viaje
--

CREATE TABLE public.viaje
(
    id serial NOT NULL,
    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.pasajero (id) MATCH SIMPLE
        ON UPDATE CASCADE
        ON DELETE CASCADE
        NOT VALID,
    CONSTRAINT viaje_trayecto_fkey FOREIGN KEY (id_trayecto)
        REFERENCES public.trayecto (id) MATCH SIMPLE
        ON UPDATE CASCADE
        ON DELETE CASCADE
        NOT VALID
)
WITH (
    OIDS = FALSE
);

ALTER TABLE public.viaje
    OWNER to postgres;
COMMENT ON TABLE public.viaje
    IS 'Esta tabla contiene datos  sobre los viajes que pueden hacer los pasajeros ';

COMMENT ON CONSTRAINT viaje_pasajero_fkey ON public.viaje
    IS 'Este campo hace referencia al  ID de la tabla pasajero';
COMMENT ON CONSTRAINT viaje_trayecto_fkey ON public.viaje
    IS 'Este campo hace referencia al  ID de la tabla trayecto';

Constraints

Hola!

Esta es mi BD. Queda pendiente relacionar las llaves foraneas.

Creación de script de inserción

Creación de tabla

Así quedaron las tablas

Creación de database

Acciones de las tablas

Buen día, comparto mis tablas .

Hola,
les compartos mis tablas
![](

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

Dejo aquí el reto del arbol de transporte:

Debo compartirles que tardé días en lograr conectar pgadmin4 con mi base de datos local… y entre muchas cosas les comento un dato que quizás para los más expertos en obvio pero para los principiantes como yo, es locura:
+++ Para poder conectar mi servidor desde pgadmin, mis datos de conexión DEBEN SER IGUAL A MIS DATOS DE CONEXION DESDE LA TERMINAL… quizás esto es obvio, pero para mí me costó mucho entender un poco la inicialización de la BD y el tema de los usuarios y roles en PSQL.

Desde el PGAdmin es muy sencillo y la interfaz es muy amigable

CREATE TABLE pasajero (
	id SERIAL PRIMARY KEY NOT NULL,
	nombre CHARACTER VARYING(100) NOT NULL,
	direccion_residencia CHARACTER VARYING NOT NULL,
	fecha_nacimiento DATE NOT NULL	
);
CREATE TABLE tren (
	id SERIAL PRIMARY KEY NOT NULL,
	modelo CHARACTER VARYING(100) NOT NULL,
	capacidad INTEGER NOT NULL
);
CREATE TABLE estacion (
	id SERIAL PRIMARY KEY NOT NULL,
	nombre CHARACTER VARYING(100) NOT NULL,
	direccion CHARACTER VARYING NOT NULL
);
CREATE TABLE trayecto (
	id SERIAL PRIMARY KEY NOT NULL,
	id_tren INTEGER NOT NULL,
	id_estacion INTEGER NOT NULL
);
ALTER TABLE trayecto ADD
CONSTRAINT trayecto_tren
FOREIGN KEY (id_tren)
REFERENCES tren(id)
ON DELETE NO ACTION
ON UPDATE NO ACTION;

ALTER TABLE trayecto ADD
CONSTRAINT trayecto_estacion
FOREIGN KEY (id_estacion)
REFERENCES estacion(id)
ON DELETE NO ACTION
ON UPDATE NO ACTION;

CREATE TABLE viaje(
	id SERIAL PRIMARY KEY NOT NULL,
	inicio TIMESTAMP NOT NULL,
	fin TIMESTAMP NOT NULL,
	id_pasajero INTEGER NOT NULL,
	id_trayecto INTEGER NOT NULL
);

ALTER TABLE viaje ADD
CONSTRAINT viaje_pasajero
FOREIGN KEY (id_pasajero)
REFERENCES pasajero(id)
ON DELETE NO ACTION
ON UPDATE NO ACTION;

ALTER TABLE viaje ADD
CONSTRAINT viaje_trayecto
FOREIGN KEY (id_trayecto)
REFERENCES trayecto(id)
ON DELETE NO ACTION
ON UPDATE NO ACTION;

Así quedó el mío 😃

Hola! Si no saben como poner la columna de la primary key, solo deben ir a constrains> signa +, le agregan el NAME, y para agregar COLUMNS, tozan en el lapiz al lado del tacho de basura>definition>Coumns y ahi ponen: ID.

listoo quedaron creadas. Si se equivocaron en el nombre de alguna tabla y quieren editarlo, sobre la tabla dan clic derecho y eligen propiedades ahi pueden volver a editar las columnas.

Que buen TIP para averiguar el formato como es el formato date ejecutar una función general de Postres que nos de ese mismo tipo de dato, (SELECT current_date).
Sencillo y rápido

Consejo personal:

  • Programen las columnas en inglés

No solo para practicar, sino que es mucho mejor visto que hacen las cosas en inglés que en español.

La estructura de mi bd

Hola a todos,
Comparto toda la creación de las 5 tablas.

Lito 😃

Hola!
Así ha quedado la estructura de las tablas en mi base de datos.

Solución al reto:

me causa conflicto que los id se definian con int auto incrementable, no se supone que int es una variable que se queda corta y es preferible usar bigint (long)?

Buenas Tardes

Árbol de las tablas creadas.

-- Si la base de datos existe la elimina
DROP DATABASE IF EXISTS transporte;
-- Creamos la base de datos
CREATE DATABASE transporte
    WITH
    OWNER = postgres
    ENCODING = 'UTF8'
    CONNECTION LIMIT = -1;

-- Nos movemos a la base de datos creada
\c transporte

-- Tabla pasajero
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;

-- Insertar un pasajero
INSERT INTO public.pasajero(nombre, direccion_residencia, fecha_nacimiento)
VALUES('Primer Pasajero', 'Direccion X', '1996-04-24');

-- Para ver la fecha actual
SELECT current_date;

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

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

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

-- Tabla viaje
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;```

En platzi deberían asegurarse que en los cursos siempre se utilicen y enseñen las buenas prácticas, por ejemplo, es una buena práctica que los nombres de las tablas sean en plural y que sean en inglés

Gracias a los comentarios pude realizar tanto las PRIMARY KEYS como las FOREINGN KEYS, así quedaron las tablas con sus debidos campos.


![](

Alguien me puede decir cuál es la diferencia entre Time y TimeStamp?

no me sale el rayito :(alguien que me diga como configurarlo??

En lo que terminan la tabla pueden escuchar la rola pasajero de Pedropiedra para que se inspiren:

}

Me gusta el hecho de poder copiar el código para consola.

listo!!!, ya se generaron las tablas

función Scripts

Las tablas son el elemento que contienen la información y la estructura en nuestra base de datos.

A pesar de que las tablas tienen un funcionamiento complejo, las acciones que puede revisar sobre ella son muy simples y es son: 1.CREATE="crear", 2.ALTER = "alterar", DROP ="Eliminar".

CREATE sirve para inicializar la estructura de datos y esto será con

CREATE sirve para inicializar la estructura de datos (tabla) y en esta se declara el nombre de la tabla junto con los campos y sus tipos de datos.

DROP simplemente nos permite borrar la tabla con toda su información.

Es buena práctica como se vio en los anteriores cursos es importante comenzar a crear las tablas que no tengan llaves foráneas.

En postgres character varying es equivalente al varchar de MySQL

En la pestaña constraints se puede crear la llaves primarias, llaves foraneas, check, Unique, Exclude

El estándar que usa postgres para nombrar los constraints de tipo primary key es: nombreCampo_pkey

Yo le tuve que colocar el id

En la pestaña SQL siempre veremos la sentencia SQL que genera PgAdmin al crear una base de dato o tabla con la interfaz gráfica.

Para crear un Script de inserción hacemos clic derecho en la tabla y nos vamos a la opción Scripts y luego seleccionamos el ejemplo de Scripts que necesitamos.

SELECT current_date; sirve para saber el día que estamos actualmente pero también nos sirve para ver como postgres guarda la fecha en un campo con el tipo de datos Date.

Las tablas tienen un funcionamiento complejo pero existe un conjunto de acciones u operaciones definidas de acciones que se pueden realizar sobre ella son muy simples y es son: 1.CREATE, 2.ALTER, 3.DROP. Esto se conoce como DATA DEFINITION LENGUAJE.

ALTER sirve para alterar o cambiar la estructura de una tabla incluyendo los CONSTRAINTS, Agregar o quitar columnas, cambiar índices, agregar llaves primarias e incluso agregar roles como propietarios de la tabla

La primera columna que necesita toda tabla es un ID y es buena práctica hacerla de tipo entero y que automáticamente incremente. El tipo de dato SERIAL en postgres es equivalente al AUTO_INCREMENT en MySQL. SERIAL es un integer por defecto.

Ya lo complete

Ya esta!!!

COMPLETADO
_este codigo si quieres puedes copiarlo en QUERY EDITOR DE transporte/[email protected] _

CREATE TABLE 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 tren(
	id serial,
	modelo character varying(30),
	capacidad integer,
	CONSTRAINT tren_pkey PRIMARY KEY (id)
)
WITH (
OIDS = FALSE );
ALTER TABLE public.tren
OWNER to postgres;

CREATE TABLE estacion(
	id serial,
	nombre character varying(30),
	direccion character varying(100),
	CONSTRAINT estacion_pkey PRIMARY KEY (id)
)
WITH (
OIDS = FALSE );
ALTER TABLE public.estacion
OWNER to postgres;

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)
)
WITH (
OIDS = FALSE );
ALTER TABLE public.trayecto
OWNER to postgres;

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

Aquí el arbol de la DB transporte:

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(50),
    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(30),
	direccion character varying,
	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),
	FOREIGN KEY (id_tren) REFERENCES estacion(id),
	FOREIGN KEY (id_estacion) REFERENCES tren(id)
)
WITH (
OIDS = FALSE );
ALTER TABLE public.trayecto
OWNER to postgres;

CREATE TABLE public.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)
)
WITH (
OIDS = FALSE );
ALTER TABLE public.viaje
OWNER to postgres;
CREATE TABLE public.pasajeros
(
    "ID_pasajero" serial,
    direccion_residencia character varying(40),
    nombre character varying(20),
    fecha_nacimiento date,
    CONSTRAINT "ID_pasajero" PRIMARY KEY ("ID_pasajero")
);

ALTER TABLE public.pasajeros
    OWNER to postgres;```

Cuál es la diferencia en utilizar Serial en vez de UUID

¿En qué casos se utiliza UUID?


Done !

Como hay hacer la relaciones del trayecto y del Viaje,o eso todavía no es importante

Listo!

transporte=# \dt
          List of relations
 Schema |   Name   | Type  |  Owner   
--------+----------+-------+----------
 public | estacion | table | postgres
 public | pasajero | table | postgres
 public | trayecto | table | postgres
 public | tren     | table | postgres
 public | viaje    | table | postgres
(5 rows)