Fundamentos de la Gestión de Bases de Datos con PostgreSQL

Introducción

En este laboratorio, aprenderá los fundamentos de la gestión de bases de datos utilizando PostgreSQL. El laboratorio cubre operaciones esenciales para la gestión de bases de datos, incluyendo la creación de nuevas bases de datos, el listado y la conexión a las existentes, y la eliminación de bases de datos cuando ya no son necesarias.

Comenzará creando una nueva base de datos utilizando el comando createdb y verificando su creación a través del comando psql. Luego, aprenderá cómo listar todas las bases de datos disponibles y conectarse a una base de datos específica. Finalmente, explorará cómo eliminar ( drop ) una base de datos y ver los metadatos de la base de datos. Este laboratorio proporciona una introducción práctica a las tareas básicas de administración de bases de datos en PostgreSQL.

Crear una Nueva Base de Datos

En este paso, aprenderá cómo crear una nueva base de datos en PostgreSQL. Crear una base de datos es el primer paso para organizar y almacenar sus datos.

Antes de comenzar, comprendamos qué es una base de datos. Una base de datos es una colección estructurada de datos que se organiza para facilitar el acceso, la gestión y la actualización. En PostgreSQL, una base de datos es un contenedor para tablas, vistas y otros objetos de la base de datos.

Para crear una nueva base de datos, utilizará el comando createdb. Este comando es un wrapper (envoltorio) alrededor del comando SQL CREATE DATABASE.

Abrir una terminal: Si aún no tiene una abierta, inicie una ventana de terminal.
Crear una nueva base de datos: Utilice el comando createdb seguido del nombre que desea dar a su base de datos. Por ejemplo, para crear una base de datos llamada mydatabase, ejecute el siguiente comando:
```
createdb mydatabase
```
Este comando creará una nueva base de datos llamada mydatabase. Si el comando se ejecuta correctamente, no verá ninguna salida.
Verificar la creación de la base de datos: Para confirmar que la base de datos se ha creado, puede listar todas las bases de datos utilizando el comando psql. Primero, conéctese a la base de datos predeterminada postgres:
```
psql -d postgres
```
Se le presentará el prompt postgres=#.

Listar bases de datos: En el prompt postgres=#, ejecute el siguiente comando SQL para listar todas las bases de datos:

\l

Este comando mostrará una lista de bases de datos, incluida la que acaba de crear (mydatabase). Debería ver una salida similar a esta:

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

Observe que mydatabase está en la lista.

Salir de psql: Para salir del prompt psql, escriba:
```
\q
```
y presione Enter. Volverá al prompt de la terminal normal.

Ahora ha creado con éxito una nueva base de datos en PostgreSQL.

Listar y Conectar a Bases de Datos

En este paso, aprenderá cómo listar las bases de datos disponibles y conectarse a una base de datos específica utilizando la herramienta de línea de comandos psql.

Abrir una terminal: Si aún no tiene una abierta, inicie una ventana de terminal.

Listar las bases de datos disponibles: Para listar todas las bases de datos, puede utilizar el comando psql con la opción -l (una 'L' minúscula). Esta opción lista todas las bases de datos en el servidor. Dado que no ha especificado una base de datos a la que conectarse, psql intentará conectarse utilizando su nombre de usuario actual.

psql -l

Este comando mostrará una lista de bases de datos, junto con sus propietarios, codificaciones y otra información. Debería ver una salida similar a esta:

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

Esta salida muestra los nombres de las bases de datos, sus propietarios y otros detalles. Debería ver la base de datos mydatabase que creó en el paso anterior.

Conectarse a una base de datos específica: Para conectarse a una base de datos específica, utilice el comando psql con la opción -d, seguido del nombre de la base de datos. Por ejemplo, para conectarse a la base de datos mydatabase, ejecute el siguiente comando:
```
psql -d mydatabase
```
Si la conexión se realiza correctamente, se le presentará el prompt mydatabase=#. Esto indica que ahora está conectado a la base de datos mydatabase.

Verificar la conexión: Para verificar que está conectado a la base de datos correcta, puede ejecutar un comando SQL simple, como:

