Dba PostgreSQL desde básico a avanzado parte1

EQ Soft Consultoría y Soporte E.I.R.L.
Http://www.eqsoft.net
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
DBA desde Básico a Avanzado
Clínica Santa Isabel - 2011
1/163
Curso de PostgreSQL DBACurso de PostgreSQL DBA
Desde Básico a AvanzadoDesde Básico a Avanzado
20112011
Parte 1Parte 1
Ernesto Quiñones AzcárateErnesto Quiñones Azcárate
ernesto@eqsoft.neternesto@eqsoft.net

●1: Instalación, Configuración y Logs bajo Gnu/Linux
●2: Software administración y SQL para DBAs
●3: Objetos de la DB, Herencias y Tablas particionadas
●4: Schemas y Tablespaces, Roles y Accesos
●5: Backup/Restore/Vacuum, Migraciones, Indices
●6: DBLinks, DbiLinks y Paquetes del Contrib
●7: Análisis de Hardware para soluciones avanzadas,
Monitoreo sobre Gnu/Linux.
●8: Configuración Avanzada y Problemas Comunes
●9: Replicación Asíncrona con PostgreSQL 9.0
●10: Pool de Conexiones con PgPool
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
2/163

1. Instalación:
3 formas de instalación son las más comunes:
●Instalación vía paquetes instaladores (deb ó rpm)
● Ventajas: mantenimiento prácticamente 0, excepto en cambios de versión
superior.
● Desventajas: ramas congeladas o sin actualizar por mucho tiempo,
básicamente solo se dan actualizaciones de seguridad.
●Compilación desde el código fuente (descargado o por Ports/Portage)
● Ventajas: Rápida ejecución, menos recursos, uso de última versión,
posibilidad de añadir nuevas funcionalidades extendidas.
● Desventajas: Mantenimiento manual, no es sencillo actualizar(salvo en
ports/portage)
●Paquetes no oficiales de instalación binarios
● Ventajas: Instalación de una versión específica
● Desventajas: Imposible de mantener
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
3/163

1. Instalación:
Instalación vía paquetes instaladores (deb ó rpm)
● Consideraciones : mantener siempre actualizada mientras no se mueva
entre ramas.
●Compilación desde el código fuente (descargado o por Ports/Portage)
● Consideraciones : no instalar en sistemas que usan administradores de
paquetes.
●Paquetes no oficiales de instalación binarios
● Consideraciones: usar solo en casos en que se requiera una versión
especifica, recomendable siempre tener una copia de la versión de
producción para casos de desastres.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
4/163

1.Instalación
Requerimientos de hardware:
● Procesador : si planea ejecutar Querys muy complejos es recomendable
utilizar plataformas de 64bits.
● Memoria : mientras más ram se pueda tener es mejor, especialmente si se
van a ejecutar Querys que van a mover mucha data, mientras mayor capacidad
tenga el cache mejor será el rendimiento de las consultas.
● Disco : la cantidad de espacio dependerá del volumen de datos,
recomendaciones:
● SCSI, para bases de datos relativamente medianas pero donde se requiere
un alto acceso a los datos, entorno muy propenso a caídas de servidor.
● SATA, para bases de datos muy grandes pero con no muy altos
requerimientos de acceso a los mismos, usar sistemas de archivos con
Journaling (ext4 por ejemplo) para minimizar riesgos en entornos
propensos a caídas.
● SSD, para cache de la DB, no usar para almacenamiento de datos “real”
debido a su “fragilidad” en entornos propensos a caídas.
● Arreglo de discos, entornos muy grandes de datos con mucho acceso a los
mismos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
5/163

1.Instalación
¿Que Linux usar? :
● Enterprise Edition
● Ventajas: muy seguros, actualizaciones centradas principalmente en la
seguridad.
● Desventajas: versiones antiguas incluso al momento de su lanzamiento.
CentOS, Ubuntu Server, RedHat, Suse
● Regular Edition
● Ventajas: actualizaciones constantes, se encuentran versiones más
recientes.
● Desventajas: no siempre bien probadas, principalmente se enfocan en
soltar la versión más reciente posible., mayor sensibilidad a problemas
de seguridad.
Ubuntu, Fedora, Suse
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
6/163

1. Instalación
¿Unixs Libres? :
● FreeBSD es una excelente opción, gestiona muy bien múltiples conexiones y
libera los procesos rápidamente, consumo de recursos increíblemente bajo,
soporte comunitario más amplio de todos los BSDs (OpenBSd ó NetBSD).
● OpenSolaris evaluar con cuidado, ¿seguirá siendo libre?, poco soporte
comunitarios, se sabe que ZFS es un sistema de archivos excelente para
PostgreSQL, se conocen experiencias de muchos procesadores virtualizados
con PostgreSQL.
● ¿Solaris y AIX?, buenas plataformas, evaluar bien los costos, seguramente
solo se encontrarán versiones antiguas de PostgreSQL disponibles para
estas plataformas o se requerirán versiones especificas de muchas
librerías dependencias.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
7/163

Instalando......
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
8/163

1. Instalación:
● La mayoría de las distribuciones actuales de GNU/Linux auto-generan los
directorios necesarios para correr el cluster de la DB, el caso de CentOS
luego de instalar los paquetes es necesario ejecutar este comando como
“root”:
service postgresql initdb <-- esto genera la estructura de
directorios necesaria para ejecutar
el cluster.
● Luego de ejecutar el comando tendremos finalmente estos directorios:
● /usr/bin <-- binarios (mezclados con los del sistema)
● /usr/lib <-- librerías (mezclados con los del sistema)
● /var/lib/pgsl/data <-- archivos de configuración y data de la base
de datos.
● El usuario administrador más común creado por los instaladores es
“postgres” (como en el caso de CentOS, alternativamente es “pgsql”
(sistemas Unix principalmente).
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
9/163

1. Instalación:
● Dentro de /var/lib/pgsql/data encontrará los directorios de trabajo del
cluster de la base de datos:
● base <-- directorio de data, “tablespace” por defecto.
● global <-- directorio de data global del sistema, por ejemplo:
los roles, los catálogos de objetos de la db, etc.
● pg_clog <-- directorio de “commit” de las transacciones, de este
directorio es que se lee la data.
● pg_log <-- log de ocurrencias del dbms
● pg_multixact <-- data producida por “locks” del sistema.
● pg_stat_tmp <-- archivos temporales de las estadísticas de las dbs
● pg_subtrans <-- usado en control de sub-transacciones
● pg_tblspc <-- enlaces simbólicos a los tablespaces
● pg_twophase <-- usado en control de commits de “dos fases” (gestiona
los commit de las transacciones que afectan al mismo
tiempo la misma data)
● pg_xlog <-- directorio de WAL (historia de movimientos de data, es
la que asegura que la dbms sea ACID)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
10/163

1. Instalación:
● Dentro de /var/lib/pgsql/data encontrará los directorios de trabajo del
cluster de la base de datos:
5 archivos adicionales:
● pg_hba.conf <-- archivos de control de accesos al sistema.
● postmaster.opts <-- comando con el que se ejecuto el servicio de la dbms
● postmaster.pid <-- “pid” del proceso del sistema, en raras ocasiones la
dbms se bloquea al reiniciar el servicio porque no
se elimina este archivo, se puede borrar
manualmente pero jamas mientras el servicio este
iniciado.
● pg_ident.conf <-- configuración de usuarios usando método “ident”
en pg_hba.conf desde IPs remotas.
● postgresql.conf <-- parámetros de configuración del sistema
● PG_VERSION <-- versión de PostgreSQL instalada
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
11/163

2. Configuración
Por defecto PostgreSQL viene configurado para dar accesos en “localhost”,
los usuarios comunes de administración son “postgres” (Gnu/Linux) y “pgsql”
(Unix).
Vamos a crear un nuevo “Super Usuario” desde consola, como usuario “root”:
root@host: su – postgres
postgres@host: createuser admindb <-- admindb es el usuario a
crear
¿Será el nuevo rol un superusuario? (s/n) <-- tendrá el mismo nivel del
usuario “postgres” tiene
permisos especiales a los
catálogos de objetos del
Sistema.
postgres@host: psql template1 <-- ingresamos para cambiar el
Password de “admindb”
template1=# alter user admindb password 'dbadmin'; <-- asignamos el nuevo
template1=# alter user postgres password 'dbpgsql'; Password.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
12/163

2.Configuración
Ahora necesitamos que no cualquier persona con acceso físico al “servidor”
pueda ingresar a la base de datos, para ello editamos el archivo
“pg_hba.conf” (como usuario “postgres”)
postgres@host: nano /var/lib/pgsql/data/pg_hba.conf
DICE:
# TYPE DATABASE USER CIDR-ADDRESS METHOD
# "local" is for Unix domain socket connections only
local all all ident
# IPv4 local connections:
host all all 127.0.0.1/32 ident
host all all ::1/128 ident
DEBE DECIR:
local all all password
host all all 127.0.0.1/32 password
#host all all ::1/128 ident <-- esto solo si usamos protocolo IPv6
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
13/163

2. Configuración
Reiniciamos el sistema
postgres@host : pg_ctl restart <--este comando no se puede ejecutar como
“root”
root@host : service postgresql restart <-- eso es lo mismo como “root”
Porque hicimos esto:
a) Hemos creado un password para el usuario administrador superior
“postgres”.
b) Trabajaremos con un usuario alterno para mayor seguridad.
c) Evitamos que cualquier persona con acceso al servidor entre a la base de
datos si conocer los passwords.
Debilidad:
Si algún usuario tiene permiso de editar el archivo pg_hba.conf y reiniciar
servicios entonces la seguridad es vulnerada.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
14/163

2. Configuración - Archivo pg_hba.conf
“pg_hba.conf” nos permite definir (en orden de aplicación):
a)Conecciones locales (x socket) ó de host seguras o inseguras (x TCP/IP)
b)Base datos a la que nos podemos conectar
c)Usuarios que se pueden conectar a las DBs
d)Direcciones autorizadas para conectarse (solo en caso TCP/IP)
e)Tipo de autenticación
# Database administrative login by UNIX sockets
local all postgres ident
local all all ident
host all all 127.0.0.1/32 ident
host all all ::1/128 md5
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
15/163

a)Conecciones locales (x socket) ó de host seguras o inseguras (x TCP/IP)
Posibles valores:
Local <-- conexiones por socket, más rápidas, solo si la aplicación
que hará uso de la db esta en el mismo servidor
Host <-- lo normal, conexiones vendrán por la red, puede o no tener
Soporte SSL
Hostssl <-- solo conexión SSL
Hostnossl <-- solo sin SSL
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
16/163

b)Base datos a la que nos podemos conectar
Se pueden definir conexiones para todas las db usando “ALL” o una
específica mencionándola directamente.
Recomendación: no usen combinaciones de mayúsculas y minúsculas.
Se puede usar sameuser, samegroup, samerol para indicar que la base de
datos a la que me conecto es la misma que mi nombre de usuario, grupo ó
rol.
c)Usuarios que se pueden conectar a las Dbs
Podemos especificar restricciones para todos los usuarios usando “ALL” o
para uno específico escribiendo su nombre, si pones “+” por detrás es el
nombre de un grupo.
En b) y c) podemos poner varias db y usuarios separados por comas.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
17/163

2.Configuración - Archivo pg_hba.conf
d)Direcciones autorizadas para conectarse (solo en caso TCP/IP)
Podemos especificar IPs directamente o por rango
192.168.1.10/32 <-- solo la IP mencionada
192.168.1.0/24 <-- todo el segmento 192.168.1.x
192.168.0.0/16 <-- todo el segmento 192.168.x.x
192.0.0.0/8 <-- todo el segmento 192.x.x.x
0.0.0.0/0 <-- todo el mundo
También podemos especificar IP y netmask (poco usado).
Se puede especificar IP de diferentes redes (no todo debe estar en
192.x.x.x).
Esto solamente se utiliza en el escenario donde el primer parametro es
HOST, HOSTSSL ó HOSTNOSSL.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
18/163

e)Tipo de autenticación
PostgreSQL provee diferentes tipos de autenticación, los mas comunes:
Trust <-- permite que se pueda ingresar a la DB sin password
Reject <-- cierra el acceso a una DB o a las direcciones especificadas
Password <-- requiere que se especifique el password del usuario
Ident <-- el usuario a usar debe ser del sistema operativo y debe a la
vez ser usuario de la db, usada en conexiones locales
Ldap <-- para autentificaciones contra un servicio como OpenLdap
Md5, gss, sspi, krb5, radius, cert, pam son de menos uso y requieren
configuraciones de otros servicios (como Ldap).
Cualquier cambio en este archivo requiere reiniciar el servicio del
PostgreSQL.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
19/163

