Lenguaje SQL para Postgres 8.

4

Contenido
Contenido...................................................................................................................1 Principales características..........................................................................................6 Limites..................................................................................................................... 7 ‐ Instrucciones del leguaje SQL...............................................................................9 BLOQUES.............................................................................................................. 9 COMENTARIOS....................................................................................................11 MANEJO DE LAS COMILLAS.................................................................................11 VARIABLES Y CONSTANTES................................................................................13 CONSTANTES Y VARIABLES CON VALORES POR OMISION..................................13 VARIABLES PASADAS A LAS FUNCIONES............................................................14 ‐ Elementos básicos de la sintaxis.........................................................................15 Asignación..........................................................................................................15 SELECT INTO......................................................................................................15 Regreso de una Función.....................................................................................18 Condicionales.....................................................................................................19 Ciclos Simples.................................................................................................... 22 Atrapar los Errores.............................................................................................25 Tipos de datos....................................................................................................... 27 Tipos String........................................................................................................27 Tipos Numéricos ................................................................................................28 Tipos de Fecha y Hora........................................................................................28 Esquemas (Schemas) ...........................................................................................29 Creación y uso....................................................................................................29 - La estructura de almacenamiento básica (la tabla)...........................................30 Generalidades....................................................................................................30 Creación de tabla vía SELECT.............................................................................31 Modificación de Tablas ......................................................................................32 Eliminación de Tablas ........................................................................................34 - Constraints (Restricciones)..................................................................................34 Column constraints ...........................................................................................35

Centro Ing. BARJ 2011

Ejecutivo Página 1

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 ‐ La normalización de las tablas............................................................................36 Grados de normalización....................................................................................36 Primera Forma Normal.......................................................................................37 Segunda Forma Normal......................................................................................37 Tercera Forma Normal.......................................................................................37 ¿Qué tan lejos debe llevar la normalización?.....................................................40 Ejemplos de Normalización................................................................................42 ‐ Instrucción DML .................................................................................................44 ‐ Filtrar datos.........................................................................................................44 - Totalizar y agrupar datos (Consultas con Agregación) ......................................47 Having................................................................................................................47 - Sub –consultas (Consultas Anidadas).................................................................48 - Combinar 2 tablas (Uso de Join).........................................................................49 Inner Join ........................................................................................................... 49 Outer Join ..........................................................................................................50 - Clausula UNION...................................................................................................54 - Instrucción Update, delete, insert......................................................................56 Insert Into...........................................................................................................56 Update................................................................................................................56 Delete.................................................................................................................56 Secuencias ........................................................................................................... 58 Creación (DDL) ..................................................................................................58 Vistas..................................................................................................................... 60 Procedimientos Almacenados ...............................................................................61 Procedimientos Almacenados en SQL ...............................................................62 Procedimientos Almacenados en Plpgsql ..........................................................63 Triggers ................................................................................................................ 65 Variables especiales ..........................................................................................67 Transacciones .......................................................................................................68 Ejercicios Entidad – Relación.................................................................................72 Funciones de PostgreSQL......................................................................................74 Funciones SQL....................................................................................................74 Funciones Matemáticas......................................................................................74 Centro Ing. BARJ 2011 Ejecutivo Página 2 Trinity CEET

Lenguaje SQL para Postgres 8.4 Funciones de Texto............................................................................................75 Funciones de Fecha/Hora...................................................................................77 Funciones de Formato........................................................................................78

Centro Ing. BARJ 2011

Ejecutivo Página 3

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Introducción
El presente documento, tiene por finalidad servir de guía para los usuarios de nivel medio en PostgreSQL. El lector podrá fácilmente encontrar ejemplos de estructuras y guías de ejercicios que le servirán para poder implementar consultas en base de datos de producción. Esta guía es un documento teórico - practico donde se sustraen las principales sentencias del lenguaje, además se muestran una serie de ejercicios y casos donde se podrá resolver situaciones reales de entornos de gestión de datos típicos. El objetivo de este curso es familiarizar a profesionales de los Sistemas de Información en la administración y mantenimiento de bases de datos PostgreSQL. En la actualidad, PostgreSQL es útil tanto para entornos de trabajo personales, pequeños departamentos o grandes organizaciones, pues tiene sencillez de instalación y potencia para responder a grandes sistemas.

Objetivos
• • Conocer las características y las funcionalidades de PostgreSQL. Servir como una guía para iniciados y usuarios nivel medio en PostgreSQL. Su contenido pretende ser una base al lector para interiorizarse en el uso completo de uno de los motores de base de datos más completos del mercado. Conocer la sintaxis de las principales sentencias SQL soportadas por la tecnología y terminología asociada al uso de bases de datos relacionales y bases de datos objeto-relacionales. Describir el lenguaje SQL desarrolladas con PL/pgSQL. y mostrar ejemplos reales de funciones

• •

Diseñar bases de datos y acceso a la información mediante consultas SQL,

Centro Ing. BARJ 2011

Ejecutivo Página 4

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Metodología de enseñanza
La metodología utilizada será eminentemente práctica, donde se hará necesario la participación activa del alumno, mediante preguntas y dinámicas realizadas por el docente, el cual hará uso las siguientes herramientas, de las cuales se recibirá instrucciones y documentación, así como el apoyo necesario: - Material de estudio, además de las presentaciones del consultor. - Materiales, documentación adicional sobre el curso - Bibliografía, donde te permitirá consultar las recomendaciones bibliográficas que el profesor indica. - Correo del docente, se utilizará para informar al alumno, y enviarle documentación y ejercicios, que el alumno deberá devolver con el mismo sistema. - Blog Informativo, se publicaran artículos sobre las sesiones de clases las cuales podrán ser descargadas y quedaran como bitácora del curso.

Perfil profesional de los expertos
Docente altamente calificado, con gran experiencia en el desarrollo de aplicaciones, manejo y administración de base de datos en múltiples gestores. El instructor designado es el Ingeniero Bernardo Antonio Robelo Jirón, el cual se ha desempeñado como docente en cursos similares de SQL para instituciones gubernamentales, y financieras además de su experiencia como consultor independiente para firmas internacionales, tiene una amplia experiencia docente.

Centro Ing. BARJ 2011

Ejecutivo Página 5

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Características Principales
PostgreSQL es un potente sistema de base de datos relacional libre (open source, su código fuente está disponible) liberado bajo licencia BSD. Tiene más de 15 años de activo desarrollo y arquitectura probada que se ha ganado una muy buena reputación por su confiabilidad e integridad de datos. Funciona en todos los sistemas operativos importantes, incluyendo Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64), y Windows. El desarrollo de PostgreSQL es realizado por un equipo de desarrolladores (voluntarios en su mayoría) dispersos alrededor del mundo y comunicados vía Internet. Este es un proyecto de la comunidad y no es controlado por ninguna compañía. PostgreSQL es un servidor de base de datos relacional libre, liberado bajo la licencia BSD. Es una alternativa a otros sistemas de bases de datos de código abierto (como MySQL, Firebird y MaxDB), así como sistemas propietarios como SQL Server, Oracle o DB2.

Principales características
• Soporta casi toda la sintaxis SQL tiene soporte total para foreign keys, joins, views, triggers, y stored procedures (en multiples lenguajes). • Integridad transaccional, obedece completamente a la especificación ACID. • Acceso concurrente multiversión, MVCC Control de Concurrencia MultiVersión (Multi-Version Concurrency Control), no se bloquean las tablas, ni siquiera las filas, cuando un proceso escribe. Es la tecnología que PostgreSQL usa para evitar bloqueos innecesarios. Mediante el uso de MVCC, PostgreSQL evita el problema de que procesos lectores estén esperando a que se termine de escribir. En su lugar, PostgreSQL mantiene una ruta a todas las transacciones realizadas por los usuarios de la base de datos. PostgreSQL es capaz entonces de manejar los registros sin necesidad de que los usuarios tengan que esperar a que los registros estén disponibles. • Cliente/Servidor: PostgreSQL usa una arquitectura proceso-por-usuario cliente/servidor. Esta es similar al método del Apache 1.3.x para manejar procesos. Hay un proceso maestro que se ramifica para proporcionar conexiones adicionales para cada cliente que intente conectar a PostgreSQL.

Centro Ing. BARJ 2011

Ejecutivo Página 6

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 • Write Ahead Logging (WAL): La característica de PostgreSQL conocida como Write Ahead Logging incrementa la dependencia de la base de datos al registro de cambios antes de que estos sean escritos en la base de datos. Esto garantiza que en el hipotético caso de que la base de datos se caiga, existirá un registro de las transacciones a partir del cual podremos restaurar la base de datos. Esto puede ser enormemente beneficioso en el caso de caída, ya que cualesquiera cambios que no fueron escritos en la base datos pueden ser recuperados usando el dato que fue previemante registrado. Una vez el sistema ha quedado restaurado, un usuario puede continuar trabajando desde el punto en que lo dejó cuando cayó la base de datos. • Lenguajes Procedurales: PostgreSQL tiene soporte para lenguajes procedurales internos, incluyendo un lenguaje nativo denominado PL/pgSQL. Este lenguaje es comparable al lenguaje procedural de Oracle, PL/SQL. Otra ventaja de PostgreSQL es su habilidad para usar Perl, Python, TCL como lenguaje procedural embebido. además de en C, C++ y, Java. • Interfaces con lenguajes de programación. La flexibilidad del API de PostgreSQL ha permitido a los vendedores proporcionar soporte al desarrollo fácilmente para el RDBMS PostgreSQL. Estas interfaces incluyen Object Pascal, Python, Perl, PHP, ODBC, Java/JDBC, Ruby, TCL, C/C++, Pike, etc. • Herencia de tablas. • Incluye la mayoría de los tipos de datos SQL92 y SQL99 (INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE, INTERVAL, y TIMESTAMP), soporta almacenamiento de objetos grandes binarios, además de tipos de datos y operaciones geométricas. • Puntos de recuperación a un momento dado, tablespaces, replicación asincrónica, transacciones jerarquizadas (savepoints), backups en línea. • Un sofisticado analizador/optimizador de consultas. Soporta juegos de caracteres internacionales, codificación de caracteres multibyte.

Limites
Es importante tener en cuenta las limitaciones que tiene PostgreSQL: • • • Máximo tamaño de base de datos ilimitado. Máximo tamaño de tabla 32 TB. Máximo tamaño de tupla 1.6 TB. Ejecutivo Página 7 Trinity CEET

Centro Ing. BARJ 2011

Lenguaje SQL para Postgres 8.4 • • • • Máximo tamaño de campo 1 GB. Máximo tuplas por tabla ilimitado. Máximo columnas por tabla 250 - 1600 dependiendo de los tipos de columnas. Máximo de índices por tabla ilimitado.

Centro Ing. BARJ 2011

Ejecutivo Página 8

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Descripción del lenguaje SQL
Dentro de PostgreSQL, la base de datos de codigo abierto más poderosa, se pueden desarrollar funciones en varios lenguajes. El lenguaje PL/pgSQL es uno de los más utilizados dentro de PostgreSQL, debido a que guarda cierta similitud con PL/SQL de Oracle y a su facilidad de uso. SQL es el lenguaje estándar para realizar consultas a un servidor de base de datos. Cada sentencia SQL se ejecuta de manera individual por el servidor, lo cual implica que las aplicaciones cliente deben enviar cada consulta al servidor, esperar a que la procese, recibir los resultados, procesar los datos y después enviar la siguiente sentencia. Al usar PL/pgSQL es posible realizar cálculos, manejo de cadenas y consultas dentro del servidor de la base de datos, combinando el poder de un lenguaje procedimental y la facilidad de uso de SQL, minimizando el tiempo de conexión entre el cliente y el servidor.

‐ Instrucciones del leguaje SQL
BLOQUES El lenguaje PL/pgSQL es estructura en bloques. Todas las palabras clave y los identificadores pueden escribirse mezclando letras mayúsculas y minúsculas. Un bloque se define de la siguiente manera:
[<<label>>] [DECLARE declaraciones] BEGIN sentencias END;

