58517228 postgre sql-desarrolladoresbasico

1
CURSO DE POSTGRESQL DESARROLLADORES
ELEMENTOS BASICOS
Euclides Figueroa
efigueroah@gmail.com
Centro de EstudiosCentro de Estudios
Tecnológicos AvanzadosTecnológicos Avanzados
Bienvenidos

2
Contenido Programático

Arquitectura de PostgreSQL

Instalación de PostgreSQL (Linux/Windows)

Iniciando, Deteniendo y Configurando

Programas Clientes de PostgreSQL
●
phppgadmin (apache,php,Postgresql)
●
psql

El programa psql

3

Creando Bases de Datos

Creando tablas
●
definición de columnas
●
valores nulos
●
indices
●
claves primarias
●
claves secundarias

show tables – valores nulos

Insertando datos insert

Reemplazando Valores (replace y update)

Eliminando registros

4

Consultando Registros
●
La sentencia select
●
inner, left, right - join
●
alias
●
consultas multitablas
●
agrupando y sumarizando

Operadores de PostgreSQL

Funciones de PostgreSQL

Usuarios y privilegios

5
PostgreSQL Server: El Demonio Servidor propiamente Postmaster que es
el encargado de manejar directamente las bases de datos y tablas.
Binarios - Fuentes
Programas Clientes: Son aquellos programas que se comunican con el
servidor enviando solicitudes a través de una conexión de red, el servidor
actúa sobre cada solicitud y envía la respuesta al programa cliente.
psql - pgadminIII - phppgadmin
Utilitarios No-Clientes: Aquellos programas de propositos especiales que
no actuan como clientes con el servidor.
initdb – inicia el area de datos de Postgresql

6
PostgreSQL Interfases: Son usadas por programas de terceros, permiten la
conexión al servidor de programas del usuario, a través de varios protocolos.
API C Interfase - PostgreSQL Connector/OBDC - PgSQL Connector/J
- PgSQL Connector/NET
Protocolos utilizados: Dependiendo del modo de conexión al Servidor
(Local o Remota) permiten la comunicación de los clientes con el Servidor
Protocolo Tipo de conexión Sistema Operativo
TCP/IP Local, remota Todos
Unix socket file Solo Local Solo Unix
Named pipe Solo Local Solo Windows

7
COMO PostgreSQL UTILIZA EL ESPACIO EN DISCO
Directorio de Datos (/var/lib/pgsql/data)
Cada Base de datos tiene su propio directorio, sin importar el tipo
de tablas que se creen, por ejemplo un directorio:
/var/lib/pgsql/data

8
Instalación y Archivos de
Configuración de PostgreSQL
OBTENER PostgreSQL
INSTALACION EN LINUX Y WINDOWS
EL ARCHIVO pg_hba.conf y postgresql.conf
Opciones de Instalación y arranque
Evaluación de un archivo ejemplo

9
OBTENER PostgresSQL
Para obtener a postgreSQL, lo descargamos de la pagina
www.postgresql.org
Alli podemos descargar las versiones especificas para cada
sistema operativo:
linux
windows
o los programas fuentes para su compilacion posterior.

10
INSTALACION EN LINUX Y WINDOWS
Para la instalación en el sistema operativo linux, se recomienda utilizar
el que viene acompañando a su distribucion de linux.
De manera standar el sistema instalara los programas en las siguientes
localidades:
/usr/sbin/postgres <--- demonio principal inicia al servicio postgreSQL
/usr/bin/psql <--- programa de gestion interactivo de SQL

11
Programas Clientes para el Usuario
PROGRAMAS DE ADMINISTRACION Y MONITOREO
ADMINISTRACION
psql
pgadminIII
OTROS PROGRAMAS
phppgadmin
otros

12
Uso del monitor PSQL
PSQL es un programa que se ejecuta desde el prompt del
sistema, que permite conectarse a un servidor PostgreSQL para
enviarle consultas y comandos, y ver los resultados.
Este comando permite:
 Consultar información de las bases de datos y tablas
 Crear bases de datos y tablas
 Eliminar bases de datos y tablas.
 Asignar y revocar privilegios.
 Consultar, insertar, actualizar y eliminar registros de una tabla.
Conectarse a PostgreSQLConectarse a PostgreSQL

13
 Sintaxis del comando psql
$shell> psql [-h hostname] [-U usuario] [-w] [base de datos]
 Para una conexión a un host local como usuario postgres, las
siguientes líneas son equivalentes.
# psql
# psql -U postgres
# psql -h localhost -U postgres
Conectarse a PostgreSQL - ejemploConectarse a PostgreSQL - ejemplo

