58517228 postgre sql-desarrolladoresbasico

1

CURSO DE POSTGRESQL DESARROLLADORESELEMENTOS BASICOS

Euclides [email protected]

Centro de Estudios Centro de Estudios Tecnológicos AvanzadosTecnológicos Avanzados

Bienvenidos

2

Contenido Programático

Arquitectura de PostgreSQLInstalación de PostgreSQL (Linux/Windows)Iniciando, Deteniendo y ConfigurandoProgramas Clientes de PostgreSQL

● phppgadmin (apache,php,Postgresql)● psql

El programa psql

3


Creando Bases de DatosCreando tablas

● definición de columnas● valores nulos● indices● claves primarias● claves secundarias

show tables – valores nulosInsertando datos insertReemplazando Valores (replace y update)Eliminando registros

4


Consultando Registros● La sentencia select● inner, left, right - join● alias● consultas multitablas● agrupando y sumarizando

Operadores de PostgreSQLFunciones de PostgreSQLUsuarios y privilegios

5

Arquitectura de PostgreSQL

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 OperativoTCP/IP Local, remota TodosUnix socket file Solo Local Solo UnixNamed 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 tipode 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 arranqueEvaluació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:

linuxwindows

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

psqlpgadminIII

OTROS PROGRAMAS

phppgadminotros

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 PostgreSQL Conectarse 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.

# psqlpsql (8.4.2)Digite «help» para obtener ayuda.

postgres=# helpEstá 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 salirpostgres=#

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

Creando Bases de Datos

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 modificarsus 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>

20


Podemos averiguar cuántas bases de datos existen en nuestro sistema usando la sentencia \l :

postgres=# \l Listado de base de datos Nombre | Dueño | Codificación | Collation | Ctype | Privilegios -----------+----------+--------------+-------------+-------------+----------------------- postgres | postgres | UTF8 | es_ES.UTF-8 | es_ES.UTF-8 | template0 | postgres | UTF8 | es_ES.UTF-8 | es_ES.UTF-8 | =c/postgres : postgres=CTc/postgres template1 | postgres | UTF8 | es_ES.UTF-8 | es_ES.UTF-8 | =c/postgres : postgres=CTc/postgres(4 filas)

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 lascolumnas:

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 cursopsql (8.4.2)Ahora está conectado a la base de datos «curso».curso=# CREATE TABLE gente (nombre VARCHAR(40), fecha DATE);CREATE TABLE

23

Creando Tablas

Podemos consultar cuántas tablas y qué nombres tienen en una base de datos, usando la sentencia:

\dt

curso=# \dt Listado de relaciones Esquema | Nombre | Tipo | Dueño ---------+--------+-------+---------- public | gente | table | postgres(1 fila)

