Apostila PostgreSQL 8.

Componentes: Arthur Baltazar Nº 06

Catia Regina Nº 08
Giovane Gabrielli Nº 21
José Felipe Nº 27
Vitor Cardoso Nº 42

Franco da Rocha
2010
 Índice:
Introdução......................................................................................................................... 5
Características................................................................................................................... 5
Recursos Presentes na Versão mais Recente.................................................................... 6
Sobre o PostgreSQL ......................................................................................................... 6
Limite Valor ..................................................................................................................... 6
Um Pouco da História do PostgreSQL............................................................................. 7
Tipos de Dados do PostgreSQL ....................................................................................... 8
Tipos de dados: Caracteres ........................................................................................... 8
Tipos de dados: Numéricos .......................................................................................... 8
Números de precisão fixa ............................................................................................. 8
Tipos de ponto flutuante ............................................................................................... 9
Pseudo tipos seriais....................................................................................................... 9
Uso.................................................................................................................................. 10
Criação de banco de dados no PostgreSQL................................................................ 10
Referências ..................................................................................................................... 49

II
 Introdução
O PostgreSQL é um SGBD (Sistema Gerenciador de Banco de Dados) objeto-
relacional de código aberto, com mais de 15 anos de desenvolvimento. É robusto e
confiável, além de ser extremamente flexível e rico em recursos. Um de seus atrativos é
possuir recursos comuns a banco de dados de grande porte (SQL Server), o que o deixa
apto a trabalhar, inclusive, com operações de missão crítica. Além disso, trata-se de um
banco de dados versátil, seguro e gratuito disponível sob uma licença BSD.
O PostgreSQL é considerado objeto-relacional por implementar, além das
características de um SGBD relacional, algumas características de orientação a objetos,
como herança e tipos personalizados com conformidade e padrões. Ele roda em todos os
grandes sistemas operacionais, incluindo GNU/Linux, Unix (AIX, BSD, HP-UX, SGI
IRIX, Mac OS X, Solaris, Tru64), e MS Windows.
Além de tudo é totalmente compatível com ACID, têm suporte completo à
chaves estrangeiras, junções (JOIN), visões, gatilhos e procedimentos armazenados em
múltiplas linguagens. Inclui a maior parte dos tipos de dados do ISO SQL: 1999,
incluindo INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE,
INTERVAL, e TIMESTAMP. Suporta também sons ou vídeos. Possui interfaces
nativas de programação para C/C++, Java, Net, Perl, Python, Ruby, Tcl, ODBC, entre
outros, e uma documentação excepcional.
O PostgreSQL teve patrocínio de diversas empresas, entre as quais se destacam:
Fujitsu, Hub.Org, NTT Group, Red Hat, Skype, SRA e Sun Microsystems. O software
tem adquirido prestígio na comunidade Linux, tendo recebido diversas vezes o prêmio
Linux Journal Editor's Choice de melhor Sistema de Gerenciamento de Banco de
Dados.
A aceitação do PostgreSQL tem se ampliado para além da comunidade de
código aberto. Há entre os seus usuários grandes empresas internacionais, órgãos
governamentais de vários países e universidades de prestígio mundial. Existe uma lista
dos principais usuários no Brasil e no mundo e, também, há alguns estudos de caso de
aplicações que utilizam o PostgreSQL.

Características
Desenvolvedor: PostgreSQL Global Development Group;

Primeiro lançamento: um de maio de 1995;

Última versão: 9.0;

Idiomas: 23 idiomas;

Plataforma (sistema Operacional): Multiplataforma;

Compatibilidade: Java, PHP, Python, Ruby, e C/C++;

Suporte: recursos como triggers, views, stored procedures, SSL, MVCC,

Website: http://www.PostgreSQL.org.br;

5
 Recursos Presentes na Versão mais Recente

• Consultas complexas
• Chaves Estrangeiras
• Integridade Transacional
• Controle de concorrência multi-versão
• Suporte ao modelo híbrido objeto-relacional
• Gatilhos
• Visões
• Linguagem Procedural em várias linguagens (PL/pgSQL, PL/Python, PL/Java,
PL/Perl) para Procedimentos armazenados
• Indexação por texto
• Estrutura para guardar dados Georeferenciados PostGIS

Sobre o PostgreSQL

Como um banco de dados de nível corporativo, o PostgreSQL possui

