Download Arquitectura [ Empezando]

Arquitectura
Antes de comenzar, debería comprender las bases de la arquitectura del sistema Postgres . Entendiendo como
las partes de Postgres interactuan le hará el siguiente capítulo mucho más sencillo. En la jerga de bases de
datos, Postgres usa un modelo cliente/sevidor conocido como "proceso por usuario". Una sesión Postgres
consiste en los siguientes procesos cooperativos de Unix (programas):
• Un proceso demonio supervisor (postmaster),
• la aplicación sobre la que trabaja el usuario (frontend) (e.g., el programapsql ), y
• uno o más servidores de bases dedatos en segundo plano (el mismo proceso postgres).
Un único postmaster controla una colección de bases de datos dadas en un único host. Debido a esto una
colección de bases de datos se suele llamar una instalación o un sitio. Las aplicaciones de frontend que
quieren acceder a una determinada base de datos dentro de una instalación hacen llamadas a la libreria La
libreria envía peticiones de usuario a través de la red al postmaster ( Como se establece una conexión), el
cual en respuesta inicia un nevo proceso en el servidor (backend) y conecta el proceso de frontend al nuevo
servidor. A partir de este punto, el proceso de frontend y el servidor en backend se comunican sin la
intervención del postmaster. Aunque, el postmaster siempre se está ejecutando, esperando peticiones,
tanto los procesos de frontend como los de backend vienen y se van.La libreria libpq permite a un único
proceso en frontend realizar multiples conexiones a procesos en backend. Aunque, la aplicación frontend
todavía es un proceso en un único thread. Conexiones multithread entre el frontend y el backend no están
soportadas de momento en libpq. Una implicación de esta arquitectura es que el postmaster y el proceso
backend siempre se ejecutan en la misma máquina (el servidor de base de datos), mientras que la aplicación
en frontend puede ejecutarse desde cualquier sitio. Debe tener esto en mente, porque los archivos que pueden
ser accedidos en la máquina del cliente pueden no ser accesibles (o sólo pueden ser accedidos usando un
nombre de archivo diferente) el máquina del servidor de base de datos.
Tenga en cuenta que los servicios postmaster y postgres se ejecutan con el identificador de usuario del
"superusuario" Postgres Note que el superusuario Postgres no necesita ser un usuario especial (ej. un usuario
llamado "postgres"). De todas formas, el superusuario Postgres definitivamente no tiene que ser el
superusuario de Unix ("root")! En cualquier caso, todos los archivos relacionados con la base de datos deben
pertenecer a este superusuario Postgres. Postgres.
[ Empezando]
¿Cómo empezar a trabajar con Postgres?
Algunos de los pasos necesarios para usar Postgres pueden ser realizados por cualquier usuario, y algunos los
deberá realizar el administrador de la base de datos. Este administrador es la persona que instaló el software,
creó los directorios de las bases de datos e inició el proceso postmaster. Esta persona no tiene que ser el
superusuario Unix ("root") o el administrador del sistema. Una persona puede instalar y usarPostgres sin tener
una cuenta especial o privilegiada
Si está instalando Postgres, consulte las instrucciones de instalación en la Guía de Administración y regrese a
esta guía cuando haya concluido la instalación.
Mientras lee este manual, cualquier ejemplo que vea que comience con el carácter "%" son órdenes que se
escribirán en el la línea de órdenes de Unix. Los ejemplos que comienzan con el caracter "*" son órdenes en el
lenguaje de consulta Postgres, Postgres SQL.
[ Empezando]
1
[ Ejecución del Monitor Interactivo (psql)]
Asumiendo que su administrador haya ejecutado adecuadamente el proceso postmaster y le haya
autorizado a utilizar la base de datos, puede comenzar a ejecutar aplicaciones como usuario. Como
mencionamos previamente, debería añadir /usr/local/pgsql/bin al "path" de búsqueda de su
intérprete de órdenes. En la mayoría de los casos, es lo único que tendrá que hacer en términos de preparación.
Desde Postgres v6.3, se soportan dos tipos diferentes de conexión. El administrador puede haber elegido
permitir conexiones por red TCP/IP, o restringir los accesos a la base de datos a través de conexiones locales
(en la misma máquina). Esta elección puede ser significativa si encuentra problemas a la hora de conectar a la
base de datos.
Si obtiene los siguientes mensajes de error de una orden Postgres (tal como psql o createdb):
[[BR]]% psql template1[[BR]]Connection to database 'postgres'
failed.[[BR]]connectDB() failed: Is the postmaster running and accepting
connections[[BR]] at 'UNIX Socket' on port '5432'?[[BR]]
o
[[BR]]% psql -h localhost template1[[BR]]Connection to database
'postgres' failed.[[BR]]connectDB() failed: Is the postmaster running and
accepting TCP/IP[[BR]] (with -i) connections at 'localhost' on port
'5432'?[[BR]]
normalmente es debido a que (1) el postmaster no está en funcionamiento, o (2) está intentando conectar
al servidor equivocado. Si obtiene el siguiente mensaje de error:
[[BR]]FATAL 1:Feb 17 23:19:55:process userid (2360) != database owner
(268)[[BR]]
Significa que el administrador ejecutó el postmaster mediante el usuario equivocado. Dígale que lo
reinicie utilizando el superusuario de Postgres.= [ Administrando una Base de datos] = Ahora
que Postgres está ejecutándose podemos crear alguna base de datos para experimentar con ella. Aquí
describimos las órdenes básicas para administrar una base de datos
La mayoría de las aplicaciones Postgres asumen que el nombre de la base de datos, si no se especifica, es el
mismo que el de su cuenta en el sistema.
Si el administrador de bases de datos ha configurado su cuenta sin privilegios de creación de bases de datos,
entonces deberán decirle el nombre de sus bases datos. Si este es el caso, entonces puede omitir la lectura de
esta sección sobre creación y destrucción de bases de datos.
[ Creación de una base de datos]
Digamos que quiere crear una base de datos llamada mydb. Puede hacerlo con la siguiente orden:
[[BR]]% createdb mydb[[BR]]
Si no cuenta con los privilegios requeridos para crear bases de datos, verá lo siguiente:
[ Ejecución del Monitor Interactivo (psql)]
2
[[BR]]% createdb mydb[[BR]]NOTICE:user "su nombre de usuario" is not
allowed to create/destroy databases[[BR]]createdb: database creation
failed on mydb.[[BR]]
Postgres le permite crear cualquier número de bases de datos en un sistema dado y automáticamente será el
administrador de la base de datos que creó. Los nombres de las bases de datos deben comenzar por un carácter
alfabético y están limitados a una longitud de 32 caracteres. No todos los usuarios están autorizados para ser
administrador de una base de datos. Si Postgres le niega la creación de bases de datos, seguramente es debido
a que el administrador del sistema ha de otorgarle permisos para hacerlo. En ese caso, consulte al
administrador del sistema.
[ Acceder a una base de datos]
Una vez que ha construido una base de datos, puede acceder a ella:
• Ejecutando los programas de monitorización de Postgres (por ejemplo psql) los cuales le permiten
introducir, editar y ejecutar órdenes SQL interactivamente
• Escribiendo un programa en C usando la librería de subrutinas LIBPQ, la cual le permite enviar
órdenes SQL desde C y obtener mensajes de respuesta en su programa. Esta interfaz es discutida más
adelante en la Guía de Programadores de PostgreSQL
Puede que desee ejecutar psql, para probar los ejemplos en este manual. Lo puede activar para la base de
datos mydb escribiendo la orden:
[[BR]]% psql mydb[[BR]]
Se le dará la bienvenida con el siguiente mensaje:
[[BR]]Welcome to the POSTGRESQL interactive sql monitor:[[BR]] Please
read the file COPYRIGHT for copyright terms of POSTGRESQL[[BR]][[BR]]
type \? for help on slash commands[[BR]] type \q to quit[[BR]] type \g or
terminate with semicolon to execute query[[BR]] You are currently
connected to the database: template1[[BR]][[BR]]mydb=>[[BR]]
Este prompt indica que el monitor está listo y puede escribir sus consultas SQL dentro de un espacio de
trabajo mantenido por el monitor. El programa psql responde a los códigos de escape que empiezan por el
carácter "\". Por ejemplo, puede obtener la ayuda acerca de la sintaxis de varias órdenes
SQL Postgres escribiendo:
[[BR]]mydb=> \h[[BR]]
Una vez que haya terminado de introducir consultas, puede pasar el contenido del espacio de trabajo al
servidor Postgres escribiendo:
[[BR]]mydb=> \g[[BR]]
Esto le dice al servidor que procese la consulta. Si termina su consulta con un punto y coma, la "\g" no es
necesaria. psql procesará automáticamente las consultas terminadas con punto y coma. Para leer consultas
desde un archivo, digamos myFile, en lugar de introducirlas interactivamente, escriba:
[[BR]]mydb=> \i nombreDelFichero[[BR]]
Para salir de psql y regresar a Unix escriba:
[ Creación de una base de datos]
3
[[BR]]mydb=> \q[[BR]]
y psql terminará y volverá a la línea de órdenes. (Para conocer más códigos de escape, escriba \h en el
prompt del monitor). Se pueden utilizar espacios en blanco (por ejemplo espacios, tabulador y el carácter de
nueva línea) en las consultas SQL. Las líneas simples comentadas comienzan por "--". Lo que haya después
de los guiones hasta el final de línea será ignorado. Los comentarios múltiples y los que ocupan más de una
línea se señalan con "/* ... */"== [ Eliminando bases de datos] == Si es el administrador de la base de
datos mydb, puede eliminarla utilizando la siguiente orden Unix:
[[BR]]% dropdb mydb[[BR]]
Esta acción elimina físicamente todos los archivos Unix asociados a la base de datos y no pueden recuperarse,
así que deberá hacerse con precaución.= [ El Lenguaje de consultas] = El lenguaje de consultas de
Postgres Postgres es una variante del estándar SQL3 Tiene muchas extensiones, tales como tipos de sistema
extensibles, herencia, reglas de producción y funciones. Estas son características tomadas del lenguaje de
consultas original de Postgres (PostQuel). Ésta sección proporciona un primer vistazo de cómo
usar Postgres SQL para realizar operaciones sencillas. La intención de este manual es simplemente la de
proporcionarle una idea de nuestra versión de SQL y no es de ningún modo un completo tutorial acerca
de SQL. Se han escrito numerosos libros sobre SQL, incluyendo [MELT93] and [DATE97]. Tenga en cuenta
que algunas características del lenguaje son extensiones del estándar ANSI.
[ Monitor interactivo]
En los ejemplos que siguen, asumimos que ha creado la base de datos mydb como se describe en la
subsección anterior y que ha arrancado psql. Los ejemplos que aparecen en este manual también se pueden
encontrar en /usr/local/pgsql/src/tutorial/. Consulte el fichero README en ese directorio para
saber cómo usarlos. Para empezar con el tutorial haga lo siguiente:
[[BR]]% cd /usr/local/pgsql/src/tutorial[[BR]]% psql -s mydb[[BR]]Welcome
to the POSTGRESQL interactive sql monitor:[[BR]] Please read the file
COPYRIGHT for copyright terms of POSTGRESQL[[BR]][[BR]] type \? for help
on slash commands[[BR]] type \q to quit[[BR]] type \g or terminate with
semicolon to execute query[[BR]] You are currently connected to the
database: postgres[[BR]][[BR]]mydb=> \i basics.sql[[BR]][[BR]]
El comando \i lee en las consultas desde los ficheros especificados . La opción -s le pone en modo single
step, que hace una pausa antes de enviar la consulta al servidor. Las consultas de esta sección están en el
fichero basics.sql.
psql tiene varios comandos \d para mostrar información de sistema. Consulte éstos comandos para ver más
detalles y teclee \? desde el prompt psql para ver un listado de comandos disponibles.
[ Conceptos]
La noción fundamental en Postgres es la de clase, que es una colección de instancias de un objeto. Cada
instancia tiene la misma colección de atributos y cada atributo es de un tipo específico. Más aún, cada
instancia tiene un identificador de objeto (OID) permanente, que es único a lo largo de toda la instalación. Ya
que la sintaxis SQL hace referencia a tablas, usaremos los términos tabla y clase indistintamente. Asimismo
,una filaSQL es una instancia y las columnas SQL son atributos. Como ya se dijo anteriormente, las clases se
agrupan en bases de datos y una colección de bases de datos gestionada por un único
proceso postmaster constituye una instalación o sitio.
[ Conceptos]
4
[ Creación de una nueva clase]
Puede crear una nueva clase especificando el nombre de la clase , además de todos los nombres de atributo y
sus tipos:
[[BR]]CREATE TABLE weather ([[BR]] city varchar(80),[[BR]] temp_lo int,
-- temperatura mínima[[BR]] temp_hi int, -- temperatura máxima[[BR]] prcp
real, -- precipitación[[BR]] date date[[BR]]);[[BR]][[BR]]
Tenga en cuenta que las palabras clave y los identificadores son sensibles a las mayúsculas y minúsculas. Los
identificadores pueden llegar a ser sensibles a mayúsculas o minúsculas si se les pone entre dobles comillas,
tal como lo permite SQL92. Postgres SQL soporta los tipos habituales
de SQL como: int, float, real, smallint, char(N), varchar(N), date, time, y timestamp, así como otros de tipo
general y otros con un rico conjunto de tipos geométricos. Tal como veremos más tarde, Postgres puede ser
configurado con un número arbitrario de tipos de datos definidos por el usuario. Consecuentemente, los
nombres de tipo no son sintácticamente palabras clave, excepto donde se requiera para soportar casos
especiales en el estándar SQL92 . Yendo más lejos, el comando Postgres CREATEes idéntico al comando
usado para crear una tabla en el sistema relacional de siempre . Sin embargo, veremos que las clases tienen
propiedades que son extensiones del modelo relacional.
[ Llenando una clase con instancias]
La declaración insert se usa para llenar una clase con instancias:
[[BR]]INSERT INTO weather[[BR]] VALUES ('San Francisco', 46, 50, 0.25,
'11/27/1994');[[BR]][[BR]]
También puede usar el comando copy para cargar grandes cantidades de datos desde ficheros (ASCII) .
Generalmente esto suele ser más rápido porque los datos son leídos (o escritos) como una única transacción
directamente a o desde la tabla destino. Un ejemplo sería:
[[BR]]COPY weather FROM '/home/user/weather.txt'[[BR]] USING DELIMITERS
'|';[[BR]][[BR]]
donde el path del fichero origen debe ser accesible al servidor backend , no al cliente, ya que el servidor lee el
fichero directamente
[ Consutar a una clase]
La clase weather puede ser consultada con una selección relacional normal y consultas de proyección. La
declaración SQL selectse usa para hacer esto. La declaración se divide en una lista destino (la parte que lista
los atributos que han de ser devueltos) y una cualificación (la parte que especifica cualquier restricción). Por
ejemplo, para recuperar todas las filas de weather, escriba:
[[BR]]SELECT * FROM weather;[[BR]][[BR]]
and the output should be:
[[BR]]+--------------+---------+---------+------+------------+[[BR]]|city |
temp_lo | temp_hi | prcp | date
|[[BR]]+--------------+---------+---------+------+------------+[[BR]]|San
[ Consutar a una clase]
5
Francisco | 46 | 50 | 0.25 | 11-27-1994
|[[BR]]+--------------+---------+---------+------+------------+[[BR]]|San
Francisco | 43 | 57 | 0 | 11-29-1994
|[[BR]]+--------------+---------+---------+------+------------+[[BR]]|Hayward
| 37 | 54 | | 11-29-1994
|[[BR]]+--------------+---------+---------+------+------------+[[BR]][[BR]]
Puede especificar cualquier expresión en la lista de destino. Por ejemplo, puede hacer:
[[BR]]SELECT city, (temp_hi+temp_lo)/2 AS temp_avg, date FROM
weather;[[BR]][[BR]]
Los operadores booleanos (and, or and not) ) se pueden usar en la cualificación de cualquier consulta. Por
ejemplo,
[[BR]]SELECT * FROM weather[[BR]] WHERE city = 'San Francisco'[[BR]] AND
prcp > 0.0;[[BR]][[BR]]
da como resultado:
[[BR]]+--------------+---------+---------+------+------------+[[BR]]|city |
temp_lo | temp_hi | prcp | date
|[[BR]]+--------------+---------+---------+------+------------+[[BR]]|San
Francisco | 46 | 50 | 0.25 | 11-27-1994
|[[BR]]+--------------+---------+---------+------+------------+[[BR]][[BR]]
Como apunte final, puede especificar que los resultados de un select puedan ser devueltos de manera
ordenada o quitando las instancias duplicadas.
[[BR]]SELECT DISTINCT city[[BR]] FROM weather[[BR]] ORDER BY
city;[[BR]][[BR]]
[ Redireccionamiento de consultas SELECT]
Cualquier consulta select puede ser redireccionada a una nueva clase:
[[BR]]SELECT * INTO TABLE temp FROM weather;[[BR]][[BR]]
Esto forma de manera implícita un comando create, creándose una nueva clase temp con el atributo names y
types especificados en la lista destino del comando select into. Entonces podremos , por supuesto, realizar
cualquier operación sobre la clase resultante como lo haríamos sobre cualquier otra clase.
[ Joins (uniones) entre clases]
Hasta ahora, nuestras consultas sólo accedían a una clase a la vez. Las consultas pueden acceder a múltiples
clases a la vez, o acceder a la misma clase de tal modo que múltiples instancias de la clase sean procesadas al
mismo tiempo . Una consulta que acceda a múltiples instancias de las mismas o diferentes clases a la vez se
conoce como una consulta join. Como ejemplo, digamos que queremos encontrar todos los registros que están
en el rango de temperaturas de otros registros. En efecto, necesitamos comparar los atributos temp_lo y
temp_hi de cada instancia EMP con los atributos temp_lo y temp_hi de todas las demás instancias EMP.
Esto es sólo un modelo conceptual. El verdadero join puede hacerse de una manera más eficaz, pero
esto es invisible para el usuario.
Podemos hacer esto con la siguiente consulta:
[ Joins (uniones) entre clases]
6
[[BR]]SELECT W1.city, W1.temp_lo AS low, W1.temp_hi AS high,[[BR]] W2.city, W2.t
low, W2.temp_hi AS high[[BR]] FROM weather W1, weather W2[[BR]] WHERE W1.temp_lo
W2.temp_lo[[BR]] AND W1.temp_hi >
W2.temp_hi;[[BR]][[BR]]+--------------+-----+------+---------------+-----+-----| low | high | city | low | high
|[[BR]]+--------------+-----+------+---------------+-----+------+[[BR]]|San Fran
57 | San Francisco | 46 | 50
|[[BR]]+--------------+-----+------+---------------+-----+------+[[BR]]|San Fran
54 | San Francisco | 46 | 50
|[[BR]]+--------------+-----+------+---------------+-----+------+[[BR]][[BR]]
En este caso, tanto W1 como W2 son sustituidos por una instancia de la clase weather y se extienden por
todas las instancias de la clase. (En la terminología de la mayoría de los sistemas de bases de datos W1 y W2
se conocen como range variables (variables de rango).) Una consulta puede contener un número arbitrario de
nombres de clases y sustituciones.
[ Actualizaciones]
Puede actualizar instancias existentes usando el comando update. Suponga que descubre que la lectura de las
temperaturas el 28 de Noviembre fue 2 grados superior a la temperatura real. Puede actualizar los datos de
esta manera:
[ Actualizaciones]
7
[[BR]]UPDATE weather[[BR]] SET temp_hi = temp_hi - 2, temp_lo = temp_lo 2[[BR]] WHERE date > '11/28/1994';[[BR]][[BR]]
[ Borrados]
Los borrados se hacen usando el comando delete:
[[BR]]DELETE FROM weather WHERE city = 'Hayward';[[BR]][[BR]]
Todos los registros de weather pertenecientes a Hayward son borrados. Debería ser precavido con las
consultas de la forma
[[BR]]DELETE FROM classname;[[BR]][[BR]]
Sin una cualificación, delete simplemente borrará todas las instancias de la clase dada, dejándola vacía. El
sistema no pedirá confirmación antes de hacer esto.= [ Uso de funciones de conjunto] = Como otros lenguajes
de consulta, PostgreSQL soporta funciones de conjunto. Una función de conjunto calcula un único resultado a
partir de múltiples filas de entrada. Por ejemplo, existen funciones globales para calcular count(contar)
,sum (sumar), avg (media), max (máximo) and min (mínimo) sobre un conjunto de instancias.
Es importante comprender la relación entre las funciones de conjunto y las cláusulas SQL where y having . .
La diferencia fundamental entre where y having es que: where selecciona las columnas de entrada antes de
los grupos y entonces se computan las funciones de conjunto (de este modo controla qué filas van a la función
de conjunto), mientras que having selecciona grupos de filas después de los grupos y entonces se computan
las funciones de conjunto. De este modo la cláusula where puede no contener funciones de conjunto puesto
que no tiene sentido intentar usar una función de conjunto para determinar qué fila será la entrada de la
función. Por otra parte, las cláusulas having siempre contienen funciones de conjunto. (Estrictamente
hablando, usted puede escribir una cláusula havingque no use funciones de grupo, pero no merece la pena. La
misma condición podría ser usada de un modo más eficaz conwhere .)
Como ejemplo podemos buscar la mínima temperatura en cualquier parte con
[[BR]]SELECT max(temp_lo) FROM weather;[[BR]][[BR]]
Si queremos saber qué ciudad o ciudades donde se dieron estas temperaturas, podemos probar
[[BR]]SELECT city FROM weather WHERE temp_lo = max(temp_lo);[[BR]][[BR]]
pero no funcionará debido a que la función max() no puede ser usada en where. Sin embargo, podemos
replantar la consulta para llevar a cabo lo que buscamos. En este caso usando una subseleccion:
[[BR]]SELECT city FROM weather WHERE temp_lo = (SELECT max(temp_lo) FROM
weather);[[BR]][[BR]]
Lo que ya es correcto, ya que la subselección es una operación independiente que calcula su propia función de
grupo sin importar lo que pase en el select exterior.Las funciones de grupo son también muy útiles
combinándolas con cláusulas group by . Por ejemplo, podemos obtener la temperatura mínima tomada en cada
ciudad con :
[[BR]]SELECT city, max(temp_lo)[[BR]] FROM weather[[BR]] GROUP BY
city;[[BR]][[BR]]
que nos devuelve una fila por ciudad. Podemos filtrar estas filas agrupadas usando having:
[ Borrados]
8
[[BR]]SELECT city, max(temp_lo)[[BR]] FROM weather[[BR]] GROUP BY
city[[BR]] HAVING min(temp_lo) < 0;[[BR]][[BR]]
que nos da los mismos resultados, pero de ciudades con temperaturas bajo cero. Finalmente, si sólo nos
interesan las ciudades cuyos nombres empiecen por 'P', deberíamos hacer :
[[BR]]SELECT city, max(temp_lo)[[BR]] FROM weather[[BR]] WHERE city like
'P%'[[BR]] GROUP BY city[[BR]] HAVING min(temp_lo) < 0;[[BR]][[BR]]
Tenga en cuenta que podemos aplicar la restricción del nombre de ciudad en where, ya que no necesita
funciones de conjunto. Esto es más eficaz que añadir la restricción a having,debido a que evitamos hacer los
cálculos de grupo para todas las filas que no pasan el filtro de where .= [ Características Avanzadas
de SQL en Postgres] = Habiendo cubierto los aspectos básicos de Postgre SQLpara acceder a los datos,
discutiremos ahora aquellas características de Postgres que los distinguen de los gestores de bases de datos
convecionales. Estas características incluyen herencia, time travel (viaje en el tiempo) y valores no-atómicos
de datos (atributos basados en vectores y conjuntos). Los ejemplos de esta sección pueden encontrarse
también en advance.sql en el directorio del tutorial. (Consulte el el capítulo de nombre El Lenguaje de
consultas para ver la forma de utilizarlo).
[ Herencia]
Creemos dos clases. La clase capitals contiene las capitales de los estados, las cuales son también ciudades.
Naturalmente, la clase capitals debería heredar de cities.
[[BR]]CREATE TABLE cities ([[BR]] name text,[[BR]] population
float,[[BR]] altitude int -- (in ft)[[BR]]);[[BR]][[BR]]CREATE TABLE
capitals ([[BR]] state char(2)[[BR]]) INHERITS (cities);[[BR]][[BR]]
En este caso, una instancia de capitals hereda todos los atributos (name, population y altitude) de su padre,
cities. El tipo del atributo name (nombre) es text, un tipo nativo de Postgres para cadenas ASCII de longitud
variable. El tipo del atributo population (población) es float, un tipo de datos, también nativo de Postgres ,
para números de punto flotante de doble precisión. Las clase capitals tiene un atributo extra, state, que muestra
a qué estado pertenecen. En Postgres, una clase puede heredar de ninguna o varias otras clases, y una consulta
puede hacer referencia tanto a todas las instancias de una clase como a todas las instancias de una clase y sus
descendientes.La jerarquía de la herencia es un gráfico acíclico dirigido.
Por ejemplo, la siguiente consulta encuentra todas aquellas ciudades que están situadas a un altura de 500 o
más pies:
[[BR]]SELECT name, altitude[[BR]] FROM cities[[BR]] WHERE altitude >
500;[[BR]][[BR]]+----------+----------+[[BR]]|name | altitude
|[[BR]]+----------+----------+[[BR]]|Las Vegas | 2174
|[[BR]]+----------+----------+[[BR]]|Mariposa | 1953
|[[BR]]+----------+----------+[[BR]][[BR]]
Por otro lado, para encontrar los nombres de todas las ciudades, incluídas las capitales estatales, que estén
situadas a una altitud de 500 o más pies, la consulta es:
[[BR]]SELECT c.name, c.altitude[[BR]] FROM cities* c[[BR]] WHERE
c.altitude > 500;[[BR]][[BR]]
which returns:
[ Herencia]
9
[[BR]]+----------+----------+[[BR]]|name | altitude
|[[BR]]+----------+----------+[[BR]]|Las Vegas | 2174
|[[BR]]+----------+----------+[[BR]]|Mariposa | 1953
|[[BR]]+----------+----------+[[BR]]|Madison | 845
|[[BR]]+----------+----------+[[BR]][[BR]]
Aquí el "*" después de cities indica que la consulta debe realizarse sobre cities y todas las clases que estén por
debajo de ella en la jerarquía de la herencia. Muchos de los comandos que ya hemos discutido
(select, and>upand> and delete) brindan soporte a esta notación de "*" al igual que otros como alter.= [
Valores No-Atómicos] = Uno de los principios del modelo relacional es que los atributos de una relación son
atómicos Postgres no posee esta restricción; los atributos pueden contener sub-valores a los que puede
accederse desde el lenguaje de consulta. Por ejemplo, se pueden crear atributos que sean vectores de alguno
de los tipos base.
[ Vectores]
Postgres permite que los atributos de una instancia sean definidos como vectores multidimensionales de
longitud fija o variable. Puede crear vectores de cualquiera de los tipos base o de tipos definidos por el
usuario. Para ilustrar su uso, creemos primero una clase con vectores de tipos base.
[[BR]]CREATE TABLE SAL_EMP ([[BR]] name text,[[BR]] pay_by_quarter
int4[],[[BR]] schedule text[][][[BR]]);[[BR]][[BR]]
La consulta de arriba creará una clase llamada SAL_EMP con una cadena del tipo text (name),un vector
unidimensional del tipo int4 (pay_by_quarter), el cual representa el salario trimestral del empleado y un vector
bidimensional del tipo text (schedule), que representa la agenda semanal del empleado. Ahora realizamos
algunos INSERTSs; note que cuando agregamos valores a un vector, encerramos los valores entre llaves y los
separamos mediante comas. Si usted conoce C, esto no es distinto a la sintaxis para inicializar estructuras.
[[BR]]INSERT INTO SAL_EMP[[BR]] VALUES ('Bill',[[BR]] '{10000, 10000,
10000, 10000}',[[BR]] '{{"meeting", "lunch"}, {}}');[[BR]][[BR]]INSERT
INTO SAL_EMP[[BR]] VALUES ('Carol',[[BR]] '{20000, 25000, 25000,
25000}',[[BR]] '{{"talk", "consult"}, {"meeting"}}');[[BR]][[BR]]
Postgres utiliza de forma predeterminada la convención de vectores "basados en uno" -- es decir, un vector de
n elementos comienza con vector[1] y termina con vector[n]. Ahora podemos ejecutar algunas consultas sobre
SAL_EMP. Primero mostramos como acceder a un solo elemento del vector por vez. Esta consulta devuelve
los nombres de los empleados cuyos pagos han cambiado en el segundo trimestre:
[[BR]]SELECT name[[BR]] FROM SAL_EMP[[BR]] WHERE
SAL_EMP.pay_by_quarter[1] <>[[BR]]
SAL_EMP.pay_by_quarter[2];[[BR]][[BR]]+------+[[BR]]|name
|[[BR]]+------+[[BR]]|Carol |[[BR]]+------+[[BR]][[BR]]
La siguiente consulta recupera el pago del tercer trimestre de todos los empleados:
[[BR]]SELECT SAL_EMP.pay_by_quarter[3] FROM
SAL_EMP;[[BR]][[BR]][[BR]]+---------------+[[BR]]|pay_by_quarter
|[[BR]]+---------------+[[BR]]|10000 |[[BR]]+---------------+[[BR]]|25000
|[[BR]]+---------------+[[BR]][[BR]]
También podemos acceder a cualquier porción de un vector, o subvectores. Esta consulta recupera el primer
item de la agenda de Bill para los primeros dos días de la semana.
[ Vectores]
10
[[BR]]SELECT SAL_EMP.schedule[1:2][1:1][[BR]] FROM SAL_EMP[[BR]] WHERE
SAL_EMP.name = 'Bill';[[BR]][[BR]]+-------------------+[[BR]]|schedule
|[[BR]]+-------------------+[[BR]]|{{"meeting"},{""}}
|[[BR]]+-------------------+[[BR]][[BR]]
[ Más características avanzadas]
Postgres posee muchas características que no se han visto en este tutorial, el cual ha sido orientado hacia
usuarios nuevos de SQL. Las mencionadas características se discuten tanto en la Guía del Usuario como en la
del Programador.
[ Más características avanzadas]
11