El COMO del SGBDR PostgreSQL(Sistema de base de datos Objeto-Relacional)

Al Dev (Alavoor Vasudevan) alavoor@yahoo.com

v15.0, 5 December 1999

Grupo de traducción de la documentación de PosreSQL RDBMS pgsql-trad@todolinux.org

v0.1, 18 de Febrero de 2000

Este documento es una "guía práctica" para poner en funcionamiento un motor de base de datos SQL y las herramientas del cliente en un sistema UNIX. También se discute el lenguaje estandar Internacional ANSI/ISO SQL y revisa los meritos/ventajas de los motores de base de datos SQL desarrolladas en la red de internet en un ambiente de "desarrollo abierto". Este COMO trata de poner en marcha la última generación de SGBDR (Sistema de Gestión de Bases de Datos Relacionales, RDBMS en inglés) "PostgreSQL" en sistemas UNIX, que puede ser usada como un servidor de datos de aplicación, o como un de base de datos en web. PostgreSQL implementa un subgrupo del SQL ISO/ANSI estandar internacional, de los años 1998,92,89. Este documento también da información sobre los programas de interface de la base de datos como IU,s "Front End" (del lado del cliente), herramientas RAD (Rapid Application Development, herramientas de desarrollo rápido de aplicaciones), drivers ODBC y JDBC, interfaces de programación en "C", "C++", Java, Perl y herramientas de based de datos para la web. La información que se da se aplica a todas las plataformas UNIX y a todas las otras bases de datos SQL. Será muy utilizable por los usuarios que sean nuevos en bases de datos, lenguaje SQL y PostgreSQL. Este documento también tiene un tutorial de SQL, sintaxis de SQL que será muy utilizable por los principiantes. Los usuarios experimentados pueden utilizar este documento como una guía de referencia. Para estudiantes, la información que aquí se dá será utilizable para adquirir el código fuente del SGBDR PostgreSQL, de donde aprenderán como está creado un motor de base de datos SQL.

1. Introducción

El propósito de este documento es proporcionar una lista extensiva de punteros/URL,s para poner en funcionamiento rápidamente PostgreSQL y también defender los beneficios del Sistema de Código Abierto (Open Source) como PostgreSQL o Linux.

Todos y cada uno de los ordenadores del mundo necesitan una base de dastos para almacenar/recuperar la información. La razón primaria por la que usamos el ordenador es almacenar, recuperar y procesar la información y todo ello hacerlo muy rápidamente, aprovechando de este modo tu tiempo. Al mismo tiempo, el sistema debe ser simple, robusto, rápido, fiable, económico y muy fácil de usar. La base de datos es el SISTEMA MÁS VITAL porque almacena la información para la misión crítica de cada compañía de este mundo. Las sistemas de bases de datos más populares están basados en las especificaciones SQL de la Organización Internacional de Estandares (ISO, International Standard Organisation en inglés), los cuales a su vez están basados en el estandar estadounidense ANSI SQL. Las especificaciones más habitualmente usadas en la industria son las ISO/ANSI SQL de 1992. El próximo estandar será el SQL 1998/99, llamado SQL-3, y que está bajo desarrollo. Los sistemas de bases de datos populares como Oracle, Sybase o Informix están basados en estos estandares o son intentos de implementarlos.

Hay más de 20 variedades de sistemas de base de dastos comerciales o de internet, que son utilizados en el mundo y muchas más se desarrollarán en el futuro próximo. Sin un estandard como el ANSI/ISO SQL, sería muy dificil para los clientes desarrollar una aplicación una vez y correrla en todos los sistemas de base de datos. Los clientes quieren desarrollar una vez la aplicación utilizando ISO SQL, ODBC, JDBC y ejecutarla contra todos los sistemas de base de datos del mundo.

La basde de datos GRATUITA más popular del mundo, y que implementa algunos de los estandares ISO SQL, ANSI SQL/98, SQL/92 Y ANSI SQL 89 es PostgreSQL. PostgreSQL es una base de datos Objeto-relacional de próxima generación, y los futuros estándares ANSI SQL como SQL 1998 (SQL-3) y siguientes incrementarán el acercamiento entre las bases de datos de tipo Objeto, y las orientadas a datos. PostgreSQL es el único SGBDR gratuito del mundo que soporta bases de datos Objeto y SQL. Este documento le indicará cómo instalar la base de datos, como levantar la base de datos de Web, base de datos de aplicación, interface gráfico de cliente y programas de interface. Le advertimos seriamente que usted DEBE escribir sus aplicaciones de bases de datos ajustadas al 100 % (100 % compliant, que dicen en inglés) a los estándares ISO/ANSI SQL, ODBC, JDBC de modo que su aplicación sea portable a través de múltiples bases de datos, como PostgreSQL, Oracle, Sybase, Informix, etc.

Usted adquirirá la más alta calidad y un montón de características compeltas con PostgreSQL porque ella sigue el 'modelo de desarrollo Código de Fuente Abierta (Open Source)'. El modelo de Código de Fuente Abierta es elúnico donde el código fuente completo se le proporciona a usted, y el desarrollo tiene lugar en internet por una red de cerebros humanos extremadamente amplia. El futuro mostrará que la mayoría del desarrollo de software tendrá lugar en la "Super-Autopista de la Información", que abarca todo el globo. En los años venideros, el crecimiento de internet será explosivo, lo que acelerará la rápida adopción de PostgreSQL por la comunidad de bases de datos.

Aplicando los principios de la estadística, las matemáticas y la ciencia de la calidad del software, usted adquiere la más alta calidad del software sólo en un 'Sistema de Código de Fuente Abierta' como PostgreSQL, donde el código fuente está abierto a un muy amplio número de cerebros humanos interconectados por la Super-Autopista de la información. Cuantos más cerebors estén trabajando en el proyecto, mejor resultará la calidad del software. El modelo del Código de Fuente Abierta previene de REINVENCIONES DE LA RUEDA, elimina DUPLICACIONES DE TRABAJO y de este modo será más económico, reduce el tiempo de distribución y sigue las leyes de la moderna economía, optimizando los recursos nacionales y globales.Una vez que el trabajo del softwae está hecho, por otros, usted YA NO necesita re-hacerlo de nuevo. Usted ya no tirará a la basura su valioso tiempo en algo que ya ha sido BIEN HECHO. Su tiempo es extremadamente precioso y debe ser utilizado eficientemente, porque ¡usted solo tiene 8 horas al día para hacer su trabajo! Conforme entremos en el siglo XX, se producirá un cambio en la forma en la que usted adquirirá el software para su uso futuro. Los usuariso le darán preferencia primero al software del sistema abierto, como PostgreSQL o Linux.

Si usted compra binarios, usted no adquiere ninguna equidad ni derecho de propiedad sobre el código fuentes. El códido fuente es muy valioso, mientras que los binarios no tienen valor. Comprar software puede volverse un tema del pasado. Usted sólo necesita comprar buen hardware, lo que es equivalente a dinero para gastos personales en informática, y adquirir el software desde internet. U punto importante es que es el hardware del ordenador el que está haciendo el grueso del trabajo. El hardware es el autentico caballo de carga, y el software es sólo quien lo dirige. El hardware del ordenador es por ello tan complejo que sólo 6 naciones de los 180 paises del mundo han demostrado la capacidad de diseñar y consutruir chips y hardware de ordenadores. El diseño y construcción de chips de ordenador es una tecnología avanzada. Alcanzar la tecnología de las 0.18 micras es un proceso muy complejo, que exige inversiones intensivas de capital, y profundas investigaciones en plantas y máquinas de producción. En un úncio chip de silicio están densamente empaquetados millones de transistores y circuitos. Las compañías como Applied Material, AMD, Intel, Cyrix, Hitachi, IBM y otras invierten un número significativo de horas/hombre para dominar las altas tecnologías como el Diseño de Chips, la Microelectrónica y la Nanoelectrónica. Un micrómetro es una millonésima de metro, un nanómetro es una mil-millonésima de metro (Nota del traductor: el original habla de una billonésima, pero en Estados Unidos, un billón son 1.000.000.000, mientras que en Europa, un billón son 1.000.000.000.000, mil veces más. Este suele ser un factor de confusión al interpretar cantidades de este calado entre estadounidenses y europeos). La tecnología actual utiliza microelectrónica de alrededor de 0.35 miras, utilizando aluminio como conductor, y 0.25 micras utilizando cobre como conductor de electrones. En un próximo futuro, se utilizará la tecnología de las 0.10 micras con cobre e incluso nanoelectrónica para construir chips. Los conductores de aluminio serán sobrepasados por los de cobre, porque el cobre es mejor conductor de electrones. En procesos de fotolitografía en el ultravioleta extremo, se utilizarán tecnologías de rayos X o de barrido de electrones para grabar los circuitos, con tamaños característicos menores de 0.15 micras. Dentro de unos 20 años, los chips de silicio serán sustituidos por ordenadores moleculares y bio-chips que serán miles de millones de veces más rápidos que los chips de silicio. Las moleculas son grupos de átomos, y los átomos son pequeñas particulas que realizan todo lo que usted ve en este mundo. Los ordenadores moleculares usarán las moléculas como una forma de interruptores electrónicos si/no ultrarrápidos. Cuando el interruptor está en ON indica 1, y cuando está en OFF indica 0. Todos los programas de ordenador de este mundo están basados en esta forma binaria, los números 1 y 0. La tabla siguiente muestra el progreso pasado y las tendencias de avance futuro de los chips de ordenador.

               Estimación de las capacidades de los chips en el futuro
               *******************************************************
+--------------------------+---------+---------+---------+---------+--------+---------+
| Tema/año                 | 1997    | 1999    | 2001    | 2003    | 2012   | 2020    |
+--------------------------+---------+---------+---------+---------+--------+---------+
| Tamaño distintivo(micras)| 0.25    | 0.18    | 0.15    | 0.13    | 0.05   |< 0.00001|
+--------------------------+---------+---------+---------+---------+--------+---------+
| Tamaño del procesador(mm)| 200     | 300     | 300     | 300     | 450    | Mol/Bio |
+--------------------------+---------+---------+---------+---------+--------+---------+
| Min voltaje operativo    | 1.8-2.5 | 1.5-1.8 | 1.2-1.5 | 1.2-1.5 | 0.5-0.6| < 0.001 |
+--------------------------+---------+---------+---------+---------+--------+---------+
| Max disipación de energía| 70      | 90      | 110     | 130     | 175    | 600     |
+--------------------------+---------+---------+---------+---------+--------+---------+
| Frecuencia del chip(MHz) | 750     | 1,250   | 1,500   | 2,100   | 10,000 | > 50,000|
+--------------------------+---------+---------+---------+---------+--------+---------+
| Capacidad DRAM           | 256 MB  | 1 GB    | 2 GB    | 4 GB    | 256 GB | > 1000GB|
+--------------------------+---------+---------+---------+---------+--------+---------+

Como usted puede ver, es el hardware el que es alta tecnología e importante, mientras qeuel software es una tecnología menos dificil. Por ello, ¡fabricar el hardware y sus componentes es vital para la economía del país! ¡Compañías como Compaq, Dell, Sun Microsystems, HP, o IBM, que fabrican ordenadores son contribuyentes fundamentales a la economía de los Estados Unidos hoy y en el futuro!

Por otro lado, todos y cada uno de los paises del mundo desarrollan/hacen software. De hecho, cualquier persona en este mundo, con un pequeño PC de bajo coste puede crear un sistema servidor de bases de datos Oracle. Pero le llevaría alrededor de 10 años. (El servidor de bases de datos Oracle requeriría alrededor de 10 años/hombre de trabajo). Un año-hombre es una persona trabajando a tiempo completo durante un año. Si 10 personas trabajan durante un año, eso supone 10 años hombre.

Bases de datos como Oracle, Informix, Sybase, IBM DB2 (Unix) están escritas usando el lenguaje "C" y sus binarios se crean compilando el codigo fuente y vendiendolo entonces a los clientes. ¡as bases de datos Oracle, Sybase o Informix son programas "C" en un 100 %!

Puesto que se ha dedicado un montón de trabajo a PostgreSQL en los pasados 14 años, no tiene sentido recrear otro sistema de bases de datos que satisfaga ANSI/ISO SQL de la nada. Será una gran ventaja tomar el código existente y añadirle características que le falten o mecanismos de potenciación a PostgreSQL, y empezar a usarla inmediatamente.

PostgreSQL no es sólo una base de datos gratuita, sino un 'Producto de Internet' de buena calidad. La predicción es que la demanda para los productos 'Made in Internet' crecerá exponencialmente puesto que son capaces de mantener una alta calidad, bajo coste, y una base de usuarios y desarrolladores extremadamente grande. Aquellas naciones que no usen los productos 'Made in Intenet' estarán perjudicandose gravemente. "La Revolución de Internet" llevará mucho más lejos a otros paises. La razón es que "Internet" en sí mismo es ¡LA MAYOR COMPAÑIA DE SOFTWARE DEL MUNDO!

2. ¡Las leyes de la Física se aplican al software!

En este capítulo se mostrará como la ciencia juega un papel importante en la creación de varios objetos como el software, este universo, la masa, los átomos, la energía e ¡incluso usted mismo! Este capítulo también muestra porqué el conocimiento de la cienda es muy importante ANTES de que usted empiece a utlizar los productos de la ciencia. Sus objetos lo incluyen todo, por ejemplo PostgresSQL, el tiempo, la masa, la energía, los planetas, el sol, la luna, las estrellas, las galaxias, los superclusters, los humanos, etc.. todos ellos son objetos creados por la ciencia. Este capítulo tambien muestra como las leyes de la ciencia y la estadística favorecen el código de fuentes abierta como PostgresSQL o Linux. Conforme la velocidad e intenet se va incrementando cada día, e intenet se está volviendo más y más fiable, el código de fuente abierta va alcanzando cada vez más rápido su momento. Y, si las relgas de la estadística y las leyes de la física son correctas, los sistemas de código de fuente cerrada eventualmente DESAPARECERÁN del planeta.

Los parrafos que siguen le demostrarán - "cuanto más vasta es la cienta tanto más importante es para el hombre y tanto más impactan los proyectos de software libre como PostgresSQL o Linux".

Desarrollar un proyecto como PostgresSQL requiere recursos como energía y tiempo, puesto que PostgresSQL es un producto de energía y tiempo. Puesto que la energía y el tiempo pueden ser explicadas sólo por la ciencia, hay una correlación directa entre la física y los proyectos de software libre como PostgresSQL o Linux.

Las leyes de la ciencia (de la Física) se aplican a todo y en todo momento, a todo lo que usted haga, incluso mientras está desarrollando los proyectos de softwaer. La Física está en acción incluso mientras usted está hablando (ondas de sonido), andando (fricción entre el pavimento y sus pies), leyendo un libro o escribiendo software. Varias ramas de la ciencia como la física, la química, etc se mezclan todos en una gran región llamada Matemáticas (a las que se conoce también como la Reina de todas las Ciencias). Todo en este mundo tiene una firme raiz en las matemáticas. El Algebra Moderna se enlaza con la 'Teoría de los Sets', 'El Algebra Relacional', la Ciencia de los grupos, Colecciones, Sets, Uniones, Intersecciones, Exclusiones, Dominios, Listas, etc.

El software como PostgresSQL existe hoy debido a la energía y el tiempo. ¡Es la energía la que ha creado este mundo, los cerebros humanos y muchas otras materias! ¡Y la masa y la energía son UNA y la MISMA entidad! ¡l hecho de que la masa y la energía eran lo mismo lo conocía la gente hace ya 100 años!

Las células del cerebro humano consumen energía mientras procesan (creando software), convirtiendo la energía química del alimento en energías electrica y calórica. Incluso mientras usted está leyendo este párrajo, las células de su cerebro estan consumiendo el combustible y usando grandes cantidades de energía. De modo que ¡DEJE DE LEER AHORA! La actividad energética de las neuronas (células cerebrales) puede ser medida en el laboratorio. Por ejemplo, hay muchos instrumentos como 'Detectores de Mentiras' y otros instrumentos médicos los cuales pueden medir la actividad energética del cerebro. Todo esto implica que el cerebro humano es una máquina termodinámica de calor. Puesto que el cerebro humano es una máquina termodinámica, las leyes de la termodinámica se aplican al cerebro y de este modo la termodinámica tiene efectos indirectos en el software como PostgresSQL.

Incluso para la ciencia, es imposible construir cualquier sistema o teoría (incluyendo el software de un sistema de base de datos) que sea un 100 % perfecto y libre de errores. Esto es como pedir un milagro, NUNCA alcanzaremos el objetivo del sistema o la teoría perfectos. Las discusiones y ecuaciones matemáticas detalladas prueban que el 'sistema perfecto' (igual que el 'sistema imperfecto') es imposible, es un tema avanzado y está más allá del tema de este documento. Y tal discusión matemática se enlaza con los números infinitos de dimensiones (como las dimensiones primarias) que existen en la naturaleza. Desgraciadamente, los humanos sólo pueden ver 4 dimensiones, pero las matemáticas pueden explorar facilmente muchas otras dimensiones. Otras dimensiones son 'infinítamente más pequeñas' que los átomos, y ¡los átomos mismos son tan diminutos que no se pueden ver con los ojos humanos! Las matemáticas son muy poderosas y pueden analizar y explicar el nacimiento o muerte de nuestro universo. Nuestro universo tiene casi tamaño cero si lo miras desde otro universo, y viceversa. Es decir, ¡nuestro universo no es visible (no existe) para personas de otro universo! ¡Y viceversa! Teóricamente, usted puede existir fuera de nuestro universo, y viajar una gran distancia (miles de millones de años luz) en un tiempo cero, y reentrar en el universo en un punto diferente del espacio-tiempo. ¡La distancia entre nuestro universo y otros universos es realmente cero!

Aunque haya un número infito de dimensiones, pueden todas generarse/derivarse de un pequeño número de dimensiones PRIMARIAS. Es decir, un número infinito de dimensiones se pueden combinar y colapsar en dimensiones primarias. Las dimensiones primarias simplemente absorven las otras dimensiones sin ser ellas mismas destruidas. Las matemáticas utilizan estas dimensiones primarias para conocer el nacimiento y la muerte de los universos. El universo donde usted está viviendo en estos momentos empezó con un BIG BANG ("la gran explosión") hace miles de millones de años (aproximadamente unos 20.000.000.000 años) causado por las interaciones de partículas atómicas de otras dimensiones. Justo antes de la gran explosión, había un pequeño punto en el que la longitud, el ancho, el alto y el tiempo eran CERO (o lo que es lo mismo, ¡nuestro universo NO ERA!) y existían otros universos y dimensiones primarias. El tiempo mismo no existía, y los átomos, las estrellas, los planetas y las galaxias ¡NO ESTABAN AQUÍ! ¡Los átomos que forman su cuerpo no estaban aquí tampoco! ¡Por lo tanto, muchas cosas ocurrieron ANTES de que el tiempo naciera!

La gran explosión, y con ello el nacimiento de de nuestro universo, fueron causados por unos pocos átomos de dimensiones primarias. ALGO (¿alguien?) causó el estallido de unos pocos átomos de otras dimensiones para crear nuestro universo, y ¡las nuevas dimensiones del tiempo, longitud, altura y anchura nacieron! Nosotros vemos la mano de alguien en este proceso. Ese proceso no es muy conocido por el hombre. El hombre está intentando generar otro universo en el laboratorio simulando el acontencimiento de la gran explosión (En Europa están construyendo un acelerador Huge, otra construcción en Dalas, EEUU, ha sido detenida por el Congreso de los Estados Unidos por recortes presupuestarios). Hay átomos de otras dimensiones justo como nosotros tenemos átomos en nuestro universo. Teóricamente, ¡Usted puede crear/generar un número infinito de Universos! Este proceso es reversible, es decir, nuestro universo podría cerrarse completamente y desaparecer en unos pocos átomos de otra dimensión. Es una analogía similar a cómo USTED nació de dos pequeñas células que chocaron la una contra la para crear una única célula. Esta única célula se dividió y multiplicó en 6 trillones (N. del t: numeración estadounidense, ignoro la traducción a numeración europea) de células para devenir en un humano de 1'80 metros de altura (¡en usted!). Hay algunas similaridades entre los humanos y los universos: los universos nacen y mueren, del mismo modo que los humanos.

Puesto que el estado PERFECTO (lo mismo que un IMPERFECTO) es imposible, los universos, como nosotros, nacen y mueren en un proceso cíclico. ¡PERO NADA PERFERCTO puede morir, la ciencia sólo permite la transformación! Nuestro universo se está expandiendo ahora a una velocidad tremenda, no es estático sino muy dinámico. Este universo seguirá expandiendose hasta que algo interfiera para colapsarlo aplicando presiones con dimensiones externas para absorverlo y anularlo. Hay dos posibilidades: retirar la masa de nuestro universo a través de agujeros negros (un proceso lento) o inyectar más masa en nuestro universo a través de agujeros blancos, que es un proceso mucho más rápido. Puede haber millones de universos en existencia, pero puede haber muy pocos univeros que estén construidos a partir de dimensiones primarias. ¡Usted no sólo puede hacer átomos de este universo, sino también átomos de otras dimensiones! En los agujeros negros, los átomos y las partículas de nuestro universo son absorvidos y transformados y convertidos en partículas de otras dimensiones. En el centro de un agujero negro, el tiempo, la longitud, anchura y altura son cero. Y el agujero negro es una puerta de entrada/salida con otros universos. Las puertas de entrada/salida a otros universos se pueden abrir en cualquier sitio, incluso dentro de su cuerpo.

Puede haber un infinito número de colores, lenguajes de ordenador, diseños de chips de ordenador y teorías, pero NO PUEDE HABER UN ÚNICO Y PERFECTO color, lenguaje de ordenador, diseño o sistema. Lo único que puede usted alcanzar es un CASI PERFECTO color (longitud de onda), sistema, base de datos o teoría. La naturaleza es como un Kaleidoscopio.

Combinando las energías de millones de personas alrededor del globo vía internet es posible alcanzar un sistema CASI PERFECTO (incluendo un sistema de base de datos). Individualmente, la energía de cada persona será diminuta, pero uniendo en una red un gran número de personas, la energía total será enorme, y podrá ser enfocada en un proyecto para generar un sistema casi perfecto. Los humanos seguirán siendo criaturas de energía y recursos finitos, frecuentemente culpables de errores que van desde lo trivial a lo profundo. Debido a que nuestra propensión a los varía mucho con los motivos particulares, la experiencia particular y vaguedades del momento, el descubrimiento y la eliminación de bugs del software producidos por errores humanos ordinarios se verá enormemente facilitada incorporando un gran número de mentes enfocadas al problema. Además, más individuos representan un extra de personas-hora de código y sus funciones asociadas.

Está muy claro que internet puede reunir una red de un vasto número de personas, lo que implica que intenet tiene un montón de energía y tiempo que puede producir productos de software de mucha mayor calidad en mucho menor tiempo que el software comparado de las compñias comerciales. Ni siquiera las grandes compañias como Microsoft o IBM pueden sobreponerse a las leyes de la Física, sino que incluso eventualmente ¡SE RENDIRÁN a las leyes de la ciencia!

Hoy, hay muchos SGBDR SQL en el mundo apuntando a una única especificación ANSI/ISO SQL. El hombre no debe malgastar su tiempo creando demasiados SIMILARES/IDENTICOS paquetes de software, habiendo muchos otros temas de la ciencia que necesitan una buena atención.

La conclusión es que debido a las leyes de la ciencia, el sistema 'código de fuente abierta' como PostgresSQL y Linux será siempre mucho mejor que el sistema 'código de fuente cerrada' y es posible probar esta aseveración científicamente.

3. ¿Qué es PostgreSQL ?

PostgreSQL Version 6.5.3 es una base de datos gratuíta, cuyo código fuente completo se le proporciona a usted. Es un Sistema de Base de Datos Objeto-Relacional próximo a cumplir (probáblemente el más próximo) con ANSI SQL1998,92,89 y corre bajo diversas plataformas hardware y sistemas operativos. Algunas veces se fijan bugs (errores) de emergencia con parches que son liberados tras la release GA de Postgresql. Usted puede aplicar estos parches opcionales dependiendo de las necesidades de su aplicación. Para aplicar los parches, siga estos pasos: Cambie al directorio fuente de Postgresql

                cd /usr/src/postgresql6.5.3
                man patch
                patch -p0 < patchfile
                make clean
                make

Los parches se encuentran en

El objetivo último y el éxito final de Postgresql es cumplir al 100 % el ANSI/ISO SQL y también volverse la base de datos genérica número UNO del munco. Postgresql también guiará, conducirá, controlará, monitorizará y dictará el futuro del ANSI/ISO SQL. Es decir: la implementación y las ideas primero tendrán lugar en Postgresql y más tarde serán incorporadas al ANSI/ISO SQL.

Informix Universal server (versión de 1997), está basada en una versión previa de PostgreSQL porque Informix compró Illustra Inc. y la integró con Informix. La base de datos de Illustra estaba completamente basada en Postgres, una versión anterior de PostgreSQL.

PostgreSQL es una potenciación del sistema de gestión de bases de datos POSTGRES, un prototipo de investigación de SGBD de segunda generación. Aunque PostgreSQL mantiene el poderoso modelo de datos y la riqueda en tipos de datos de POSTGRES, reemplaza el lenguaje de query PostQuel por un subgrupo extendido de SQL.

El desarrollo de PostgreSQL esta siendo desarrollado por un equipo de desarrolladores de Internet, suscritos a la lista de correo de desarrollo de PostgreSQL. El coordiandor actual es Marc G. Fournier.

Este equipo es ahora el responsable para todo el desarrollo actual y futuro de PostgreSQL. De paso, ¡el usuario de la base de datos mismo es el desarrolador de PostgreSQL! La cara de desarrollo se distribuye entre un gran número de usuarios finales de la base de datos en internet.

Los autores de PostgreSQL 1.01 fueron Andrew Yu y Jolly Chen. Muhcos otros han contribuido a la migración, testeo, revisión y potenciación del código. El codigo original de Postgres, del que se deriva PostgreSQL, fue un esfuerzo de muchos estudiantes graduados, estudiantes pregraduados, y equipo de programadores trabajando bajo la dirección del Profesor Michael Stonebraker en la Universidas de California en Berkeley.

El nombre orginal del software de Berkeley era Postgres. Cuando se añadió la funcionalidad SQL en 1995, su nombre se cambió a Postgres95. El nombre se cambió al final de 1996 a PostgreSQL.