Pueden existir varios bloques o sub-bloques en la sección de sentencias de un bloque. Los sub-bloques pueden ser usados para ocultar las variables a los bloques más externos. Normalmente una de las sentencias es el valor de retorno, usando la palabra clave RETURN.

Centro Ing. BARJ 2011

Ejecutivo Página 9

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Las variables declaradas en la sección que antecede a un bloque se inicializan a su valor por omisión cada vez que se entra al bloque, no solamente al ser llamada la función.

Centro Ing. BARJ 2011

Ejecutivo Página 10

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

COMENTARIOS Existen dos tipo de comentarios en PL/pgSQL. Un doble guion – da inicio a un comentario, el cual se extiende hasta el final de la línea. Un /* inicia un bloque que se extiende hasta la primera ocurrencia de */. MANEJO DE LAS COMILLAS El código de una función PL/pgSQL se especifica en CREATE FUNCTION como una cadena literal. Si usted escribe la cadena literal de la manera común, con comillas sencillas como delimitadores, entonces cada comilla sencilla dentro del cuerpo de la función debe ser duplicada; de igual manera cualquier diagonal inversa debe ser duplicada. La duplicación de las comillas es, por lo menos, tedioso, y en los casos complejos el código se vuelve incomprensible, debido a que se pueden necesitar media docena o más de comillas sencillas contiguas. Es recomendable que mejor escriba el cuerpo de la función como una cadena literal “dollar-quoted”. Con el estilo dollarquoting usted nunca necesitará duplicar las comillas, en cambio deberá cuidar el uso de un delimitador dollar-quoting diferente para cada nivel de anidamiento que necesite. Por ejemplo, usted debe escribir el comando CREATE FUNCTION como
CREATE OR REPLACE FUNCTION testfunc(integer) RETURNS integer AS $PROC$ .... $PROC$ LANGUAGE plpgsql;

Dentro de éste, usted puede usar comillas para las cadenas literales simples en los comandos SQL y $$ para delimitar fragmentos de comandos SQL que esté ensamblando para crear cadenas más largas. Si necesita incluir en su texto $$, puede usar $Q$ y así consecutivamente. La siguiente tabla le muestra lo que debe hacer cuando escriba comillas sin delimitar su cadena con $$. Puede serle útil cuando traduzca sus funciones hechas con código en el que no se usaba $$ y para hacer más claro el código. 1 comilla Para iniciar y finalizar el cuerpo de la función, por ejemplo:
CREATE FUNCTION foo() RETURNS integer AS ’ .... ’ LANGUAGE plpgsql;

En cualquier lugar dentro del cuerpo de la función delimitada por una comilla, las comillas deben aparecer en pares. 2 comillas Para cadenas literales dentro del cuerpo de la función, por ejemplo:
a_output := “Blah”;

Centro Ing. BARJ 2011

Ejecutivo Página 11

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
SELECT * FROM users WHERE f_name=’’foobar’’;

Usando la técnica de $$, usted debería escribir
a_output := ’Blah’; SELECT * FROM users WHERE f_name=’foobar’;

Que es exactamente lo que el analizador de PL/pgSQL vería en ambos casos. 4 comillas Cuando requiera una comilla sencilla en una cadena constante dentro del cuerpo de la función, por ejemplo;
a_output := a_output || ” AND name LIKE ””foobar”” AND xyz”

El valor realmente concatenado a a_output sería: AND name LIKE ’foobar’ AND xyz. Usando la técnica de $$, usted escribiría
a_output := a_output || $$ AND name LIKE ’foobar’ AND xyz$$

Teniendo cuidado de que cualquiera de los delimitadores estilo dólar alrededor de esta cadena no sea ciertamente $$. 6 comillas Cuando una comilla sencilla en una cadena dentro del cuerpo de la función sea adyacente al final de la cadena constante, por ejemplo:
a_output := a_output || ” AND name LIKE ””foobar”””

El valor concatenado a a_output sería entonces: AND name LIKE ’foobar’. Con el estilo dólar se transformaría en:
a_output := a_output || $$ AND name LIKE ’foobar’$$

10 comillas Cuando requiera dos comillas sencillas en una cadena constante (que equivalen a 8 comillas) y ésta es adyacente al final de la cadena constante (2 más). Es probable que solamente necesite esto si está escribiendo una función que genera otras funciones. Por ejemplo:
a_output := a_output || ” if v_” || referrer_keys.kind || ” like ””””” || referrer_keys.key_string || ””””” then return ””” || referrer_keys.referrer_type || ”””; end if;”;

El valor de a_output sería entonces:
if v_... like ”...” then return ”...”; end if;

Con el estilo dólar quedaría como

Centro Ing. BARJ 2011

Ejecutivo Página 12

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
a_output := a_output || $$ if v_$$ || referrer_keys.kind referrer_keys.key_string || $$’ then return ’$$ || referrer_keys.referrer_type || $$’; end if;$$; || $$ like ’$$ ||

En donde suponemos que solamente requerimos colocar una comilla dentro de a_output debido a que será re-encomillado antes de usarse. Una variante es el escapar las comillas en el cuerpo de la función con una diagonal invertida en lugar de duplicarlas. Con este método escribiría cosas como \’\’ en lugar de ””. Algunas personas consideran esta técnica más sencilla, pero otras no.

VARIABLES Y CONSTANTES Todas las variables, filas y registros usados en un bloque o en sus sub-bloques deben declararse en la sección de declaraciones del bloque.
La excepción es la variable de un ciclo FOR que itera sobre un rango de valores enteros.

Las variables en PL/pgSQL pueden ser de cualquier tipo de datos de SQL, como INTEGER, VARCHAR y CHAR. El valor por omisión de todas las variables es el valor NULL de SQL.
A continuación se muestran algunos ejemplos de declaración de variables: user_id INTEGER; quantity NUMBER(5); url VARCHAR;

CONSTANTES Y VARIABLES CON VALORES POR OMISION
La declaraciones tienen las siguiente sintaxis: nombre [ CONSTANT ] tipo [ NOT NULL ] [ { DEFAULT | := } valor ]; El valor de una variable declarado como CONSTANT no puede ser modificado.

Si acaso se especifica NOT NULL, la asignación de un valor NULL causa en un error en tiempo de ejecución. Puesto que el valor por omisión de todas las variables es el valor NULL de SQL, todas las variables declaradas como NOT NULL deben contar con un valor por omisión especifico. EL valor se evalúa cada vez que se llama la función, así que asignar now a una variable de tipo timestamp causa que la variables almacene el tiempo real de la llamada a la función, no el de la hora en que se compiló en bytecode.
Ejemplos: cantidad INTEGER := 32;

Centro Ing. BARJ 2011

Ejecutivo Página 13

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
url varchar := ''http://misitio.com''; user_id CONSTANT INTEGER := 10; VARIABLES PASADAS A LAS FUNCIONES

Las variables que se pasan a las funciones son denominadas con los identificadores $1, $2, etc. (el máximo es 16).
Algunos ejemplos: CREATE FUNCTION iva_venta(REAL) RETURNS REAL AS ' DECLARE subtotal ALIAS FOR $1; BEGIN return subtotal * 1.15; END; ' LANGUAGE 'plpgsql'; CREATE FUNCTION instr(VARCHAR,INTEGER) RETURNS INTEGER AS ' DECLARE v_string ALIAS FOR $1; index ALIAS FOR $2; BEGIN -- Algunos calculos iran aqui. END; ' LANGUAGE 'plpgsql';

Centro Ing. BARJ 2011

Ejecutivo Página 14

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

‐ Elementos básicos de la sintaxis
En esta sección y las siguientes describimos todos los tipos de sentencias que entiende explícitamente PL/pgSQL. Cualquier cosa que no sea reconocida como una de estos tipos de sentencias se presume que es un comando SQL y se envía a la máquina de la base de datos principal para ejecutarse (después de la sustitución de cualquier variable de PL/pgSQL usada en la sentencia).

Asignación Una asignación de una valor a una variable o campo de un renglón/registro se escribe como:
identificador := expresión;

Tal como se escribió arriba, la expresión en tal sentencia es evaluada por medio de un comando SQL SELECT enviado a la máquina de la base de datos principal. La expresión debe producir un valor único. Si el tipo de dato del resultado de la expresión no coincide con el tipo de dato de la variable, o la variable tiene un tamaño/precisión específico (como char(20)), el valor resultante será convertido implícitamente por el intérprete de PL/pgSQL usando el tipo de resultado de la función de salida (output_function) y el tipo de variable de la función de entrada (input_function). Observe que esto puede resultar potencialmente en un error en tiempo de ejecución generado por la función de entrada, si la forma de la cadena del valor resultante no es aceptable para la función de entrada. Ejemplos:
id_usuario := 20; impuesto := subtotal * 0.15;

SELECT INTO El resultado de un comando SELECT que produce columnas múltiples (pero sólo un renglón) puede ser asignado a una variable registro, variable tipo-renglón o una lista de variables escalares. Esto se realiza con:
SELECT INTO meta expresiones_select FROM ...;

En donde meta puede ser una variable registro, una variable renglón o una lista de variables simples y campos registro/renglón separados por comas. Las expresiones_select y el resto del comando son iguales que en el SQL regular.

Centro Ing. BARJ 2011

Ejecutivo Página 15

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Observe que es muy diferente de la interpretación normal de SELECT INTO de PostgreSQL, en donde la meta INTO es una tabla recién creada. Si desea crear una tabla a partir de una resultado de un SELECT dentro de una función PL/pgSQL, use la sintaxis CREATE TABLE ... AS SELECT. Si un renglón o una lista de variables se usan como meta, los valores seleccionados deben coincidir exactamente con la estructura de la meta, u ocurrirá un error en tiempo de ejecución. Cuando la meta es una variable registro, automáticamente se configura siguiendo la estructura del tipo renglón de la columnas del resultado de la consulta. Las sentencias SELECT es la misma que el comando SELECT normal y puede utilizarse con todo su poder, con la excepción de la claúsula INTO. La claúsula INTO puede aparecer casi en cualquier lugar en la sentencia SELECT. Suele escribirse ya sea antes de SELECT como se muestra arriba o justo antes de FROM — es decir, justo antes o justo después de la lista de las expresiones_select. Si la consulta regresa cero renglones, se asignan valores nulos a la(s) meta(s). Si la consulta regresa múltiples renglones, se asigna el primer renglón a la(s) meta(s) y el resto se descarta. (Observe que “el primer renglón” no está bien definido a menos que haga uso de ORDER BY). Puede verificar la variable especial FOUND (vea la sección de nombre Obteniendo el Estado del Resultado) después de una sentencia SELECT INTO para determinar si la asignación fue correcta, es decir, que la consulta regresó al menos un renglón. Por ejemplo:
SELECT INTO mireg * FROM emp WHERE empnombre= minombre; IF NOT FOUND THEN RAISE EXCEPTION ’no se encontró al empleado %’, minombre; END IF;

Para probar si un resultado registro/renglón es nulo puede usar la condicional IS NULL. Sin embargo, no existe una manera de decir si han sido descartados algunos renglones adicionales. Aquí hay un ejemplo que maneja el caso en que no se han regresado renglones:
DECLARE reg_usuarios RECORD; BEGIN SELECT INTO reg_usuarios * FROM usuarios WHERE id_usuario=3;

Centro Ing. BARJ 2011

Ejecutivo Página 16

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
IF reg_usuarios.homepage IS NULL THEN -- El usuario no digitó un homepage, regresar "http://" RETURN ’http://’; END IF;

END;

Centro Ing. BARJ 2011

Ejecutivo Página 17

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Regreso de una Función Existen dos comandos que le permiten regresar datos desde una función: RETURN y RETURN NEXT. RETURN
RETURN expresión;