funcionalidades sofisticadas como o Controle de Concorrência Multiversionado
(MVCC), Recuperação em um Ponto no Tempo (PITR), Tablespaces (divisão lógica),
Replicação Assincrônica, Transações Agrupadas, Cópias de Segurança Quente
(hotbackup), um sofisticado Planejador de Consultas e Registrador de Transações
Sequenciais (WAL) para tolerância à falhas.
Suporta conjuntos de caracteres internacionais, codificação de caracteres
multibyte, Unicode e sua ordenação por localização, sensibilidade à formatação
(maiúsculas e minúsculas). É altamente escalável, tanto na quantidade enorme de dados
que pode gerenciar, quanto no número de usuários concorrentes que pode acomodar.
Existem sistemas ativos com o PostgreSQL em ambiente de produção que gerenciam
mais de 4TB de dados. Alguns limites do PostgreSQL estão incluídos na tabela abaixo.

Limite Valor
Tamanho Máximo do Banco de Dados Ilimitado

Tamanho máximo de uma Tabela 32 TB

Tamanho Máximo de uma Linha 1.6 TB

Tamanho Máximo de um Campo 1 GB

Máximo de Linhas por Tabela: Ilimitado

Máximo de Colunas por Tabela 250–1600 dependendo do

Máximo de Índices por Tabela: Ilimitado

6
 Um Pouco da História do PostgreSQL

O sistema gerenciador de banco de dados PostgreSQL teve seu início na

Universidade de Berkeley, na Califórnia, em 1986. À época, um programador chamado
Michael Stonebraker liderou um projeto para a criação de um servidor de banco de
dados relacionais chamado Postgres, oriundo de um outro projeto da mesma instituição
denominado Ingres. Essa tecnologia foi então comprada pela Illustra, empresa
posteriormente adquirida pela Informix. Porém, mesmo diante disso, dois estudantes de
Berkeley (Jolly Chen e Andrew Yu) compatibilizaram o Postgres à linguagem SQL.
Este projeto recebeu o nome de Postgres95.
Em 1996, quando o projeto estava estável, o banco de dados recebeu o nome de
PostgreSQL. No entanto, enquanto ainda possuía o nome Postgres95, o banco de dados
teve várias mudanças. O seu código foi totalmente revisado e a linguagem SQL foi
definida como padrão. Também em 1996, o projeto foi renomeado para PostgreSQL a
fim de refletir a nova linguagem de consulta ao banco de dados: SQL.
A primeira versão de PostgreSQL foi a 6.0, liberada em janeiro de 1997. Desde
então, um grupo de desenvolvedores e de voluntários de todo o mundo, coordenados
pela Internet, têm mantido o software e desenvolvido novas funcionalidades.
As principais características acrescentadas nas versões 6.x são o: MVCC
(Controle de Concorrência Multiversões), melhorias no SQL e novos tipos de dados
nativos (novos tipos de datas e hora e tipos geométricos).
Em maio de 2000 foi liberada a versão 7.0. As versões 7.x trouxeram as
seguintes novas funcionalidades: Write-Ahead Log (checa as transações de dados),
Schemas SQL, Outer Joins (junção de dados), Suporte IPv6, Indexação por Texto,
Suporte à SSL e informações estatísticas do banco de dados.
A versão 8.0 foi lançada em janeiro de 2005 e entre outras novidades, foi a primeira a
ter suporte nativo para Microsoft Windows (tradicionalmente, o PostgreSQL só rodava
de forma nativa em sistemas Unix e, em sistemas Windows - através da biblioteca
Cygwin). Dentre as muitas novidades da versão 8.x, pode-se destacar o suporte a
Tablespaces, Savepoints, Point-in-time Recovery, e Two-Phase Commit (2PC).
Em julho de 2009 foi lançada a versão mais nova a 8.4, que detém ferramentas e
comandos para administração e monitoramento novos ou melhorados. Cada usuário tem
sua funcionalidade favorita que tornará o seu dia-a-dia com o PostgreSQL mais fácil e
produtivo. Dentre as principais se destacam:
Restauração Paralela de Bases de Dados, aumentando a velocidade de
recuperação de cópia de segurança (backup) em até oito vezes;
Permissões por Coluna, permitindo um controle mais granular de dados
sigilosos;
Suporte a Configuração Regional por Banco de Dados, tornando o PostgreSQL
mais útil em ambientes com múltiplos idiomas;
Upgrades In-place com o pg_migrator beta, permitindo migrações das 8.3 para a
8.4 sem tirar o banco do ar por muito tempo;
Novas Ferramentas de Monitoramento de Consultas, dando aos administradores
mais detalhes sobre a atividade das consultas.