2. Configuración - Archivo postgresql.conf
El archivo “postgresql.conf” contiene los parámetros de configuración del
rendimiento y funcionalidad del dbms, algunos parámetros principales:
listen_addresses = 'localhost' <-- permite especificar si las conexiones a
la db son locales o de red (poner “*”).
Port = 5432 <-- es el puerto TCP que va a escuchar el
Dbms para aceptar conexiones, es posible
Tener diferentes instalaciones en el
Mismo servidor pero especificando
Diferetnes puertos.
max_connections = 100 <-- máximo de conexiones simultaneas que
aceptará el servidor.
shared_buffers = 24MB <-- indica la cantidad de RAM que usa el
Dbms para trabajar las consultas, no
puede ser mayor a el valor guardado en
/proc/sys/kernel/shmmax
Modificar /etc/sysctl.conf añadiendo
kernel.shmmax=[nuevo_valor_en_#entero]
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
20/163

2. Configuración - Archivo postgresql.conf
El archivo “postgresql.conf” contiene los parametros de configuración del
rendimiento y funcionalidad del dbms, algunos parámetros principales:
autovacuum = on <-- activa la “limpieza” de páginas no-activas
en el directorio donde se almacena la data,
tomar en cuenta que este es un “lazy vacuum”
no un “full vacuum” y que los valores de
precisión del vacuum no deben generar
congestión en la base de datos.
lc_messages = 'es_PE.utf8' <-- determina el tipo de “locale” para el
almacenamiento de la data
(internacionalización), por defecto se usa
el mismo del sistema operativo,
recomendación no modificarlo.
Cualquier cambio en este archivo requiere reiniciar el servicio del
PostgreSQL.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
21/163

2. Configuración
Práctica
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
22/163

3. Logs bajo Gnu/Linux
Los logs se configuran en el archivo “postgresql.conf”, por defecto el
directorio de localización de los Logs en CentOS es
“/var/lib/pgsql/data/pg_log”.
log_destination = 'stderr' <-- permite generar el log de la dbms.
Stderr, manda el log a donde se especifique
Syslog, manda el log a /var/log/messages
log_connections = off <-- permite loggear las conexiones que recibe la
Dbms, ayuda mucho a depurar el pg_hba.conf
log_disconnections = off <-- Loggear conexiones cerradas.
log_statement = 'none' <-- permite loggear los querys que procesa la
Dbms.
none, no loggea querys
all, loggea todos los querys, bien o mal
Procesados (ideal para ambiente de
desarrollo)
ddl, loggea los comandos que modifican
Estructuras en la db
mod, loggea los mismos comandos que ddl más
Comandos de movimiento de data
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
23/163

3. Logs bajo Gnu/Linux
log_directory = 'pg_log' <-- directorio pajo /var/lib/pgsql/data donde se
almacenarán los archivos de log, el usuario
“postgres” debe tener derechos de escritura
Sobre el nuevo directorio.
log_filename = 'postgresql-%a.log' <-- nombre del archivo de log.
dbms, ayuda mucho a depurar el pg_hba.conf
log_truncate_on_rotation = on <-- permite generar un nuevo archivo de log
cuando llega a un tamaño determinado o tiene
una antigüedad determinada.
log_rotation_age = 1d <-- antigüedad máxima
log_rotation_size = 0 <-- tamaño máximo en bytes que puede tener el
archivo de log.
log_duration = off <-- permite loggear la duración de la ejecución
de los querys.
log_min_duration_statement = -1 <-- permite loggear la duración de la
ejecución de los querys. (valor 0 para
activar, mayor a 0 solo loggerá el tiempo
de los querys que duren más del tiempo
indicado en milisegundos)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
24/163

3. Logs
Práctica
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
25/163

1. Software de Administración – instalando Rpmforge
Este es un repositorio adicional de CentOS para tener acceso a una
serie de aplicaciones adicionales que nos ayudarán en las
siguientes tareas.
a. Bajar el rpm oficial de Rpmforge de estas direcciones
i686 http://packages.sw.be/rpmforge-release/rpmforge-release-0.5.2-2.el6.rf.i686.rpm
x86_64 http://packages.sw.be/rpmforge-release/rpmforge-release-0.5.2-2.el6.rf.x86_64.rpm
b. Instalar la firma del repositorio
rpm --import http://apt.sw.be/RPM-GPG-KEY.dag.txt
c. Verificar que tenemos la firma correcta
rpm -K rpmforge-release-0.5.2-2.el6.rf.*.rpm
d. Instalar el rpm
rpm -i rpmforge-release-0.5.2-2.el6.rf.*.rpm
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
26/163

1. Software de Administración - PhpPgAdmin
PhpPgAdmin http://phppgadmin.sourceforge.net/
Aplicación Web que nos permite administrar la base de datos, contiene toda
la funcionalidad necesaria para un DBA.
Puede instalarse de “fuentes” o del repositorio de su distribución de Linux
(versiones más antiguas que la última estable), en el caso se CentOS debe
ser descargada.
Requisitos:
- Apache 2
- PHP 5.3 (de preferencia para ejecutar la última versión)
- Librerías de PostgreSQL para la versión de PHP a usar
- SeLinux (en CentOS) genera algunos problemas para conectarse a la base
de datos, para desactivarlo modificar el archivo /etc/selinux/config
mover el parámetro “SELINUX” de “enforcing” a “disabled”.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
27/163

1. Software de Administración - PhpPgAdmin
Archivo de configuración “conf/config.inc.php”.
$conf['servers'][0]['host'] = ''; <-- host ó IP de la dbms
$conf['servers'][0]['port'] = 5432; <-- puerto para conexiones Tcp/Ip
$conf['servers'][0]['sslmode']= allow;<-- Si se tiene conexión SSL, sino
desactivar
$conf['extra_login_security'] = true; <-- indispensable para que no
ingrese alguien a la dbms con los
usuarios clásicos.
$conf['owned_only'] = true; <-- para ver solo los objetos de los
Cuales eres propietario
$conf['show_advanced'] = false; <-- permite ver los objetos avanzados
De la base de datos
$conf['show_system'] = false; <-- permite ver los objetos del
sistema
$conf['show_oids'] = false; <-- permite ver los identificadores
Únicos del sistema
$conf['max_rows'] = 30; <-- cantidad de registros a
visualizar por página en una
consulta
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
28/163

1. Software de Administración - PgAdmin3
PgAdmin3 http://www.pgadmin.org/
Aplicativo GUI que permite una administración y depuración de los objetos
de una dbms PostgreSQL.
Instalar de preferencia desde los repositorios de su distribución de Linux,
en el caso de CentOS la versión de 32 y 64bits puede ser descargada desde
aquí:
http://pkgs.org/centos-6-rhel-6/epel-x86_64/pgadmin3-1.12.2-2.el6.x86_64.rpm.html
La versión actual disponible en Centos 6 de repositorio no oficial es la
1.12 (actual 1.18).
Una de las funcionalidades más importantes es el Debugger para funciones,
pero requiere que se compile desde código fuente un “contrib” adicional
para la base de datos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
29/163

1. Software de Administración - PgAdmin3
a. Descargar el paquete y proceder a instalar:
rpm -i /ruta_rpm/pgadmin3-1.12.2-2.el6.x86_64.rpm
warning: /ruta_rpm/pgadmin3-1.12.2-2.el6.x86_64.rpm:
Header V3 RSA/SHA256 Signature, key ID 0608b895: NOKEY
error: Failed dependencies:
libwx_baseu-2.8.so.0()(64bit) is needed by pgadmin3-1.12.2-2.el6.x86_64
libwx_baseu-2.8.so.0(WXU_2.8)(64bit) is needed by pgadmin3-1.12.2-2.el6.x86_64
libwx_baseu-2.8.so.0(WXU_2.8.5)(64bit) is needed by pgadmin3-1.12.2-2.el6.x86_64
libwx_baseu_net-2.8.so.0()(64bit) is needed by pgadmin3-1.12.2-2.el6.x86_64
.... y varios otros software base más
b. Instalar el paquete wsGTK que importará todas las dependencias
yum install wxGTK
c. Ejecutar paso “a” nuevamente
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
30/163

1. Software de Administración - PSQL
El comando básico para cualquier buen DBA en PostgreSQL es “psql”.
PSQL es un comando de consola que nos permitirá conectarnos a
cualquier servidor PostgreSQL dentro del alcance de nuestra red,
algunos parámetros a tomar en cuenta:
psql BASE_DE_DATOS [opciones]
-h, --host=HOST <-- hostname ó ip del servidor al que se conectará
-p, --port=PUERTO <-- puerto de conexión (5432 por defecto)
-U, --username=USUARIO <-- nombre de usuario
-w, --no-password <-- no solicita contraseña
-W, --password <-- exige ingresar contraseña
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
31/163

psql -U postgres -l <-- Lista las bases de datos del
password for user postgres: servidor sin ingresar a este
List of databases
Name | Owner | Encoding | Collation | 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
Una vez conectado a la base de datos podemos usar “d” para pedir
diferente tipo de información, la más representativa es:
d[S+] list tables, views, and sequences
d[S+] NAME describe table, view, sequence, or index
db[+] [PATTERN] list tablespaces
des[+] [PATTERN] list foreign servers
dew[+] [PATTERN] list foreign-data wrappers
dn[+] [PATTERN] list schemas
dp [PATTERN] list table, view, and sequence access privileges
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
32/163

ds[S+] [PATTERN] list sequences
dt[S+] [PATTERN] list tables
dT[S+] [PATTERN] list data types
du[+] [PATTERN] list roles (users)
dv[S+] [PATTERN] list views
l[+] list all databases
Usar “S” muestra además los datos del sistema que se solicitan en la
consulta, así por ejemplo:
pruebas=# dt
Listado de relaciones
Esquema | Nombre | Tipo | Dueño
---------+--------+-------+----------
public | tabla1 | tabla | postgres
pruebas=# dtS
------------+-------------------------+-------+----------
....... (presenta varias tablas del sistema)
pg_catalog | pg_type | tabla | postgres
pg_catalog | pg_user_mapping | tabla | postgres
(43 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
33/163

1. Software de Administración
Practica
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
35/163

2. SQL para DBAs – Tipos de Datos
a)Tipos de datos numéricos
●smallint
●integer
●bigint
●decimal
●numeric
●Real <-- tomar en cuenta la presición de punto flotante, por ejemplo 10
podría guardarse como 9.9999999E9
●double precision <-- mismo caso que real
●Serial <-- genera automáticamente una “secuencia”, los seriales actualizan
sus datos dependiendo cuantas veces se ejecute un “nextval()” de
la secuencia, si la transacción no se completa se generará un
“hueco” en el contador.
●Bigserial
●Money <-- inserta el símbolo de la moneda por delante, podemos precisar
el símbolo cambiando el “locale” del parámetro lc_monetary en
postgresql.conf
●Booelan <-- true ó false, 1 ó 0
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
36/163

b)Tipos de datos caractér
●character varying() ó varchar(n)
●character(n) ó char(n)
●Text
c) tipo de datos fecha
●timestamp without time zone <-- considere que guardar fecha y tiempo juntos no ayuda
a la formación de querys de búsqueda, por ejemplo:
prueba=# create table tbl_fecha ( fecha timestamp);
prueba=# insert into tbl_fecha values ('2010-01-01');
prueba=# insert into tbl_fecha values ('2010-01-02 01:01:01');
prueba=# select * from tbl_fecha where fecha >= '2010-01-01' and fecha <= '2010-01-02';
fecha
---------------------
2010-01-01 00:00:00
prueba=# select * from tbl_fecha where fecha >= '2010-01-01' and fecha <= '2010-01-02 23:59:59';
fecha
---------------------
2010-01-01 00:00:00
2010-01-02 01:01:01
●timestamp with time zone
●date
●time without time zone
●time with time zone
●interval
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
37/163

d)Tipos direcciones de red
●Cidr <-- solo Ips v.4 ó v.6
●inet <-- Ips v.4 ó v.6 ó hostnames
●Macaddr <-- dirección de identificador único de una NIC
prueba=# create table tbl_inet ( host cidr, hostname varchar(32));
prueba=# insert into tbl_inet values ( '192.168.1.1','192.168.1.1');
INSERT 0 1
ERROR: la sintaxis de entrada no es válida para tipo cidr: «292.168.1.1»
LÍNEA 1: insert into tbl_inet values ( '292.168.1.1','192.168.1.1');
^
INSERT 0 1
e)Tipo de dato NULO
NO es un tipo de datos en si, es una característica que puede tener un tipo de datos
cualquiera y significa que aceptará no tener ningún valor.
OjO:
* En cadenas una cadena vacía o de longitud 0 es diferente que NULL
* En valores numéricos el 0 es diferente que NULL
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
38/163

2. SQL para DBAs - SQL
El SQL de PostgreSQL se puede dividir en 2 tipos, los de comandos
y los “Utility Commands” y los que requieren “Plan de Ejecución”.
Este último grupo son los clásicos Insert, Update, Delete ya que
requieren que el interprete de queries los analice y hasta
reescriba para una mejor optimizar su ejecución, esto se debe a
que “mueven datos”.
El primer grupo corresponde a un conjunto de comandos que actúan
directamente sobre datos, estructuras y objetos de la base de
datos pero que no requieren de un análisis de ejecución,
simplemente se ejecutan tal cual se escriben, por ejemplo CREATE,
DROP, TRUNCATE, ALTER, etc.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
39/163

2. SQL para DBAs – SQL - Create
Nos permite crear un objeto en la base de datos.
Los más usados:
CREATE DATABASE -- create a new database
CREATE DOMAIN -- define a new domain
CREATE FUNCTION -- define a new function
CREATE GROUP -- define a new database role
CREATE INDEX -- define a new index
CREATE LANGUAGE -- define a new procedural language
CREATE OPERATOR -- define a new operator
CREATE ROLE -- define a new database role
CREATE RULE -- define a new rewrite rule
CREATE SCHEMA -- define a new schema
CREATE SEQUENCE -- define a new sequence generator
CREATE TABLE -- define a new table
CREATE TABLE AS -- define a new table from the results of a query
CREATE TABLESPACE -- define a new tablespace
CREATE TRIGGER -- define a new trigger
CREATE TYPE -- define a new data type
CREATE USER -- define a new database role
CREATE VIEW -- define a new view
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
40/163

