postgres programmer

Guia del Programador dePostgreSQL

El equipo de desarrollo de PostgreSQL

Editado porThomas Lockhart

Guia del Programador de PostgreSQLpor El equipo de desarrollo de PostgreSQL

Editado por Thomas Lockhart

PostgreSQLes marca registrada 1996-9 por el Postgres Global Development Group.

Tabla de contenidosSumario........................................................................................................................... i1. Introduccin ...............................................................................................................1

1.1. Recursos............................................................................................................11.2. Terminologa .....................................................................................................31.3. Notacin............................................................................................................41.4. Y2K Statement (Informe sobre el efecto 2000)................................................51.5. Copyrights y Marcas Registradas .....................................................................6

2. Arquitectura ...............................................................................................................12.1. Conceptos de Arquitectura de Postgres ............................................................1

3. Extensor SQL: Preludio ............................................................................................33.1. Como hacer extensible el trabajo......................................................................33.2. El Tipo de Sistema de Postgres.........................................................................43.3. Acerca de los Sistema de Catalogo de Postgres................................................4

4. Extendiendo SQL: Funciones ...................................................................................74.1. Funciones de Lenguaje de Consultas (SQL).....................................................7

4.1.1. Ejemplos ................................................................................................84.1.2. Funciones SQL sobre Tipos Base ..........................................................94.1.3. Funciones SQL sobre Tipos Compuestos ............................................10

4.2. Funciones de Lenguaje Procedural .................................................................134.3. Funciones Internas ..........................................................................................134.4. Funciones de Lenguaje Compilado (C) ..........................................................14

4.4.1. Funciones de Lenguaje C sobre Tipos Base ........................................154.4.2. Funciones del Lenguaje C sobre Tipos Compuestos ...........................204.4.3. Escribiendo cdigo...............................................................................22

4.5. Sobrecarga de funciones .................................................................................244.5.1. Conflictos en el Espacio de Nombres ..................................................24

4.5.1.1. Pre-v6.6.....................................................................................245. Extendiendo SQL: Tipos .........................................................................................26

5.1. Tipos Definidos por el Usuario .......................................................................265.1.1. Funciones Necesarias para un Tipo Definido por el Usuario...............26

3

5.1.2. Objetos Grandes...................................................................................286. Extenediendo SQL: Operadores.............................................................................30

6.1. Informacin de optimizacin de operador ......................................................316.1.1. COMMUTATOR (conmutador)...........................................................326.1.2. NEGATOR(negador) ...........................................................................336.1.3. RESTRICT (Restringir) .......................................................................346.1.4. JOIN (unir)...........................................................................................356.1.5. HASHES(desmenusamiento)...............................................................366.1.6. SORT1 and SORT2 (orden1 y orden2)................................................37

7. Extensiones de SQL: Agregados.............................................................................408. El Sistema de reglas de Postgres .............................................................................43

8.1. Qu es un rbol de query?.............................................................................438.1.1. Las partes de un rbol de query ...........................................................44

8.2. Las vistas y el sistema de reglas. ....................................................................468.2.1. Implementacin de las vistas en Postgres............................................478.2.2. Cmo trabajan las reglas de SELECT .................................................478.2.3. Reglas de vistas en instrucciones diferentes a SELECT......................578.2.4. El poder de las vistas en Postgres ........................................................59

8.2.4.1. Beneficios..................................................................................598.2.4.2. Puntos delicados a considerar ...................................................60

8.2.5. Efectos colaterales de la implementacin ............................................618.3. Reglas sobre INSERT, UPDATE y DELETE .................................................62

8.3.1. Diferencias con las reglas de las vistas. ...............................................628.3.2. Cmo trabajan estas reglas...................................................................62

8.3.2.1. Una primera regla paso a paso. .................................................648.3.3. Cooperacin con las vistas...................................................................70

8.4. Reglas y permisos ...........................................................................................798.5. Reglas frente triggers ......................................................................................81

9. Utilizacin de las Extensiones en los ndices .........................................................8610. GiST Indices ...........................................................................................................9811. Lenguajes Procedurales.......................................................................................101

11.1. Instalacin de lenguajes procedurales.........................................................101

4

11.2. PL/pgSQL ...................................................................................................10311.2.1. Panormica.......................................................................................10311.2.2. Descripcion ......................................................................................104

11.2.2.1. Estructura de PL/pgSQL.......................................................10411.2.2.2. Comments .............................................................................10511.2.2.3. Declaraciones........................................................................10511.2.2.4. Tipos de datos .......................................................................10711.2.2.5. Expressions ...........................................................................10811.2.2.6. Sentencias .............................................................................11011.2.2.7. Procedimientos desencadenados...........................................11411.2.2.8. Excepciones ..........................................................................116

11.2.3. Ejemplos ..........................................................................................11611.2.3.1. Algunas funciones sencillas en PL/pgSQL...........................11711.2.3.2. Funciones PL/pgSQL para tipos compuestos .......................11711.2.3.3. Procedimientos desencadenados en PL/pgSQL....................118

11.3. PL/Tcl .........................................................................................................11911.3.1. Introduccin .....................................................................................11911.3.2. Descripcin ......................................................................................120

11.3.2.1. Funciones de Postgres y nombres de procedimientos Tcl ....12011.3.2.2. Definiendo funciones en PL/Tcl ...........................................12011.3.2.3. Datos Globales en PL/Tcl .....................................................12111.3.2.4. Procedimientos desencadenados en PL/Tcl ..........................12211.3.2.5. Acceso a bases de datos desde PL/Tcl..................................124

12. Enlazando funciones de carga dinmica............................................................12912.1. ULTRIX ......................................................................................................13012.2. DEC OSF/1 .................................................................................................13112.3. SunOS 4.x, Solaris 2.x y HP-UX................................................................132

13. Triggers (disparadores) .......................................................................................13413.1. Creacin de Triggers...................................................................................13413.2. Interaccin con el Trigger Manager............................................................13613.3. Visibilidad de Cambios en Datos................................................................13813.4. Ejemplos .....................................................................................................139

14. Server Programming Interface...........................................................................145

5

14.1. Interface Functions......................................................................................145SPI_connect .................................................................................................146SPI_finish.....................................................................................................147SPI_exec.......................................................................................................149SPI_prepare..................................................................................................152SPI_saveplan................................................................................................154SPI_execp.....................................................................................................155

14.2. Interface Support Functions........................................................................158SPI_copytuple ..............................................................................................158SPI_modifytuple ..........................................................................................159SPI_fnumber ................................................................................................161SPI_fname....................................................................................................162SPI_getvalue ................................................................................................164SPI_getbinval ...............................................................................................166SPI_gettype ..................................................................................................167SPI_gettypeid...............................................................................................169SPI_getrelname............................................................................................171SPI_palloc ....................................................................................................172SPI_repalloc.................................................................................................173SPI_pfree......................................................................................................174

14.3. Memory Management.................................................................................17614.4. Visibility of Data Changes ..........................................................................17714.5. Examples.....................................................................................................177

15. Objetos Grandes...................................................................................................18215.1. Nota Histrica .............................................................................................18215.2. Caractersticas de la Implementacin .........................................................18215.3. Interfaces.....................................................................................................182

15.3.1. Creando un Objeto Grande ..............................................................18315.3.2. Importando un Objeto Grande .........................................................18415.3.3. Exportando un Objeto Grande .........................................................18415.3.4. Abriendo un Objeto Grande Existente.............................................18515.3.5. Escribiendo Datos en un Objeto Grande..........................................18515.3.6. Leyendo Datos desde un Objeto Grande .........................................185

6

15.3.7. Posicionndose en un Objeto Grande ..............................................18615.3.8. Cerrando un Descriptor de Objeto Grande ......................................186

15.4. Funciones registradas Incorporadas ............................................................18615.5. Accediendo a Objetos Grandes desde LIBPQ ............................................18715.6. Programa de Ejemplo..................................................................................187

16. libpq.......................................................................................................................19516.1. Funciones de Conexin a la Base de Datos ................................................19516.2. Funciones de Ejecucin de Consultas.........................................................20716.3. Procesamiento Asncrono de Consultas......................................................21316.4. Ruta Rpida.................................................................................................21816.5. Notificacin Asncrona ...............................................................................22016.6. Funciones Asociadas con el Comando COPY............................................22116.7. Funciones de Trazado de libpq ...................................................................22516.8. Funciones de control de libpq .....................................................................22516.9. Variables de Entorno ...................................................................................22616.10. Programas de Ejemplo ..............................................................................228

16.10.1. Programa de Ejemplo 1..................................................................22816.10.2. Programa de Ejemplo 2..................................................................23216.10.3. Programa de Ejemplo 3..................................................................237

17. libpq C++ Binding................................................................................................24417.1. Control e Inicializacin...............................................................................244

17.1.1. Variables de Entorno. .......................................................................24417.2. Clases de libpq++........................................................................................246

17.2.1. Clase de Conexin: PgConnection ...............................................24617.2.2. Clase Base de Datos: PgDatabase .................................................246

