Cómo crear y eliminar bases de datos y tablas en PostgreSQL

Introducción

PostgreSQL y otros sistemas de gestión de bases de datos relacionales utilizan bases de datos y tablas para estructurar y organizar sus datos. Podemos revisar la definición de esos dos términos rápidamente:

• bases de datos: separar diferentes conjuntos de estructuras y datos entre sí
• tablas: definir la estructura de datos y almacenar los valores de datos reales dentro de las bases de datos

En PostgreSQL, también existe un objeto intermediario entre las bases de datos y las tablas llamado esquema. :

• esquema: un espacio de nombres dentro de una base de datos que contiene tablas, índices, vistas y otros elementos.

Esta guía no tratará directamente el concepto de esquema de PostgreSQL, pero es bueno saber que está ahí.

En su lugar, nos centraremos en cómo crear y destruir bases de datos y tablas de PostgreSQL. Los ejemplos utilizarán principalmente SQL, pero hacia el final, le mostraremos cómo realizar algunas de estas tareas mediante la línea de comandos. Estas alternativas usan herramientas incluidas en la instalación estándar de PostgreSQL que están disponibles si tiene acceso administrativo al host de PostgreSQL.

Algunas de las declaraciones cubiertas en esta guía, particularmente PostgreSQL CREATE TABLE declaración, tienen muchas opciones adicionales que estaban fuera del alcance de este artículo. Si desea obtener más información, consulte la documentación oficial de PostgreSQL para obtener más información.

Requisitos previos

Para seguir esta guía, deberá iniciar sesión en una instancia de PostgreSQL con un usuario con privilegios administrativos mediante psql cliente de línea de comandos. Su instancia de PostgreSQL se puede instalar localmente, de forma remota o aprovisionada por un proveedor.

Específicamente, su usuario de PostgreSQL necesitará CREATE DB privilegio o ser un Superuser , que puede consultar con el \du metacomando en psql :

\du
 

                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
 

El postgres superusuario, que se crea automáticamente durante la instalación, tiene los privilegios necesarios, pero puede usar cualquier usuario con Create DB privilegio.

Crear una nueva base de datos

Una vez que esté conectado a su instancia de PostgreSQL usando psql o cualquier otro cliente SQL, puede crear una base de datos usando SQL.

La sintaxis básica para crear una base de datos es:

CREATE DATABASE db_name;
 

Esto creará una base de datos llamada db_name en el servidor actual con el usuario actual configurado como el propietario de la nueva base de datos utilizando la configuración de base de datos predeterminada. Puede ver las propiedades de la template1 predeterminada plantilla usando el siguiente psql metacomando:

\l template1
 

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

Puede agregar parámetros adicionales para modificar la forma en que se crea su base de datos. Estas son algunas opciones comunes:

• CODIFICACIÓN: establece la codificación de caracteres para la base de datos.
• LC_COLLATE: establece la colección , u ordene, ordene la base de datos. Esta es una opción de localización que determina cómo se organizan los artículos cuando se ordenan.
• LC_CTYPE: establece la clasificación de caracteres para la nueva base de datos. Esta es una opción de localización que afecta qué caracteres se consideran mayúsculas, minúsculas y dígitos.

Estos pueden ayudar a garantizar que la base de datos pueda almacenar datos en los formatos que planea admitir y con las preferencias de localización de su proyecto.

Por ejemplo, para asegurarse de que su base de datos se cree con compatibilidad con Unicode y anular la configuración regional propia del servidor para usar la localización en inglés americano (todo esto coincide con los valores en la template1 se muestra arriba, por lo que en realidad no se producirá ningún cambio), puede escribir:

CREATE DATABASE db_name  ENCODING 'UTF8'  LC_COLLATE 'en_US.UTF-8'  LC_CTYPE 'en_US.UTF-8';
 

Para seguir los ejemplos de esta guía, cree una base de datos llamada school utilizando la configuración regional predeterminada de su instancia y la codificación de caracteres UTF8:

CREATE DATABASE school ENCODING 'UTF8';
 

Esto creará su nueva base de datos utilizando las especificaciones que proporcionó.

Lista de bases de datos existentes

Para determinar qué bases de datos están actualmente disponibles en su servidor o clúster, puede usar la siguiente instrucción SQL:

SELECT datname FROM pg_database;
 