RETURN con una expresión termina la función y regresa el valor de expresión a quién la está llamando. Esta forma debe ser usada para las funciones PL/pgSQL que no regresan un conjunto. Cuando se regresa un tipo escalar puede usarse cualquier expresión. El resultado de la expresión será transformado (cast) automáticamente al tipo de retorno de la función, tal como se definió en la asignación. Para regresar un valor compuesto (renglón) debe escribir una variable registro o renglón como la expresión. El valor de retorno de una función no puede quedarse indefinido. Si el control alcanza el final de bloque más externo de la función sin encontrar una sentencia RETURN, se producirá un error en tiempo de ejecución. Si declaró que la función regrese void, también debe proporcionar una sentencia RETURN, pero en este caso la expresión que sigue a RETURN será opcional y será ignorada si está presente. RETURN NEXT
RETURN NEXT expresión;

Cuando se declara que una función PL/pgSQL regrese SETOF alguntipo, el procedimiento a seguir es ligeramente diferente. En este caso, los items individuales a retornar se especifican en comandos RETURN NEXT, y después un comando final RETURN sin argumentos se utiliza para indicar que la función ha terminado de ejecutarse. RETURN NEXT puede usarse con tipos escalares y compuestos; en el último caso, será regresado una “tabla” completa de resultados. Las funciones que usan RETURN NEXT deben se llamadas de la siguiente manera:
SELECT * FROM alguna_func();

Es decir, las funciones deben se usadas como una tabla fuente en una claúsula FROM. RETURN NEXT realmente no regresa de la función, simplemente almacena el

Centro Ing. BARJ 2011

Ejecutivo Página 18

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 valor de la expresión. Después, continúa la ejecución de la siguiente sentencia en la función PL/pgSQL. Al ejecutarse los comandos sucesivos RETURN NEXT, se va armando el resultado. Un RETURN final, sin argumentos, ocasiona que el control salga de la función. Nota: La implementación actual de RETURN NEXT para PL/pgSQL almacena el conjunto resultante completo antes de regresar de la función, como es explica arriba. Esto significa que si una función PL/pgSQL produce un conjunto resultante muy grande, el desempeño puede empobrecerse: los datos serán escritos en el disco para evitar el consumo de memoria, pero la función misma no regresará hasta que todo el conjunto resultante haya sido generado. Condicionales Las sentencias IF le permiten ejecutar comandos cuando se dan ciertas condiciones. PL/pgSQL tiene cinco formas de IF:
• • • • • IF IF IF IF IF ... ... ... ... ... THEN THEN THEN THEN THEN ... ... ... ... ELSE ELSE IF ELSIF ... THEN ... ELSE ELSEIF ... THEN ... ELSE

IF-THEN
IF expresión-lógica THEN sentencias END IF;

Las sentencias IF-THEN son las formas más simples de IF. Las sentencias entre THEN y END IF serán ejecutadas si la condición es verdadera. De otra manera, serán ignoradas. Ejemplo:
IF v_id_usuario <> 0 THEN UPDATE usuarios SET email = v_email WHERE id_usuario= v_id_usuario; END IF;

IF-THEN-ELSE
IF expresión-lógica THEN sentencias ELSE sentencias END IF;

Las sentencias IF-THEN-ELSE añaden funcionalidad a IF-THEN permitiéndole especificar un conjunto de sentencias alternativo que debe ejecutarse si la condición produce un valor de falso. Ejemplo:
IF parentid IS NULL OR parentid = ” THEN RETURN fullname; ELSE
RETURN hp_true_filename(parentid) || ’/’ || fullname; END IF;

Centro Ing. BARJ 2011

Ejecutivo Página 19

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

IF v_cuenta> 0 THEN INSERT INTO usuarios_cuenta(count) VALUES (v_cuenta); RETURN ’t’; ELSE RETURN ’f’; END IF;

IF-THEN-ELSE IF
Las sentencias IF pueden anidarse, como se muestra en el siguiente ejemplo: IF demo_renglon.sexo = ’m’ THEN pretty_sex := ’hombre’; ELSE IF demo_renglon.sexo = ’f’ THEN pretty_sex := ’mujer’; END IF; END IF;

Cuando se usa esta forma, realmente se está anidano la sentencia IF dentro de la parte ELSE de la sentencia IF. Así, require una sentencia END IF para cada IF anidado y una para el padre IF-ELSE. Esto funciona, pero se vuelve tedioso cuando existen varias alternativas por revisar.
De ahi que exista la siguiente forma. IF-THEN-ELSIF-ELSE IF expresión-lógica THEN sentencias [ ELSIF expresión-lógica THEN sentencias [ ELSIF expresión-lógica THEN sentencias ...]] [ ELSE sentencias ] END IF;
IF-THEN-ELSIF-ELSE

proporciona un método más conveniente para revisar varias alternativas en una sentencia. Formalmente es equivalente a los comandos anidados IF-THEN-ELSE-IF-THEN, pero solo se necesita un END IF.
A continuación en ejemplo: IF numero = 0 THEN resultado := ’cero’; ELSIF numero > 0 THEN resultado := ’positivo’; ELSIF numero < 0 THEN resultado := ’negativo’; ELSE -- hmm, la única otra posibilidad que el número sea nulo resultad := ’NULL’; END IF;

IF-THEN-ELSEIF-ELSE

Centro Ing. BARJ 2011

Ejecutivo Página 20

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 ELSEIF es un alias de ELSIF.

Centro Ing. BARJ 2011

Ejecutivo Página 21

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Ciclos Simples Con las sentencia LOOP, EXIT, WHILE y FOR, usted puede hacer que en sus funciones PL/pgSQL se repitan una serie de comandos.
LOOP [<<etiqueta>>] LOOP sentencias END LOOP;

LOOP define un ciclo incondicional que se repite indefinidamente hasta que encuentra alguna sentencia EXIT o RETURN. La etiqueta opcional puede usarse por las sentencias EXIT en los ciclos anidados para especificar que nivel de anidamiento debe terminarse. EXIT Si no se proporciona una etiqueta se termina el ciclo más interno y se ejecuta a continuación la sentencia posterior a END LOOP. Si se define una etiqueta, ésta debe ser la etiqueta del nivel actual o de algún otro más externo del ciclo anidado o del bloque. Entonces, el ciclo o bloque nombrado se termina y el control continúa con la sentencia posterior al END del ciclo/bloque correspondiente. Si WHEN está presente, la salida del ciclo ocurre solo si la condición especificada es verdadera, de otra manera, el control pasa a la sentencia después del EXIT. EXIT puede utilizarse para provocar una salida temprana de todo tipo de ciclos; no está limitado al uso de ciclos condicionales. Ejemplos:
LOOP -- algun procesamiento IF count > 0 THEN EXIT; -- salir del ciclo END IF; END LOOP; LOOP -- algún procesamiento EXIT WHEN count > 0; -- mismo resultado que en el ejemplo anterior END LOOP; BEGIN -- algún procesamiento IF stocks > 100000 THEN EXIT; -- causa la salida del bloque BEGIN END IF; END; EXIT [ etiqueta ] [ WHEN expresión ];

Centro Ing. BARJ 2011

Ejecutivo Página 22

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

WHILE
[<<etiqueta>>] WHILE expresión LOOP sentencia END LOOP;

La sentencia WHILE repite una secuencia de sentencias tanto como la expresión de la condición produzca un valor de verdadero. La condición se revisa justo antes de cada entrada al cuerpo del ciclo. Por ejemplo:
WHILE cantidad_adeudo > 0 AND balance_certificado_regalo > 0 LOOP -- algún procesamiento END LOOP; WHILE NOT expresión_lógica LOOP -- algún procesamiento END LOOP; FOR (variante con enteros) [<<etiqueta>>] FOR nombre IN [ REVERSE ] expresión .. expresión LOOP sentencias END LOOP;

Este forma de FOR crea un ciclo que itera sobre un rango de valores enteros. La variable nombre se define de manera automática como de tipo integer y existe solo dentro del ciclo. Las dos expresiones que generan los límites inferior y superior del rango, son evaluados una sola vez al entrar al ciclo. El paso de la iteración es 1 generalmente, pero es -1 cuando se especifica REVERSE. Algunos ejemplos de ciclos enteros FOR:
FOR i IN 1..10 LOOP -- algún procesamiento aquí RAISE NOTICE ’i es %’, i; END LOOP; FOR i IN REVERSE 10..1 LOOP -- algún procesamiento aquí END LOOP;

Si el límite inferior es mayor que el límite superior (o menor que, en el caso de REVERSE), el cuerpo del ciclo no se ejecuta en absoluto. No se genera un error.

Centro Ing. BARJ 2011

Ejecutivo Página 23

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Ciclos a Través de Resultados de Consultas Usando un tipo diferente de un ciclo FOR, puede iterar a lo largo de los resultados de una consulta y manipular los datos correspondientes. La sintaxis es:
[<<etiqueta>>] FOR registro_o_renglón IN consulta LOOP sentencias END LOOP;

A las variables registro o renglón les es asignado, de manera sucesiva, cada renglón resultante de la consulta (la cual debe ser un comando SELECT) y el cuerpo del ciclo se ejecuta para cada renglón. He aquí un ejemplo:
CREATE FUNCTION cs_refresca_mvistas() RETURNS integer AS $$ DECLARE mvistas RECORD; BEGIN PERFORM cs_log(’Refrescando las vistas materializadas...’); FOR mvistas IN SELECT * FROM cs_vistas_materializadas ORDER BY llave_orden LOOP -- Ahora "mvistas" tiene un registro de cs_vistas_materializadas PERFORM cs_log(’Refrescando vistas materializadas’ || quote_ident(mvistas.mv_nombre) || ’ ...’); EXECUTE ’TRUNCATE TABLE ’ || quote_ident(mvistas.mv_nombre); EXECUTE ’INSERT INTO ’ || quote_ident(mvistas.mv_nombre) || ’ ’ || mvistas.mv_consulta; END LOOP; PERFORM cs_log(’Terminado el refresco de las vistas materializadas.’); RETURN 1; END; $$ LANGUAGE plpgsql;

Si el ciclo se termina por una sentencia EXIT, el valor del último renglón asignado se encuentra accesible después del ciclo. La sentencia FOR-IN-EXECUTE es otra manera de iterar sobre los renglones:
[<<etiqueta>>] FOR registro_o_renglón IN EXECUTE texto_expresión LOOP sentencia END LOOP;

Esta es similar a la forma anterior, excepto que la sentencia SELECT fuente se especifica como una expresion en cadena, la cual es evaluada y replaneada en cada entrada al ciclo FOR. Esto le permite al programador el seleccionar la velocidad de una consulta previamente planeada o la flexibilidad de una consulta dinámica, exactamentecomo una simple sentencia EXECUTE. Nota: El analizador de PL/pgSQL distingue actualmente las dos clases de ciclos FOR (enteros o resultados de consultas) revisando si los símbolos .. aparecen fuera de Centro Ing. BARJ 2011 Ejecutivo Página 24 Trinity CEET

Lenguaje SQL para Postgres 8.4 los paréntesis entre IN y LOOP. Si no se observan los símbolos .. entonces se presume que es un ciclo sobre renglones. Si se escriben mal los símbolos .. llevará seguramente a una queja entre las líneas de “loop variable of loop over rows must be a record or row variable”, en lugar de un simple error de sintaxis que usted esperaría obtener.

Atrapar los Errores Por omisión, cualquier error que ocurra en una función PL/pgSQL aborta la ejecución de la función, en consecuencia, también la transacción que la envuelve. Usted puede atrapar los errores y recuperarse de ellos usando un bloque BEGIN con una cláusula EXCEPTION. La sintaxis es una extensión de la sintaxis normal de un bloque BEGIN.
[ <<etiqueta>> ] [ DECLARE declaraciones ] BEGIN sentencia EXCEPTION WHEN condición [ OR condición ... ] THEN sentencias_del_manejador [ WHEN condición [ OR condición ... ] THEN sentencias_del_manejador ... ] END;