Hay millones de PostgreSQL instalados como servidores de bases de datos, coo servidores de bases de datos para Web y como servidores de datos para aplicaciones. Es mucho más avanzada y es una base de datos relacional orientada a objetos (SGBDRO).

Postgresql puede almacenar más tipos de datos que los tipos tradicionales como enteros, caracteres, etc. Usted puede crear tipos definidos por el usuario, fuciones, herencia, etc. PostgreSQL corre en Solaris, SunOS, HPUX, AIX, Linux, Irix, Unix de Digital, BSDi, NetBSD, FreeBSD, Unix de SCO, NEXTSTEP, Unixware y todas las otras versiones de Unix. La migración a Windows 95/NT se está realizando.

PostgreSQL y los nombres indicados en este documento están sujetos al COPYRIGHT de la Universidad de California en Berkeley.

4. ¿Dónde adquirirlo ?

Usted puede comprar los CDROM de Linux de Redhat, Debian o Slackware, que ya contienen PostgreSQL en formato paquete (tanto el código fuente como los binarios) en:

La organización PostgreSQL tambien envía CDROM,s de PostgreSQL que contienen el código fuente completo y los binarios para muchos sistemas operativos Unix, junto con documentación completa.

Si sólo desea los binarios de PostgreSQL:

WWW Web direcciones:

Una lista de direcciones ftp :-

El código fuente de PostgreSQL está también accesible en todos los espejos de sunsite unc (un total de alrededor de 1000 sitios alrededor del globo. Está en la distribución de Linux de Red Hat en /pub/contrib/i386/postgresql.rpm.

N.del T., aunque he mantenido la palabra "espejo" por desconocimiento de la terminología utilizada en otros paises, personalmente estoy más habituado a mantener el termino anglosajón mirror, que aunque sea un anglicismo, nunca el castellano le hizo ascos a aprender palabras de otros idiomas.

5. Primeros pasos con PostgreSQL.

Este capítulo le ayudará a instalar y poner en marcha la base de datos muy facilmente en menos de 10 minutos.

5.1 Instalación y Prueba.

Pasos fáciles para instalar, probar, verificar y poner en marcha un Login de PostgreSQL como root. 

# rpm -qpl postgre*.rpm (para ver la lista de los ficheros. Para documentación 'man rpm')
# rpm -qpi postgre*.rpm (para ver información de los paquetes)
# cat /etc/passwd | grep postgres

Nota: Si usted ve un usuario 'postgres', quizá necesite hacer un backup y borrar el directorio home de postgres, y borrar el usuario unix 'postgres', o cambiarle el nombre al usuario unix 'postgres' a algo similiar a 'postgres2'. La instalación se debe hacer sobre un estado "limpio".


# rpm -i postgre*.rpm (Debe instalar todos los paquetes de clientes, desarrollo, 
                       datos y común para que pgaccess pueda trabajar).
# chkconfig --add postgresql  (Para arrancar pg durante el arranque, ver 'man chkconfig')

# cp /usr/lib/pgsql/python/_pg.so /usr/lib/python1.5/lib-dynload (para python)
# /etc/rc.d/init.d/postgresql start  (para levantar postgres)
# su - postgres
bash$ createdb mi_base_de_datos  (Esto creará una base de datos llamada mi_base_de_datos)
                 (para documentación 'man createdb')
bash$ psql mi_base_de_datos   (para documentación 'man psql')
..... en psql presione las flechar arriba/abajo para editar las lineas de historial, or \s 
bash$ export DISPLAY=<hostname>:0.0; pgaccess mi_base_de_datos; (ver 'man pgaccess')

¡¡Ahora puede empezar a lanzar comandos SQL en pgaccess o psql !! 

bash$ cd /usr/doc/postgresql*

Y ahora lea todos los FAQ,s, guías y tutoriales de usuario, programador y administrador.

5.2 Paquetes RPM de PostgreSQL

Vea también la guía "Installation Steps" que encontrará en http://www.ramifordistat.net/postgres

Mantiene los paquetes rpm de PostgreSQL Lamar Owen, a quien encontrarán en lamar.owen@wgcr.org Encontrarán más detalles sobre PostgreSQL en http://www.postgresql.org

5.3 Paquete RPM completo

Descargue el libro de texto 'Maximum RPM' desde http://www.RPM.org el nombre del fichero es

maximum-rpm.ps.gz, y lealo utilizando el comando de linux gv


# gv maximum-rpm.ps.gz

5.4 Probando PyGreSQL - El interface Python 

bash$ cd /usr/lib/pgsql/python
bash$ createdb thilo
bash$ psql thilo
thilo=> create table test (aa char(30), bb char(30) );
bash$ /usr/bin/python
>>> import _pg
>>> db = _pg.connect('thilo', 'localhost')
>>> db.query("INSERT INTO test VALUES ('ping', 'pong')")
>>> db.query("SELECT * FROM test")
eins|zwei
----+----
ping|pong
(1 row)
>>>CTRL+D
bash$
..... Yow! Seems to work - now install it properly
bash$ su - root
# cp /usr/lib/pgsql/python/_pg.so /usr/lib/python1.5/lib-dynload

5.5 Probando Perl - El interface Perl 

bash$ cd /usr/doc/postgresql-6.5.3/examples/perl5

Nota: la variable global @INC debería incluir el módulo Pg.pm en el directorio sitio_perl, y para ello use la opción \I como sigue abajo.

bash$ perl -I/usr/lib/perl5/site_perl/5.004/i386-linux-thread ./example.newstyle

.... ¡Wow! ¡Ha lanzado usted el perl, que está accediendo a la base PostgreSQL!

Lea los ficheros de ejemplos para usar el interface perl.

Read the example files for using perl interface

5.6 Probando las interface libpq, libpq++ 

bash$ cd /usr/doc/postgresql-6.5.3/examples/libpq++
bash$ su root   --> para cambiar al propietario de los ejemplos
# chown -R postgres /usr/doc/postgresql-6.5.3/examples
# exit
bash$ g++ testlibpq0.cc -I/usr/include/pgsql -I/usr/include/pgsql/libpq++
-lpq++ -lpq -lcrypt
bash$ ./a.out  (Nota: Ignore los mensajes de error si le aparece alguno, como más abajo)
> create table foo (aa int, bb char(4));
No tuples returned...
status = 1
Error returned: fe_setauthsvc: invalid name: , ignoring...
> insert into foo values ('4535', 'vasu');
No tuples returned...
status = 1
Error returned: fe_setauthsvc: invalid name: , ignoring...
> select * from foo;
aa   |bb   |
-----|-----|
4535 |vasu |
Query returned 1 row.
>
>CTRL+D
bash$

.... ¡Hurra! ¡Ha hecho usted corred los interfaces C/C++ directamente contra la base PostgreSQL!

5.7 Probando los interfaces Java

Para hacerlo, usted debe instalar el paquete jdk-*glibc*.rpm (los paquetes rpm java)

bash$ cd /usr/doc/postgresql-6.5.3/examples/jdbc
bash$ echo $CLASSPATH
 --> Should show  CLASSPATH=/usr/lib/jdk-1.1.6/lib/classes.zip
bash$ export CLASSPATH=$CLASSPATH:.:/usr/lib/pgsql/postgresql.jar
Edite el fichero psql.java y comente las lineas 'package'
bash$ javac psql.java
bash$ java psql jdbc:postgresql:template1 postgres < password>[1] select * from pg_tables;
tablename       tableowner      hasindexes      hasrules
pg_type postgres        true    false   false
pg_attribute    postgres        true    false   false
[2]
CTRL+C
bash$

.... ¡Hurra! ¡Ha corrido usted directamente la interface Java contra la base PostgreSQL!

5.8 Probando la interface ecpg

bash$ cd /usr/doc/postgresql-6.5.3/examples/ecpg
bash$ ecpg test1.pgc -I/usr/include/pgsql
bash$ cc test1.c -I/usr/include/pgsql -lecpg -lpq -lcrypt
bash$ createdb mm
bash$ ./a.out

.... ¡Bueno! ¡Ha hecho usted corres SQL embebido en "C" contra la base PostgreSQL!

5.9 Probando los ejemplos de SQL - Tipos y funciones definidas por el User 

bash$ cd /usr/doc/postgresql-6.5.3/examples/sql
En desarrollo...

5.10 Probando las interfaces Tcl/Tk

Un ejemplo de interface Tcl/Tk es el programa pgaccess. Lea el fichero /usr/bin/pgaccess usando un editor 

bash$ view /usr/bin/pgaccess
bash$ export DISPLAY=<nombre de su máquina>:0.0
bash$ createdb mydb
bash$ pgaccess mydb

5.11 Probando la interface ODBC

  1. Adquiera el driver odbc para pgsql en http://www.insightdist.com/psqlodbc/

  2. Vea tambien /usr/lib/libpsqlodbc.a

5.12 Probando la interface de hoja de cálculo Motif MPSQL

Adquiera los paquetes rpm en http://www.mutinybaysoftware.com

5.13 Verificación

Para verificar la calidad completa de PostgreSQL, corra el paquete de test de Regresión, haciendo Login como root

# rpm -i postgresql*.src.rpm
# cd /usr/src/redhat/SPECS
# more postgresql*.spec   (para ver los paquetes del sistema rpm que necesita instalar)
# rpm -bp postgresql*.spec  (.. esto preparará el paquete)

El test de regresión necesita los Makefiles y algunos ficheros de cabeceras como *fmgr*.h
que pueden ser construidos con:
# rpm --short-circuit -bc postgresql*.spec ( .. Utilice short-circuit para abreviar)
Aborte la contrucción con CTRL+C, cuando vea 'make -C common SUBSYS.o'
con esto, la configuración estará conseguida, y se habrán creado todos los makefiles y ficheros de
cabecera. Ya no necesita seguir adelante.
# cd /usr/src/redhat/BUILD
# chown -R postgres postgresql*
# su - postgres
bash$ cd /usr/src/redhat/BUILD/postgresql-6.5.3/src/test/regress
bash$ more README
bash$ make clean; make all runtest
bash$ more regress.out

6. PostgreSQL Supporta Bases de Datos extremadamente grandes, mayores de 200 Gb

El rendimiento en maquinas de cpu de 32 bits decaerá muy rápidamente cuando la base de datos exceda de 5 Gb. Puede usted correr una base de 30 Gb en una máquina de 32 bits, pero el rendimiento se degradará. Las máquinas con cpu,s de 32 bits imponen una limitación de la RAM a 2 Gb, 2Gb en el tamaño de los sistemas de ficheros y otras limitaciones al sistema operativo.

Para bases de datos extremadamente grandes, se sugiere decididametne el uso de máquinas de 64 bits, como las cpu Alpha de Digital, las cpu de 64 bits Ultra-sparc de Sun, cpu,s de 64 bits de Silicon graphics, la cpu IA-64 Intel Merced, las máquinas de 64 bits HPUX o las máquinas de 64 bits de IBM. Compile PostgreSQL bajo una cpu de 64 bits, y podrá soportar las más grandes bases de datos y las más largas queries. El rendimiento de PostgreSQL para quieries en bases de datos y tablas grandes será varias veces mejor que el mismo en máquinas de 32 bits. La ventaja de las máquinas de 64 bits es que usted aquirirá un espacio de direccionamiento de memoria muy grande, y el sistema operativo puede sorportar sistemas de ficheros muy grandes, proporcionando mejor rendimiento con bases de datos mayores, mucho mayor soporte de memoria (RAM), tiene mayores capacidades, etc.

7. ¿Cómo puedo confiar en PostgreSQL? El paquete de Test de Regression contruye la confianza del usuario

Para validad PostgreSQL, el paquete de test de Regresión (src/test/regress) está incluido en la distribución. El paquete de test de regresión verificará las operaciones de SQL estandar, así como la extensibilidad de las capacidades de PostgreSQL. El paquete de test de regresión ya contiene cientos de programas de test de SQL.

Usted utilizaría la alta velocidad del ordenador para validar la base, en lugar de utilizar el bajo rendimiento humano. Los ordenadores pueden realizar test de regresión millones e incluso miles de millones de veces más rápido que los humanos. Los ordenadores modernos pueden realizar miles de millones de pruebas de SQL en un tiempo muy corto. En el futuro próximo, ¡la velocidad de los ordenadores será billones de veces mayor que la del cerebro humano! Por ello, tiene sentido utilizar la potencia del ordenador para validar el software.

Usted puede añadir tantas pruebas como necesite, y puede subirlas a la dirección web principal de PostgreSQL si piensa que serán útiles para otros en internet. El paquete de test de regresión ayuda a construir la confianza del usuario y a confiar en PostgreSQL y las facilidades de desrrollo rápido de PostgreSQL en sistema de producción.

El paquete de test de regresión puede ser considerado un documento técnico "MUY SÓLIDO" mútuamente mejorado entre los desarrodores y los usuarios finales. Los desarrolladores de PostgreSQL lo utilizan extensamente durante el periodo de desarrollo y antes de liberar el software al público para asegurar una buena calidad.

Las capacidades de PostgreSQL se reflejan directamente en el paquete de test de regresión. Si una funcionalidad, sintaxis o característica existe en el paquete de regresión, entonces está soportada, mientras que todas las demás que NO aparecen reflejadas ¡PUEDEN NO ESTAR soportadas por PostgreSQL! Usted puede necesitar verificarlos y añadirlos al paquete.

8. Herramientas gráficas de cliente para PostgreSQL (GUI, Interface gráfico de usuario)

