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.
¿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?
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:
postgres.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:
Tables y selecciona Create Table.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:
SERIAL que actúa como llave primaria.VARCHAR con una longitud máxima definida.VARCHAR para almacenar direcciones.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:
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!
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.
Veamos un ejemplo práctico de cómo comenzar con estas acciones.
Para comenzar a desarrollar nuestra base de datos, primero debemos activarla y configurarla:
postgres.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;
Ahora que tenemos nuestra base de datos, podemos crear una tabla:
Tables y selecciona Create Table.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
);
Cuando definas las columnas, considera el tipo de datos y la longitud adecuada para optimizar el uso de memoria. Por ejemplo:
SERIAL que actúa como llave primaria.VARCHAR con una longitud máxima definida.VARCHAR para almacenar direcciones.DATE.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;
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:
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!
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)
)
Modo OSCURO PGADMIN: Ir a File / Preferences / Themes / y elegir el tema Dark.
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;
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





Este es el código con el que cree la base de datos y también está el arbol de las tablas
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;
El tipo de dato SERIAL en postgres es equivalente al AUTO_INCREMENT en MySQL
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
John J. Meza
Oscar Julian Layton
Andrea Maria Clavero Parra
Marco Antonio González Arellano
Andoni Alonso Tort
Marco Antonio González Arellano
Leandro Cosme Tomassini
Mariana Ramirez
Santiago Garcia Rojas
Carlos Delgado
Mateo Posada
Miguel Torres
Jerson Mosquera Pretelt
Jesús David Barraza Guzmán
Angel de Jesus Quintero Pereira
Christian Rangel
Juan Pablo Reina Gutierrez
Jose Colmenares
Jhon Mario Ochoa Lemus
Angel de Jesus Quintero Pereira
Jeisson Espinosa
Jessica Andrea Aquino Torrez
Isay Humberto Lucas Hernandez
Verónica Rodríguez
Cristopher Rojas Salas
Martín Alejandro Vera
Andoni Alonso Tort
Mario David Herrera Vásquez
Carlos Augusto Sánchez Seminario
Juan Andres Quiroz Franco
Edgar Contreras
luis felipe castro calderón
Sergio Alejandro Trejo Cuxim
Jeinfferson Bernal G
David Jonatan Mora Bejarano
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.
Gracias por el aporte, ya estaba pensando en esto.
Gracias!!! se me complico con las fkey ya que no esta explicado en este video.-
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) )
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
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!
Modo OSCURO PGADMIN: Ir a File / Preferences / Themes / y elegir el tema Dark.
¡Gracias por esto! ¡Me estaban sangrando los ojos!
Buenísimo este aporte
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 );
muy bien
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;
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));
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...
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
Excelente gracias por aclarar mi duda
Este es el código con el que cree la base de datos y también está el arbol de las tablas
Igual al mio!
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;
El tipo de dato SERIAL en postgres es equivalente al AUTO_INCREMENT en MySQL
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
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;
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')
Para la primary key no deberia activar tambien el not null?
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.
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
Falto explicar cómo se puede crear una llave foránea en pgAdmin para poder realizar las relaciones desde ahí :c
yo lo hice de esta forma y me funciono
nombre de la tabla
agregamos los atributos a nuestra tabla
3.agregamos nuestra llave primaria
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
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
Gracías, capo!
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:
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.
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
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/
Las tablas son elementos que contiene la informacion y estructura de la BD. Las acciones que se pueden realizar sobre ellas son muy sencillas:
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.