Si no ocurre un error, esta forma de bloque simplemente ejecuta todas las sentencias, y el control pasa a la siguiente sentencia después de END. Pero si ocurre un error dentro de las sentencias, se abandona el resto del procesamiento, y el control se pasa a la lista EXCEPTION. En la lista se busca la primera condición que coincida con el error ocurrido. Si hay una coincidencia, se ejecuta la sentencia_del_manejador correspondiente, y el control pasa a la siguiente sentencia después de END. Si no hay alguna coincidencia, el error se propaga como si la cláusula EXCEPTION no estuviera ahí en absoluto: el error puede ser atrapado por un bloque envolvente con EXCEPTION, o si no hay ninguno se aborta el proceso de la función. Los nombres de las condiciones pueden ser cualquiera de los mostrados en el apéndice de códigos de error. Una nombre de categoría coincide con cualquier error dentro de su categoría. El nombre de la condición especial OTHERS coincide con cualquier error, excepto QUERY_CANCELED. (Es posible, pero en ocasiones improbable, atrapar QUERY_CANCELED por nombre). Los nombres de las condiciones no son sensibles a las mayúsculas.

Centro Ing. BARJ 2011

Ejecutivo Página 25

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Si ocurre un error dentro de las sentencias_del_manejador, no puede ser atrapado por esta cláusula EXCEPTION, pero si se propaga. Una cláusula EXCEPTION envolvente podría atraparla. Cuando se atrapa un error por una cláusula EXCEPTION, las variable locales de la función PL/pgSQL se mantienen como estaban cuando ocurrió el error, pero todos los cambios al estado persistente de la base de datos dentro del bloque se deshacen. Como ejemplo, considere este fragmento:
INSERT INTO miagenda(nombre, apellido) VALUES(’Joaquín’, ’Sabina’); BEGIN UPDATE miagenda SET nombre = ’Joe’ WHERE apellido = ’Sabina’; x := x + 1; y := x / 0; EXCEPTION WHEN division_by_zero THEN RAISE NOTICE ’division_by_zero atrapado’; RETURN x; END;

Cuando el control alcanza la asignación a y, fallará con un error division_by_zero. Este será atrapado por la cláusula EXCEPTION. El valor regresado en la sentencia RETURN será el valor incrementado de x, pero los efectos del comando UPDATE habrán sido deshechos. El comando INSERT que precede al bloque no se deshace, sin embargo, al final resulta que la base de datos contiene Joaquín Sabina, no Joe Sabina. Sugerencia: Un bloque que contiene una cláusula EXCEPTION es significativamente más costoso, para entrar y salir, que un bloque sin ella. Por tanto, no use EXCEPTION, a menos que sea necesario.

Centro Ing. BARJ 2011

Ejecutivo Página 26

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Base de datos relacionales
Tipos de datos
Postgres pone a disposición del usuario una gran variedad de tipos de datos pensados en cubrir necesidades específicas. Suele suceder que al modelar una base de datos se utilizan los tipos conocidos y no se da provecho a las características especiales de Postgres; mientras esto provee compatibilidad, es menudo más conveniente sacar provecho a aquellas definiciones adicionales del motor. A continuación se describen los tipos de datos más utilizados y la sugerencia de cuando es conveniente utilizarlos. Tipos String

El tipo char(n) almacena n caracteres en formato ASCII, un byte por cada letra. Cuando almacenamos datos en el tipo char, siempre se utilizan los n caracteres indicados, incluso si la entrada de datos es inferior. Por ejemplo, si en un char(5), guardamos el valor 'A', se almacena 'A ', ocupando los cinco bytes. Por su parte varchar(n) almacena n caracteres en formato ASCII, un byte por cada letra. Cuando almacenamos datos en el tipo varchar, únicamente se utilizan los caracteres necesarios, Por ejemplo, si en un varchar(255), guardamos el valor 'A', se almacena 'A', ocupando solo un byte. El tipo de dato text permite el almacenamiento de un string en cualquier formato de largo no predefinido. Este es el tipo más versátil de string. Considerando que hoy en día los espacios de almacenamiento son enormes, este tipo se recomienda en todo caso por sobre varchar. Cabe señalar que dado que text no tiene límite predefinido, entonces al momento de llevar los datos a otros sistemas con largos predefinidos no hay aviso previo de que estamos sobrepasando algún largo establecido, siendo este un punto a considerar al momento de seleccionar el tipo de dato.

Centro Ing. BARJ 2011

Ejecutivo Página 27

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Tipos Numéricos

Postgres contiene los tipos de datos nativos comúnmente conocidos int y float, para números enteros y reales respectivamente. Estos dependiendo del dígito que acompañe su nombre, indica la precisión que soporta la columna. Para grandes números se utiliza bigint, el cual suele ser utilizado para las columnas de identificadores. Cuando se requiere de gran precisión en números, virtualmente sin limitación (1000 dígitos), el tipo a utilizar es sin duda numeric. Este es recomendado para valores monetarios u cualquier dato donde la precisión es crucial. Este tipo además soporta el valor ‘NaN’ (Not A Number – No Un Numero) para indicar tal caso, además de NULL. El tipo de dato SERIAL es en realidad un atajo. En Postgres no existe un tipo autoincremental. Aquí por un lado se genera la columna con tipo BIGINT asociando al valor por defecto el siguiente valor de una secuencia creada especialmente, provocándose el efecto de auto incremento. Tipos de Fecha y Hora

En tipos de datos para fecha y hora, Postgres conserva los tipos tradicionales. Aquí el único parámetro interesante es aquel que se puede pasar a timestamp para indicar la cantidad de milisegundos a almacenar que por defecto son 6.

Centro Ing. BARJ 2011

Ejecutivo Página 28

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Esquemas (Schemas)
PostgreSQL provee un mecanismo para poder agrupar objetos dentro de una misma base de datos, de manera permitir un mayor orden en modelos con un gran número de elementos. El uso de esquemas permite, entre otras cosas, que muchos usuarios interactúen con una misma base de datos sin interferirse, organizar objetos lógicamente según su relación, tener tablas de un mismo nombre en una misma base de datos sin toparse, etc. Los esquemas son grupos de objetos. Por defecto PostgreSQL provee esquemas que existen en toda base de datos: - public: contexto publico por defecto donde se crean los objetos si no se especifica otro. - information_schema: conjunto de vistas que contienen información sobre los objetos definidos en la base de datos actual. - pg_catalog: schema que mantiene las tablas del sistema y los tipos de datos, funciones y operadores incorporados en PostgreSQL. Creación y uso
Los esquemas pueden ser creados por el usuario dueño de la base de datos, aquellos que tengan permisos de superusuario sobre la base y los superusuarios; sintaxis a continuación. CREATE SCHEMA nombre [AUTHORIZATION usuario]; Si se omite el nombre de esquema y se provee authorization, entonces se crea un esquema con el mismo nombre del usuario. Para acceder a un objeto dentro de un esquema, se utiliza la sintaxis esquema.objeto. Ejemplos: CREATE TABLE miesquema.tabla ( ... ); DROP TABLE miesquema.tabla; CREATE SEQUENCE miesquema.secuencia; SELECT * FROM miesquema.tabla as t1, miotroesquema.tabla as t2 WHERE t1.id = t2.id ;

Para eliminar un esquema se utiliza DROP SCHEMA.
DROP SCHEMA miesquema

Si se tiene dependencia de las tablas del esquema a eliminar y se quiere propagar la eliminación, se usa CASCADE.
MiBase=> DROP SCHEMA miesquema CASCADE;

Centro Ing. BARJ 2011

Ejecutivo Página 29

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

- La estructura de almacenamiento básica (la tabla)
Generalidades En Postgres existen dos formas de crear una tabla: declarándola y seleccionando un set de datos vía query. Para crear una tabla vía declaración, se tiene la siguiente sintaxis en forma simplificada. Referirse al manual de Postgres para la sintaxis completa.

La cláusula opcional INHERITS especifica una colección de nombres de tabla de las cuales esta tabla hereda todos los campos. Si algún campo heredado aparece más de una vez, Postgres informa de un error. Postgres permite automáticamente a la tabla creada heredar funciones de las tablas superiores a ella en la jerarquía de herencia. Notar que cuando se utiliza INHERITS, la tabla que hereda cambia si la tabla padre lo hace.
A través de LIKE se puede obtener el mismo resultado que INHERITS, pero con la salvedad que la tabla creada no cambia cuando el padre lo hace. La opción ON COMMIT permite establecer el comportamiento de las tablas temporales en una transacción. - PRESERVE ROWS indica que ninguna acción es realizada (por defecto). - DELETE ROWS elimina todas las filas de la tabla. - DROP elimina la tabla completa.

Ejemplos:
CREATE TABLE miesquema.ejemplo1 ( Id SERIAL PRIMARY KEY, Texto text );

Centro Ing. BARJ 2011

Ejecutivo Página 30

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Esto creará la tabla ejemplo1 en el esquema miesquema con las 2 columnas especificadas, siendo la llave primaria la columna id.
CREATE TEMP TABLE temporal1 ( Id SERIAL PRIMARY KEY, Texto text );

Esto creará la tabla temporal temporal1 con la misma estructura de la anterior. Nótese que aquí no especificamos esquema puesto que las tablas temporales existen en un esquema especial para este efecto.

CREATE TABLE cities ( name text, population float, altitude int -- in feet ); CREATE TABLE capitals ( state char(2) ) INHERITS (cities);

Esto creara una tabla capitals que hereda de la tabla cities Creación de tabla vía SELECT
Existe 2 formas de crear tablas a partir de un set de resultados: SELECT INTO y CREATE TABLE AS.

SELECT INTO crea una nueva tabla a partir del resultado de una query. Típicamente, esta query recupera los datos de una tabla existente, pero se permite cualquier query de SQL.
SELECT [ ALL | DISTINCT [ ON ( expresión [, ...] ) ] ] expresión [ AS nombre ] [, ...] [ INTO [ TEMPORARY | TEMP ] [ TABLE ] nueva_tabla ] [ FROM tabla [ alias ] [, ...] ] [ WHERE condición ] [ GROUP BY columna [, ...] ] [ HAVING condición [, ...] ] [ { UNION [ ALL ] | INTERSECT | EXCEPT } select ] [ ORDER BY columna [ ASC | DESC | USING operador ] [, ...] ] [ FOR UPDATE [ OF Nombre_de_clase [, ...] ] ] LIMIT { contador | ALL } [ { OFFSET | , } incio ]

Ejemplo:
SELECT clientes.*, cuentas.saldo INTO clientes_premium FROM cuentas, clientes WHERE cuentas.cliente_rut = clientes.cliente_rut AND cuentas.saldo > 10000000;

Centro Ing. BARJ 2011

Ejecutivo Página 31

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

CREATE TABLE AS produce el mismo efecto que el comando anterior con otra sintaxis. CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name [ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ] AS query Ejemplo: CREATE TABLE clientes_premium AS SELECT clientes.*, cuentas.saldo INTO clientes_premium FROM cuentas, clientes WHERE cuentas.cliente_rut = clientes.cliente_rut AND cuentas.saldo > 10000000;

Modificación de Tablas Para modificar una tabla, se utiliza el comando ALTER TABLE, sintaxis a continuación.
ALTER TABLE [ ONLY ] name [ * ] action [, ... ] ALTER TABLE [ ONLY ] name [ * ] RENAME [ COLUMN ] column TO new_column ALTER TABLE name RENAME TO new_name ALTER TABLE name SET SCHEMA new_schema Donde “action” puede ser alguna de las siguientes opciones. ADD [ COLUMN ] column type [ column_constraint [ ... ] ] DROP [ COLUMN ] column [ RESTRICT | CASCADE ] ALTER [ COLUMN ] column TYPE type [ USING expression ] ALTER [ COLUMN ] column SET DEFAULT expression ALTER [ COLUMN ] column DROP DEFAULT ALTER [ COLUMN ] column { SET | DROP } NOT NULL ADD table_constraint DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ] { DISABLE | ENABLE } TRIGGER [ trigger_name | ALL | USER ] OWNER TO new_owner

Centro Ing. BARJ 2011