Esto enumerará cada una de las bases de datos actualmente definidas dentro del entorno:

  datname----------- _dodb template1 template0 defaultdb school(5 rows)
 

Como se mencionó anteriormente, si está conectado mediante psql cliente, también puede obtener esta información \l metacomando:

\l
 

Esto mostrará los nombres de bases de datos disponibles junto con sus propietarios, codificación, configuraciones locales y privilegios:

                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)
 

La school base de datos que creamos se muestra entre las otras bases de datos en el sistema. Esta es una buena manera de obtener una descripción general de las bases de datos dentro de su servidor o clúster.

Crear tablas dentro de bases de datos

Después de crear una o más bases de datos, puede comenzar a definir tablas para almacenar sus datos. Las tablas constan de un nombre y un esquema definido que determina los campos y tipos de datos que debe contener cada registro.

PostgreSQL CREATE TABLE sintaxis

Puede crear tablas utilizando CREATE TABLE declaración. Una sintaxis básica simplificada para el comando es similar a la siguiente:

CREATE TABLE table_name (    column_name TYPE [column_constraint],    [table_constraint,]);
 

Los componentes de la sintaxis anterior incluyen lo siguiente:

• CREATE TABLE table_name :La declaración de creación básica que indica que desea definir una tabla. El table_name el marcador de posición debe reemplazarse con el nombre de la tabla que desea usar.
• column_name TYPE :Define una columna básica dentro de la tabla. El column_name el marcador de posición debe reemplazarse con el nombre que desea usar para su columna. El TYPE especifica el tipo de datos de PostgreSQL para la columna. Los datos almacenados en la tabla deben ajustarse a la estructura de la columna y los tipos de datos de la columna para ser aceptados.
• column_constraint :Las restricciones de columna son restricciones opcionales para agregar más restricciones a los datos que se pueden almacenar en la columna. Por ejemplo, puede exigir que las entradas no sean enteros nulos, únicos o positivos.
• table_constraints :Las restricciones de tabla son similares a las restricciones de columna, pero implican la interacción de varias columnas. Por ejemplo, podría tener una restricción de tabla que verifique que un DATE_OF_BIRTH es anterior a DATE_OF_DEATH en una tabla.

Crear tablas condicionalmente con IF NOT EXISTS cláusula

De forma predeterminada, si intenta crear una tabla en PostgreSQL que ya existe en la base de datos, se producirá un error. Para solucionar este problema en los casos en los que desea crear una tabla si no está presente, pero continuar si ya existe, puede usar IF NOT EXISTS cláusula. El IF NOT EXISTS calificador opcional que le dice a PostgreSQL que ignore la declaración si la base de datos ya existe.

Para usar el IF NOT EXISTS cláusula, insértela en el comando después de CREATE TABLE sintaxis y antes del nombre de la tabla:

CREATE TABLE IF NOT EXISTS table_name (    column_name TYPE [column_constraint],    [table_constraint,]);
 

Esta variante intentará crear la tabla. Si ya existe una tabla con ese nombre dentro de la base de datos especificada, PostgreSQL arrojará una advertencia que indica que el nombre de la tabla ya se tomó en lugar de fallar con un error.

Cómo crear tablas en PostgreSQL

La sintaxis anterior es suficiente para crear tablas básicas. Como ejemplo, crearemos dos tablas dentro de nuestra school base de datos. Una tabla se llamará supplies y el otro se llamará teachers :

En los supplies tabla, queremos tener los siguientes campos:

• ID: Una identificación única para cada tipo de material escolar.
• Nombre: El nombre de un artículo escolar específico.
• Descripción: Una breve descripción del artículo.
• Fabricante: El nombre del fabricante del artículo.
• Color: El color del artículo.
• Inventario: La cantidad de artículos que tenemos para cierto tipo de útiles escolares. Esto nunca debe ser menor que 0.

Podemos crear los supplies tabla con las cualidades anteriores usando el siguiente SQL.

Primero, cambia a la school base de datos que creaste con psql escribiendo:

\c school
 

Esto cambiará la base de datos a la que apuntarán nuestros futuros comandos. Su mensaje debería cambiar para reflejar la base de datos.

A continuación, cree los supplies tabla con la siguiente declaración:

CREATE TABLE supplies (  id INT PRIMARY KEY,  name VARCHAR,  description VARCHAR,  manufacturer VARCHAR,  color VARCHAR,  inventory int CHECK (inventory > 0));
 