2. SQL para DBAs – SQL - Create
Los más específicos :
CREATE AGGREGATE -- define a new aggregate function
CREATE CAST -- define a new cast
CREATE CONSTRAINT TRIGGER -- define a new constraint trigger
CREATE CONVERSION -- define a new encoding conversion
CREATE OPERATOR CLASS -- define a new operator class
CREATE OPERATOR FAMILY -- define a new operator family
CREATE SERVER -- define a new foreign server
CREATE FOREIGN DATA WRAPPER -- define a new foreign-data wrapper
CREATE TEXT SEARCH CONFIGURATION -- define a new text search configuration
CREATE TEXT SEARCH DICTIONARY -- define a new text search dictionary
CREATE TEXT SEARCH PARSER -- define a new text search parser
CREATE TEXT SEARCH TEMPLATE -- define a new text search template
CREATE USER MAPPING -- define a new mapping of a user to a foreign server
http://www.postgresql.org/docs/8.4/interactive/sql-commands.html
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
41/163

2. SQL para DBAs – SQL – Create y Alter
Cada create tiene su sintaxis específica, esto depende del tipo de objeto
que estamos creado, en algunos casos como en “create table” la sintaxis
puede ser bastante amplia y compleja y en algunos casos como en “create
database” es más sencilla, depende de la utilidad del objeto.
Alter permite modificar la estructura de un objeto, en general todo objeto
creado puede ser modificado pero no todos sus atributos pueden ser
modificados, así algunas características podrían estar restringidas y será
necesario consultarlo en la documentación, algunas podrían incluso ser
restricciones de integridad de la base de datos, por ejemplo será imposible
borrar una llave primaria en una tabla si es que las referencias que tiene
en otras tablas no son eliminadas previamente.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
42/163

2. SQL para DBAs – SQL – Create y Drop
Create permite crear objetos en la base de datos, básicamente cualquier
objeto puede ser creado con la sintaxis:
Create tipo_de_objeto nombre_de_objeto caracteristicas
create database nombre_objeto
create table nombre_objeto (estructura)
create index nombre_objeto on table nombre_tabla
create view nombre_objeto as sentencia_sql
.... etc.
Drop permite borrar los objetos de una base de datos.
drop database nombre_objeto
drop table nombre_objeto
drop index nombre_objeto
drop view nombre_objeto
... etc.
Drop permitirá eliminar un objeto que no tenga restricciones de integridad
por estar referencia en otra sección de la base de datos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
43/163

2. SQL para DBAs – SQL – Create Database
create database nombre_base_datos
usuario@host:# psql template1 -U USUARIO
Contraseña para usuario USUARIO:
psql (8.4.8)
Digite «help» para obtener ayuda.
template1=# create database prueba2;
CREATE DATABASE
template1=# q
usuario@host:# psql prueba2 -U USUARIO
Contraseña para usuario USUARIO:
psql (8.4.8)
Digite «help» para obtener ayuda.
prueba2=#
* El propietario (owner) de la base de datos es el usuario quien la crea.
* El “encoding” de la base de datos será por defecto el mismo del sistema
Operativo en donde esta instalado PostgreSQL.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
44/163

2. SQL para DBAs – SQL – Create Table
create table nombre_tabla ( nombre_de_campo tipo_de_datos);
prueba2=# create table tablita (campo1 char(10), campo2 int);
CREATE TABLE
prueba2=# dt tablita
---------+---------+-------+---------
public | tablita | tabla | dbadmin
(1 fila)
prueba2=# d tablita
Tabla «public.tablita»
Columna | Tipo | Modificadores
---------+---------------+---------------
campo1 | character(10) |
campo2 | integer |
* El owner de la tabla por defecto es el usuario quien la crea.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
45/163

2. SQL para DBAs – SQL – Create Table
Podemos crear tablas en base a otras tablas a través de una
consulta SELECT.
pruebas=# create table tabla_base (codigo int, nombre char(10));
pruebas=# insert into tabla_base values (1,'A');
* Crear una tabla de un select solo estructura
pruebas=# create table tabla_base1 as select * from tabla_base where 1=2;
pruebas=# select * from tabla_base1;
codigo | nombre
--------+--------
* Crear una tabla de un select con sus datos
pruebas=# create table tabla_base2 as select * from tabla_base;
codigo | nombre
--------+------------
1 | A
* Crear una tabla de un select, solo ciertos campos
pruebas=# create table tabla_base3 as select codigo from tabla_base;
codigo
--------
1
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
46/163

2. SQL para DBAs – SQL - Insert
Insert into nombre_tabla (campos, ..) values ( valores, ..);
Insert into nombre_tabla values (valores, ..);
prueba2=# insert into tablita (campo1, campo2) values ('cadena1', 1);
INSERT 0 1
prueba2=# insert into tablita values ('cadena2', 2);
INSERT 0 1
prueba2=# insert into tablita values (2, 'cadena2');
ERROR: la sintaxis de entrada no es válida para integer: «cadena2»
LÍNEA 1: insert into tablita values (2, 'cadena2');
prueba2=# insert into tablita values ('cadena3');
INSERT 0 1
* Si no se especifica el orden en que debe insertarse los datos entonces
se corre el riesgo de que los tipos de datos no concuerden y no se
grabe los datos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
47/163

* No es necesario que se llenen todos los campos de una tabla, a menos que
tengan la restricción NOT NULL
prueba2=# create table tablita2 (campo1 char(10), campo2 int not null);
CREATE TABLE
prueba2=# insert into tablita2 (campo1, campo2) values ('texto', 2);
INSERT 0 1
prueba2=# insert into tablita2 (campo1) values ('texto');
ERROR: el valor null para la columna «campo2» viola la restricción not null
prueba2=# insert into tablita2 (campo1, campo2) values ('texto', 0);
INSERT 0 1
prueba2=# insert into tablita2 (campo1, campo2) values ('texto', null);
prueba2=# insert into tablita2 (campo1, campo2) values (null, 3);
INSERT 0 1
prueba2=# insert into tablita2 (campo1, campo2) values ('A', 10), ('B', 20); <-- puede añadir
INSERT 0 2 tantos datos
sea necesario
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
48/163

Cuando trabajamos con tablas con el tipo de datos “SERIAL” es posible
retornar el valor autoincremental de este luego que se ejecuta un insert.
prueba=# create table tbl_simple ( id serial, nombre varchar(10));
NOTICE: CREATE TABLE creará una secuencia implícita «tbl_simple_id_seq» para la columna serial
«tbl_simple.id»
CREATE TABLE
prueba=# insert into tbl_simple (nombre) values ('ernesto') returning id;
id
----
1
prueba=# insert into tbl_simple (nombre) values ('juan') returning id;
id
----
2
prueba=# insert into tbl_simple (nombre) values ('estosupera10caracteres') returning id;
ERROR: el valor es demasiado largo para el tipo character varying(10)
prueba=# insert into tbl_simple (nombre) values ('10chars') returning id;
id
----
3
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
49/163

Es posible ejecutar una inserción de datos desde una consulta del tipo
“Select”.
prueba=# create table tbl_simple2 ( id serial, nombre varchar(10));
NOTICE: CREATE TABLE creará una secuencia implícita «tbl_simple2_id_seq» para la columna serial
«tbl_simple2.id»
CREATE TABLE
prueba=# insert into tbl_simple2 ( nombre) select nombre from tbl_simple;
INSERT 0 4
prueba=# select * from tbl_simple2;
id | nombre
----+---------
1 | ernesto
2 | juan
3 | 111
4 | 10chars
(4 filas)
prueba=# insert into tbl_simple2 ( nombrE) select nombre from tbl_simple returning id;
id
----
5
6
7
8
(4 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
50/163

2. SQL para DBAs – SQL – Llaves primarias
Una Llave primaria es uno o más campos que determinan un valor único en una
tabla, no pueden haber 2 iguales o ser nulo (null), una tabla solo puede tener
una llave primaria.
prueba2=# create table tablita3 (campo1 int primary key, campo2 float);
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «tablita3_pkey»
para la tabla «tablita3»
CREATE TABLE
prueba2=# d tablita3;
Tabla «public.tablita3»
---------+------------------+---------------
campo1 | integer | not null
campo2 | double precision |
Índices:
"tablita3_pkey" PRIMARY KEY, btree (campo1)
prueba2=# insert into tablita3 (campo1, campo2) values (1,2);
INSERT 0 1
INSERT 0 1
ERROR: llave duplicada viola restricción de unicidad «tablita3_pkey»
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
51/163

2. SQL para DBAs – SQL – Llaves primarias
prueba2=# create table tablita4 (campo1 int , campo2 int, campo3 float, constraint pk_tablita4
primary key (campo1, campo2));
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «pk_tablita4» para la tabla
«tablita4»
CREATE TABLE
prueba2=# d tablita4;
Tabla «public.tablita4»
---------+------------------+---------------
campo3 | double precision |
Índices:
"pk_tablita4" PRIMARY KEY, btree (campo1, campo2)
prueba2=# insert into tablita4 (campo1, campo2, campo3) values (1,1,2);
INSERT 0 1
INSERT 0 1
ERROR: llave duplicada viola restricción de unicidad «pk_tablita4»
ERROR: llave duplicada viola restricción de unicidad «pk_tablita4»
prueba2=# insert into tablita4 (campo1, campo2, campo3) values (1,null,4);
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
52/163

2. SQL para DBAs – SQL – Llaves Foraneas
Una llave foránea obliga que el valor que se almacena en un campo de una tabla este
obligatoriamente registrado como parte de la llave primaria de una tabla “maestra”
para poder ser aceptado, a esto se le llama integridad referencial.
prueba2=# create table maestro (campo1 int primary key, campo2 int);
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «maestro_pkey» para la tabla «maestro»
CREATE TABLE
prueba2=# create table detalle (campoA int primary key, campoB int, constraint fk_detalle foreign key
(campo) references maestro (campo2));
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «detalle_pkey» para la tabla «detalle»
ERROR: no hay restricción unique que coincida con las columnas dadas en la tabla referida «maestro»
prueba2=# create table detalle (campoA int primary key, campoB int, constraint fk_detalle foreign key
(campoB) references maestro (campo1));
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «detalle_pkey» para la tabla «detalle»
CREATE TABLE
prueba2=# d detalle
Tabla «public.detalle»
---------+---------+---------------
campoa | integer | not null
campob | integer |
Índices:
"detalle_pkey" PRIMARY KEY, btree (campoa)
Restricciones de llave foránea:
"fk_detalle" FOREIGN KEY (campob) REFERENCES maestro(campo1)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
53/163

2. SQL para DBAs – SQL – Llaves Foraneas
prueba2=# insert into detalle (campoA, campoB) values (1,2);
ERROR: inserción o actualización en la tabla «detalle» viola la llave foránea «fk_detalle»
DETALLE: La llave (campob)=(2) no está presente en la tabla «maestro».
prueba2=# insert into maestro (campo1) values (2);
INSERT 0 1
INSERT 0 1
ERROR: inserción o actualización en la tabla «detalle» viola la llave foránea «fk_detalle»
DETALLE: La llave (campob)=(1) no está presente en la tabla «maestro».
prueba2=# insert into detalle1_1 (campoA, campoB) values (2,null);
INSERT 0 1
Eventualmente la referencia puede hacerse con un campo UNIQUE en la tabla maestra, un
campo UNIQUE es como una llave primaria, no puede tener valores duplicados.
prueba2=# create table maestro1 (campo1 int unique);
NOTICE: CREATE TABLE / UNIQUE creará el índice implícito «maestro1_campo1_key» para la tabla
«maestro1»
CREATE TABLE
prueba2=# create table detalle1 (campoA int primary key, campoB int, constraint fk_detalle1
foreign key (campoB) references maestro1 (campo1));
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «detalle1_pkey» para la tabla
«detalle1»
CREATE TABLE
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
54/163

2. SQL para DBAs – SQL – Select
El comando SELECT permite ejecutar una consulta en una tabla.
prueba2=# select * from tablita4;
campo1 | campo2 | campo3
--------+--------+--------
1 | 1 | 2
1 | 2 | 2
(2 filas)
prueba2=# select campo1, campo3 from tablita4;
campo1 | campo3
--------+--------
1 | 2
1 | 2
(2 filas)
Se puede pedir todos los campos de una tabla con “*” o solo los que nos interesa detallando todos
estosn entre “SELECT” y “FROM”.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
55/163

2. SQL para DBAs – SQL – Select - Joins
Es posible unir el resultado de 2 tablas utilizando los “joins”, en sus formas más
básicas tenemos 2 opciones Join, Left Join y Right Join.
prueba2=# create table maestro ( codigo int, nombre varchar(100));
CREATE TABLE
prueba2=# create table detalle ( correlativo int, codigo int, descripción varchar(100));
CREATE TABLE
^
prueba2=# insert into maestro values (1, 'plan a');
INSERT 0 1
prueba2=# insert into maestro values (2, 'plan b');
INSERT 0 1
prueba2=# insert into maestro values (3, 'plan c');
INSERT 0 1
^
prueba2=# insert into detalle values (1, 1, 'detalle 1');
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 1
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
56/163

prueba2=# select * from detalle <-- lista todo lo de “detalle” aunque no se
left join maestro on maestro.codigo = detalle.codigo; intersecte con “maestro”
-------------+--------+-------------+--------+--------
4 | 4 | detalle 4 | |
5 | 4 | detalle 5 | |
(5 filas)
prueba2=# select * from detalle <-- lista todo lo de “maestro” aunque no se
right join maestro on maestro.codigo = detalle.codigo; intersecte con “detalle”
-------------+--------+-------------+--------+--------
| | | 3 | plan c
(4 filas)
Se pueden hacer “joins” entre 2 ó más tablas, pueden mezclarse los diversos tipos de
joins presentados cuando se involucran consultas de muchas tablas.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
58/163