Ejecutivo Página 32

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Revisemos algunas de las opciones. Para el listado completo de opciones referirse al manual PostgreSQL. ADD COLUMN Agrega una columna a la tabla al final. DROP COLUMN Elimina una columna de la tabla. Notar que esto no elimina físicamente los datos del sistema de archivos; se debe llamar a VACUUM. ALTER COLUMN TYPE Cambia el tipo de dato de la columna propaganda el cambio a los constraints para la columna. Agregando USING se puede indicar una expresión de conversión a aplicar, de lo contrario se utilizará la conversión por defecto interna de Postgres SET/DROP DEFAULT columna. SET/DROP NOT NULL Permite indicar si la columna acepta valores NULL o no. Se setearse, se debe asegurar que ninguna fila tenga valor NULL o haber especificado el valor por defecto. ADD table_constraint Agrega una restricción a la tabla. Permite setear o eliminar el valor por omisión de una

DROP CONSTRAINT Elimina una restricción de la tabla. DISABLE/ENABLE TRIGGER Permite habilitar o deshabilitar un trigger específico ya sea a un usuario o a todos. OWNER Cambia el dueño de la tabla RENAME Cambia el nombre de la columna o la tabla dependiendo del caso. SET SCHEMA Cambia el esquema al cual pertenece la tabla
Ejemplos: ALTER TABLE ALTER TABLE ALTER TABLE ALTER TABLE ALTER TABLE ALTER TABLE ALTER TABLE

tabla RENAME TO tabla1; tabla1 ALTER COLUMN columna1 RENAME TO columna2; tabla1 ADD COLUMN nueva_columna NUMERIC DEFAULT 0; tabla1 ALTER COLUMN nueva_columna SET NOT NULL; tabla1 DROP COLUMN nueva_columna CASCADE; tabla1 ADD CHECK ( valor > 0 ); tabla1 DROP tabla1_valor_check;

Centro Ing. BARJ 2011

Ejecutivo Página 33

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Eliminación de Tablas
DROP TABLE [Eliminar Tabla] -- Elimina tablas de una base de datos DROP TABLE name [, ...] [ CASCADE | RESTRICT ] Nombre: nombre de una tabla a eliminar. Pueden proveerse varios nombres separados por coma. Al indicar CASCADE, se eliminarán además los objetos que dependen de esta tabla, como las vistas asociadas (por defecto es RESTRICT, que no propaga la eliminación). A diferencia de DELETE, DROP borra completamente (datos y definiciones de la tabla), no solo los datos de la tabla (rows) como el DELETE. Ejemplo: DROP TABLE mitabla; DROP TABLE mitabla1, mitabla2 CASCADE;

- Constraints (Restricciones)
La opción TEMPORARY indica que la tabla se crea solo para esta sesión, y es eliminada automáticamente con el fin de la sesión. Las tablas permanentes existentes con el mismo nombre no son visibles mientras la tabla temporal existe. En Postgres los modificadores GLOBAL y LOCAL no tienen efecto, siendo proporcionados solo por compatibilidad. Mediante la sección de CONSTRAINT se pueden especificar restricciones de una forma alternativa a crearlas directamente en cada fila, obteniéndose el mismo resultado.

[ CONSTRAINT constraint_name ] { UNIQUE ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] | PRIMARY KEY ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] | CHECK ( expression ) | FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

UNIQUE permite la creación de un índice en la(s) columna(s) indicada(s) que fuerza a que no existan valores repetidos - PRIMARY KEY define las columnas que componen la llave primaria

Centro Ing. BARJ 2011

Ejecutivo Página 34

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 - CHECK permite la definición de reglas a verificar al momento de insertar o modificar la información de la tabla. La expresión en esta opción debe evaluar booleano. - FOREIGN KEY establece las llaves foráneas de la tabla. - DEFERRABLE o NOT DEFERRABLE establece que esta condición puede ser chequeada al final de una transacción en lugar de en cada fila. Actualmente solo FOREIGN KEY soporta NOT DEFERRABLE.
Ejemplo: CREATE TABLE ciudadanos ( ciudadano_id SERIAL, ciudadano_nombre text, ciudadano_rut VARCHAR(10), PRIMARY KEY (ciudadano_id), CONSTRAINT rut UNIQUE (ciudadano_rut), CONSTRAINT check1 CHECK ( ciudadano_nombre <> ‘’ ciudadano_rut <> ‘’), CONSTRAINT FOREIGN KEY (ciudadano_rut) REFERENCES otra_tabla (persona_rut), )

Column constraints
[ CONSTRAINT constraint_name ] { NOT NULL | NULL | UNIQUE [ USING INDEX TABLESPACE tablespace ] | PRIMARY KEY [ USING INDEX TABLESPACE tablespace ] | CHECK (expression) | REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

Adicionalmente cada columna puede tener las siguientes opciones. - NOT NULL que indica que su valor no puede ser nulo - UNIQUE, su valor no se puede repetir en la tabla - DEFAULT ‘valor’, dice que valor tiene la columna en caso de proporcionarse NULL al insertar. - “column_constraint” permite indicar una restricción a los valores que esta puede tomar. - PRIMARY KEY: indica que la columna es parte de la llave primaria de la tabla.

Centro Ing. BARJ 2011

Ejecutivo Página 35

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Ejemplo: (Análogo al ejemplo anterior)
CREATE TABLE ciudadanos ( ciudadano_id SERIAL PRIMARY KEY, ciudadano_nombre text CHECK (ciudadano_nombre <> ‘’), ciudadano_rut VARCHAR(10) UNIQUE CHECK (ciudadano_rut <> ‘’) REFERENCES otra_tabla (persona_rut), );

‐ La normalización de las tablas
Qué es la normalización La normalización es el proceso mediante el cual se transforman datos complejos a un conjunto de estructuras de datos más pequeñas, que además de ser más simples y más estables, son más fáciles de mantener. También se puede entender la normalización como una serie de reglas que sirven para ayudar a los diseñadores de bases de datos a desarrollar un esquema que minimice los problemas de lógica. Cada regla está basada en la que le antecede. La normalización se adoptó porque el viejo estilo de poner todos los datos en un solo lugar, como un archivo o una tabla de la base de datos, era ineficiente y conducía a errores de lógica cuando se trataban de manipular los datos. La normalización también hace las cosas fáciles de entender. Los seres humanos tenemos la tendencia de simplificar las cosas al máximo. Lo hacemos con casi todo, desde los animales hasta con los automóviles. Vemos una imagen de gran tamaño y la hacemos más simple agrupando cosas similares juntas. Las guías que la normalización provee crean el marco de referencia para simplificar una estructura de datos compleja. Otra ventaja de la normalización de base de datos es el consumo de espacio. Una base de datos normalizada ocupa menos espacio en disco que una no normalizada. Hay menos repetición de datos, lo que tiene como consecuencia un mucho menor uso de espacio en disco. El proceso de normalización tiene un nombre y una serie de reglas para cada fase. Esto puede parecer un poco confuso al principio, pero poco a poco se va entendiendo el proceso, así como las razones para hacerlo de esta manera. Grados de normalización Existen básicamente tres niveles de normalización: Primera Forma Normal (1NF), Segunda Forma Normal (2NF) y Tercera Forma Normal (3NF). Cada una de estas formas tiene sus propias reglas. Cuando una base de datos se conforma a un nivel, se considera normalizada a esa forma de normalización. No siempre es una buena idea tener una base de datos conformada en el nivel más alto de normalización, puede llevar a un nivel de complejidad que pudiera ser evitado si estuviera en un nivel más bajo de normalización.

Centro Ing. BARJ 2011

Ejecutivo Página 36

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

En la tabla siguiente se describe brevemente en que consiste cada una de las reglas, y posteriormente se explican con más detalle.

Primera Forma Normal La regla de la Primera Forma Normal establece que las columnas repetidas deben eliminarse y colocarse en tablas separadas. Poner la base de datos en la Primera Forma Normal resuelve el problema de los encabezados de columna múltiples. Muy a menudo, los diseñadores de bases de datos inexpertos harán algo similar a la tabla no normalizada. Una y otra vez, crearán columnas que representen los mismos datos. La normalización ayuda a clarificar la base de datos y a organizarla en partes más pequeñas y más fáciles de entender. En lugar de tener que entender una tabla gigantesca y monolítica que tiene muchos diferentes aspectos, sólo tenemos que entender los objetos pequeños y más tangibles, así como las relaciones que guardan con otros objetos también pequeños.

Segunda Forma Normal La regla de la Segunda Forma Normal establece que todas las dependencias parciales se deben eliminar y separar dentro de sus propias tablas. Una dependencia parcial es un término que describe a aquellos datos que no dependen de la llave primaria de la tabla para identificarlos. Una vez alcanzado el nivel de la Segunda Forma Normal, se controlan la mayoría de los problemas de lógica. Podemos insertar un registro sin un exceso de datos en la mayoría de las tablas.

Tercera Forma Normal Una tabla está normalizada en esta forma si todas las columnas que no son llave son funcionalmente dependientes por completo de la llave primaria y no hay dependencias transitivas. Comentamos anteriormente que una dependencia transitiva es aquella en la cual existen columnas que no son llave que dependen de otras columnas que tampoco son llave.

Centro Ing. BARJ 2011

Ejecutivo Página 37

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Cuando las tablas están en la Tercera Forma Normal se previenen errores de lógica cuando se insertan o borran registros. Cada columna en una tabla está identificada de manera única por la llave primaria, y no debe haber datos repetidos. Esto provee un esquema limpio y elegante, que es fácil de trabajar y expandir. Un dato sin normalizar no cumple con ninguna regla de normalización. Para explicar con un ejemplo en que consiste cada una de las reglas, vamos a considerar los datos de la siguiente tabla.

Al examinar estos registros, podemos darnos cuenta que contienen un grupo repetido para NUM_ITEM, DESC_ITEM, CANT y PRECIO. La 1FN prohibe los grupos repetidos, por lo tanto tenemos que convertir a la primera forma normal. Los pasos a seguir son: » Tenemos que eliminar los grupos repetidos. » Tenemos que crear una nueva tabla con la PK de la tabla base y el grupo repetido. Los registros quedan ahora conformados en dos tablas que llamaremos ORDENES y ARTICULOS_ORDENES

Ahora procederemos a aplicar la segunda formal normal, es decir, tenemos que eliminar cualquier columna no llave que no dependa de la llave primaria de la tabla. Los pasos a seguir son:

Centro Ing. BARJ 2011

Ejecutivo Página 38

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 » Determinar cuáles columnas que no son llave no dependen de la llave primaria de la tabla. » Eliminar esas columnas de la tabla base. » Crear una segunda tabla con esas columnas y la(s) columna(s) de la PK de la cual dependen. La tabla ORDENES está en 2FN. Cualquier valor único de ID_ORDEN determina un sólo valor para cada columna. Por lo tanto, todas las columnas son dependientes de la llave primaria ID_ORDEN. Por su parte, la tabla ARTICULOS_ORDENES no se encuentra en 2FN ya que las columnas PRECIO y DESC_ITEM son dependientes de NUM_ITEM, pero no son dependientes de ID_ORDEN. Lo que haremos a continuación es eliminar estas columnas de la tabla ARTICULOS_ORDENES y crear una tabla ARTICULOS con dichas columnas y la llave primaria de la que dependen. Las tablas quedan ahora de la siguiente manera.

La tercera forma normal nos dice que tenemos que eliminar cualquier columna no llave que sea dependiente de otra columna no llave. Los pasos a seguir son: » Determinar las columnas que son dependientes de otra columna no llave. » Eliminar esas columnas de la tabla base. » Crear una segunda tabla con esas columnas y con la columna no llave de la cual son dependientes. Al observar las tablas que hemos creado, nos damos cuenta que tanto la tabla ARTICULOS, como la tabla ARTICULOS_ORDENES se encuentran en 3FN. Sin

Centro Ing. BARJ 2011

Ejecutivo Página 39

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 embargo la tabla ORDENES no lo está, ya que NOM_CLIENTE y ESTADO son dependientes de ID_CLIENTE, y esta columna no es la llave primaria. Para normalizar esta tabla, moveremos las columnas no llave y la columna llave de la cual dependen dentro de una nueva tabla CLIENTES. Las nuevas tablas CLIENTES y ORDENES se muestran a continuación.

¿Qué tan lejos debe llevar la normalización? La siguiente decisión es ¿qué tan lejos debe llevar la normalización? La normalización es una ciencia subjetiva. Determinar las necesidades de simplificación depende de nosotros. Si nuestra base de datos va a proveer información a un solo usuario para un propósito simple y existen pocas posibilidades de expansión, normalizar los datos hasta la 3FN quizá sea algo exagerado. Las reglas de normalización existen como guías para crear tablas que sean fáciles de manejar, así como flexibles y eficientes. A veces puede ocurrir que normalizar los datos hasta el nivel más alto no tenga sentido. ¿Se están dividiendo tablas sólo para seguir las reglas o estas divisiones son en verdad prácticas?. Éstas son el tipo de cosas que nosotros como diseñadores de la base de datos, necesitamos decidir, y la experiencia y el sentido común nos pueden auxiliar para tomar la decisión correcta. La normalización no es una ciencia exacta, más bien subjetiva. Existen seis niveles más de normalización que no se han discutido aquí. Ellos son Forma Normal Boyce- Codd, Cuarta Forma Normal (4NF), Quinta Forma Normal (5NF) o Forma Normal de Proyección-Unión, Forma Normal de Proyección-Unión Fuerte, Forma Normal de Proyección-Unión Extra Fuerte y Forma

Centro Ing. BARJ 2011

Ejecutivo Página 40

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Normal de Clave de Dominio. Estas formas de normalización pueden llevar las cosas más allá de lo que necesitamos. Éstas existen para hacer una base de datos realmente relacional. Tienen que ver principalmente con dependencias múltiples y claves relacionales.

Centro Ing. BARJ 2011

Ejecutivo Página 41

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Ejemplos de Normalización Ejemplo 1 Orden de Recepción

Centro Ing. BARJ 2011

Ejecutivo Página 42

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Ejemplo 2 Vamos a normalizar una boleta de notas, para la cual se tienen los siguientes atributos

Centro Ing. BARJ 2011

Ejecutivo Página 43

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Realización de consultas
‐ Instrucción DML
Como en el caso de los más modernos lenguajes relacionales, SQL está basado en el cálculo relacional de tuplas. Como resultado, toda consulta formulada utilizando el cálculo relacional de tuplas ( o su equivalente, el álgebra relacional) se pude formular también utilizando SQL. Hay, sin embargo, capacidades que van más allá del cálculo o del álgebra relaciona. Aquí tenemos una lista de algunas características proporcionadas por SQL que no forman parte del álgebra y del cálculo relacionales: • • Comandos para inserción, borrado o modificación de datos. Capacidades aritméticas: En SQL es posible incluir operaciones aritméticas así como comparaciones, por ejemplo A < B + 3. Nótese que ni + ni otros operadores aritméticos aparecían en el álgebra relacional ni en cálculo relacional. Asignación y comandos de impresión: es posible imprimir una relación construida por una consulta y asignar una relación calculada a un nombre de relación. Funciones agregadas: Operaciones tales como promedio (average), suma (sum), máximo (max), etc. se pueden aplicar a las columnas de una relación para obtener una cantidad única

‐ Filtrar datos
El comando más usado en SQL es la instrucción SELECT, que se utiliza para recuperar datos. La sintaxis es:
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ] * | expression [ AS output_name ] [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY expression [, ...] ] [ HAVING condition [, ...] ] [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]