curso=#

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 NULLcurso(# );CREATE TABLE

29

Indices

Claves primarias

También se puede definir una clave primaria sobre unacolumna, usando la palabra clave KEY o PRIMARY KEY.

Sólo puede existir una clave primaria en cada tabla, y lacolumna sobre la que se define una clave primaria nopuede tener valores NULL.

Si esto no se especifica de forma explícita, PostgreSQL lo hará de forma automática.

30

Indices

Claves primarias

curso=# CREATE TABLE ciudad3 (curso(# id INTEGER PRIMARY KEY,curso(# nombre CHAR(20) NOT NULL, curso(# poblacion INT NULLcurso(# );

NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «ciudad3_pkey» para la tabla «ciudad3»CREATE TABLE

31

Indices

Claves primarias

curso=# CREATE TABLE ciudad2 (curso(# id serial PRIMARY KEY,curso(# nombre CHAR(20) NOT NULL, curso(# poblacion INT NULLcurso(# );

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

IndicesClaves ÚnicasEl tercero permite definir índices con claves únicas, también sobre una columna, sobre varias o sobre partes decolumnas. Para definir índices con claves únicas se usa laopció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

IndicesClaves 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


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


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


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


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


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 ForaneasLas 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 ForaneasLa 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 Listado de relaciones Esquema | Nombre | Tipo | Dueño ---------+---------+-------+---------- 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 DATABASEpostgres=# \c borramepsql (8.4.2)Ahora está conectado a la base de datos «borrame».borrame=# CREATE TABLE borrame(id int, nombre char(40));CREATE TABLEborrame=# \dt Listado de relaciones Esquema | Nombre | Tipo | Dueño ---------+---------+-------+---------- public | borrame | table | postgres(1 fila)

45


borrame=# \l Listado de base de datos Nombre | Dueño | Codificación | Collation |...-----------+----------+--------------+------------- borrame | postgres | UTF8 | es_ES.UTF-8 |... curso | postgres | UTF8 | es_ES.UTF-8 |... euclides | postgres | UTF8 | es_ES.UTF-8 |... postgres | postgres | UTF8 | es_ES.UTF-8 |... template0 | postgres | UTF8 | es_ES.UTF-8 |... template1 | postgres | UTF8 | es_ES.UTF-8 |...(6 filas)

borrame=# \c postgrespsql (8.4.2)Ahora está conectado a la base de datos «postgres».postgres=# DROP DATABASE borrame;DROP DATABASE

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 1curso=# SELECT * from ciudad3; curso id | nombre | poblacion -------+----------------------+----------- 80000 | Roma | (1 fila)curso=# UPDATE ciudad3 SET poblacion=poblacion*1.10;UPDATE 1curso=# 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

Eliminando registros

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

Eliminando registros

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 PostgreSQLLa 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_tablasWHERE 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 FROMciudad3; curso id | nombre | date -------+----------------------+------------ 80000 | Roma | 2010-06-03(1 fila)

55

La sentencia SELECT

AliasAprovechemos 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 FROMciudad3; curso codigo | nombre | date --------+----------------------+------------ 80000 | Roma | 2010-06-03(1 fila)

56

La sentencia SELECT

WhereLo 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 FROMciudad3 WHERE id=80000; curso codigo | nombre | date --------+----------------------+------------ 80000 | Roma | 2010-06-03(1 fila)

curso=#

57

La sentencia SELECT

Wherecurso=# SELECT id AS codigo, nombre , CURRENT_DATE FROMciudad3 WHERE id>80 AND id<100000; curso codigo | nombre | date --------+----------------------+------------ 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);curso=# SELECT * FROM personas2 JOIN telefonos2-> WHERE (personas2.id = telefonos2.id);curso=# SELECT * FROM personas2 INNER JOIN telefonos2-> ON (personas2.id = telefonos2.id);curso=# SELECT * FROM personas2 CROSS JOIN telefonos2-> ON (personas2.id = telefonos2.id);curso=# SELECT * FROM personas2 JOIN telefonos2 USING(id);

69


Composiciones JOINAl 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

Operadores de PostgreSQL

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

Operadores de PostgreSQL

Los operadores relacionales son los siguientes:

= igual<> distinto> mayor< menor>= mayor o igual<= menor o igual

72

Funciones de PostgreSQL

IF Elección en función de una expresión booleanaIFNULL Elección en función de si el valor de una expresión es NULLNULLIF 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 -WContraseñ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 elprivilegio 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 ]

REVOKE [ GRANT OPTION FOR ] { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] } ON DATABASE nombre_bd [, ...] FROM { nombre_usuario | GROUP nombre_grupo | PUBLIC } [, ...] [ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] } ON FUNCTION nombre_función ( [ [ modo_arg ] [ nombre_arg ] tipo_arg [, ...] ] ) [, ...] FROM { nombre_usuario | GROUP nombre_grupo | PUBLIC } [, ...] [ CASCADE | RESTRICT ]

Para eliminar los privilegios de un rol o grupo hay usar la sentencia REVOKE

86

CURSO DE POSTGRESQL DESARROLLADORESELEMENTOS BASICOS

Centro de Estudios Centro de Estudios Tecnológicos AvanzadosTecnológicos Avanzados

Euclides [email protected]

Gracias por tu Participación

Documents

58517228 postgre sql-desarrolladoresbasico