4.1. Creacion de tablas

Una vez conectados a una base de datos, la sentencia SQL create table permite crear las tablas que necesitemos:


demo=# create table persona (
demo(# nombre varchar(30),
demo(# direccion varchar(30)
demo(# );
CREATE

El comando drop table permite eliminar tablas:


demo=# drop table persona;

La tabla recién creada aparece ahora en la lista de tablas de la base de datos en uso:


demo=# \dt
List of relations
Name |Type |Owner
---------+-------+--------
persona | table | quiron
(1 row)

Podemos consultar su descripción mediante el comando \d tabla:


demo=# \d persona
Table "persona"
Column |Type | Modifiers
-----------+-----------------------+-----------
nombre | character varying(30) |
direccion | character varying(30) |

 

La tabla está lista para insertar en ella algunos registros.


demo=# insert into persona values ( `Alejandro Magno´ , `Babilonia´ );
INSERT 24756 1
demo=# insert into persona values ( `Federico García Lorca´ , `Granada 65´ );
INSERT 24757 1

 

Este aspecto se explicará en detalle más adelante.

El número con el que responde el comando insert se refiere al OID del registro insertado.

Las consultas se realizan con la sentencia SQL select. En este caso solicitamos que nos muestre todas las columnas de los registros en la tabla persona:


demo=# select * from persona;
nombre |direccion
-----------------------+------------
Alejandro Magno | Babilonia
Federico García Lorca | Granada 65
(2 rows)
demo=#

Las tablas creadas en PostgreSQL incluyen, por defecto, varias columnas ocultas que almacenan información acerca del identificador de transacción en que pueden estar implicadas, la localización física del registro dentro de la tabla (para localizarla muy rápidamente) y, los más importantes, el OID y el TABLE OID. Estas últimas columnas están definidas con un tipo de datos especial llamado  identificador  de  objeto  (OID)  que  se  implementa  como  un  entero positivo de 32 bits. Cuando se inserta un nuevo registro en una tabla se le asigna un número consecutivo como OID, y el TABLEOID de la tabla que le corresponde.


En la programación orientada a objetos, el concepto de OID es de vital importancia, ya que se refiere a la identidad propia del objeto, lo que lo diferencia de los demás objetos.

Para observar las columnas ocultas, debemos hacer referencia a ellas específicamente en el comando select:


demo=# select oid, tableoid, * from persona;
oid |tableoid |nombre |direccion
-------+----------+------------------------+----------------------
17242 | 17240 | Alejandro Magno | Babilonia
17243 | 17240 | Federico García Lorca | Granada 65
(2 rows)
demo=#


Estas columnas se implementan para servir de identificadores en la realización de enlaces desde otras tablas.

Ejemplo de la utilización de OID para enlazar dos tablas

Retomamos la tabla persona y construimos una nueva tabla para almacenar los teléfonos.


demo=# create table telefono (
demo(# tipo char(10),
demo(# numero varchar(16),
demo(# propietario oid
demo(# );
CREATE

La tabla teléfono incluye la columna propietario de tipo OID, que almacenará la referencia a los registros de la tabla persona. Agreguemos dos teléfonos a ‘Alejandro Magno’, para ello utilizamos su OID que es 17242:


demo=# insert into telefono values( `móvil´ , `12345678´, 17242 );
demo=# insert into telefono values( `casa´ , `987654´, 17242 );

Las dos tablas están vinculadas por el OID de persona.


demo=# select * from telefono;
tipo |numero | propietario
------------+-------------+-------------
móvil | 12345678 | 17242
casa | 987654 | 17242
(2 rows)

La operación que nos permite unir las dos tablas es join, que en este caso une teléfono y persona, utilizando para ello la igualdad de las columnas telefono.propietario y persona.oid:


demo=# select * from telefono join persona on (telefono.propietario = persona.oid);
tipo |numero | propietario |nombre | direccion
------------+-------------+-------------+-----------------+-----------
móvil | 12345678 | 17242 | Alejandro Magno | Babilonia
casa | 987654 | 17242 | Alejandro Magno | Babilonia
(2rows)

Los OID de PostgreSQL presentan algunas deficiencias:

•    Todos los OID de una base de datos se generan a partir de una única secuencia centralizada, lo que provoca que en bases de datos con mucha actividad de inserción y eliminación de registros, el contador de 4 bytes se desborde y pueda entregar OID ya entregados. Esto sucede, por supuesto, con bases de datos muy grandes.

•    Las tablas enlazadas mediante OID no tienen ninguna ventaja al utilizar operadores de composición en términos de eficiencia respecto a una clave primaria convencional.

•    Los OID no mejoran el rendimiento. Son, en realidad, una columna con un número entero como valor.

Los desarrolladores de PostgreSQL proponen la siguiente alternativa para usar OID de forma absolutamente segura:

•    Crear una restricción de tabla para que el OID sea único, al menos en cada tabla. El SGBD irá incrementando secuencialmente el OID hasta encontrar uno sin usar.

•    Usar la combinación OID - TABLEOID si se necesita un identificador único para un registro válido en toda la base de datos.

Por los motivos anteriores, no es recomendable el uso de OID hasta que nuevas versiones de PostgreSQL los corrijan. En caso de usarlos, conviene seguir las recomendaciones anteriores.

 

Es posible crear tablas que no incluyan la columna OID mediante la siguiente notación:


create table persona (
nombre varchar(30),
direccion varchar(30)
)without oids;


 

 



 

  BI   |    CRM     |    CMS    |    Tendencias en software empresarial    |    Cloud computing  |    Software libre    |   Internet    |    Movilidad y apps