2. SQL para DBAs – SQL – Select – Alias
Es posible en una consulta colocar alias a los campos y a las tablas para mejorar los resultados de
las consultas y eventualmente las uniones de tablas.
prueba2=# select codigo as Cmaestro, nombre Nmaestro from maestro;
cmaestro | nmaestro
----------+----------
1 | plan a
2 | plan b
3 | plan c
(3 filas)
prueba2=# select maestro.codigo as Cmaestro, nombre Nmaestro from maestro
join detalle b on b.codigo = maestro.codigo;
cmaestro | nmaestro
----------+----------
1 | plan a
1 | plan a
2 | plan b
(3 filas)
prueba2=# select maestro.codigo as Cmaestro, nombre Nmaestro, b.codigo as Dmaestro from maestro
cmaestro | nmaestro | dmaestro
----------+----------+----------
1 | plan a | 1
1 | plan a | 1
2 | plan b | 2
(3 filas)
prueba2=# select maestro.codigo as Cmaestro, nombre Nmaestro, codigo as Dmaestro from maestro
ERROR: la referencia a la columna «codigo» es ambigua
LÍNEA 1: ...lect maestro.codigo as Cmaestro, nombre Nmaestro, codigo as ...
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
59/163

2. SQL para DBAs – SQL – Select – Distinct
Permite generar un resultado de datos único al realizar una consulta.
prueba2=# create table tablaA (campo1 int, campo2 varchar(10));
prueba2=# insert into tablaA values (1, 'A');
prueba2=# insert into tablaA values (2, 'A');
prueba2=# insert into tablaA values (2, 'B');
prueba2=# insert into tablaA values (2, 'B');
prueba2=# insert into tablaA values (1, 'C');
prueba2=# select * from tablaA;
campo1 | campo2
--------+--------
1 | A
2 | A
2 | B
2 | B
1 | C
(5 filas)
prueba2=# select distinct * from tablaa;
campo1 | campo2
--------+--------
2 | A
1 | C
1 | A
2 | B
(4 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
60/163
prueba2=# select distinct campo1 from tablaa;
campo1
--------
1
2
(2 filas)

2. SQL para DBAs – SQL – Select – Where
La clausula WHERE nos permitirá filtrar los datos que debe devolver la
consulta.
prueba2=# select * from tablaA where campo2 = 'A';
campo1 | campo2
--------+--------
1 | A
2 | A
(2 filas)
prueba2=# select * from tablaA where campo2 = '';
campo1 | campo2
--------+--------
(0 filas)
prueba2=# insert into tablaA values (1, null);
INSERT 0 1
prueba2=# select * from tablaA where campo2 = null; <-- los campos con tipo de datos “null” requieren
campo1 | campo2 una sintaxis especial
--------+--------
(0 filas)
prueba2=# select * from tablaA where campo2 is null;
campo1 | campo2
--------+--------
1 |
(1 fila)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
61/163

WHERE nos permite manejar operadores lógicos, los más usados son AND, OR y operadores
de precisión como =, !=, <, <=, >, >= (hay muchos otros operadores lógicos y de
precisión que se detallarán más adelante)
prueba2=# select * from maestro a , detalle b where a.codigo = b.codigo and correlativo < 3;
codigo | nombre | correlativo | codigo | descripción
--------+--------+-------------+--------+-------------
(2 filas)
prueba2=# select * from detalle where codigo < 3 or descripción = 'detalle 5';
-------------+--------+-------------
1 | 1 | detalle 1
2 | 1 | detalle 2
3 | 2 | detalle 3
5 | 4 | detalle 5
(4 filas)
Podemos agrupar los operadores entre ( )
prueba2=# select * from detalle where codigo = 2 and codigo = 1 or descripción = 'detalle 5';
-------------+--------+-------------
5 | 4 | detalle 5
(1 fila)
prueba2=# select * from detalle where codigo = 2 and (codigo = 1 or descripción = 'detalle 5');
-------------+--------+-------------
(0 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
63/163

2. SQL para DBAs – SQL – Select – Union
UNION nos permite unir los resultados de 2 consultas, como restricción los resultados
deben coincidir en tipo de datos para las columnas especificadas en cada consulta.
campo1 | campo2
--------+--------
1 | A
2 | A
2 | B
2 | B
1 | C
1 |
^
prueba2=# select campo1, campo2 from tablaA where campo1 = 1
union
select campo1, campo2 from tablaA where campo2 = 'B';
campo1 | campo2
--------+--------
1 | A
2 | B
1 | C
1 |
prueba2=# select campo1, campo2 from tablaA where campo1 = 1
union all
select campo1, campo2 from tablaA where campo2 = 'B';
campo1 | campo2
--------+--------
1 | A
1 | C
1 |
2 | B
2 | B
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
64/163

2. SQL para DBAs – SQL – Select – Intersec y Except
Como UNION unen 2 o más consultas, pero en este caso con INTERSEC se
mostrarán en el resultado solo aquellos datos que coincidan entre ambas
consultas y en EXCEPT los que no coincidan.
pruebas=# select * from tablaA;
campo1 | campo2
--------+--------
1 | A
2 | A
2 | B
2 | B
1 | C
1 |
pruebas=# select campo1, campo2 from tablaA
intersect
select campo1, campo2 from tablaA where campo1=2;
campo1 | campo2
--------+--------
2 | B
2 | A
pruebas=# select campo1, campo2 from tablaA
except
select campo1, campo2 from tablaA where campo1=2;
campo1 | campo2
--------+--------
1 | C
1 | A
1 |
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
65/163

2. SQL para DBAs – SQL – Select – GROUP BY
GROUP nos permite agrupar los resultados de una consulta, generalmente se usa en operaciones matemáticas
como suma, promedio, mayor valor, menor valor, etc.
campo1 | campo2
--------+--------
1 | A
2 | A
2 | B
2 | B
1 | C
1 |
prueba2=# select sum(campo1), avg(campo1), campo2 from tablaA group by campo2;
sum | avg | campo2
-----+------------------------+--------
1 | 1.00000000000000000000 |
4 | 2.0000000000000000 | B
1 | 1.00000000000000000000 | C
3 | 1.5000000000000000 | A
prueba2=# select min(campo1), max(campo1), campo2 from tablaA group by campo2;
min | max | campo2
-----+-----+--------
1 | 1 |
2 | 2 | B
1 | 1 | C
1 | 2 | A
* GROUP siempre requerirá que el campo especificado en “group by” sea parte de los
resultados de la consulta.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
66/163

2. SQL para DBAs – SQL – Select – GROUP BY y HAVING
HAVING dentro de un GROUP nos permite filtrar los resultados de la consulta operando
funciones en el filtro.
codigo | nombre
--------+--------
1 | plan a
2 | plan b
3 | plan c
3 | plan c
prueba2=# select codigo, sum(codigo) , count(*) from maestro where sum(codigo) > 1 group by codigo;
ERROR: no se permiten funciones de agregación en la cláusula WHERE
LÍNEA 1: ...odigo, sum(codigo) , count(*) from maestro where sum(codigo...
prueba2=# select codigo, sum(codigo) , count(*) from maestro group by codigo having sum(codigo) > 1;
codigo | sum | count
--------+-----+-------
3 | 6 | 2
2 | 2 | 1
(2 filas)
prueba2=# select codigo, sum(codigo) , count(*), nombre from maestro group by codigo, nombre having
sum(codigo) > 1;
codigo | sum | count | nombre
--------+-----+-------+--------
3 | 6 | 2 | plan c
2 | 2 | 1 | plan b
(2 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
67/163

2. SQL para DBAs – SQL – Select – ORDER BY, LIMIT y OFFSET
ORDER BY nos permite ordenar el resultado de nuestra consulta de manera ASCendente y
DESCendente, en vez de indicar el nombre del campo de ordenamiento también podríamos
simplemete referencias el número de su posición.
codigo | nombre
--------+--------
1 | plan a
2 | plan b
3 | plan c
3 | plan c
1 | plan a
prueba2=# select * from maestro order by nombre asc;
codigo | nombre
--------+--------
1 | plan a
1 | plan a
2 | plan b
3 | plan c
3 | plan c
prueba2=# select codigo, nombre from maestro order by 2 desc;
codigo | nombre
--------+--------
3 | plan c
3 | plan c
2 | plan b
1 | plan a
1 | plan a
* OjO PostgreSQL presenta los datos conforme los obtiene al armar el resultado de la
consulta, sin un ordenamiento entonces el resultado podría ser aleatorio.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
68/163

2. SQL para DBAs – SQL – Select – ORDER BY, LIMIT y OFFSET
LIMIT permite restringir la cantidad de registros a presentar en una
consulta y OFFSET permite indicar a partir de que posición de resultado
presentar el resultado, son efectivos solo si se usan con ORDER BY.
prueba2=# select * from maestro order by codigo;
codigo | nombre
--------+--------
1 | plan a
1 | plan a
2 | plan b
3 | plan c
3 | plan c
(5 rows)
prueba2=# select * from maestro order by codigo limit 2;
codigo | nombre
--------+--------
1 | plan a
1 | plan a
(2 rows)
prueba2=# select * from maestro order by codigo limit 2 offset 2;
codigo | nombre
--------+--------
2 | plan b
3 | plan c
(2 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
69/163

2. SQL para DBAs – SQL – Select – SUBQUERYS
prueba2=# select a.correlativo, a.descripción, a.codigo,
( select b.nombre from maestro b where b.codigo = a.codigo) as nombre_maestro from detalle a;
correlativo | descripción | codigo | nombre_maestro
-------------+-------------+--------+----------------
1 | detalle 1 | 1 | plan a
2 | detalle 2 | 1 | plan a
3 | detalle 3 | 2 | plan b
4 | detalle 4 | 4 |
5 | detalle 5 | 4 |
prueba2=# select a.correlativo, a.descripción,
( select sum(b.codigo) from maestro b ) total_codigo,
( select c.codigo from maestro c where a.codigo = c.codigo) as codigo from detalle a;
correlativo | descripción | total_codigo | codigo
-------------+-------------+--------------+--------
1 | detalle 1 | 6 | 1
2 | detalle 2 | 6 | 1
3 | detalle 3 | 6 | 2
4 | detalle 4 | 6 |
5 | detalle 5 | 6 |
prueba2=# select correlativo, descripción, total_codigo, codigo, total_codigo/codigo as division
from (select a.correlativo, a.descripción,
( select sum(b.codigo) from maestro b ) total_codigo,
( select c.codigo from maestro c where a.codigo = c.codigo) as codigo
from detalle a)
as tabla_temporal;
correlativo | descripción | total_codigo | codigo | division
-------------+-------------+--------------+--------+----------
1 | detalle 1 | 6 | 1 | 6
2 | detalle 2 | 6 | 1 | 6
3 | detalle 3 | 6 | 2 | 3
4 | detalle 4 | 6 | |
5 | detalle 5 | 6 | |
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
71/163

pruebas=# update maestro set nombre = 'A-' || nombre;
UPDATE 5
pruebas=# select * from maestro;
codigo | nombre
--------+----------
1 | A-plan a
2 | A-plan b
3 | A-plan c
3 | A-plan c
1 | A-plan a
(5 filas)
pruebas=# update maestro set nombre = 'B-' || (select nombre from maestro a where maestro.codigo =
a.codigo limit 1);
UPDATE 5
codigo | nombre
--------+------------
1 | B-A-plan a
2 | B-A-plan b
3 | B-A-plan c
3 | B-A-plan c
1 | B-A-plan a
(5 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
73/163

pruebas=# select * from maestro2;
codigo | nombre
--------+--------
1 | C1
2 | C2
3 | C3
3 | C3
1 | C1
pruebas=# update maestro set nombre = a.nombre from (select codigo, nombre from maestro2) as a where
maestro.codigo = a.codigo;
UPDATE 5
pruebas=# select * from maestro2;
codigo | nombre
--------+--------
1 | C1
2 | C2
3 | C3
3 | C3
1 | C1
Un UPDATE puede retornar un set de datos al estilo de una consulta usando el comando
RETURNING
pruebas=# update maestro set nombre = 'D-' || a.nombre from (select codigo, nombre from maestro2) as a where
maestro.codigo = a.codigo returning maestro.*;
codigo | nombre
--------+--------
1 | D-C1
1 | D-C1
2 | D-C2
3 | D-C3
3 | D-C3
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
74/163

2. SQL para DBAs – SQL – Delete
Podemos llevar a cabo un DELETE haciendo un WHERE que involucre a otra tabla usando USING, el uso de
RETURNING también es válido en DELETE como en el UPDATE.
codigo | nombre
--------+--------
1 | D-C1
1 | D-C1
2 | D-C2
3 | D-C3
3 | D-C3
(5 filas)
pruebas=# delete from maestro using maestro2 where maestro.codigo = maestro2.codigo and maestro2.codigo > 2;
DELETE 2
pruebas=# delete from maestro using maestro2 where maestro.codigo = maestro2.codigo returning maestro.*;
codigo | nombre
--------+--------
1 | D-C1
1 | D-C1
2 | D-C2
(3 filas)
DELETE 3
codigo | nombre
--------+--------
(0 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
76/163

2. SQL para DBAs – SQL – Truncate
Permite eliminar todos los datos de una tabla, se diferencia de DELETE en
que esta sentencia es “command utility”, se ejecuta directamente y es mucho
más conveniente cuando el borrado debe ser masivo, demora mucho menos que
un DELETE sin filtro WHERE.
codigo | nombre
--------+--------
1 | plan a
2 | plan b
3 | plan c
3 | plan c
1 | plan a
(5 rows)
prueba2=# truncate maestro;
TRUNCATE TABLE
(0 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
77/163

2. SQL para DBAs – SQL – Create View
Permite crear una “VISTA”, esto es un representación solo de consulta de
los datos de una tabla o un conjunto de tablas relacionadas.
codigo | nombre
--------+--------
1 | plan a
2 | plan b
3 | plan c
3 | plan c
1 | plan a
(5 rows)
prueba2=# truncate maestro;
TRUNCATE TABLE
(0 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
78/163

2. SQL para DBAs – SQL – Copy
Copy es una excelente alternativa cuando debemos cargar información de millares de
registros en una tabla, es mucho más eficiente que hacer varios insert o un insert de
un select.
Copy además nos permite generar un archivo con datos de una tabla o de una consulta.
prueba=# copy tbl_simple2 to '/tmp/uno.txt';
COPY 8
prueba=# copy tbl_simple2(nombre) to '/tmp/uno.txt';
COPY 8
prueba=# copy (select * from tbl_simple2) to '/tmp/uno.txt';
COPY 8
prueba=# copy (select * from tbl_simple2) to stdin;
1 321ernesto
2 321juan
3 321111
4 32110chars
5 321ernesto
6 321juan
7 321111
8 32110chars
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
79/163

2. SQL para DBAs – SELECTs Avanzados - OVER
POSTGRESQL > 9.0
prueba=# select * from tbl_window;
mes | nombre | sueldo
--------+---------+--------
201001 | ernesto | 10
201002 | ernesto | 11
201003 | ernesto | 12
201001 | juan | 13
201003 | juan | 15
201002 | juan | 14
prueba=# select nombre, mes, sueldo, sum(sueldo) as sueldo_total over (partition by nombre) from tbl_window;
nombre | mes | sueldo | sueldo_total
---------+--------+--------+-------------
ernesto | 201001 | 10 | 33
ernesto | 201002 | 11 | 33
ernesto | 201003 | 12 | 33
juan | 201001 | 13 | 42
juan | 201003 | 15 | 42
juan | 201002 | 14 | 42
prueba=# select nombre, mes, sueldo, sum(sueldo) over (partition by nombre) sueldo_total, sum(sueldo) over (partition by
nombre) / 3 as sueldo_promedio, (sum(sueldo) over (partition by nombre) / 3 )- sueldo as desviacion_promedio from
tbl_window;
nombre | mes | sueldo | sueldo_total | sueldo_promedio | desviacion_promedio
---------+--------+--------+--------------+-----------------+---------------------
ernesto | 201001 | 10 | 33 | 11 | 1
ernesto | 201002 | 11 | 33 | 11 | 0
ernesto | 201003 | 12 | 33 | 11 | -1
juan | 201001 | 13 | 42 | 14 | 1
juan | 201003 | 15 | 42 | 14 | -1
juan | 201002 | 14 | 42 | 14 | 0
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
81/163

2. SQL para DBAs – SELECTs Avanzados - OVER
POSTGRESQL > 9.0
prueba=# select nombre, mes, sueldo, sum(sueldo) over (partition by nombre order by nombre desc, mes ) from tbl_window;
nombre | mes | sueldo | sum
---------+--------+--------+-----
juan | 201001 | 13 | 13
juan | 201002 | 14 | 27
juan | 201003 | 15 | 42
ernesto | 201001 | 10 | 10
ernesto | 201002 | 11 | 21
ernesto | 201003 | 12 | 33
prueba=# select nombre, mes, sueldo, rank() over (partition by nombre order by sueldo desc) from tbl_window;
nombre | mes | sueldo | rank
---------+--------+--------+------
ernesto | 201003 | 12 | 1
ernesto | 201002 | 11 | 2
ernesto | 201001 | 10 | 3
juan | 201003 | 15 | 1
juan | 201002 | 14 | 2
juan | 201001 | 13 | 3
prueba=# select nombre, sueldo, mes, sum(sueldo) over ventana, avg(sueldo) over ventana from tbl_window window ventana
as (partition by nombre);
nombre | sueldo | mes | sum | avg
---------+--------+--------+-----+---------------------
ernesto | 10 | 201001 | 33 | 11.0000000000000000
ernesto | 11 | 201002 | 33 | 11.0000000000000000
ernesto | 12 | 201003 | 33 | 11.0000000000000000
juan | 13 | 201001 | 42 | 14.0000000000000000
juan | 15 | 201003 | 42 | 14.0000000000000000
juan | 14 | 201002 | 42 | 14.0000000000000000
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
82/163

2. SQL para DBAs – SELECTs Avanzados – FETCH y LIMIT
prueba=# select * from tbl_simple2 fetch first 3 rows only;
id | nombre
----+------------
1 | 321ernesto
2 | 321juan
3 | 321111
(3 filas)
prueba=# select * from tbl_simple2 limit 3;
id | nombre
----+------------
1 | 321ernesto
2 | 321juan
3 | 321111
(3 filas)
A simple vista parecen iguales, pero en el caso de Limit en siguientes ocasiones donde
se ejecute el query el orden en el que tome los datos no necesariamente será el mismo
(en el que se almacenaron en la db) a menos que se use un ORDER BY, para FETCH el
orden siempre sera igual.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
84/163

2. SQL para DBAs – SELECTs Avanzados - FOR UPDATE / FOR SHARE
FOR UDATE bloqueda el acceso a los registros que se solicitan de tal manera que el
query no desbloqueara los registros hasta que haya culminado la transacción en curso.
prueba=# select * from tbl_simple2 limit 2 for update;
FOR SHARE permite que se modifiquen los datos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
85/163

2. SQL para DBAs – SELECTs Avanzados - WITH
Facilitamos el trabajo de subquerys definiendolo para ser usados varias veces.
prueba=# select * from tbl_simple2;
id | nombre
----+---------
10 | ernesto
20 | juan
12 | pedro
12 | ernesto
prueba=# select nombre, sum(id) from tbl_simple2 group by nombre;
nombre | sum
---------+-----
pedro | 12
ernesto | 22
juan | 20
prueba=# with suma as ( select nombre, sum(id) from tbl_simple2 group by nombre order by 2 desc limit 2) select nombre,
id from tbl_simple2 where nombre in (select nombre from suma);
nombre | id
---------+----
ernesto | 10
juan | 20
ernesto | 12
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
86/163

2. SQL para DBAs – SELECTs Avanzados - SIMILAR TO
Hacemos búsquedas por expresiones regulares
prueba4=# select * from log_regla;
           fecha            | id |   nombre   | estado
+++
20101008 20:26:37.200866 |  2 | Ernesto    | I
20101008 20:49:24.691783 |  8 | pedro      | I
20101008 21:00:08.529349 |  1 | alejandro  | U
20101008 21:21:55.82194  |  5 | pepelucho  | U
prueba4=# select * from log_regla where nombre similar to '%(a|c)%';  < contiene a ó c
+++
20101008 21:00:08.529349 |  1 | alejandro  | U
20101008 21:21:55.82194  |  5 | pepelucho  | U
prueba4=# select * from log_regla where nombre similar to '%(x|f)%';
+++
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
87/163

2. SQL para DBAs – SELECTs Avanzados - SIMILAR TO
prueba4=# select * from log_regla where nombre similar to '(d|f)%'; < inicia con d ó f
+++
(0 rows)
prueba4=# select * from log_regla where nombre similar to '(p|f)%';
+++
20101008 20:49:24.691783 |  8 | pedro      | I
20101008 20:49:43.711889 |  9 | pedro      | I
20101008 21:21:55.82194  |  5 | pepelucho  | U
20101008 21:22:06.759216 |  5 | pepelucho1 | U
prueba4=# select * from log_regla where nombre similar to '[az]{5}'; < alfabéticos de al menos
           fecha            | id | nombre | estado                        5 letras
+++
20101008 20:49:24.691783 |  8 | pedro  | I
20101008 20:49:43.711889 |  9 | pedro  | I
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
88/163

2. SQL para DBAs – Actualizaciones en Cascada
Cuando existen referencias entre tablas y es necesario modificar o
actualizar datos en las tablas “padrea” tenemos que tener mucho cuidado con
el impacto que podemos tener en las tablas “hijas”, no es buena idea
activar las actualizaciones en cascada por defecto porque podrían
generarnos un problema terrible.
pruebas=# create table padre ( id int primary key);
pruebas=# create table hija1 ( idH int, idP int, constraint llave_foranea foreign key (idP)
references padre (id));
pruebas=# insert into padre values (1), (2);
pruebas=# insert into hija1 values (1,1);
pruebas=# delete from padre where id = 1;
ERROR: update o delete en «padre» viola la llave foránea «llave_foranea» en la tabla «hija1»
http://www.postgresql.org/docs/8.4/interactive/sqlcreatetable.html
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
89/163

pruebas=# drop table hija1;
references padre (id) ON DELETE CASCADE);
pruebas=# select * from padre;
id

  1
  2
pruebas=# delete from padre where id = 1 ;
DELETE 1
id

  2
(1 fila)
pruebas=# select * from hija2;
idh | idp
+
   1 |   2
(1 fila)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
90/163

pruebas=# update padre set id = 3 where id = 2;
ERROR:  update o delete en «padre» viola la llave foránea «llave_foranea» en la tabla «hija2»
DETALLE:  La llave (id)=(2) todavía es referida desde la tabla «hija2».
pruebas=# drop table hija2;
references padre (id) ON DELETE CASCADE on update cascade);

idh | idp
+
   1 |   2
   2 |   2
id

  2
pruebas=# update padre set id = 3 where id = 2;
idh | idp
+
   1 |   3
   2 |   3
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
91/163

Borrar tablas unidas por referencias(constraints) esta prohibido hasta que
no se elimine la dependencia o en todo caso se ejecute con el atributo
“CASCADE”.
idh | idp
+
   1 |   3
   2 |   3
(2 filas)
pruebas=# drop table padre;
ERROR:  no se puede eliminar tabla padre porque otros objetos dependen de él
DETALLE:  restricción «llave_foranea» en tabla hija3 depende de tabla padre
SUGERENCIA:  Use DROP ... CASCADE para eliminar además los objetos dependientes.
pruebas=# drop table padre cascade;
NOTICE:  eliminando además restricción «llave_foranea» en tabla hija3
DROP TABLE
idh | idp
+
   1 |   3
   2 |   3
(2 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
92/163

1. Objetos de la DB
PostgreSQL permite crear objetos comunes de una base de datos tales como:
●Base datos
●Tablas
●Vistas
●Schemas
●Usuarios
●Grupos
●Roles
●Funciones (que sería un simil a store procedures)
●Triggers
●Rules
●Etc, etc.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
93/163

1. Objetos de la DB - Base datos
● Si puede hacer por consola del OS usando “createdb” o desde consola de
PostgreSQL (psql) usando “create database”.
● Podemos especificar quien será el owner de la db, si no se especifica por
defecto el owner es el usuario que la esta creando.
● Desde la versión 8.3 PostgreSQL se une fuertemente con el Locate del OS,
si no se especifica el encoding o el locate se asumirá el del OS
● La db asume la estructura de una db “template”, esta es por defecto la db
“template1”, podemos usar cualquier db como template siempre y cuando no
exista ningún usuario logeado en ella, se recomienda no cambiar la
estructura de template1, solo se copia estructura y no data.
CREATE DATABASE name
[ [ WITH ] [ OWNER [=] user_name ]
[ TEMPLATE [=] template ]
[ ENCODING [=] encoding ]
[ LC_COLLATE [=] lc_collate ]
[ LC_CTYPE [=] lc_ctype ]
[ TABLESPACE [=] tablespace ]
[ CONNECTION LIMIT [=] connlimit ] ]
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
94/163

1. Objetos de la DB - Base datos
Teóricamente no hay problemas de recibir data en Latin1 (ASCii) en una db UTF8, solo
es necesario hacer esto:
ALTER DATABASE base_de_datos SET client_encoding TO 'latin1';
Para cambiar el encoding de toda la db:
update pg_database set encoding=8 where datname=’base_de_datos’;
Para ver la tabla de códigos completa: http://www.lscvsystems.com/blog/?p=32
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
95/163

1. Objetos de la DB - Types
Los Types son estructuras de datos definidas por el usuario, además de los ejemplos especificados en las
láminas 35 a 37 también podemos:
a) Types de datos enumerados
template1=# create type mes as enum ('enero', 'febrero', 'marzo');
CREATE TYPE
template1=# create table tbl_mes ( fecha mes);
CREATE TABLE
template1=# insert into tbl_mes values ('enero');
INSERT 0 1
template1=# insert into tbl_mes values ('abril');
ERROR: la sintaxis de entrada no es válida para el enum mes: «abril»
LÍNEA 1: insert into tbl_mes values ('abril');
El orden de los enumerados en caso de aplicar al campo un “order by” es el orden en el
que fueron declarados los valores.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
96/163

b) Types de retorno de estructura de datos
template1=# create type tpy_cuenta as( cmp_cuenta char(10));
CREATE TYPE
template1=# create function fn_cuenta () returns setof tpy_cuenta as $$ select cuenta from tbl_padre
$$ language sql;
CREATE FUNCTION
template1=# select fn_cuenta();
fn_cuenta
----------------
("00.01 ")
("10.01 ")
("10.02 ")
("40.01 ")
("540.01 ")
(5 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
97/163

Crear una tabla de un Type nos ayuda a tener estructuras pre-construidas para los
datos.
prueba4=# create type tpy_usuario as (id integer, password char(25), nombre
varchar(100));
prueba4=# create table tbl_usuario of tpy_usuario;
prueba4=# select * from tbl_usuario;
id | password | nombre
++
(0 rows)
prueba4=# drop type tpy_usuario cascade;
NOTICE:  drop cascades to table tbl_usuario
DROP TYPE
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
98/163
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
98/163
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
98/163

1. Objetos de la DB – Types
Un campo de la tabla puede tener la estructura de un Type.
prueba4=# create table tbl_usuario2 ( id serial, datos_unicos tpy_usuario);
prueba4=# insert into tbl_usuario2 values (1,(1,'password','nombre'));
prueba4=# insert into tbl_usuario2 (datos_unicos.id, datos_unicos.password,
datos_unicos.nombre)  values (2, 'password2', 'nombre2');
prueba4=# select * from tbl_usuario2;
id |              datos_unicos
+
  1 | (1,"password                 ",nombre)
  1 | (2,"password2                ",nombre2)
prueba4=# select (datos_unicos).password from tbl_usuario2;
         password

password
password2
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
99/163

Borrar el type hará que se pierdan todas los campos creados a partir de este en todas
las tablas donde se haya usado.
prueba4=# drop type tpy_usuario cascade;
NOTICE:  drop cascades to 2 other objects
DETAIL:  drop cascades to table tbl_usuario
drop cascades to table tbl_usuario2 column datos_unicos
DROP TYPE
prueba4=# select * from tbl_usuario2;
id

  1
  1
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
100/163

1. Objetos de la DB - Domains
Los domains nos dejan crear tipos de datos validados, si lo eliminamos
eliminamos todos los campos de todas las tablas que lo han usado.
prueba3=# create domain dmn_adulto as integer check (value > 18 and value < 60);
prueba3=# create table tbl_persona(id int, edad dmn_adulto);
prueba3=# insert into persona values (1,25);
INSERT 0 1
prueba3=# insert into persona values (1,5);
ERROR: value for domain dmn_adulto violates check constraint "dmn_adulto_check"
prueba3=# drop domain dmn_adulto cascade;
NOTICE: drop cascades to table persona column edad
DROP DOMAIN
prueba3=# select * from persona;
id
----
1
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
101/163

1. Objetos de la DB - Vistas
Una interesante funcionalidad extendida es la posibilidad de tener vistas “updatable”,
es soportado solo insert y update.
prueba4=# create table tbl_vista ( id integer, nombre varchar(100));
prueba4=# crea view vw_vista as select * from tbl_vista;
prueba4=# create rule rul_vista as on insert to vw_vista do instead insert into
tbl_vista (id,nombre) values (new.id, new.nombre);
prueba4=# insert into vw_vista (id,nombre) values (1,'ernesto');
prueba4=# select * from tbl_vista;
id | nombre
----+---------
1 | ernesto
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
102/163

1. Objetos de la DB – Secuencias (Sequences)
Una secuencia es un tipo de datos auto-incremental, podría o no estar
ligado a una tabla como valor por defecto para un campo específico
(generalmente para la llave primaria), en esencia es un tipo de datos
entero.
pruebas=# create table tbl_simple (id serial, nombre varchar(10));
NOTICE: CREATE TABLE creará una secuencia implícita «tbl_simple_id_seq» para la columna serial
«tbl_simple.id»
CREATE TABLE
pruebas=# insert into tbl_simple (nombre) values ('ernesto') returning id;
id
----
1
INSERT 0 1
pruebas=# insert into tbl_simple (nombre) values ('juan') returning id;
id
----
2
INSERT 0 1
pruebas=# insert into tbl_simple (nombre) values ('10chars') returning id;
id
----
3
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
103/163

Algunas funciones pre-definidas de PostgreSQL nos permiten administrar las
secuencias:
pruebas=# d tbl_simple;
Tabla «public.tbl_simple»
+-------------------------------------------------------------------
id | integer | not null valor por omisión nextval('tbl_simple_id_seq'::regclass)
nombre | character varying(10) |
pruebas=# select currval('tbl_simple_id_seq'); <-- consulta el valor actual
currval
---------
3
pruebas=# select nextval('tbl_simple_id_seq'); <-- aumenta el valor el 1 de la secuencia
nextval
---------
4
pruebas=# select currval('tbl_simple_id_seq');
currval
---------
4
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
104/163

pruebas=# insert into tbl_simple (nombre) values ('10char') returning id;
id
----
5
pruebas=# select setval('tbl_simple_id_seq',1); <-- modifica el valor de la secuencia
setval
--------
1
pruebas=# insert into tbl_simple (nombre) values ('10cha') returning id;
id
----
2
pruebas=# select currval('tbl_simple_id_seq');
currval
---------
2
pruebas=# select * from tbl_simple;
id | nombre
----+---------
1 | ernesto
2 | juan
3 | 10chars
5 | 10char
2 | 10cha
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
105/163

Una funcionalidad interesante puede ser aplicable en entornos donde se
producen muchas “insersiones” de data, y es mantener una cantidad de
números en memoria para un acceso más rápido a los contadores.
prueba4=# create sequence contador cache 100; <-- reserva 100 números en
Cache
Cycle permite reiniciar el contador con el mínimo valor especificado cuando
este llega a su máximo valor declarado.
prueba4=# create sequence cmin_max cycle minvalue 1 maxvalue 3;
Increment permite definir cada cuantas unidades aumentará el contador,
positivo ó negativo.
prueba4=# create sequence salto increment -10;
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
107/163

1. Objetos de la DB - Tipos de datos especiales
a)Tsvector
El tipo de datos Vector nos permite almacenar cadenas en lexemas para facilitar las
búsquedas de cadenas específicas en textos muy largos.
prueba=# create table tbl_vector ( campo1 text, campo2 tsvector);
prueba=# insert into tbl_vector values ( 'esta es una pruena de un vector repitiendo la palabra vector','esta es una
prueba de un vector repitiendo la palabra vector');
prueba=# insert into tbl_vector values ( 'esta es una pruena de un vector repitiendo la palabra vector','esta es una
prueba de un vector repitiendo la palabra vector');
prueba=# insert into tbl_vector values ( 'árbol y vector añade acentos y eñes','árbol y vector añade acentos y eñes');
prueba=# insert into tbl_vector values ( 'las ratas y los ratones estan ratoneando un rato', 'las ratas y los ratones
estan ratoneando un rato');
^
prueba=# select * from tbl_vector;
campo1 | campo2
--------------------------------------------------------------+---------------------------------------------------------------------------
esta es una pruena de un vector | 'de' 'es' 'esta' 'prueba' 'un' 'una' 'vector'
esta es una pruena de un vector repitiendo la palabra vector | 'de' 'es' 'esta' 'la' 'palabra' 'prueba' 'repitiendo' 'un' 'una' 'vector'
árbol y vector añade acentos y eñes | 'acentos' 'añade' 'eñes' 'vector' 'y' 'árbol'
las ratas y los ratones estan ratoneando un rato | 'estan' 'las' 'los' 'ratas' 'rato' 'ratoneando' 'ratones' 'un' 'y'
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
108/163

a)Tsvector
prueba=# select campo1 from tbl_vector where to_tsvector(campo1) @@ to_tsquery('añade');
campo1
-------------------------------------
árbol y vector añade acentos y eñes
prueba=# select campo1 from tbl_vector where to_tsvector(campo1) @@ to_tsquery('vector & palabra');
campo1
--------------------------------------------------------------
esta es una pruena de un vector repitiendo la palabra vector
Podemos acceder directamente al campo del vector.
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('pg_catalog.spanish','vector');
campo1
--------------------------------------------------------------
esta es una pruena de un vector
esta es una pruena de un vector repitiendo la palabra vector
árbol y vector añade acentos y eñes
Pero esto no funciona, ¿porque?
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('pg_catalog.spanish','palabra');
campo1
--------
(0 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
109/163

a)Tsvector
Para una mejor administración de los datos debemos especificar el idioma en el cual
estamos añadiendo los datos.
prueba=# insert into tbl_vector values('esto añade soporte en español', to_tsvector('pg_catalog.spanish','esto añade
soporte en español'));
prueba=# select campo2 from tbl_vector;
campo2
---------------------------------------------------------------------------
'acentos' 'añade' 'eñes' 'vector' 'y' 'árbol'
'añad':2 'español':5 'soport':3
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('pg_catalog.spanish','añad');
campo1
-------------------------------
esto añade soporte en español
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('pg_catalog.spanish','añada');
campo1
-------------------------------
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
110/163