SELECT version();

Este comando mostrará la versión del servidor PostgreSQL al que está conectado. La salida se verá así:

                                                 version
----------------------------------------------------------------------------------------------------------------
 PostgreSQL 14.7 (Debian 14.7-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
(1 row)

Salir de psql: Para salir del prompt psql, escriba:
```
\q
```
y presione Enter. Volverá al prompt de la terminal normal.

Ahora ha listado con éxito las bases de datos disponibles y se ha conectado a una base de datos específica utilizando psql.

Eliminar una Base de Datos

En este paso, aprenderá cómo eliminar (o dropear, del inglés "drop") una base de datos en PostgreSQL. Eliminar una base de datos es una acción permanente, por lo que es importante tener cuidado al usar este comando. Todos los datos dentro de la base de datos se perderán.

Abrir una terminal: Si aún no tiene una abierta, inicie una ventana de terminal.
Eliminar la base de datos: Utilice el comando dropdb seguido del nombre de la base de datos que desea eliminar. Por ejemplo, para eliminar la base de datos mydatabase, ejecute el siguiente comando:
```
dropdb mydatabase
```
Este comando eliminará la base de datos mydatabase. Si el comando se ejecuta correctamente, no verá ninguna salida.

Importante: Antes de eliminar una base de datos, asegúrese de que nadie esté conectado a ella. Si hay conexiones activas, el comando dropdb podría fallar.
Verificar la eliminación de la base de datos: Para confirmar que la base de datos se ha eliminado, puede listar todas las bases de datos utilizando el comando psql. Primero, conéctese a la base de datos predeterminada postgres:
```
psql -d postgres
```
Se le presentará el prompt postgres=#.

Listar bases de datos: En el prompt postgres=#, ejecute el siguiente comando SQL para listar todas las bases de datos:

\l

Este comando mostrará una lista de bases de datos. Verifique que mydatabase ya no esté en la lista.

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(3 rows)

Si mydatabase no aparece en la lista, se ha eliminado correctamente.

Salir de psql: Para salir del prompt psql, escriba:
```
\q
```
y presione Enter. Volverá al prompt de la terminal normal.

Ahora ha eliminado con éxito una base de datos en PostgreSQL. Recuerde tener precaución al eliminar bases de datos, ya que esta acción es irreversible.

Ver Metadatos de la Base de Datos

En este paso, aprenderá cómo ver los metadatos de la base de datos en PostgreSQL. Los metadatos son "datos sobre datos". En el contexto de una base de datos, los metadatos describen la estructura y las características de la base de datos en sí, incluida la información sobre tablas, columnas, tipos de datos y restricciones.

Abrir una terminal: Si aún no tiene una abierta, inicie una ventana de terminal.
Conectarse a la base de datos postgres: Dado que eliminamos (dropped) mydatabase en el paso anterior, nos conectaremos a la base de datos predeterminada postgres para explorar los metadatos.
```
psql -d postgres
```
Se le presentará el prompt postgres=#.

Listar tablas: Para listar todas las tablas en la base de datos actualmente conectada, puede usar el comando \dt.

\dt

Dado que aún no hemos creado ninguna tabla, la salida debería estar vacía o mostrar tablas del sistema. Podría verse así:

Did not find any relations.

             List of relations
 Schema |         Name          | Type  |  Owner
--------+-----------------------+-------+----------
 pg_catalog | pg_aggregate          | table | postgres
 pg_catalog | pg_am               | table | postgres
 pg_catalog | pg_amop             | table | postgres
...

La salida muestra el esquema (schema), el nombre, el tipo y el propietario de cada tabla.

Describir una tabla: Para ver información detallada sobre una tabla específica, puede usar el comando \d seguido del nombre de la tabla. Dado que no tenemos una tabla creada por el usuario, examinemos una tabla del sistema, por ejemplo, pg_class.

\d pg_class

Este comando mostrará la estructura de la tabla pg_class, incluidos los nombres de las columnas, los tipos de datos y cualquier restricción. La salida será bastante extensa, pero proporciona una descripción general completa de la definición de la tabla.

                                     Table "pg_catalog.pg_class"
      Column       |   Type    | Collation | Nullable | Default | Storage  | Stats target | Description
-------------------+-----------+-----------+----------+---------+----------+--------------+-------------
 oid               | oid       |           | not null |         | plain    |              |
 relname           | name      |           | not null |         | plain    |              |
 relnamespace      | oid       |           | not null |         | plain    |              |
 reltype           | oid       |           | not null |         | plain    |              |
 reloftype         | oid       |           | not null |         | plain    |              |
 relowner          | oid       |           | not null |         | plain    |              |
 relam             | oid       |           | not null |         | plain    |              |
 relfilenode       | oid       |           | not null |         | plain    |              |
 reltablespace     | oid       |           | not null |         | plain    |              |
 relpages          | integer   |           | not null |         | plain    |              |
 reltuples         | real      |           | not null |         | plain    |              |
 relallvisible     | boolean   |           | not null |         | plain    |              |
 reltoastrelid     | oid       |           | not null |         | plain    |              |
 relhasindex       | boolean   |           | not null |         | plain    |              |
 relhasrules       | boolean   |           | not null |         | plain    |              |
 relhastriggers    | boolean   |           | not null |         | plain    |              |
 relhassubclass    | boolean   |           | not null |         | plain    |              |
 relrowsecurity    | boolean   |           | not null |         | plain    |              |
 relforcerowsecurity| boolean   |           | not null |         | plain    |              |
 relispopulated    | boolean   |           | not null |         | plain    |              |
 relreplident      | character |           | not null |         | plain    |              |
 relispartition    | boolean   |           | not null |         | plain    |              |
 relrewrite        | oid       |           | not null |         | plain    |              |
 relacl            | aclitem[] |           |          |         | plain    |              |
 reloptions        | text[]    |           |          |         | plain    |              |
 relpartbound      | pg_node_tree |           |          |         | extended |              |
Indexes:
    "pg_class_oid_index" UNIQUE, btree (oid)
    "pg_class_relname_nsp_index" UNIQUE, btree (relname, relnamespace)
Foreign-key constraints:
    "pg_class_relam_fkey" FOREIGN KEY (relam) REFERENCES pg_am(oid)
    "pg_class_relnamespace_fkey" FOREIGN KEY (relnamespace) REFERENCES pg_namespace(oid)
    "pg_class_relowner_fkey" FOREIGN KEY (relowner) REFERENCES pg_authid(oid)
    "pg_class_reltoastrelid_fkey" FOREIGN KEY (reltoastrelid) REFERENCES pg_class(oid)
Referenced by:
    TABLE "pg_statistic_ext" CONSTRAINT "pg_statistic_ext_relid_fkey" FOREIGN KEY (relid) REFERENCES pg_class(oid)
    TABLE "pg_rewrite" CONSTRAINT "pg_rewrite_ev_class_fkey" FOREIGN KEY (ev_class) REFERENCES pg_class(oid)
    TABLE "pg_trigger" CONSTRAINT "pg_trigger_tgrelid_fkey" FOREIGN KEY (tgrelid) REFERENCES pg_class(oid)

Salir de psql: Para salir del prompt psql, escriba:
```
\q
```
y presione Enter. Volverá al prompt de la terminal normal.

Ahora ha visto con éxito los metadatos de la base de datos en PostgreSQL utilizando psql. Esto le permite comprender la estructura y las propiedades de sus bases de datos y tablas.

Resumen

En este laboratorio, aprendió los conceptos básicos de la gestión de bases de datos en PostgreSQL, comenzando con la creación de una nueva base de datos. El proceso implica el uso del comando createdb seguido del nombre de la base de datos deseada en la terminal. La ejecución exitosa crea la base de datos sin ninguna salida.

Para verificar la creación, se conecta a la base de datos predeterminada postgres utilizando psql -d postgres y luego utiliza el comando \l para listar todas las bases de datos disponibles, confirmando que la base de datos recién creada está presente.