14
Si se puede establecer la conexión a postgreSQL, se obtiene un
mensaje de bienvenida, y se cambia el prompt, indicando que se
pueden enviar consultas al servidor.
# psql
psql (8.4.2)
Digite «help» para obtener ayuda.
postgres=# help
Está usando psql, la interfaz de línea de órdenes de PostgreSQL.
Digite: copyright para ver los términos de distribución
h para ayuda de órdenes SQL
? para ayuda de órdenes psql
g o punto y coma («;») para ejecutar la consulta
q para salir
postgres=#
Conectarse a PostgreSQLConectarse a PostgreSQL

15
La siguiente tabla muestra cada uno de los indicadores que podrá ver y
sintetiza lo que dicen acerca del estado en que se encuentra postgresql:
postgres=#Listo para un nuevo comando.
-> Esperando la siguiente línea en un comando de
múltiples líneas.
'> Esperando la siguiente línea, se encuentra abierta
una cadena que comienza con apostrofo (''').
"> Esperando la siguiente línea, se encuentra abierta
una cadena que comienza con comillas dobles ('"').
Conectarse a postgreSQLConectarse a postgreSQL

16
La siguiente tabla muestra cada uno de los indicadores que podrá ver y
sintetiza lo que dicen acerca del estado en que se encuentra Postgresql:
`> Esperando la siguiente línea, se encuentra abierta una
cadena que comienza con tilde ('`').
/*> Esperando la siguiente línea, se encuentra abierto un
comentario que comienza con /*.
Conectarse a postgreSQLConectarse a postgreSQL

17
Informativo
opciones: S = desplegar objectos de sistema, + = agregar más detalle)
l[+] listar bases de datos
dv[S+] [PATRÓN] listar vistas
dt[S+] [PATRÓN] listar tablas
di[S+] [PATRÓN] listar índices
d[S+] NOMBRE describir tabla, índice, secuencia o vista
dv[S+] [PATRÓN] listar vistas
du[+] [PATTERN] list roles (users)
los Comandos bases del psqllos Comandos bases del psql

18
A nivel teórico, existen dos lenguajes para el manejo de bases de datos:
DDL (Data Definition Language) Lenguaje de definición de datos.
Es el lenguaje que se usa para crear bases de datos y tablas, y para modificar
sus estructuras, así como los permisos y privilegios.
Este lenguaje trabaja sobre unas tablas especiales llamadas diccionario
de datos.
DML (Data Manipulation Language) lenguaje de manipulación de datos.
Es el que se usa para modificar y obtener datos desde las bases de datos.
SQL engloba ambos lenguajes DDL+DML, y los estudiaremos juntos, ya
que ambos forman parte del conjunto de sentencias de SQL.

19
Crear una base de datos es una tarea muy simple. Claro que, en el momento
de crearla, la base de datos estará vacía, es decir, no contendrá ninguna tabla.
Para empezar, crearemos una base de datos para nosotros solos, y la
llamaremos "curso". Para crear una base de datos se usa una sentencia
CREATE DATABASE:
postgres> CREATE DATABASE curso;
Query OK, 1 row affected (0.03 sec)
postgres>

21
Creando Tablas
Veamos ahora la sentencia CREATE TABLE que sirve para crear tablas.
La sintaxis de esta sentencia es muy compleja, ya que existen muchas
opciones y tenemos muchas posibilidades diferentes a la hora de crear una
tabla. Las iremos viendo paso a paso, y en poco tiempo sabremos usar
muchas de sus posibilidades.
En su forma más simple, la sentencia CREATE TABLE creará una tabla
con las columnas que indiquemos. Crearemos, como ejemplo, una tabla que
nos permitirá almacenar nombres de personas y sus fechas de nacimiento.
Deberemos indicar el nombre de la tabla y los nombres y tipos de las
columnas:

22
Creando Tablas
Hemos creado una tabla llamada "gente" con dos columnas:
"nombre" que puede contener cadenas de hasta 40 caracteres
y
"fecha" de tipo fecha.
postgres=# c curso
psql (8.4.2)
Ahora está conectado a la base de datos «curso».
curso=# CREATE TABLE gente (nombre VARCHAR(40), fecha DATE);
CREATE TABLE

24
Definición de columnas
Pero tenemos muchas más opciones a la hora de definir columnas. Además
del tipo y el nombre, podemos definir valores por defecto, permitir o no que
contengan valores nulos, crear una clave primaria, indexar...
La sintaxis para definir columnas es:
nombre_col tipo [NOT NULL | NULL] [DEFAULT valor_por_defecto]
[[PRIMARY] KEY] [definición_referencia]

25
El tipo de dato especifica el tipo de información que puede guardar un campo:
caracteres, números, etc.
Estos son algunos tipos de datos básicos de PostgreSQL (posteriormente veremos
otros):
varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de
caracteres. Se coloca entre comillas (simples); ejemplo: 'Hola', 'Juan Perez'.

26
El tipo "varchar" define una cadena de longitud variable en la cual determinamos el
máximo de caracteres entre paréntesis. Puede guardar hasta 10485760 caracteres.
Por ejemplo, para almacenar cadenas de hasta 30 caracteres, definimos un campo de
tipo varchar(30), es decir, entre paréntesis, junto al nombre del campo colocamos la
longitud.
Si asignamos una cadena de caracteres de mayor longitud que la definida, la cadena
no se carga, aparece un mensaje indicando tal situación y la sentencia no se ejecuta
(ERROR: value too long for type character varying(30)).

27
integer: se usa para guardar valores numéricos enteros, de -2000000000 a
2000000000 aprox.
Definimos campos de este tipo cuando queremos representar, por ejemplo,
cantidades.
float: se usa para almacenar valores numéricos con decimales.
Se utiliza como separador el punto (.). Definimos campos de este tipo para precios,
por ejemplo

28
Valores Nulos
Al definir cada columna podemos decidir si podrá o no contener valores
nulos.
La opción por defecto es que se permitan valores nulos, NULL, y para
que no se permitan, se usa NOT NULL. Por ejemplo:
curso=# CREATE TABLE ciudad1 (
curso(# nombre CHAR(20) NOT NULL,
curso(# poblacion INT NULL
curso(# );
CREATE TABLE

29
Indices
Claves primarias
También se puede definir una clave primaria sobre una
columna, usando la palabra clave KEY o PRIMARY KEY.
Sólo puede existir una clave primaria en cada tabla, y la
columna sobre la que se define una clave primaria no
puede tener valores NULL.
Si esto no se especifica de forma explícita,
PostgreSQL lo hará de forma automática.

30
Indices
Claves primarias
curso(# id INTEGER PRIMARY KEY,
curso(# );
NOTICE: CREATE TABLE / PRIMARY KEY creará
el índice implícito «ciudad3_pkey» para la tabla «ciudad3»
CREATE TABLE

31
Indices
Claves primarias
curso(# id serial PRIMARY KEY,
curso(# );
NOTICE: CREATE TABLE creará una secuencia implícita
«ciudad2_id_seq» para la columna serial «ciudad2.id»
NOTICE: CREATE TABLE / PRIMARY KEY creará el índice
implícito «ciudad2_pkey» para la tabla «ciudad2»
CREATE TABLE

32
Indices
Claves Únicas
El tercero permite definir índices con claves únicas,
también sobre una columna, sobre varias o sobre partes de
columnas. Para definir índices con claves únicas se usa la
opción UNIQUE.
La diferencia entre un índice único y uno normal es que en los
únicos no se permite la inserción de filas con claves repetidas.
La excepción es el valor NULL, que sí se puede repetir.
curso=# CREATE TABLE mitabla2 (
curso(# id INT,
curso(# nombre CHAR(19),
curso(# unique (nombre));
NOTICE: CREATE TABLE / UNIQUE creará el índice implícito
«mitabla2_nombre_key» para la tabla «mitabla2»
CREATE TABLE

33
Indices
Claves Foráneas
Hemos visto que una de las alternativas que PostgreSQL ofrece para asegurar la
integridad de datos es el uso de restricciones (constraints). Aprendimos que las
restricciones se establecen en tablas y campos asegurando que los datos sean válidos
y que las relaciones entre las tablas se mantengan.
Con la restricción "foreign key" se define un campo (o varios) cuyos valores
coinciden con la clave primaria de la misma tabla o de otra, es decir, se define una
referencia a un campo con una restricción "primary key" o "unique" de la misma
tabla o de otra.

34
Indices
Claves Foráneas
La integridad referencial asegura que se mantengan las referencias entre las claves
primarias y las externas. Por ejemplo, controla que si se agrega un código de
editorial en la tabla "libros", tal código exista en la tabla "editoriales".
También controla que no pueda eliminarse un registro de una tabla ni modificar la
clave primaria si una clave externa hace referencia al registro. Por ejemplo, que no se
pueda eliminar o modificar un código de "editoriales" si existen libros con dicho
código.

35
Indices
Claves Foráneas
La siguiente es la sintaxis parcial general para agregar una restricción "foreign key":
alter table NOMBRETABLA1
add constraint NOMBRERESTRICCION
foreign key (CAMPOCLAVEFORANEA)
references NOMBRETABLA2 (CAMPOCLAVEPRIMARIA);
Analicémosla:
- NOMBRETABLA1 referencia el nombre de la tabla a la cual le aplicamos la
restricción,
- NOMBRERESTRICCION es el nombre que le damos a la misma,

36
Indices
Claves Foráneas
La siguiente es la sintaxis parcial general para agregar una restricción "foreign key":
alter table NOMBRETABLA1
add constraint NOMBRERESTRICCION
foreign key (CAMPOCLAVEFORANEA)
references NOMBRETABLA2 (CAMPOCLAVEPRIMARIA);
- luego de "foreign key", entre paréntesis se coloca el campo de la tabla a la que le
aplicamos la restricción que será establecida como clave foránea,
- luego de "references" indicamos el nombre de la tabla referenciada y el campo que
es clave primaria en la misma, a la cual hace referencia la clave foránea. La tabla
referenciada debe tener definida una restricción "primary key" o "unique"; si no la
tiene, aparece un mensaje de error.

37
Indices
Claves Foráneas
Hasta el momento hemos agregado restricciones a tablas existentes con "alter table"
(manera aconsejada), también pueden establecerse al momento de crear una tabla (en
la instrucción "create table").
En el siguiente ejemplo creamos la tabla "libros" con la restricción respectiva:
create table editoriales(
codigo serial, nombre varchar(20),
primary key (codigo)
);
create table libros(
codigo serial, titulo varchar(40), autor varchar(30),
codigoeditorial smallint references editoriales(codigo),
primary key(codigo)
);

38
Indices
Claves Foráneas
Si intentamos eliminar un registro de la tabla referenciada por una restricción
"foreign key" cuyo valor de clave primaria existe referenciada en la tabla que tiene
dicha restricción, la acción no se ejecuta y aparece un mensaje de error.
Esto sucede porque, por defecto, para eliminaciones, la opción de la restricción
"foreign key" es "no action". Lo mismo sucede si intentamos actualizar un valor de
clave primaria de una tabla referenciada por una "foreign key" existente en la tabla
principal.
La restricción "foreign key" tiene las cláusulas "on delete" y "on update" que son
opcionales.
Estas cláusulas especifican cómo debe actuar PostgreSQL frente a eliminaciones y
modificaciones de las tablas referenciadas en la restricción.

39
Restricciones Claves Foraneas
Las opciones para estas cláusulas son las siguientes:
- "no action": indica que si intentamos eliminar o actualizar un valor de la clave
primaria de la tabla referenciada (TABLA2) que tengan referencia en la tabla
principal (TABLA1), se genere un error y la acción no se realice; es la opción
predeterminada.
- "cascade": indica que si eliminamos o actualizamos un valor de la clave primaria en
la tabla referenciada (TABLA2), los registros coincidentes en la tabla principal
(TABLA1), también se eliminen o modifiquen; es decir, si eliminamos o
modificamos un valor de campo definido con una restricción "primary key" o
"unique", dicho cambio se extiende al valor de clave externa de la otra tabla
(integridad referencial en cascada).
- "set null": Establece con el valor null en el campo de la clave foránea.
- "set default": Establece el valor por defecto en el campo de la clave foránea.

40
Restricciones Claves Foraneas
La sintaxis completa para agregar esta restricción a una tabla es la siguiente:
alter table TABLA1
add constraint NOMBRERESTRICCION foreign key
(CAMPOCLAVEFORANEA) references TABLA2(CAMPOCLAVEPRIMARIA)
on delete OPCION on update OPCION;
Veamos un ejemplo. Definimos una restricción "foreign key" a la tabla "libros"
estableciendo el campo "codigoeditorial" como clave foránea que referencia al
campo "codigo" de la tabla "editoriales". La tabla "editoriales" tiene como clave
primaria el campo "codigo". Especificamos la acción en cascada para las
actualizaciones y eliminaciones:
alter table libros
add constraint FK_libros_codigoeditorial
foreign key (codigoeditorial) references editoriales(codigo)
on update cascade on delete cascade;

41
Eliminando Tablas
A veces es necesario eliminar una tabla, ya sea porque es más sencillo
crearla de nuevo que modificarla, o porque ya no es necesaria.
Para eliminar una tabla se usa la sentencia DROP TABLE.
curso=# DROP TABLE ciudad6;
curso=#

42
Eliminando Tablas
borrame=# dt
---------+---------+-------+----------
public | borrame | table | postgres
(1 fila)
borrame=# DROP TABLE borrame;
DROP TABLE

43
Eliminando Bases de Datos
De modo parecido, se pueden eliminar bases de datos completas, usando la
sentencia DROP_DATABASE.
La sintaxis también es muy simple:
DROP DATABASE [IF EXISTS] db_name
Hay que tener cuidado, ya que al borrar cualquier base de datos se elimina
también cualquier tabla que contenga.

44
postgres=# CREATE DATABASE borrame;
CREATE DATABASE
postgres=# c borrame
psql (8.4.2)
Ahora está conectado a la base de datos «borrame».
borrame=# CREATE TABLE borrame(id int, nombre char(40));
CREATE TABLE
borrame=# dt
---------+---------+-------+----------
public | borrame | table | postgres
(1 fila)

46
Insertando Registros (registros)
La forma más directa de insertar una fila nueva en una tabla es mediante una
sentencia INSERT. En la forma más simple de esta sentencia debemos
indicar la tabla a la que queremos añadir filas, y los valores de cada
columna. Las columnas de tipo cadena o fechas deben estar entre comillas
sencillas o dobles, para las columnas numéricas esto no es imprescindible,
aunque también pueden estar entrecomilladas.
La sintaxis básica y general es la siguiente:
insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn)
values (VALORCAMPO1, ..., VALORCAMPOn);

47
Insertando Registros (registros)
Para agregar un registro a la tabla escribimos:
insert into usuarios (nombre, clave) values ('Mariano','payaso');
Note que los datos ingresados, como corresponden a cadenas de caracteres
se colocan entre comillas simples.
Para ver los registros de una tabla usamos "select":
select * from usuarios;
El comando "select" recupera los registros de una tabla.
Con el asterisco indicamos que muestre todos los campos de la tabla
"usuarios".

48
Actualizando registros
Podemos modificar valores de las filas de una tabla usando la sentencia
UPDATE. En su forma más simple, los cambios se aplican a todas las
filas, y a las columnas que especifiquemos.
Por ejemplo, podemos aumentar en un 10% la población de todas las
ciudades de la tabla ciudad3 usando esta sentencia:
curso=# UPDATE ciudad3 SET poblacion=poblacion*1.10;
UPDATE 1
curso=# SELECT * from ciudad3;
curso
id | nombre | poblacion
-------+----------------------+-----------
80000 | Roma |
(1 fila)
curso=# UPDATE ciudad3 SET poblacion=poblacion*1.10;
UPDATE 1
curso=# SELECT * from ciudad3;

49
Actualizando registros
Pero no tenemos por qué actualizar todas las filas de la tabla. Podemos
limitar el número de filas afectadas de varias formas.
La primera es mediante la cláusula WHERE. Usando esta cláusula
podemos establecer una condición.
Sólo las filas que cumplan esa condición serán actualizadas:
UPDATE ciudad5 SET poblacion=poblacion*1.03
WHERE nombre='Roma';

50
Para eliminar filas se usa la sentencia DELETE. La sintaxis es muy
parecida a la de UPDATE:
DELETE FROM ciudad3;
De este modo se eliminan todas las filas de la tabla.

51
Pero es más frecuente que sólo queramos eliminar ciertas filas que
cumplan determinadas condiciones.
La forma más normal de hacer esto es usar la cláusula WHERE:
DELETE FROM ciudad5 WHERE clave=2;
SELECT * FROM ciudad5;

52
Vaciando una Tabla
Cuando queremos eliminar todas la filas de una tabla, vimos en el punto
anterior que podíamos usar una sentencia DELETE sin condiciones. Sin
embargo, existe una sentencia alternativa, TRUNCATE, que realiza la
misma tarea de una forma mucho más rápida.
TRUNCATE ciudad5;
La diferencia es que DELETE hace un borrado secuencial de la tabla, fila
a fila. Pero TRUNCATE borra la tabla y la vuelve a crear vacía, lo que es
mucho más eficiente.

53
Consultas con PostgreSQL
La sentencia SELECT
Ya disponemos de bases de datos, y sabemos cómo añadir y modificar
datos. Ahora aprenderemos a extraer datos de una base de datos. Para ello
volveremos a usar la sentencia SELECT.
La sintaxis de SELECT es compleja, no explicaremos todas sus opciones.
Una forma más general consiste en la siguiente sintaxis:
SELECT [ALL | DISTINCT | DISTINCTROW]
expresion_select,...
FROM referencias_de_tablas
WHERE condiciones
[GROUP BY {nombre_col | expresion | posicion}
[ASC | DESC], ... [WITH ROLLUP]]
[HAVING condiciones]
[ORDER BY {nombre_col | expresion | posicion}
[ASC | DESC] ,...]
[LIMIT {[desplazamiento,] contador | contador OFFSET
desplazamiento}]

54
La sentencia SELECT
También podemos aplicar funciones sobre columnas de tablas, y usar esas
columnas en expresiones para generar nuevas columnas:
curso=# SELECT id, nombre , CURRENT_DATE FROM
ciudad3;
curso
id | nombre | date
-------+----------------------+------------
80000 | Roma | 2010-06-03
(1 fila)

55
La sentencia SELECT
Alias
Aprovechemos la ocasión para mencionar que también es posible asignar
un alias a cualquiera de las expresiones select. Esto se puede hacer usando
la palabra AS, aunque esta palabra es opcional:
curso=# SELECT id AS codigoAS codigo, nombre , CURRENT_DATE FROM
ciudad3;
curso
codigo | nombre | date
--------+----------------------+------------
80000 | Roma | 2010-06-03
(1 fila)

56
La sentencia SELECT
Where
Lo que es más útil de una base de datos es la posibilidad de hacer consultas
en función de ciertas condiciones. Generalmente nos interesará saber qué filas
se ajustan a determinados parámetros. Por supuesto, SELECT permite usar
condiciones como parte de su sintaxis, es decir, para hacer selecciones.
Concretamente mediante la cláusula WHERE, veamos algunos ejemplos:e
curso=# SELECT id AS codigo, nombre , CURRENT_DATE FROM
ciudad3 WHERE id=80000;
curso
--------+----------------------+------------
80000 | Roma | 2010-06-03
(1 fila)
curso=#

57
La sentencia SELECT
Where
curso=# SELECT id AS codigo, nombre , CURRENT_DATE FROM
ciudad3 WHERE id>80 AND id<100000;
curso
--------+----------------------+------------
80000 | Roma | 2010-06-03
(1 fila)
curso=#
En una cláusula WHERE se puede usar cualquier función disponible en PostgreSQL,
excluyendo sólo las de resumen o reunión, que veremos en el siguiente punto. Esas
funciones están diseñadas específicamente para usarse en cláusulas GROUP BY.
También se puede aplicar lógica booleana para crear expresiones complejas.
Disponemos de los operadores AND, OR, XOR y NOT.

58
La sentencia SELECT
Group by
curso=# SELECT fecha FROM gente GROUP BY fecha;
curso
fecha
------------
2010-12-20
2009-11-20
2010-11-20
2008-01-12
(5 filas)
curso=#
Es posible agrupar filas en la salida de una sentencia SELECT según los distintos
valores de una columna, usando la cláusula GROUP BY. Esto, en principio, puede
parecer redundante, ya que podíamos hacer lo mismo usando la opción DISTINCT.
Sin embargo, la cláusula GROUP BY es más potente:

59
La sentencia SELECT
Group by
curso=# SELECT fecha, COUNT(*) AS cuenta FROM gente GROUP BY
fecha;
curso
fecha | cuenta
------------+--------
| 1
2010-12-20 | 1
2009-11-20 | 1
2010-11-20 | 1
2008-01-12 | 2
(5 filas)
curso=#
Pero la diferencia principal es que el uso de la cláusula GROUP BY permite usar
funciones de resumen o reunión. Por ejemplo, la función COUNT(), que sirve para
contar las filas de cada grupo:

60
La sentencia SELECT
curso=# SELECT MAX(nombre) FROM gente;
curso
max
--------
Centec
(1 fila)
curso=#
Existen otras funciones de resumen o reunión, como MAX(), MIN(), SUM(),
AVG(), STD(), VARIANCE()...
Estas funciones también se pueden usar sin la cláusula GROUP BY siempre que no
se proyecten otras columnas:
Pruebe el uso y resultado de estas funciones MAX(), MIN(), SUM(), AVG(),
STD(), VARIANCE()

61
La sentencia SELECT
curso=# SELECT * FROM gente ORDER BY fecha;
curso=# SELECT * FROM gente ORDER BY fecha DESC;
curso=# SELECT * FROM gente ORDER BY fecha ASC;
curso=#
Además, podemos añadir una cláusula de orden ORDER BY para obtener resultados
ordenados por la columna que queramos.
Existe una opción para esta cláusula para elegir el orden, ascendente o descendente.
Se puede añadir a continuación ASC o DESC, respectivamente. Por defecto se usa el
orden ascendente.

62
La sentencia SELECT
Las cláusulas "limit" y "offset" se usan para restringir los registros que se retornan en
una consulta "select".
La cláusula limit recibe un argumento numérico positivo que indica el número
máximo de registros a retornar; la cláusula offset indica el número del primer
registro a retornar. El número de registro inicial es 0 (no 1).
Si el limit supera la cantidad de registros de la tabla, se limita hasta el último
registro.
Ejemplo:
select * from libros limit 4 offset 0;
Muestra los primeros 4 registros, 0,1,2 y 3.

63
La sentencia SELECT
Si escribimos:
select * from libros limit 4 offset 5;
recuperamos 4 registros, desde el 5 al 8.
Si se coloca solo la cláusula limit retorna tantos registros como el valor indicado,
comenzando desde 0. Ejemplo:
select * from libros limit 8;
Muestra los primeros 8 registros.

64
La sentencia SELECT
Es conveniente utilizar la cláusula order by cuando utilizamos limit y offset, por
ejemplo:
select * from libros order by codigo limit 8;

65
Consultas Multitablas con PostgreSQL
Hasta ahora todas las consultas que hemos usado se refieren sólo a una tabla,
pero también es posible hacer consultas usando varias tablas en la misma
sentencia SELECT.
Esto nos permite realizar otras dos operaciones de álgebra relacional:
el producto cartesiano y
la composición.

66
El producto cartesiano
curso=# SELECT * FROM personas2,telefonos2;
El producto cartesiano de dos tablas son todas las combinaciones de todas
las filas de las dos tablas.
Usando una sentencia SELECT se hace proyectando todos los atributos de
ambas tablas. Los nombres de las tablas se indican en la cláusula FROM
separados con comas:

67
Composiciones JOIN
curso=# SELECT * FROM personas2, telefonos2
-> WHERE personas2.id=telefonos2.id;
curso=#
Se trata de un producto cartesiano restringido, las tuplas que se emparejan
deben cumplir una determinada condición.
En el ejemplo anterior tenemos 24 tuplas procedentes del producto cartesiano
de las tablas personas2 y teléfonos2. Si la condición para la composición es
que personas2.id=telefonos2.id, tendremos que eliminar todas las tuplas en
que la condición no se cumpla.

68
Composiciones JOIN
curso=# SELECT * FROM personas2, telefonos2
-> WHERE personas2.id=telefonos2.id;
Esta consulta es equivalente a estas otras:
curso=# SELECT * FROM personas2 JOIN telefonos2
-> ON (personas2.id = telefonos2.id);
-> WHERE (personas2.id = telefonos2.id);
curso=# SELECT * FROM personas2 INNER JOIN telefonos2
curso=# SELECT * FROM personas2 CROSS JOIN telefonos2
USING(id);

69
Composiciones JOIN
Al contrario que con las composiciones internas, las externas no proceden
de un producto cartesiano. Por lo tanto, en estas pueden aparecer tuplas que
no aparecen en el producto cartesiano.
Para hacer una composición externa se toman las tuplas de una de las tablas
una a una y se combinan con las tuplas de la otra.
curso=# SELECT * FROM personas2 LEFT JOIN telefonos2 USING(id);
curso=# SELECT * FROM tabla1 RIGHT JOIN tabla2 USING(id);

70
Los operadores relacionales (o de comparación) nos permiten comparar dos
expresiones, que pueden ser variables, valores de campos, etc.
Hemos aprendido a especificar condiciones de igualdad para seleccionar
registros de una tabla; por ejemplo:
select * from libros
where autor='Borges';
Utilizamos el operador relacional de igualdad.
Los operadores relacionales vinculan un campo con un valor para que
PostgreSQL compare cada registro (el campo especificado) con el valor dado.

71
Los operadores relacionales son los siguientes:
= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual

72
IF Elección en función de una expresión booleana
IFNULL Elección en función de si el valor de una expresión es NULL
NULLIF Devuelve NULL en función del valor de una expresiónd
Funciones de control de flujo

73
PostgreSQL tiene algunas funciones para trabajar con cadenas de caracteres.
Estas son algunas:
char_length(string): Retorna la longitud del texto.
upper(string): Retorna el texto convertido a mayúsculas.
lower(string): Retorna el texto convertido a minúsculas.
position(string in string): Retorna la posición de un string dentro de otro. Si no
está contenido retorna un 0.
substring(string [from int] [for int]): Retorna un substring, le indicamos la
posición inicial y la cantidad de caracteres a extraer desde dicha posición.
Funciones Texto

74
trim([leading|trailing|both] [string] from string): Elimina caracteres del
principio o o final de un string. Por defecto elimina los espacios en blanco si no
indicamos el caracter o string.
ltrim(string,string): Elimina los caracteres de la izquierda según el dato del
segundo parámetro de la función.
rtrim(string,string): Elimina los caracteres de la derecha según el dato del
segundo parámetro de la función.
Funciones Texto

75
substr(text,int[,int]): Retorna una subcadena a partir de la posición que le
indicamos en el segundo parámetro hasta la posición indicada en el tercer
parámetro.
lpad(text,int,text): Rellena de caracteres por la izquierda. El tamaño total de
campo es indicado por el segundo parámetro y el texto a insertar se indica en el
tercero.
rpad(text,int,text): Rellena de caracteres por la derecha. El tamaño total de
campo es indicado por el segundo parámetro y el texto a insertar se indica en el
tercero.
Funciones Texto

76
Usuarios y Privilegios
Hasta ahora hemos usado sólo el usuario 'postgres', que es el administrador,
y que dispone de todos los privilegios disponibles en PostgreSQL.
Sin embargo, normalmente no será una buena práctica dejar que todos los
usuario con acceso al servidor tengan todos los privilegios.
Para conservar la integridad de los datos y de las estructuras será conveniente
que sólo algunos usuarios puedan realizar
determinadas tareas, y que otras, que requieren mayor conocimiento sobre las
estructuras de bases de datos y tablas, sólo puedan realizarse por un número
limitado y controlado de usuarios.

77
Los conceptos de usuarios y privilegios están íntimamente relacionados. No se
pueden crear usuarios sin asignarle al mismo tiempo privilegios.
De hecho, la necesidad de crear usuarios está ligada a la necesidad de limitar
las acciones que tales usuarios pueden llevar a cabo.
PostgreSQL permite definir diferentes usuarios, y además, asignar a cada uno
determinados privilegios en distintos niveles o categorías de ellos.

78
En PostgreSQL existen niveles distintos de privilegios:
Globales: se aplican al conjunto de todas las bases de datos en un servidor. Es
el nivel más alto de privilegio, en el sentido de que su ámbito es el más
general.
De base de datos: se refieren a bases de datos individuales, y por extensión, a
todos los objetos que contiene cada base de datos.
De tabla: se aplican a tablas individuales, y por lo tanto, a todas las columnas
de esas tabla

79
Un usuario 'anonimo' podrá abrir una sesión PostgreSQL mediante una orden:
shell> psql -h localhost -U anonimo -d curso -W
Contraseña para usuario anonimo:
Pero no podrá hacer mucho más, ya que no tiene privilegios.
No tendrá, por ejemplo, oportunidad de hacer selecciones de datos,
de crear bases de datos o tablas, insertar datos, etc.

80
Para que un usuario pueda hacer algo más que consultar algunas variables
del sistema debe tener algún privilegio. Lo más simple es conceder el
privilegio para seleccionar datos de una tabla concreta. Esto se haría así:
La misma sentencia GRANT se usa para añadir privilegios a un usuario
existente.
curso=# GRANT SELECT ON public.curso TO anonimo;
GRANT
Esta sentencia concede al usuario 'anonimo' el privilegio de ejecutar sentencias
SELECT sobre la tabla 'curso' del esquema 'public'.

81
Sintaxis:
GRANT { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES |
TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] nombre_tabla [, ...]
TO { nombre_usuario | GROUP nombre_grupo | PUBLIC } [, ...] [ WITH GRANT
OPTION ]
GRANT { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE nombre_bd [, ...]
TO { nomnbre_usuario | GROUP nombre_grupo | PUBLIC } [, ...] [ WITH GRANT
OPTION ]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION nombre_función ( [ [ modo_arg ] [ nombre_arg ] tipo_arg [, ...] ] ) [, ...]
TO { nombre_usuario | GROUP nombre_grupo | PUBLIC } [, ...] [ WITH GRANT
OPTION ]

82
Se pueden conceder varios privilegios en una única sentencia. Por ejemplo:
curso=# GRANT SELECT, UPDATE ON public.curso TO anonimo ;
GRANT

83
Podemos ver qué privilegios se han concedido a un usuario mediante
la sentencia z. Por ejemplo:
curso=> z
Privilegios para base de datos «curso»
Schema | Nombre | Tipo |
Privilegios
--------+---------------------------+-----------+
-------------------------------------------------
public | cursantes | tabla |
public | cursantes_id_cursante_seq | secuencia |
public | curso | tabla |
{postgres=arwdRxt/postgres,anonimo=r/postgres}
public | curso_id_curso_seq | secuencia |
public | curso_sl | tabla |
{postgres=arwdRxt/postgres,anonimo=rd/postgres}
(5 filas)

84
Para eliminar usuarios se usa la sentencia DROP USER.
curso=# drop user anonimo;
DROP ROLE

85
Sintaxis:
REVOKE [ GRANT OPTION FOR ]
{ { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES |
TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] nombre_tabla [, ...]
FROM { nombre_usuario | GROUP nombre_grupo | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
{ { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE nombre_bd [, ...]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION nombre_función ( [ [ modo_arg ] [ nombre_arg ]
tipo_arg [, ...] ] ) [, ...]
Para eliminar los privilegios de un rol o grupo hay usar la sentencia REVOKE

86
CURSO DE POSTGRESQL DESARROLLADORES
ELEMENTOS BASICOS
Centro de EstudiosCentro de Estudios
Tecnológicos AvanzadosTecnológicos Avanzados
Euclides Figueroa
efigueroah@gmail.com
Gracias por tu Participación

58517228 postgre sql-desarrolladoresbasico

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Destaque

Destaque (9)

Semelhante a 58517228 postgre sql-desarrolladoresbasico

Semelhante a 58517228 postgre sql-desarrolladoresbasico (20)

Mais de Lucia Zambrano Franco

Mais de Lucia Zambrano Franco (9)

58517228 postgre sql-desarrolladoresbasico