a)Tsvector
Tenemos a nuestra disposición diferentes operadores lógicos
prueba=# delete from tbl_vector;
prueba=# insert into tbl_vector values('esto añade soporte en español', to_tsvector('pg_catalog.spanish','esto añade
soporte en español'));
prueba=# insert into tbl_vector values('vamos a repetir vector 2 veces más, vector, vector',
to_tsvector('pg_catalog.spanish','vamos a repetir vector 2 veces más, vector, vector'));
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('añada & vector');
campo1
--------
(0 filas)
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('añada | vector');
campo1
----------------------------------------------------
vamos a repetir vector 2 veces más, vector, vector
(2 filas)
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('!vec');
campo1
-------------------------------
prueba=# select campo1 from tbl_vector where campo2 @@ to_tsquery('!vec & añada');
campo1
-------------------------------
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
111/163

a)Tsvector
Para combinar operadores lógicos entre varios campos:
&& <-- and
●|| <-- or
●!! <-- not
Los vectores se pueden indexar, para ellos existe el tipo de índice GIN.
prueba=# create index idx_vector3 on tbl_vector using gin(campo2);
CREATE INDEX
En caso de que los textos se actualicen demasiado seguido entonces podemos crear un
trigger para que actualice la columna donde están guardados los lexemas.
Para listar los lexemas más usados:
prueba=# SELECT * FROM ts_stat('SELECT campo2 FROM tbl_vector') ORDER BY nentry DESC, ndoc DESC, word LIMIT 5;
word | ndoc | nentry
---------+------+--------
cociner | 1 | 5
adrià | 1 | 3
gaston | 1 | 3
mund | 1 | 3
peruan | 1 | 3
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
112/163