Centro Ing. BARJ 2011

Ejecutivo Página 44

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
[ [ [ [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ] LIMIT { count | ALL } ] OFFSET start ] FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] ]

En términos más simples: SELECT elementos cantidad_máxima. FROM tablas WHERE condiciones ORDER BY criterio LIMIT

Donde elementos son las columnas de tablas a recuperar, las cuales cumplen las condiciones. Al terminar la operación son ordenadas por criterio y finalmente se entrega cantidad_maxima de filas en el set de resultados. Ejemplo:
Las consultas más simples son aquellas donde se unen algunas tablas, recuperando algunas de las filas de cada tabla involucrada. Sean las siguientes tablas en una base de datos

Si se desea conocer todas las ventas de todas las sucursales, con fecha superior al 10 de enero de 2008, entregando solo los 10 mayores montos; se puede hacer la siguiente consulta SELECT SQL.
SELECT sucursal_nombre, sucursal_direccion, Fecha, cliente_nombre, cliente_teléfono, monto FROM Clientes, Sucursales, Ventas WHERE Clientes.cliente_rut = Ventas.cliente_rut Sucursales.sucursal_id = Ventas.sucursal_id ORDER BY Monto DESC, Fecha ASC LIMIT 10;

Centro Ing. BARJ 2011

Ejecutivo Página 45

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Centro Ing. BARJ 2011

Ejecutivo Página 46

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

- Totalizar y agrupar datos (Consultas con Agregación)
Las funciones de agregación son aquellas que permiten agrupar datos bajo un criterio obteniéndose un valor representativo. Funciones comunes son: - min – mínimo del valor de la columna al cual se aplica - max – máximo del valor de la columna al cual se aplica - count – número de resultados obtenidos. No se ve afectado por la columna al cual se aplica. - sum – Suma de los valores de la columna indicada. - avg – promedio de los valores de la columna indicada.
Ejemplos de consultas con agregación: Máximo de un folio: SELECT max(folio) FROM ordenes_compra; Mínimo precio de las acciones de LAN Chile en la bolsa: SELECT min(precio) FROM acciones WHERE nemotecnico = ‘LAN’; Suma de las ventas por fecha del mes de enero: SELECT fecha, sum(monto) FROM ventas WHERE fecha >= ‘2008-01-01’ AND fecha < ‘2008-02-01’ GROUP BY fecha;

En esta última se hace uso de la sentencia GROUP BY, la cual como indica su nombre agrupa los resultados bajo alguna columna, permitiendo que todos los datos asociados a usa columna se resuman mediante una funciona de agregación. Se debe usar GROUP BY cada vez que acompañemos una función de agregación de otras columnas, debiendo aparecer todas estas en la cláusula de agregación. Having La cláusula HAVING trabaja de forma muy parecida a la cláusula WHERE, y se utiliza para considerar sólo aquellos grupos que satisfagan la cualificación dada en la misma. Las expresiones permitidas en la cláusula HAVING deben involucrar funcionen agregadas. Cada expresión que utilice sólo atributos planos deberá recogerse en la cláusula WHERE. Por otro lado, toda expresión que involucre funciones agregadas debe aparecer en la cláusula HAVING. Ejemplo Si queremos solamente los proveedores que venden más de un artículo, utilizaremos la consulta:
SELECT S.SNO, S.SNAME, COUNT(SE.PNO) FROM SUPPLIER S, SELLS SE

Centro Ing. BARJ 2011

Ejecutivo Página 47

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
WHERE S.SNO = SE.SNO GROUP BY S.SNO, S.SNAME HAVING COUNT(SE.PNO) > 1;

y obtendremos:
SNO | SNAME | COUNT -----+-------+------1 | Smith | 2 3 | Adams | 2 4 | Blake | 3

- Sub –consultas (Consultas Anidadas)
Una de las características más útiles dentro del lenguaje SQL, es la posibilidad de anidar consultas para simplificar la sentencia o poder realizar operaciones que de otra manera serían imposibles o requerirían de la creación de tablas temporales explicitas. Las consultas anidadas funcionan para cualquier motivo igual que una tabla. Aquí se da el nombre “tabla2” al resultado.
SELECT * FROM (SELECT * FROM tabla1) as tabla2;

Es necesario darle un nombre cada subconsulta para que Postgres pueda identificarlo y referenciarlo inequívocamente

Centro Ing. BARJ 2011

Ejecutivo Página 48

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

- Combinar 2 tablas (Uso de Join)
Join es un operador utilizado para unir tablas en una consulta. Para explicarlo se utilizara un ejemplo con tres tablas que se muestran a continuación.

Inner Join El Inner Join se utiliza para unir 2 tablas en base a un columna. En este tipo, se unirán datos de la primera tabla que tengan una entrada en la segunda tabla, entregando como resultado filas en las que solamente hay datos que se puedan unir entre las dos tablas a través de un valor común. La sintaxis utilizada es la siguiente
SELECT [datos] FROM [tabla1] INNER JOIN [tabla2] ON tabla1.parametro = tabla2.parametro;

Utilizando las dos primeras tablas que tenemos de ejemplo se obtiene lo siguiente:

Centro Ing. BARJ 2011

Ejecutivo Página 49

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Utilizar el INNER JOIN logra mezclar todas las entradas de tabla1 con todos las entradas de tabla2 en las que el parámetro id sea igual. También se puede ver como, por ejemplo, se tienen 9 resultados con el id = 2. Esto es por la cantidad de entradas con id = 2 que hay en la tabla1 (3 entradas) y la cantidad que hay en la tabla2 (3 entradas). Siempre la cantidad será la multiplicación de la cantidad de la tabla1 multiplicado por la cantidad de la tabla2, para cada parámetro coincidente. Outer Join El Outer Join es una extensión del Inner Join, pero que permite agregar valores al set de resultados. La sintaxis utilizada es la siguiente:
SELECT [datos] FROM [tabla1] [LEFT | RIGHT | FULL] OUTER JOIN [tabla2] ON tabla1.parametro = tabla2.parametro;

Si aplicamos un Left Outer Join a las tablas de ejemplo se obtiene el siguiente resultado:

Centro Ing. BARJ 2011

Ejecutivo Página 50

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Como podemos apreciar, se obtienen los mismos resultados del Inner Join, pero agregando aquellos datos de la tabla1 que no se encuentran en la tabla2, en este caso las entradas con Id = 6 y 7. Al no tener valores en la tabla2, se agregan valores en NULL para las columnas de resultado. Si aplicamos un Right Outer Join a las tablas de ejemplo se obtiene el siguiente resultado:

En este caso, tenemos los resultados del Inner Join sumados a las entradas de la tabla2 que no se encuentran en la tabla1, id = 3 y 4. Al igual que el Left Inner Join, Centro Ing. BARJ 2011 Ejecutivo Página 51 Trinity CEET

Lenguaje SQL para Postgres 8.4 aquellos valores que no se encuentran en tabla1 son reemplazados con valores en NULL. Si aplicamos un Full Outer Join a las tablas de ejemplo se obtiene el siguiente resultado:

Aquí se obtienen los resultados de un Inner Join, más las entradas que aportan el Left y Outer Join juntos. El Join se puede aplicar a más de una tabla y mezclado de la manera que resulte conveniente, como se muestra a continuación:

Centro Ing. BARJ 2011

Ejecutivo Página 52

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Los Joins se van resolviendo desde primero al último. Por lo tanto, tomando el ejemplo, se resuelve el Inner Join de la tabla1 con la tabla2 y luego un Left Outer Join del set de datos resultante de la primera operación con la tabla3.

Centro Ing. BARJ 2011

Ejecutivo Página 53

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

- Clausula UNION
Los comandos union, intersect y except permiten juntar resultados de 2 consultas separadas en un solo set. Todos estos comandos requieren que ambas consultas retornen el mismo número de columnas, considerando que los tipos correspondientes de columnas sean de tipos de datos compatibles.
(SELECT …) UNION (SELECT …)

UNION [ALL]

Une ambos sets de resultados entregando todas filas sin duplicar. No se pueden usar SENTENCIAS que tengan ORDER BY, LIMIT, FOR UPDATE o FOR SHARE. Order by y limit pueden venir en subconsultas entre paréntesis. Entrega el set donde los resultados son los valores presentes en ambos sets de resultados. No se pueden usar SENTENCIAS que tengan ORDER BY, LIMIT, FOR UPDATE o FOR SHARE. Order by y limit pueden venir en subconsultas entre paréntesis. Entrega las filas que se encuentran en la consulta de la izquierda, pero no en la de la derecha. No se pueden usar SENTENCIAS que tengan ORDER BY, LIMIT, FOR UPDATE o FOR SHARE. Order by y limit pueden venir en subconsultas entre paréntesis.

INTERSECT [ALL]

EXCEPT [ALL]

Todos los comandos no entregan filas duplicadas a menos que se agregue la opción ALL. Ejemplos:
SELECT monto, cliente_rut, ‘dolar’ as tipo FROM ordenes_compra_dolares UNION SELECT monto, cliente_rut, ‘pesos’ as tipo FROM ordenes_compra_pesos SELECT monto, cliente_rut, ‘dolar’ as tipo FROM ordenes_compra_dolares UNION ALL SELECT monto, cliente_rut, ‘pesos’ as tipo FROM ordenes_compra_pesos SELECT votante_rut, votante_nombre FROM votantes_total EXCEPT SELECT persona_rut as votante_rut, persona_nombre as votante_nombre FROM penas_aflictivas; SELECT cliente_rut FROM clientes_premium INTERSECT SELECT persona_rut as cliente_rut FROM habitantes_las_condes;

Centro Ing. BARJ 2011

Ejecutivo Página 54

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Centro Ing. BARJ 2011

Ejecutivo Página 55

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

- Instrucción Update, delete, insert
Insert Into Una vez que se crea una tabla puede ser llenada con tuplas mediante el comando INSERT INTO. La sintaxis es:
INSERT INTO table_name (name_of_attr_1 [, name_of_attr_2 [,...]]) VALUES (val_attr_1 [, val_attr_2 [, ...]]);

Para insertar la primera tupla en la relación SUPPLIER instrucción:
INSERT INTO SUPPLIER (SNO, SNAME, CITY) VALUES (1, 'Smith', 'London');

utilizamos la siguiente

Para insertar la primera tupla en la relación SELLS, utilizamos:
INSERT INTO SELLS (SNO, PNO) VALUES (1, 1);

Update Para cambiar uno o más valores de atributos de tuplas en una relación, se utiliza el comando UPDATE. La sintaxis es:
UPDATE table_name SET name_of_attr_1 = value_1 [, ... [, name_of_attr_k = value_k]] WHERE condition;

Para cambiar el valor del atributo PRICE en el artículo 'Tornillos' de la relación PART, utilizamos:
UPDATE PART SET PRICE = 15 WHERE PNAME = 'Tornillos';

El nuevo valor del atributo PRICE de la tupla cuyo nombre es 'Tornillos' es ahora 15. Delete Para borrar una tupla de una tabla particular, utilizamos el comando DELETE FROM. La sintaxis es:
DELETE FROM table_name WHERE condition;

Para borrar el proveedor llamado 'Smith' de la tabla SUPPLIER, utilizamos la siguiente instrucción: Centro Ing. BARJ 2011 Ejecutivo Página 56 Trinity CEET

Lenguaje SQL para Postgres 8.4
DELETE FROM SUPPLIER WHERE SNAME = 'Smith';

Centro Ing. BARJ 2011

Ejecutivo Página 57

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Objetos Principales PostgreSQL
Secuencias

en

Las secuencias son objetos dentro de una base de datos cuya función es generar números. Son utilizadas principalmente para proporcionar auto-incremento a columnas llave. Las secuencias parten por defecto desde 1, incrementándose en 1 cada vez que son consultadas. De alcanzarse el valor máximo establecido, cualquier llamada a la secuencia falla a menos que se establezca que cicla.