Esto creará los supplies tabla dentro de la school base de datos. La PRIMARY KEY La restricción de columna es una restricción especial que se utiliza para indicar columnas que pueden identificar de forma única los registros dentro de la tabla. Como tal, la restricción especifica que la columna no puede ser nula y debe ser única. PostgreSQL crea índices para columnas de clave principal para aumentar la velocidad de consulta.

Verifique que la nueva tabla esté presente escribiendo:

\dt
 

          List of relations Schema |   Name   | Type  |  Owner  --------+----------+-------+--------- public | supplies | table | doadmin(1 row)
 

Verifique que el esquema refleje el diseño previsto escribiendo:

\d supplies
 

                      Table "public.supplies"    Column    |       Type        | Collation | Nullable | Default--------------+-------------------+-----------+----------+--------- id           | integer           |           | not null | name         | character varying |           |          | description  | character varying |           |          | manufacturer | character varying |           |          | color        | character varying |           |          | inventory    | integer           |           |          |Indexes:    "supplies_pkey" PRIMARY KEY, btree (id)Check constraints:    "supplies_inventory_check" CHECK (inventory > 0)
 

Podemos ver cada una de las columnas y tipos de datos que especificamos. La restricción de columna que definimos para el inventory columna aparece hacia el final.

A continuación, crearemos un teachers mesa. En esta tabla, las siguientes columnas deben estar presentes:

• ID de empleado :Un número de identificación de empleado único.
• Nombre :El nombre del profesor.
• Apellido :El apellido del profesor.
• Asunto :La materia que el profesor es contratado para enseñar.
• Nivel de grado :El nivel de grado de los estudiantes para los que el profesor está contratado para enseñar.

Crear los teachers tabla con el esquema anterior con el siguiente SQL:

CREATE TABLE teachers (  id INT PRIMARY KEY,  first_name VARCHAR,  last_name VARCHAR,  subject VARCHAR,  grade_level int);
 

Cómo crear tablas con claves primarias y claves foráneas

Puede encontrar información sobre cómo crear tablas con claves primarias y externas en algunas de nuestras otras guías de PostgreSQL. Las claves primarias y las claves externas son tipos de restricciones de base de datos dentro de PostgreSQL.

Una clave principal es una columna o columna especial que se garantiza que es única en todas las filas dentro de la misma tabla. Todas las claves primarias se pueden usar para identificar de forma única una fila específica. Las claves primarias no solo garantizan que cada fila tenga un valor único para las columnas de la clave principal, sino que también garantizan que ninguna fila contenga NULL valores para esa columna. A menudo, la clave principal en PostgreSQL usa el siguiente formato para especificar una clave principal incremental asignada automáticamente:id SERIAL PRIMARY KEY .

Las claves externas son una forma de garantizar que una columna o columnas en una tabla coincidan con los valores contenidos en otra tabla. Esto ayuda a garantizar la integridad referencial entre tablas.

Cómo ver tablas en PostgreSQL

En PostgreSQL, puede enumerar tablas de diferentes maneras según la información que esté buscando.

Si desea ver qué tablas están disponibles en su base de datos, puede usar \dt meta-comando incluido con el psql cliente para enumerar todas las tablas, como demostramos anteriormente:

\dt
 

          List of relations Schema |   Name   | Type  |  Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)
 

También puede verificar que el esquema de la tabla coincida con sus especificaciones:

\d teachers
 

                     Table "public.teachers"   Column    |       Type        | Collation | Nullable | Default-------------+-------------------+-----------+----------+--------- id          | integer           |           | not null | first_name  | character varying |           |          | last_name   | character varying |           |          | subject     | character varying |           |          | grade_level | integer           |           |          |Indexes:    "teachers_pkey" PRIMARY KEY, btree (id)
 

Los teachers la tabla parece coincidir con nuestra definición.

Alterar tablas

Si necesita cambiar el esquema de una tabla existente en PostgreSQL, puede usar ALTER TABLE dominio. La ALTER TABLE El comando es muy similar a CREATE TABLE comando, pero opera en una tabla existente.

Alterar la sintaxis de la tabla

La sintaxis básica para modificar tablas en PostgreSQL se ve así:

ALTER TABLE <table_name> <change_command> <change_parameters>
 