7
 Tipos de Dados do PostgreSQL

Tipos de dados: Caracteres

No PostgreSQL, existem três tipos básicos que podem comportar caracteres

alfanuméricos: char, varchar e text. A diferença entre eles está nos limites e estrutura de
armazenamento dos dados.
O tipo char(n) armazena uma cadeia de caracteres com tamanho fixo, tendo
como n o seu tamanho máximo. Ocupa 4+n bytes em disco (se a cadeia de caracteres for
menor que n, o campo é preenchido com espaços em branco à direita). Esses 4 bytes
fixos são utilizados pelo PostgreSQL para armazenar informações referentes ao tipo e
tamanho do campo.
O tipo varchar(n) tem como diferença possuir tamanho de armazenamento
variável, limitado a ncaracteres. Ocupa 4 + m bytes, onde m é o número de caracteres
efetivamente usados.
O terceiro tipo, denominado text, possui tamanho variável e um limite muito
grande de armazenamento. Equivale a um varchar(4000000000) e pode ser utilizado
para armazenar campos BLOB do tipo texto.

Tipos de dados: Numéricos

Os tipos numéricos se subdividem em números inteiros, de precisão fixa, de

ponto flutuante e os pseudo tipos seriais.

Inteiros
Esse tipo armazena números sem componentes fracionais. Números inteiros
possuem limites máximos e mínimos, e qualquer tentativa de se armazenar valores fora
dessa faixa irá gerar um erro. Existem os seguintes tipos inteiros:

smallint ou int2 2 bytes (16 bits)

int, integer ou int4 4 bytes (32 bits)

int8, bigint 8 bytes (64 bits)

Na maior parte dos casos, o tipo integer oferece a melhor relação performance
versus capacidade de armazenamento. O tipo bigint, por ser mais pesado e
conseqüentemente mais lento, deve ser usado somente quando a faixa de
armazenamento do integer realmente não for suficiente.

Números de precisão fixa

Os números de precisão fixa são criados com o tipo numeric. Seu uso é
recomendado para armazenar valores monetários e outras quantias nas quais a exatidão
é necessária.
8
 Tipos de ponto flutuante
Os tipos de dado real e double precision são tipos numéricos não exatos de
precisão variável. Na prática, estes tipos são geralmente implementações do "Padrão
IEEE 754 para Aritmética Binária de Ponto Flutuante" (de precisão simples e dupla,
respectivamente), conforme suportado pelo processador, sistema operacional e
compilador utilizados.

Não exato significa que alguns valores não podem ser convertidos exatamente
para o formato interno, sendo armazenados como aproximações. Portanto, ao se
armazenar e posteriormente imprimir um valor podem ocorrer pequenas discrepâncias.
A gerência destes erros, e como se propagam através dos cálculos como, por exemplo:
Se for necessário armazenamento e cálculos exatos (como em quantias
monetárias), em vez de tipos de ponto flutuante deve ser utilizado o tipo numeric.

Se for desejado efetuar cálculos complicados usando tipos de ponto flutuante

para algo importante, especialmente dependendo de certos comportamentos em
situações limites (infinito ou muito próximo de zero), a implementação deve ser
avaliada cuidadosamente.

A comparação de igualdade de dois valores de ponto flutuante pode funcionar

conforme o esperado, ou não.

Pseudo tipos seriais

Os tipos de dado serial e bigserial não são tipos verdadeiros, mas meramente
uma notação conveniente para definir colunas identificadoras únicas (semelhante à
propriedade AUTO_INCREMENTO existente em alguns outros bancos de dados).

9
 Uso

Criação de banco de dados no PostgreSQL

Exemplo Biblioteca:

Após instalar o PostgreSQL, clique em iniciar > todos os programas > PostgreSQL >
pgAdmin III

10
 Antes de tudo, é necessário conectar-se com o servidor. Clique com o botão
direito no servidor desejado e clique em conectar, ou apenas clique duas vezes no
servidor.

Depois de conectado, clique no “+” do seu servidor conectado e com o botão