17.3. Funciones de Conexin a la Base de Datos ................................................24717.4. Funciones de Ejecucin de las Consultas ...................................................24817.5. Notificacin Asncrona ...............................................................................25317.6. Funciones Asociadas con el Comando COPY. ...........................................254

18. pgtcl .......................................................................................................................25718.1. Comandos ...................................................................................................25718.2. Ejemplos .....................................................................................................25818.3. Informacin de referencia de comandos pgtcl ............................................259

7

pg_connect ...................................................................................................259pg_disconnect ..............................................................................................261pg_conndefaults ...........................................................................................262pg_exec ........................................................................................................263pg_result.......................................................................................................265pg_select ......................................................................................................267pg_listen.......................................................................................................269pg_lo_creat...................................................................................................271pg_lo_open...................................................................................................273pg_lo_close ..................................................................................................274pg_lo_read....................................................................................................275pg_lo_write ..................................................................................................277pg_lo_lseek ..................................................................................................278pg_lo_tell .....................................................................................................279pg_lo_unlink ................................................................................................281pg_lo_import................................................................................................282pg_lo_export ................................................................................................283

I. CCVS API Functions .............................................................................................286..............................................................................................................................287

19. Interfaz ODBC .....................................................................................................28819.1. Trasfondo ....................................................................................................28819.2. Aplicaciones Windows................................................................................289

19.2.1. Escritura de Aplicaciones ................................................................28919.3. Instalacin Unix ..........................................................................................290

19.3.1. Construyendo el Driver ....................................................................29019.4. Ficheros de Configuracin ..........................................................................29519.5. ApplixWare .................................................................................................297

19.5.1. Configuration ...................................................................................29719.5.2. Problemas Comunes.........................................................................29919.5.3. Depurando las conexiones ODBC ApplixWare...............................30019.5.4. Ejecutando la demo ApplixWare .....................................................30119.5.5. Useful Macros..................................................................................30219.5.6. Plataformas soportadas ....................................................................303

8

20. JDBC Interface.....................................................................................................30420.1. Building the JDBC Interface.......................................................................304

20.1.1. Compiling the Driver .......................................................................30420.1.2. Installing the Driver .........................................................................305

20.1.2.1. Example ................................................................................30520.2. Preparing the Database for JDBC...............................................................30520.3. Using the Driver..........................................................................................30620.4. Importing JDBC..........................................................................................30620.5. Loading the Driver ......................................................................................30620.6. Connecting to the Database ........................................................................30720.7. Issuing a Query and Processing the Result .................................................308

20.7.1. Using the Statement Interface..........................................................30920.7.2. Using the ResultSet Interface...........................................................309

20.8. Performing Updates ....................................................................................31020.9. Closing the Connection...............................................................................31020.10. Using Large Objects .................................................................................31120.11. Postgres Extensions to the JDBC API ......................................................31320.12. Further Reading ........................................................................................369

21. Interfaz de Programacin Lisp...........................................................................37122. Codigo Fuente Postgres .......................................................................................373

22.1. Formateo .....................................................................................................37323. Revisin de las caractersticas internas de PostgreSQL...................................375

23.1. El camino de una consulta ..........................................................................37523.2. Cmo se establecen las conexiones ............................................................37623.3. La etapa de traduccin ................................................................................377

23.3.1. Traductor..........................................................................................37723.3.2. Proceso de transformacin...............................................................380

23.4. El sistema de reglas de Postgres .................................................................38123.4.1. El sistema de reescritura ..................................................................381

23.4.1.1. Tcnicas para implementar vistas .........................................38123.5. Planificador/optimizador.............................................................................383

23.5.1. Generando planes posibles...............................................................38323.5.2. Estructura de datos del plan .............................................................385

9

23.6. Ejecutor .......................................................................................................38624. pg_options.............................................................................................................38725. Optimizacin Gentica de Consulta en Sistemas de Base de Datos ................392

25.1. Planificador de consulta para un Problema Complejo de Optimizacin.....39225.2. Algoritmo Genticos (AG)..........................................................................39325.3. Optimizacin Gentica de Consultas (GEQO) en Postgres........................39425.4. Futuras Tareas de Implementacin para el OGEC de Postgres ..................395

25.4.1. Mejoras Bsicas ...............................................................................39625.4.1.1. Mejora en la liberacin de memoria cuando la consulta ya se

ha procesado.................................................................................39625.4.1.2. Mejora de las configuraciones de los parmetros del algoritmo

gentico ........................................................................................39625.4.1.3. Busqueda de una mejor solucin para el desbordamiento de

entero............................................................................................39625.4.1.4. Encotrar solucin para la falta de memoria ..........................397

Referencias...................................................................................................39726. Protocolo Frontend/Backend ..............................................................................399

26.1. Introduccin ................................................................................................39926.2. Protocolo .....................................................................................................400

26.2.1. Inicio ................................................................................................40026.2.2. Consulta ...........................................................................................40326.2.3. Llamada a funcin............................................................................40526.2.4. Respuestas de notificacin ...............................................................40626.2.5. Cancelacin de peticiones en progreso ............................................40726.2.6. Finalizacin......................................................................................408

26.3. Tipos de Datos de Mensajes........................................................................40826.4. Formatos de Mensajes.................................................................................409

27. Seales de Postgres...............................................................................................42228. gcc Default Optimizations ...................................................................................42429. Interfaces de Backend..........................................................................................426

29.1. Formato de fichero BKI ..............................................................................42629.2. Comandos Generales ..................................................................................427

10

29.3. Macro Commands.......................................................................................42829.4. Comandos de Depuracin ...........................................................................42929.5. Ejemplo .......................................................................................................430

30. Ficheros de pginas..............................................................................................43130.1. Estructura de la pgina................................................................................43130.2. Ficheros.......................................................................................................43230.3. Bugs ............................................................................................................433

DG1. El Repositorio del CVS....................................................................................434DG1.1. Organizacin del rbol de CVS...............................................................434DG1.2. Tomando Las Fuentes Va CVS Annimo..............................................437DG1.3. Tomando Los Fuentes Va CVSup..........................................................439

DG1.3.1. Preparando un Sistema Cliente CVSup........................................439DG1.3.2. Ejecutando un Cliente CVSup .....................................................440DG1.3.3. Instalando CVSup ........................................................................443DG1.3.4. Instalacin a partir de los Fuentes................................................445

DG2. Documentacin.................................................................................................448DG2.1. Mapa de la documentacin......................................................................448DG2.2. El proyecto de documentacin ................................................................449DG2.3. Fuentes de la documentacin ..................................................................450

DG2.3.1. Estructura del documento.............................................................450DG2.3.2. Estilos y convenciones .................................................................452DG2.3.3. Herramientas de autor para SGML ..............................................452

DG2.3.3.1. emacs/psgml......................................................................452DG2.4. Haciendo documentaciones.....................................................................454DG2.5. Pginas man ............................................................................................455DG2.6. Generacin de copias impresas para v6.5 ...............................................456

DG2.6.1. Texto de copia impresa.................................................................456DG2.6.2. Copia impresa postscript ..............................................................457

DG2.7. Herramientas ...........................................................................................459DG2.7.1. Instalacin de RPM Linux ...........................................................459DG2.7.2. Instalacin en FreeBSD................................................................460DG2.7.3. Instalacin en Debian...................................................................461DG2.7.4. Instalacin manual de las herramientas........................................462

11

DG2.7.4.1. Requisitos previos .............................................................462DG2.7.4.2. Instalacin de Jade ............................................................464DG2.7.4.3. Instalacin del DTD de DocBook .....................................465DG2.7.4.4. Instalacin de las hojas de estilo DSSSL de Norman Walsh

466DG2.7.4.5. Instalacin de PSGML ......................................................467DG2.7.4.6. Instalacin de JadeTeX .....................................................469

DG2.8. Otras herramientas ..................................................................................470Bibliografa .................................................................................................................471

12

Lista de tablas3-1. Sistema de Catalogos de Postgres ............................................................................54-1. Tipos de C equivalentes para los tipos internos de Postgres ..................................159-1. Esquema de un ndice.............................................................................................869-2. Estrategias B-tree....................................................................................................889-3. Esquema de pg_amproc ........................................................................................9318-1. Comandos pgtcl ...............................................................................................25727-1. Seales Postgres .................................................................................................42230-1. Muestra de Dibujo de Pgina..............................................................................431DG2-1. Documentacin de Postgres............................................................................448

Tabla de figuras2-1. Cmo se establece una conexin ..............................................................................13-1. El principal sistema de catalogo de Postgres............................................................5

Tabla de ejemplos23-1. Una SELECT sencilla.........................................................................................378

1

SumarioPostgres, desarrollada originalmente en el Departamento de Ciencias de laComputacin de la Universidad de California en Berkeley, fu pionera en muchos delos conceptos de bases de datos relacionales orientadas a objetos que ahora empiezan aestar disponiblesen algunas bases de datos comerciales. Ofrece suporte al lenguageSQL92/SQL3, integridad de transacciones, y extensibilidad de tipos de datos.PostgreSQL es un descendiente de dominio pblico y cdigo abierto del cdigooriginal de Berkeley.

1

Captulo 1. IntroduccinEste documento es el manual del programador para el gestor de bases de datosPostgreSQL (http://postgresql.org/), desarrollado inicialmente en la Universidad deCalifornia en Berkeley. PostgreSQL se basa en Postgres versin 4.2(http://s2k-ftp.CS.Berkeley.EDU:8000/postgres/postgres.html). El proyecto Postgres,liderado por el Profesor Michael Stonebraker, ha sido financiado por la Agencia deProyectos de Investigacin de Defensa Avanzados (DARPA), la Oficina deInvestigacin del Ejrcito (ARO), la Fundacin Nacional de Ciencia (NSF), y ESL, Inc.La primera parte de este manual explica el enfoque extensible de Postgres y describecomo Postgres puede ser ampliado por los usuarios aadiendo sus propios tipos,operadores, agregados y funciones, tanto en lenguaje de programacin como enlenguaje de bases de datos. Despus de una discusin del sistema de reglas de Postgres,discutimos las interfaces de disparo (trigger) y SPI. El manual concluye con unadescripcin detallada de la interfaz de programacin y de las libreras de apoyo paravarios lenguajes.Asumimos que el lector tiene buenos conocimientos de Unix y de programacin en C.

1.1. RecursosEste manual est organizado en diferentes partes:

Tutorial

Introduccion para nuevos usuarios. No cubre caractersticas avanzadas.

Guia del Usuario

Informacion general para el usuario, incluye comandos y tipos de datos.

Gua del Programador

Informacin avanzada para programadores de aplicaciones. Incluyendo tipos y

1

Captulo 1. Introduccin

extensin de funciones, libreria de interfaces y lo referido al diseo deaplicaciones.

Guia del Administrador

Informacin sobre instalacin y administracin. Lista de equipo soportado.

Guia del Desarrollador

Informacin para desarrolladores de Postgres. Este documento es para aquellaspersonas que estan contribuyendo al proyecto de Postgres; la informacinrefererida al desarrollo de aplicaciones aparece en la Guia del Programador.Actualmente incluido en la Guia del Programador.

Manual de Referencia

Informacin detallada sobre los comandos. Actualmente includo en la Guia delUsuario.

Ademas de ste manual, hay otros recursos que le servirn de ayuda para la instalaciony el uso de Postgres:

man pages

Las pginas de manual(man pages) contienen mas informacin sobre loscomandos.

FAQs(Preguntas Frequentes)La seccin de Preguntas Frequentes(FAQ) contiene respuestas a preguntas

generales y otros asuntos que tienen que ver con la plataforma en que se desarrolle.

LEAME(READMEs)Los archivos llamados LEAME(README) estan disponibles para algunas

contribuciones.

Web Site

El sitio web de Postgres (postgresql.org) contiene informacin que algunas

2


distribuciones no incluyen. Hay un catlogo llamado mhonarc que contiene elhistrico de las listas de correo electrnico. Aqu podr encontrar bastanteinformacin.

Listas de Correo

La lista de correo pgsql-general (mailto:[email protected]) (archive(http://www.PostgreSQL.ORG/mhonarc/pgsql-general/)) es un buen lugar paracontestar sus preguntas.

Usted!

Postgres es un producto de cdigo abierto . Como tal, depende de la comunidadde usuarios para su soporte. A medida que empieze a usar Postgres, empezar adepender de otros para que le ayuden, ya sea por medio de documentacin o en laslistas de correo. Considere contribuir lo que aprenda. Si aprende o descubre algoque no est documentado, escrbalo y contribuya. Si aade nuevas caractersticasal cdigo, hgalas saber.

Aun aquellos con poca o ninguna experiencia pueden proporcionar correcciones ycambios menores a la documentacin, lo que es una buena forma de empezar. Elpgsql-docs (mailto:[email protected]) (archivo(http://www.PostgreSQL.ORG/mhonarc/pgsql-docs/)) de la lista de correos es unbuen lugar para comenzar sus pesquisas.

1.2. TerminologaEn la documentacin siguiente, sitio (o site) se puede interpretar como la mquina en laque est instalada Postgres. Dado que es posible instalar ms de un conjunto de basesde datos Postgres en una misma mquina, este trmino denota, de forma ms precisa,cualquier conjunto concreto de programas binarios y bases de datos de Postgresinstalados.

3


El superusuario de Postgres es el usuario llamado postgres que es dueo de losficheros de la bases de datos y binarios de Postgres. Como superusuario de la base dedatos, no le es aplicable ninguno de los mecanismos de proteccin y puede acceder acualquiera de los datos de forma arbitraria. Adems, al superusuario de Postgres se lepermite ejecutar programas de soporte que generalmente no estn disponibles paratodos los usuarios. Tenga en cuenta que el superusuario de Postgres no es el mismo queel superusuario de Unix (que es conocido como root). El superusuario debera tener unidentificador de usuario (UID) distinto de cero por razones de seguridad.El administrador de la base de datos (database administrator) o DBA, es la personaresponsable de instalar Postgres con mecanismos para hacer cumplir una poltica deseguridad para un site. El DBA puede aadir nuevos usuarios por el mtodo descritoms adelante y mantener un conjunto de bases de datos plantilla para usar concreatedb.El postmaster es el proceso que acta como una puerta de control (clearing-house) paralas peticiones al sistema Postgres. Las aplicaciones frontend se conectan al postmaster,que mantiene registros de los errores del sistema y de la comunicacin entre losprocesos backend. El postmaster puede aceptar varios argumentos desde la lnea derdenes para poner a punto su comportamiento. Sin embargo, el proporcionarargumentos es necesario slo si se intenta trabajar con varios sitios o con uno que no seejecuta a la manera por defecto.El backend de Postgres (el programa ejecutable postgres real) lo puede ejecutar elsuperusuario directamente desde el intrprete de rdenes de usuario de Postgres (con elnombre de la base de datos como un argumento). Sin embargo, hacer esto elimina elbuffer pool compartido y bloquea la tabla asociada con un postmaster/sitio, por elloesto no est recomendado en un sitio multiusuario.

1.3. Notacin... o /usr/local/pgsql/ delante de un nombre de fichero se usa para representarel camino (path) al directorio home del superusuario de Postgres.En la sinopsis, los corchetes ([ y ]) indican una expresin o palabra clave opcional.Cualquier cosa entre llaves ({ y }) y que contenga barras verticales (|) indica que

4


debe elegir una de las opciones que separan las barras verticales.

En los ejemplos, los parntesis (( y )) se usan para agrupar expresiones booleanas.| es el operador booleano OR.Los ejemplos mostrarn rdenes ejecutadas desde varias cuentas y programas. Lasrdenes ejecutadas desde la cuenta del root estarn precedidas por >. Las rdenesejecutadas desde la cuenta del superusuario de Postgres estarn precedidas por %,mientras que las rdenes ejecutadas desde la cuenta de un usuario sin privilegiosestarn precedidas por $. Las rdenes de SQL estarn precedidas por => o noestarn precedidas por ningn prompt, dependiendo del contexto.

Nota: En el momento de escribir (Postgres v6.5) la notacin de las rdenesflagging (o flojos) no es universalmente estable o congruente en todo el conjuntode la documentacin. Por favor, enve los problemas a la Lista de Correo de laDocumentacin (o Documentation Mailing List) (mailto:[email protected]).

1.4. Y2K Statement (Informe sobre el efecto2000)

Autor: Escrito por Thomas Lockhart (mailto:[email protected]) el22-10-1998.

El Equipo de Desarrollo Global (o Global Development Team) de PostgreSQLproporciona el rbol de cdigo de software de Postgres como un servicio pblico, singaranta y sin responsabilidad por su comportamiento o rendimiento. Sin embargo, enel momento de la escritura:

5


El autor de este texto, voluntario en el equipo de soporte de Postgres desdeNoviembre de 1996, no tiene constancia de ningn problema en el cdigo dePostgres relacionado con los cambios de fecha en torno al 1 de Enero de 2000 (Y2K).

El autor de este informe no tiene constancia de la existencia de informes sobre elproblema del efecto 2000 no cubiertos en las pruebas de regresin, o en otro campode uso, sobre versiones de Postgres recientes o de la versin actual. Podramos haberesperado or algo sobre problemas si existiesen, dada la base que hay instalada ydada la participacin activa de los usuarios en las listas de correo de soporte.

Por lo que el autor sabe, las suposiciones que Postgres hace sobre las fechas que seescriben usando dos nmeros para el ao estn documentadas en la Gua del Usuario(http://www.postgresql.org/docs/user/datatype.htm) en el captulo de los tipos dedatos. Para aos escritos con dos nmeros, la transicin significativa es 1970, no elao 2000; ej. 70-01-01 se interpreta como 1970-01-01, mientras que 69-01-01se interpreta como 2069-01-01.

Los problemas relativos al efecto 2000 en el SO (sistema operativo) sobre el queest instalado Postgres relacionados con la obtencin de "la fecha actual" se puedenpropagar y llegar a parecer problemas sobre el efecto 2000 producidos por Postgres.

Dirjase a The Gnu Project (http://www.gnu.org/software/year2000.html) y a The PerlInstitute (http://language.perl.com/news/y2k.html) para leer una discusin msprofunda sobre el asunto del efecto 2000, particularmente en lo que tiene que ver con elopen source o cdigo abierto, cdigo por el que no hay que pagar.

1.5. Copyrights y Marcas RegistradasLa traduccin de los textos de copyright se presenta aqu nicamente a modo deaclaracin y no ha sido aprobada por sus autores originales. Los nicos textos decopyright, garantas, derechos y dems legalismos que tienen validez son los originalesen ingls o una traduccin aprobada por los autores y/o sus representantes legales. .

PostgreSQL tiene Copyright 1996-2000 por PostgreSQL Inc. y se distribuye bajo lostrminos de la licencia de Berkeley.

6


Postgres95 tiene Copyright 1994-5 por los Regentes de la Universidad de California.Se autoriza el uso, copia, modificacin y distribuicin de este software y sudocumentacin para cualquier propsito, sin ningn pago, y sin un acuerdo por escrito,siempre que se mantengan el copyright del prrafo anterior, este prrafo y los dosprrafos siguientes en todas las copias.

En ningn caso la Universidad de California se har responsable de daos, causados acualquier persona o entidad, sean estos directos, indirectos, especiales, accidentales oconsiguientes, incluyendo lucro cesante que resulten del uso de este software y sudocumentacin, incluso si la Universidad ha sido notificada de la posibilidad de talesdaos.

La Universidad de California rehusa especficamente ofrecer cualquier garantia,incluyendo, pero no limitada nicamente a, la garanta implcita de comerciabilidad ycapacidad para cumplir un determinado propsito. El software que se distribuye aqu seentrega "tal y cual", y la Universidad de California no tiene ninguna obligacin demantenimiento, apoyo, actualizacin, mejoramiento o modificacin.Unix es una marca registrada de X/Open, Ltd. Sun4, SPARC, SunOS y Solaris sonmarcas registradas de Sun Microsystems, Inc. DEC, DECstation, Alpha AXP yULTRIX son marcas registradas de Digital Equipment Corp. PA-RISC y HP-UX sonmarcas registradas de Hewlett-Packard Co. OSF/1 es marca registrada de OpenSoftware Foundation.

7

Captulo 2. Arquitectura

2.1. Conceptos de Arquitectura de PostgresAntes de continuar, debera usted conocer la arquitectura bsica del sistema Postgres.El conocimiento de como interactan las partes de Postgres debera aclararse algodurante el siguiente captulo. En la jerga de las bases de datos, Postgres utiliza unsimple modelo cliente/servidor de "proceso por usuario". Una sesin de Postgresconsiste en los siguientes procesos Unix (programas) cooperando:

Un proceso demonio supervisor (postmaster), la aplicacin de interface del usuario (frontend en ingls) (por ejemplo, el programa

psql), y los uno o ms procesos servidores de acceso a la base de datos (backend en ingls)

(el proceso postgres mismo).

Un nico postmaster maneja una coleccin dada de bases de datos en nico host. Talcoleccin se denomina una instalacin o un site. Las aplicaciones de frontend quequieren acceder a una base de datos dada en una instalacin realizan llamadas a lalibrera. La librera enva el requerimiento del usuario a travs de la red al postmaster(Cmo se establece una conexin(a)), quien en su turno arranca un nuevo procesoservidor de backend (Cmo se establece una conexin(b))

Figura 2-1. Cmo se establece una conexin

1

Captulo 2. Arquitectura

y se conecta el proceso cliente al nuevo servidor (Cmo se establece una conexin(c)).> A partir de aqu, el proceso cliente y el servidor se comunican entre ellos sinintervencin del postmaster. En consecuencia, el proceso postmaster est siemprecorriendo, esperando llamadas, mientras que los procesos cliente y servidor vienen yvan. La librera libpq permite a un nico proceso cliente tener mltiples conexionescon procesos servidores. Sin embargo, la aplicacin cliente sigue siendo un procesomono-hebra. Las conexiones con multihebrado cliente/servidor no estn actualmentesoportadas en libpq. Una implicacin de esta arquitectura es que el postmaster y losservidores siempre corren en la misma mquina (el servidor de base de datos), mientrasque el cliente puede correr en cualquier sitio. Debe usted tener esto en cuenta, ya quelos ficheros que pueden estar accesibles en una mquina cliente, pueden no estarlo (oestarlo slo con un nombre de fichero diferente) en la mquina servidor. Debera tenertambin en cuenta que postmaster y los servidores postgres corren bajo el user-id del"superusuario" de Postgres. Ntese que el superusuario de Postgres no tiene porqu serun usuario especial (es decir, un usuario llamado "postgres"), aunque en muchossistemas est instalado as. Ms an, el superusuario de Postgres definitivamente nodebe de ser el superusuario de Unix, "root"! En cualquier caso, todos los ficherosrelacionados con una base de datos deben encontrarse bajo este superusuario dePostgres.

2

Captulo 3. Extensor SQL: PreludioEn la seccion que sigue, trataremos como aadir extensiones al Postgres SQL usandopeticiones del lenguaje:

funciones tipos operadores aadidos

3.1. Como hacer extensible el trabajoPostgres es extensible porque las operaciones son catalogos en disco. Si estfamiliarizado con los estandares de sistemas relacionales, sabe que la informacion sealmacena en bases de datos, tablas, columnas, etc., en lo que se comunmente conocecomo sistema de catalogos. (Algunos sistemas lo llaman diccionario de datos). Elcatalogo aparece al usuario como una clase, como otro objeto cualquiera, pero DBMSlo almacena en una bilioteca. Una diferencia clave entre Postgres y el estandar desistemas relacionales es que Postgres almacena muchas mas informacion en sucatalogos no solo informacion de tablas y columnas, sino tambien informacion sobresus tipos, funciones y metodos de acceso. Estas clases pueden ser modificadas por elusuario, y dado que Postgres basa la operacion interna en todas sus clases, estosignifica que Postgres puede ser extendido por los usuarios. Por comparacion, laconvencion es que los sitemas de base de datos pueden ser extendidos solamantecambiando los procedimientos codificados del DBMS o cargando modulosespecialmente escritos por el vendedor de DBMS.

Postgres es tambien distinto a otros gestores de datos en que el servidor puedeincoporar codigo escrito por el usuario a traves de bibliotecas de carga dinamicas. Osea, el usuario puede especificar un fichero de codigo objeto (p. ej., un fichero

3

Captulo 3. Extensor SQL: Preludio

compilado .o o bibliotecas de intercambio) con lo que se implementa un nuevo tipo ofunciones y Postgres cargara lo que requiera. El codigo escrito en SQL es mas dificil deaadir al servidor. Esta habilitad para modificar la operacion al vuelo hace dePostgres la unica suite para prototipos rapidos de nuevas aplicaciones y estructuras dealmacenamiento.

3.2. El Tipo de Sistema de PostgresEl tipo de sistema de Postgres puede entrar en crisis por varios medios. Los tipos estandivididos en tipos base y tipos compuestos. Los tipos base son precisamente eso, comoint4, que es implementado en leguajes como C. Generalmente se corresponde a locomunmente conocido como "abstract data types"; Postgres puede operar solo con lostipos de metodos provistos por el usuario y solo se entiende el comportamiento de lostipos de la extension que el usuario describe. Los tipos compuestos son los creadoscuando el usuario crea una clase. EMP es un ejemplo de un tipo de composicion.Postgres almacena estos tipos en solo un sentido (que el fichero que almacena todas lasinstancias de las clases) pero el usuario puede "mirar dentro" de estos tipos desde ellenguaje de peticion y optimizar sus recuperacion por (por ejemplo) definir indices enlos atributos. La base de tipos de Postgres esta mas dividida en tipos y tipos definidospor el usuario. Los tipos de construccion (como int4) son los que son compiladosdentro del sistema. Los tipos definidos por el usuario son creados por el usuario de lamanera descrita abajo.

3.3. Acerca de los Sistema de Catalogo dePostgres

Para introducirnos en los conceptos basicos de la extensibilidad, hemos de estudiarcomo se disean los catalogos. Puede saltarse esta seccion ahora, pero algunassecciones mas tarde no seran comprendidas sin la informacion dada aqui, asi quemarque esta pagina como posterior referencia. Todos los sistemas de catalogos tienen

4


un nombre que empieza por pg_. Las siguientes clases contienen informacion que debede ser util para los usuarios finales. (Hay muchas otros sistemas de catalogo, pero estosraramente son pedidos directamente.)

Tabla 3-1. Sistema de Catalogos de Postgres

Nombre del Catalogo Descriccionpg_database base de datospg_class clasespg_attribute atributos de clasespg_index indices secundariospg_proc procedimientos (ambos C y SQL)pg_type tipos (ambos base y complejo)pg_operator operadorespg_aggregate conjunto y conjunto de funcionespg_am metodo de accesopg_amop operador de metodo de accesopg_amproc soporte de operador de metodo de accesopg_opclass operador de clases de metodo de acceso

Figura 3-1. El principal sistema de catalogo de Postgres

El manual de referencia da mas detalle de explicacion de estos catalogos y susatributos. De cualquier manera, El principal sistema de catalogo de Postgres muestrasu mayor entidades y sus relacionamiento en el sistema de catalogo. (Los atributos que

5


no se refieren a otras entidades no son mostrados si no son parte primaria de la llave.Este diagrama puede ser mas o menos incomprensible hasta que realmente comience amirar los contenidos de los catalogos y vea como se relacionan entre si. Por ahora, loprincipal seguir este diagrama:

En varias de las secciones que vienen a continuacion, presentaremos varias consultascompuestas en los catalogos del sistema que presentan informacion que necesitamospara extender el sistema. Mirado este diagrama podremos hacer que algunas de estasconsultas compuestas (que a menudo se componen de tres o cuatro partes) sean Mscomprensibles mas faciles de entender, dado que sera capaz de ver los atributosusados en las claves importadas de los formularios de consulta de otras clases.

Muchas caracteristicas distintas (clases, atributos, funciones, tipos, metodos deacceso, etc) estan estrechamente relacionadas en este esquema. Un simple comandode creacion puede modificar muchos de estos catalogos.

Los tipos y procedimientos son elementos fundamentales de este esquema.

Nota: Usamos las palabras procedure y function de forma mas o menosindistinta.

Practicamente todo catalogo contiene alguna referencia a instancias en una o ambasclases. Por ejemplo, Postgres frecuentemente usa firmas de tipo (por ejemplo, defunciones y operadores) para identificar instancias unicas en otros catalogos.

Hay muchos otros atributos y relaciones que tienen significados obvios, pero hayotros muchos (particularmente aquellos que tienen que ver con los metodos deacceso) que no los tienen. Las relaciones entre pg_am, pg_amop, pg_amproc,pg_operator y pg_opclass son particularmente dificiles de complrender, y serandescritas en profundidad (en la seccion sobre tipos de interfase y operadores deindice) antes de que estudiemos las extensiones basicas.

6

Captulo 4. Extendiendo SQL:Funciones

Parte de definir un tipo nuevo es la definicin de funciones que describen sucomportamiento. Como consecuencia, mientras que es posible definir una nuevafuncin sin definir un tipo nuevo, lo contrario no es cierto. Por ello describimos comoaadir nuevas funciones para Postgres antes de describir cmo aadir nuevos tipos.

Postgres SQL proporciona tres tipos de funciones:

funciones de lenguaje de consultas (funciones escritas en SQL) funciones de lenguaje procedural (funciones escritas en, por ejemplo, PLTCL o

PLSQL) funciones de lenguaje de programacin (funciones escritas en un lenguaje de

programacin compilado tales como C)Cada clase de funcin puede tomar un tipo base, un tipo compuesto o algunacombinacin como argumentos (parmetros). Adems, cada clase de funcn puededevolver un tipo base o un tipo compuesto. Es ms fcil definir funciones SQL, as queempezaremos con ellas. Los ejemplos en esta seccin se puede encontrar tambin enfuncs.sql y funcs.c.

4.1. Funciones de Lenguaje de Consultas (SQL)Las funciones SQL ejecutan una lista arbitraria de consultas SQL, devolviendo losresultados de la ltima consulta de la lista. Las funciones SQL en general devuelvenconjuntos. Si su tipo de retorno no se especifica como un setof, entonces un elementoarbitrario del resultado de la ltima consulta ser devuelto.

El cuerpo de una funcin SQL que sigue a AS debera ser una lista de consultasseparadas por caracteres espacio en blanco y entre parntesis dentro de comillas

7

Captulo 4. Extendiendo SQL: Funciones

simples. Notar que las comillas simples usadas en las consultas se deben escribir comosmbolos de escape, precedindolas con dos barras invertidas.

Los argumentos de la funcin SQL se pueden referenciar en las consultas usando unasintaxis $n: $1 se refiere al primer argumento, $2 al segundo, y as sucesivamente. Si unargumento es complejo, entonces una notacin dot (por ejemplo "$1.emp") se puedeusar para acceder a las propiedades o atributos del argumento o para llamar a funciones.

4.1.1. EjemplosPara ilustrar una funcin SQL sencilla, considere lo siguiente, que se podra usar paracargar en una cuenta bancaria:

create function TP1 (int4, float8) returns int4as update BANK set balance = BANK.balance - $2

where BANK.acctountno = $1select(x = 1)

language sql;

Un usuario podra ejecutar esta funcin para cargar $100.00 en la cuenta 17 de lasiguiente forma:

select (x = TP1( 17,100.0));

El ms interesante ejemplo siguiente toma una argumento sencillo de tipo EMP, ydevuelve resultados mltiples:

select function hobbies (EMP) returns set of HOBBIESas select (HOBBIES.all) from HOBBIES

where $1.name = HOBBIES.personlanguage sql;

8


4.1.2. Funciones SQL sobre Tipos BaseLa funcin SQL ms simple posible no tiene argumentos y sencillamente devuelve untipo base, tal como int4:

CREATE FUNCTION one() RETURNS int4AS SELECT 1 as RESULT LANGUAGE sql;

SELECT one() AS answer;

+-----+

|answer |+-----+

|1 |+-----+

Notar que definimos una lista objetivo para la funcin (con el nombre RESULT), perola lista objetivo de la consulta que llam a la funcin sobreescribi la lista objetivo dela funcin. Por esto, el resultado se etiqueta answer en vez de one.

Es casi tan fcil definir funciones SQL que tomen tipos base como argumentos. En elejemplo de abajo, note cmo nos referimos a los argumentos dentro de la funcin como$1 y $2:

CREATE FUNCTION add_em(int4, int4) RETURNS int4AS SELECT $1 + $2; LANGUAGE sql;

SELECT add_em(1, 2) AS answer;

+-----+

|answer |+-----+

9


|3 |+-----+

4.1.3. Funciones SQL sobre Tipos CompuestosAl especificar funciones con argumentos de tipos compuestos (tales como EMP),debemos no solo especificar qu argumento queremos (como hicimos ms arriba con$1 y $2) sino tambin los atributos de ese argumento. Por ejemplo, observe la funcindouble_salary que procesa cual sera su salario si se doblase:

CREATE FUNCTION double_salary(EMP) RETURNS int4AS SELECT $1.salary * 2 AS salary; LANGUAGE sql;

SELECT name, double_salary(EMP) AS dreamFROM EMPWHERE EMP.cubicle ~= (2,1)::point;

+---+-----+

|name | dream |+---+-----+

|Sam | 2400 |+---+-----+

Note el uso de la sintaxis $1.salary. Antes de adentrarnos en el tema de las funcionesque devuelven tipos compuestos, debemos presentar primero la notacin de la funcinpara proyectar atributos. La forma sencilla de explicar esto es que podemosnormalmente usar la notacin atributo(clase) y clase.atributo indistintamente:

-

10


- esto es lo mismo que:- SELECT EMP.name AS youngster FROM EMP WHERE EMP.age < 30-

SELECT name(EMP) AS youngsterFROM EMPWHERE age(EMP) < 30;

+-------+

|youngster |+-------+

|Sam |+-------+

Como veremos, sin embargo, no siempre es este el caso. Esta notacin de funcin esimportante cuando queremos usar una funcin que devuelva una nica instancia.Hacemos esto embebiendo la instancia completa dentro de la funcin, atributo poratributo. Esto es un ejemplo de una funcin que devuelve una nica instancia EMP:

CREATE FUNCTION new_emp() RETURNS EMPAS SELECT \None\::text AS name,1000 AS salary,25 AS age,\(2,2)\::point AS cubicleLANGUAGE sql;

En este caso hemos especificado cada uno de los atributos con un valor constante, perocualquier computacin o expresin se podra haber sustituido por estas constantes.Definir una funcin como esta puede ser delicado. Algunos de las deficiencias msimportantes son los siguientes:

11


La orden de la lista objetivo debe ser exactamente la misma que aquella en la que losatributos aparezcan en la orden CREATE TABLE (o cuando ejecute una consulta .*).

Se debe encasillar las expresiones (usando ::) muy cuidadosamente o ver elsiguiente error:WARN::function declared to return type EMP does not retrieve (EMP.*)

Al llamar a una funcin que devuelva una instancia, no podemos obtener la instanciacompleta. Debemos o bien proyectar un atributo fuera de la instancia o bien pasar lainstancia completa a otra funcin.

SELECT name(new_emp()) AS nobody;

+-----+

|nobody |+-----+

|None |+-----+

La razn por la que, en general, debemos usar la sintaxis de funcin para proyectarlos atributos de los valores de retorno de la funcin es que el parser no comprende laotra sintaxis (dot) para la proyeccin cuando se combina con llamadas a funciones.

SELECT new_emp().name AS nobody;WARN:parser: syntax error at or near "."

Cualquier coleccin de ordenes en el lenguaje de consulta SQL se pueden empaquetarjuntas y se pueden definir como una funcin. Las ordenes pueden incluir updates (esdecir, consultas INSERT, UPDATE, y DELETE) as como SELECT. Sin embargo, laorden final debe ser un SELECT que devuelva lo que se especifique como el tipo deretorno de la funcin.

CREATE FUNCTION clean_EMP () RETURNS int4AS DELETE FROM EMP WHERE EMP.salary


LANGUAGE sql;

SELECT clean_EMP();

+-+

|x |+-+

|1 |+-+

4.2. Funciones de Lenguaje ProceduralLos lenguajes procedurales no estn construidos dentro de Postgres. Se proporcionancomo mdulos cargables. Por favor dirjase a la documentacin para el PL en cuestinpara los detalles sobre la sintaxis y cmo la clusula AS se interpreta por el manejadordel PL.

Hay dos lenguajes procedurales disponibles con la distribucin estndar de Postgres(PLTCL y PLSQL), y otros lenguajes se pueden definir. Dirjase a LenguajesProcedurales para ms informacin.

4.3. Funciones InternasLas funciones internas son funciones escritas en C que han sido enlazadasestticamente en el proceso backend de Postgres. La clusula da el nombre en lenguajeC de la funcin, que no necesita ser el mismo que el nombre que se declara para el usode SQL. (Por razones de compatibilidad con versiones anteriores, una cadena AS vacase acepta con el significado de que el nombre de la funcin en lenguaje C es el mismo

13


que el nombre en SQL.) Normalmente, todas las funciones internas presentes en elbackend se declaran como funciones SQL durante la inicializacin de la base de datos,pero un usuario podra usar CREATE FUNCTION para crear nombres de aliasadicionales para una funcin interna.

4.4. Funciones de Lenguaje Compilado (C)Las funciones escritas en C se pueden compilar en objetos que se pueden cargar deforma dinmica, y usar para implementar funciones SQL definidas por el usuario. Laprimera vez que la funcin definida por el usuario es llamada dentro del backend, elcargador dinmico carga el cdigo objeto de la funcin en memoria, y enlaza la funcincon el ejecutable en ejecucin de Postgres. La sintaxis SQL para CREATEFUNCTION enlaza la funcin SQL a la funcin en cdigo C de una de dos formas. Sila funcin SQL tiene el mismo nombre que la funcin en cdigo C se usa la primeraforma. El argumento cadena en la clusula AS es el nombre de camino (pathname)completo del fichero que contiene el objeto compilado que se puede cargar de formadinmica. Si el nombre de la funcin C es diferente del nombre deseado de la funcinSQL, entonces se usa la segunda forma. En esta forma la clusula AS toma dosargumentos cadena, el primero es el nombre del camino completo del fichero objetoque se puede cargar de forma dinmica, y el segundo es el smbolo de enlace que elcargador dinmico debera buscar. Este smbolo de enlace es solo el nombre de funcinen el cdigo fuente C.

Nota: Despus de que se use por primera vez, una funcin de usuario,dinmicamente cargada, se retiene en memoria, y futuras llamadas a la funcinsolo incurren en la pequea sobrecarga de una bsqueda de tabla de smbolos.

La cadena que especifica el fichero objeto (la cadena en la clusula AS) debera ser elcamino completo del fichero de cdigo objeto para la funcin, unido por comillassimples. Si un smbolo de enlace se usa en la clusula AS, el smbolo de enlace sedebera unir por comillas simples tambin, y debera ser exactamente el mismo que el

14


nombre de la funcin en el cdigo fuente C. En sistemas Unix la orden nm imprimirtodos los smbolos de enlace de un objeto que se puede cargar de forma dinmica.(Postgres no compilar una funcin automticamente; se debe compilar antes de que seuse en una orden CREATE FUNCTION. Ver abajo para informacin adicional.)

4.4.1. Funciones de Lenguaje C sobre Tipos BaseLa tabla siguiente da el tipo C requerido para los parmetros en las funciones C que secargarn en Postgres. La columna "Defined In" da el fichero de cabecera real (en eldirectorio .../src/backend/) en el que el tipo C equivalente se define. Sin embargo,si incluye utils/builtins.h, estos ficheros se incluirn de forma automtica.

Tabla 4-1. Tipos de C equivalentes para los tipos internos de Postgres

Built-In Type C Type Defined Inabstime AbsoluteTime utils/nabstime.hbool bool include/c.hbox (BOX *) utils/geo-decls.hbytea (bytea *) include/postgres.hchar char N/Acid CID include/postgres.hdatetime (DateTime *) include/c.h or

include/postgres.hint2 int2 include/postgres.hint2vector (int2vector *) include/postgres.hint4 int4 include/postgres.hfloat4 float32 or (float4 *) include/c.h or

include/postgres.hfloat8 float64 or (float8 *) include/c.h or

include/postgres.hlseg (LSEG *) include/geo-decls.h

15


Built-In Type C Type Defined Inname (Name) include/postgres.hoid oid include/postgres.hoidvector (oidvector *) include/postgres.hpath (PATH *) utils/geo-decls.hpoint (POINT *) utils/geo-decls.hregproc regproc or REGPROC include/postgres.hreltime RelativeTime utils/nabstime.htext (text *) include/postgres.htid ItemPointer storage/itemptr.htimespan (TimeSpan *) include/c.h or

include/postgres.htinterval TimeInterval utils/nabstime.huint2 uint16 include/c.huint4 uint32 include/c.hxid (XID *) include/postgres.h

Internamente, Postgres considera un tipo base como un "blob de memoria". Lasfunciones definidas por el usuario que usted define sobre un tipo en turn definen laforma en que Postgres puede operar sobre l. Esto es, Postgres solo almacenar yrecuperar los datos desde disco y solo usar sus funciones definidas por el usuariopara introducir y procesar los datos, as como para obtener la salida de los datos. Lostipos base pueden tener uno de los tres formatos internos siguientes:

pass by value, fixed-length

pass by reference, fixed-length

pass by reference, variable-length

16


Los tipos por valor solo pueden tener 1, 2 o 4 bytes de longitud (incluso si sucomputadora soporta tipos por valor de otros tamaos). Postgres mismo solo pasa lostipos entero por valor. Debera tener cuidado al definir sus tipos para que tengan elmismo tamao (en bytes) en todas las arquitecturas. Por ejemplo, el tipo long espeligroso porque es de 4 bytes en algunas mquinas y de 8 bytes en otras, mientras queel tipo int es de 4 bytes en la mayora de las mquinas Unix (aunque no en la mayorade computadores personales). Una implementacin razonable del tipo int4 en lasmquinas Unix podra ser:

/* 4-byte integer, passed by value */typedef int int4;

En el otro lado, los tipos de longitud fija de cualquier tamao se pueden pasar porreferencia. Por ejemplo, aqu se presenta una implementacin de ejemplo de un tipo dePostgres:

/* 16-byte structure, passed by reference */typedef struct{

double x, y;} Point;

Solo los punteros a tales tipos se pueden usar a la hora de pasarlos como argumentos deentrada o de retorno en las funciones de Postgres. Finalmente, todos los tipos delongitud variable se deben pasar tambin por referencia. Todos los tipos de longitudvariable deben comenzar con un campo length de exactamente 4 bytes, y todos losdatos que se tengan que almacenar dentro de ese tipo deben estar situados en lamemoria inmediatamente a continuacin de ese campo length. El campo length es lalongitud total de la estructura (es decir, incluye el tamao del campo length mismo).Podemos definir el tipo texto como sigue:

17


typedef struct {int4 length;char data[1];

} text;

Obviamente, el campo data no es suficientemente largo para almacenar todas lascadenas posibles; es imposible declarar tal estructura en C. Al manipular tipos delongitud variable, debemos tener cuidado de reservar la cantidad de memoria correcta yde inicializar el campo length. Por ejemplo, si quisiramos almacenar 40 bytes en unaestructura text, podramos usar un fragmento de cdigo como este:

#include "postgres.h"...

char buffer[40]; /* our source data */...

text *destination = (text *) palloc(VARHDRSZ + 40);destination->length = VARHDRSZ + 40;memmove(destination->data, buffer, 40);...

Ahora que hemos visto todas las estructuras posibles para los tipos base, podemosmostrar algunos ejemplos de funciones reales. Suponga que funcs.c es as:

#include #include "postgres.h"

/* By Value */

intadd_one(int arg){

return(arg + 1);

18


}

/* By Reference, Fixed Length */

Point *makepoint(Point *pointx, Point *pointy ){

Point *new_point = (Point *) palloc(sizeof(Point));

new_point->x = pointx->x;new_point->y = pointy->y;

return new_point;}

/* By Reference, Variable Length */

text *copytext(text *t){

/** VARSIZE is the total size of the struct in bytes.*/text *new_t = (text *) palloc(VARSIZE(t));memset(new_t, 0, VARSIZE(t));VARSIZE(new_t) = VARSIZE(t);/** VARDATA is a pointer to the data region of the struct.*/memcpy((void *) VARDATA(new_t), /* destination */

(void *) VARDATA(t), /* source */VARSIZE(t)-VARHDRSZ); /* how many bytes */

return(new_t);}

text *concat_text(text *arg1, text *arg2)

19


{int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) -

VARHDRSZ;text *new_text = (text *) palloc(new_text_size);

memset((void *) new_text, 0, new_text_size);VARSIZE(new_text) = new_text_size;strncpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-

VARHDRSZ);strncat(VARDATA(new_text), VARDATA(arg2), VARSIZE(arg2)-

VARHDRSZ);return (new_text);

}

On OSF/1 we would type:

CREATE FUNCTION add_one(int4) RETURNS int4AS PGROOT/tutorial/funcs.so LANGUAGE c;

CREATE FUNCTION makepoint(point, point) RETURNS pointAS PGROOT/tutorial/funcs.so LANGUAGE c;

CREATE FUNCTION concat_text(text, text) RETURNS textAS PGROOT/tutorial/funcs.so LANGUAGE c;

CREATE FUNCTION copytext(text) RETURNS textAS PGROOT/tutorial/funcs.so LANGUAGE c;

En otros sistemas, podramos tener que especificar la extensin del nombre del ficherocomo .sl (para indicar que es una librera (o biblioteca) compartida).

20


4.4.2. Funciones del Lenguaje C sobre TiposCompuestos

Los tipos compuestos no tienen un formato fijo como las estructuras de C. Lasinstancias de un tipo compuesto pueden contener campos null. Adems, los tiposcompuestos que son parte de una jerarqua de herencia pueden tener campos diferentesrespecto a otros miembros de la misma jerarqua de herencia. Por ello, Postgresproporciona una interfaz procedural para acceder a los campos de los tipos compuestosdesde C. Cuando Postgres procesa un conjunto de instancias, cada instancia se pasar asu funcin como una estructura opaca de tipo TUPLE. Suponga que queremos escribiruna funcin para responder a la consulta

* SELECT name, c_overpaid(EMP, 1500) AS overpaidFROM EMPWHERE name = Bill or name = Sam;

En la consulta anterior, podemos definir c_overpaid como:

#include "postgres.h"#include "executor/executor.h" /* for GetAttributeByNa-

me() */

boolc_overpaid(TupleTableSlot *t, /* the current instance of EMP */

int4 limit){

bool isnull = false;int4 salary;salary = (int4) GetAttributeByName(t, "salary", &isnull);if (isnull)

return (false);return(salary > limit);

}

21


GetAttributeByName es la funcin de sistema de Postgres que devuelve los atributosfuera de la instancia actual. Tiene tres argumentos: el argumento de tipo TUPLE pasadoa la funcin, el nombre del atributo deseado, y un parmetro de retorno que describe siel atributo es null. GetAttributeByName alinear los datos apropiadamente de formaque usted pueda convertir su valor de retorno al tipo deseado. Por ejemplo, si tiene unatributo name que es del tipo name, la llamada a GetAttributeByName sera as:

char *str;...

str = (char *) GetAttributeByName(t, "name", &isnull)

La consulta siguiente permite que Postgres conozca a la funcin c_overpaid:

* CREATE FUNCTION c_overpaid(EMP, int4) RETURNS boolAS PGROOT/tutorial/obj/funcs.so LANGUAGE c;

Aunque hay formas de construir nuevas instancias o de modificar las instanciasexistentes desde dentro de una funcin C, stas son demasiado complejas paradiscutirlas en este manual.

4.4.3. Escribiendo cdigoAhora volvemos a la tarea ms difcil de escribir funciones del lenguaje deprogramacin. Aviso: esta seccin del manual no le har un programador. Debe tenerun gran conocimiento de C (incluyendo el uso de punteros y el administrador dememoria malloc) antes de intentar escribir funciones C para usarlas con Postgres.Aunque sera posible cargar funciones escritas en lenguajes distintos a C en Postgres,eso es a menudo difcil (cuando es posible hacerlo completamente) porque otros

22


lenguajes, tales como FORTRAN y Pascal a menudo no siguen la misma convencin dellamada que C. Esto es, otros lenguajes no pasan argumentos y devuelven valores entrefunciones de la misma forma. Por esta razn, asumiremos que las funciones de sulenguaje de programacin estn escritas en C.Las funciones C con tipos base como argumentos se pueden escribir de una formasencilla. Los equivalentes C de los tipos internos de Postgres son accesibles en unfichero C si PGROOT/src/backend/utils/builtins.h se incluye como un ficherode cabecera. Esto se puede conseguir escribiendo

#include

al principio del fichero fuente C.

Las reglas bsicas para construir funciones C son las siguientes:

La mayora de los ficheros cabecera (include) para Postgres deberan estar yainstalados en PGROOT/include (ver Figura 2). Debera incluir siempre-I$PGROOT/include

en sus lneas de llamada a cc. A veces, podra encontrar que necesita ficheroscabecera que estn en el cdigo fuente del servidor mismo (es decir, necesita unfichero que no hemos instalado en include). En esos casos puede necesitar aadir unoo ms de-I$PGROOT/src/backend-I$PGROOT/src/backend/include-I$PGROOT/src/backend/port/-I$PGROOT/src/backend/obj(donde es el nombre del puerto, por ejemplo, alpha or sparc).

Al reservar memoria, use las rutinas de Postgres palloc y pfree en vez de las rutinasde la librera de C correspondientes malloc y free. La memoria reservada por pallocse liberar automticamente al final de cada transaccin, previniendo fallos dememoria.

23


Siempre cntrese en los bytes de sus estructuras usando memset o bzero. Variasrutinas (tales como el mtodo de acceso hash, hash join y el algoritmo sort)computan funciones de los bits puros contenidos en su estructura. Incluso si ustedinicializa todos los campos de su estructura, puede haber varios bytes de relleno dealineacin (agujeros en la estructura) que pueden contener valores incorrectos obasura.

La mayora de los tipos internos de Postgres se declaran en postgres.h, por eso esuna buena idea incluir siempre ese fichero tambin. Incluyendo postgres.h incluirtambin elog.h y palloc.h por usted.

Compilar y cargar su cdigo objeto para que se pueda cargar dinmicamente enPostgres siempre requiere flags (o banderas) especiales. Ver Enlazando funciones decarga dinmica para una explicacin detallada de cmo hacerlo para su sistemaoperativo concreto.

4.5. Sobrecarga de funcionesSe puede definir ms de una funcin con el mismo nombre, siempre que losargumentos que tomen sean diferentes. En otras palabras, los nombres de las funcionesse pueden sobrecargar. Una funcin puede tener adems el mismo nombre que unatributo. En el caso de que haya ambigedad entre una funcin sobre un tipo complejoy un atributo del tipo complejo, se usar siempre el atributo.

4.5.1. Conflictos en el Espacio de NombresA partir de Postgres v6.6, la forma alternativa de la clusula AS para la orden de SQLCREATE FUNCTION desempareja el nombre de la funcin SQL del nombre defuncin en el cdigo fuente C. Esta es ahora la tcnica preferida para realizar lasobrecarga de funciones.

24


4.5.1.1. Pre-v6.6Para funciones escritas en C, el nombre SQL declarado en CREATE FUNCTIONdebe ser exactamente el mismo que el nombre real de la funcin en el cdigo C (debidoa esto debe ser un nombre de funcin de C legal).Hay una sutil consecuencia de este restriccin: mientras las rutinas de carga dinmicasen la mayora de los sistemas operativos estn mas que felices de permitirle cargarcualquier nmero de libreras compartidas que contienen nombres de funcionesconflictivos (con idnticos nombres), pueden, de hecho, chapucear la carga de formasinteresantes. Por ejemplo, si usted define una funcin dinmicamente cargada queresulta tener el mismo nombre que una funcin perteneciente a Postgres, el cargadorDEC OSF/1 dinmico hace que Postgres llame a la funcin dentro de l mismopreferiblemente a dejar que Postgres llame a su funcin. Por esto, si quiere que sufuncin se use en diferentes arquitecturas, recomendamos que no sobrecargue losnombres de las funciones C.

Hay un truco ingenioso para resolver el problema que se acaba de describir. Dado queno hay problemas al sobrecargar funciones SQL, usted puede definir un conjunto defunciones C con nombres diferentes y entonces definir un conjunto de funciones SQLcon idnticos nombres que tomen los tipos de argumentos apropiados y llamen a lafuncin C correspondiente.

Otra solucin es no usar la carga dinmica, sino enlazar sus funciones al backendstticamente y declararlas como funciones INTERNAL. Entonces, las funciones debentener todas nombres C distintos pero se pueden declarar con los mismos nombres SQL(siempre que los tipos de sus argumentos difieran, por supuesto). Esta forma evita lasobrecarga de una funcin wrapper (o envolvente) SQL, con la desventaja de un mayoresfuerzo para preparar un ejecutable del backend a medida. (Esta opcin estdisponible slo en la versin 6.5 y posteriores, dado que las versiones anterioresrequeran funciones internas para tener el mismo nombre en SQL que en el cdigo C.)

25

Captulo 5. Extendiendo SQL: TiposComo se mencion anteriormente, hay dos clases de tipos en Postgres: tipos base(definidos en un lenguaje de programacin) y tipos compuestos (instancias). Losejemplos en esta seccin hasta los de ndices de interfaz se pueden encontrar encomplex.sql y complex.c. Los ejemplos compuestos estn en funcs.sql.

5.1. Tipos Definidos por el Usuario

5.1.1. Funciones Necesarias para un Tipo Definido por elUsuario

Un tipo definido por el usuario debe tener siempre funciones de entrada y salida. Estasfunciones determinan cmo aparece el tipo en las cadenas (para la entrada por elusuario y la salida para el usuario) y cmo se organiza el tipo en memoria. La funcinde entrada toma una cadena de caracteres delimitada por null como su entrada ydevuelve la representacin interna (en memoria) del tipo. La funcin de salida toma larepresentacin interna del tipo y devuelve una cadena de caracteres delimitada por null.Suponga que queremos definir un tipo complejo que representa nmeros complejos.Naturalmente, elegimos representar un complejo en memoria como la siguienteestructura en C:

typedef struct Complex {double x;double y;

} Complex;

y una cadena de la forma (x, y) como la representacin externa de la cadena. Estasfunciones normalmente no son difciles de escribir, especialmente la funcin de salida.Sin embargo, hay varios puntos a recordar:

26

Captulo 5. Extendiendo SQL: Tipos

Al definir su representacin externa (cadena), recuerde que al final debe escribir unparser completo y robusto para esa representacin como su funcin de entrada!

Complex *complex_in(char *str){

double x, y;Complex *result;if (sscanf(str, " ( %lf , %lf )", &x, &y) != 2) {

elog(WARN, "complex_in: error in parsingreturn NULL;

}result = (Complex *)palloc(sizeof(Complex));result->x = x;result->y = y;return (result);

}

La funcin de salida puede ser sencillamente:char *complex_out(Complex *complex){

char *result;if (complex == NULL)

return(NULL);result = (char *) palloc(60);sprintf(result, "(%g,%g)", complex->x, complex-

>y);return(result);

}

Debera intentar hacer las funciones de entrada y salida inversas la una a la otra. Sino lo hace, tendr problemas serios cuando necesite volcar sus datos en un fichero ydespus leerlos (por ejemplo, en la base de datos de otra persona en otracomputadora). Este es un problema particularmente comn cuando hay nmeros enpunto flotante de por medio.

27


Para definir el tipo complejo, necesitamos crear las dos funciones definidas por elusuario complex_in y complex_out antes de crear el tipo:

CREATE FUNCTION complex_in(opaque)RETURNS complexAS PGROOT/tutorial/obj/complex.soLANGUAGE c;

CREATE FUNCTION complex_out(opaque)RETURNS opaqueAS PGROOT/tutorial/obj/complex.soLANGUAGE c;

CREATE TYPE complex (internallength = 16,input = complex_in,output = complex_out

);

Como se discuti antes, Postgres soporta totalmente vectores (o arrays) de tipos base.Adems, Postgres soporta vectores de tipos definidos por el usuario tambin. Cuandousted define un tipo, Postgres automticamente proporciona soporte para vectores deese tipo. Por razones histricas, el tipo vector tiene el mismo nombre que el tipodefinido por el usuario con el carcter subrayado _ antepuesto. Los tipos compuestosno necesitan ninguna funcin definida sobre ellos, dado que el sistema ya comprendecmo son por dentro.

5.1.2. Objetos GrandesLos tipos discutidos hasta este punto son todos objetos "pequeos" esto es, sonmenores que 8KB en tamao.

Nota: 1024 longwords == 8192 bytes. De hecho, el tipo debe ser

28


considerablemente menor que 8192 bytes, dado que las pginas y tuplas desobrecarga de Postgres deben caber en esta limitacin de 8KB tambin. El valorreal que cabe depende de la arquitectura de la mquina.

Si usted necesita un tipo ms grande para algo como un sistema de recuperacin dedocumentos o para almacenar bitmaps, necesitar usar la interfaz de grandes objetos dePostgres.

29

Captulo 6. Extenediendo SQL:Operadores

Postgres soporta operadores unitarios izquierdos, unitarios derechos y binarios. Losoperadores pueden ser sobrecargados; eso es, el mismo nombre de operador puede serusado para diferentes operadores que tengan diferentes nmero y tipo de argumentos.Si hay una situacin ambigua y el sistema no puede determinar el operador correcto ausar, retornar un error. Tu puedes tener los tipos de operadores izquierdo y/o derechopara ayudar a entender que operadores tienen significado usar.

Cada operador es "azucar sintctico" por una llamada hacia una funcin subyacenteque hace el trabajo real; entonces tu debes primero crear la funcin subyacente antes deque puedas crear el operador. Sin embargo, un operador no es slo un azucar sintctico,porque carga informacin adicional que ayuda al planeador de consultas a obtimizarconsultas que usa el operador. Mucho de este captulo, ser dedicado a explicar esainformacin adicional. merely syntactic sugar, because it carries additional information

Este es un ejemplo de crear un operador para sumar dos nmeros complejos. Nosotrosaumimos que ya hemos creado la definicin del tipo complejo. Primero necesitamosuna funcin que haga el tragajo; entonces podemos crear el operador.CREATE FUNCTION complex_add(complex, complex)

RETURNS complexAS $PWD/obj/complex.soLANGUAGE c;

CREATE OPERATOR + (leftarg = complex,rightarg = complex,procedure = complex_add,commutator = +

);

30

Captulo 6. Extenediendo SQL: Operadores

Ahora podemos hacer:

SELECT (a + b) AS c FROM test_complex;

+-----------+

|c |+-----------+

|(5.2,6.05) |+-----------+

|(133.42,144.95) |+-----------+

Nosotros hemos mostrado como crear un operador binario aqu. Para crear un operadorunario, solamente omite un argumento izquierdo (para unario izquierdo) o unargumento derecho (para unario derecho). El procedimietno y las sentencias delargumneto son los nicos items requeridos para CREATE OPERATOR (Crearoperador). La sentencia COMMUTATOR (conmutador) mostrada en esta ejemplo esuna indicacin opcional para optimizar la consulta. Adems de los detalles acerca deCOMMUTATOR, aparecen otras indicaciones de optimizacin.

6.1. Informacin de optimizacin de operadorAutor: Escrito por Tom Lane.

Una definicin de un operador Postgres puede incluir muchas sentencias opcionalesque dicen al sistema cosas tiles acerca de como el operador se comporta. Estassentencias deben ser proveidas siempre que sea apropiado, porque ellas pueden hacerconsiderablemente una ms rpida ejecucin de la consulta que usa el operador. Pero situ las provees, debes estar seguro que estn bien! Un incorrecto uso de una sentencia deoptimizacin puede resultar en choques finales, salidas sutilmente errneas, o otras

31

Captulo 6. Extenediendo SQL: Operadores

cosas malas. Tu puedes no poner las sentencias de optimizacin si no ests seguro deellas, la nica consecuencia es que las consultas pueden ejecutarse ms lentamente delo necesario.

Sentencias de optimizacin adicionales pueden ser agregadas en versiones posterioresde Postgres. Las descrptas aqu son todas aquellas que la versin 6.5 entinede.

6.1.1. COMMUTATOR (conmutador)La sentencia COMMUTATOR ,si es proveida, nombra un operador que es elconmutador del operador que est siendo definido. Decimos que el operador A es elconmutador del operador B si (x A y) es igual (y B x) para todos los posibles valores deentrada x,y. Nota que B es tambin el conmutador de A. Por ejemplo, operadores (y lgico) para un tipo de dato particular son usualmente entre s conmutadores,y el operador + es usualmente conmutativo con sigo mismo.Pero el operador - no esconmutativo con nada.

El tipo de argumento izquierdo de un operador conmutado es el mismo que el tipo deargumento derecho de su conmutador, y viceversa. Entonces el nombre del operadorconmutador es todo lo que Postgres necesita para ser dado de alta el conmutador y esoes todo lo que necesita ser proveido en la sentencia COMMUTATOR.

Cuando tu estas definiendo un operador conmutador por si mismo (self-conmutative),tu solamente hazlo.Cuando tu estas definiendo un par de operadores conmutadores, lascosas son un poquito mas engaosas: Cmo pede el primero ser definido refirindose aotro, que no ha sido definido todava? hay dos soluciones a este problema:

Un mtodo es omitir la sentencia COMMUTATOR en el primer operador que tudefines, y entonces proveer uno en la segunda definicin de operador. Desde quePostgres sabe que operadores conmutativos vienen de a pares, cuando ve la segundadefinicin automaticamente vol

postgres programmer

Documents