Creación (DDL) La sintaxis de creación es la siguiente.
CREATE [ TEMPORARY | TEMP ] SEQUENCE name [ INCREMENT [ BY ] increment ] [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ] [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

Ejemplos:
CREATE SEQUENCE misecuencia;

Secuencia normal partiendo de 1, incrementándose en 1.
CREATE SEQUENCE misecuencia2 INCREMENT by -1 START 10000;

Secuencia que parte en 10.000 y decrece de uno en uno.
CREATE SEQUENCE misecuencia3 MAXVALUE 100 CYCLE;

Secuencia que parte de 1, incrementa en uno, llega hasta 100 y cicla. Formalmente Postgres general una tabla de 1 sola fila con el nombre de la secuencia donde se mantiene la información relacionada con la secuencia.

Centro Ing. BARJ 2011

Ejecutivo Página 58

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Para utilizar una secuencia se llama al método nextval pasando como parámetro el nombre de la secuencia. => select nextval('articulos_articulo_id_seq'); nextval --------- 1 (1 row) Asimismo se puede consultar el valor de una secuencia sin tener que incrementar el valor de esta a través del comando currval. => select currval('articulos_articulo_id_seq'); currval --------- 1 (1 row) Para modificar algún valor de la secuencia, se utiliza el comando setval, el cual puede recibir 2 o 3 parámetros. SELECT setval(‘misecuencia’, 31); Setea el valor de misecuencia a 31. SELECT setval(‘misecuencia’, 1, false); Setea el valor de misecuancia a 1 e indica que esta no ha sido llamada nunca. Esto provoca que la primera llamada a nextval retorne 1. Para eliminar una secuencia se usa DROP SEQUENCE. DROP SEQUENCE misecuencia;

Centro Ing. BARJ 2011

Ejecutivo Página 59

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Vistas
Una vista es una forma de resumir una consulta SQL en una tabla virtual la cual se presenta al usuario como una tabla más. La vista no es materializada físicamente, sino que la consulta con la cual fue creada es ejecutada cada vez que se consulta la vista. Existen beneficios asociados al uso de vistas. Seguridad: Las vistas pueden proporcionar un nivel adicional de seguridad. Cada vista al comportarse como una tabla puede tener permisos independientes de las tablas que figuran en la consulta base. Simplicidad: Las vistas permiten ocultar la complejidad de los datos. Exactitud en los datos solicitados: Permiten acceder a un subconjunto de datos específicos, omitiendo datos e información innecesaria e irrelevante para el usuario. Amplía Perspectivas de la base de datos: Proporciona diversos modelos de información basados en los mismos datos, enfocándolos hacia distintos usuarios con necesidades específicas. El mostrar la información desde distintos ángulos nos ayuda a crear ambientes de trabajo y operación acordes a los objetivos de la empresa. Debe evaluarse el perfil y requerimientos de información de los usuarios destino de la vista. La sintaxis de creación es la siguiente.
CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW name [ ( column_name [, ...] ) ] AS query

Cuando se reemplaza una vista, solo se puede hacer por una consulta que genere la misma cantidad y tipos de columnas que la consulta anterior.
Ejemplo: CREATE VIEW mivista AS SELECT nombre, telefono FROM clientes WHERE edad > 18; Para eliminar una vista se usa DROP VIEW. DROP VIEW mivista;

Centro Ing. BARJ 2011

Ejecutivo Página 60

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Procedimientos Almacenados
Los procedimientos almacenados son funciones que se crean dentro de una base de datos. Estas, como su nombre lo indica, están almacenadas dentro del modelo de datos haciendo que su ejecución sea lo más ágil posible para el manejo de la información. Los procedimientos pueden estar escritos en varios lenguajes. PostgreSQL soporta SQL, C, PL/pgSQL, PL/PerlSQL, etc; permitiéndose la sobrecarga. La sintaxis de creación de un procedimiento almacenado para cualquier lenguaje es la siguiente.
CREATE [ OR REPLACE ] FUNCTION name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [ RETURNS rettype ] { LANGUAGE langname | IMMUTABLE | STABLE | VOLATILE | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER | AS 'definition' | AS 'obj_file', 'link_symbol' } ... [ WITH ( attribute [, ...] ) ]

Los parámetros.
name argmode

Nombre de la función Modo del argumento (IN , OUT), por defecto IN. Los parámetros definidos con OUT son realmente retorno en lugar de entradas a la función. Nombre que tendrá la variable dentro de la función. (Solo disponible en PL/pgsql) Tipo de dato de retorno de la función. Si se omite se asume VOID. Lenguaje en el cual esta escrita la función.

argname

rettype

langname

Centro Ing. BARJ 2011

Ejecutivo Página 61

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Los parámetros INMUTABLE, STABLE, VOLATIL, sirven para indicar al sistema si es seguro reemplazar múltiples evaluaciones de la función con una sola para optimización de la ejecución. En detalle: INMUTABLE indica que la función siempre retorna el mismo valor cuando se le entregan los mismos argumentos, es decir, no realiza ninguna consulta a otras tablas o depende de variables como la hora. Cuando se entrega este argumento, en donde se llame a la función se reemplaza directamente su valor si se ha calculado. STABLE indica que dentro de un recorrido por una tabla, el valor de la función no cambia – no cambia fila a fila. Tipo recomendado para funciones que dependen del valor de parámetros, consultas a tablas, timezone, etc; VOLATILE se utiliza para aquellas funciones que cambian en cada llamado, como nextval de las secuencias. Esta opción es aquella que se asume por defecto. La opción CALLED ON NULL INPUT – seleccionada por defecto – permite que esta sea llamada con algunos o todos sus parámetros en NULL. RETURNS NULL ON NULL INPUT dice que se entregue NULL como retorno si alguno de los parámetros es NULL. Con la opción SECURITY DEFINER se especifica que la función se ejecutará con los permisos del creador, en lugar de los del invocador como es por defecto (SECURITY INVOKER). Dentro de una función los parámetros son accedidos a través de posición en la definición anteponiendo $. Ejemplo:
CREATE FUNCTION ejemplo(varchar, int) RETURNS boolean AS ‘ SELECT $1 = ‘ejemplo && $2 < 0: ‘ LANGUAGE sql;

En este ejemplo el retorno es booleano y se construye de la verificación de los valores de los parámetros Procedimientos Almacenados en SQL En PostgreSQL existe la posibilidad de crear procedimientos almacenados en lenguaje SQL. Esta característica permite la reutilización de código y ordenamiento del mismo, pudiendo concentrar parte de la lógica en un solo lugar desde donde se le puede cambiar transparentemente. Dentro el código debe ser construido
Ejemplo:
CREATE FUNCTION getPrecio(INT) RETURNS NUMERIC AS ‘ SELECT precio FROM bitacora_precio WHERE producto_id = $1 ORDER BY timestamp DESC LIMIT 1; ‘ LANGUAGE SQL;

Centro Ing. BARJ 2011

Ejecutivo Página 62

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Procedimientos Almacenados en Plpgsql
PL/pgSQL es un lenguaje procedural cargable al DBMS PostgreSQL, es decir, no viene incorporado dentro del core del sistema, sino que se carga cuando se requiere. Del manual de Postgres, se conocen los objetivos al momento de diseñar PL/pgSQL, entre los cuales estan: - Poder ser utilizado para la creación de funciones y triggers. - Añadir estructuras de control al lenguaje SQL - Realizar computaciones complejas - Heredar todos los tipos, funciones y operadores definidos por el usuario

Es un lenguaje orientado a bloques. Un bloque se define como:
[ <<etiqueta>> ] [ DECLARE declaraciones ] BEGIN estamentos END;

Puede haber múltiples subbloques en la sección de sentencia de un bloque. Los subbloques pueden usarse para ocultar variables a otros bloques de sentencias. Las variables declaradas en la sección de declaraciones que preceden a un bloque, son inicializadas a sus valores por defecto cada vez que el bloque es introducido, no sólo una vez por cada llamada a la función.
CREATE FUNCTION funcion() RETURNS INTEGER AS ' DECLARE cantidad INTEGER; BEGIN -- LOGICA DEL PROGRAMA AQUI RETURN 1; END; ' LANGUAGE 'plpgsql';

Un ejemplo con subbloques:
CREATE FUNCTION funcion() RETURNS INTEGER AS ' DECLARE cantidad INTEGER; BEGIN -- LOGICA DEL PROGRAMA AQUI DECLARE cantidad; BEGIN -- LOGICA DEL SUBBLOQUE RETURN 0;

Centro Ing. BARJ 2011

Ejecutivo Página 63

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
END; END; ' LANGUAGE 'plpgsql';

Centro Ing. BARJ 2011

Ejecutivo Página 64

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Triggers
Los triggers son procedimiento almacenados los cuales se ejecutan de forma automática ante una acción – INSERT, UPDATE, DELETE – sobre una tabla en la base de datos. La utilización de triggers permite dar vida al modelo de una base de datos, dando la posibilidad de actualizar varias tablas con una sola inserción como por ejemplo propagación de consistencia, creación de resúmenes, checkeos complejos, etc. Esta libertad y apertura de posibilidades también conlleva problemas. Si no se es cuidadoso con la cantidad de triggers que se utiliza, se puede llegar a un punto en donde cada operación sobre las tablas involucradas desencadene tal número de funciones que el desempeño del sistema se vea degradado considerablemente. Más aún, si no se documentó apropiadamente los triggers que se agregan al modelo, puede llegar a ser una tarea no menor averiguar la traza completa de acciones gatilladas sobre una acción en una tabla.
Un trigger se crea a partir de una función – procedimiento almacenados – que ha sido declarado con algunas características en particular: - Se declara sin argumento, estos son manejados de otra forma dentro del procedimiento. - Se declara con tipo de retorno trigger.

Ejemplo:
CREATE FUNCTION check_saldo() RETURNS trigger AS ‘ DECLARE saldo_disponible NUMERIC; BEGIN SELECT cliente.saldo INTO saldo_disponible FROMcuentas_corriente WHERE cta_numero = NEW.cta_numero; IF NOT FOUND RAISE EXCEPTION ‘’Cuenta corriente % no existe’’, NEW.cta_numero; ELSE IF saldo_disponible > NEW.valor_cargo THEN RETURN NEW; ELSE RAISE EXCEPTION ‘’Saldo en cuenta % es insuficiente’’, NEW.cta_numero; END; END; END; ‘ LANGUAGE plpgsql;

Centro Ing. BARJ 2011

Ejecutivo Página 65

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

En este caso se tiene una función que verificará que la cuenta indicada en la nueva fila (variable NEW) exista y que tenga saldo antes de permitir la inserción.
Para asociar esta función a una se utiliza la siguiente sintaxis CREATE TRIGGER nombre { BEFORE | AFTER } { INSERT | UPDATE | DELETE [ OR …] } ON tabla FOR EACH { ROW | STATEMENT } EXECUTE PROCEDURE nombrefuncion;

Los parámetros BEFORE y AFTER permiten indicar si el trigger es ejecutado antes o después de que la operación se aplique a la tabla. Al usar BEFORE se pueden modificar los valores de la nueva fila en caso de inserción y modificación. En ambos casos un trigger que lance un error cancelará la operación que lo disparó. A continuación se indica sobre que operación sobre la tabla se lanzará el trigger: INSERT, UPDATE, DELETE. Se pueden especificar múltiples acciones separadas por OR. El parámetro ROW o STATEMENT permite indicar si la función se ejecutará para cada fila afectada en la operación o solo al final de la ejecución. Si por ejemplo un operación de UPDATE cambia 10 filas, al seleccionar EACH ROW, el procedimiento se ejecutará 10 veces (una por cada fila), mientras que con EACH STATEMENT lo hará al final. En nuestro ejemplo:
CREATE TRIGGER check_saldo BEFORE INSERT ON giros FOR EACH ROW EXECUTE PROCEDURE check_saldo();

Esto provocara que al momento de insertar una fila en la tabla giros se ejecute la función check_saldo ANTES de que se realice la inserción propiamente tal .

Centro Ing. BARJ 2011

Ejecutivo Página 66

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Variables especiales
Cuando una función plpgsql es un trigger, se tienen una serie de variables especiales disponibles dentro del procedimiento las cuales permiten conocer el estado de la operación que ejecuta el trigger.

NEW OLD TG_NAME TG_WHEN TG_LEVEL TG_OP TG_RELID TG_RELNAME TG_NARGS TG_ARGV[]

Variable de tipo RECORD que contiene la nueva fila en caso de INSERT o UPDATE. Es null en caso de EACH STATEMENT. Variable de tipo RECORD que contiene la antigua fila en caso de UPDATE o DELETE. Es null en caso de EACH STATEMENT. Nombre del trigger que se esta ejecutando Contiene el cuando se esta ejecutando (BEFORE / AFTER) Indica si el procedimiento se ejecuta fila a fila o por statement. Operación sobre la cual se gatilló el evento (INSERT, UPDATE, DELETE) ID de la relación sobre la cual se disparó el trigger Nombre de la relación sobre la cual se disparó el trigger Número de argumentos pasados como parámetros en CREATE TRIGGER. Arreglo con los argumentos pasados en CREATE TRIGGER.

Centro Ing. BARJ 2011

Ejecutivo Página 67

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Transacciones
Uno de los puntos más importantes en un motor de base de datos es proporcionar los mecanismos adecuados para manejar la concurrencia, es decir, como asegurar la integridad de los datos y la correctitud de las operaciones realizadas cuando existen múltiples personas intentando de acceder a la misma información. Para ejemplificar el concepto, usemos un ejemplo cotidiano. Los cajeros automáticos (Redbanc / ATM) realizan descuentos del saldo de la cuenta corriente cuando se obtiene dinero de ellos. Supongamos que en un momento determinado existe un usuario sacando dinero y simultáneamente se esta realizando un cobro electrónico sobre la misma cuenta.

El mecanismo seria: Cuanto dinero hay en la cuenta? Del saldo descuente esta cantidad de dinero. Si esta operación puede ser realizada EXACTAMENTE al mismo tiempo, entonces se obtendrá el resultado de la tabla anterior. Así es necesario proveer mecanismos de bloqueo temporal para asegurar que solo una instancia tenga acceso a los datos concurrentemente (simultáneamente). Una transacción es una operación que se realiza por completo, de forma atómica 3. En caso de fallar algo, los cambios se revierten y todo vuelve al estado anterior. Postgres sigue el estándar SQL para la sintaxis de transacciones
BEGIN WORK; INSERT INTO usuarios VALUES (‘acampos’, ‘Andres Campos’); INSERT INTO usuario_saldo VALUES (‘acampos’, 10000); COMMIT;

Cada transacción comienza con el comando BEGIN WORK, aunque WORK es opcional. Al terminar el trabajo se debe invocar al comando COMMIT para indicar que la transacción ha concluido. En cualquier punto de la transacción se puede invocar a ROLLBACK, comando que deshace todos los cambios realizados en la base de datos, dejándola en el estado previo al inicio de la transacción.
BEGIN WORK; INSERT INTO usuarios VALUES (‘acampos’, ‘Andres Campos’); ROLLBACK;

Centro Ing. BARJ 2011

Ejecutivo Página 68

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4
INSERT INTO usuarios VALUES (‘acampos’, ‘Andres Campos’); INSERT INTO usuario_saldo VALUES (‘acampos’, 10000); COMMIT;

En el caso de que un comando SQL falle, Postgres ignorará las siguientes sentencias hasta el fin de la transacción, la cual se indica con COMMIT o ROLLBACK. Las transacciones en Postgres pueden ser grabadas en un punto intermedio, de manera de poder re-ejecutar o deshacer solo una porción de la transacción. Para esto se utiliza SAVEPOINT.
BEGIN WORK; INSERT INTO usuarios VALUES (‘acampos’, ‘Andres Campos’); SAVEPOINT s1; INSERT INTO usuario_saldo VALUES (‘acampos’, 10000); ROLLBACK s1; INSERT INTO usuario_saldo VALUES (‘acampos’, 10000); COMMIT;

Centro Ing. BARJ 2011

Ejecutivo Página 69

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Bibliografía consultada
Estos apuntes se han basado principalmente en los siguientes materiales

PostgreSQL 8.4 Documentación [http://www.postgresql.org] Curso de Administración de PostgreSQL Juan Carlos Casamayor Departamento de Sistemas Informáticos y Computación Universidad Politécnica de Valencia Curso de Administración de PostgreSQL Alvaro Herrera (Publicado en Internet) Curso de PostgreSQL, versión 6.5 Equipo de Desarrollo de PostgreSQL (Publicado en Internet) Manual de Usuario de PostgreSQL versión 6.5 Equipo de Desarrollo de PostgreSQL Editado por Thomas Lockhart Mastering PostgreSQL Administration Bruce Momjian Software Research Associates TLDP-LUCAS [http://es.tldp.org/Postgresql-es/web/]

Centro Ing. BARJ 2011

Ejecutivo Página 70

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Apéndices
Ejercicios Entidad – Relación Funciones Postgres Guia de Ejercicios

Centro Ing. BARJ 2011

Ejecutivo Página 71

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Ejercicios Entidad – Relación
1. Una empresa vende productos a varios clientes. Se necesita conocer los datos personales de los clientes (nombre, apellidos, cedula, dirección y fecha de nacimiento). Cada producto tiene un nombre y un código, así como un precio unitario. Un cliente puede comprar varios productos a la empresa, y un mismo producto puede ser comprado por varios clientes. Los productos son suministrados por diferentes proveedores. Se debe tener en cuenta que un producto sólo puede ser suministrado por un proveedor, y que un proveedor puede suministrar diferentes productos. De cada proveedor se desea conocer el RUC, nombre y dirección. 2. Una clínica necesita llevar un control informatizado de su gestión de pacientes y médicos. De cada paciente se desea guardar el código, nombre, apellidos, dirección, población, provincia, código postal, teléfono y fecha de nacimiento. De cada médico se desea guardar el código, nombre, apellidos, teléfono y especialidad. Se desea llevar el control de cada uno de los ingresos que el paciente hace en el hospital. Cada ingreso que realiza el paciente queda registrado en la base de datos. De cada ingreso se guarda el código de ingreso (que se incrementará automáticamente cada vez que el paciente realice un ingreso), el número de habitación y cama en la que el paciente realiza el ingreso y la fecha de ingreso. Un médico puede atender varios ingresos, pero el ingreso de un paciente solo puede ser atendido por un único médico. Un paciente puede realizar varios ingresos en el hospital. 3. Se desea informatizar la gestión de una empresa de transportes que reparte paquetes por toda Nicaragua. Los encargados de llevar los paquetes son los camioneros, de los que se quiere guardar el ruc, nombre, teléfono, dirección, salario y población en la que vive. De los paquetes transportados interesa conocer el código de paquete, descripción, destinatario y dirección del destinatario. Un camionero distribuye muchos paquetes, y un paquete sólo puede ser distribuido por un camionero. De las provincias a las que llegan los paquetes interesa guardar el código de provincia y el nombre. Un paquete sólo puede llegar a una provincia. Sin embargo, a una provincia pueden llegar varios paquetes. De los camiones que llevan los camioneros, interesa conocer la matrícula, modelo, tipo y potencia. Un camionero puede conducir diferentes camiones en fechas diferentes, y un camión puede ser conducido por varios camioneros. 4. De cada producto informático se desea guardar el código, descripción, precio y número de existencias. De cada cliente se desea guardar el código, nombre, apellidos, dirección y número de teléfono. Un cliente puede comprar varios productos en la tienda y un mismo producto puede ser comprado por varios

Centro Ing. BARJ 2011

Ejecutivo Página 72

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 clientes. Cada vez que se compre un artículo quedará registrada la compra en la base de datos junto con la fecha en la que se ha comprado el artículo. La tienda tiene contactos con varios proveedores que son los que suministran los productos. Un mismo producto puede ser suministrado por varios proveedores. De cada proveedor se desea guardar el código, nombre, apellidos, dirección, provincia y número de teléfono.

Centro Ing. BARJ 2011

Ejecutivo Página 73

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Funciones de PostgreSQL
Funciones SQL

Funciones Matemáticas

Centro Ing. BARJ 2011

Ejecutivo Página 74

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Funciones de Texto

Centro Ing. BARJ 2011

Ejecutivo Página 75

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Centro Ing. BARJ 2011

Ejecutivo Página 76

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Funciones de Fecha/Hora

Centro Ing. BARJ 2011

Ejecutivo Página 77

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4 Funciones de Formato

Centro Ing. BARJ 2011

Ejecutivo Página 78

Trinity

-

CEET

Lenguaje SQL para Postgres 8.4

Centro Ing. BARJ 2011

Ejecutivo Página 79

Trinity

-

CEET

Sign up to vote on this title
UsefulNot useful