direito do mouse clique em Banco de Dados > Novo Banco de Dados

11
 Normalmente, o criador se torna o dono do novo banco de dados. Super usuários
podem criar bases de dados detidas por outros usuários, usando a cláusula OWNER.
Eles podem até mesmo criar bancos de dados pertencentes a usuários sem privilégios
especiais. Os usuários comuns com privilégio CREATEDB só podem criar bases de
dados detidas por si próprios.

Por padrão, o novo banco de dados será criado clonando o banco de dados
padrão do sistema template1. Um modelo diferente pode ser especificado por código,
nome do modelo. Em particular, escrevendo TEMPLATE template0, você pode criar
um banco de dados virgem contendo apenas os objetos padrão pré-definidos pela versão
do PostgreSQL. Isso é útil se você deseja evitar a cópia de qualquer objeto da instalação
local que possa ter sido adicionado ao template1.

12
 Aparecerá a janela onde se definirá os parâmetros do banco de dados a ser
criado:
• Nome: é definido o nome do banco de dados;
• Dono: O nome do usuário do banco de dados que será o novo banco de dados,
se não for inserido um nome ficará como DEFAULT para utilizar o padrão;

• Modelo: O nome do modelo a partir do qual pretende criar o novo banco de

dados, se não escolhido, será usado o modelo padrão (template1);

• Tablespace: O nome da tabela que será associado ao novo banco de dados, ou

DEFAULT para utilizar o espaço de tabelas do banco de dados modelo. Esta
tabela será o tablespace padrão para os objetos criados neste banco de dados;

• Connection Limit: Quantas conexões simultâneas podem ser feitas a este banco
de dados. -1 (O padrão) significa sem limite.

NOTA: Na guia SQL é possível visualizar e alterar o código de criação do banco de

dados

Neste exemplo, o nome do banco de dados será Biblioteca e será usado o

modelo Template1 conforme a imagem abaixo.

13
 Após a criação, será possível visualizar o banco de dados que foi criado,
clicando no sinal de “+” em Banco de dados do lado esquerdo da tela, na guia
propriedades no lado direito da tela.

Para criar as tabelas, chaves e etc.:

Digitando o código poderíamos clicar em cima do banco criado com o botão
direito do mouse e clicar em script Create. Veremos essa opção mais adiante. Note que
14
no Painel SQL no canto direito inferior da tela está a visualização do código que foi
criado quando criamos o banco de dados pela interface.

15
 Demonstraremos primeiro a criação do banco de dados pela interface:
1. A esquerda da tela, clique no sinal de “+” do banco de dados criado;
2. Clique no sinal de “+” de esquemas;
3. Clique no sinal de “+” de public;
4. Clique com o botão direito em Tabelas e clique em Nova Tabela.

Criaremos seis tabelas:

• Usuario;
• Acervo;
• Livro;
• Revista;
• TipoUsuario;
• Empréstimo.

16
 Demonstraremos algumas formas de se criar campos, restrições e índices.
A tabela Usuario terá os campos:
• CodUsuario;
• CodTipo;
• Nome;
• Endereco;
• Telefone
Criaremos agora a tabela Usuario:

No campo nome coloque o nome da tabela

Na próxima etapa criaremos os campos da tabela, mas antes, repare no campo
OID e a opção desmarcada “Possui OIDS”:

Se uma tabela é criada com WITH OIDS, cada registro recebe um OID único.
OIDs são automaticamente atribuídos como inteiros de 4 bytes que são únicos ao longo
de toda instalação. Contudo, eles são limitados em 4 bilhões e, então, os OIDs começam
a ser duplicados. O PostgreSQL utiliza OIDs para ligar as tabelas do sistema.

Para numerar registros nas tabelas dos usuários, é melhor utilizar SERIAL ao
invés de OIDs porque seqüências SERIAIS são únicas somente em uma tabela; e são
menos propícias a atingir o limite. SERIAL8 está disponível para armazenar valores de
seqüência com oito bytes.

17
Clique na guia Colunas;

Para adicionar as colunas das tabelas clique em adicionar.

Assim que clicar no botão Adicionar aparecerá a seguinte janela:

18
 Vamos aos campos:

Nome: digite o nome da coluna a ser criada

Tipo de dado: Digite o tipo de dado da coluna;

Neste exemplo usaremos o tipo de dado serial que é um auto-incremento. Como