El navegador Web será el Interface Gráfico de Usuario (GUI en inglés) más popular en el futuro. La mayor parte del código debería ser escrito en lenguaje de escritura (scripting) (y compilación para servidor Web PHP/Zend PHP con pequeñas cantidades de JavaScript en la parte cliente. Se recomienda migrar las aplicaciones heredadas en Windows 95/NT a PHP/Zend.

Las mejores herramientas son:

Los lenguajes a elegir en orden de preferencia son:

  1. Scripts del servidor Web en PHP con scripts en Javascript para el cliente.

  2. Lenguaje de fabricación de scripts Perl utilizando Perl-Qt o Perl-Tk Perl Database Interface

  3. El Omnipresente y Omnipotente lenguaje C++:

  4. Java, pero sus programas son muy lentos.

Hay otras herramientas utilizables: PostgreSQL tiene librerias de interface Tcl/Tk en la distribución llamadas 'pgTcl'. Hay un entorno de desarrollo integrado (IDE) para Tcl/Tk llamado SpecTcl.

También puede usar Borland C++ Builder, Delphi, Borland JBuilder, PowerBuilder en Windows95 conectando a bases PostgreSQL en ordenadores UNIX a través de drivers ODBC/JDBC.

9. Drivers de Interface para PostgreSQL

9.1 Drivers de Interface ODBC para PostgreSQL

ODBC significa 'Open DataBase Connectivity' (Conectividad Abierta a Bases de Datos). Es un estandar muy popular para el acceso a la información de varias bases de datos de diferentes vendedores. Las aplicaciones escritas utilizando los drivers ODBC garantizan trabajar contra varias bases de datos como PostgreSQL, Oracle, Sybase, Informix, etc.

Hay un proyecto llamado FreeODBC Pack Package (paquete gratuito de ODBC). No hay una versión para PostgreSQL, quizá pueda usted ayudar.

9.2 Drivers UDBC para PostgreSQL

UDBC es una versión estática de ODBC independiente de manejadores de drivers y soporte DLL, usada para soportar conectividad a las bases de datos, embebida directamente en las aplicaciones.

9.3 Drivers JDBC para PostgreSQL

JDBC significa 'Java DataBase Connectivity' (Conectividad a bases de datos en Java). Java es un lenguaje de programación independiente de la plataforma desarrollado por Sun Microsystems. Los programadores en Java prefieren escribir las aplicaciones de base de datos utilizando el JDBC para facilitar la portabilidad entre bases de datos como PostgreSQL, Oracle, Informix, etc. Si usted escribe aplicaciones en Java, puede tomar los drivers JDBC para PostgreSQL desde las direcciones:

El driver JDBC está ya incluido en la distribución de PostgreSQL.

La dirección principal de JDBC, la guía y la FAQ se encuentran en -

9.4 Java para PostgreSQL

Los programadores en Java pueden encontrar estas direcciones para PostgreSQL muy utilizables.

10. El Driver de Interface de Base de datos Perl (DBI) para PostgreSQL

10.1 El interface Perl 5 para PostgreSQL

PERL es un acrónimo de 'Practical Extraction and Report Language' (Lenguaje práctico de extracción e informe). Perl se puede utilizar en todos y cada uno de los sistemas operativos y plataformas hardware del mundo. Usted puede usar Perl en Windows95/NT, iMac de Apple Macintosh, todas las variantes de Unix (Solaris, HPUX, AIX, Linux, SCO, etc) ordenadores centrales MVS, ordenadores de sobremesa OS/2, OS/400, Amdahl UTS y muchos otros. ¡Perl corre INCLUSO en muchos sistemas operativos y plataformas hardware poco populares o generalmente desconocidos! De modo que no se sorprenda si encuentra Perl corriendo en un sistema operativo muy ráramente usado. Puede usted imaginar la vasta extensión de la base de usuarios y desarrolladores de Perl.

La interface Perl para PostgreSQL está incluida en la distribución de PostgreSQL. Compruebelo en el directorio src/pgsql_perl5

10.2 El Interface para Bases de Datos de Perl DBI

¿QUÉ ES DBI ?

El Interface de Bases de Datos en Perl (DBI, Database Interface) es un Interface de Programación de Aplicaciones (API) para el lenguaje Perl. Las especificaciones del API DBI para Perl definen un juego de funciones, variables y convenciones que proporcionan un interface de base de datos consistente e independiente de la base de datos que se esté usando en ese momento. La información para esta sección DBI se ha obtenido del documento 'DBI FAQ' cuyo autor es Alligato Descartes, y lo reproducimos aquí con su permiso.

Driver DBI para PostgreSQL DBD-Pg-0.89

Consiga DBD-Pg-0.89.tar.gz en uno de los siguientes:

REQUERIMIENTOS:

Soporte técnico para DBI

Envíe por favor comentarios y avisos de error a

incluyendo por favor la salida de perl -v, y perl -V, la versión de PostgreSQL, la versión de DBD-Pg, y la versión de DBI en su aviso de error.

¿Qué son DBI, DBperl, Oraperl y *perl?

Tomado de Tim Bunce, el arquitecto y autor de DBI:

``"DBI es un Interface de Programación de Aplicaciones de Acceso a Bases de Dados (API) para el lenguaje Perl. La especificación del API DBI define un juego de funciones, variable y convenciones que proporcionan un interface de base de datos consistente e independiente de la base de datos que se esté utilizando"

En un lenguaje sencillo, la interface DBI permite a los usuarios acceder a múltiples tipos de bases de datos de modo transparente. Por ello, si usted está conectando a una Oracle, Informix, mSQL, Sybase, o cualquier otra base de datos, no necesita conocer los mecanismos subyacentes de lenguaje 3GL. La API definida por DBI trabajara en todos estos tipos de datos.

Un beneficio similar se consigue por la capacidad de conectar a dos bases de datos diferentes de vendedores diferentes con un único script en perl, es decir, yo quiero leer datos de una base Oracle e insertarlos en una Informix, y todo en un único programa. La capa DBI le permite hacer esto de una forma simple y poderosa.

DBperl es el nombre anterior para la especificación del interfe. Habitualmente, se utiliza ahora para referirse a los módulos perl4 para acceso a bases de datos, tales como oraperl, isqlperl, ingperl y demás. Estos interfaces no tienen una API estandar y generalmente no están soportados.

Aquí tiene una lista de módulos DBperl, sus correspondientes contrapartidas DBI, e información de soporte. Las preguntas sobre drivers DBI deberían dirigirse a las listas de correo de usuarios de DBI.

    Módulo      Base de datos       Autor                   DBI
    ----------- -----------------   ------                  ---
    Sybperl     Sybase              Michael Peppler         DBD::Sybase
                                    <mpeppler@datamig.com>
                                    http://www.mbay.net/~mpeppler
    Oraperl     Oracle 6 & 7        Kevin Stock             DBD::Oracle
                                    <dbi-users@fugue.com>
    Ingperl     Ingres              Tim Bunce &             DBD::Ingres
                                    Ted Lemon
                                    <dbi-users@fugue.com>
    Interperl   Interbase           Buzz Moschetti          DBD::Interbase
                                    <buzz@bear.com>
    Uniperl     Unify 5.0           Rick Wargo              None
                                    <rickers@coe.drexel.edu>
    Pgperl      Postgres            Igor Metz               DBD::Pg
                                    <metz@iam.unibe.ch>
    Btreeperl   NDBM                John Conover            SDBM?
                                    <john@johncon.com>
    Ctreeperl   C-Tree              John Conover            None
                                    <john@johncon.com>
    Cisamperl   Informix C-ISAM     Mathias Koerber         None
                                    <mathias@unicorn.swi.com.sg>
    Duaperl     X.500 Directory     Eric Douglas            None
                User Agent

Sin embargo, algunos módulos DBI tienen capas de emulación de DBperl, así, DBD::Oracle viene con una capa de emulación Oraperl, que le permite correr scripts oraperl heredados sin modificaciones. La capa de emulación traduce las llamadas del API oraperl a llamadas de DBI y las ejecuta a través del enlace DBI.

Aquí hay una tabla de información sobre las capas de emulación:

    Módulo          Capa de Emulación   Situación
    ------          -----------------   ---------
    DBD::Oracle     Oraperl             Completa
    DBD::Informix   Isqlperl            En desarrollo.
    DBD::Sybase     Sybperl             ¿Trabajando?(Necesita verificación)
    DBD::mSQL       Msqlperl            Liberado experimentalmente con
                                        DBD::mSQL-0.61

La emulación Msqlperl es un caso especial. Msqlperl es un driver en perl5 para bases de datos mSQL, pero no se ajusta a la especificación DBI. Su uso está siendo abandonado en favor de DBD::MSQL. Se puede descargar Msqlperl desde CPAN a travé de:

Especificaciones DBI

Hay algunas fuentes de información sobre DBI:

Hay dos especificiaciones utilizables en este enlace, la nueva especificación DBI Draft, que es un documento en rápida evolución que el equipo de desarrollo dirige hacia una interface estable, y la histórica Especificación DBperl, desde la que ha evolucionado la actual interface DBI.

El documento anterior debería se visto solo por su interés histórico, y no debería servir como un manual de programación, ni documentación autorizada en ningún sentido. Sin embargo, sigue siendo muy utilizable como fuente de referencias.

Documentación POD (N. del T.: ¿Piece of Documentation?). Los PODs son trozos de documentación habitualmente embebidos en los programas en perl, que documentan el código "en el sitio", proporcionando un recurso utilizable por los programadores y usuarios de los módulos. Los POD para DBI y los driver están empezando a volverse lugares comunes, y la documentación para estos módulos puede leerse con los siguientes comandos:

El POD para la especificación DBI se puede leer con el comando

perldoc DBI

Los usuarios de Oraperl y la capa de emulación Oraperl incluída en DBD::Oracle, pueden leer sobre como programar con la interface Oraperl tecleando:

perldoc Oraperl

Esto producirá una copia actualizada de la página man sobre oraperl original, escrita por Kevin Stock para perl4. La API oraperl está listada y descrita completamente ahí.

Los usuarios del módulo DBD::mSQL pueden leer sobre algunas de las funciones privadas y las peculiaridades de ese driver tecleando:

perldoc DBD::mSQL

Las Preguntas más Frecuentemente Respondidas (FAQ) están utilizables como documentación POD. Léalas tecleando:

perldoc DBI::FAQ

Esta alternativa puede ser más conveniente para personas que no están permanentemente, o adecuadamente, conectadas a internet.

Los POD sobre información general para escribir POD, y la filosofía de los POD en general, se puede leer tecleando:

perldoc perlpod

Los usuarios con el módulo Tk instalado pueden estar interesados en un lecto de POD basado en Tk, llamado tkpod, que formatea los POD en una forma conveniente y legíble.

Hay una serie de aproximaciones ocasionales de varias personas en las listas de correo de DBI.

"DBI -- El Interface de bases de datos en perl5" es un articulo escrito por Alligator Descartes y Tim Bunce sobre la estructura de DBI. Se publico en el fascículo 5 de "The Perl Journal". Es extremandamente bueno. Compre la revista. De hecho, cómprelos todos. La página Web de "The Perl Journal" está en:

``"DBperl" Este artículo publicado en la edición de Noviembre de 1.996 de "Dr. Dobbs Journal" se refiere al DBperl.

"The Perl5 Database Interface": Es un libro escrito por Alligator Descartes y publicado por O'Reilly y asociados.

Hay tres listas de correo sobre la ejecución de DBI de Ted Lemon. Se pueden subscribir y desubscribir a través de la WWW en

Las listas en las que pueden participar los usuarios son:

dbi-announce Esta lista de correo es sólo para anuncios. Si usted no puede utilizar adecuadamente el formato de la página www correspondiente, suscribase enviando un correo-e a la dirección:

dbi-dev Esta lista de correo está dedicada al uso de desarrolladores dicutiendo sobre ideas y conceptos sobre la mecánica de drivers, interface DBI y API. Utilizar sólo para desarrolladores o personas interesadas. Si usted no puede utilizar adecuadamente el formulario de la página www anterior, subscríbase enviando un correo-e a la dirección:

dbi-users Esta lista de correo es una lista de propósito general, utilizada para notificar errores, discutir problemas y preguntas de tipo general. Si usted no puede utilizar adecuadamente la página www anterior, subscríbase enviando un correo-e a la dirección:

Archivos de listas de correo:

Problemas de compilación o "It fails the test"

Si se le produce un volcado de memoria (core dump), intente con el módulo Devel::CoreStack para generar un rastro de la pila a partir del volcado de memoria. Puede encontrar Devel::CoreStack en CPAN, en:

Envíe a las listas de correo dbi-users es rastro de la pila, las versiones de los módulos, la versión de perl, el juego de pruebas, versiones de sistema operativo y cualquier otra información que considere pertinente. Cuanta más información envíe, más rápido podrán resolver su problema los desarrolladores. Si no nos envía nada, no espere nada.

¿Se soporta DBI bajo plataformas Windows 95 / NT?

Las migraciones de DBI y DBD:Oracle para Windows de 32 bits son ahora una parte estandar del DBI, de modo que descargando una versión de DBI superior a la 0.81, debería trabajar adecuadamente. Podrá usted acceder a las bases Microsoft Access y SQL-Server desde DBI a través de ODBC. Con las versiones de DBI 0.79 y posteriors una 'capa de emulación' experimental para el módulo Win32::ODBC. Se llama DBI::W32ODBC. Necesitará el módulo Win32::ODBC.

¿Qué es DBM? ¿Y porqué utilizar entonces DBI?

UNIX fué dotado originariamente con unas "bases de datos" sencillas basadas en ficheros, llamadas "el sistema dbm". Dbm le permitía almacenar datos en ficheros, y recuperarlos rápidamente. Sin embargo, también tenían serios problemas.

Bloqueo de ficheros.

Los sistemas dbm no permitían capacidades de bloqueo de ficheros particularmente robustas, ni niguna capacidad de corregir problemas surgidos de escrituras simultáneas [en la base de datos].

Estructuras de datos arbitrarios.

Los sistemas dbm solo permitían una estructura de datos fija: los pares clave-valor. Ese valor podría ser un objeto complejo, tal como una estructura [C], pero la clave debía ser única. Esto era una gran limitación sobre la utilidad de los sistemas dbm.

Sin embargo, los sistemas dbm también proporcionaban una función utilizable por los usuarios con juegos de datos sencillos y recursos ilimitados, puesto que era rápida, robusta y extremadamente bien comprobada. Los módulos perl para acceder a sistemas dbm han sido integrados ahora en el núcleo de la distribución de Perl, a través del módulo AnyDBM_File.

Además to todo esto, DBM es una solución perfectamente satisfactoria para bases de datos esencialmente de sólo lectura, o juegos de datos pequeños y sencillos. Sin embargo, para juegos de datos más potentes y escalables, no se puede mencionar bloqueos transaccionales robustos, a los usuarios se les recomienda usar DBI.

¿Está soportada por DBI <ponga_aquí_su_característica>?

Dado que hacemos el supuesto de que la característica por la que está usted preguntando una característica no estandar de una base de datos específica, la respuesta será que no.

DBI refleja una API genérica que trabajará para la mayoría de las bases de datos, y no tiene funcionalidades específicas de una base de datos.

Sin embargo, los autores de los drivers pueden, si lo desean, incluir enlaces a funcionalidades específicas de una base de datos a través de los métodos de funciones definidas en la API DBI. Los desarrolladores de scripts deberían tener en cuenta que el uso de funcionalidades proporcionadas a través de los métodos de funciones no son deseables si se desea portabilidad a distintas bases de datos.

¿Se puede programar DGI usando DBI?

En una palabra, ¡si! ¡DBI es completamente utilizable para programar CGI! De hecho, la programación de CGI es uno de los dos usos mayores de DBI.

DBI confiere a los programadores de CGI la capacidad de ofrecer a sus usuarios bases de datos accedidas por WWW, lo que aporta a los usuarios vastas cantidades de datos ordenados para manejarlos. DBI también proporciona la posibilidad de que, si en un lugar se está recibiendo demasiado tráfico, entonces sus servidores de bases de datos pueden hacerle frente, pueden actualizar el servidor de base de datos desacoplando las escenas sin alteraciones de los scripts de CGI.

¿Cómo puedo acelerar la conexión con DBD Oracle y CGI?

El servidor de http Apache mantiene un conjunto de demonios http hijos (httpd) para servir los requerimientos de los clientes. Utilizando el módulo mod_perl de Apache, de Doug MacEachern, el interprete de perl está embebido en el hijo httpd. El CGI, DBI y sus otros módulos favoritos pueden ser cargados en el arranque de cada hijo. Estos módulos no resran recargados a menos que se cambien en el disco. Para más información sobre Apache, vea el sitio Web del proyecto Apache:

¿Cómo puedo hacer conexiones persistentes con DBI y CGI?

Utilizando el módulo Apache::DBI de Edmund Mergl, el login a la base de datos se almacena en un todo con cada uno de estos hijos httpd. Si su aplicación está basada en un único usuario de base de datos, esta conexión puede arrancarse para cada hijo. Actualmente, no se pueden compartir conexiones a base de datos entre hijos httpd. Se puede descargar Apache::DBI desde CPAN a través de:

"¡Cuando ejecuto un script perl desde la línea de comandos, funciona, pero cuando lo ejecuto bajo httpd, falla!" ¿Porqué?

Básicamente, una buena posibilidad de que esto ocurra se debe al hecho de que el usuario con el que usted ejecutó la línea de comando tiene bien configurado el juego de variables de entorno, en el caso de DBD::Oracle, variables como $ORACLE_HOME, $ORACLE_SID, o TWO_TASK. El proceso httpd usualmente corre bajo el usuario nobody, lo que implica que no hay entorno configurado. Cualquier script que se intente ejecutar en esta situación fallará. Para resolver este problema, coloque el entorno de su base de datos en un bloque BEGIN ( ) al principio de su script. Esto resolverá el problema. Similarmente, debería usted chequear su fichero de errores de httpd para todas las indicaciones, así como la "Guía de Idiotas para Resolver Problemas en Perl / CGI", y la "FAQ programando Perl y CGI" para posterior información. Es improbable que esto sea un problema relacionado con DBI. ¡Lea AMBOS documentos cuidadosamente!

¿Cómo puedo programar en multi-hebra con DBI?

En este momento, no puede. Perl no soporta multi-hebras. Sin embargo, el soporte para multi-hebras se espera que forme parte de la distribución del núcleo de perl con la versión 5.005, lo que implica que DBI pueda soportar multi-hebrado muy poco tiempo después. Para ver algunos ejemplo de codigo OCI con instrucciones SELECT con multi-hebrado para Oracle, vea:

¿Cómo puedo invocar procedimientos almacenados con DBI?

Asumiendo que ha creado usted un procedimiento almacenado dentro de la base de datos, por ejemplo una base de datos Oracle, puede utilizar $dbh->do para ejecutar inmediatamente el procedimiento. Por ejemplo,

$dbh->do( "BEGIN mi_procedimiento END" );

¿Cómo puedo recoger valores devueltos pro procedimientos almacenados con DBI?

¡Recuerde realizar la comprobación de errores!

    $sth = $dbh->prepare( "BEGIN foo(:1, :2, :3); END;" );
    $sth->bind_param(1, $a);
    $sth->bind_param_inout(2, \$path, 2000);
    $sth->bind_param_inout(3, \$success, 2000);
    $sth->execute;

¿Cómo puedo crear o borrar una base de datos con DBI?

La creación y borrado son conceptos que están enteramente abstractos para ser adecuadamente soportados por DBI. Por ejemplo, Oracle no soporta el concepto de borrado de una base de datos por completo. Además, en Oracle, el servidor de base de datos es esencialmente la misma base de datos, mientras que en mSQL, el proceso servidor de base de datos funciona adecuadamente sin tener ninguna base de datos creada. El problema es demasiado dispar para atacarlo. Algunos drivers, sin embargo soportan la creación y el borrado a través de los métodos de funciones privadas. Debería usted chequear la documentación para los drivers que está usted utilizando para ver si soportan este mecanismo.

¿Cómo manipula los valores NULL DBI?

Los valores NULL están especificados en DBI como valores indefinidos. Se pueden insertar valores nulos en las bases de datos como NULL. Por ejemplo:

    $rv = $dbh->do( "INSERT INTO table VALUES( NULL )" );

pero cuando se recupera el valor, los nulos se deberían comprobar como undef. Este es un estandar en todos los drivers.

¿Qué son estos métodos de funciones tan mencionados?

Los método de funciones (func method) se define en DBI como un punto de entrada para funcionalidades específicas de la base de datos, por ejemplo, la capacidad de crear y borrar bases de datos. Invocar estos métodos específicos del driver es sencillo, por ejemplo, para invocar un método createDatabase que tiene un argumento, escribiríamos:

    $rv = $dbh->func( 'argumento', 'createDatabase' );

Los desarrolladores de software deberían tener en cuenta que estos métodos de función no son portables entre bases de datos.

Soporte comercial y formación.

El interface de base de datos Perl5 es software LIBRE. VIENE SIN GARANTÍA DE NINGÚN TIPO. Sin embargo, algunas organizaciones están proporcionando bien soporte técnico, bien programas de formación en DBI.

PERL CLINIC : The Perl Clinic puede organizar contratos de soporte comercial para Perl, DBI, DBD::Oracle y Oraperl. El soporte se proporciona a través de la compañía en la que trabaja Tim Bunce, autor de DBI. Para más información sobre sus servicios, visite por favor:

11. Herramientas de Gestión de PostgreSQL

11.1 PGACCESS - Una herramienta gráfica de usuario para la gestión de PostgreSQL

PgAccess es un interface Tcl/Tk para PostgreSQL. Está incluido en la distribución de PostgreSQL. Para adquirir una copia más reciente, compruebe en este sitio Web:

Características de PgAccess

PgAccess para windows: ventana completa, constructor de tablas, visor de tablas (query), constructor de tablas visual.

Tablas:

Consulta:

Secuenciadores.

Las implentaciones futuras tendrán:

Si tiene usted cualquier comentario o sugerencia para potenciar la herramienta, envíe un correo-e a:

Información sobre libgtcl:

Necesitará usted la librería de interface de PostgreSQL a Tcl libpgtcl, colocada en línea como un módulo cargable en Tcl/Tk. La librería libpgtcl y la fuente está localizada en el directorio /src/interfaces/libpgtcl del PostgreSQL. Específicamente, necesitará una librería libpgtcl que sea cargable desde Tcl/Tk. Esto es tecnicamente diferente de un fichero objeto cargable de PostgreSQL ordinario, porque libpgtcl es una colección de ficheros objeto. Bajo Linux, esto se llama libpgtcl.so. Puede usted descargar desde la dirección anterior una versión ya compilada para sistemas Linux i386. Simplemente copie el fichero libpgtcl.so en el directorio de librerías de su sistema (/usr/lib). Una de las solucioens es eliminar del fichero fuente la linea que contiene la carga de libpgtcl.so y cargar pgaccess.tcl, con no wish, sino con pgwish (o con wishpg) que es el wish que está listado con la librería libpgtcl.

11.2 Herramienta de consulta interactiva bajo Windows para PostgreSQL (WISQL or MPSQL)

MPSQL proporciona a los usuarios un interface gráfica SQL para PostgreSQL. MPSQL es similar a la hoja de cálculo para SQL de Oracle y a la herramienta de consultas de Microsoft SQL Server WISQL. Es una Interface Gráfica de Usuario (GUI en inglés) sencilla y tiene historia de comandos. Permite también cortar y pegar, y tiene otras características agradables para incrementar la productividad.

11.3 Herramienta de consulta interactiva (ISQL) para PostgreSQL llamada PSQL

ISQL es para terminales de línea de comando de formato carácter. Está incluido en la distribución, y se le llama con PSQL. Es muy similar al ISQL de Sybase o al SQL*Plus de Oracle. De en promp de Unix el comando psql, lo que le devolverá un promp psql>

Teclee \h para ver ayuda sobre los comandos.

Es muy amigable y facil de utilizar. Puede utilizarse desde scripts de la shell.

11.4 MPMGR - Una herramienta de gestión de la base de datos para PostgresSQL

MPMGR le proporcionará un interface gráfico de gestión para PostgreSQL. La puede encontrar en

12. Gestionando multiples ordenadores con bases de datos PostgreSQL con un único monitor

Usted puede amontonar los ordenadores y conectarlos con un único monitor, y utilizar un KVM (Keyboard, Video, Monitor), un selector que le permite elegir el ordenador contra el que están trabajando estos tres elementos. Esto reduce espacio, y elimina monitor, teclado y ratón (ahorrándole entre 100 y 500 dólares por juego), e impedir un montón de desorden.

Utilizando estos selectores, puede usted apilar varios servidores PostgreSQL (de desarrollo, de pruebas, de producción), servidores Web, servidores ftp, servidores Intranet, servidores de correo, de news (más amplio que el castellano noticias) en una misma torre. El selector puede utilizarse también para controlar ordenadores Windows 95/NT o OS/2.

Compruebe por favor estas direcciones:

También puede utilizar su buscador web favorito, como yahoo por ejemplo, para encontrar más compañías con "Server Switches" o "KVM Switches".

Se recomienda encarecidamente tener un ordenador unix dedicado a cada servidor de datos PostgreSQL para obtener mejores rendimientos. Ningún otro proceso/programa de aplicación debería correr en este ordenador. Vea la sección de negocios de su periódico local para buscar vendedores locales que vendad ordenadores sólo intel, con monitores monocromos de 13" (de muy bajo coste). Los vendedores locales le venderán sólo el hardware, sin Microsoft Windows/DOS (lo que le ahorrará unos 150 $ por ordenador). No necesita usted un monitor en color para el servidor de base de datos, ya que puede usted administrarlo remontamente con PC en color. Adquiera los cdrom para Linux de RedHat (o de cualquier otra distribución) desde

Asegúrese de que el hardware que compra esté sorportado por Linux. Chequee el servidor de ftp de RedHat para comprobar el hardware recomendado, como adaptadores SCSI o tarjetas de video, antes de comprar. Por apenas 600 $ puede adquirir un potente ordenador intel con Linux de RedHat corriendo PostgreSQL. Utilice odbc/jdbc/perl/tcl para conectarse a PostgreSQL desde Windows95, OS/2, Motif para Unix o un navegador de internet (como Redbaron, Opera, Netscape y otros 20). (Los navegadores se están convirtiendo muy rápidamente en el cliente estandar).

¡Utilizando esta idea, puede usted controlar muchos ordenadores con un sólo monitor y un sólo teclado.!

Lo anterior está extraido de networktechnic Inc para los "Server Switches"

Cómprelos ahora llamando al 800-742-8324 (llamada gratis en USA)

Para recibir nuestro catalogo, envíenos un correo-e a la dirección: sales@networktechinc.com

CONTROLE MULTIPLES PC's con un único teclado, monitor y ratón. Estos selectores electrónicos le permitirán controlar con un teclado, monitor y ratón hasta 64 PC,s. Los microordenadores incluidos simulan la presencia de teclado, monitor y ratón para todos los PC's enchufados el 100 % del tiempo.

Características y aplicaciones

Especificaciones del teclado

Controles - botones en el frente.

Ratón

* 9 pin D serial

* 6 pin miniDIN

Cableado remoto

Monitor-VGA


Siguiente Anterior Contenido

13. Aplicaciones y herramientas para PostgreSQL

13.1 Lenguaje 4GL para aplicaciones de base de datos para el Web paraPostgreSQL - El sistema de desarrollo AppGEN

AppGEN se puede descargar de

AppGEN es un lenguaje de cuarta generación de alto nivel y un generador de aplicaciones para producir aplicaciones basadas en la World Wide Web (WWW). Estas aplicaciones se utilizan típicamente sobre internet o en una intranet corporativa. Las aplicaciones de AppGEN se implementan típicamente como programas en C que se ajustan al standard Common Gateway Interface (CGI) que soportan la mayoría de los servidores Web. Para usar AppGEN, necesitará usted lo siguiente :- PostgreSQL, systema de gestión de bases de datos relacional.

Un servidor web compatible con CGI como el HTTPD de NCSA.

Un compilador ANSI-C como GCC.

AppGEN consiste en los siguientes ejecutables Unix (Linux) :-

Se puede contactar al autor, Andrew Whaley, en

13.2 Interface WWW para PostgreSQL - DBENGINE

dbengine es un interface Web plug & play para PostgreSQL creado por Ingo Ciechowski. Lo encontrarán en

Sobre DBENGINE : dbengine es un interface entre la WWW y Postgres95 que proporciona acceso sencillo a una base de datos existente en pocos minutos.

PHP le da un lenguaje similar al Perl en sus documentos, pero al no ser autentico Perl, contra AppGen con wdb-p95, requiere que usted cree algunos ficheros de configuración para cada una de sus bases de datos, lo que suena como que usted primero tendrá que leer algo sobre nuevos metalenguajes antes de empezar.

Al contrario de otra herramientas, usted no necesitará aprender ningun lenguaje de programación o scripting para arrancar con dbengine. Tampoco hay ficheros de configuración para cada base de datos, de modo que no debe familiarizarse con ninguna nueva estructura.

Sin embargo, en el caso de que usted quiera adquirir las capacidades completas de dbengine, será una buena idea que conociera el lenguaje Perl.

El sistema completo puede configurarse por sencillas manipulacioens de una base de datos adicional que contiene información más cerrada sobre como visualizar su acceso a las bases de datos. Puede usted incluso especificar campos virtuales que serán calculados sobre la marcha antes de ser mostrados en la pantalla.

13.3 El módulo del Servidor Web Apache para PostgreSQL - NeoSoft NeoWebScript

Apache es un Servidor Web bien conocido. Y un módulo para interface con PostgreSQL desde el Webserver Apache se puede encontrar en -

NeoWebScript es un lenguaje de programación que permite a los programas tanto sencillos como complejos ser embebidos en ficheros HTML.

Cuando una página HTML que contiene NeoWebScript es requerida, el webserver con capacidad para NeoWebScript ejecuta el/los Scripts embebidos, produciendo una página web que contiene información personalizada creada por el programa.

NeoWebScript es una forma rápida, segura y facil de aprender de hacer programas interactivos y poderosos basados en el servidor directamente en código HTML en páginas web. Con NeoWebScript, los contadores, formularios de email, pinturas murales, libros de honor y de visitas, son sencillos, incluso para un programador novato. Vea lo bien que trabaja NeoWebScript contra Perl y JavaScript.

Si quiere usted instalar NeoWebScript en su servidor web, su administrador necesitará leer nuestro FAQ Sysop para arrancarlo. La Teoría de Operaciones le explicará como trabaja NeoWebScript, mientras la instalación le guiará a través de los pasos necesarios. El mantenimiento se entrelaza con los pasos de configuración y ejecución en el servidor, y las pruebas le permitirán verificar el correcto funcionamiento de NeoWebScript, mientras la miscelánea le aproxima a los problemas del servidor.

No hay coste por utilizar NeoWebScript-2.2 en su ISP, su intranet o su extranet. Deberá usted pagar una licencia completa cuando se registre para descargarlo, pero cuesta 99 $ si usted quiere incluirlo en su propio producto o utilizarlo en un servidor comercial (pe SSL).

NeoWebScript es un módulo para el servidor web Apache que le permite embeber el lenguaje de programación Tcl/Tk en sus páginas web como una herramienta de script. Fué inventado por Karl Lehenbauer, Oficial Técnico Jefe de NeoSoft, y documentado, potenciado y extendido por programadores y escritores técnicos de NeoSoft.

El servidor web Apache es el más popular del mundo, asentado en el 68 %de los servidores.

Tcl/tk es un lenguaje de script poderoso, libre y multiplataforma desarrollado por el Dr. John Ousterhout. En sus propias palabras

"Tcl/Tk permite a los desarrolladores de software tener el trabajo hecho diez veces más rápido que con herramientas basadas en C o C++. Es también un gran lenguaje intermediario para hacer a las aplicaciones existentes trabajar juntas y hacerlas más gráficas e Internet-capaces".

Karl Lehenbauer, Fundador y Oficial Técnico Jefe de NeoSoft, ha formado parte del desarrollo del Tcl/Tk desde muy al principio. Junto con Mark Diehkans, crearon el Tcl Extendido, también conocido como TclX o NeoSoft Tcl, un juego de extensiones muy poderoso para el lenguaje. Muchos de los comandos del núcleo actual de Tcl se originaron en el Tcl Extendido, y fueron importados al núcleo del lenguaje por el Dr. Ousterhount.

NeoSoft Inc., 1770 St. James Place, Suite 500, Houston, TX 77056 USA

13.4 HEITML: extensión para servidor del HTML y lenguaje 4GL para PostgreSQL

La herramienta heitml es otra forma de interface para postgres con la wold wide web. Para más detalles, pongase en contacto con 

          Helmut Emmelmann H.E.I. Informationssyteme GmbH 
          Wimpfenerstrasse 23 Tel. 49-621-795141 
          68259 Mannheim Germany Fax. 49-621-795161

Heitml es una extensión del lado del servidor para el HTML y un lenguaje 4GL al mismo tiempo. El público puede escribir aplicaciones web en estilo HTML utilizando nuevas etiquetas del estilo de HTML.

Heitml (se pronuncia "jai"-TML) es una extensión del HTML y un lenguaje 4GL de características completas que capacita a las aplicaciones basadas en el web a interactuar con datos almacenados en bases de datos SQL, sin recurrir a complicados scripts CGI.

Heitml extiende HTML en el lado del servidor, convirtiendo dinámicamente los ficheros ".hei" al formato HTML, y así es compatible con cualquier navegador web. Se aproxima a la familiar y facil de usar sintaxis del HTML y proporciona un gran juego de etiquetas y librerías predesarrolladas para cuidarse de las tareas que normalmente requerirían CGI. Como XML, heitml proporciona etiquetas definidas por el usuario. Con heitml, el usuario define marcas que pueden ser traducidad a HTML y enviadas a un navegador.

Heitml se dirige tanto a diseñadores como a programadores de estilo profesional. Los diseñadores de HTML pueden utilizar las etiquetas de heitml para construir dinámicamente páginas web, acceder a bases de datos SQL, o crear aplicaciones web completas. Los contadores, bases de datos de registro, formularios de búsqueda, formularios de e-mail, o menús jerarquicos pueden crearse sencillamente utilizando las etiquetas de estilo HTML predesarrolladas que se encuentran en las librerías de componentes completas.

Para los programadores, heitml incluye un lenguaje de cuarta generación completo en HTML 

          (p.e. etiquetas <if>, <while> y <let>),
además de evaluacion de expresiones poderosas con tipos de datos enteros, reales, boleanos, cadenas de caracteres (string) y registros (tuple). Los registros tienen semantica referenciada en un moderno lenguaje orientado a objetos, y se almacenan en una pila. Las variables heitml, incluyendo todas las estructuras de datos complejas almacenadas en la pila, mantienen sus valores entre páginas utilizando el modo sesión. Es posible definir sus propias etiquetas o etiquetas de ambiente e incluso redefinir etiquetas de HTML.

Heitml hace posible:

- - - desarrollar sitios web de forma modular y estructurada reduciendo drásticamente la carga de mantenimiento.

- - - desarrollar sitios web inteligentes e interactivos, con contenidos que se adaptan dinámicamente ellos mismos a las necesidades del usuario.

- - - desarrollar bases de datos complejas y aplicaciones de catálogo de ventas utilizando variables de sesion.

heitml corre en Linux con cualquier servidor web utilizando el interface CGI, y es especialmente rápido (evitando la sobre carga de CGI) con el servidor web Apache, utilizando la API Apache. Actualmente se soportan MSQL (Versión 1 y 2), PostgreSQL (Versión 6), mysql, y las bases de datos más extendidas). Heitml también trabaja en Linux, BSDi, Solaris y SunOS, así como con Windows NT con CGI e ISAPI, y ODBC y Windows 95.

Heitml (en Linux) es gratuito para investigación y uso privado y no comercial. Los sitios web comerciales deben pagan una cuota de licencia. La versión completamente operativa de heitml está disponible para un periodo de prueba descargado gratuitamente. (Note, sin embargo, que cada página web ".hei" que muestre usted incluirá un mensaje identificandolo como la versión de uso no comercial. Tras registrarse, usted recibirá una clave para eliminar el mensaje sin tener que reinstalar el programa).

Heitml (pronunciado "jai"-TML) extiende e incrementa significativamente la funcionalidad de HTML a través de etiquetas definibles y características de programación completa. Esto hace posibles las aplicaciones de base de datos y contenido dinámico, simplemente en el mundo HTML, sin CGI y sin lenguajes de programación o scripting externos. Por otro lado, como un programador o usuario avanzado, puede usted crear y programar poderosas librerías de etiquetas. Esta aproximación hace al heitml utilizable tanto para principiantes en HTML como para programadores profesionales. Heitml corre en el servidor web y genera HTML dinámicamente, de modo que heitml es compatible con los estandares de internet y con cualquier navegador web. Permite acceso completo a las bases de datos, liberando al usuario de cualquier complejidad innecesaria del CGI. heitml ha sido desarrollado de acuerdo a la investigación más reciente y en sistemas de transacción y construcción de compiladores.

Las páginas heitml se desarrollan de la misma forma que las páginas HTML, con un editor de texto o un editor HTML, y se situan en el web como es habitual. Sin embargo, las nuevas páginas pueden contener etiquetas heitml dinámicas, enviar e-mail, e incluso crear poderosas aplicaciones como bases de datos de registro o sistemas de ventas.

Tanto los recien llegados a HTML como los programadores profesionales apreciarán lo rápida y sencillamente que pueden diseñar excitantes aplicaciones interactivas como nuestro libro de honor interactivo, sin recurrir a la complejidad y dificultad de aprender scripts de CGI, simplemente utilizando las herramientas proporcionadas por nuestra librería dba.

Heitml se acompaña con un amplio juego de librerías de etiquetas, para crear libros de honor, aplicaciones de mantenimiento de bases de datos, formularios de query extensibles, poderosos formularios de e-mail o estructurar su sitio web utilizando un menú jerarquico. Estas herramientas están preparadas para funcionar, simplemente añadiendo las correspondientes etiquetas a su sitio web.

Como un programador experimentado, usted puede utilizar completamente la estructura de tupla dinámica persistente de heitml: heitml no es sólo un lenguaje de script con escritura dinámica, poder de evaluación de expresiones completo, procedimientos recursivos, y características de paso de parámetros extensivas, sino que también ofrece registros dinámicos persistentes, para mantener datos de sesión automáticamente de cualquier tamaño.

13.5 El servidor web de América On-line AOL para PostgreSQL

El servidor web comercial sin coste, AOLserver versión 2.3 soporta conexiones a bases de datos PostgreSQL 6.2.1 y superiores. Para más información, vea

13.6 Herramienta de rastreo de problemas en el Sistema de Información

(N. del T. Le he cambiado el nombre completamente en función de lo que aparece en la página indicada, que por cierto también ha cambiado sobre el original).

Está en

13.7 Convertir ficheros dbf de dbase a PostgreSQL

El programa dbf2msql trabaja bien con mSQL y PostgreSQL. Lo puede usted encontrar en:

Este programa fue escrito por Maarten Boekhold, Faculty of Electrical Engineering TU Delft, NL Computer Architecture and Digital Technique section

También puede utilizar un método python para leer los ficheros dbf y cargarlos en una base de datos postgres.

14. Herramienta de Diseño/Implementación de Bases de Datos para la web para PostgreSQL - EARP

14.1 ¿ Qué es EARP ?

El "Programa de Respuesta Fácilmente Ajustable" ("Easily Adjustable Response Program" (EARP)) ha sido creado por David Dougherty. EARP es una Herramienta de Diseño/Implementación de Bases de Datos para la web, creada sobre sistema de bases de datos PostgreSQL. Su funcionalidad incluye:

14.2 Implementación

La principal implementación de EARP es un binario CGI que ejecuta el demonio http para proporcionar acceso al servidor de Bases de Datos. Todas las herramientas de diseño están contenidas en el controlador, y todo el diseño tiene lugar en la web. Las herramientas requieren un navegador gráfico; la compatibilidad de los objetos diseñados con las herramientas es independiente de la implementación, basada en preferencias de diseño individuales.

14.3 ¿ Cómo funciona ?

Una de las principales características de EARP es que utiliza una aproximación Orientada a Objetos para producir páginas html que interactúan con la base de datos. La mayoría de las páginas consisten en varios objetos. Cada objeto es producido por algún tipo de herramienta y posee un nombre. Los objetos son vinculados en una secuencia que puede ser llamada por la herramienta de página. Los objetos son también reusables en múltiples páginas. Existen herramientas básicas para HTML, Consultas, para tomar información de formularios, Formato Extensible de Consultas y Objetos de Entrada, y Vinculación de varios objetos dentro de otro objeto. Otras herramientas más avanzadas incluyen la de correo y la herramienta de consulta multihilos.

Otra característica de EARP es la seguridad avanzada. El acceso a varias áreas del sistema EARP pueden ser limitadas en una variedad de formas. Para facilitar su seguridad avanzada, EARP realiza comprobaciones con cada conexión al sistema, determinando a qué ids y grupos pertenece el agente de conexión. El acceso a las áreas esta definido de forma separada, y la combinación de ellas decide si se permite el acceso a un área específica de EARP. Aún más, todo lo que se requiere para implementar las características de seguridad es un servidor http que soporte autenticación de usuario básica (o mejor)

14.4 ¿ Dónde consigo EARP ?

EARP está disponible vía ftp anónimo en

15. El Preprocesador de Hypertexto PHP - Lenguaje de Fabricaciónde Scripts Embebido en el Html del Lado del Servidor para PostgreSQL

WWW La Herramienta de Interface está en -

PHP tiene también un compilador llamado Zend que incrementará ampliamente el rendimiento. Primero escribirá usted la aplicación en el lenguaje de script PHP durante la fase de desarrollo, prueba y debug. Una vez que el proyecto está listo para el despliegue, utilizará usted el compilador Zend para compilar el fichero y crear un ejecutable que correrá muy rápido.

El nombre anterior era Professional Home Pages (PHP) y ahora es PHP Hypertext Pre-Processor

PHP es un lenguaje de script embebido en el html para el lado del servidor. El le permitirá escribir pequeños scripts en sus ficheros .HTML de modo muy similar a como lo hace JavaScript, excepto que, contra lo que ocurre con JavaScript, PHP no depende del navegador. JavaScript es un lenguaje embebido en el html del lado del cliente mientras que PHP se ejecuta en el lado del servidor. PHP es similar en concepto al producto LiveWire Pro de Netscape. Si le gusta el software libre en rápido movimiento que viene con el código fuente completo, probablemente le guste PHP.

15.1 Características Principales

15.2 PHP - Una Breve Historia

PHP empezó a vivir como un simple creador de cgi escrito en Perl. El nombre de este primer paquete era Personal Home Page Tools, que más tarde se cambió en Personal Home Page Construction Kit.

Se escribó una herramienta para facilitar incluir queries de SQL en páginas web. Era básicamente otro creador de CGI que tradicía queries de SQL y facilitaba crear formularios y tablas basadas en estas queries. Esta herramienta se llamó FI (Form Interpreter).

PHP/FI version 2.0 es una reescritura completa de los dos paquetes combinados en único programa. Este evolucionó en un único lenguaje de programación embebido dentro de ficheros HTML. PHP elimina la necesidad de disponer de numerosos pequeños programas cgi en Perl permitiendole situar sencillos scripts directamente en sus ficheros HTML. Esto incrementa la velocidad de ejecución de sus páginas web, una vez que la sobrecarga de lanzar Perl muchas veces se ha eliminado. Esto también hace más facil manejar grandes sitios web, al situar todos los componentes de una página web en un único fichero html. Incluyendo soporte para varias bases de datos, también hace trivial desarrollar páginas web potenciadas con acceso a base de datos. Mucha gente encuentra la naturaleza embebida mucho más facil gestionar que intentar crear ficheros HTML y CGI separados.

Ahora, PHP/FI se ha renombrado como PHP.

15.3 ¿Pero, qué puedo hacer con PHP?

La primera idea que le puede dar noticia de si usted está corriendo una página a través de PHP es que le añade un pie con información sobre el número de veces que la página ha sido accedida (si usted ha cumplido un acceso registrandose en el binario). Esto es una parte muy pequeña de lo que PHP puede hacer por usted. Sirve para otro papel muy importante como interprete de formularios cgi, por la parte FI de su antíguo nombre. Por ejemplo, si usted crea un formulario en una de sus páginas web, usted necesitará algo para procesar la información de ese formulario. Incluso si usted sólo quiere pasar la información a tora página web, deberá tener un programa en cgi que haga esto por usted. PHP hace extremadamente facil tomar datos de formularios y hacer algo con ellos.

15.4 Un ejemplo sencillo

Suponga que tenemos un formulario: 

 <FORM ACTION="/cgi-bin/php.cgi/~userid/display.html"
METHOD=POST> <INPUT TYPE="text" name="name"> <INPUT TYPE="text"
name="age"> <INPUT TYPE="submit"> <FORM>

Su fichero display.html debería entonces contener algo como: 

 < ?echo "Hi $ name, you are $ age
years old!<p>" >

¡Es así de simple! PHP crea automáticamente una variable para cada campo de entrada en su formulario. Usted puede utilizar estas variables en el fichero ACTION URL.

El siguiente paso una vez ha creado usted la figura de como usar variables es empezar la ejecución con algunas etiquetas de flujo lógico en sus páginas. Por ejemplo, si usted quiere mostrar mensajes diferentes basados en algo que el usuario introduce, debería usted utilizar la lógica if/else. En nuestro ejemplo anterior, podremos mostrar diferentes mensajes basados en la edad que el usuario entró cambiando nuestro display.html a: 

 <?
    if($age>50);
        echo "Hi $name, you are ancient!<p>";
    elseif($age>30);
        echo "Hi $name, you are very old!<p>";
    else;
        echo "Hi $name.";
    endif;
>

PHP proporciona un lenguaje de creación de script muy potente que hará mucho más de lo que los ejemplos anteriores muestran. Vea la sección sobre el Lenguaje de Script PHP para más información.

Puede usted también utilizar PHP para configurar quién está autorizado a acceder a sus páginas. Esto se hace utilizando una pantalla de configuración preconstruida. Con esto podría usted por ejemplo especificar que sólo los usuarios de determinados dominios pueden estar autorizados a ver sus páginas, o crear una regla con la cual proteger ciertas páginas con un password. Vea la sección Control de Acceso para obtener más detalles.

PHP también es capaz de recibir "subidas" de ficheros desde cualquier navegador web que cumpla con la RFC-1867. Esta característica permite a los usuarios subir tanto ficheros de texto como ficheros binarios. Con las funciones lógicas y de control de acceso de PHP, tiene usted control completo sobre quién está autorizado a actualizar y que se puede hacer con los ficheros una vez actualizados. Vea la sección "Subida de Ficheros" para obtener más detalles.

PHP tiene soporte para los paquetes de base de datos PostgreSQL y MySQL. Soporta queries de SQL embebidas en sus ficheros .HTML

15.5 Redirección de CGI

Notas relacionadas con Apache 1.0.x

Una buena forma de ejecutar PHP es utilizar un módulo de redirección de cgi con el servidor Apache. Note por favor que no necesita usted preocuparse por los módulos de redirección si está usted utilizando la versión de módulos de Apache de PHP. Hay dos de estos módulos de redirección utilizables. Uno desarrollado por Dave Andersen

y se encuentra disponible en

y el otro viene incluido en Apache y se llama mod_actions.c. Los módulos son extremadamente similares. Difieren muy ligeramente en su uso. Ambos han sido probados y trabajan con PHP.

Compruebe la documentación de Apache sobre como añadir un módulo. Generalmente usted añadirá un nombre de módulo en un fichero llamado Configuration. La línea que deberá añadir si quiere utilizar el módulo mod_actions es:

Module action_module mod_actions.o

Si está usted utilizando el módulo mod_cgi_redirect.c, añada esta línea:

Module cgi_redirect_module mod_cgi_redirect.o

Y luego compile su httpd e instalelo. Para configurar la redirección de cgi, necesitará o bien crear un nuevo tipo mime en el fichero mime.types, o utilizar el comando AddType en el fichero srm.conf para añadir el tipo mime. El tipo mime para añadir debería ser algo como esto: 

     application/x-httpd-php phtml

Si está usted utilizando el módulo mod_actions.c necesitará añadir la siguiente línea en su fichero srm.conf: 

     Action application/x-httpd-php /cgi-bin/php.cgi

Si está usted utilizando mod_cgi_redirect.c, debería añadir esta línea en srm.conf: 

     CgiRedirect application/x-httpd-php /cgi-bin/php.cgi

No intente utilizar al mismo tiempo mod_actions.c y mod_cgi_redirect.c.

Una vez que tenga usted uno de estos módulos de redirección de cgi instalado y configurado correctamente, será capaz de especificar que quiere un fichero traducido por PHP simplemente modificando la extensión del fichero por .phtml. Más aún, si usted añade index.phtml a su línea de configuración DirectoryIndex en su fichero srm.conf, entorces la página de más alto nivel de un directorio será traducida automáticamente por PHP, si su fichero índice se llama index.phtml.

Netscape HTTPD

Puede usted redirigir automáticamente requerimientos para ficheros con una extensión dada para que sean manipulados por PHP utilizando el módulo CGI Redirection de Netscape Server. Este módulo está disponible en los Archivos de Ficheros de la Página Principal de PHP. El README del paquete explica explícitamente como configurarlo para utilizarlo con PHP.

NCSA HTTPD

NCSA no soporta módulos en la actualidad, de modo que para poder redirectionar cgi con este servidor, necesitará usted modificar el código fuente del servidor. Hay disponible un parche para hacer esto con NCSA 1.5 en los archivos de ficheros del PHP.

15.6 Corriendo PHP desde la línea de comando.

Si construye la versión CGI de PHP, puede utilizarla desde la línea de comandos simplemente tecleando:

php.cgi filename

donde filename es el fichero que quiere usted traducir. Puede también crear scripts PHP independientes colocando en la primera línea de su script algo como: 

    #!/usr/local/bin/php.cgi -q

La "-q" suprime la impresión de las cabeceras HTTP. Puede eliminar esta opción si lo prefiere.

16. La interface Python para PostgreSQL

Python es un lenguaje de scripting interpretado y orientado a objetos. Es faci de utilizar (instrucciones sencillas, simples y de sintaxis ligera), y tiene muchas extenciones para la contrucción de GUIs, interactuar con WWW, etc. Se está desarrollando actualmente (Noviembre de 1.995) un navegador web inteligente (al estilo de HotJava), y esto debería abrir a los programadores muchas puertas. El copyright de Python corresponde a Stichting S Mathematisch Centrum, Amsterdam, Holanda, y se puede distribuir libremente. Contiene soporte para carga dinámica de objetos, clases, módulos y excepciones. Es sencillo añadirle interfaces a nuevas librerías del sistema utilizando código C haciendo así a Python facil de utilizar en personalizaciones. Python es un lenguaje de scripting de muy alto nivel con interface con entorno X-window. El paquete Python se distribuye en los CD-ROMs de Linux, incluyendo la mayoría de los módulos estandar de Python, junto con los módulos para interface al conjunto de instrucciones Tix para Tk.

PyGreSQL es un módulo Python que ataca una base de datos PostgreSQL. Tiene embebido la librería de query de PostgreSQL para permitir utilizar facilmente las poderosas características de PostgreSQL desde un script Python. PyGreSQL está escrito por D'Arcy J.M. Cain y Pascal André.

16.1 ¿Donde encontrar PyGres?

Se encuentran los diferentes paquetes en:

Debería usted, de todas formas, intentar encontrar un mirror de estas direcciones más cerca de usted. Refierase a las fuentes de información para encontrar estos sitios. PyGreSQL debería encontrarse en los directorios contrib de las direcciones de Python y PostgreSQL.

16.2 Información y soporte.

Si necesita usted información sobre estos paquetes, compruebe por favor si direcciones de internet:

Para conseguir soporte:

16.3 Comprobando la interface Python.

Vea la sección - Testing Python PostgreSQL interface

17. El puente entre PostgreSQL y la WWW - WDB-P95

17.1 Sobre wdb-p95

WDB-P95 - Un interface Web para bases de datos PostgreSQL fue creado por J. Douglas Dunlop. Lo pueden encontrar en:

Esta es una versión modificada de wdb-1.3a2, que proporciona un gateway (un puente de acceso) a la WWW para PostgreSQL. Esta versión también requiere un navegador que sea capaz de manipular tablas HTML para las salidas tabulares. Esto no se requiere para el web original y puede ser revertido facilmente.

******************** OJO::: Este párrafo no lo se traducir. Avisar. ********************

You can try out CASI Tape and Image Query. You can have a peek at the Form Definition File (FDF) which is used to create the CASI Tape and Image Query too, which includes a JOIN of 2 tables.

******************** Hasta aquí. Desde aquí ya sigo yo ***************************************

Esta release contiene todos los ficheros necesarios para instalar y correr WDB-P95 como un interface en sus bases de datos PostgreSQL. Trasladar este sistema a otras bases de datos debería ser relativamente sencillo, puesto que soporta SQL estandar y tiene un interface Perl.

17.2 ¿Deben estar en el mismo host el servidor PostgreSQL, pgperl y httpd?

No. El servidor PostgreSQL no tiene porque estar en el mismo host. Como WDB-P95 es llamado por el demonio http, estos dos sí deben estar en el mismo host. Y como WDB-P95 está escrito para usar Pg.pm -pgperl debe estar también en el mismo host. Pgperl está escrito utilizando la librería libpq, de modo que es capaz de acceder a cualquier servidor PostgreSQL en cualquier lugar de la red, tal como cualquier otro cliente PostgreSQL. Como se muestra a continuación:

(WWW Client (Netscape)) => (HTTP Server (NCSA's http) + WDB-P95 + pgperl + libpq)=> (PostgreSQL server)

Los paréntesis externos () representan máquinas.

Cada máquina puede ser de un tipo diferente: NT, SUN, HP, ... pero necesitará la librería de interface libpq para el tipo de máquina donde usted planee utilizar WDB-P95, ya que necesitará compilar pgperl. (El sistema está diseñado para utilizar tablas HTML, de modo que es mejor disponer de un cliente WWW reciente).

18. Interfaces de lenguajes "C", "C++", ESQL/C y Operadores a nivel de Bit para PostgreSQL

18.1 Interface "C"

Está incluido en la distribución y se llama 'libpq'. Similar al OCI de Oracle, DB-lib de Sybase, y las librerías CLI de Informix.

18.2 Interface "C++"

Está incluido en la distribución y se llama 'libpq++'. Vea la sección - Probando el interface C y C++ para PostgreSQL

18.3 ESQL/C

EL 'Precompilador C embebido' ESQL/C para PostgreSQL es similar al Pro*C de Oracle o al ESQL/C de Informix. El ESQL/C de PostgreSQL es un interface de programación de aplicaciones (API) que capacita al programador C a crear aplicaciones con capacidades de mantenimiento de base de datos. El ESQL/C de PostgreSQL le permite utilizar un lenguaje de tercera generación con el cual usted ya está familiarizado, y sacar ventajas del Lenguaje de Estructurado de Query (SQL).

ESQL/C consiste en las siguientes piezas de software:

Se puede encontrar en: Vea la sección - Probando el interface de SQL/C Embebido para PostgreSQL

18.4 Operadores a nivel de Bit para PostgreSQL

Los operadores a nivel de bit han sido escritos por Nicolas Moldavsky

Son funciones "C" las que implementan operadores a nivel de bit (AND, OR, XOR, complemento de bit) en pgsql. Adquieralas por FTP anónimo de: Se incluye un Makefile para Linux.

19. Codigo Japanese Kanji para PostgreSQL

Está en la siguiente dirección:

20. Migración de PostgreSQL a Windows 95/Windows NT

La migración de PostgreSQL a Windows NT está hecha y se puede encontrar en http://www.postgresql.org. Puede usted descargar los binarios de PostgreSQL para Windows NT desde la página de descarga y ahorrar tiempo. Si quiere re-compilar el arbol fuente, siga las instrucciones que damos a continuación. La migración a NT se ha hecho con el paquete cygwin32 de Cygnus, que incluye gcc y gmake para Windows 95/NT.

Tome en esta dirección el fichero cdk.exe (fichero autoextraible para gnu-win32).

20.1 Autores de la migración a NT

Los autores de la migración a Windows NT de PostgreSQL son:

20.2 Instalación del paquete Cygwin. Install the Cygwin package

  1. Descargue ftp://go.cygnus.com/pub/sourceware.cygnus.com/cygwin/latest/full.exe
  2. Ejecute full.exe e instale en el directirion c:\Unix\Root.
  3. Ejecute Cygwin, y luego "mount c:/Unix/Root /"

20.3 Instalación de las herramientas de Andy Piper

  1. Vaya a ftp://ftp.xemacs.org/pub/xemacs/aux/ y descargue cygwin-b20-local.tar.bz2 en el directorio c:/Unix/Root.
  2. cd c:/Unix/Root; bunzip2 cygwin-b20-local.tar.bz2
  3. tar -xvf cygwin-b20-local.tar
  4. cd /local/bin; sh check_cygwin_setup.sh
  5. Tras realizar el paso 4, recibirá usted el siguiente mensaje: 
    You don't have /bin would you like to mount cygwin as /bin?"
[ y/n ]Responda 'n', y las otras opciones seleccionadas a 'y'
  6. mount c:/Unix/Root/cygwin-b20/H-i586-cygwin32/i586-cygwin32/bin /bin
  7. cd c:/Unix/Root/cygwin-b20/H-i586-cygwin32/i586-cygwin32; mkdir libexec share man etc sbin info
  8. cp -R /local/{ bin,libexec,share,man,etc,sbin,info,include }

20.4 Instalación del paquete IPC Cygwin32 de Ludovic Lange

  1. Vaya a http://www.multione.capgemini.fr/tools/pack_ipc y descargue cygwin32_ipc-1.03.tgz en el directorio c:/Unix/Root.
  2. tar -zxvf cygwin32_ipc-1.03.tgz
  3. cd cygwin32_ipc-1.03/src and run 'make'
  4. mkdir -p c:/usr/local/{bin,include,lib,include/sys} 
    cp /cygwin32_ipc-1.03/bin/* c:/usr/local/bin
cp /cygwin32_ipc-1.03/include/sys/* c:/usr/local/include/sys
cp /cygwin32_ipc-1.03/lib/* c:/usr/local/lib
cp c:/usr/local/bin/* /bin
cp c:/Unix/Root/cygwin-b20/H-i586-cygwin32/bin/* /bin
  5. mount c:/usr/local/bin /usr/local/bin 
    mount c:/usr/local/include /usr/local/include
mount c:/usr/local/lib /usr/local/lib
cp /local/lib/* /usr/local/lib

20.5 Instalación de PostgreSQL

  1. Descargue el último código fuente de PostgreSQL
  2. Postgres trata todos los ficherso como binarios, por lo que aparece el caracter lf/cf, y por ello hacemos los pasos 2, 3, 4 y 5: 
    mkdir -p c:/Postgres/{Source,Binary}
mkdir c:/Postgres/Binary/pgsql
mkdir -p /usr/src/pgsql
mkdir -p /usr/local/pgsql
  3. Copie el codigo fuente de Postgres al directorio c:/Postgres/Source, y haga tar -zxvf postgresql-6.5.3.tar.gz
  4. mv postgresql-6.5.3 pgsql
  5. Monte los directorios ahora - 
    mount -b c:/Postgres/Binary/pgsql /usr/local/pgsql
mount c:/Postgres/Source/pgsql /usr/src/pgsql
mount c:/Unix/Root/cygwin-b20/share /sw/cygwin-b20/share
  6. mkdir -p /usr/local/pgsql/{bin,include,lib,data}
  7. cd /usr/src/pgsql/src/win32
  8. Copie los ficheros de cabeceras - 
    cp un.h c:/Unix/Root/cygwin-b20/H-i586-cygwin32/i586-cygwin32/include/sys
cp endian.h c:/Unix/Root/cygwin-b20/H-i586-cygwin32/i586-cygwin32/include
cp tcp.h c:/Unix/Root/cygwin-b20/H-i586-cygwin32/i586-cygwin32/include/netinet
  9. ln -s /usr/local/lib /usr/src/pgsql/src/backend/libpostgres.a
  10. cd /usr/src/pgsql/src, y ejecute './configure'
  11. make > make.txt 2>&1
  12. make install > make.install.txt 2>&1
  13. cp /usr/local/pgsql/lib/pq.dll /usr/local/pgsql/bin
  14. Tras ejecutar el make install, deberá usted cambiar todos los ficheros de texto de los directorios bin y lib de modo que no contengan los caracteres cr/lf y eof.
  15. Utilizando cualquier editor, cree .bashrc en el directorio / como sigue: 
    PATH=$PATH:/usr/local/pgsql/bin:/usr/local/bin
PGDATA=/usr/local/pgsql/data
PGLIB=/usr/local/pgsql/lib
LD_LIBRARY_PATH=/usr/local/pgsql/lib:/usr/local/lib
export LD_LIBRARY_PATH PATH PGDATA PGLIB
  16. salve /.bashrc, y ejecute 'initdb --username=xxxx' Tenga en cuenta que el propietardo del sistema de Base de datos deberá se diferente de root/administrador.
  17. Edite el fichero /usr/local/pgsql/data/pg_hba.conf, tal como: 
    host        all     163.17.11.109   255.255.255.0   trust
  18. ipc-daemon.exe&
  19. postmaster -i&
  20. Run ' psql -h host_name template1'

21. Listas de Correo

21.1 Cuenta de E-mail para PostgreSQL

Puede adquirir cuentas de e-mail gratuitas en:

Suscribase a listas de correo de PostgreSQL, y Yahoo tiene características adicionales de crear una carpeta separada para los e-mails de PostgreSQL, que modo que su carpeta general no se vea saturada. Seleccione en el menú de Email Email- > Options- > Filters y cree una carpeta separada para el e-mail Con esta cuenta de e-mail puede usted acceder al su e-mail desde cualquier parte del mundo desde la que pueda acceder a una página web.

Si tiene usted otro e-mail, puede utilizar los filtros de correo para recibir automáticamente los e-mails de PostgreSQL en una carpeta separada. Esto evitará la mezcla del correo.

(N. del T. Actualmente son multitud los protales de intenet que ofrecen servicio de e-mail gratuito, tanto para su lectura en web como con protocolos pop3 para descarga a local. En particular, www.teleline.es ofrece correo pop3 únicamente, mientras www.alehop.com lo ofrece web. El traductor utiliza para estos menesteres una cuenta en yahoo, de la que descarga el correo con fetchmail en su linux.)

21.2 Listas de correo en inglés

Diríjase al campo Mailing Lists en la página web principal en:

Recibirá las respuestas/replicas por e-mail en menos de un día.

También puede suscribirse a las listas de correo. Para suscribirse o desuscribirse, envíe un e-mail a:

El cuerpo del mensaje deberá contener una única línea:

subscribe

(o)

unsubscribe

21.3 Archivo de las Listas de Correo

Las listas de correo son también archivadas en formato html en la siguiente dirección:

Hay también un buscador utilizable en el sitio web principal de PostgreSQL específicamente para temas de pgsql.

21.4 Lista de correo en español

Hay ahora una lista de correo que no es oficial para PostgreSQL en español. Para suscribirse, el usuario debe enviar un mensaje a:

El cuerpo del mensaje debe incluir una única línea:

inscripcion pgsql-ayuda

22. Documentation and Reference Books

22.1 User Guides and Manuals

The following are included in the PostgreSQL distribution in the postscript, HTML formats and unix man-pages. They are located in /usr/doc/postgresql* directory. If you have access to internet, you can find the documents listed below at http://www.postgresql.org/docs

22.2 Online Documentation

22.3 Useful Reference Textbooks

Hundreds of other titles on SQL are available! Check out a bookstore.

22.4 ANSI/ISO SQL Specifications documents - SQL 1992, SQL 1998

ANSI/ISO SQL specifications documents can be found at these sites listed below -

22.5 Syntax of ANSI/ISO SQL 1992

See Appendix A of this document Appendix A

22.6 Syntax of ANSI/ISO SQL 1998

The SQL 1998 (SQL 3) specification is still under development. See 'Electronic Access to the SQL3 Working Draft' of this document at SQL 1998

22.7 SQL Tutorial for beginners

See Appendix B of this document Appendix B

22.8 Temporal Extension to SQL92

This directory contains the language specification for a temporal extension to the SQL-92 language standard. This new language is designated TSQL2.

The language specification present here is the final version of the language.

Correspondence may be directed to the chair of the TSQL2 Language Design Committee, Richard T.Snodgrass, Department of Computer Science, University of Arizona, Tucson, AZ 85721,

The affiliations and e-mail addresses of the TSQL2 Language Design Committee members may be found in a separate section at the end of the language specification.

The contents of this directory are as follows.

spec.dvi,.ps TSQL2 Language Specification, published in September, 1994

bookspec.ps TSQL2 Language Specification, as it appears in the TSQL2 book, published in September, 1995 (see below).

sql3 change proposals submitted to the ANSI and ISO SQL3 committees.

Associated with the language specification is a collection of commentaries which discuss design decisions, provide examples, and consider how the language may be implemented. These commentaries were originally proposals to the TSQL2 Language Design Committee. They now serve a different purpose: to provide examples of the constructs, motivate the many decisions made during the language design, and compare TSQL2 with the many other language proposals that have been made over the last fifteen years. It should be emphasized that these commentaries are not part of the TSQL2 language specification per se, but rather supplement and elaborate upon it. The language specification proper is the final word on TSQL2.

The commentaries, along with the language specification, several indexes, and other supporting material, has been published as a book:

Snodgrass, R.T., editor, The TSQL2 Temporal Query Language, Kluwer Academic Publishers, 1995, 674+xxiv pages.

The evaluation commentary appears in the book in an abbreviated form; the full commentary is provided in this directory as file eval.ps

The file tl2tsql2.pl is a prolog program that tranlates allowed temporal logic to TSQL2. This program was written by Michael Boehlen

He may be contacted for a paper that describes this translation. This is a rather dated version of that program. Newer versions are available at (the TimeDB and Tiger systems).

22.9 Part 0 - Acquiring ISO/ANSI SQL Documents

This document shows you how to (legally) acquire a copy of the SQL-92 standard and how to acquire a copy of the "current" SQL3 Working Draft.

The standard is copyrighted ANSI standard by ANSI, the ISO standard by ISO.

There are two (2) current SQL standards, an ANSI publication and an ISO publication. The two standards are word-for-word identical except for such trivial matters as the title of the document, page headers, the phrase "International Standard" vs "American Standard", and so forth.

Buying the SQL-92 Standard

The ISO standard, ISO/IEC 9075:1992, Information Technology - Database Languages - SQL, is currently (March, 1993) available and in stock from ANSI at: 

     American National Standards Institute
     1430 Broadway
     New York, NY 10018 (USA)
     Phone (sales): +1.212.642.4900
at a cost of US$230.00. The ANSI version, ANSI X3.135-1992, American National Standard for Information Systems - Database Language SQL, was not available from stock at this writing, but was expected to be available by some time between late March and early May, 1993). It is expected to be be priced at US$225.00.

If you purchase either document from ANSI, it will have a handling charge of 7% added to it (that is, about US$9.10). Overseas shipping charges will undoubtedly add still more cost. ANSI requires a hardcopy of a company purchase order to accompany all orders; alternately, you can send a check drawn on a US bank in US dollars, which they will cash and clear before shipping your order. (An exception exists: If your organization is a corporate member of ANSI, then ANSI will ship the documents and simply bill your company.)

The ISO standard is also available outside the United States from local national bodies (country standardization bodies) that are members of either ISO (International Organization for Standardization) or IEC (International Electrotechnical Commission). Copies of the list of national bodies and their addresses are available from ANSI or from other national bodies. They are also available from ISO: 

     International Organization for Standardization
     Central Secretariat
     1, rue de Varembi
     CH-1211 Genhve 20
     Switzerland
If you prefer to order the standard in a more convenient and quick fashion, you'll have to pay for the privilege. You can order ISO/IEC 9075:1992, Information Technology - Database Languages - SQL, from: 
     Global Engineering Documents
     2805 McGaw Ave
     Irvine, CA 92714 (USA)
     USA
     Phone (works from anywhere): +1.714.261.1455
     Phone (only in the USA): (800)854-7179
for a cost of US$308.00. I do not know if that includes shipping or not, but I would guess that international shipping (at least) would cost extra. They will be able to ship you a document fairly quickly and will even accept "major credit cards". Global does not yet have the ANSI version nor do they have a price or an expected date (though I would expect it within a few weeks following the publication by ANSI and at a price near US$300.00).

Buying a copy of the SQL3 Working Draft

You can purchase a hardcopy of the SQL3 working draft from the ANSI X3 Secretariat, CBEMA (Computer and Business Equipment Manufacturers Association). They intend to keep the "most recent" versions of the SQL3 working draft available and sell them for about US$60.00 to US$65.00. You can contact CBEMA at: 

     CBEMA, X3 Secretariat
     Attn: Lynn Barra
     1250 Eye St.
     Suite 200
     Washington, DC 20005 (USA)
Lynn Barra can also be reached by telephone at +1.202.626.5738 to request a copy, though mail is probably more courteous.

Electronic Access to the SQL3 Working Draft

The most recent version (as of the date of this writing) of the SQL3 (both ANSI and ISO) working draft (and all of its Parts) is available by "anonymous ftp" or by "ftpmail" on: 

     gatekeeper.dec.com

  at

     /pub/standards/sql/
In this directory are a number of files. There are PostScript. files and "plain text" (not prettily formatted, but readable on a screen without special software).

In general, you can find files with names like: 

     sql-bindings-mar94.ps
     sql-bindings-mar94.txt
     sql-cli-mar94.ps
     sql-cli-mar94.txt
     sql-foundation-mar94.ps
     sql-foundation-mar94.txt
     sql-framework-mar94.ps
     sql-framework-mar94.txt
     sql-psm-mar94.ps
     sql-psm-mar94.txt
As new versions of the documents are produced, the "mar94" will change to indicate the new date of publication (e.g., "aug94" is the expected date of the next publication after "mar94").

In addition, for those readers unable to get a directory listing by FTP, we have placed a file with the name: 

     ls
into the same directory. This file (surprise!) contains a directory listing of the directory.

Retrieving Files Directly Using ftp

This is a sample of how to use FTP. Specifically, it shows how to connect to gatekeeper.dec.com, get to the directory where the base document is kept, and transfer the document to your host. Note that your host must have Internet access to do this. The login is 'ftp' and the password is your email address (this is sometimes referred to as 'anonymous ftp'). The command 'type binary' is used to ensure that no bits are stripped from the file(s) received. 'get' gets one file at a time. Comments in the script below are inside angle brackets < like so > . 

  % ftp gatekeeper.dec.com
  Connected to gatekeeper.dec.com.
  220- *** /etc/motd.ftp ***
       Gatekeeper.DEC.COM is an unsupported service of DEC Corporate Research.
       <...this goes on for a while...>
  220 gatekeeper.dec.com FTP server (Version 5.83 Sat ... 1992) ready.
  Name (gatekeeper.dec.com:<yourlogin here>): ftp  <anonymous also works>
  331 Guest login ok, send ident as password.
  Password: <enter your email address here >
  230 Guest login ok, access restrictions apply.
  Remote system type is UNIX.  <or whatever>
  Using binary mode to transfer files.
  ftp> cd pub/standards/sql
  250 CWD command successful.
  ftp> dir
  200 PORT command successful.
  150 Opening ASCII mode data connection for /bin/ls.
  total 9529
  -r--r--r--  1 root     system     357782 Feb 25 10:18 x3h2-93-081.ps
  -r--r--r--  1 root     system     158782 Feb 25 10:19 x3h2-93-081.txt
  -r--r--r--  1 root     system     195202 Feb 25 10:20 x3h2-93-082.ps
  -r--r--r--  1 root     system      90900 Feb 25 10:20 x3h2-93-082.txt
  -r--r--r--  1 root     system    5856284 Feb 25 09:55 x3h2-93-091.ps
  -r--r--r--  1 root     system    3043687 Feb 25 09:57 x3h2-93-091.txt
  226 Transfer complete.
  ftp> type binary
  200 Type set to I.
  ftp> get x3h2-93-082.txt
  200 PORT command successful.
  150 Opening BINARY mode data connection for x3h2-93-082.txt (90900 bytes).
  226 Transfer complete.
  90900 bytes received in 0.53 seconds (166.11 Kbytes/s)
  ftp> quit
  % <the file is now in your directory as x3h2-93-082.txt>
Retrieving Files Without Direct ftp Support

Digital Equipment Corporation, like several other companies, provides ftp email service. The response can take several days, but it does provide a service equivalent to ftp for those without direct Internet ftp access. The address of the server is:

ftpmail@decwrl.dec.com

The following script will retrieve the PostScript for the latest version of the SQL3 document: 

     reply joe.programmer@imaginary-corp.com
     connect gatekeeper.dec.com anonymous
     binary
     compress
The following script will retrieve the PostScript for the latest version of the SQL3 document: 
     reply joe.programmer@imaginary-corp.com
     connect gatekeeper.dec.com anonymous
     binary
     compress
     uuencode
     chdir /pub/standards/sql
     get x3h2-93-091.ps
     quit
The first line in the script commands the server to return the requested files to you; you should replace "joe.programmer@imaginary-corp.com" with your Internet address. The file in this example, x3h2-93-091.ps, is returned in "compress"ed "uuencode"d format as 34 separate email messages. If your environment does not provide tools for reconstructing such files, then you could retrieve the file as plain text with the following script: 
     reply joe.programmer@imaginary-corp.com
     connect gatekeeper.dec.com anonymous
     chdir /pub/standards/sql
     get x3h2-93-091.ps
     quit
But be warned, the .ps file will probably be sent to you in more than 70 parts!

To retrieve any particular file, other than x3h2-93-091.ps, simply replace "x3h2-93-091.ps" with the name of the desired file. To get a directory listing of all files available, replace "get x3h2-93-091.ps" with "dir".

22.10 Part 1 - ISO/ANSI SQL Current Status

This chapter is a source of information about the SQL standards process and its current state.

Current Status:

Development is currently underway to enhance SQL into a computationally complete language for the definition and management of persistent, complex objects. This includes: generalization and specialization hierarchies, multiple inheritance, user defined data types, triggers and assertions, support for knowledge based systems, recursive query expressions, and additional data administration tools. It also includes the specification of abstract data types (ADTs), object identifiers, methods, inheritance, polymorphism, encapsulation, and all of the other facilities normally associated with object data management.

In the fall of 1996, several parts of SQL3 went through a ISO CD ballot. Those parts were SQL/Framework, SQL/Foundation, and SQL/Bindings. Those ballots failed (as expected) with 900 or so comments. In Late January, there was an ISO DBL editing meeting that processed a large number of problem solutions that were either included with ballot comments or submitted as separate papers. Since the DBL editing meeting was unable to process all of the comments, the editing meeting has been extended. The completion of the editing meeting is scheduled for the end of July, 1997, in London.

Following the July editing meeting, the expectation is that a Final CD ballot will be requested for these parts of SQL. The Final CD process will take about 6 months and a DBL editing meeting, after which there will be a DIS ballot and a fairly quick IS ballot.

The ISO procedures have changed since SQL/92, so the SQL committees are still working through the exact details of the process.

If everything goes well, these parts of SQL3 will become an official ISO/IEC standard in late 1998, but the schedule is very tight.

In 1993, the ANSI and ISO development committees decided to split future SQL development into a multi-part standard. The Parts are:

In the USA, the entirety of SQL3 is being processed as both an ANSI Domestic ("D") project and as an ISO project. The expected time frame for completion of SQL3 is currently 1999.

The SQL/CLI and SQL/PSM are being processed as fast as possible as addendums to SQL-92. In the USA, these are being processed only as International ("I") projects. SQL/CLI was completed in 1995. SQL/PSM should be completed sometime in late 1996.

In addition to the SQL3 work, a number of additional projects are being persued:

Standards Committee and Process

There are actually a number of SQL standards committees around the world. There is an international SQL standards group as a part of ISO. A number of countries have committees that focus on SQL. These countries (usually) send representatives to ISO/IEC JTC1/SC 21/WG3 DBL meetings. The countries that actively participate in the ISO SQL standards process are:

NIST Validation

SQL implementations are validated (in the Unites States) by the National Institute of Standards and Training (NIST). NIST currently has a validation test suite for entry level SQL-92. The exact details of the NIST validation requirements are defined as a Federal Information Processing Standard (FIPS). The current requirements for SQL are defined in FIPS 127-2. The Postscript and Text versions of this document can be retrieved from NIST. The current SQL Validated Products List can also be retrieved from NIST.

Standard SQL Publications and Articles

There are two versions of the SQL standard. Both are available from ANSI:

The two versions of the SQL standard are identical except for the front matter and references to other standards. Both versions are available from: 

     American National Standards Institute
     1430 Broadway
     New York, NY 10018
     USA
     Phone (sales): +1.212.642.4900
In additon to the SQL-92 standard, there is now a Technical Corrigendum (bug fixes): 
   * Technical Corrigendum 1:1994 to ISO/IEC 9075:1992
TC 1 should also be available from ANSI. There is only an ISO version of TC 1 -- it applies both to the ISO and ANSI versions of SQL-92.

In addition to the standards, several books have been written about the 1992 SQL standard. These books provide a much more readable description of the standard than the actual standard.

Related Standards

A number of other standards are of interest to the SQL community. This section contains pointers to information on those efforts. These pointers will be augmented as additional information becomes available on the web.

22.11 Part 2 - ISO/ANSI SQL Foundation

A significant portion of the SQL3 effort is in the SQL Foundation document:

There are several prerequisites to the object oriented capabilities:

These capabilities are defined as a part of SQL/PSM

A great deal of work is currently being done to refine the SQL-3 object model and align it with the object model proposed by ODMG. This effort is described in the X3H2 and ISO DBL paper: Accomodating SQL3 and ODMG. A recent update on the SQL3/OQL Merger is also available.

SQL3 Timing

Work on SQL3 is well underway, but the final standards is several years away.

The ANSI version of the standard will be on a similar schedule.

22.12 Part 3 - ISO/ANSI SQL Call Level Interface

The SQL/CLI is a programing call level interface to SQL databases. It is designed to support database access from shrink-wrapped applications. The CLI was originally created by a subcommittee of the SQL Access Group (SAG). The SAG/CLI specification was published as the Microsoft Open DataBase Connectivity (ODBC) specification in 1992. In 1993, SAG submitted the CLI to the ANSI and ISO SQL committees. (The SQL Access Group has now merged with X/Open consortium.)

SQL/CLI provides an international standard for:

SQL/CLI Timing

For the standards process, SQL/CLI is being processed with blinding speed.

22.13 Part 4 - ISO/ANSI SQL Persistent Stored Modules

SQL/PSM expands SQL by adding:

In addition to being a valuable application development tool, SQL/PSM provides the foundation support for the object oriented capabilities in SQL3.

Multi-statement and Stored Procedures

Multi-statement and stored procedures offer a variety of advantages in a client/server environment:

Procedural Language Extensions

Procedural language add the power of a traditional programming language to SQL through flow control statements and a variety of other programming constructs.

Flow Control Statements

The procedural language extensions include other programming language constructs:

In addition, all of the traditional SQL statements can be included in multi-statement procedures.

External Procedure and Function Calls

One feature frequently mentioned in the wish lists for many database products, and implemented in some, is a capability augmenting the built-in features with calls to user-written procedures external to the database software.

The benefit of this capability is that it gives the database (and therefore database applications) access to a rich set of procedures and functions too numerous to be defined by a standards committee.

SQL/PSM Timing

SQL/PSM is proceeding quickly:

22.14 Part 5 - ISO/ANSI SQL/Bindings

For ease of reference, the programming language bindings have been pulled out into a separate document. The current version is simply an extract of the dynamic and embedded bindings from SQL-92.

A variety of issues remain unresolved for the programming language bindings.

For traditional programming language, mappings exist for the SQL-92 datatypes. However, mappings must be defined between SQL objects and programming language variables.

For object oriented languages, mapping must be defined for the current SQL datatypes and between the SQL object model and the object model of the object-oriented language.

The object model needs to stabilize before these can be addressed.

The language bindings will be completed as a part of SQL3.

22.15 Part 6 - ISO/ANSI SQL XA Interface Specialization (SQL/XA)

This specification would standardize an application program interface (API) between a global Transaction Manager and an SQL Resource Manager. It would standardize the function calls, based upon the semantics of ISO/IEC 10026, "Distributed Transaction Processing", that an SQL Resource Manager would have to support for two-phase commit. The base document is derived from an X/Open publication, with X/Open permission, that specifies explicit input and output parameters and semantics, in terms of SQL data types, for the following functions: xa_close, xa_commit, xa_complete, xa_end, xa_forget, xa_open, xa_prepare, xa_recover, xa_rollback, and xa_start.

ISO is currently attempting to fast-track the X/Open XA specification. The fast-track process adopts a current industry specification with no changes. The XA fast-track ballot at the ISO SC21, JTC 1 level started on April 27, 1995 and ends on October 27, 1995. If the XA specification is approved by 75% of the votes, and by 2/3 of the p-members of JTC 1, it will become an International Standard. If the fast-track ballot is approved, SQL/XA could become a standard in 1996.

22.16 Part 7 - ISO/ANSI SQL Temporal

Temporal SQL deals with time-related data. The concept is that it is useful to query data to discover what it looked like at a particular point in time. Temporal SQL is a December, 1994 paper by Rick Snodgrass describing the concepts.

X3 Announces the Approval of a New Project, ISO/IEC 9075 Part 7: SQL/Temporal is a press release related to SQL/Temporal. 

----------------------------------------------------------------------------
                                Temporal SQL
                                ************
Rick Snodgrass (chair of the TSQL2 committee)
31-Dec-1994
Several people have questioned the need for additional support for time in SQL3 (as proposed by DBL RIO-75, requesting a new part of SQL to support temporal databases). The claim is that abstract data types (ADT's) are sufficient for temporal support. In this informational item, I argue, using concrete examples, that using columns typed with abstract data types is inadequate for temporal queries. In particular, many common temporal queries are either difficult to simulate in SQL, or require embedding SQL in a procedural language. Alternatives are expressed in TSQL2, a temporal extension to SQL-92.

INTRODUCTION

Valid-time support goes beyond that of a temporal ADT. With the later, a column is specified as of a temporal domain, such as DATE or INTERVAL (examples will be given shortly). With valid time, the rows of a table vary over time, as reality changes. The timestamp associated with a row of a valid-time table is interpreted by the query language as the time when the combination of values of the columns in the row was valid. This implicit timestamp allows queries to be expressed succinctly and intuitively.

A CASE STUDY - STORING CURRENT INFORMATION

The University of Arizona's Office of Appointed Personnel has some information in a database, including each employee's name, their current salary, and their current title. This can be represented by a simple table. 

        Employee(Name, Salary, Title)
Given this table, finding an employee's salary is easy. 
        SELECT Salary
        FROM Employee
        WHERE Name = 'Bob'
Now the OAP wishes to record the date of birth. To do so, a column is added to the table, yielding the following schema. 
        Employee(Name, Salary, Title, DateofBirth DATE)
Finding the employee's date of birth is analogous to determining the salary. 
        SELECT DateofBirth
        FROM Employee
        WHERE Name = 'Bob'

A CASE STUDY - STORING HISTORY INFORMATION

The OAP wishes to computerize the employment history. To do so, they append two columns, one indicating when the information in the row became valid, the other indicating when the information was no longer valid.

Employee (Name, Salary, Title, DateofBirth, Start DATE, Stop DATE)

To the data model, these new columns are identical to DateofBirth. However, their presence has wide-ranging consequences.

A CASE STUDY - PROJECTION

To find an employee's current salary, things are more difficult. 

        SELECT Salary
        FROM Employee
        WHERE Name = 'Bob' AND Start <= CURRENT_DATE AND CURRENT_DATE <= Stop
This query is more complicated than the previous one. The culprit is obviously the two new columns. The OAP wants to distribute to each employee their salary history. Specifically, for each person, the maximal intervals at each salary needs to be determined. Unfortunately, this is not possible in SQL. An employee could have arbitrarily many title changes between salary changes. 
Name    Salary  Title             DateofBirth   Start           Stop
----    ------  -----             -----------   -----           ----
Bob     60000   Assistant Provost 1945-04-09    1993-01-01      1993-05-30
Bob     70000   Assistant Provost 1945-04-09    1993-06-01      1993-09-30
Bob     70000   Provost           1945-04-09    1993-10-01      1994-01-31
Bob     70000   Professor         1945-04-09    1994-02-01      1994-12-31

                               Figure 1
Note that there are three rows in which Bob's salary remained constant at $70,000. Hence, the result should be two rows for Bob. 
Name    Salary  Start           Stop
----    ------  -----           ----
Bob     60000   1993-01-01      1993-05-30
Bob     70000   1993-06-01      1994-12-31
One alternative is to give the user a printout of Salary and Title information, and have user determine when his/her salary changed. This alternative is not very appealing or realistic. A second alternative is to use SQL as much as possible. 
CREATE TABLE Temp(Salary, Start, Stop)
AS      SELECT Salary, Start, Stop
        FROM Employee;
repeat 
        UPDATE Temp T1
        SET (T1.Stop) = (SELECT MAX(T2.Stop)
                         FROM Temp AS T2
                         WHERE T1.Salary = T2.Salary AND T1.Start < T2.Start
                                AND T1.Stop >= T2.Start AND T1.Stop < T2.Stop)
        WHERE EXISTS (SELECT *
                      FROM Temp AS T2
                      WHERE T1.Salary = T2.Salary AND T1.Start < T2.Start
                                AND T1.Stop >= T2.Start AND T1.Stop < T2.Stop)
        until no rows updated;

DELETE FROM Temp T1

WHERE EXISTS (SELECT *
              FROM Temp AS T2
              WHERE T1.Salary = T2.Salary
                        AND ((T1.Start > T2.Start AND T1.Stop <= T2.Stop)
                        OR (T1.Start >= T2.Start AND T1.Stop < T2.Stop))
The loop finds those intervals that overlap or are adjacent and thus should be merged. The loop is executed log N times in the worst case, where N is the number of rows in a chain of overlapping or adjacent value-equivalent rows. The reader can simulate the query on the example table to convince him/herself of its correctness.

A third alternative is to use SQL only to open a cursor on the table. A linked list of periods is maintained, each with a salary. This linked list should be initialized to empty. 

DECLARE emp_cursor CURSOR FOR
        SELECT Salary, Title, Start, Stop
        FROM Employee;
OPEN emp_cursor;
loop:
        FETCH emp_cursor INTO :salary, :start, :stop;
        if no-data returned then goto finished;
        find position in linked list to insert this information;
        goto loop;
finished:
CLOSE emp_cursor;
iterate through linked list, printing out dates and salaries

The linked list may not be necessary in this case if the cursor is ORDER BY Start.

In any case, the query, a natural one, is quite difficult to express using the facilities present in SQL-92. The query is trivial in TSQL2. 

        SELECT Salary
        FROM Employee

A CASE STUDY - JOIN

A more drastic approach is to avoid the problem of extracting the salary history by reorganizing the schema to separate salary, title, and date of birth information (in the following, we ignore the date of birth, for simplicity). 

        Employee1 (Name, Salary, Start DATE, Stop DATE)
        Employee2 (Name, Title, Start DATE, Stop DATE)
The Employee1 table is as follows. 
Name    Salary  Start           Stop
----    ------  -----           ----
Bob     60000   1993-01-01      1993-05-30
Bob     70000   1993-06-01      1993-12-31
Here is the example Employee2 table. 
Name    Title                   Start           Stop
----    ------                  -----           ----
Bob     Assistant Provost       1993-01-01      1993-09-30
Bob     Provost                 1993-10-01      1994-01-31
Bob     Professor               1994-02-01      1994-12-31
With this change, getting the salary information for an employee is now easy. 
        SELECT Salary, Start, Stop
        FROM Employee1
        WHERE Name = 'Bob'
But what if the OAP wants a table of salary, title intervals (that is, suppose the OAP wishes a table to be computed in the form of Figure 1)? One alternative is to print out two tables, and let the user figure out the combinations. A second alternative is to use SQL entirely. Unfortunately, this query must do a case analysis of how each row of Employee1 overlaps each row of Employee2; there are four possible cases. 
SELECT Employee1.Name, Salary, Dept, Employee1.Start, Employee1.Stop
FROM Employee1, Employee2
WHERE Employee1.Name = Employee2.Name
     AND Employee2.Start <= Employee1.Start AND Employee1.Stop < Employee2.Stop
UNION
SELECT Employee1.Name, Salary, Dept, Employee1.Start, Employee2.Stop
FROM Employee1, Employee2
WHERE Employee1.Name = Employee2.Name
     AND Employee1.Start >= Employee2.Start AND Employee2.Stop < Employee1.Stop
        AND Employee1.Start < Employee2.Stop
UNION
SELECT Employee1.Name, Salary, Dept, Employee2.Start, Employee1.Stop
FROM Employee1, Employee2
WHERE Employee1.Name = Employee2.Name
     AND Employee2.Start > Employee1.Start AND Employee1.Stop < Employee2.Stop
        AND Employee2.Start < Employee1.Stop
UNION
SELECT Employee1.Name, Salary, Dept, Employee2.Start, Employee2.Stop
FROM Employee1, Employee2
WHERE Employee1.Name = Employee2.Name
     AND Employee2.Start > Employee1.Start AND Employee2.Stop < Employee1.Stop
Getting all the cases right is a challenging task. In TSQL2, performing a temporal join is just what one would expect. 
        SELECT Employee1.Name, Salary, Dept
        FROM Employee1, Employee2
        WHERE Employee1.Name = Employee2.Name

A CASE STUDY - AGGREGATES

Now the OAP is asked, what is the maximum salary? Before adding time, this was easy. 

        SELECT MAX(Salary)
        FROM Employee
Now that the salary history is stored, we'd like a history of the maximum salary over time. The problem, of course, is that SQL does not provide temporal aggregates. The easy way to do this is to print out the information, and scan manually for the maximums. An alternative is to be tricky and convert the snapshot aggregate query into a non-aggregate query, then convert that into a temporal query. The non-aggregate query finds those salaries for which a greater salary does not exist. 
        SELECT Salary
        FROM Employee AS E1
        WHERE NOT EXISTS (SELECT *
                          FROM Employee AS E2
                          WHERE E2.Salary > E1.Salary)
Converting this query into a temporal query is far from obvious. The following is one approach. 
CREATE TABLE Temp (Salary, Start, Stop)
AS      SELECT Salary, Start, Stop
        FROM Employee;
INSERT INTO Temp
        SELECT T.Salary, T.Start, E.Start
        FROM Temp AS T, Employee AS E
        WHERE E.Start >= T.Start AND E.Start < T.Stop AND E.Salary > T.Salary;

INSERT INTO Temp
        SELECT T.Salary, T.Stop, E.Stop
        FROM Temp AS T, Employee AS E
        WHERE E.Stop > T.Start AND E.Stop <= T.Stop AND E.Salary > T.Salary;
DELETE FROM Temp T
WHERE EXISTS (SELECT *
              FROM Employee AS E
              WHERE ((T.Start => E.Start AND T.Start < E.Stop)
                        OR (E.Start >= T.Start AND E.Start < T.Stop))
                    AND E.Salary > T.Salary;
This approach creates an auxiliary table. We add to this table the lower period of a period subtraction and the upper period of a period subtraction. We then delete all periods that overlap with some row defined by the subquery, thereby effecting the NOT EXISTS. Finally we generate from the auxiliary table maximal periods, in the same way that the salary information was computed above. As one might imagine, such SQL code is extremely inefficient to execute, given the complex nested queries with inequality predicates.

A third alternative is to use SQL as little as possible, and instead compute the desired maximum history in a host language using cursors.

The query in TSQL2 is again straightforward and intuitive. 

        SELECT MAX(Salary)
        FROM Employee

SUMMARY

Time-varying data is manipulated in most database applications. Valid-time support is absent in SQL. Many common temporal queries are either difficult to simulate in SQL, or require embedding SQL in a procedural language, due to SQL's lack of support for valid-time tables in its data model and query constructs.

Elsewhere, we showed that adding valid-time support requires few changes to the DBMS implementation, can dramatically simplify some queries and enable others, and can later enable optimizations in storage structures, indexing methods, and optimization strategies that can yield significant performance improvements.

With a new part of SQL3 supporting time-varying information, we can begin to address such applications, enabling SQL3 to better manage temporal data. 

----------------------------------------------------------------------------
           Accredited Standards Committee* X3, Information Technology
NEWS RELEASE

Doc. No.:       PR/96-0002

Reply to:       Barbara Bennett at bbennett@itic.nw.dc.us

             X3 Announces the Approval of a New Project, ISO/IEC

                         9075 Part 7:  SQL/Temporal

Washington D.C., January 1996 
----------------------------------------------------------------------------
-- Accredited Standards Committee X3, Information Technology is announcing the approval of a new project on SQL/Temporal Support, ISO/IEC 9075 Part 7, with the work being done in Technical Committee X3H2, Database. The scope of this proposed standard specifies a new Part of the emerging SQL3 standard, e.g., Part 7, Temporal SQL, to be extensions to the SQL language supporting storage, retrieval, and manipulation of temporal data in an SQL database environment. The next X3H2 meeting is scheduled for March 11-14, 1996 in Kansas.

Inquiries regarding this project should be sent to the 

        Chairman of X3H2, 
        Dr. Donald R. Deutsch, 
        Sybase, Inc., Suite 800, 
        6550 Rock Spring
        Drive, Bethesda, MD  20817. 
        Email: deutsch@sybase.com.
An initial call for possible patents and other pertinent issues (copyrights, trademarks) is now being issued. Please submit information on these issues to the 
        X3 Secretariat at 
        1250 Eye Street
        NW, Suite 200,
        Washington DC  20005.
        Email: x3sec@itic.nw.dc.us
        FAX:  (202)638-4922.

22.17 Part 8 - ISO/ANSI SQL MULTIMEDIA (SQL/MM)

A new ISO/IEC international standardization project for development of an SQL class library for multimedia applications was approved in early 1993. This new standardization activity, named SQL Multimedia (SQL/MM), will specify packages of SQL abstract data type (ADT) definitions using the facilities for ADT specification and invocation provided in the emerging SQL3 specification. SQL/MM intends to standardize class libraries for science and engineering, full-text and document processing, and methods for the management of multimedia objects such as image, sound, animation, music, and video. It will likely provide an SQL language binding for multimedia objects defined by other JTC1 standardization bodies (e.g. SC18 for documents, SC24 for images, and SC29 for photographs and motion pictures).

The Project Plan for SQL/MM indicates that it will be a multi-part standard consisting of an evolving number of parts. Part 1 will be a Framework that specifies how the other parts are to be constructed. Each of the other parts will be devoted to a specific SQL application package. The following SQL/MM Part structure exists as of August 1994:

There are a number of standards efforts in the area of Spatial and Geographic information:

23. Soporte Técnico para PostgreSQL

Si tiene usted cualquier pregunta técnica o encuentra cualquier programa, puede enviar un correo electrónico (e-mail) a:

y espere la respuesta por correo electrónico en menos de un día. Como la base de usuarios de internet del producto es muy amplia, y los usuarios soportan a otros usuarios, internet será capaz de dar soporte técnico a miles de millones (sic) de usuarios facilmente. El soporte por correo electrónico es mucho más conveniente que el soporte telefónico puesto que usted puede cortar y pegar los mensajes de error, outputs de los programas, etc... y transmitirlos a la lista de correo o al grupo de noticias.

También la organización PostgreSQL está proporcionando soporte técnico para compañías, y los beneficios generados se utilizarán para mantener varios mirrors (web y ftp) de la página principal alrededor del mundo. Los beneficios también serán usados para producir documentación escrita, guías, y libros de texto con los cuales ayudar a los usuarios.

También puede conseguir ayuda de firmas de consultaría profesional como RedHat, Anderson, WGS (Work Group Solutions). Contactelos para conseguir ayuda, puesto que ellos tienen muy buenos expertos en "C", "C++" (PostgreSQL está escrito en "C").

24. Aspectos Económicos y de Negocios.

Las bases de datos comerciales pagan multitud de impuestos, federales, estatales, ventas, empleo, seguridad social, tasas de medicamentos, cuidado de salud para empleados, puñados de beneficios para los empleados, costes de marketing y publicidad. Todos estos costes no van directamente al desarrollo de la base de datos, y no incrementan la calidad o tecnología de la base de datos. Usted puede comprar una base de datos comercial, y una parte del importe irá a sobrecostes como tasas, gastos y balances para cotes de R&D de la base de datos.

Las bases de datos comerciales tienen que pagar también por el mantenimiento de estados reales y de desarrollo, y comprar máquinas UNIX, instalarlas y mantenerlas. Todos estos costes se trasladan a los clientes.

PostgreSQL tiene la ventaja sobre las bases de datos comerciales de no tener tasas directas, puesto que está hecha en internet. Un grupo muy amplio de gente contribuye al desarrollo de PostgreSQL. Por ejemplo, en un hipotético caso, si hay un millón de compañías en Estados Unidos, y cada una contribuje con alrededor de 10 $ (el valor del software de PostgreSQL), entonces cada una de estas compañías adquirirá ¡10 millones de dólares!. Esta es la GRAN MAGIA del software desarrollado en internet.

Actualmente, el código fuente de PostgreSQL contiene unas 250.000 líneas de código "C" y "C++". Si el coste de cada línea de "C" es de 2 $, el coste total de PostgreSQL es de alrededor de 500.000 $ (¡medio millón de dólares!).

Muchas compañias ya desarrollan grandes cantidades de código "C" y "C++". De aquí, colaborando en el código fuente de PostgreSQL y con otras compañías en internet beneficiará enormemente a reducir el tiempo y el esfuerzo de la compañía.

25. Lista de otras bases de datos.

Se listan a continuación otras bases de datos SQL para Unix, Linux.

26. Buscando consejos en la World Wide Web

Internet es muy amplio, tiene una vasta cantidad de software y un océano de información. Está creciendo a un ritmo del 300 % anual. ¡Se estima que hay alrededor de 10 millones de sitios Web en el mundo!

Para buscar cualquier información, debería usted utilizar buscadores como "Yahoo", "Netscape", "Lycos", etc. Vaya hasta Yahoo, y haga clic en Buscar. Utilice las opciones de filtrado para mejorar sus criterios de búsqueda. La acción de búsqueda de defecto es la "Búsqueda Inteligente", que es la más general y lista todas las posibilidades. Haga clic en "Opciones" para seleccionar las búsquedas "frase EXACTA", "Y", "O", etc. ("EXACT phrase", "AND", "OR",...). De esta forma encontrará mucho más rápido la información que necesita. También puede utilizar el menú de búsqueda, hay radio-buttons (selecciones alternativas) para buscar en Usenet, sitios Web y sitios de Yahoo.

27. Conclusión

Tras investigar en todas las bases de datos utilizables que sean libres y de código abierto, hemos comprobado que SOLO PostgreSQL es el RDBMS SQL (objeto relacional) más MADURO, más usado y más robusto mayormente del mundo.

PostgreSQL es muy atrayente porque ya se ha realizado un montón de trabajo. Tiene drivers ODBC y JDBC, con los que es posible construir aplicaciones independientes de la base de datos. Las aplicaciones escritas en PostgreSQL utilizando ODBC y JDBC son fácilmente portables a otras bases como Oracle, Sybase e Informix, y viceversa.

Usted puede preguntar "¿Pero porqué PostgreSQL?". La respuesta es, puesto que se llevaría un montón de tiempo desarrollar una base de datos de la nada, que tiene sentido elegir un sistema de base de datos que satisfaga las siguientes condiciones:

Un sistema de base de datos: A database system

Y la única base de datos que satisfaga estas condiciones y sea un software apropiado para esta situación es 'PostgreSQL'. Puede usted ver que 'PostgreSQL' es un nombre muy extraño. Pero mi argumento es ¿porqué cambiar el nombre? ¡¡El mundo ya se ha enganchado a 'PostgreSQL' para siempre!!

28. FAQ - Preguntas sobre PostgreSQL

Por favor, diríjanse a la última versión de la FAQ sobre preguntas generales, sobre Linux y sobre Irix en

29. Otros formatos de este documento

Este documento se ha publicado en 10 formatos diferentes: DVI, Postscript, Latex, Lyx, GNU-info, HTML, RTF (Rich Text Format), Texto Plano, Páginas man de Unix, y SGML.

Este documento se ha escrito utilizando una herramienta llamada "SGML tool", la cual se puede descargar de: http://www.xs4all.nl/~cg/sgmltools/ Compilando el código fuentes, tendrá los siguientes comandos, como

El documento se encuentra en:

Y también en los siguientes directorios mirror:

(N. del T: la lista de mirrors crece constantemente. Le recomiendo que se dirija a la dirección ftp://postgresql.org, donde le dirigirán a los sites oficiales más próximos a usted. En el momento de redactar esta traducción, la lista ya superaba la decena).

Para ver el documento en formato dvi, utilice el programa xdvi. El programa xdvi se encuentra en el paquete tetex-xdvi*.rpm de Linux de RedHat, y puede localizarse a través de ControlPanel | Applications | Publishing | TeX.

Para leer el documento en dvi, de el comando: 

        xdvi -geometry 80x90 howto.dvi
        man xdvi
Y reajuste el tamaño de la ventana con el ratón. Para navegar, utilice las teclas de las flechas, Avance Página, Retrocede Página, y también puede usted utilizar las letras 'f', 'd', 'u', 'c', 'l', 'r', 'p', 'n', para moverse arriba, abajo, centro, página siguiente, página anterior, etc. Para descontectar el menú experto, presiones 'x'.

Puede usted leer el fichero postscript utilizando el programa 'gv' (ghostview) o 'ghostscript'. El programa ghostscript está en el paquete ghostscript*.rmp, y el programa gv en el paquete gv*.rpm de RedHat Linux, y se pueden encontar en ControlPanel | Applications | Graphics. El programa gv es mucho más amigable que ghostscript. Los dos programas se pueden utilizar también sobre otras plataformas, como OS/2, Windows 95 y NT, y ver este documento también es esas plataformas. Leerá el documento postscript dando el comando 

                gv howto.ps
                ghostscript howto.ps
ATENCIÓN: Este documento es largo. El total de páginas (en postscript) si se imprime, será aproximadamente de 113.

Puede usted leer el formato HTML utilizando Netscape Navigator, Microsoft Internet Explorer, RedHat Baron Web Browser o cualquier otro de los más de 10 navegadores de internet.

Puede usted leer los formatos latex y Lyx utilizando Lyx, un front end de X-Window para latex.

30. Términos del Copyright

La política de Copyright es la GNU/GPL al igual que para el LDP (Linux Documentation Project). LDP es un proyecto GNU/GPL.

Existen restricciones adicionales: usted debe incluir el nombre del autor, la dirección de correo electrónico y este aviso de Copyright en todas las copias. Si realiza cambios o agregados a este documento deberá consultar a todos los autores del mismo.

AUSENCIA DE RESPONSABILIDAD POR DAÑOS CONSECUENTES. En ningún caso podrán el/los autor/autores del presente documento ser responsabilizados por cualquier clase de daño (incluyendo pero sin limitarse a: daños especiales, incidentales, consecuenciales, personales, pérdida de beneficios comerciales, lucro cesante, pérdida de información comercial, o cualquier otra pérdida pecuniaria) derivadas de la utilización de este documento.

El/Los autor/autores no ofrecen ninguna garantía sobre la adecuación para un fin, utilidad, ausencia de infracción de este documento. Las marcas, compañías y nombres de producto mencionados en este documento son marcas de fábrica o marcas de fábrica registradas de sus respectivos propietarios. Por favor consulte los avisos de copyright individuales de cada producto, marca y compañía que se menciona en este documento. Es su responsabilidad leer y entender los avisos de copyright de las organizaciones/compañías/productos/autores mencionados en este documento antes de utilizar sus respectivas informaciones.

Appendix

31. Appendix A - Syntax of ANSI/ISO SQL 1992 

This file contains a depth-first tree traversal of the BNF
for the  language done at about 27-AUG-1992 11:03:41.64.
The specific version of the BNF included here is:  ANSI-only, SQL2-only.


<SQL terminal character> ::=
      <SQL language character>
    | <SQL embedded language character>

<SQL language character> ::=
      <simple Latin letter>
    | <digit>
    | <SQL special character>

<simple Latin letter> ::=
      <simple Latin upper case letter>
    | <simple Latin lower case letter>

<simple Latin upper case letter> ::=
          A | B | C | D | E | F | G | H | I | J | K | L | M | N | O
    | P | Q | R | S | T | U | V | W | X | Y | Z

<simple Latin lower case letter> ::=
          a | b | c | d | e | f | g | h | i | j | k | l | m | n | o
    | p | q | r | s | t | u | v | w | x | y | z

<digit> ::=
    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<SQL special character> ::=
      <space>
    | <double quote>
    | <percent>
    | <ampersand>
    | <quote>
    | <left paren>
    | <right paren>
    | <asterisk>
    | <plus sign>
    | <comma>
    | <minus sign>
    | <period>
    | <solidus>
    | <colon>
    | <semicolon>
    | <less than operator>
    | <equals operator>
    | <greater than operator>
    | <question mark>
    | <underscore>
    | <vertical bar>

<space> ::= !! <EMPHASIS>(space character in character set in use)

<double quote> ::= "

<percent> ::= %

<ampersand> ::= &

<quote> ::= '

<left paren> ::= (

<right paren> ::= )

<asterisk> ::= *

<plus sign> ::= +

<comma> ::= ,

<minus sign> ::= -

<period> ::= .

<solidus> ::= /

<colon> ::= :

<semicolon> ::= ;

<less than operator> ::= <

<equals operator> ::= =

<greater than operator> ::= >

<question mark> ::= ?

<underscore> ::= _

<vertical bar> ::= |

<SQL embedded language character> ::=
      <left bracket>
    | <right bracket>

<left bracket> ::= [

<right bracket> ::= ]

<token> ::=
      <nondelimiter token>
    | <delimiter token>

<nondelimiter token> ::=
      <regular identifier>
    | <key word>
    | <unsigned numeric literal>
    | <national character string literal>
    | <bit string literal>
    | <hex string literal>

<regular identifier> ::= <identifier body>

<identifier body> ::=
    <identifier start> [ ( <underscore> | <identifier part> )... ]

<identifier start> ::= <EMPHASIS>(!! See the Syntax Rules)

<identifier part> ::=
      <identifier start>
    | <digit>

<key word> ::=
      <reserved word>
    | <non-reserved word>

<reserved word> ::=
      ABSOLUTE | ACTION | ADD | ALL
    | ALLOCATE | ALTER | AND
    | ANY | ARE
    | AS | ASC
    | ASSERTION | AT
    | AUTHORIZATION | AVG
    | BEGIN | BETWEEN | BIT | BIT_LENGTH
    | BOTH | BY
    | CASCADE | CASCADED | CASE | CAST
    | CATALOG
    | CHAR | CHARACTER | CHAR_LENGTH
    | CHARACTER_LENGTH | CHECK | CLOSE | COALESCE
    | COLLATE | COLLATION
    | COLUMN | COMMIT
    | CONNECT
    | CONNECTION | CONSTRAINT
    | CONSTRAINTS | CONTINUE
    | CONVERT | CORRESPONDING | COUNT | CREATE | CROSS
    | CURRENT
    | CURRENT_DATE | CURRENT_TIME
    | CURRENT_TIMESTAMP | CURRENT_USER | CURSOR
    | DATE | DAY | DEALLOCATE | DEC
    | DECIMAL | DECLARE | DEFAULT | DEFERRABLE
    | DEFERRED | DELETE | DESC | DESCRIBE | DESCRIPTOR
    | DIAGNOSTICS
    | DISCONNECT | DISTINCT | DOMAIN | DOUBLE | DROP
    | ELSE | END | END-EXEC | ESCAPE
    | EXCEPT | EXCEPTION
    | EXEC | EXECUTE | EXISTS
    | EXTERNAL | EXTRACT
    | FALSE | FETCH | FIRST | FLOAT | FOR
    | FOREIGN | FOUND | FROM | FULL
    | GET | GLOBAL | GO | GOTO
    | GRANT | GROUP
    | HAVING | HOUR
    | IDENTITY | IMMEDIATE | IN | INDICATOR
    | INITIALLY | INNER | INPUT
    | INSENSITIVE | INSERT | INT | INTEGER | INTERSECT
    | INTERVAL | INTO | IS
    | ISOLATION
    | JOIN
    | KEY
    | LANGUAGE | LAST | LEADING | LEFT
    | LEVEL | LIKE | LOCAL | LOWER
    | MATCH | MAX | MIN | MINUTE | MODULE
    | MONTH
    | NAMES | NATIONAL | NATURAL | NCHAR | NEXT | NO
    | NOT | NULL
    | NULLIF | NUMERIC
    | OCTET_LENGTH | OF
    | ON | ONLY | OPEN | OPTION | OR
    | ORDER | OUTER
    | OUTPUT | OVERLAPS
    | PAD | PARTIAL | POSITION | PRECISION | PREPARE
    | PRESERVE | PRIMARY
    | PRIOR | PRIVILEGES | PROCEDURE | PUBLIC
    | READ | REAL | REFERENCES | RELATIVE | RESTRICT
    | REVOKE | RIGHT
    | ROLLBACK | ROWS
    | SCHEMA | SCROLL | SECOND | SECTION
    | SELECT
    | SESSION | SESSION_USER | SET
    | SIZE | SMALLINT | SOME | SPACE | SQL | SQLCODE
    | SQLERROR | SQLSTATE
    | SUBSTRING | SUM | SYSTEM_USER
    | TABLE | TEMPORARY
    | THEN | TIME | TIMESTAMP
    | TIMEZONE_HOUR | TIMEZONE_MINUTE
    | TO | TRAILING | TRANSACTION
    | TRANSLATE | TRANSLATION | TRIM | TRUE
    | UNION | UNIQUE | UNKNOWN | UPDATE | UPPER | USAGE
    | USER | USING
    | VALUE | VALUES | VARCHAR | VARYING | VIEW
    | WHEN | WHENEVER | WHERE | WITH | WORK | WRITE
    | YEAR
    | ZONE

<non-reserved word> ::=
    
      ADA
    | C | CATALOG_NAME
    | CHARACTER_SET_CATALOG | CHARACTER_SET_NAME
    | CHARACTER_SET_SCHEMA | CLASS_ORIGIN | COBOL | COLLATION_CATALOG
    | COLLATION_NAME | COLLATION_SCHEMA | COLUMN_NAME | COMMAND_FUNCTION
    | COMMITTED
    | CONDITION_NUMBER | CONNECTION_NAME | CONSTRAINT_CATALOG | CONSTRAINT_NAME
    | CONSTRAINT_SCHEMA | CURSOR_NAME
    | DATA | DATETIME_INTERVAL_CODE
    | DATETIME_INTERVAL_PRECISION | DYNAMIC_FUNCTION
    | FORTRAN
    | LENGTH
    | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | MORE | MUMPS
    | NAME | NULLABLE | NUMBER
    | PASCAL | PLI
    | REPEATABLE | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE
    | ROW_COUNT
    | SCALE | SCHEMA_NAME | SERIALIZABLE | SERVER_NAME | SUBCLASS_ORIGIN
    | TABLE_NAME | TYPE
    | UNCOMMITTED | UNNAMED

<unsigned numeric literal> ::=
      <exact numeric literal>
    | <approximate numeric literal>

<exact numeric literal> ::=
      <unsigned integer> [ <period> [ <unsigned integer> ] ]
    | <period> <unsigned integer>

<unsigned integer> ::= <digit>...

<approximate numeric literal> ::= <mantissa> E <exponent>

<mantissa> ::= <exact numeric literal>

<exponent> ::= <signed integer>

<signed integer> ::= [ <sign> ] <unsigned integer>

<sign> ::= <plus sign> | <minus sign>

<national character string literal> ::=
    N <quote> [ <character representation>... ] <quote>
      [ ( <separator>... <quote> [ <character representation>... ] <quote> )... ]

<character representation> ::=
      <nonquote character>
    | <quote symbol>

<nonquote character> ::= !! <EMPHASIS>(See the Syntax Rules.)

<quote symbol> ::= <quote><quote>

<separator> ::= ( <comment> | <space> | <newline> )...

<comment> ::=
    <comment introducer> [ <comment character>... ] <newline>

<comment introducer> ::= <minus sign><minus sign>[<minus sign>...]

<comment character> ::=
      <nonquote character>
    | <quote>

<newline> ::= !! <EMPHASIS>(implementation-defined end-of-line indicator)

<bit string literal> ::=
    B <quote> [ <bit>... ] <quote>
      [ ( <separator>... <quote> [ <bit>... ] <quote> )... ]

<bit> ::= 0 | 1

<hex string literal> ::=
    X <quote> [ <hexit>... ] <quote>
      [ ( <separator>... <quote> [ <hexit>... ] <quote> )... ]

<hexit> ::= <digit> | A | B | C | D | E | F | a | b | c | d | e | f

<delimiter token> ::=
      <character string literal>
    | <date string>
    | <time string>
    | <timestamp string>
    | <interval string>
    | <delimited identifier>
    | <SQL special character>
    | <not equals operator>
    | <greater than or equals operator>
    | <less than or equals operator>
    | <concatenation operator>
    | <double period>
    | <left bracket>
    | <right bracket>

<character string literal> ::=
    [ <introducer><character set specification> ]
    <quote> [ <character representation>... ] <quote>
      [ ( <separator>... <quote> [ <character representation>... ] <quote> )... ]

<introducer> ::= <underscore>

<character set specification> ::=
      <standard character repertoire name>
    | <implementation-defined character repertoire name>
    | <user-defined character repertoire name>
    | <standard universal character form-of-use name>
    | <implementation-defined universal character form-of-use name>

<standard character repertoire name> ::= <character set name>

<character set name> ::= [ <schema name> <period> ]
      <SQL language identifier>

<schema name> ::=
    [ <catalog name> <period> ] <unqualified schema name>

<catalog name> ::= <identifier>

<identifier> ::=
    [ <introducer><character set specification> ] <actual identifier>

<actual identifier> ::=
      <regular identifier>
    | <delimited identifier>

<delimited identifier> ::=
    <double quote> <delimited identifier body> <double quote>

<delimited identifier body> ::= <delimited identifier part>...

<delimited identifier part> ::=
      <nondoublequote character>
    | <doublequote symbol>

<nondoublequote character> ::= <EMPHASIS>(!! See the Syntax Rules)

<doublequote symbol> ::= <double quote><double quote>

<unqualified schema name> ::= <identifier>

<SQL language identifier> ::=
    <SQL language identifier start>
       [ ( <underscore> | <SQL language identifier part> )... ]

<SQL language identifier start> ::= <simple Latin letter>

<SQL language identifier part> ::=
      <simple Latin letter>
    | <digit>

<implementation-defined character repertoire name> ::=
    <character set name>

<user-defined character repertoire name> ::= <character set name>

<standard universal character form-of-use name> ::=
    <character set name>

<implementation-defined universal character form-of-use name> ::=
    <character set name>

<date string> ::=
    <quote> <date value> <quote>

<date value> ::=
    <years value> <minus sign> <months value>
        <minus sign> <days value>

<years value> ::= <datetime value>

<datetime value> ::= <unsigned integer>

<months value> ::= <datetime value>

<days value> ::= <datetime value>

<time string> ::=
    <quote> <time value> [ <time zone interval> ] <quote>

<time value> ::=
    <hours value> <colon> <minutes value> <colon> <seconds value>

<hours value> ::= <datetime value>

<minutes value> ::= <datetime value>

<seconds value> ::=
      <seconds integer value> [ <period> [ <seconds fraction> ] ]

<seconds integer value> ::= <unsigned integer>

<seconds fraction> ::= <unsigned integer>

<time zone interval> ::=
    <sign> <hours value> <colon> <minutes value>

<timestamp string> ::=
    <quote> <date value> <space> <time value>
        [ <time zone interval> ] <quote>

<interval string> ::=
    <quote> ( <year-month literal> | <day-time literal> ) <quote>

<year-month literal> ::=
      <years value>
    | [ <years value> <minus sign> ] <months value>

<day-time literal> ::=
      <day-time interval>
    | <time interval>

<day-time interval> ::=
    <days value>
      [ <space> <hours value> [ <colon> <minutes value>
        [ <colon> <seconds value> ] ] ]

<time interval> ::=
      <hours value> [ <colon> <minutes value> [ <colon> <seconds value> ] ]
    | <minutes value> [ <colon> <seconds value> ]
    | <seconds value>

<not equals operator> ::= <>

<greater than or equals operator> ::= >=

<less than or equals operator> ::= <=

<concatenation operator> ::= ||

<double period> ::= ..

<module> ::=
    <module name clause>
    <language clause>
    <module authorization clause>
    [ <temporary table declaration>... ]
    <module contents>...

<module name clause> ::=
    MODULE [ <module name> ]
      [ <module character set specification> ]

<module name> ::= <identifier>

<module character set specification> ::=
    NAMES ARE <character set specification>

<language clause> ::=
    LANGUAGE <language name>

<language name> ::=
    ADA | C | COBOL | FORTRAN | MUMPS | PASCAL | PLI

<module authorization clause> ::=
      SCHEMA <schema name>
    | AUTHORIZATION <module authorization identifier>
    | SCHEMA <schema name>
          AUTHORIZATION <module authorization identifier>

<module authorization identifier> ::=
    <authorization identifier>

<authorization identifier> ::= <identifier>

<temporary table declaration> ::=
    DECLARE LOCAL TEMPORARY TABLE
        <qualified local table name>
      <table element list>
      [ ON COMMIT ( PRESERVE | DELETE ) ROWS ]

<qualified local table name> ::=
    MODULE <period> <local table name>

<local table name> ::= <qualified identifier>

<qualified identifier> ::= <identifier>

<table element list> ::=
      <left paren> <table element> [ ( <comma> <table element> )... ] <right paren>

<table element> ::=
      <column definition>
    | <table constraint definition>

<column definition> ::=
    <column name> ( <data type> | <domain name> )
    [ <default clause> ]
    [ <column constraint definition>... ]
    [ <collate clause> ]

<column name> ::= <identifier>

<data type> ::=
      <character string type>
           [ CHARACTER SET <character set specification> ]
    | <national character string type>
    | <bit string type>
    | <numeric type>
    | <datetime type>
    | <interval type>

<character string type> ::=
      CHARACTER [ <left paren> <length> <right paren> ]
    | CHAR [ <left paren> <length> <right paren> ]
    | CHARACTER VARYING <left paren> <length> <right paren>
    | CHAR VARYING <left paren> <length> <right paren>
    | VARCHAR <left paren> <length> <right paren>

<length> ::= <unsigned integer>

<national character string type> ::=
      NATIONAL CHARACTER [ <left paren> <length> <right paren> ]
    | NATIONAL CHAR [ <left paren> <length> <right paren> ]
    | NCHAR [ <left paren> <length> <right paren> ]
    | NATIONAL CHARACTER VARYING <left paren> <length> <right paren>
    | NATIONAL CHAR VARYING <left paren> <length> <right paren>
    | NCHAR VARYING <left paren> <length> <right paren>

<bit string type> ::=
      BIT [ <left paren> <length> <right paren> ]
    | BIT VARYING <left paren> <length> <right paren>

<numeric type> ::=
      <exact numeric type>
    | <approximate numeric type>

<exact numeric type> ::=
      NUMERIC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
    | DECIMAL [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
    | DEC [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
    | INTEGER
    | INT
    | SMALLINT

<precision> ::= <unsigned integer>

<scale> ::= <unsigned integer>

<approximate numeric type> ::=
      FLOAT [ <left paren> <precision> <right paren> ]
    | REAL
    | DOUBLE PRECISION

<datetime type> ::=
      DATE
    | TIME [ <left paren> <time precision> <right paren> ]
          [ WITH TIME ZONE ]
    | TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]
          [ WITH TIME ZONE ]

<time precision> ::= <time fractional seconds precision>

<time fractional seconds precision> ::= <unsigned integer>

<timestamp precision> ::= <time fractional seconds precision>

<interval type> ::= INTERVAL <interval qualifier>

<interval qualifier> ::=
      <start field> TO <end field>
    | <single datetime field>

<start field> ::=
    <non-second datetime field>
        [ <left paren> <interval leading field precision> <right paren> ]

<non-second datetime field> ::= YEAR | MONTH | DAY | HOUR
    | MINUTE

<interval leading field precision> ::= <unsigned integer>

<end field> ::=
      <non-second datetime field>
    | SECOND [ <left paren> <interval fractional seconds precision> <right paren> ]

<interval fractional seconds precision> ::= <unsigned integer>

<single datetime field> ::=
      <non-second datetime field>
          [ <left paren> <interval leading field precision> <right paren> ]
    | SECOND [ <left paren> <interval leading field precision>
          [ <comma> <interval fractional seconds precision> ] <right paren> ]

<domain name> ::= <qualified name>

<qualified name> ::=
    [ <schema name> <period> ] <qualified identifier>

<default clause> ::=
      DEFAULT <default option>

<default option> ::=
      <literal>
    | <datetime value function>
    | USER
    | CURRENT_USER
    | SESSION_USER
    | SYSTEM_USER
    | NULL

<literal> ::=
      <signed numeric literal>
    | <general literal>

<signed numeric literal> ::=
    [ <sign> ] <unsigned numeric literal>

<general literal> ::=
      <character string literal>
    | <national character string literal>
    | <bit string literal>
    | <hex string literal>
    | <datetime literal>
    | <interval literal>

<datetime literal> ::=
      <date literal>
    | <time literal>
    | <timestamp literal>

<date literal> ::=
    DATE <date string>

<time literal> ::=
    TIME <time string>

<timestamp literal> ::=
    TIMESTAMP <timestamp string>

<interval literal> ::=
    INTERVAL [ <sign> ] <interval string> <interval qualifier>

<datetime value function> ::=
      <current date value function>
    | <current time value function>
    | <current timestamp value function>

<current date value function> ::= CURRENT_DATE

<current time value function> ::=
      CURRENT_TIME [ <left paren> <time precision> <right paren> ]

<current timestamp value function> ::=
      CURRENT_TIMESTAMP [ <left paren> <timestamp precision> <right paren> ]

<column constraint definition> ::=
    [ <constraint name definition> ]
    <column constraint>
      [ <constraint attributes> ]

<constraint name definition> ::= CONSTRAINT <constraint name>

<constraint name> ::= <qualified name>

<column constraint> ::=
      NOT NULL
    | <unique specification>
    | <references specification>
    | <check constraint definition>

<unique specification> ::=
    UNIQUE | PRIMARY KEY

<references specification> ::=
    REFERENCES <referenced table and columns>
      [ MATCH <match type> ]
      [ <referential triggered action> ]

<referenced table and columns> ::=
     <table name> [ <left paren> <reference column list> <right paren> ]

<table name> ::=
      <qualified name>
    | <qualified local table name>

<reference column list> ::= <column name list>

<column name list> ::=
    <column name> [ ( <comma> <column name> )... ]

<match type> ::=
      FULL
    | PARTIAL

<referential triggered action> ::=
      <update rule> [ <delete rule> ]
    | <delete rule> [ <update rule> ]

<update rule> ::= ON UPDATE <referential action>

<referential action> ::=
      CASCADE
    | SET NULL
    | SET DEFAULT
    | NO ACTION

<delete rule> ::= ON DELETE <referential action>

<check constraint definition> ::=
    CHECK
        <left paren> <search condition> <right paren>

<search condition> ::=
      <boolean term>
    | <search condition> OR <boolean term>

<boolean term> ::=
      <boolean factor>
    | <boolean term> AND <boolean factor>

<boolean factor> ::=
    [ NOT ] <boolean test>

<boolean test> ::=
    <boolean primary> [ IS [ NOT ]
          <truth value> ]

<boolean primary> ::=
      <predicate>
    | <left paren> <search condition> <right paren>

<predicate> ::=
      <comparison predicate>
    | <between predicate>
    | <in predicate>
    | <like predicate>
    | <null predicate>
    | <quantified comparison predicate>
    | <exists predicate>
    | <unique predicate>
    | <match predicate>
    | <overlaps predicate>

<comparison predicate> ::=
    <row value constructor> <comp op>
        <row value constructor>

<row value constructor> ::=
       <row value constructor element>
    | <left paren> <row value constructor list> <right paren>
    | <row subquery>

<row value constructor element> ::=
      <value expression>
    | <null specification>
    | <default specification>

<value expression> ::=
      <numeric value expression>
    | <string value expression>
    | <datetime value expression>
    | <interval value expression>

<numeric value expression> ::=
      <term>
    | <numeric value expression> <plus sign> <term>
    | <numeric value expression> <minus sign> <term>

<term> ::=
      <factor>
    | <term> <asterisk> <factor>
    | <term> <solidus> <factor>

<factor> ::=
    [ <sign> ] <numeric primary>

<numeric primary> ::=
      <value expression primary>
    | <numeric value function>

<value expression primary> ::=
      <unsigned value specification>
    | <column reference>
    | <set function specification>
    | <scalar subquery>
    | <case expression>
    | <left paren> <value expression> <right paren>
    | <cast specification>

<unsigned value specification> ::=
      <unsigned literal>
    | <general value specification>

<unsigned literal> ::=
      <unsigned numeric literal>
    | <general literal>

<general value specification> ::=
      <parameter specification>
    | <dynamic parameter specification>
    | <variable specification>
    | USER
    | CURRENT_USER
    | SESSION_USER
    | SYSTEM_USER
    | VALUE

<parameter specification> ::=
    <parameter name> [ <indicator parameter> ]

<parameter name> ::= <colon> <identifier>

<indicator parameter> ::=
    [ INDICATOR ] <parameter name>

<dynamic parameter specification> ::= <question mark>

<variable specification> ::=
    <embedded variable name> [ <indicator variable> ]

<embedded variable name> ::=
    <colon><host identifier>

<host identifier> ::=
      <Ada host identifier>
    | <C host identifier>
    | <COBOL host identifier>
    | <Fortran host identifier>
    | <MUMPS host identifier>
    | <Pascal host identifier>
    | <PL/I host identifier>

<Ada host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<C host identifier> ::=
    !! <EMPHASIS>(See the Syntax Rules.)

<COBOL host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<Fortran host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<MUMPS host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<Pascal host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<PL/I host identifier> ::= !! <EMPHASIS>(See the Syntax Rules.)

<indicator variable> ::=
    [ INDICATOR ] <embedded variable name>

<column reference> ::= [ <qualifier> <period> ] <column name>

<qualifier> ::=
      <table name>
    | <correlation name>

<correlation name> ::= <identifier>

<set function specification> ::=
      COUNT <left paren> <asterisk> <right paren>
    | <general set function>

<general set function> ::=
      <set function type>
          <left paren> [ <set quantifier> ] <value expression> <right paren>

<set function type> ::=
    AVG | MAX | MIN | SUM | COUNT

<set quantifier> ::= DISTINCT | ALL

<scalar subquery> ::= <subquery>

<subquery> ::= <left paren> <query expression> <right paren>

<query expression> ::=
      <non-join query expression>
    | <joined table>

<non-join query expression> ::=
      <non-join query term>
    | <query expression> UNION  [ ALL ]
          [ <corresponding spec> ] <query term>
    | <query expression> EXCEPT [ ALL ]
          [ <corresponding spec> ] <query term>

<non-join query term> ::=
      <non-join query primary>
    | <query term> INTERSECT [ ALL ]
          [ <corresponding spec> ] <query primary>

<non-join query primary> ::=
      <simple table>
    | <left paren> <non-join query expression> <right paren>

<simple table> ::=
      <query specification>
    | <table value constructor>
    | <explicit table>

<query specification> ::=
    SELECT [ <set quantifier> ] <select list> <table expression>

<select list> ::=
      <asterisk>
    | <select sublist> [ ( <comma> <select sublist> )... ]

<select sublist> ::=
      <derived column>
    | <qualifier> <period> <asterisk>

<derived column> ::= <value expression> [ <as clause> ]

<as clause> ::= [ AS ] <column name>

<table expression> ::=
    <from clause>
    [ <where clause> ]
    [ <group by clause> ]
    [ <having clause> ]

<from clause> ::= FROM <table reference>
    [ ( <comma> <table reference> )... ]

<table reference> ::=
      <table name> [ [ AS ] <correlation name>
          [ <left paren> <derived column list> <right paren> ] ]
    | <derived table> [ AS ] <correlation name>
          [ <left paren> <derived column list> <right paren> ]
    | <joined table>

<derived column list> ::= <column name list>

<derived table> ::= <table subquery>

<table subquery> ::= <subquery>

<joined table> ::=
      <cross join>
    | <qualified join>
    | <left paren> <joined table> <right paren>

<cross join> ::=
    <table reference> CROSS JOIN <table reference>

<qualified join> ::=
    <table reference> [ NATURAL ] [ <join type> ] JOIN
      <table reference> [ <join specification> ]

<join type> ::=
      INNER
    | <outer join type> [ OUTER ]
    | UNION

<outer join type> ::=
      LEFT
    | RIGHT
    | FULL

<join specification> ::=
      <join condition>
    | <named columns join>

<join condition> ::= ON <search condition>

<named columns join> ::=
    USING <left paren> <join column list> <right paren>

<join column list> ::= <column name list>

<where clause> ::= WHERE <search condition>

<group by clause> ::=
    GROUP BY <grouping column reference list>

<grouping column reference list> ::=
    <grouping column reference>
        [ ( <comma> <grouping column reference> )... ]

<grouping column reference> ::=
    <column reference> [ <collate clause> ]

<collate clause> ::= COLLATE <collation name>

<collation name> ::= <qualified name>

<having clause> ::= HAVING <search condition>

<table value constructor> ::=
    VALUES <table value constructor list>

<table value constructor list> ::=
    <row value constructor> [ ( <comma> <row value constructor> )... ]

<explicit table> ::= TABLE <table name>

<query term> ::=
      <non-join query term>
    | <joined table>

<corresponding spec> ::=
    CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]

<corresponding column list> ::= <column name list>

<query primary> ::=
      <non-join query primary>
    | <joined table>

<case expression> ::=
      <case abbreviation>
    | <case specification>

<case abbreviation> ::=
      NULLIF <left paren> <value expression> <comma>
            <value expression> <right paren>
    | COALESCE <left paren> <value expression>
            ( <comma> <value expression> )... <right paren>

<case specification> ::=
      <simple case>
    | <searched case>

<simple case> ::=
    CASE <case operand>
      <simple when clause>...
      [ <else clause> ]
    END

<case operand> ::= <value expression>

<simple when clause> ::= WHEN <when operand> THEN <result>

<when operand> ::= <value expression>

<result> ::= <result expression> | NULL

<result expression> ::= <value expression>

<else clause> ::= ELSE <result>

<searched case> ::=
    CASE
      <searched when clause>...
      [ <else clause> ]
    END

<searched when clause> ::= WHEN <search condition> THEN <result>

<cast specification> ::=
    CAST <left paren> <cast operand> AS
        <cast target> <right paren>

<cast operand> ::=
      <value expression>
    | NULL

<cast target> ::=
      <domain name>
    | <data type>

<numeric value function> ::=
      <position expression>
    | <extract expression>
    | <length expression>

<position expression> ::=
    POSITION <left paren> <character value expression>
        IN <character value expression> <right paren>

<character value expression> ::=
      <concatenation>
    | <character factor>

<concatenation> ::=
    <character value expression> <concatenation operator>
        <character factor>

<character factor> ::=
    <character primary> [ <collate clause> ]

<character primary> ::=
      <value expression primary>
    | <string value function>

<string value function> ::=
      <character value function>
    | <bit value function>

<character value function> ::=
      <character substring function>
    | <fold>
    | <form-of-use conversion>
    | <character translation>
    | <trim function>

<character substring function> ::=
    SUBSTRING <left paren> <character value expression> FROM <start position>
                [ FOR <string length> ] <right paren>

<start position> ::= <numeric value expression>

<string length> ::= <numeric value expression>

<fold> ::= ( UPPER | LOWER )
     <left paren> <character value expression> <right paren>

<form-of-use conversion> ::=
    CONVERT <left paren> <character value expression>
        USING <form-of-use conversion name> <right paren>

<form-of-use conversion name> ::= <qualified name>

<character translation> ::=
    TRANSLATE <left paren> <character value expression>
        USING <translation name> <right paren>

<translation name> ::= <qualified name>

<trim function> ::=
    TRIM <left paren> <trim operands> <right paren>

<trim operands> ::=
    [ [ <trim specification> ] [ <trim character> ] FROM ] <trim source>

<trim specification> ::=
      LEADING
    | TRAILING
    | BOTH

<trim character> ::= <character value expression>

<trim source> ::= <character value expression>

<bit value function> ::=
    <bit substring function>

<bit substring function> ::=
    SUBSTRING <left paren> <bit value expression> FROM <start position>
        [ FOR <string length> ] <right paren>

<bit value expression> ::=
      <bit concatenation>
    | <bit factor>

<bit concatenation> ::=
    <bit value expression> <concatenation operator> <bit factor>

<bit factor> ::= <bit primary>

<bit primary> ::=
      <value expression primary>
    | <string value function>

<extract expression> ::=
    EXTRACT <left paren> <extract field>
        FROM <extract source> <right paren>

<extract field> ::=
      <datetime field>
    | <time zone field>

<datetime field> ::=
      <non-second datetime field>
    | SECOND

<time zone field> ::=
      TIMEZONE_HOUR
    | TIMEZONE_MINUTE

<extract source> ::=
      <datetime value expression>
    | <interval value expression>

<datetime value expression> ::=
      <datetime term>
    | <interval value expression> <plus sign> <datetime term>
    | <datetime value expression> <plus sign> <interval term>
    | <datetime value expression> <minus sign> <interval term>

<interval term> ::=
      <interval factor>
    | <interval term 2> <asterisk> <factor>
    | <interval term 2> <solidus> <factor>
    | <term> <asterisk> <interval factor>

<interval factor> ::=
    [ <sign> ] <interval primary>

<interval primary> ::=
      <value expression primary> [ <interval qualifier> ]

<interval term 2> ::= <interval term>

<interval value expression> ::=
      <interval term>
    | <interval value expression 1> <plus sign> <interval term 1>
    | <interval value expression 1> <minus sign> <interval term 1>
    | <left paren> <datetime value expression> <minus sign>
          <datetime term> <right paren> <interval qualifier>

<interval value expression 1> ::= <interval value expression>

<interval term 1> ::= <interval term>

<datetime term> ::=
      <datetime factor>

<datetime factor> ::=
      <datetime primary> [ <time zone> ]

<datetime primary> ::=
      <value expression primary>
    | <datetime value function>

<time zone> ::=
    AT <time zone specifier>

<time zone specifier> ::=
      LOCAL
    | TIME ZONE <interval value expression>

<length expression> ::=
      <char length expression>
    | <octet length expression>
    | <bit length expression>

<char length expression> ::=
    ( CHAR_LENGTH | CHARACTER_LENGTH )
        <left paren> <string value expression> <right paren>

<string value expression> ::=
      <character value expression>
    | <bit value expression>

<octet length expression> ::=
    OCTET_LENGTH <left paren> <string value expression> <right paren>

<bit length expression> ::=
    BIT_LENGTH <left paren> <string value expression> <right paren>

<null specification> ::=
    NULL

<default specification> ::=
    DEFAULT

<row value constructor list> ::=
    <row value constructor element>
        [ ( <comma> <row value constructor element> )... ]

<row subquery> ::= <subquery>

<comp op> ::=
      <equals operator>
    | <not equals operator>
    | <less than operator>
    | <greater than operator>
    | <less than or equals operator>
    | <greater than or equals operator>

<between predicate> ::=
    <row value constructor> [ NOT ] BETWEEN
      <row value constructor> AND <row value constructor>

<in predicate> ::=
    <row value constructor>
      [ NOT ] IN <in predicate value>

<in predicate value> ::=
      <table subquery>
    | <left paren> <in value list> <right paren>

<in value list> ::=
    <value expression> ( <comma> <value expression> )...

<like predicate> ::=
    <match value> [ NOT ] LIKE <pattern>
      [ ESCAPE <escape character> ]

<match value> ::= <character value expression>

<pattern> ::= <character value expression>

<escape character> ::= <character value expression>

<null predicate> ::= <row value constructor>
    IS [ NOT ] NULL

<quantified comparison predicate> ::=
    <row value constructor> <comp op> <quantifier> <table subquery>

<quantifier> ::= <all> | <some>

<all> ::= ALL

<some> ::= SOME | ANY

<exists predicate> ::= EXISTS <table subquery>

<unique predicate> ::= UNIQUE <table subquery>

<match predicate> ::=
    <row value constructor> MATCH [ UNIQUE ]
        [ PARTIAL | FULL ] <table subquery>

<overlaps predicate> ::=
    <row value constructor 1> OVERLAPS <row value constructor 2>

<row value constructor 1> ::= <row value constructor>

<row value constructor 2> ::= <row value constructor>

<truth value> ::=
      TRUE
    | FALSE
    | UNKNOWN

<constraint attributes> ::=
      <constraint check time> [ [ NOT ] DEFERRABLE ]
    | [ NOT ] DEFERRABLE [ <constraint check time> ]

<constraint check time> ::=
      INITIALLY DEFERRED
    | INITIALLY IMMEDIATE

<table constraint definition> ::=
    [ <constraint name definition> ]
    <table constraint> [ <constraint attributes> ]

<table constraint> ::=
      <unique constraint definition>
    | <referential constraint definition>
    | <check constraint definition>

<unique constraint definition> ::=
            <unique specification> even in SQL3)
    <unique specification>
      <left paren> <unique column list> <right paren>

<unique column list> ::= <column name list>

<referential constraint definition> ::=
    FOREIGN KEY
        <left paren> <referencing columns> <right paren>
      <references specification>

<referencing columns> ::=
    <reference column list>

<module contents> ::=
      <declare cursor>
    | <dynamic declare cursor>
    | <procedure>

<declare cursor> ::=
    DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR
      FOR <cursor specification>

<cursor name> ::= <identifier>

<cursor specification> ::=
    <query expression> [ <order by clause> ]
      [ <updatability clause> ]

<order by clause> ::=
    ORDER BY <sort specification list>

<sort specification list> ::=
    <sort specification> [ ( <comma> <sort specification> )... ]

<sort specification> ::=
    <sort key> [ <collate clause> ] [ <ordering specification> ]

<sort key> ::=
      <column name>
    | <unsigned integer>

<ordering specification> ::= ASC | DESC

<updatability clause> ::=
    FOR
        ( READ ONLY |
          UPDATE [ OF <column name list> ] )

<dynamic declare cursor> ::=
    DECLARE <cursor name> [ INSENSITIVE ] [ SCROLL ] CURSOR
        FOR <statement name>

<statement name> ::= <identifier>

<procedure> ::=
    PROCEDURE <procedure name>
        <parameter declaration list> <semicolon>
      <SQL procedure statement> <semicolon>

<procedure name> ::= <identifier>

<parameter declaration list> ::=
      <left paren> <parameter declaration>
          [ ( <comma> <parameter declaration> )... ] <right paren>
    | <parameter declaration>...

<parameter declaration> ::=
      <parameter name> <data type>
    | <status parameter>

<status parameter> ::=
    SQLCODE | SQLSTATE

<SQL procedure statement> ::=
      <SQL schema statement>
    | <SQL data statement>
    | <SQL transaction statement>
    | <SQL connection statement>
    | <SQL session statement>
    | <SQL dynamic statement>
    | <SQL diagnostics statement>

<SQL schema statement> ::=
      <SQL schema definition statement>
    | <SQL schema manipulation statement>

<SQL schema definition statement> ::=
      <schema definition>
    | <table definition>
    | <view definition>
    | <grant statement>
    | <domain definition>
    | <character set definition>
    | <collation definition>
    | <translation definition>
    | <assertion definition>

<schema definition> ::=
    CREATE SCHEMA <schema name clause>
      [ <schema character set specification> ]
      [ <schema element>... ]

<schema name clause> ::=
      <schema name>
    | AUTHORIZATION <schema authorization identifier>
    | <schema name> AUTHORIZATION
          <schema authorization identifier>

<schema authorization identifier> ::=
    <authorization identifier>

<schema character set specification> ::=
    DEFAULT CHARACTER
        SET <character set specification>

<schema element> ::=
      <domain definition>
    | <table definition>
    | <view definition>
    | <grant statement>
    | <assertion definition>
    | <character set definition>
    | <collation definition>
    | <translation definition>

<domain definition> ::=
    CREATE DOMAIN <domain name>
        [ AS ] <data type>
      [ <default clause> ]
      [ <domain constraint>... ]
      [ <collate clause> ]

<domain constraint> ::=
    [ <constraint name definition> ]
    <check constraint definition> [ <constraint attributes> ]

<table definition> ::=
    CREATE [ ( GLOBAL | LOCAL ) TEMPORARY ] TABLE
        <table name>
      <table element list>
      [ ON COMMIT ( DELETE | PRESERVE ) ROWS ]

<view definition> ::=
    CREATE VIEW <table name> [ <left paren> <view column list>
                                  <right paren> ]
      AS <query expression>
      [ WITH [ <levels clause> ] CHECK OPTION ]

<view column list> ::= <column name list>

<levels clause> ::=
    CASCADED | LOCAL

<grant statement> ::=
   GRANT <privileges> ON <object name>
     TO <grantee> [ ( <comma> <grantee> )... ]
       [ WITH GRANT OPTION ]

<privileges> ::=
      ALL PRIVILEGES
    | <action list>

<action list> ::= <action> [ ( <comma> <action> )... ]

<action> ::=
      SELECT
    | DELETE
    | INSERT [ <left paren> <privilege column list> <right paren> ]
    | UPDATE [ <left paren> <privilege column list> <right paren> ]
    | REFERENCES [ <left paren> <privilege column list> <right paren> ]
    | USAGE

<privilege column list> ::= <column name list>

<object name> ::=
      [ TABLE ] <table name>
    | DOMAIN <domain name>
    | COLLATION <collation name>
    | CHARACTER SET <character set name>
    | TRANSLATION <translation name>

<grantee> ::=
      PUBLIC
    | <authorization identifier>

<assertion definition> ::=
    CREATE ASSERTION <constraint name> <assertion check>
      [ <constraint attributes> ]

<assertion check> ::=
    CHECK
        <left paren> <search condition> <right paren>

<character set definition> ::=
    CREATE CHARACTER SET <character set name>
        [ AS ]
      <character set source>
      [ <collate clause> | <limited collation definition> ]

<character set source> ::=
      GET <existing character set name>

<existing character set name> ::=
      <standard character repertoire name>
    | <implementation-defined character repertoire name>
    | <schema character set name>

<schema character set name> ::= <character set name>

<limited collation definition> ::=
    COLLATION FROM <collation source>

<collation source> ::=
      <collating sequence definition>
    | <translation collation>

<collating sequence definition> ::=
      <external collation>
    | <schema collation name>
    | DESC <left paren> <collation name> <right paren>
    | DEFAULT

<external collation> ::=
    EXTERNAL <left paren> <quote> <external collation name> <quote> <right paren>

<external collation name> ::=
      <standard collation name>
    | <implementation-defined collation name>

<standard collation name> ::= <collation name>

<implementation-defined collation name> ::= <collation name>

<schema collation name> ::= <collation name>

<translation collation> ::=
    TRANSLATION <translation name>
        [ THEN COLLATION <collation name> ]

<collation definition> ::=
    CREATE COLLATION <collation name> FOR
        <character set specification>
      FROM <collation source>
        [ <pad attribute> ]

<pad attribute> ::=
      NO PAD
    | PAD SPACE

<translation definition> ::=
    CREATE TRANSLATION <translation name>
      FOR <source character set specification>
        TO <target character set specification>
      FROM <translation source>

<source character set specification> ::= <character set specification>

<target character set specification> ::= <character set specification>

<translation source> ::=
      <translation specification>

<translation specification> ::=
      <external translation>
    | IDENTITY
    | <schema translation name>

<external translation> ::=
    EXTERNAL <left paren> <quote> <external translation name> <quote> <right paren>

<external translation name> ::=
      <standard translation name>
    | <implementation-defined translation name>

<standard translation name> ::= <translation name>

<implementation-defined translation name> ::= <translation name>

<schema translation name> ::= <translation name>

<SQL schema manipulation statement> ::=
      <drop schema statement>
    | <alter table statement>
    | <drop table statement>
    | <drop view statement>
    | <revoke statement>
    | <alter domain statement>
    | <drop domain statement>
    | <drop character set statement>
    | <drop collation statement>
    | <drop translation statement>
    | <drop assertion statement>

<drop schema statement> ::=
    DROP SCHEMA <schema name> <drop behavior>

<drop behavior> ::= CASCADE | RESTRICT

<alter table statement> ::=
    ALTER TABLE <table name> <alter table action>

<alter table action> ::=
      <add column definition>
    | <alter column definition>
    | <drop column definition>
    | <add table constraint definition>
    | <drop table constraint definition>

<add column definition> ::=
    ADD [ COLUMN ] <column definition>

<alter column definition> ::=
    ALTER [ COLUMN ] <column name> <alter column action>

<alter column action> ::=
      <set column default clause>
    | <drop column default clause>

<set column default clause> ::=
    SET <default clause>

<drop column default clause> ::=
    DROP DEFAULT

<drop column definition> ::=
    DROP [ COLUMN ] <column name> <drop behavior>

<add table constraint definition> ::=
    ADD <table constraint definition>

<drop table constraint definition> ::=
    DROP CONSTRAINT <constraint name> <drop behavior>

<drop table statement> ::=
    DROP TABLE <table name> <drop behavior>

<drop view statement> ::=
    DROP VIEW <table name> <drop behavior>

<revoke statement> ::=
    REVOKE [ GRANT OPTION FOR ]
        <privileges>
        ON <object name>
      FROM <grantee> [ ( <comma> <grantee> )... ] <drop behavior>

<alter domain statement> ::=
    ALTER DOMAIN <domain name> <alter domain action>

<alter domain action> ::=
      <set domain default clause>
    | <drop domain default clause>
    | <add domain constraint definition>
    | <drop domain constraint definition>

<set domain default clause> ::= SET <default clause>

<drop domain default clause> ::= DROP DEFAULT

<add domain constraint definition> ::=
    ADD <domain constraint>

<drop domain constraint definition> ::=
    DROP CONSTRAINT <constraint name>

<drop domain statement> ::=
    DROP DOMAIN <domain name> <drop behavior>

<drop character set statement> ::=
    DROP CHARACTER SET <character set name>

<drop collation statement> ::=
    DROP COLLATION <collation name>

<drop translation statement> ::=
    DROP TRANSLATION <translation name>

<drop assertion statement> ::=
    DROP ASSERTION <constraint name>

<SQL data statement> ::=
      <open statement>
    | <fetch statement>
    | <close statement>
    | <select statement: single row>
    | <SQL data change statement>

<open statement> ::=
    OPEN <cursor name>

<fetch statement> ::=
    FETCH [ [ <fetch orientation> ] FROM ]
      <cursor name> INTO <fetch target list>

<fetch orientation> ::=
      NEXT
    | PRIOR
    | FIRST
    | LAST
    | ( ABSOLUTE | RELATIVE ) <simple value specification>

<simple value specification> ::=
      <parameter name>
    | <embedded variable name>
    | <literal>

<fetch target list> ::=
    <target specification> [ ( <comma> <target specification> )... ]

<target specification> ::=
      <parameter specification>
    | <variable specification>

<close statement> ::=
    CLOSE <cursor name>

<select statement: single row> ::=
    SELECT [ <set quantifier> ] <select list>
      INTO <select target list>
        <table expression>

<select target list> ::=
    <target specification> [ ( <comma> <target specification> )... ]

<SQL data change statement> ::=
      <delete statement: positioned>
    | <delete statement: searched>
    | <insert statement>
    | <update statement: positioned>
    | <update statement: searched>

<delete statement: positioned> ::=
    DELETE FROM <table name>
      WHERE CURRENT OF <cursor name>

<delete statement: searched> ::=
    DELETE FROM <table name>
      [ WHERE <search condition> ]

<insert statement> ::=
    INSERT INTO <table name>
      <insert columns and source>

<insert columns and source> ::=
      [ <left paren> <insert column list> <right paren> ]
            <query expression>
    | DEFAULT VALUES

<insert column list> ::= <column name list>

<update statement: positioned> ::=
    UPDATE <table name>
      SET <set clause list>
        WHERE CURRENT OF <cursor name>

<set clause list> ::=
    <set clause> [ ( <comma> <set clause> )... ]

<set clause> ::=
    <object column> <equals operator> <update source>

<object column> ::= <column name>

<update source> ::=
      <value expression>
    | <null specification>
    | DEFAULT

<update statement: searched> ::=
    UPDATE <table name>
      SET <set clause list>
      [ WHERE <search condition> ]

<SQL transaction statement> ::=
      <set transaction statement>
    | <set constraints mode statement>
    | <commit statement>
    | <rollback statement>

<set transaction statement> ::=
    SET TRANSACTION <transaction mode>
        [ ( <comma> <transaction mode> )... ]

<transaction mode> ::=
      <isolation level>
    | <transaction access mode>
    | <diagnostics size>

<isolation level> ::=
    ISOLATION LEVEL <level of isolation>

<level of isolation> ::=
      READ UNCOMMITTED
    | READ COMMITTED
    | REPEATABLE READ
    | SERIALIZABLE

<transaction access mode> ::=
      READ ONLY
    | READ WRITE

<diagnostics size> ::=
    DIAGNOSTICS SIZE <number of conditions>

<number of conditions> ::= <simple value specification>

<set constraints mode statement> ::=
    SET CONSTRAINTS <constraint name list>
        ( DEFERRED | IMMEDIATE )

<constraint name list> ::=
      ALL
    | <constraint name> [ ( <comma> <constraint name> )... ]

<commit statement> ::=
    COMMIT [ WORK ]

<rollback statement> ::=
    ROLLBACK [ WORK ]

<SQL connection statement> ::=
      <connect statement>
    | <set connection statement>
    | <disconnect statement>

<connect statement> ::=
    CONNECT TO <connection target>

<connection target> ::=
      <SQL-server name>
        [ AS <connection name> ]
          correspondence with Tony Gordon)
        [ USER <user name> ]
    | DEFAULT

<SQL-server name> ::= <simple value specification>

<connection name> ::= <simple value specification>

<user name> ::= <simple value specification>

<set connection statement> ::=
    SET CONNECTION <connection object>

<connection object> ::=
      DEFAULT
    | <connection name>

<disconnect statement> ::=
    DISCONNECT <disconnect object>

<disconnect object> ::=
      <connection object>
    | ALL
    | CURRENT

<SQL session statement> ::=
      <set catalog statement>
    | <set schema statement>
    | <set names statement>
    | <set session authorization identifier statement>
    | <set local time zone statement>

<set catalog statement> ::=
    SET CATALOG <value specification>

<value specification> ::=
      <literal>
    | <general value specification>

<set schema statement> ::=
    SET SCHEMA <value specification>

<set names statement> ::=
    SET NAMES <value specification>

<set session authorization identifier statement> ::=
    SET SESSION AUTHORIZATION
        <value specification>

<set local time zone statement> ::=
    SET TIME ZONE
        <set time zone value>

<set time zone value> ::=
      <interval value expression>
    | LOCAL

<SQL dynamic statement> ::=
      <system descriptor statement>
    | <prepare statement>
    | <deallocate prepared statement>
    | <describe statement>
    | <execute statement>
    | <execute immediate statement>
    | <SQL dynamic data statement>

<system descriptor statement> ::=
      <allocate descriptor statement>
    | <deallocate descriptor statement>
    | <set descriptor statement>
    | <get descriptor statement>

<allocate descriptor statement> ::=
    ALLOCATE DESCRIPTOR <descriptor name>
       [ WITH MAX <occurrences> ]

<descriptor name> ::=
    [ <scope option> ] <simple value specification>

<scope option> ::=
      GLOBAL
    | LOCAL

<occurrences> ::= <simple value specification>

<deallocate descriptor statement> ::=
    DEALLOCATE DESCRIPTOR <descriptor name>

<set descriptor statement> ::=
    SET DESCRIPTOR <descriptor name>
        <set descriptor information>

<set descriptor information> ::=
      <set count>
    | VALUE <item number>
        <set item information> [ ( <comma> <set item information> )... ]

<set count> ::=
    COUNT <equals operator> <simple value specification 1>

<simple value specification 1> ::= <simple value specification>

<item number> ::= <simple value specification>

<set item information> ::=
    <descriptor item name> <equals operator> <simple value specification 2>

<descriptor item name> ::=
      TYPE
    | LENGTH
    | OCTET_LENGTH
    | RETURNED_LENGTH
    | RETURNED_OCTET_LENGTH
    | PRECISION
    | SCALE
    | DATETIME_INTERVAL_CODE
    | DATETIME_INTERVAL_PRECISION
    | NULLABLE
    | INDICATOR
    | DATA
    | NAME
    | UNNAMED
    | COLLATION_CATALOG
    | COLLATION_SCHEMA
    | COLLATION_NAME
    | CHARACTER_SET_CATALOG
    | CHARACTER_SET_SCHEMA
    | CHARACTER_SET_NAME

<simple value specification 2> ::= <simple value specification>

<item number> ::= <simple value specification>

<get descriptor statement> ::=
    GET DESCRIPTOR <descriptor name> <get descriptor information>

<get descriptor information> ::=
      <get count>
    | VALUE <item number>
        <get item information> [ ( <comma> <get item information> )... ]

<get count> ::=
    <simple target specification 1> <equals operator>
         COUNT

<simple target specification 1> ::= <simple target specification>

<simple target specification> ::=
      <parameter name>
    | <embedded variable name>

<get item information> ::=
    <simple target specification 2> <equals operator> <descriptor item name>>

<simple target specification 2> ::= <simple target specification>

<prepare statement> ::=
    PREPARE <SQL statement name> FROM <SQL statement variable>

<SQL statement name> ::=
      <statement name>
    | <extended statement name>

<extended statement name> ::=
    [ <scope option> ] <simple value specification>

<SQL statement variable> ::= <simple value specification>

<deallocate prepared statement> ::=
    DEALLOCATE PREPARE <SQL statement name>

<describe statement> ::=
      <describe input statement>
    | <describe output statement>

<describe input statement> ::=
    DESCRIBE INPUT <SQL statement name> <using descriptor>

<using descriptor> ::=
    ( USING | INTO ) SQL DESCRIPTOR <descriptor name>

<describe output statement> ::=
    DESCRIBE [ OUTPUT ] <SQL statement name> <using descriptor>

<execute statement> ::=
    EXECUTE <SQL statement name>
      [ <result using clause> ]
      [ <parameter using clause> ]

<result using clause> ::= <using clause>

<using clause> ::=
      <using arguments>
    | <using descriptor>

<using arguments> ::=
    ( USING | INTO ) <argument> [ ( <comma> <argument> )... ]

<argument> ::= <target specification>

<parameter using clause> ::= <using clause>

<execute immediate statement> ::=
    EXECUTE IMMEDIATE <SQL statement variable>

<SQL dynamic data statement> ::=
      <allocate cursor statement>
    | <dynamic open statement>
    | <dynamic fetch statement>
    | <dynamic close statement>
    | <dynamic delete statement: positioned>
    | <dynamic update statement: positioned>

<allocate cursor statement> ::=
    ALLOCATE <extended cursor name> [ INSENSITIVE ]
        [ SCROLL ] CURSOR
      FOR <extended statement name>

<extended cursor name> ::=
    [ <scope option> ] <simple value specification>

<dynamic open statement> ::=
    OPEN <dynamic cursor name> [ <using clause> ]

<dynamic cursor name> ::=
      <cursor name>
    | <extended cursor name>

<dynamic fetch statement> ::=
    FETCH [ [ <fetch orientation> ] FROM ] <dynamic cursor name>
        <using clause>

<dynamic close statement> ::=
    CLOSE <dynamic cursor name>

<dynamic delete statement: positioned> ::=
    DELETE FROM <table name>
      WHERE CURRENT OF
          <dynamic cursor name>

<dynamic update statement: positioned> ::=
    UPDATE <table name>
      SET <set clause>
          [ ( <comma> <set clause> )... ]
        WHERE CURRENT OF
            <dynamic cursor name>

<SQL diagnostics statement> ::=
    <get diagnostics statement>

<get diagnostics statement> ::=
    GET DIAGNOSTICS <sql diagnostics information>

<sql diagnostics information> ::=
      <statement information>
    | <condition information>

<statement information> ::=
    <statement information item> [ ( <comma> <statement information item> )... ]

<statement information item> ::=
    <simple target specification> <equals operator> <statement information item name>

<statement information item name> ::=
      NUMBER
    | MORE
    | COMMAND_FUNCTION
    | DYNAMIC_FUNCTION
    | ROW_COUNT

<condition information> ::=
    EXCEPTION <condition number>
      <condition information item> [ ( <comma> <condition information item> )... ]

<condition number> ::= <simple value specification>

<condition information item> ::=
    <simple target specification> <equals operator> <condition information item name>

<condition information item name> ::=
      CONDITION_NUMBER
    | RETURNED_SQLSTATE
    | CLASS_ORIGIN
    | SUBCLASS_ORIGIN
    | SERVER_NAME
    | CONNECTION_NAME
    | CONSTRAINT_CATALOG
    | CONSTRAINT_SCHEMA
    | CONSTRAINT_NAME
    | CATALOG_NAME
    | SCHEMA_NAME
    | TABLE_NAME
    | COLUMN_NAME
    | CURSOR_NAME
    | MESSAGE_TEXT
    | MESSAGE_LENGTH
    | MESSAGE_OCTET_LENGTH

<embedded SQL host program> ::=
      <embedded SQL Ada program>
    | <embedded SQL C program>
    | <embedded SQL COBOL program>
    | <embedded SQL Fortran program>
    | <embedded SQL MUMPS program>
    | <embedded SQL Pascal program>
    | <embedded SQL PL/I program>

<embedded SQL Ada program> ::= !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL C program> ::=
      !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL COBOL program> ::= !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL Fortran program> ::=
    !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL MUMPS program> ::= !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL Pascal program> ::=
    !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL PL/I program> ::= !! <EMPHASIS>(See the Syntax Rules.)

<embedded SQL declare section> ::=
      <embedded SQL begin declare>
        [ <embedded character set declaration> ]
        [ <host variable definition>... ]
      <embedded SQL end declare>
    | <embedded SQL MUMPS declare>

<embedded SQL begin declare> ::=
    <SQL prefix> BEGIN DECLARE SECTION
        [ <SQL terminator> ]

<SQL prefix> ::=
      EXEC SQL
    | <ampersand>SQL<left paren>

<SQL terminator> ::=
      END-EXEC
    | <semicolon>
    | <right paren>

<embedded character set declaration> ::=
    SQL NAMES ARE <character set specification>

<host variable definition> ::=
      <Ada variable definition>
    | <C variable definition>
    | <COBOL variable definition>
    | <Fortran variable definition>
    | <MUMPS variable definition>
    | <Pascal variable definition>
    | <PL/I variable definition>

<Ada variable definition> ::=
    <Ada host identifier> [ ( <comma> <Ada host identifier> )... ] :
    <Ada type specification> [ <Ada initial value> ]

<Ada type specification> ::=
      <Ada qualified type specification>
    | <Ada unqualified type specification>

<Ada qualified type specification> ::=
      SQL_STANDARD.CHAR [ CHARACTER SET
         [ IS ] <character set specification> ]
          <left paren> 1 <double period> <length> <right paren>
    | SQL_STANDARD.BIT
          <left paren> 1 <double period> <length> <right paren>
    | SQL_STANDARD.SMALLINT
    | SQL_STANDARD.INT
    | SQL_STANDARD.REAL
    | SQL_STANDARD.DOUBLE_PRECISION
    | SQL_STANDARD.SQLCODE_TYPE
    | SQL_STANDARD.SQLSTATE_TYPE
    | SQL_STANDARD.INDICATOR_TYPE

<Ada unqualified type specification> ::=
      CHAR
          <left paren> 1 <double period> <length> <right paren>
    | BIT
          <left paren> 1 <double period> <length> <right paren>
    | SMALLINT
    | INT
    | REAL
    | DOUBLE_PRECISION
    | SQLCODE_TYPE
    | SQLSTATE_TYPE
    | INDICATOR_TYPE

<Ada initial value> ::=
    <Ada assignment operator> <character representation>...

<Ada assignment operator> ::= <colon><equals operator>

<C variable definition> ::=
      [ <C storage class> ]
      [ <C class modifier> ]
      <C variable specification>
    <semicolon>

<C storage class> ::=
      auto
    | extern
    | static

<C class modifier> ::= const | volatile

<C variable specification> ::=
      <C numeric variable>
    | <C character variable>
    | <C derived variable>

<C numeric variable> ::=
    ( long | short | float | double )
      <C host identifier> [ <C initial value> ]
            [ ( <comma> <C host identifier> [ <C initial value> ] )... ]

<C initial value> ::=
    <equals operator> <character representation>...

<C character variable> ::=
    char [ CHARACTER SET
             [ IS ] <character set specification> ]
      <C host identifier>
        <C array specification> [ <C initial value> ]
        [ ( <comma> <C host identifier>
          <C array specification>
                 [ <C initial value> ] )... ]

<C array specification> ::=
    <left bracket> <length> <right bracket>

<C derived variable> ::=
      <C VARCHAR variable>
    | <C bit variable>

<C VARCHAR variable> ::=
    VARCHAR [ CHARACTER SET [ IS ]
        <character set specification> ]
        <C host identifier>
            <C array specification> [ <C initial value> ]
          [ ( <comma> <C host identifier>
              <C array specification>
                      [ <C initial value> ] )... ]

<C bit variable> ::=
    BIT <C host identifier>
        <C array specification> [ <C initial value> ]
      [ ( <comma> <C host identifier>
        <C array specification>
                   [ <C initial value> ] )... ]

<COBOL variable definition> ::=
    (01|77) <COBOL host identifier> <COBOL type specification>
      [ <character representation>... ] <period>

<COBOL type specification> ::=
      <COBOL character type>
    | <COBOL bit type>
    | <COBOL numeric type>
    | <COBOL integer type>

<COBOL character type> ::=
    [ CHARACTER SET [ IS ]
          <character set specification> ]
    ( PIC | PICTURE ) [ IS ] ( X [ <left paren> <length> <right paren> ] )...

<COBOL bit type> ::=
    ( PIC | PICTURE ) [ IS ]
        ( B [ <left paren> <length> <right paren> ] )...

<COBOL numeric type> ::=
    ( PIC | PICTURE ) [ IS ]
      S <COBOL nines specification>
    [ USAGE [ IS ] ] DISPLAY SIGN LEADING SEPARATE

<COBOL nines specification> ::=
      <COBOL nines> [ V [ <COBOL nines> ] ]
    | V <COBOL nines>

<COBOL nines> ::= ( 9 [ <left paren> <length> <right paren> ] )...

<COBOL integer type> ::=
      <COBOL computational integer>
    | <COBOL binary integer>

<COBOL computational integer> ::=
    ( PIC | PICTURE ) [ IS ] S<COBOL nines>
      [ USAGE [ IS ] ] ( COMP | COMPUTATIONAL )

<COBOL binary integer> ::=
    ( PIC | PICTURE ) [ IS ] S<COBOL nines>
      [ USAGE [ IS ] ] BINARY

<Fortran variable definition> ::=
    <Fortran type specification>
    <Fortran host identifier>
        [ ( <comma> <Fortran host identifier> )... ]

<Fortran type specification> ::=
      CHARACTER [ <asterisk> <length> ]
          [ CHARACTER SET [ IS ]
                <character set specification> ]
    | BIT [ <asterisk> <length> ]
    | INTEGER
    | REAL
    | DOUBLE PRECISION

<MUMPS variable definition> ::=
    ( <MUMPS numeric variable> | <MUMPS character variable> )
        <semicolon>

<MUMPS numeric variable> ::=
    <MUMPS type specification>
      <MUMPS host identifier> [ ( <comma> <MUMPS host identifier> )... ]

<MUMPS type specification> ::=
      INT
    | DEC
          [ <left paren> <precision> [ <comma> <scale> ] <right paren> ]
    | REAL

<MUMPS character variable> ::=
    VARCHAR <MUMPS host identifier> <MUMPS length specification>
      [ ( <comma> <MUMPS host identifier> <MUMPS length specification> )... ]

<MUMPS length specification> ::=
    <left paren> <length> <right paren>

<Pascal variable definition> ::=
    <Pascal host identifier> [ ( <comma> <Pascal host identifier> )... ] <colon>
      <Pascal type specification> <semicolon>

<Pascal type specification> ::=
      PACKED ARRAY
          <left bracket> 1 <double period> <length> <right bracket>
        OF CHAR
          [ CHARACTER SET [ IS ]
                <character set specification> ]
    | PACKED ARRAY
          <left bracket> 1 <double period> <length> <right bracket>
        OF BIT
    | INTEGER
    | REAL
    | CHAR [ CHARACTER SET
                                [ IS ] <character set specification> ]
    | BIT

<PL/I variable definition> ::=
    (DCL | DECLARE)
        (   <PL/I host identifier>
          | <left paren> <PL/I host identifier>
                [ ( <comma> <PL/I host identifier> )... ] <right paren> )
    <PL/I type specification>
    [ <character representation>... ] <semicolon>

<PL/I type specification> ::=
      ( CHAR | CHARACTER ) [ VARYING ]
          <left paren><length><right paren>
          [ CHARACTER SET
                [ IS ] <character set specification> ]
    | BIT [ VARYING ] <left paren><length><right paren>
    | <PL/I type fixed decimal> <left paren> <precision>
          [ <comma> <scale> ] <right paren>
    | <PL/I type fixed binary> [ <left paren> <precision> <right paren> ]
    | <PL/I type float binary> <left paren> <precision> <right paren>

<PL/I type fixed decimal> ::=
      ( DEC | DECIMAL ) FIXED
    | FIXED ( DEC | DECIMAL )

<PL/I type fixed binary> ::=
      ( BIN | BINARY ) FIXED
    | FIXED ( BIN | BINARY )

<PL/I type float binary> ::=
      ( BIN | BINARY ) FLOAT
    | FLOAT ( BIN | BINARY )

<embedded SQL end declare> ::=
    <SQL prefix> END DECLARE SECTION
        [ <SQL terminator> ]

<embedded SQL MUMPS declare> ::=
    <SQL prefix>
      BEGIN DECLARE SECTION
        [ <embedded character set declaration> ]
        [ <host variable definition>... ]
      END DECLARE SECTION
    <SQL terminator>

<embedded SQL statement> ::=
    <SQL prefix>
      <statement or declaration>
    [ <SQL terminator> ]

<statement or declaration> ::=
      <declare cursor>
    | <dynamic declare cursor>
    | <temporary table declaration>
    | <embedded exception declaration>
    | <SQL procedure statement>

<embedded exception declaration> ::=
    WHENEVER <condition> <condition action>

<condition> ::=
    SQLERROR | NOT FOUND

<condition action> ::=
    CONTINUE | <go to>

<go to> ::=
    ( GOTO | GO TO ) <goto target>

<goto target> ::=
      <host label identifier>
    | <unsigned integer>
    | <host PL/I label variable>

<host label identifier> ::= !!<EMPHASIS>(See the Syntax Rules.)

<host PL/I label variable> ::= !!<EMPHASIS>(See the Syntax Rules.)

<preparable statement> ::=
      <preparable SQL data statement>
    | <preparable SQL schema statement>
    | <preparable SQL transaction statement>
    | <preparable SQL session statement>
    | <preparable implementation-defined statement>

<preparable SQL data statement> ::=
      <delete statement: searched>
    | <dynamic single row select statement>
    | <insert statement>
    | <dynamic select statement>
    | <update statement: searched>
    | <preparable dynamic delete statement: positioned>
    | <preparable dynamic update statement: positioned>

<dynamic single row select statement> ::= <query specification>

<dynamic select statement> ::= <cursor specification>

<preparable dynamic delete statement: positioned> ::=
   DELETE [ FROM <table name> ]
      WHERE CURRENT OF <cursor name>

<preparable dynamic update statement: positioned> ::=
   UPDATE [ <table name> ]
      SET <set clause list>
      WHERE CURRENT OF <cursor name>

<preparable SQL schema statement> ::=
      <SQL schema statement>

<preparable SQL transaction statement> ::=
      <SQL transaction statement>

<preparable SQL session statement> ::=
      <SQL session statement>

<preparable implementation-defined statement> ::=
    !! <EMPHASIS>(See the Syntax Rules.)

<direct SQL statement> ::=
    <directly executable statement> <semicolon>

<directly executable statement> ::=
      <direct SQL data statement>
    | <SQL schema statement>
    | <SQL transaction statement>
    | <SQL connection statement>
    | <SQL session statement>
    | <direct implementation-defined statement>

<direct SQL data statement> ::=
      <delete statement: searched>
    | <direct select statement: multiple rows>
    | <insert statement>
    | <update statement: searched>
    | <temporary table declaration>

<direct select statement: multiple rows> ::=
    <query expression> [ <order by clause> ]

<direct implementation-defined statement> ::=
    !!<EMPHASIS>(See the Syntax Rules)

<SQL object identifier> ::=
    <SQL provenance> <SQL variant>

<SQL provenance> ::= <arc1> <arc2> <arc3>

<arc1> ::= iso | 1 | iso <left paren> 1 <right paren>

<arc2> ::= standard | 0 | standard <left paren> 0 <right paren>

<arc3> ::= 9075

<SQL variant> ::= <SQL edition> <SQL conformance>

<SQL edition> ::= <1987> | <1989> | <1992>

<1987> ::= 0 | edition1987 <left paren> 0 <right paren>

<1989> ::= <1989 base> <1989 package>

<1989 base> ::= 1 | edition1989 <left paren> 1 <right paren>

<1989 package> ::= <integrity no> | <integrity yes>

<integrity no> ::= 0 | IntegrityNo <left paren> 0 <right paren>

<integrity yes> ::= 1 | IntegrityYes <left paren> 1 <right paren>

<1992> ::= 2 | edition1992 <left paren> 2 <right paren>

<SQL conformance> ::= <low> | <intermediate> | <high>

<low> ::= 0 | Low <left paren> 0 <right paren>

<intermediate> ::= 1 | Intermediate <left paren> 1 <right paren>

<high> ::= 2 | High <left paren> 2 <right paren>

32. Apendice B - Tutorial de SQL para principiantes

32.1 Tutorial de PostgreSQL

El tutorial de SQL se distribuye también con PostgreSQL. Los scripts para el tutorial están en el directorio src/tutorial.

32.2 Punteros a URLs de Internet

Se puede encontrar el Tutorial de SQL para principiantes en:

¿Comentarios o sugerencias? Dirijanse por e-mail a Las siguientes son las direcciones sugeridas por John Hoffman:

33. Apédice C - Instrucciones Rápidas para la Instalación de Linux

Si está planeando utilizar PostgreSQL sobre Linux, y necesita ayuda para instalar Linux, por favor siga los enlaces a los sitios que se indican en este apéndice. Estos sitios cubren los siguientes temas: