Documento con el trabajo completo

MAQUETA DCC
POSTGRESQL
Software Libre y Compromiso Social
Autor: Fc. Javier González Rivera
Fecha: 2014/05/12
ÍNDICE
1.
INTRODUCCIÓN ........................................................................................................ 3
1.1. Breve descripción del trabajo a realizar ..............................................................................3
1.2. Lenguajes de Programación/Tecnologías utilizados ..........................................................3
1.3. Descripción de cada elemento desarrollado .......................................................................3
2.
SOBRE POSTGRESQL .............................................................................................. 4
2.1. ¿Qué es PostgreSQL? ........................................................................................................4
2.2. Características ....................................................................................................................5
2.2.1.
Características Generales ........................................................................................5
2.2.2.
Características Programación / Desarrollo ...............................................................6
2.2.3.
Características SQL ..................................................................................................6
2.2.4.
Características versiones PostgreSQL .....................................................................7
2.2.5.
Algunos de los límites de PostgreSQL .....................................................................7
3.
HISTORIA ................................................................................................................... 7
3.1.
3.2.
3.3.
3.4.
4.
5.
6.
CICLO DE VIDA (EOL) Y SOPORTE ....................................................................... 10
INSTALACIÓN BÁSICA PostgreSQL 9.3.4 EN UBUNTU 12.04 ............................. 11
ALGUNOS CONCEPTOS A TENER ENCUTA PARA TRABRAJAR CON
POSTGRESQL ......................................................................................................... 12
6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
7.
Ingres 1977-1985 - "El comienzo" .......................................................................................7
Postgres 1986-1994 - Después (post) de Ingres ................................................................8
Postgres95 1994-1995 - Nueva vida en el mundo opensource ..........................................8
PostgreSQL 1996-actualidad - Proyecto PostgreSQL ........................................................9
Jerarquía de PostgreSQL..................................................................................................12
Transacciones ...................................................................................................................12
PSQL .................................................................................................................................12
pgAdmin III ........................................................................................................................13
Tablespace ........................................................................................................................14
Tabla DUAL .......................................................................................................................14
MAQUETA DCC ....................................................................................................... 15
7.1. Tabla DUAL .......................................................................................................................15
7.2. Tipos de datos utilizados ...................................................................................................15
REFERENCIAS Y ENLACES DE INTERÉS ............................................................. 16
SLSC. Maqueta DCC PostgreSQL.
8.
2 de 16
1.
INTRODUCCIÓN
En este trabajo se pretende analizar/estudiar el sistema de gestión de bases de
datos PostgreSQL y las posibilidades que ofrece.
1.1. Breve descripción del trabajo a realizar
Mediante la elaboración de una maqueta del modelo de datos de la aplicación
DCC (Diraya Clínico Centralizado) en el sistema de gestión de bases de datos
PostgreSQL, se analizará el manejo y las características de PostgreSQL,
basándonos en la experiencia laboral sobre el sistema de gestión de bases de
datos Oracle.
La idea es evaluar PostgreSQL y la viabilidad de poder utilizarlo en pequeñas
aplicaciones multiusuario de servicio online.
1.2. Lenguajes de Programación/Tecnologías utilizados
 SQL
 PL/pgSQL (similar al PL/SQL de Oracle)
1.3. Descripción de cada elemento desarrollado
 Tablas y tipos de datos principales (numéricos, cadenas, fechas, booleanos,
campos de gran tamaño estilo LONG, CLOB de Oracle)
 Claves Primarias, Claves Foráneas y Constraint (restricciones)
 Índices
 Secuencias
 Disparadores (triggers)
 Objetos PL/pgSQL: funciones, procedimientos y paquetes
 Sinónimos
 Vistas
 Enlaces de bases de datos
 Vistas Materializadas
 Replicación de Vistas Materializadas (completas e incrementales)
 Usuarios
 Roles
 Jobs
 Contextos
SLSC. Maqueta DCC PostgreSQL.
Con la Maqueta DCC PostgreSQL se evaluarán los siguientes elementos de
desarrollo:
3 de 16
2.
SOBRE POSTGRESQL
La información de este punto se puede obtener en:
http://www.postgresql.org.es/sobre_postgresql
2.1. ¿Qué es PostgreSQL?
PostgreSQL es un sistema de gestión de bases de datos objeto-relacional,
distribuido bajo licencia BSD y con su código fuente disponible libremente.
PostgreSQL utiliza un modelo cliente/servidor y usa multiprocesos en vez de
multihilos para garantizar la estabilidad del sistema. Un fallo en uno de los
procesos no afectará el resto y el sistema continuará funcionando.
SLSC. Maqueta DCC PostgreSQL.
A continuación tenéis un gráfico que ilustra de manera general los componentes
más importantes en un sistema PostgreSQL.
4 de 16
 Aplicación cliente: Esta es la aplicación cliente que utiliza PostgreSQL
como administrador de bases de datos. La conexión puede ocurrir via
TCP/IP o sockets locales.
 Demonio postmaster: Este es el proceso principal de PostgreSQL. Es el
encargado de escuchar por un puerto/socket por conexiones entrantes de
clientes. También es el encargado de crear los procesos hijos que se
encargaran de autentificar estas peticiones, gestionar las consultas y
mandar los resultados a las aplicaciones clientes.
 Ficheros de configuración: Los 3 ficheros principales de configuración
utilizados por PostgreSQL, postgresql.conf, pg_hba.conf y pg_ident.conf.
 Procesos hijos postgres: Procesos hijos que se encargan de autentificar a
los clientes, de gestionar las consultas y mandar los resultados a las
aplicaciones clientes.
 PostgreSQL share buffer cache: Memoria compartida usada por
PostgreSQL para almacenar datos en caché.
 Write-Ahead Log (WAL): Componente del sistema encargado de asegurar
la integridad de los datos (recuperación de tipo REDO).
 Kernel disk buffer cache: Caché de disco del sistema operativo.
 Disco: Disco físico donde se almacenan los datos y toda la información
necesaria para que PostgreSQL funcione.
2.2. Características
La última serie de producción es la 9.3. Sus características técnicas la hacen una
de las bases de datos más potentes y robustas del mercado. Su desarrollo
comenzó hace más de 16 años, y durante este tiempo, estabilidad, potencia,
robustez, facilidad de administración e implementación de estándares han sido las
características que más se han tenido en cuenta durante su desarrollo.
PostgreSQL funciona muy bien con grandes cantidades de datos y una alta
concurrencia de usuarios accediendo a la vez al sistema.
A continuación tenéis algunas de las características más importantes y soportadas
por PostgreSQL:










Es una base de datos 100% ACID.
Integridad referencial.
Tablespaces.
Nested transactions (savepoints).
Replicación asincrónica/sincrónica / Streaming replication - Hot Standby
Two-phase commit.
PITR - point in time recovery.
Copias de seguridad en caliente (Online/hot backups).
Unicode.
Juegos de caracteres internacionales.
SLSC. Maqueta DCC PostgreSQL.
2.2.1.Características Generales
5 de 16









Regionalización por columna.
Multi-Version Concurrency Control (MVCC).
Multiples métodos de autentificación.
Acceso encriptado vía SSL.
Actualización in-situ integrada (pg_upgrade).
SE-postgres.
Completa documentación.
Licencia BSD.
Disponible para Linux y UNIX en todas sus variantes (AIX, BSD, HP-UX,
SGI IRIX, Mac OS X, Solaris, Tru64) y Windows 32/64bit.
2.2.2.Características Programación / Desarrollo
 Funciones/procedimientos almacenados (stored procedures) en numerosos
lenguajes de programación, entre otros PL/pgSQL (similar al PL/SQL de
Oracle), PL/Perl, PL/Python y PL/Tcl.
 Bloques anónimos de código de procedimientos (sentencias DO).
 Numerosos tipos de datos y posibilidad de definir nuevos tipos. Además de
los tipos estándares en cualquier base de datos, tenemos disponibles, entre
otros, tipos geométricos, de direcciones de red, de cadenas binarias, UUID,
XML, matrices, etc.
 Soporta el almacenamiento de objetos binarios grandes (gráficos, videos,
sonido, ...).
 APIs para programar en C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC,
PHP, Lisp, Scheme, Qt y muchos otros.















SQL92, SQL99, SQL2003, SQL2008.
Llaves primarias (primary keys) y foráneas (foreign keys).
Check, Unique y Not null constraints.
Restricciones de unicidad postergables (deferrable constraints).
Columnas auto-incrementales.
Índices compuestos, únicos, parciales y funcionales en cualquiera de los
métodos de almacenamiento disponibles, B-tree, R-tree, hash o GiST.
Sub-selects.
Consultas recursivas.
Funciones 'Windows'.
Joins.
Vistas (views).
Disparadores (triggers) comunes, por columna, condicionales.
Reglas (Rules).
Herencia de tablas (Inheritance).
Eventos LISTEN/NOTIFY.
SLSC. Maqueta DCC PostgreSQL.
2.2.3.Características SQL
6 de 16
2.2.4.Características versiones PostgreSQL
Podéis consultar la lista completa en inglés de características disponibles en todas
las versiones de PostgreSQL en la dirección:
http://www.postgresql.org/about/featurematrix
2.2.5.Algunos de los límites de PostgreSQL
Límite
Máximo tamaño base de dato
Máximo tamaño de tabla
Máximo tamaño de fila
Máximo tamaño de campo
Máximo número de filas por tabla
Máximo número de columnas por tabla
Máximo número de índices por tabla
3.
Valor
Ilimitado (Depende de tu sistema de almacenamiento)
32 TB
1.6 TB
1 GB
Ilimitado
250 - 1600 (dependiendo del tipo)
Ilimitado
HISTORIA
El proyecto PostgreSQL tal y como lo conocemos hoy en día empezó en 1996,
aunque las bases y el trabajo en la que se asienta tienen sus comienzos en la
década de los 70. A continuación teméis una corta descripción de la historia de
PostgreSQL.
3.1. Ingres 1977-1985 - "El comienzo"
IBM había estado trabajando desde 1973 con los primeros conceptos, ideas y
teorías sobre bases de datos relacionales. Su proyecto "System R" fue entre otras
cosas la primera implementación del lenguaje SQL (Structured Query Language).
Este proyecto, sus decisiones de diseño y muchos de los algoritmos usados,
influenciaron muchos de los sistemas de bases de datos relacionales que
aparecieron posteriormente.
Por aquel entonces un profesor de la Universidad de Berkeley, Michael
Stonebraker, leyó unos artículos publicados por IBM sobre "Sistema R" que le
hicieron interesarse en el tema. Utilizando el dinero de otro proyecto que ya tenía
asignado, Ingres (INteractive Graphics REtrieval System), Stonebraker empezó a
desarrollar sus ideas sobre bases de datos relacionales. Durante estos años Ingres
mantuvo su código fuente abierto y permaneció en gran medida similar en
conceptos a "System R".
SLSC. Maqueta DCC PostgreSQL.
La década de los 70 fue una década de desarrollos y pruebas de nuevos
conceptos en el nuevo mundo de los gestores de bases de datos.
7 de 16
A principio de los 80, Ingres estuvo compitiendo con Oracle por el liderazgo en el
mundo de bases de datos relacionales y su código e implementación
evolucionaron y fueron el origen de otras bases de datos relacionales, entre ellas
podemos citar a Informix, NonStop SQL y Sybase (Microsoft SQL Server fue una
versión licenciada de Sybase hasta su versión 6.0).
Michael Stonebraker dejo la Universidad de Berkeley en 1982 para comercializar
Ingres pero volvio a la misma en 1985 con nuevas ideas.
3.2. Postgres 1986-1994 - Después (post) de Ingres
Después de su vuelta a Berkeley en 1985, Michael Stonebraker lideró un nuevo
proyecto llamado Postgres (después de Ingres) patrocinado por la Defense
Advanced Research Projects Agency (DARPA), la Army Research Office (ARO), la
National Science Foundation (NSF), y ESL, Inc. Con este proyecto y basándose en
la experiencia obtenida con Ingres, Stonebraker tenía como meta mejorar lo que
habían conseguido y aprendido en el desarrollo de Ingres. Y aunque se basó en
muchas ideas de Ingres, no se basó en el código fuente del mismo.
Los objetivos iniciales de este proyecto fueron:
 Proporcionar un mejor soporte para objetos complejos.
 Proporcionar a los usuarios la posibilidad de extender los tipos de datos,
operadores y métodos de acceso.
 Proporcionar los mecanismos necesarios para crear bases de datos activas
(triggers, etc).
 Simplificar el código encargado de la recuperación del sistema después de
una caída del mismo.
 Hacer cambios mínimos (preferiblemente ninguno) en el modelo relacional.
 Mejorar el lenguaje de consulta QUEL heredado de Ingres (POSTQUEL).
La última versión de Postgres en este projecto fue la versión 4.2.
En 1994, dos estudiantes de Berkeley, Andrew Yu y Jolly Chen, empezaron a
trabajar con el código de Postgres (versión 4.2) y llamaron al proyecto Postgres95.
Hicieron una limpieza general del código, arreglaron errores en el mismo, e
implementaron otras mejoras, entre las que destacan:






Sustitución de POSTQUEL por un intérprete del lenguaje SQL.
Reimplementación de las funciones agregadas.
psql fue creado para ejecutar consultas SQL.
El interface de objetos grandes (large-object) fue revisado.
Un pequeño tutorial sobre Postgres fue creado.
Postgres se pudo empezar a compilar con GNU make y GCC sin parchear.
SLSC. Maqueta DCC PostgreSQL.
3.3. Postgres95 1994-1995 - Nueva vida en el mundo opensource
8 de 16
La versión 1.0 de Postgre95 vio la luz en 1995, el código era 100% ANSI C, un
25% más corto en relación con la versión 4.2 y un 30-50% más rápido. El código
fue publicado en la web y liberado bajo una licencia BSD, y más y más personas
empezaron a utilizar y a colaborar en el proyecto.
3.4. PostgreSQL 1996-actualidad - Proyecto PostgreSQL
En 1996, Andrew Yu y Jolly Chen ya no tenían tanto tiempo para dirigir y
desarrollar Postgres95. Algunos de los usuarios habituales de las listas de correo
del proyecto decidieron hacerse cargo del mismo y crearon el llamado
"PostgreSQL Global Development Team".
En un principio este equipo de desarrolladores al cargo de la organización del
proyecto estuvo formado por Marc Fournier en Ontario, Canadá, Thomas Lockhart
en Pasadena, California, Vadim Mikheev en Krasnoyarsk, Rusia y Bruce Momjian
in Philadelphia, Pennsylvania. El nombre fue cambiado de Postgres95 a
PostgreSQL y lanzaron la versión 6.0 en enero de 1997.
Hoy en día el grupo central (core team) de desarrolladores está formado por 6
personas, existen 38 desarrolladores principales y más 21 desarrolladores
habituales. En total alrededor de 65 personas activas, contribuyendo con el
desarrollo de PostgreSQL. Podéis encontrar más información sobre este equipo de
desarrolladores en: http://www.postgresql.org/community/contributors/
Existe también una gran comunidad de usuarios, programadores y administradores
que colaboran activamente en numerosos aspectos y actividades, relacionadas
con el proyecto. Informes y soluciones de problemas, tests, comprobación del
funcionamiento, aportaciones de nuevas ideas, discusiones sobre características y
problemas, documentación y fomento de PostgreSQL son solo algunas de las
actividades que la comunidad de usuarios realiza.
En los últimos años los trabajos de desarrollo se han concentrado mucho en la
velocidad de proceso y en características demandadas en el mundo empresarial.
En este gráfico podéis ver cuando las diferentes versiones de PostgreSQL han
visto la luz y las principales características en las que se ha centrado el desarrollo.
Durante los años de existencia del Proyecto PostgreSQL, el tamaño del mismo,
tanto en número de desarrolladores, como en números de línea de código,
funciones y complejidad del mismo ha ido aumentando año a año. En el siguiente
gráfico teméis una gráfica con la evolución del número de líneas de código en cada
versión de PostgreSQL.
SLSC. Maqueta DCC PostgreSQL.
No tenemos que olvidar tampoco que existen muchas empresas que también
colaboran con dinero y/o con tiempo/personas en mejorar PostgreSQL. Muchos
desarrolladores y nuevas características están muchas veces patrocinadas por
empresas privadas.
9 de 16
Los datos de este gráfico están generados con CLOC. Contabilizamos como líneas
de código a todas las líneas de código en diferentes lenguajes, más comentarios,
menos líneas en blanco. Los ficheros HTML y CSS no se cuentan como código.
Usando el modelo de estimación de costes de software "COCOMOII" (Constructive
COst MOdel) podemos obtener unos datos meramente orientativos pero que nos
pueden ayudar a entender la complejidad del proyecto PostgreSQL y los recursos
que se necesitarían para desarrollar un producto similar desde cero.
Según COCOMOII, obtendríamos estos números para PostgreSQL 9.0.0:
4.
Valor
969.562
0,6
1,24
$53,3
618,71
$65,30
$63.316.697
7
3.6
171,4
CICLO DE VIDA (EOL) Y SOPORTE
El Proyecto PostgreSQL tiene como objetivo mantener y soportar cada versión de
PostgreSQL durante 5 años desde el momento de su lanzamiento. A continuación
teméis un resumen del ciclo de vida de las diferentes versiones de PostgreSQL:
Versión
9.2
9.1
9.0
Versión menor
9.2.0
9.1.5
9.0.9
Soportada
Si
Si
Si
Lanzamiento
Sep 2012
Sep 2011
Sep 2010
Soporte
Sep 2017
Sep 2016
Sep 2015
SLSC. Maqueta DCC PostgreSQL.
Descripción
Números de lineas de código (PG-9.0.0)
Habilidad de los programadores (alta)
Complejidad del projecto (alta)
Precio/hora ($100.000/año 1.875horas/año)
Programadores-año
Precio por linea de código
Precio Total
Lineas de código por persona/dia
Tiempo de desarrollo del proyecto (años)
Número medio de programadores
10 de 16
8.4
8.3
8.2
8.1
8.0
7.4
7.3
7.2
7.1
7.0
6.5
6.4
6.3
5.
8.4.13
8.3.20
8.2.23
8.1.23
8.0.26
7.4.30
7.3.21
7.2.8
7.1.3
7.0.3
6.5.3
6.4.2
6.3.2
Si
Si
No
No
No
No
No
No
No
No
No
No
No
Jul 2009
Feb 2008
Dic 2006
Nov 2005
Ene 2005
Nov 2003
Nov 2002
Feb 2002
Abr 2001
May 2000
Jun 1999
Oct 1998
Mar 1998
Jul 2014
Feb 2013
Dic 2011
Nov 2010
Oct 2010
Oct 2010
Nov 2007
Feb 2007
Abr 2006
May 2005
Jun 2004
Oct 2003
Mar 2003
INSTALACIÓN BÁSICA PostgreSQL 9.3.4 EN UBUNTU 12.04
 Descargar el paquete postgresql-9.3.4-3-linux.run con PostgreSQL 9.3.4