CodUsuario será a chave primária e foi um campo criado justamente para relacionar a
tabela Usuario com as outras tabelas, é interessante que seja criado o numero
automaticamente sem que o usuário precise preencher esse campo.

Não é NULL: marque esta opção sempre que o campo (coluna) a ser inserido
não possa ser nulo.

Neste caso, marcaremos essa opção, já que o campo a ser criado se tornará
chave-primária.

Após marcar as opções clique em OK.

Note que Apareceu na janela a coluna que adicionamos

Clique em Adicionar novamente, dessa vez o nome do campo é CodTipo

escolheremos o tipo de dado integer, pois esse campo será chave estrangeira nessa
tabela. Na tabela “TipoUsuario”, que será a de origem, ele será chave primária do tipo
serial. Esse campo também não será nulo.

Adicione também as colunas nome e endereco, só que esses serão do tipo Text.

19
 Agora adicionaremos o campo Telefone. Este campo terá o valor padrão de 11
caracteres. Clique em OK.

Note que estão listados todos os campos adicionados e a descrição de cada

campo:

20
21
 Agora Definiremos a Chave Primária:

Clique na guia restrições, mantenha a opção chave primária na caixa de texto e

clique em adicionar:

22
 Aparecerá a janela abaixo:

Clique na guia Colunas na caixa de texto. Na parte inferior da mesma janela terá
todas as colunas que criamos da tabela. Escolha a opção “CodUsuario” , em seguida
clique no botão Adicionar.

Agora Clique na guia Propriedades e em Nome defina o nome para a chave

primaria, no nosso caso colocaremos “pk_CodUsuario” aonde “pk” vem de Primary
Key. Clique em OK.

23
24
 Note que a chave Primária que criamos já está listada.
Observe também que na caixa de texto abaixo não há mais a opção “Chave
Primária”.
Se já houvesse outras tabelas e já existisse o campo para referenciar a chave
estrangeira, poderíamos criar agora, mas como não há, clique em OK.

25
 Clicando no sinal de “+” de Tabelas, estará visível a tabela que criamos.
Clicando no sinal de “+” da Tabela criada, estará visível o número de colunas,
restrições, índices, regras, e outros. Se você clicar no sinal de “+” de Colunas verá todas
as colunas criadas, do mesmo jeito no sinal de “+” de restrições verá a chave primária
que criamos, se você adicionar chaves estrangeiras, restrição de verificação ou de
unificação também as encontrará em restrições.

Clique novamente com o botão direito do mouse em tabelas

Dessa vez faremos um caminho um pouco diferente.

26
27
 Criaremos a Tabela Acervo, ela conterá as colunas:

• CodItem
• DataInscricao
• Quantidade
• Paginas
• Observações

Digite o nome da nova tabela, que dessa vez será Acervo, e clique em OK.

28
 Clique no sinal de “+” em Acervo clique com o botão direito em Colunas e
clique em Nova Coluna.

29
 Repare que este é outro modo de se chegar à mesma janela de definição de
colunas que chegamos antes. CodItem será a chave primária desta tabela, foi criado
apenas para ser chave primária, já que nenhuma das colunas estava apta, por isso, será
definido o tipo de dado serial e não será nulo. Clique em OK.

30
 A coluna “CodItem” já está adicionada na tabela Acervo.
Clique novamente em Colunas com o botão direito do mouse >Nova Coluna e
você verá a mesma janela.
A coluna DataInscricao será do tipo date, pois registrará a data de inscrição dos
livros e revistas da biblioteca e não poderá ser nulo.Clique em OK.

Crie a coluna Quantidade como tipo de dado Integer e sendo not null, a coluna
Paginas como Integer também, porém podendo ser nulo e crie também a coluna
Observacoes como tipo de dado Text podendo conter valores nulos.

31
 Depois de criados, deverão estar aparecendo assim:

Definiremos a única restrição desta tabela que é a chave primária:

Clique com o botão direito do mouse em Restrições > Novo Objeto > Nova
Chave Primária

32
Vá para a guia Colunas escolha a coluna CodItem e clique em Adicionar.

Deve ficar como na figura abaixo:

33
 Agora Clique na guia Propriedades, Digite o nome para a chave primária e
clique em OK.

Clique no sinal de “+” de Restrições e veja a chave primária:

34
 Crie a tabela livro, ela terá as seguintes colunas:

• CodItem :será do tipo integer e será not null;

• Titulo: será do tipo text e será not null;
• Subtitulo: será do tipo text;
• Autor: será do tipo text e será not null;
• Editora: será do tipo text;
• ISBN: será do tipo text, será not null e terá 10 caracteres obrigatórios.

Deverá ficar assim:

35
 Definiremos agora a chave primária que será CodItem e deixaremos o nome
como “PK_Livro”:

CodItem também será chave estrangeira,clique em restrições novamente >novo

objeto>nova chave estrangeira.

36
 Na janela que aparece Coloque um nome para a chave estrangeira, nesse caso
colocaremos “fk_CodItem” onde FK vem de Foreign Key. Em referências escolha a
tabela a ser referenciada.

Clique na aba Colunas em Coluna Local escolha a coluna que será chave estrangeira.
Em Referenciado escolha a coluna da tabela referenciada que será a referencia de
chave estrangeira. Clique em Adicionar e em seguida em OK.

37
 A chave estrangeira que criamos já aparece em Restrições

Vamos criar os índices agora. Nesta tabela serão 3:Titulo,Autor e ISBN.Clique

com o botão direito do mouse em Índices>Novo índice.

38
 Defina o nome de índice a ser criado.

Nos campos:

Unicidade: Faz com que o sistema procure por valores duplicados na tabela
quando o índice é criado, se existirem dados na tabela, e sempre que novos dados forem
adicionados. A tentativa de inserir ou de atualizar dados, que produza um valor
duplicado, gera um erro.

Método de Acesso: O nome do método de acesso a ser utilizado pelo índice. O

método de acesso padrão é o BTREE. O PostgreSQL implementa quatro métodos de
acesso para os índices:

BTREE: uma implementação das "B-trees" de alta concorrência de Lehman-

Yao.

RTREE: implementa "R-trees" padrão, utilizando o algoritmo de partição

quadrática de Guttman.

HASH: uma implementação das dispersões lineares de Litwin.

GIST: Generalized Index Search Trees (Árvores de Procura de Índice

Generalizadas).

39
NOTAS:

• O otimizador de consultas do PostgreSQL vai considerar o uso de um índice B-

tree sempre que um atributo indexado estiver envolvido em uma comparação
utilizando um dos seguintes operadores: <, <=, =, >=, >

• O otimizador de consultas do PostgreSQL vai considerar o uso de um índice R-

tree sempre que um atributo indexado estiver envolvido em uma comparação
utilizando um dos seguintes operadores: <<, &<, &>, >>, @, ~=, &&

• O otimizador de consultas do PostgreSQL vai considerar o uso de um índice

hash sempre que um atributo indexado estiver envolvido em uma comparação
utilizando o operador =.

• Atualmente somente os métodos de acesso B-tree e Gist suportam índices com

mais de uma coluna. Por padrão, até 16 chaves podem ser especificadas (este
limite pode ser alterado na geração do PostgreSQL). Na implementação atual,
somente o B-tree suporta índices únicos.

• Uma classe de operador pode ser especificada para cada coluna de um índice. A
classe de operador identifica os operadores a serem utilizados pelo índice desta
coluna. Por exemplo, um índice B-tree sobre inteiros de quatro bytes vai utilizar
a classe de operadores int4_ops; esta classe de operadores inclui funções de
comparação para inteiros de quatro bytes. Na prática, a classe de operadores
padrão para o tipo de dado do campo é normalmente suficiente. O ponto
principal em haver classes de operadores é que, para alguns tipos de dado, pode
haver mais de uma ordenação que faça sentido. Por exemplo, pode se desejar
ordenar o tipo de dado do número complexo tanto pelo valor absoluto, quanto
pela parte real, o que pode ser feito definindo-se duas classes de operadores para
o tipo de dado e, então, selecionando-se a classe apropriada para a construção do
índice. Também existem algumas classes de operadores com finalidades
especiais:

• As duas classes de operadores box_ops e bigbox_ops suportam índices R-tree

para o tipo de dado box. A diferença entre as duas é que bigbox_ops ajusta as
coordenadas da caixa para baixo, evitando exceções de ponto flutuante ao
executar multiplicação, adição e subtração de coordenadas com números de
ponto flutuante muito grande (Nota: isto era verdade há algum tempo atrás, mas
atualmente as duas classes de operadores utilizam ponto flutuante e são
efetivamente idênticas).