El <change_command> indica el tipo exacto de cambio que le gustaría realizar, ya sea que implique establecer diferentes opciones en la tabla, agregar o eliminar columnas, o cambiar tipos o restricciones. El <change_parameters> parte del comando contiene información adicional que PostgreSQL necesita para completar el cambio.

Agregar columnas a tablas

Puede agregar una columna a una tabla de PostgreSQL con ADD COLUMN cambio de mando. Los parámetros de cambio incluirán el nombre de la columna, el tipo y las opciones, tal como los especificaría en CREATE TABLE comando.

Por ejemplo, para agregar una columna llamada missing_column del text escribe en una tabla llamada some_table , escribiría:

ALTER TABLE some_table ADD COLUMN missing_column text;
 

Eliminando columnas de tablas

Si, en cambio, desea eliminar una columna existente, puede usar el DROP COLUMN comando en su lugar. Debe especificar el nombre de la columna que desea eliminar como parámetro de cambio:

ALTER TABLE some_table DROP COLUMN useless_column;
 

Cambiando el tipo de datos de una columna

Para cambiar el tipo de datos que usa PostgreSQL para una columna específica, puede usar ALTER COLUMN cambie el comando con SET DATA TYPE comando de columna Los parámetros incluyen el nombre de la columna, su nuevo tipo y un USING opcional cláusula para especificar cómo se debe convertir el tipo antiguo al tipo nuevo.

Por ejemplo, para establecer el valor de un id columna en el resident tabla a un int usando un molde explícito, podemos escribir lo siguiente:

ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;
 

Otros cambios en la tabla

Se pueden lograr muchos otros tipos de cambios con ALTER TABLE dominio. Para obtener más información sobre las opciones disponibles, consulte la documentación oficial de PostgreSQL para ALTER TABLE .

Soltar tablas

Si desea eliminar una tabla, puede usar el DROP TABLE instrucción SQL. Esto eliminará la tabla y todos los datos almacenados en ella.

La sintaxis básica se ve así:

DROP TABLE table_name;
 

Esto eliminará la tabla si existe y generará un error si el nombre de la tabla no existe.

Si desea eliminar la tabla si existe y no hacer nada si no existe, puede incluir el IF EXISTS calificador dentro de la declaración:

DROP TABLE IF EXISTS table_name;
 

Las tablas que tienen dependencias con otras tablas u objetos no se pueden eliminar de forma predeterminada mientras existan esas dependencias. Para evitar el error, puede incluir opcionalmente el CASCADE parámetro, que descarta automáticamente cualquier dependencia junto con la tabla:

DROP TABLE table_name CASCADE;
 

Si alguna tabla tiene una clave externa restricción, que hace referencia a la tabla que está eliminando, esa restricción se eliminará automáticamente.

Eliminar los supplies tabla que creamos anteriormente escribiendo:

DROP TABLE supplies;
 

Mantendremos a los teachers base de datos para demostrar que la declaración para eliminar bases de datos también elimina todos los objetos secundarios como tablas.

Soltar bases de datos

La DROP DATABASE La declaración le dice a PostgreSQL que elimine la base de datos especificada. La sintaxis básica se ve así:

DROP DATABASE database_name;
 

Reemplace el database_name marcador de posición con el nombre de la base de datos que desea eliminar. Esto eliminará la base de datos si se encuentra. Si no se puede encontrar la base de datos, se producirá un error:

DROP DATABASE some_database;
 

ERROR:  database "some_database" does not exist
 

Si desea eliminar la base de datos si existe y no hacer nada, incluya el IF EXISTS opcional. opción:

DROP DATABASE IF EXISTS some_database;
 

NOTICE:  database "some_database" does not exist, skippingDROP DATABASE
 

Esto eliminará la base de datos o no hará nada si no se encuentra.

Para eliminar la school base de datos que usamos en esta guía, enumere las bases de datos existentes en su sistema:

\l
 

                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)
 

Abra una nueva conexión a una de las bases de datos que no desea eliminar:

\c defaultdb
 

Una vez que la nueva conexión esté abierta, elimine la school base de datos con el siguiente comando:

DROP DATABASE school;
 

Esto eliminará la school base de datos junto con los teachers tabla definida dentro.

createdb db_name
 

createdb --encoding=UTF8 --locale=en_US db_name
 

createdb --encoding=UTF8 school
 

dropdb database_name
 

dropdb --if-exists database_name
 

dropdb school