58517228 postgre sql-desarrolladoresbasico

1,092 views
992 views

Published on

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,092
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
27
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

58517228 postgre sql-desarrolladoresbasico

  1. 1. 1 CURSO DE POSTGRESQL DESARROLLADORES ELEMENTOS BASICOS Euclides Figueroa efigueroah@gmail.com Centro de EstudiosCentro de Estudios Tecnológicos AvanzadosTecnológicos Avanzados Bienvenidos
  2. 2. 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. 3. 3 Contenido Programático  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. 4. 4 Contenido Programático  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. 5. 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. 6. 6 Arquitectura de PostgreSQL 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. 7. 7 Arquitectura de PostgreSQL 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. 8. 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. 9. 9 Instalación y Archivos de Configuración de PostgreSQL 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. 10. 10 Instalación y Archivos de Configuración de PostgreSQL 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. 11. 11 Programas Clientes para el Usuario PROGRAMAS DE ADMINISTRACION Y MONITOREO ADMINISTRACION psql pgadminIII OTROS PROGRAMAS phppgadmin otros
  12. 12. 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. 13. 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. 14. 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. 15. 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. 16. 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. 17. 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. 18. 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 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. 19. 19 Creando Bases de Datos 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. 20. 20 Creando Bases de Datos 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. 21. 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. 22. 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
  23. 23. 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. 24. 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. 25. 25 Definición de columnas 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. 26. 26 Definición de columnas 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. 27. 27 Definición de columnas 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. 28. 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. 29. 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. 30. 30 Indices Claves primarias curso=# CREATE TABLE ciudad3 ( curso(# id INTEGER PRIMARY KEY, curso(# nombre CHAR(20) NOT NULL, curso(# poblacion INT NULL curso(# ); NOTICE: CREATE TABLE / PRIMARY KEY creará el índice implícito «ciudad3_pkey» para la tabla «ciudad3» CREATE TABLE
  31. 31. 31 Indices Claves primarias curso=# CREATE TABLE ciudad2 ( curso(# id serial PRIMARY KEY, curso(# nombre CHAR(20) NOT NULL, curso(# poblacion INT NULL 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. 32. 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. 33. 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. 34. 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. 35. 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. 36. 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. 37. 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. 38. 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. 39. 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. 40. 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. 41. 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. 42. 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. 43. 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. 44. 44 Eliminando Bases de Datos 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 Listado de relaciones Esquema | Nombre | Tipo | Dueño ---------+---------+-------+---------- public | borrame | table | postgres (1 fila)
  45. 45. 45 Eliminando Bases de Datos 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 postgres psql (8.4.2) Ahora está conectado a la base de datos «postgres». postgres=# DROP DATABASE borrame; DROP DATABASE
  46. 46. 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. 47. 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. 48. 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. 49. 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. 50. 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. 51. 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. 52. 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. 53. 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. 54. 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. 55. 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. 56. 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 codigo | nombre | date --------+----------------------+------------ 80000 | Roma | 2010-06-03 (1 fila) curso=#
  57. 57. 57 La sentencia SELECT Where curso=# SELECT id AS codigo, nombre , CURRENT_DATE FROM ciudad3 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. 58. 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. 59. 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. 60. 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. 61. 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. 62. 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. 63. 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. 64. 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. 65. 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. 66. 66 Consultas Multitablas con PostgreSQL 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. 67. 67 Consultas Multitablas con PostgreSQL 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. 68. 68 Consultas Multitablas con PostgreSQL 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. 69. 69 Consultas Multitablas con PostgreSQL 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. 70. 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. 71. 71 Operadores de PostgreSQL Los operadores relacionales son los siguientes: = igual <> distinto > mayor < menor >= mayor o igual <= menor o igual
  72. 72. 72 Funciones de PostgreSQL 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. 73. 73 Funciones de PostgreSQL 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. 74. 74 Funciones de PostgreSQL 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. 75. 75 Funciones de PostgreSQL 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. 76. 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. 77. 77 Usuarios y Privilegios 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. 78. 78 Usuarios y Privilegios 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. 79. 79 Usuarios y Privilegios 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. 80. 80 Usuarios y Privilegios 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. 81. 81 Usuarios y Privilegios 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. 82. 82 Usuarios y Privilegios Se pueden conceder varios privilegios en una única sentencia. Por ejemplo: curso=# GRANT SELECT, UPDATE ON public.curso TO anonimo ; GRANT
  83. 83. 83 Usuarios y Privilegios 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. 84. 84 Usuarios y Privilegios Para eliminar usuarios se usa la sentencia DROP USER. curso=# drop user anonimo; DROP ROLE
  85. 85. 85 Usuarios y Privilegios 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. 86. 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

×