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:
CREATEDATABASE 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:
CREATETABLE pasajero ( id SERIALPRIMARYKEY, 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:
Si deseas saber el formato exacto que utiliza tu sistema para fechas, puedes hacer una consulta rápida:
SELECTCURRENT_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!
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.
CREATETABLEpasajero( id serial, nombre character varying(100), direccion_residencia character varying, fecha_nacimiento date,CONSTRAINT pasajero_pkey PRIMARYKEY(id))CREATETABLEtren( id serial, modelo character varying(30), capacidad integer,CONSTRAINT tren_pkey PRIMARYKEY(id))CREATETABLEestacion( id serial, nombre character varying(30), direccion character varying(100),CONSTRAINT estacion_pkey PRIMARYKEY(id))CREATETABLEtrayecto( id serial, id_tren integer, id_estacion integer,CONSTRAINT trayecto_pkey PRIMARYKEY(id),FOREIGNKEY(id_tren)REFERENCESestacion(id),FOREIGNKEY(id_estacion)REFERENCEStren(id))CREATETABLEviaje( id serial, id_pasajero integer, id_trayecto integer, inicio date, fin date,CONSTRAINT viaje_pkey PRIMARYKEY(id),FOREIGNKEY(id_pasajero)REFERENCESpasajero(id),FOREIGNKEY(id_trayecto)REFERENCEStrayecto(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,);CREATETABLEpublic.tren( id serial not NULL, modelo varchar NULL, capacidad int null, constraint tren_pk primary key(id));CREATETABLEpublic.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.
--PASAJEROSCREATETABLEpublic.pasajeros( id integer NOTNULLDEFAULTnextval('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 PRIMARYKEY(id))WITH(OIDS=FALSE)TABLESPACE pg_default;ALTERTABLEpublic.pasajerosOWNER to postgres;--ESTACIONESCREATETABLEpublic.estaciones( id serial NOTNULL, nombre character varying(50)NOTNULL, direccion character varying(50),CONSTRAINT estaciones_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.estacionesOWNER to postgres;--TRENESCREATETABLEpublic.trenes( id serial NOTNULL, modelo character varying(50)NOTNULL, capacidad integer,CONSTRAINT trenes_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.trenesOWNER to postgres;--TRAYECTOSCREATETABLEpublic.trayectos( id serial NOTNULL, nombre character varying(50); id_estacion integer, id_tren integer,CONSTRAINT trayectos_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.trayectosOWNER to postgres;--VIAJESCREATETABLEpublic.viajes( id serial NOTNULL, id_pasajero integer, id_trayecto integer, inicio timestamp without time zone NOTNULL, fin timestamp without time zone NOTNULL,CONSTRAINT viajes_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.viajesOWNER to postgres;
Excelente, yo las hice utilizando solamente la consola!!
Ejemplo:
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...
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:
CREATETABLEpublic.pasajero( id serial, nombre character varying(100), direccion_residencia character varying, fecha_nacimiento date,CONSTRAINT pasajero_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.pasajeroOWNER to postgres;---------CREATETABLEpublic.tren( id serial, modelo character varying, capacidad integer,CONSTRAINT tren_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.trenOWNER to postgres;---------CREATETABLEpublic.estacion( id serial, nombre character varying, direcion integer,CONSTRAINT estacion_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.estacionOWNER to postgres;---------CREATETABLEpublic.trayecto( id serial, id_tren integer, id_estacion integer,CONSTRAINT trayecto_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.trayectoOWNER to postgres;---------CREATETABLEpublic.viaje( id serial, id_pasajero integer, id_trayecto integer, inicio timestamp without time zone, fin timestamp without time zone,CONSTRAINT viaje_pkey PRIMARYKEY(id))WITH(OIDS=FALSE);ALTERTABLEpublic.viajeOWNER 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:
CREATETABLEpublic.pasajeros( id serial, nombre character varying(100), direccion_residencia character varying, fecha_nacimiento date,CONSTRAINT pasajero_pkey PRIMARYKEY(id));CREATETABLEpublic.estaciones( id serial, nombre character varying(100), direccion character varying,CONSTRAINT estacion_pkey PRIMARYKEY(id));CREATETABLEpublic.trenes( id serial, modelo character varying(100), capacidad integer,CONSTRAINT tren_pkey PRIMARYKEY(id));CREATETABLEpublic.trayectos( id serial, id_tren integer, id_estacion integer,CONSTRAINT trayecto_pkey PRIMARYKEY(id),CONSTRAINT trayecto_trenes_fkey FOREIGNKEY(id_tren)REFERENCESpublic.trenes(id),CONSTRAINT trayecto_estaciones_fkey FOREIGNKEY(id_estacion)REFERENCESpublic.estaciones(id));CREATETABLEpublic.viajes( id serial, id_pasajero integer, id_trayecto integer, inicio date, fin date,CONSTRAINT viaje_pkey PRIMARYKEY(id),CONSTRAINT viaje_pasajero_fkey FOREIGNKEY(id_pasajero)REFERENCESpublic.pasajeros(id),CONSTRAINT viaje_trayecto_fkey FOREIGNKEY(id_trayecto)REFERENCESpublic.trayectos(id));ALTERTABLEIFEXISTSpublic.pasajerosOWNER to postgres;ALTERTABLEIFEXISTSpublic.estacionesOWNER to postgres;ALTERTABLEIFEXISTSpublic.trenesOWNER to postgres;ALTERTABLEIFEXISTSpublic.trayectosOWNER to postgres;ALTERTABLEIFEXISTSpublic.viajesOWNER 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
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
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
CREATEDATABASE transporte
WITHOWNER= postgres
ENCODING='UTF8'CONNECTIONLIMIT=-1IS_TEMPLATE=False;--CREATIONOFTABLES--Table'pasajeros'CREATETABLEpublic.passengers( id serial, name character varying(60), address character varying(60), birth_date date,CONSTRAINT passengers_pkey PRIMARYKEY(id));ALTERTABLEIFEXISTSpublic.passengersOWNER to postgres;--Table'trains'CREATETABLEpublic.trains( id serial, model character varying(60), capacity integer,CONSTRAINT trains_pkey PRIMARYKEY(id));ALTERTABLEIFEXISTSpublic.trainsOWNER to postgres;--Table'stations'CREATETABLEpublic.stations( id serial, name character varying(60), address character varying(80),CONSTRAINT stations_pkey PRIMARYKEY(id));ALTERTABLEIFEXISTSpublic.stationsOWNER to postgres;--Table'travels'CREATETABLEpublic.travels( id serial, start_station character varying(60)NOTNULL, end_station character varying(60)NOTNULL, passenger_id integer,CONSTRAINT travel_pkey PRIMARYKEY(id));ALTERTABLEIFEXISTSpublic.travelsOWNER to postgres;--Table'routes'CREATETABLEpublic.routes( id serial, name character varying(60)NOTNULL,CONSTRAINT routes_pkey PRIMARYKEY(id));ALTERTABLEIFEXISTSpublic.routesOWNER 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:
CREATETABLE color ( color_id INT GENERATED ALWAYS ASIDENTITY, color_name VARCHARNOTNULL);
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
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.
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.