para Linux de 32bite, de la URL:
http://www.enterprisedb.com/products-services-training/pgdownload
 Para instalar PostgreSQL 9.3.4 ejecuto en un terminal:
sudo ./postgresql-9.3.4-3-linux.run
 Introducir los siguientes datos durante la instalación:
Directorio de Instalación: /opt/PostgreSQL/9.3
Directorio de Datos: /opt/PostgreSQL/9.3/data
Contraseña super-usuario de la bbdd (postgres): postgres
Puerto escucha del servidor: 5432
Configuración Regional: Configuración Regional por defecto
 Si se desea instalar más herramientas de PostgreSQL, utilizar la aplicación:
Application Stack Builder
 Algunas notas de la instalación se encuentran en la ruta:
/opt/PostgreSQL/9.3/doc/installation-notes.html
 Editar el fichero /home/usuario/.bashrc y le añadir las líneas siguientes para
automatizar algunas rutas y parámetros:
# Ruta de programas de PostgreSQL
export PATH=$PATH:/opt/PostgreSQL/9.3/bin
# variable de entorno con el superusuario de PostgreSQL
export PGUSER=postgres
# variable de entorno con el nombre de la máquina servidor de bbdd
#export PGHOST=127.0.0.1
# variable de entorno con el pueto del servidor de bbdd
#export PGPORT=5432
SLSC. Maqueta DCC PostgreSQL.
Para realizar una instalación básica de PostgreSQL 9.3.4 en Ubuntu 12.04, realizar
los siguientes pasos:
11 de 16
6.
ALGUNOS CONCEPTOS A TENER ENCUTA PARA
TRABRAJAR CON POSTGRESQL
6.1. Jerarquía de PostgreSQL
A la hora de trabajar con PostgreSQL hay que tener en cuenta la siguiente
jerarquía, en la que un elemento superior puede contener varios elementos
inferiores:
1.
2.
3.
4.
5.
Máquina Hardware
Instancia Servidor PostgreSQL
Base de Datos
Esquema
Objetos (Tablas, índices, procedimientos,…)
6.2. Transacciones
PostgreSQL trata cada declaración de SQL como si se estuviera ejecutando dentro
de una transacción. Si uno no especifica una orden BEGIN, entonces cada
declaración individual tiene un BEGIN y, si es exitosa, un COMMIT alrededor de
ella. Algunas veces, a un grupo de declaraciones encerradas entre BEGIN y
COMMIT se les llama un bloque de transacción.
En los siguientes enlaces se puede obtener información más detallada:
http://pgsqltutorial.readthedocs.org/en/latest/part_iii/transactions.html
file:///opt/PostgreSQL/9.3/doc/postgresql/html/tutorial-transactions.html
6.3. PSQL
El interfaz del cliente de línea de comandos que viene con la instalación por
defecto de PostgreSQL es PSQL. La ruta en la que se instala por defecto en
Ubuntu es: :/opt/PostgreSQL/9.3/bin/psql
Para ejecutar sentencias en PSQL todas tienen que terminar con “;”, ejemplo:
select now();
Para salir de PSQL ejecutar el comando \q y pulsar intro.
En la siguiente imagen podemos ver una captura de los comandos indicados
anteriormente:
SLSC. Maqueta DCC PostgreSQL.
Para conectar a una base de datos PosgreSQL con PSQL la sintaxis sería:
psql nombre_bbdd nombre_usuario
12 de 16
6.4. pgAdmin III
En la imagen anterior podemos observar en la parte izquierda el árbol de objetos
que muestra pgAdmin III y en la parte derecha las propiedades del tablespace
data_dcc y así como el sql para crearlo.
SLSC. Maqueta DCC PostgreSQL.
La interfaz gráfica que instala por defecto PostgreSQL 9.3.4 se llama pgAdmin III.
Desde ella podremos gestionar la mayoría de elementos y objetos de PostgreSQL.
13 de 16
6.5. Tablespace
En PostgreSQL el concepto tablespace no está compuesto por datafiles como en
Oracle. Un tablespace en PostgreSQL equivale a un directorio, en el que se irá
guardando un fichero por cada objeto del tablespace y con su contenido. Ejemplo:
En la imagen anterior podemos ver el directorio correspondiente al tablespace
data_dcc del punto anterior y los ficheros de los distintos objetos que alberga.
En Oracle existe la tabla DUAL para realizar muchas select, en PostgreSQL se
puede hacer lo mismo pero poniendo la select sin el from y terminándola
directamente con ;
SLSC. Maqueta DCC PostgreSQL.
6.6. Tabla DUAL
14 de 16
Esta tabla fue creada en PostgreSQL como un objeto para aliviar los problemas de
portabilidad. Esto permite que el código permanezca un tanto compatible con
Oracle SQL, sin molestar el analizador de PostgreSQL.
7.
MAQUETA DCC
7.1. Tabla DUAL
7.2. Tipos de datos utilizados
La siguiente tabla muestra los tipos de datos utilizados en la Maqueta DCC de
PostgreSQL, así como su equivalencia con los de Oracle.
PostgreSQL
BOOLEAN = bool
TIMESTAMP[(P)][WITHOUT TIMEZONE]
Oracle
BOOLEAN
DATE
SLSC. Maqueta DCC PostgreSQL.
En la siguiente imagen se muestra el modelo de datos a implementar en la
Maqueta DCC. Indicar que en este modelo de datos los tipos de datos que
aparecen son de Oracle, por lo que habrá que hacer en PostgreSQL la
equivalencia correspondiente.
15 de 16
(Existe un tipo DATE pero sólo almacena la
fecha sin hora)
NUMERIC = decimal
NUMERIC(1) = decimal(1)
NUMERIC(2) = decimal(2)
NUMERIC(10) = decimal(10)
NUMERIC(38) = decimal(38)
CHARACTER VARYING(6) = varchar(6)
CHARACTER VARYING(8) = varchar(8)
CHARACTER VARYING(10) = varchar(10)
CHARACTER VARYING(12) = varchar(12)
CHARACTER VARYING(32) = varchar(32)
CHARACTER VARYING(50) = varchar(50)
CHARACTER VARYING(100) = varchar(100)
CHARACTER VARYING(200) = varchar(200)
CHARACTER VARYING(255) = varchar(255)
CHARACTER VARYING(500) = varchar(500)
CHARACTER VARYING(2048) =
varchar(2048)
CHARACTER VARYING(4000) =
varchar(4000)
TEXT
TEXT
NUMBER
NUMBER(1)
NUMBER(2)
NUMBER(10)
NUMBER(38)
VARCHAR2(6)
VARCHAR2(8)
VARCHAR2(10)
VARCHAR2(12)
VARCHAR2(32)
VARCHAR2(50)
VARCHAR2(100)
VARCHAR2(200)
VARCHAR2(255)
VARCHAR2(500)
VARCHAR2(2048)
VARCHAR2(4000)
LONG
CLOB
Junto con este documento se adjuntan dos ficheros, utilizados como base para
elaborar la tabla anterior: SLCS_TiposDeDatosPostgreSQL8.4.4.pdf y
SLCS_TiposDatosOracle11g.pdf.
8.
REFERENCIAS Y ENLACES DE INTERÉS




SLSC. Maqueta DCC PostgreSQL.
Portal en inglés de PostgreSQL: http://www.postgresql.org/
Portal en Español de PostgreSQL: http://www.postgresql.org.es/
Documentación: http://www.postgresql.org.es/documentacion
Documentación de la instalación de PostgreSQL 9.3.4:
file:///opt/PostgreSQL/9.3/doc/postgresql/html/index.html
 Tutorial PostgreSQL en español:
 http://www.postgresql.org.es/node/391
16 de 16