b)Arreglos
Los arreglos en PostgreSQL son como en cualquier lenguaje de programación, su longitud
y dimensión es variable.
prueba4=# create table tbl_array (data int[]);
prueba4=# insert into tbl_array values('{1,2,3,4,5}');
prueba4=# select * from tbl_array;
data
-------------
{1,2,3,4,5}
prueba4=# alter table tbl_array add column data2 int[][];
prueba4=# insert into tbl_array (data2) values('{{1,2},{2,3},{3,4},{4,5},{5,6}}');
data | data2
-------------+---------------------------------
{1,2,3,4,5} |
| {{1,2},{2,3},{3,4},{4,5},{5,6}}
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
113/163

b)Arreglos
prueba4=# select data from tbl_array where data[2]=2;
data
-------------
{1,2,3,4,5}
(1 row)
prueba4=# select data from tbl_array where data[2]=1;
data
------
(0 rows)
prueba4=# select data2 from tbl_array where data2[1][2]=2;
data2
---------------------------------
{{1,2},{2,3},{3,4},{4,5},{5,6}}
(1 row)
data2
-------
(0 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
114/163

b)Arreglos
prueba4=# alter table tbl_array add column data3 int[][3];
ALTER TABLE
prueba4=# insert into tbl_array (data3) values('{{1,2,3},{2,3,4}}');
INSERT 0 1
data | data2 | data3
-------------+---------------------------------+-------------------
{1,2,3,4,5} | |
| {{1,2},{2,3},{3,4},{4,5},{5,6}} |
| | {{1,2,3},{2,3,4}}
(3 rows)
data3
-------------------
{{1,2,3},{2,3,4}}
(1 row
data3
-------
(0 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
115/163

c)OIDs
Los OIDs son identificadores únicos de los objetos en la base de datos, incluso cada
registro tiene un OID propio que jamas se repite en ninguna otra tabla.
prueba4=# create table tbl_oid2(id integer) with oids;
prueba4=# insert into tbl_oid2 values(1);
INSERT 24446 1
prueba4=# insert into tbl_oid2 values(2);
INSERT 24447 1
prueba4=# select * from tbl_oid2;
id
----
1
2
(2 rows)
prueba4=# select oid,* from tbl_oid2;
oid | id
-------+----
24446 | 1
24447 | 2
(2 rows)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
116/163

c)OIDs
Para obtener los oids de los objetos en la base de datos
prueba4=# select oid,relname from pg_class where substr(relname,1,3) = 'tbl';
oid | relname
-------+---------------------
...
24440 | tbl_oid
24443 | tbl_oid2
prueba4=# SELECT attrelid,attname FROM pg_attribute where attrelid = 'tbl_oid2'::Regclass;
attrelid | attname
----------+----------
24443 | tableoid
...
24443 | oid
...
24443 | id
prueba4=# SELECT attrelid,attname FROM pg_attribute where attrelid = 'vw_vista'::Regclass;
attrelid | attname
----------+---------
24380 | id
24380 | nombre
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
117/163

c)OIDs
Podemos borrar data apuntando a su OID
prueba4=# delete from tbl_oid2 where oid = 24447;
DELETE 1
prueba4=# select * from tbl_oid2;
id
----
1
(1 row)
Ahora por defecto ya no se crean OIDs para data, esto debido a que en volúmenes muy
grandes de datos los OIDs podrían llegar a ser insuficientes y es por ello que se
prescinde de ellos por defecto.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
118/163

d)Very Large Objetcs
PostgreSQL permite guardar binarios dentro de una tabla de muchos gigas de extensión,
estos files no se guardan directamente dentro de la tabla creada sino en un ambiente
especial y se apunta el oid del file para acceder a este.
prueba4=# create table tbl_files( name varchar(100), file oid);
prueba4=# insert into tbl_files values('primer archivo',
lo_import('/home/ernesto/Descargas/Programa.pdf'));
INSERT 0 1
prueba4=# select * from tbl_files;
name | file
----------------+-------
primer archivo | 24455
(1 row
prueba4=# select lo_export(tbl_files.file,'/tmp/Programa.pdf') from tbl_files where file = '24455';
lo_export
-----------
1
(1 row)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
119/163

d)Very Large Objetcs
Para retirar el binario añadido a la base de datos.
prueba4=# update tbl_files set file = null; <-- borramos el link pero no la data
prueba4=# insert into tbl_files values('segundo archivo', lo_import('/home/ernesto/Descargas/LAN.png'));
name | file
-----------------+-------
primer archivo |
segundo archivo | 24456
prueba4=# select lo_unlink(tbl_files.file) from tbl_files where file = 24456;
lo_unlink
-----------
1
prueba4=# update tbl_files set file= lo_import('/home/ernesto/Descargas/LAN.png') where name = 'segundo
archivo';
name | file
-----------------+-------
primer archivo |
segundo archivo | 24457
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
120/163

1. Objetos de la DB - Conversiones
TO_CHAR
Convierte números, fechas y otros a cadenas de texto.
pruebas=# select to_char(3.14159,'999');
to_char
---------
3
pruebas=# select to_char(3.14159,'9.99');
to_char
---------
3.14
pruebas=# select to_char(3.14159,'09.99');
to_char
---------
03.14
pruebas=# select to_char(now(), 'DD Mon YYYY');
to_char
-------------
24 Sep 2011
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
121/163

1. Objetos de la DB - Conversiones
TO_DATE
Convierte texto a fecha
pruebas=# select to_date('24 Sep 2011','DD Mont Y');
to_date
------------
2011-09-24
TO_NUMBER
De texto a numérico
pruebas=# select to_number('3.1415','9999');
to_number
-----------
314
pruebas=# select to_number('3.1415','999.9');
to_number
-----------
3.1
pruebas=# select to_number('3.1415','9.999');
to_number
-----------
3.141
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
122/163

2. Herencias
INHERITS nos permite heredar a la estructura de nuestra nueva tabla la
estructura de otra tabla.
prueba4=# create table tbl_padre (id integer, nombre varchar(100));
prueba4=# create table tbl_hijo (direccion varchar(200)) INHERITS (tbl_padre);
CREATE TABLE
prueba4=# select * from tbl_hijo;
id | nombre | direccion
++
(0 rows)
prueba4=# drop table tbl_padre cascade;
NOTICE:  drop cascades to table tbl_hijo
DROP TABLE
LIKE genera el mismo efecto pero al borrar la tabla padre no se pierde la
estructura.
prueba4=# create table tbl_hijo2  (like tbl_padre);
prueba4=# create table tbl_hijo3  (like tbl_padre, casa varchar(300));
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
123/163

2. Herencias - SELECTs
Es posible limitar una consulta a que solo presente
prueba=# create table ciudades ( nombre varchar(100));
prueba=# create table capitales ( capital boolean) inherits (ciudades);
prueba=# insert into ciudades values ('callao');
prueba=# insert into ciudades values ('piura');
prueba=# insert into capitales values ('lima', true);
prueba=# insert into capitales values ('buenos aires', true);
prueba=# select * from ciudades;
nombre
--------------
callao
piura
lima
buenos aires
(4 filas)
prueba=# select * from only ciudades;
nombre
--------
callao
piura
(2 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
124/163

3. Tablas Particionadas
Las tablas particionadas nos permiten crear diferentes espacios de almacenamiento para
una data en común.
template1=# create table tbl_padre(cuenta char(10));
template1=# create table tbl_hija10(cuenta char(10)) inherits (tbl_padre);
template1=# create table tbl_hija20(cuenta char(10)) inherits (tbl_padre);
template1=# insert into tbl_hija20 values('20.01');
template1=# select * from tbl_padre;
cuenta
------------
10.01
20.01
template1=# select * from tbl_hija10;
cuenta
------------
10.01
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
125/163

template1=# create table tbl_hija30(descripcion varchar(100)) inherits (tbl_padre);
template1=# insert into tbl_hija30 values('30.01', 'orden');
cuenta | descripcion
------------+-------------
30.01 | orden
cuenta
------------
..
30.01
template1=# create table tbl_hija40() inherits (tbl_padre);
cuenta
------------
...
40.01
cuenta
------------
40.01
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
126/163

template1=# create table tbl_hija50( check (substr(cuenta,1,1) = '5' )) inherits (tbl_padre);
ERROR: el nuevo registro para la relación «tbl_hija50» viola la restricción check
«tbl_hija50_cuenta_check»
template1=# select * from tbl_padrE;
cuenta
------------
...
540.01
template1=# drop table tbl_padre;
ERROR: no se puede eliminar tabla tbl_padre porque otros objetos dependen de él
DETALLE: tabla tbl_hija10 depende de tabla tbl_padre
tabla tbl_hija20 depende de tabla tbl_padre
SUGERENCIA: Use DROP ... CASCADE para eliminar además los objetos dependientes.
template1=# drop table tbl_hija20;
DROP TABLE
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
127/163

Supongamos que tenemos el caso de una tabla de movimientos contables, con millones de
registros por mes y decidimos crear una tabla por mes, pero es tanta data que
necesitamos grabarla en diferentes unidades físicas de almacenamiento, aplicamos:
template1=# create table tbl_hija60( check (substr(cuenta,1,1) = '6' )) inherits (tbl_padre)
tablespace ts_prueba;
CREATE TABLE
A cada tabla “hija” podemos aplicarle sus propios índices y relaciones, al igual que a
la tabla padre.
template1=# create index idx_padre on tbl_padre(cuenta);
CREATE INDEX
template1=# create index idx_padre2 on tbl_padre(cuenta) tablespace ts_prueba;
CREATE INDEX
Para retirar la herencia entre las tablas.
template1=# alter table tbl_hija30 no inherit tbl_padre;
cuenta
------------
10.01
40.01
540.01
(3 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
128/163

Objetos de la DB y Accesos
Podemos crear rules o triggers para manejar la correcta desviación de los datos cuando
se intenta grabar en la tabla principal ó padre.
template1=# CREATE RULE rl_tbl_padre10 AS
template1-# ON INSERT TO tbl_padre WHERE ( substr(cuenta,1,2) = '10' )
template1-# DO INSTEAD INSERT INTO tbl_hija10 VALUES (NEW.cuenta);
template1=# insert into tbl_padre values ('10.02');
cuenta
------------
00.01
10.01
10.02
40.01
540.01
(5 filas)
cuenta
------------
10.01
10.02
(2 filas)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
129/163

1. Schemas
Los esquemas son contenedores de objetos dentro de una db, por default
trabajamos en el schema PUBLIC.
La principal utilidad puede estar en la administración de permisos a los
objetos de la db ó simplemente la organización.
prueba4=# create schema public2;
prueba4=# create table public2.tbl_prueba(id integer);
prueba4=# create table public.tbl_prueba(id integer);
prueba4=# insert into tbl_prueba values(1);
prueba4=# insert into public2.tbl_prueba(2);
prueba4=# select * from public.tbl_prueba;
id
----
1
prueba4=# select * from public2.tbl_prueba;
id
----
2
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
130/163

2. TableSpaces
Los tablespaces nos permite generar áreas de almacenamiento de objetos de
una db en directorios ó unidades de almacenamiento diferentes a la
determinada por defecto.
La ventaja de esto es que podemos balancear el trabajo de nuestra DB en
diversas unidades haciendo que nuestra performanse mejore notablemente.
Un tablespace puede ser:
●Otro disco duro
●Un “disco” de estado solido (SSD)
●Una memoria USB
●Un “disco” virtual (en RAM)
●Otros tipos de unidades de almacenamiento
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
131/163

2. TableSpaces
CREATE TABLESPACE tablespacename [ OWNER username ] LOCATION 'directory'
El owner siempre es por defecto el creador, el directorio donde se creará
el tablespace debe estar VACIO y tener los permisos del usuario de Linux
que ejecuta el servicio del dbms (en el caso de CentOS es el usuario
“postgres”).
Como root (o con sudo):
root@depeche:~# mkdir /home/tablespace
root@depeche:~# chown postgres:postgres /home/tablespace/
En consola de PgSQL:
template1=# create tablespace ts_prueba location '/home/tablespace';
template1=# create table tbl_prueba(id serial) tablespace ts_prueba;
Como root:
root@depeche:/home/tablespace# ls -la
total 16
drwx------ 3 postgres postgres 4096 2010-10-04 12:43 .
drwxr-xr-x 4 root root 4096 2010-10-04 12:35 ..
drwx------ 2 postgres postgres 4096 2010-10-04 12:43 1 <-- directorio de la data
-rw------- 1 postgres postgres 4 2010-10-04 12:41 PG_VERSION
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
132/163

2. TableSpaces
Podemos usar esta funcionalidad con:
●Base de datos
●Tablas
●Indices
Se recomienda que los Tablespaces creados en discos virtuales ó memorias USB solo
almacenen objetos de la db de los cuales se puedo presncindir como tablas temporales,
esto debido a que son muy volátiles y fácil de corromper o perder los datos (por
ejemplo tener un tablespace en disco virtual desaparece si alguien reinicia el
servidor).
Los tablespace de índices tienen una muy buena persormanse en discos SSD.
Más sobre tablespace en ram:
http://wiki.postgresql.org/wiki/La_verdad_y_la_mentira_de_los_tablespaces_en_memoria
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
133/163

3. Roles y Accesos
Los permisos.
Por defecto uno tiene permisos totales sobre los objetos que haya creado
con su propio rol, ningún rol puede acceder a un objeto creado por otro
rol.
Se usan 2 comandos principales para asignación de permisos Grant (autoriza)
y Revoke (desautoriza).
prueba4=# create role usr1 password 'prueba';
prueba4=# create role usr2 password 'prueba';
Como usr1
prueba4=> create table tbl_prueba ( id integer);
Como usr2
prueba4=> select * from tbl_prueba;
ERROR: permission denied for relation tbl_prueba
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
135/163

3. Roles y Accesos
GRANT
●GRANT ON TABLE
●GRANT ( column ) ON TABLE
●GRANT ON SEQUENCE
●GRANT ON DATABASE
●GRANT ON FOREIGN DATA WRAPPER <-- para conexiones Dlink
●GRANT ON FOREIGN SERVER <-- para conexiones Dlink
●GRANT ON FUNCTION
●GRANT ON LANGUAGE
●GRANT ON LARGE OBJECT
●GRANT ON SCHEMA
●GRANT ON TABLESPACE
●GRANT role_name TO role_name
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
136/163

3. Roles y Accesos
●GRANT ON TABLE
prueba4=# create role usr3 password 'usr3' login;
prueba4=# create table tbl_acceso (id integer, nombre varchar(100));
prueba4=# grant insert on table tbl_accesos to usr3;
Como usr3
prueba4=> select * from tbl_acceso;
ERROR: permission denied for relation tbl_acceso
prueba4=> insert into tbl_acceso values ( 1, 'ernesto');
INSERT 0 1
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
137/163

3. Roles y Accesos
●GRANT ON TABLE
prueba4=# grant select (nombre) on tbl_acceso to usr3;
GRANT
Como usr3
prueba4=> select * from tbl_acceso;
ERROR: permission denied for relation tbl_acceso
prueba4=> select nombre from tbl_acceso;
nombre
---------
ernesto
No existe GRANT para “vistas”, se tratan como tablas (usar ON TABLE).
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
138/163

3. Roles y Accesos
●GRANT ON DATABASE
●GRANT ON SCHEMA
prueba4=# create table sin_acceso.prueba(id integer);
CREATE TABLE
Como usuario usr3
prueba4=> select * from sin_acceso.prueba;
ERROR: permission denied for schema sin_acceso
LINE 1: select * from sin_acceso.prueba;
Como superusuario:
prueba4=# grant usage on sin_acceso to usr3;
prueba4=# grant select on table sin_acceso.prueba to usr3;
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
139/163

3. Roles y Accesos
REVOKE
Sigue más o menos la misma estructura de GRANT salvo que en vez de dar
permisos los retira.
REVOKE [ GRANT OPTION FOR ]
{ { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON { [ TABLE ] table_name [, ...]
| ALL TABLES IN SCHEMA schema_name [, ...] }
FROM { [ GROUP ] role_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
140/163

3. Roles y Accesos
Usuarios del dbms vs Usuarios de la aplicación
Muchas aplicaciones (especialmente web) siguen la lógica de conectarse a la
dbms usando un solo usuario y controlan los accesos a opciones del sistema.
Esto es muy práctico de mantener, no llena la dbms de usuarios, PERO,
permite que todos tengan el mismo nivel de acceso a todos los objetos de la
db con los problemas que esto puede tener.
Para ver los accesos superiores de un rol puede utilizar este comando:
prueba4=> select * from pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
-----------+----------+-------------+----------+-----------+----------+----------+-----------
postgres | 10 | t | t | t | ******** | |
dbadmin | 16392 | t | t | t | ******** | |
pgsql | 16643 | t | t | t | ******** | |
usr3 | 24410 | f | f | f | ******** | infinity |
usr4 | 24414 | f | f | f | ******** | |
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
141/163

3. Roles y Accesos
OjO, todas las claves por defecto se guardan encriptadas en MD5 (lo cual
es relativamente seguro, pero no totalmente) sin embargo cerciórese de no
generar claves sin encriptación ya que fácilmente se puede ver estas con el
siguiente comando:
template1=# create role usr8 unencrypted password 'se_me_ve_todo' login;
template1=# select usename, passwd from pg_shadow;
  usename  |               passwd
+
postgres  | md54abfba9c735cfbc34d97b56a593120c0
dbadmin   | md5695c0e25f6fe7c4ce633c67292190b90
pgsql     |
usr1      | md51575823e236277b188fdd5d691aa8d08
usr3      | md5f06099b5e97add7ed510d76e24146f1e
usr8      | se_me_ve_todo
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
142/163

1. Backup y Restore
a) pg_dump, permite generar un backup de una db específica.
pf_dump NOMBRE_DB a                 < solo datos

pf_dump NOMBRE_DB b                 < incluir objetos grandes
pg_dump NOMBRE_DB c                 < incluye limpieza de objetos de la db, inserta drops antes
                                         De crearlos
pg_dump NOMBRE_DB C                 < incluye un create database
pg_dump NOMBRE_DB encoding=LATIN1  < backup con otra codificación
pg_dump NOMBRE_DB file=backup.dump < el backup se crear en este archivo
pg_dump NOMBRE_DB format=p         < backup en texto plano
pg_dump NOMBRE_DB format=c         < backup en formato que soporta pg_restore, comprimido
pg_dump NOMBRE_DB schema=NOMBRE_SC < backup solo del esquema especificado
pg_dump NOMBRE_DB excludeschema=NO< backup excluyendo el esquema especificado
pf_dump NOMBRE_DB o                 < incluir el OID de los objetos, útil solo si se usa los OID
                                         Especificamente.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
143/163

1. Backup y Restore
pf_dump NOMBRE_DB O                 < no se backupean los OWNER de los objetos, es útil cuando
                                         Cuando se mueve una db de un servidor a otro diferente.

pf_dump NOMBRE_DB S                 < solo backupea estructura de la db más no la data
pg_dump NOMBRE_DB table=NOMBRE_TAB < backupea solo la tabla especificada
pg_dump NOMBRE_DB excludetable=TA < backupea sin la tabla especificada
pg_dump NOMBRE_DB X                 < no se backupean los permisos
pg_dump NOMBRE_DB –compres=0..9      < especifica el nivel de compresión del backup, útil cuando
                                         Se usa el parámetro: format=c
pg_dump NOMBRE_DB inserts          < genera inserts de la data en vez de copys, añadir
                                         columninserts si se desea que se especifiquen en los
                                         Insert los nombres de los campos
pg_dump NOMBRE_DB disabletriggers < desabilita los triggers, útil solo si copiamos data y no
                                         Estructura de la db.
pg_dump NOMBRE_DB notablespaces   < no incluye las definiciones de los tablespaces en el backup
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
144/163

1. Backup y Restore
Todos los parámetros donde se especifican nombre de objteos (tablas, schemas, etc.)
pueden usar el comodín “*”, por ejemplo todas la tabla que empiezan con EQSOFT es “
table=EQSOFT*”
Todos se pueden usar solos o en combinación, además están los parametros de conexión
los cuales son:
h HOST_NAME < ip del servidor o nombre del host
p PUERTO    < número del puerto
U USER_NAME < nombre del usuario
w           < no pide password
W           < fuerza a pedir el password
Se pueden usar estas variables de entorno: PGDATABASE, PGHOST, PGOPTIONS, PGPORT y
PGUSER
ernesto@depeche:~/aaa$ pg_dump prueba5 > archivo.dump
pg_dump: [archivador (bd)] fallÃ³ la conexiÃ³n a la base de datos Â«prueba5Â»: FATAL:  no se
especifica un nombre de usuario en el paquete de inicio
ernesto@depeche:~/aaa$ export PGUSER=dbadmin
ernesto@depeche:~/aaa$ pg_dump prueba5 > archivo.dump
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
145/163

1. Backup y Restore
b) pg_dumpall, permite generar un backup de todo el dbms.
Implementa los mismos parámetros de pg_dump, añade el parámetro “l NOMBRE_DB” para
especificar el nombre de la base de datos a kacupear (mejor usar pg_dump).
pg_dumpall ademas copia usuarios de la base de datos además de la data y estructura
cosa que no hace pg_dump
Para comprimir un dump normal (en texto plano) podemos usar:
ernesto@depeche:~/aaa$ pg_dump prueba5 U dbadmin > dump.dump
ernesto@depeche:~/aaa$ ls dump.dump la
rwrr 1 ernesto ernesto 24522 20101009 12:07 dump.dump
ernesto@depeche:~/aaa$ pg_dump prueba5 U dbadmin | gzip > dump.dump.gz
ernesto@depeche:~/aaa$ ls dump.dump.gz la
rwrr 1 ernesto ernesto 3940 20101009 12:06 dump.dump.gz
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
146/163

1. Backup y Restore
c) pg_restore, permite cargar un backup a la dbms, siempre y cuando el backup haya
sido generado por el parámetro “format=c”
Algunas ventajas de usar pg_restore sobre el metodo alternativo es que tenemos mayor
velocidad en restore de bases de datos enormes debido al uso de multihilos para el
restore.
ernesto@depeche:~/aaa$ pg_dump prueba5 format=c U dbadmin > pgrestore.dump
ernesto@depeche:~/proyectos$ dropdb prueba5 U dbadmin
ernesto@depeche:~/proyectos$ createdb prueba5 U dbadmin
ernesto@depeche:~/aaa$ pg_restore pgrestore.dump U dbadmin –dbname=prueba5

ernesto@depeche:~/aaa$ pg_dump prueba5 > otro.dump U dbadmin
ernesto@depeche:~/proyectos$ createdb prueba6 U dbadmin
ernesto@depeche:~/aaa$ pg_restore otro.dump U dbadmin dbname=prueba6
pg_restore: [archivador] el archivo de entrada no parece ser un archivador vÃ¡lido
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
147/163

1. Backup y Restore
c) pg_restore
Pg_restore permite el uso de muchos parámetros, básicamente los mismos de pg_dump en
sentido inverso (no baja data sino sube obviamente), la lista completa puede ser
revisada aquí:
http://www.postgresql.org/docs/9.0/interactive/apppgrestore.html
Para especificar cuantos hilos deseamos que se lancen en el proceso de restore usamos
el parámetro j
ernesto@depeche:~/aaa$ pg_restore pgrestore.dump U dbadmin j 4 dbname=prueba8
El tiempo mejorado depende de: cantidad de data, estructura de la db, cantidad de
jobs, disponibilidad de la db, etc. Eventualmente se obtendrán beneficios de 25% de
reducción del tiempo hasta 85% (lo máximo reportado) de ahorro.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
148/163

1. Backup y Restore
d)¿Backups incrementales?
No existe funcionalidad para ello en la versión de serie de PostgreSQL
Pgrman
http://code.google.com/p/pgrman/
Otra opción es hacer backups “online” de los archivos WAL.
http://www.postgresql.org/docs/9/static/continuousarchiving.html
Los archivos WAL son los intercambios de data transaccional en la base de datos a
nivel binario, no es necesariamente consistente el backup.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
149/163