40
 Clique na guia Colunas escolha a coluna que será o índice, neste caso, a coluna
Titulo clique em adicionar depois clique em OK.

Faça a mesma coisa com Autor e ISBN. Deverá ficar como na figura abaixo:

41
 Criaremos agora uma restrição de unicidade para a tabela ISBN.

A restrição de unicidade garante que os dados contidos na coluna, ou no grupo

de colunas, sejam únicos em relação a todas as outras linhas da tabela.

Clique com o botão direito do mouse em Restrições > Novo Objeto > Nova
Restrição de Unicidade.

42
 Clique na guia Colunas escolha a coluna desejada, neste caso a coluna ISBN,
clique em Adicionar e clique em OK.

Desta vez, deixaremos o PostgreSQL colocar um nome para restrição.Veja na

imagem abaixo:

43
 Demonstraremos agora a criação das outras 3 tabelas por código.

Vá ao menu Ferramentas >Query Tool:

A tabela Revista terá os campos:

• CodItem que será do tipo integer e not null;

• Nome que será do tipo text e not null;
• Tema que será do tipo text;
• Ano que será do tipo integer e not null;
• Numero que será do tipo text;
• ISSN que será do tipo text, not null e terá oito caracteres.

A tabela TipoUsuario terá os campos:

• CodTipo será do tipo serial e not null;

• Tipo será do tipo text e not null;
• Multa será do tipo money;
• Prazo será do tipo integer e not null.

E por fim, a Tabela Empréstimo terá os campos:

• CodEmprestimo será do tipo serial e not null;

• CodItem será do tipo integer e not null;
• CodUsuario será do tipo integer e not null;
• DataEmprestimo será do tipo date e not null;
• DataDevolucao será do tipo date;
• Observações será do tipo text.

44
 Quando aparecer a janela da Query, digite o código como na imagem abaixo:
Onde:
• CREATE TABLE: Cria Tabelas;
• Os nomes da tabelas e colunas sendo criadas e referencias são digitadas dentro de aspas (“”);
• Vírgula (,) indica que há mais comando (como se fosse um “e”);
• Ponto e vírgula (;) indica o final do comando;
• O sinal de parêntese [( ] abrindo é como se fosse o “inicio” e o sinal de parêntese fechando [)] é
como se fosse o “fim” do código de um comando;

45
 Na figura abaixo estamos adicionando Campos indexados e restrição de
unicidade:

Criando a Tabela TipoUsuario e a chave primária:

46
 Criando a ultima tabela, Emprestimo, adicionando chave primária e índice:

Clique no botão “Executar Consulta, Escrever Resultado Para o arquivo”

destacado na imagem abaixo. Veja que a Query foi executada com sucesso:

47
 Feche a janela da Query, aparecerá uma mensagem perguntando se você quer
salvar a consulta, no nosso caso não salvaremos.

Clique com o botão direito do mouse em tabelas e clique em atualizar:

E pronto! Note que as Tabelas que criamos estão listadas, está criado nosso
exemplo de Banco de Dados.

48
 Referências

http://www.infowester.com/postgremysql.php

http://www.devmedia.com.br/articles/post-6390-Introducao-ao-PostgreSQL.html

http://wiki.PostgreSQL.org/wiki/Introdu%C3%A7%C3%A3o_e_Hist%C3%B3rico

http://www.youtube.com/watch?v=rPR0NCrO1R4&feature=related

http://www.htmlstaff.org/PostgreSQLmanual/sql-createindex.html

http://pgdocptbr.sourceforge.net/pg74/ddl-constraints.html

http://pt.wikibooks.org/wiki/PostgreSQL_Pr%C3%A1tico/DDL/Cria%C3%A7%C3%
A3o_e_Exclus%C3%A3o_de_Bancos,_Esquemas,_Tabelas,_Views,_Constraints,_e
tc

http://pt.wikipedia.org/wiki/UTF-8

http://pt.wikipedia.org/wiki/PostgreSQL

http://www.PostgreSQL.org.br

http://pgdocptbr.sourceforge.net/pg80/extend-type-system.html

http://www.htmlstaff.org/PostgreSQLmanual/sql-createindex.html

http://www.bau-de-dev.com/banco-de-dados/trabalhando-com-chaves-primarias-
primary-key-no-PostgreSQL

49
50