2. Vacuum
El Vacuum es una de las más importantes tareas de administración, lo que hace es
limpiar las “páginas” no usadas por el sistema y actualiza las estadísticas de las
tablas e índices para una mejor resolución de querys.
La dbms ejecuta periodicamente (definido en postgresql.conf) un Lazy Vacuum, esto es
libera páginas no usadas por data, más no por índice, este vacuum no genera demasiado
tiempo de bloqueo en la tabla (depende el tamaño).
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
150/163

2. Vacuum
El full vacuum requiere acceso exclusivo a la tabla durante el tiempo que demoré la
operación, esta limpiara totalmente las páginas no usadas.
Mejora notablemente el tiempo de acceso a los datos.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
151/163

2. Vacuum
Se pueden aplicar Vaccums a nivel de tabla o base de datos.
●Vacuum full TABLA    < limpia todo el espacio no utilizado, reescribe totalmente la
                         tabla por lo cual consume más espacio.
●Vacuum analyze TABLA < actualiza las estadísticas para e generador de plan de
                         ejecución.
●Vacuum TABLA         < solo limpia data y reorganiza las páginas.
Se puede añadir de precisión un Vacuum sobre un campo.
“Vacuumdb” se utiliza externamente desde la linea de comandos del sistema operativo
para ejecutar la operación sobre la base de datos seleccionada.
ernesto@depeche:~$ vacuumdb full prueba5 U dbadmin
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
152/163

3. Migraciones
El proceso de migrar cualquier base de datos hacía PostgreSQL debe pasar
por una etapa de evaluación.
En la mayoría de los casos el escenario de migrar la data no es el mayor
inconveniente, es posible que la lógica de programación incluido en la base
de datos es mucho más complicado.
Algunas bases de datos como Oracle tienen un proceso de migración más
transparente hacia PostgreSQL utilizando productos de terceros y
licenciados.
Algunas bases de datos como MS SQL Server tienen la costumbre de tener
objetos con nombres escritos en combinación de mayúsculas y minúsculas,
esto debe ser transformado a totalmente a minúsculas como estándar de
nomenclatura.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
153/163

3. Migraciones
Problemas con la data numérica:
* La precisión de punto flotante del tipo de dato float o double puede dar
como resultado nùmeros no exactos al migrar, así un número 10 por ejemplo
podría aparecer como 9.99999999 (radical)
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
154/163

3. Migraciones
Problemas con la data texto:
* PostgreSQL soporta los tipos de datos SQL Ansi, mientras la data a migrar
  este acorde o cercana a este estándar no debería haber demasiados
  inconvenientes.
* Sobre la internacionalización de los caracteres debe de tener en cuenta
  que por defecto PostgreSQL 8.4 y 9.0 soporta solo un tipo por DB, a
  partir de 9.1 es posible trabajar con internacionalización por campo.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
155/163

3. Migraciones
Problemas con la data binaria:
* Migrar archivos debería trabajarse en un proceso aparte, especialmente
si el tipo de datos utilizado para almacenarlos es equivalente al “bytea”
de PostgreSQL donde hay que reconstruir el binario alamcenado.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
156/163

3. Migraciones
Entre versiones de PostgreSQL
Migrar en el mismo servidor entre diferentes versiones de PostgreSQL debe
tener las siguientes consideraciones:
* Si es un cambio a releases de actualización, por ejemplo de 8.4.1 a
  8.4.2, se puede reemplazar simplemente los binarios.
* Si el cambio es entre releases menores, como por ejemplo 8.3 a 8.4, si
  debería hacerse mediante un backup y restore simple, levantar la nueva
  versión debería ser transparente.
  pg_dumpall p 5432 | psql d postgres p 6543  < este ejemplo presume que tendremos instaladas
                                                      ambas versiones en el mismo server.
* Si el cambio es entre releases mayores, por ejemplo de 8.4 a 9.0,
  utilizar forzosamente backup y restore y validar que todos los objetos de
  la base de datos respondan adecuadamente, especialmente la lógica de
  programación implementada dentro de esta.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
157/163

3. Migraciones
Herramientas para migrar
La mayoría de las bases de datos tienen herramientas para generar ETL (en
PostgreSQL existen muchos proyectos que importan/exportan a PostgreSQL),
estas herramientas pueden ser utilizadas para labor de migrar DATA y
ESTRUCTURAS, nada más eso.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
158/163

3. Migraciones
Lógica de programación
* Triggers, Rules y Funciones deberán, preferiblemente, ser reescritas
  nuevamente al migrar.
* Consideré que PostgreSQL no implementa store procedures, todo son
  funciones, que pueden hacer las veces de store procedures.
* Una facilidad en PostgreSQL es la disponibilidad de muchos lenguajes
  “PL” como Java, Perl, Python, PHP, etc. Pero, esta facilidad debe ser
  evaluada bajo criterios de rendimiento en el procesamiento de la base
  de datos, el lenguaje mejor integrado con PostgreSQL es PL/pgSQL.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
159/163

4. Indices
Es importante saber que índice se requiere para cada tipo de operación:
B-trees : <,<=,=,>=,>, BETWEEN, IN y las condiciones IS NULL e IS NOT NULL
Las búsquedas con LIKE '%algo' no usan el índice
Las búsquedas con LIKE 'algo%' si usan el índice
Las búsquedas con iLIKE no usan el índice
HASH : =
GiN : <@,@>,=,&&
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
160/163

4. Indices
Los índices compuestos tiene el límite de hasta 32 campos en su composición, considere
al momento de las consultas usar el mismo orden de columnas con el cual creo el
índice.
En versiones anteriores a la 9 de PostgreSQL, los datos NULL no se indexaban.
Podemos crear índices más complejos como por ejemplo:
●Create index idx_tabla on tabla ( campo1 || campo 2);
●Create index idx_tabla on tabla ( substr(campo1,5,10) );
●Create index idx_tabla on tabla ( upper(campo1));
Para obtener provecho de esto las consultas deben hacer el pedido de la data en la
estructura en la que se ha creado el índice.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
161/163

4. Indices
Los índices parciales nos permiten tener indexada una porción de la data de una tabla.
●Create index idx_nombre on tabla1 (campo1) where campo1 > 100 and campo1 <= 100000;
Si la búsqueda sobre esta tabla escapa a los valores especificados entonces no se
usará el índice.
Podemos especificar un índice de este tipo donde los valores WHERE sean diferentes a
los que estamos indexando.
●Create index idx_nombre on tabla1 (campo1) where campo2 > 100 and campo2 <= 100000;
Select * from tabla1 where campo1 = 10 and campo2 = 1000; <-- usará el índice
Select * from tabla1 where campo1 = 10; <-- no usará el índice
Select * from tabla1 where campo2 > 1000 and campo3 = 1000; <-- podría usar el índice
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
162/163

4. Indices
Se pueden aplicar ordenes especificos a los índices:
Create index idx_nombre on tabla1 ( campo1 DESC);
Create index idx_nombre on tabla1 ( campo1 ASC);
Create index idx_nombre on tabla1 ( campo1 NULLS FIRST);
Create index idx_nombre on tabla1 ( campo1 NULLS LAST);
text_pattern_ops, varchar_pattern_ops, and bpchar_pattern_ops son operadores que se
usan para tipos de datos cadenas de caracteres, tiene utilidad cuando se hacen
búsquedas por expresiones regulares.
informes@eqsoft.net
Teléfonos: (51) (1) 5645744 / 5645424
163/163

Dba PostgreSQL desde básico a avanzado parte1

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Dba PostgreSQL desde básico a avanzado parte1 (20)

Más de EQ SOFT EIRL (20)

Último (20)

Dba PostgreSQL desde básico a avanzado parte1