Vous êtes sur la page 1sur 27

Autor: obubiba. E-mail: obubiba@ig.com.

br (envie-me um e-mail em caso de dúvidas,


críticas ou sugestões ou procure-me no canal #Delphix da rede Brasnet).

Esta Apostila é apenas uma breve iniciação ao Servidor de Banco de Dados Firebird.
Não tenho a intenção de esgotar o assunto Firebird/Sql pois trata-se de um sistema
muito complexo. Mesmo assim espero que esta apostila seja útil para quem a for lê-la,
ou mesmo que seja um ponto de partida para um estudo mais aprofundado no
Servidor/Linguagem.

Para obter o Firebird acesse a página


[http://sourceforge.net/project/showfiles.php?group_id=9028] e peque a versão 1 do
Firebird.
O Firebird é um servidor de banco de dados relacional que roda nas mais diversas
plataformas, entre elas, o Linux, Windows e variados Unix. O Firebird é a versão open
source do conhecido servidor Interbase da Borland. Sua atual versão é a 1.5.0.3389-
RC2 (na última atualização desta apostila), mas esta é ainda apenas uma versão para
testes, não sendo recomendada para uso imediato. Como versão estável, recomendo a
1.0.2.908, e foi esta a versão utilizada para montar esta apostila.

Seu uso é recomendado para pequenas e médias empresas, onde o número de acessos
simultâneos ao servidor não supere 150. Não tenho informações se esse número
aumentou na versão 1.5.

A instalação do Firebird é mais simples do que a do Interbase, e o conhecido IBConsole


do Interbase não vem junto com o instalador do Firebird, mas aplicativos similares
podem ser encontrados na internet. Mais à frente estarei mostrando como utilizar o
IBConsole com o Firebird.

Com meu crescente interesse e estudo do servidor Firebird, pude nos últimos meses
atualizar esta apostila, de modo a torná-la o mais próxima possível das mais atuais
informações acerca do SGDB (Gerenciador de bando de dados).

Ocorreram algumas mudanças a partir da versão 1.5, alterações ainda não


implementadas na versão 1.0.2.908, tais como:

Mudança do nome dos arquivos ibguard.exe e ibserver.exe para fbguard.exe e


fbserver.exe respectivamente;
Mudança do arquivo de mensagens do servidor de Interbase.msg para Firebird.msg;
Entre outras mudanças. Fique atento ao uso de tais arquivos em uma possível
atualização do banco, pois provavelmente, estes novos nomes serão os adotados como
padrão daqui para frente no Firebird.

Atenção: para que você possa criar ou se conectar a um banco de dados, tanto pelo
Isql quanto pelo IBConsole, é necessário que o servidor Firebird esteja rodando.
Algumas pessoas me reportam o seguinte erro, ao tentarem acessar um banco de
dados: unavailable database. Dentre outras causas, a falta do servidor rodando
pode informar este tipo de erro. O arquivo chama-se ibserver.exe (fbserver.exe na
versão 1.5) e está na pasta bin da instalação. Você pode também definir que o
servidor seja iniciado automaticamente na inicialização do sistema operacional no ato
da instalação.
Sumário

Parte 1. Introdução aos comandos utilizados para criar/alterar/apagar objetos a partir


do prompt Isql

1 - Criando o banco de dados


1.1 - Dividindo o banco de dados em vários arquivos no disco;
1.2 - Criando domains;
1.3 - Criando tabelas;
1.4 - Criando índices;
1.5 - Criando generators;
1.6 - Criando triggers;
1.7 - Criando stored procedures;
1.8 - Criando Exceções
1.9 - Tipos de dados;

2 - Apagando objetos do banco

3 - Alterando as estruturas dos objetos já criados no banco


3.1 - Alterando um banco de dados;
3.2 - Alterando domains;
3.3 - Alterando índices;
3.4 - Alterando generators;
3.5 - Alterando stored procedures;
3.6 - Alterando tabelas;
3.7 - Alterando triggers;

4 - Utilizando arquivos externos na criação do banco

5 - Consultado os objetos contidos no banco

Parte 2. Introdução à sintaxe de consulta Sql

1 - Extração de dados com o comando Select;

2 - Extração de dados com restrições;

3 - Ordenação dos dados extraídos;

Parte 3. Gravando e desfazendo alterações

Parte 4. Utilização do IBConsole

2
Parte 1. Introdução aos comandos utilizados para criar/alterar/apagar
objetos a partir do prompt Isql

O Isql é um console para criação de banco de dados na linguagem Sql, do servidor


Firebird. A linguagem SQL é uma linguagem exclusiva e adotada como padrão para
bancos de dados relacionais, e todos os comandos que são executados no Isql são
comandos Sql. Com o Firebird é possível através de linha de comando criar um banco
de dados inteiro, incluir, alterar e excluir registros, consultar e exibir relatórios dos
registros do banco com comandos Sql. O Isql fica na pasta bin da instalação do
servidor (geralmente Unidade:\Firebird\Bin para Windows e /opt/Interbase/Bin para o
Linux).

Para iniciar o prompt de comando já tendo acesso como usuário master, escreva:

C:\<path>\Firebird\bin\isql> isql -user SYSDBA -password masterkey


[enter]
no caso do Windows, ou

/opt/Interbase/Bin/Isql -user SYSDBA -password masterkey [enter]


no caso do Linux

notando que o usuário é caixa alta, e a senha é caixa baixa.

Mas para podermos trabalhar em uma pasta específica do disco sem termos que
executar e criar nosso banco na pasta Bin da instalação, adicione o caminho do
executável Isql à variável de ambiente PATH do sistema:

No Windows: c:\> set path C:\<path>\Firebird\bin [enter],

e no Linux: $ export PATH=$PATH:/opt/Interbase/Bin [enter], respeitando


neste caso as caixas, altas e baixas.

Lembre-se que no caso do linux, você tem que ter permissão para executar o Isql e ter
uma pasta de trabalho com permissão exclusiva de seu usuário para criar e apagar
arquivos, caso não esteja logado como root.

Depois de iniciado o Isql passando usuário e senha no prompt aparecerá:

Use CONNECT or CREATE DATABASE to especify a database


SQL>

Atenção: se em algum momento aparecer o prompt desta maneira:

CON>

significa continuação, ou seja, você esqueceu de algo ou o comando ainda não foi dado
por completo.

O ; (ponto e vírgula) é necessário ser colocado ao final de todos os comandos dados.

Para acessar a ajuda do Isql digite help; ou ? e tecle [Enter].

3
_____________________________________________________________

1 - Criando o banco de dados


_____________________________________________________________

no Windows:

SQL> create database 'c:\Sql\Empresa.gdb'; [Enter]


SQL>

no Linux:

SQL> create database '/home/SeuUser/Sql/Empresa.gdb'; [Enter]


SQL>

O banco será criado se o Isql não retornar nenhum erro.

Criando um banco em vários arquivos:

Quando um banco é criado (instrução create database) podemos especificar mais de


um arquivo para o banco. Para entender melhor, vejamos a situação:

Você tem um banco de grande capacidade, onde você guarda informações de clientes,
fornecedores, cheques, estoque, contas e finanças de uma grande loja, e a base de
dados esteja instalada em uma plataforma FAT32. Como sabemos, este sistema de
arquivos tem um limite para o tamanho dos arquivos (aproximadamente 2Gb). Com o
aumento de volume de dados nas tabelas do banco, esse limite será facilmente
atingido, impossibilitando então a inclusão de mais dados nas tabelas. Para resolver
este problema, você poderia adaptar seu sistema para outra plataforma, que fosse
mais flexível quanto ao tamanho dos arquivos. Mas esta pode ser uma solução pouco
prática em alguns casos. E mesmo que você esteja utilizando um sistema de arquivos
que aceite arquivos de grandes dimensões, é sábio por questões de performance,
dividir o banco em mais de um arquivo, tendo assim um acesso mais rápido a eles.
______________________________________________________________

1.1 - Dividindo o banco de dados em vários arquivos no disco:

No prompt do Isql digite:


no Windows:

SQL>create database 'c:\Banco\Empresa.gdb' file


'c:\Sql\Cliente.gd1' file 'c:\Sql\Financa.gd2' file
c:\Sql\Contas.gd3'; [Enter]
SQL>

no Linux:

SQL>create database '/home/SeuUser/Sql/Empresa.gdb' file


'/home/SeuUser/Sql/Cliente.gd1' file
'/home/SeuUser/Sql/Financa.gd2' file
'/home/SeuUser/Sql/Contas.gd3'; [Enter]
SQL>

4
**inclua quantos arquivos forem necessários**

O banco foi assim dividido em vários arquivos, eliminando o problema inicial de um


único arquivo de tamanho astronômico.

Atenção: caso você esteja na pasta em que for criar o banco, não é necessário
especificar o caminho.

_____________________________________________________________

1.2 - Criando domains:

Domains são especificações de tipos de dados. Pela lógica, os domains devem ser
criados antes das tabelas, ou quaisquer outros elementos que os usarem. Escreva no
prompt:

SQL> create domain Cod1 as integer not null; [Enter]


SQL> create domain Nome1 as varchar(50) not null; [Enter]
SQL>

______________________________________________________________

1.3 - Criando tabelas:

Ao criar a tabela você deve especificar, no ato da criação, os campos, seus tipos, as
chaves primárias da tabela, as chaves estrangeiras e em que arquivo a tabela será
criada (tudo em uma linha só). No modelo relacional, cada linha da tabela deve ser
preferencialmente única, tendo para isso, um atributo que a diferencie das demais, não
podendo ser repetido. Caso um único atributo/coluna não seja suficiente para definir a
linha com única, deve-se usar um conjunto de atributos. Este é o conceito de chave
primária. Uma chave estrangeira é uma referência a um campo de outra tabela do
banco de dados. Mais uma vez, por questão de lógica, se você for incluir um campo
que for chave estrangeira na tabela, a tabela originária do campo associado já deverá
existir. Vamos ao exemplo:

SQL> create table Pessoa(Codigo Cod1, Nome Nome1, Cpf varchar(30)


not null, constraint Cod_Chave primary key(Codigo));
SQL>

Obs: os campos que forem chave primária/estrangeira serão, obrigatoriamente, não


nulos.

Para definir se a tabela a ser criada estará em outro arquivo do banco de dados,
escreva:

SQL> create table 'NomeTabela' external file 'Arquivo.gd0' (Campo


Tipo);

Exemplo:

SQL> create table Cliente external file 'Cliente.gd1' (Codigo


integer not null, Cod_Assoc integer not null, Nome varchar(50),
Endereco varchar(50), Telefone varchar(15), constraint Cod_Chave
primary key (Codigo), constraint Cod_Fk_Associado foreign key
(Cod_Assoc) references Tabela_Associada(ID_Campo)); [Enter]

5
SQL>

O atributo Not Null define que o campo não poderá receber valores nulos.

Uma constraint é uma restrição que aplicamos a uma ou mais colunas da tabela.
Quando esta for UNIQUE, significa que a coluna não poderá receber valores
duplicados. A coluna em questão deverá ser obrigatoriamente Not Null. Exemplo:

Constraint Cód_Unique unique(Codigo)

Restrições específicas a determinada coluna da tabela podem ser implementadas com


a cláusula Check. Veja o exemplo:

SQL> create table Carro(Codigo integer not null, Modelo


varchar(30), Licenciado char(3) default ‘Sim’, Tipo smallint,
check (Licenciado in (‘Sim’, ‘Não’)), check (Tipo between 1 and
10));

Neste exemplo, a cada alteração ou inclusão na tabela, o banco verificará se o valor


passado para a coluna Licenciado esteja entre os valores Sim e Não, só permitindo a
entrada destes dois valores, tendo como padrão caso nada seja passado o valor Sim
(implementado pela cláusula default).

É possível ainda, a verificação de valores que estejam dentro de uma determinada


faixa de valores, como no caso da coluna Tipo, que só receberá valores entre 1 e 10.

______________________________________________________________

1.4 - Criando índices:

Índices são objetos com a função principal de aumentar a performance geral do banco
de dados. Também é utilizado para garantir a integridade dos dados gravados nas
tabelas. Quando se tem um índice relacionado com um determinado campo de uma
tabela, a busca por informações nesta coluna pode se tornar mais rápida. E quando se
tem um índice relacionado com campo que seja chave primária ou chave estrangeira, o
índice auxilia para que valores já existentes não sejam adicionados novamente à
coluna e mantém a integridade dos valores existentes em outras tabelas
respectivamente.

Exemplo:

SQL> create unique index index_codigo on Pessoa(Codigo);

Neste índice, a cláusula Unique garante que nenhum valor duplicado seja inserido na
tabela, index_codigo é o nome do index, Pessoa é a tabela e Código o campo em
questão.

Índices devem ser definidos para colunas que façam parte de consultas com as
cláusulas Join (para junção de tabelas) e Order By e para colunas de chave primária ou
estrangeira.

______________________________________________________________

6
1.5 - Criando generators:

Um generator quando associado a uma trigger, é utilizado para emular um campo


autonumerado. O generator irá armazenar o valor de um campo especifico, que será
definido na trigger associada. Escreva no prompt:

SQL> create generator Inc_Pessoa; [Enter]


SQL>
___________________________________________________________

1.6 - Criando triggers:

Trigger é um código que é executado quando ocorre uma ação na tabela. Escreva:

set term $ ;
create trigger T_Pessoa for Pessoa before insert as
begin
new.codigo = gen_id(Inc_Pessoa,1);
end$
set term ; $

O comando Set Term define um novo caractere ou conjunto de caracteres como novo
terminador, com o objetivo de não confundir o término da trigger com o término de
um simples comando dentro da mesma.

A linha create trigger T_Pessoa for Pessoa before insert as define como T_Pessoa o
nome da trigger, Pessoa como sendo o nome da tabela à que a trigger deve atuar e,
before insert define que a trigger atuará antes que um novo registro seja inserido na
tabela.

A linha new.codigo = gen_id(Inc_Pessoa,1); define o campo codigo como sendo da


tabela associada, ao qual receberá o valor calculado por gen_id, que é uma função
interna do banco, que atribui ou subtrai o número especificado(1) do
contador(Generator Inc_Pessoa).

New é uma variável que armazena o novo valor a ser inserido na coluna. Você pode
recuperar o valor de um campo apagado usando a variável Old no lugar de New.

Nesta trigger, utilizei before insert, mas ainda temos as seguintes opções:

before update – antes de atualizar;


before delete – antes de apagar;
after insert – depois de inserir;
after update – depois de atualizar; e
after delete – depois de apagar;

Considerando-se que você crie duas ou mais triggers para a mesma tabela, é
necessário informar a ordem em que as triggers serão executadas. Isso se faz com a
cláusula Position, como nos exemplos:

Trigger before insert 1:

set term $ ;
create trigger T_Pessoa for Pessoa before insert position 0 as
begin

7
new.codigo = gen_id(Inc_Pessoa,1);
end$
set term ; $

Trigger before insert 2:

set term $ ;
create trigger T_Pessoa2 for Pessoa before insert position 1 as
begin
if (new.nome is null) then
begin
new.Nome = 'Nome não informado.';
end
end$
set term ; $

Nestes exemplos, a trigger T_Pessoa será executada primeiro, e a T_Pessoa2 logo em


seguida. Para alterar a ordem, basta mudar o número da cláusula Position.

_____________________________________________________________

1.7 - Criando Stored Procedures:

Uma Stored Procedure é um conjunto de instruções sql dadas ao banco.


Uma stored procedure pode conter código para incluir registros em uma tabela, alterá-
los, excluí-los, retornar valores de campos numerados, realizar cálculos, retornar a
quantidade de registros de uma tabela, o resultado de uma consulta, entre muitas
outras opções.

Podemos dividir as Stored Procedures em dois tipos: de seleção e de execução.


SPs de seleção retornam resultados de instruções Select. SPs de execução são
utilizados para alterar informações do banco de dados.

Como exemplo, vamos criar uma stored procedure que inclui dados em uma
tabela( uma procedure de execução):

set term $ ;
create procedure ProcPessoa(VarNome varchar(60), VarCpf
varchar(30)) as
begin
insert into Pessoa(Nome, Cpf) values(:VarNome, :VarCpf);
end$
set term ; $

Com o uso desta procedure, é mais fácil incluir um registro na tabela Pessoas,
simplesmente executando o comando:

SQL> execute procedure ProcProcedure('Fulano','1234567');


SQL> commit;

Agora um exemplo de uma procedure que permita alterar o conteúdo de um registro,


tendo como parâmetros, a chave primária do registro a ser alterado, e os novos
valores dos campos:

8
set term $ ;
create procedure UpPessoa(Codigo integer, Nome varchar(60), Cpf
varchar(30)) as
begin
update pessoa set
Nome = :Nome,
Cpf = :Cpf
where Codigo = :Codigo;
end$
set term ; $

Para executar a procedure:

SQL> execute procedure ProcProcedure(65,'Nome65','47828641562');


SQL> commit;

Criaremos agora uma procedure para apagar um registro da tabela, tendo como
parâmetro, a chave primária da tabela:

set term $ ;
create procedure DelPessoa(Codigo integer) as
begin
Delete from Pessoa
where Codigo = :Codigo;
end$
set term ; $

Para executar esta procedure:

SQL> execute procedure DelPessoa(3);


SQL> commit;

Vamos ver um exemplo de uma procedure de Seleção:

set term $ ;
create procedure SelectPessoa(Codigo integer) as
begin
Select Nome, Cpf from Pessoa
where Codigo = :Codigo;
end$
set term ; $

Para executar esta procedure:

SQL> execute procedure SelectPessoa(15);

_______________________________________________________________

9
1.8 - Criando Exceções

Exceções são definições de mensagens de erros criadas pelo usuário. São utilizadas em
triggers e procedures. Quando uma exceção é encontrada, a execução da trigger ou da
procedure é imediatamente interrompida e todas as alterações realizadas até o
momento são desfeitas. Exemplo de criação:

SQL> create exception Codigo_Invalido ‘Código inválido para


inclusão.’;

Uso:

set term $ ;
create trigger T_Pessoa for Pessoa before insert as
begin
if (new.codigo = 0) then
Exception Codigo_Invalido;
else
new.codigo = gen_id(Inc_Pessoa,1);
end$
set term ; $

______________________________________________________________

1.9 - Tipos de dados:

1.7.1 – Char(n)

O tipo Char armazena caracteres com o máximo de 32767, 32k. O tamanho da coluna
é definido com o ordinal passado na criação da tabela, Ex.:

SQL> create table Pessoa(Sexo char(1));

Este tipo de dado é utilizado quando se sabe o tamanho exato da coluna, e não é
variável. Se você criar uma coluna de 5 caracteres, e armazenar 3, sobrarão 2
caracteres vazios na coluna.

1.7.2 - Varchar(n)

O tipo Varchar também armazena caracteres com o máximo de 32767, 32k. O


tamanho da coluna é definido com o ordinal passado na criação da tabela, mas o
tamanho ocupado pela coluna na tabela depende das informações gravadas. Ex.:

SQL> create table Pessoa(Nome varchar(50));

Neste caso, diferentemente do tipo Char, se você não ocupar todos os campos da
coluna, gravando por exemplo apenas 5 caracteres, os 45 restantes não ficarão
consumindo memória a toa, sendo desconsiderados.

1.7.3 - Date

O tipo Date armazena Datas, e seu tamanho é de 32 bits inteiros longos. Ex.:

1
SQL> create table Pessoa(DiaInicio Date);

1.7.4 - Time

O tipo Time armazena a hora, e seu tamanho é de 32 bits inteiros longos. Ex.:

SQL> create table Pessoa(HoraCarrega Time);

1.7.5 - TimeStamp

O tipo TimeStamp armazena a Data e a hora ao mesmo tempo, e seu tamanho é de 32


bits inteiros longos. Ex.:

SQL> create table Pessoa(DiaHora TimeStamp);

1.7.6 – Decimal(n,n) e Numeric(n,n)

Os tipos de Dado Decimal e Numeric tem tamanho variável(16, 32 ou 64 bits) e


armazenam valores de ponto flutuante, na precisão especificada na criação da tabela.
Ex.:

SQL> create table Pessoa(Calculo Decimal(5,2), Contagem


Numeric(10,2));

A diferença entre eles é o conceito de precisão, que para o tipo Decimal é de até 18
dígitos, e para o tipo Numeric é de exatamente 18 dígitos.

1.7.7 - Smallint

O tipo Smallint armazena dígitos inteiros com o limite de: -32768 a 32767. Serve para
armazenar dados numéricos pequenos. Ex.:

SQL> create table Pessoa(Idade Smallint);

1.7.8 - Integer

O tipo Integer é um valor inteiro de 32 bits e armazena dígitos inteiros com o limite
de: -2.147.483.648 até 2.147.483.648. Ex.:

SQL> create table Pessoa(Codigo integer);

1.7.9 - Float

O tipo Float armazena valores de ponto flutuante, mas, com precisão simples de 7
dígitos. Ex.:

SQL> create table Pessoa(Salario float);

1
1.7.10 - Double Precision

O tipo Double Precision armazena valores de ponto flutuante mas com precisão de 64
bits. Ex.:

SQL> create table Pessoa (Armazenagem double precision);

1.7.11 - Blob

O tipo de Dado BLOB, tem o tamanho variável, mas, o limite do campo Blob que está
na documentação do InterBase, é de 64k por segmento. Este tipo de dado é indicado
para armazenar Textos Longos, Fotos, Gráficos, Ícones, ou qualquer outra informação.
Campos Blob não podem ser indexados. Quando se define uma coluna do tipo Blob,
deve-se informar o subtipo desejado. Os subtipos 0 e 1 são os mais utilizados, e
significam:

0 – Dados binários ou de tipo indeterminado;


1 – Texto;

Ex.:

SQL> create table Pessoa (Foto blob sub_type 0);

Caso você não indique nenhum subtipo, é adotado o subtipo 0 para a coluna.

______________________________________________________________

2 - Apagando objetos do banco


______________________________________________________________

Para apagar qualquer componente do banco, utiliza-se o comando Drop.

Por exemplo, apagando uma tabela:

SQL> drop table Tabela; [enter]


SQL>

Assim como a tabela, você pode apagar domains, stored procedures, triggers, etc.,
utilizando-se sempre do comando drop [componente] [nome do componente];

No Interbase não era possível a exclusão de um generator com o comando drop


generator nome_generator, como no Firebird, para excluir um GENERATOR, ele teria
que ser excluído direto da tabela de sistema do InterBase "RDB$GENERATORS".
Ex.:

SQL> DELETE FROM RDB$GENERATORS WHERE RDB$GENARATOR_NAME =


‘NOME_DO_GENERATOR’;

1
______________________________________________________________

3 - Alterando as estruturas dos objetos já criados no banco


______________________________________________________________

A alteração de estruturas como domains, triggers, entre outros componentes do banco


é feita com o comando:

Alter [componente] [nome do componente] [alterações].


______________________________________________________________

3.1 - Alterando um banco de dados

Para adicionar arquivos ao banco já criado, é necessário antes se conectar ao banco,


com o comando Connect, depois escrever a seguinte linha:

SQL> alter database add file ‘comercial.gd3’;


______________________________________________________________

3.2 - Alterando domains:

Pode-se alterar qualquer elemento de domínio, exceto os domínios de NOT NULL e o


tipo de dado. Para alterar o tipo de dado do domínio ou alterar o NOT NULL, deve-se
recriar o domínio. No ato de deleção e recriação do domínio, não deverá haver
nenhuma referência ao domínio em outros objetos do banco, caso contrário, a
operação não será possível.

SQL> create domain cod_id as integer;


SQL> alter domain cod_id add constraint check(value >0);
______________________________________________________________

3.3 – Alterando Índices

Índices podem ser ativados ou desativados. Quando ocorrem grandes alterações em


determinada tabela, como uma inclusão em massa de muitos registros, se existirem
índices vinculados a esta tabela, estes podem ficar desbalanceados, ou
desorganizados. Para que isto não ocorra, é prudente desativar o(s) índice(s) antes de
realizar as operações necessárias, reativando-os em seguida, com os respectivos
comandos:

SQL> alter index index_código inactive;


SQL> alter index index_código active;

Nas versões superiores a 1.5, este comando se dá corretamente, mas em versões


anteriores, o comando pode gerar um erro se o índice for definido pelas restrições
UNIQUE, PRIMARY KEY ou FOREIGN KEY.

______________________________________________________________

3.4 - Alterando generators;

Somente o que pode ser alterado nos generators é seu valor, mas não é utilizando o
comando Alter. Veja o exemplo:

1
SQL> set generator Inc_Pessoa to 0;

Isto fará com o que o generator retorne se valor para 0 (Zero). Qualquer número pode
ser colocado no lugar do ordinal. Mas é necessário tomar cuidado ao se alterar o valor
do generator, pois, se ele estiver sendo usado para emular um campo autonumerado,
podem ocorrer problemas de violação de chave primária, ou seja, a tentativa de gravar
uma chave primária que já existe.

E para alterar o nome do generator, somente recriando-o.

__________________________________________________________________

3.5 - Alterando stored procedures:

Para alterar uma procedure, reescreva o código da procedure, alterando a palavra


create por alter, e adicionando ou removendo o código desejado:

set term $ ;
alter procedure DelPessoa(Codigo integer) as
begin
if ( :Codigo <> 0 ) then
begin
Delete from Pessoa
where Codigo = :Codigo;
end
end$
set term ; $
______________________________________________________________

3.6 - Alterando tabelas:

Você pode apagar ou criar colunas na tabela, ou criar e apagar constraints:

SLQ> alter table Cliente drop Cpf, add Profissao varchar (30);
SQL>

Neste caso eu apaguei o campo Cpf, e incluí um novo campo: Profissao.

SQL> alter table pessoa add constraint codigo check( codigo > 0
and codigo < 99999 );

Aqui, eu adicionei uma validação para o campo Codigo. Para a constraint deve ser
passado o nome do campo onde aplicar a restrição:
constraint codigo check ( codigo > 0 ...

SQL> alter table pessoa drop constraint codigo;

E aqui, excluí a constraint previamente criada.

1
______________________________________________________________

3.7 - Alterando triggers:

Você pode alterar o corpo da trigger, apenas copiando o código utilizado na criação, e
alterando o que for necessário:

set term $ ;
alter trigger TPessoa before insert as
begin
new.codigo = gen_id(Inc_Pessoa,1);
update pessoa set Profissao = 'funcionario'
where codigo > new.codigo;
end$
set term ; $

O Alter também é utilizado para ativar ou desativar uma trigger:

SQL> alter trigger T_pessoa inactive;

Quando a trigger estiver Inactive, ela não será executada quando ocorrer a ação na
tabela para a qual foi especificada.

______________________________________________________________

4 - Utilizando arquivos externos na criação do banco


______________________________________________________________

Talvez o único ponto negativo do Isql para criação de bancos, seja a de não possuir
uma estrutura versátil para você poder criar/alterar os componentes do banco. É muito
cansativo e improdutivo você ter que escrever toda a estrutura do componente caso
tenha errado, ou ter que alterar a estrutura do componente caso tenha esquecido de
alguma coisa. Isso porque alterar a estrutura de um componente pode acarretar em
problemas, como referências a componentes já criados, dificultando bastante o
serviço. Mas há uma maneira de resolver esse tipo de problema: utilizando arquivos
externos para a criação do banco. Esses arquivos são arquivos do tipo texto que você
mesmo cria, contendo a estrutura dos componentes a serem criados, também
conhecidos como scripts. Por exemplo:

Crie um arquivo normal (pode ter qualquer extensão) e escreva a estrutura do


componente a ser criado. Por exemplo:

Edite um arquivo chamado Tabela.sql, e escreva:

create table Produtos(Codigo integer not null, Nome varchar(30)


not null, IdFornecedor integer not null, DataEntrada Date,
Quantidade integer, constraint Codprod primary key(Codigo));

Salve o arquivo. Em seguida, se conecte a um banco existente pelo Isql. Caso não
tenha nenhum, crie um banco simples e escreva no prompt do Isql:

SLQ> input Tabela.sql; [enter]

1
SQL>

O Isql lê o conteúdo do arquivo, e executa.

Lembre-se que no caso do Linux, há diferença entre caixa alta e caixa baixa, ou seja,
minúsculas e maiúsculas diferem.

Você pode utilizar este método para criar praticamente todas as estruturas que o
banco conterá, inclusive o próprio banco, bastando para isso, passar o comando que
você normalmente digitaria no prompt em um arquivo, e depois incluí-lo com o
comando input no Isql.

Por exemplo, crie um arquivo chamado Banco.sql, e digite:

create database 'Banco.gdb';


connect Banco.gdb;
create domain Codigo as integer;
create domain Nome as varchar(60);
create table Pessoa(CodPessoa Codigo, NomePessoa Nome, Cpf
varchar(30));

Salve o arquivo, execute o Isql, passando usuário e senha, e inclua o arquivo:

C:\Sql> isql -user SYSDBA -password masterkey


Use CONNECT or CREATE DATABASE to specify a database
SQL> input Banco.sql;
Commit current transaction (y/n)?y
Committing.
Database: c:\Sql\Banco.gdb, User: SYSDBA
SQL>

Após o comando input Banco.sql ser dado, o Isql perguntará Commit current
transaction (y/n)? para confirmar se você quer gravar as informações atuais, ou seja,
efetivar a criação do banco de dados. Digite y(Yes) e o banco será criado com base nas
informações contidas no arquivo.

Este é um método bastante versátil, mas você não precisa escrever toda a estrutura
do banco em um único arquivo. Você pode por exemplo, escrever as estruturas das
tabelas em um arquivo chamado Tabelas.sql, a estrutura dos domains em um arquivo
chamado Domains.sql, e assim por diante, organizando muito melhor seu banco de
dados. E para ligar todos os arquivos, e criar o banco a partir de um único comando,
faça o seguinte:

No arquivo em que você escrever a estrutura principal do banco, adicione os comandos


para carregar os outros arquivos:

create database 'Banco.gdb';


connect Banco.gdb;
input Domains.sql;
input Tabelas.sql;
input Triggers.sql;
**etc.**

Lembre-se, você poderá colocar quaisquer comandos pertinentes ao Isql em arquivos


para carregá-los posteriormente.

1
Mas este método também não é um método perfeito, apesar de ser eficiente e
produtivo, pois se você quiser alterar as estruturas de um banco existente, será
necessário apagar o banco que você deseja alterar, perdendo assim, os registros
gravados.

Por isso, considere no caso de você necessitar alterar a estrutura de um banco que já
esteja em uso o comando Alter, para não perder as informações já armazenadas.

______________________________________________________________

5 - Consultado os objetos contidos no banco


______________________________________________________________

Para listar os objetos (procedures, tabelas, etc.) contidos no banco, utiliza-se o


comando Show:

SQL> show [componente];

ou

SLQ> show [componente] [nome do componente a ser consultado];

Exemplo:

SQL> show table; ou SQL> show tables;

irá listar todas as tabelas contidas no banco, e

SLQ> show table pessoa;

irá mostrar o conteúdo (campos, tipos e constraints) da tabela pessoa.

A cláusula Show aplicada a um domínio, mostra o tipo do dado; aplicada a uma Stored
Procedure ou a uma Trigger, mostrará o código da mesma, e aplicada a um Generator
mostrará o seu valor atual.

______________________________________________________________

1
Parte 2. Introdução à sintaxe de consulta Sql

SQL significa Structured Query Language, ou Linguagem Estruturada de Consulta.


A SQL contém comandos que permitem a definição dos dados, chamada de DDL (Data
Definition Language - Definição de Dados Declarados), e como exemplo destes
comandos, temos: Create, Alter e Drop, que já foram vistos nesse tutorial, entre
outros.

E também comandos da série DML (Data Manipulation Language - Manipulação de


Dados Declarados), exclusivos para consultas, inserções, exclusões e alterações. Como
exemplo de comandos da classe DML temos os comandos Select, Insert, Update,
Delete, Commit e Rollback, estes que serão vistos mais adiante.
______________________________________________________________

1 - Extração de dados com o comando Select

Talvez o maior poder da linguagem Sql seja o de extrair os dados das mais variadas
opções possíveis, com segurança e rapidez.
A consulta mais simples possível é conseguida com o comando:

SQL> select * from [Tabela];

Todos os registros da tabela serão listados, na ordem em que foram incluídos.


Em qualquer consulta, é obrigatório informar quais colunas serão mostradas, e qual
tabela deve ser consultada.
No exemplo acima, o * (asterisco) representa todos os campos da tabela.
______________________________________________________________

2 - Extração de dados com restrições

Para colocar uma restrição a uma consulta, é usada a cláusula Where, como a seguir:

SQL> select * from pessoa where codigo =1;

Neste exemplo, todos os registros cujo campo Codigo seja igual a 1 serão mostrados
na consulta.

SQL> select nome from pessoa where codigo=1;

Já neste caso, apenas o campo Nome dos registros cujo campo Codigo seja igual a 1
serão mostrados na consulta.

SQL> select * from pessoa where nome='primeiro';

Todos os registros cujo campo Nome seja igual a 'primeiro' serão mostrados na
consulta.

SQL> select nome from pessoa where nome like '%n%';

1
Todos os registros cujo campo Nome contenha a letra n minúscula, em qualquer
posição serão mostrados na consulta.
Atenção: o Firebird é sensível a caixa, ou seja, se for passado n minúsculo, o select
procurará por n minúsculo, e ignorará N maiúsculo.
O Like aceita frases inteiras, como '%Comunicacao de dados%'.

SQL> select nome from pessoa where nome starting with 'A';

Esta consulta retornará todos os registros cujo campo Nome comece com o A
maiúsculo. A Consulta também se aplica a campos de outros tipos:

SQL> select nome from pessoa where codigo starting with 2;

O resultado será o campo Nome dos registros cujo campo Codigo inicie-se com o
ordinal 2.

Você pode aplicar agora várias restrições de consulta em uma mesma:

SQL> select nome from pessoa where codigo starting with 2 and nome
like '%t%';

É possível o retorno de dados mostrando várias colunas da tabela, mas não


necessariamente todas, informando quais colunas aparecerão, separadas por vírgula:

SQL> select codigo, nome from pessoa where codigo < 10;

Onde serão mostrados os campos Codigo e Nome de todos os registros, cujo campo
Codigo tenha o valor menor que 10.

Como obter o número de registros de uma tabela:

SQL> select count(*) from pessoa;

Você ainda pode definir um texto a ser mostrado quando a consulta for realizada, para
determinado campo ou valor. Por exemplo, como resultado do último comando
apresentado (select count(*) from pessoa), teríamos:

Count(*)
--------------
10

SQL>

Mas podemos alterar esse tipo de apresentação:

SQL> select count(*) “Total de registros” from pessoa;

E o resultado então seria algo parecido com isto:

Total de registros
------------------
10

1
SQL>

Você pode definir qualquer texto para qualquer coluna apresentada na consulta, como
por exemplo:

SQL> select Nome “Nome da Pessoa” from pessoa;


______________________________________________________________

3 - Ordenação dos dados extraídos

Em uma simples consulta, os dados são mostrados na ordem em que foram


cadastrados. Mas isso nem sempre é o ideal.

- 1.3.1 - Cláusula Order by

Para ordenar uma consulta por ordem alfabética pelo campo Nome por exemplo:

SQL> select * from pessoa order by nome;

É possível ordenar a consulta pela ordem invertida, como:

SQL> select * from pessoa order by codigo desc;

desc significa descending. O padrão para order by é asc (ascending).

- 1.3.2 - Cláusula Group By

Suponhamos que temos 5 registros cujo nome da pessoa seja Jose; faremos a
seguinte consulta:

SQL> select nome, count(*) "Numero" from pessoa where nome =


'Jose' group by nome;

O resultado dessa consulta será algo parecido com este:

NOME Numero
============================ ============
Jose 5

Ou seja, o comando group by agrupou todos os nomes iguais em uma só linha,


mostrando o resultado de count(*) com o título "Numero".
A função de group by é esta, agrupar os resultados, deixando a consulta mais "limpa".

- 1.3.3 - Cláusula Having

A cláusula Having desempenha a mesma função que o Where, mas com campos
calculados. Por exemplo:

Temos uma tabela com os seguintes registros:

2
SQL> select codigo, nome, valor from pessoa;

CODIGO NOME VALOR


========== =============== ============
1 Ademar 15.60
2 Jose 14.20
23 Antonio 8.40
3 Jose 4.56

E passamos a seguinte consulta:

SQL> select nome, sum(valor) "Valor agregado" from pessoa group by


nome having sum(valor) > 2;

Tendo como resultado:

NOME Valor agregado


===================== =====================
Ademar 15.60
Antonio 8.40
Jose 18.76

Sum() é uma função que calcula a soma dos campos da tabela, e Having restringe a
busca para os cálculos cujo resultado derem maior que 2, e sendo agrupados pelo
campo Nome. Neste caso, Group By vai agrupar todos os registros que tiverem o
mesmo conteúdo para o campo Nome, e a função Sum() vai atuar no somatório desses
registros iguais, gerando um único valor para o agrupamento.

Caso você omita a string "Valor agregado", não será gerado um erro, o que aparecerá
será sum(valor) como nome da coluna.

Em um somatório, como o Sum(), ou em qualquer outro tipo de cálculo, não é usada a


cláusula Where, pois isto geraria um erro, é nestes casos que utiliza-se Having.

Neste ponto podemos montar uma consulta mais complexa como a seguir:

SQL> select nome, sum(valor) "Valor agregado" from pessoa where


nome like '%e%' group by nome having sum(valor) > 2 order by nome
desc;

1.3.4 - Cláusulas First e Skip

First e Skip são cláusulas de limitação de consulta. Exemplo:

SQL> select first 5 skip 2 * from pessoa;

Obs.: Como em uma consulta normal, é necessário informar os campos que


aparecerão na consulta, e neste caso, o * (asterisco) representando todos os campos.

Nesta consulta, serão retornados apenas 5 registros, e dois deles serão ignorados, ou
seja, aparecerão 3 registros como resultado.

2
First faz retornar o número de registros especificados com o ordinal passado, enquanto
que o Skip ignora o número de registros representados pelo ordinal passado. No
exemplo acima, 2 dos 5 registros encontrados foram ignorados.
São comandos úteis principalmente para reduzir o tráfego na rede, evitando que
muitos dados sejam retornados à toa. E é claro, para restringir mais a consulta, podem
ser utilizados em conjunto com Where, Group By ou Having.

______________________________________________________________

2
Parte 3. Gravando e desfazendo alterações

Veremos aqui o uso das cláusulas Commit e Rollback.

Commit faz a gravação real das informações criadas/alteradas/excluídas das tabelas. É


chamada assim:

SQL> commit;

Rollback desfaz as alterações, inclusões ou exclusões executadas no banco, caso não


sejam efetivados com a cláusula Commit. É chamada assim:

SQL> rollback;

Quando você grava um novo registro em uma tabela, altera ou exclui um registro
existente, o registro é alterado em memória, ou seja, a gravação não é efetivamente
gravada no arquivo de banco de dados. Isso é extremamente útil em casos onde a
integridade dos dados é crítica.
Vou exemplificar:

Você necessita gravar dados em várias tabelas, e uma gravação depende do sucesso
da gravação de outra tabela, como campos calculados, chaves estrangeiras etc.. No
caso de uma gravação em uma tabela que não foi feita corretamente, devido a
inúmeros contratempos, a gravação nas outras tabelas ficará prejudicada, gerando
valores errados e desatualizados. É aí que entra o Rollback. Ele irá desfazer todas as
atualizações feitas no banco, que ainda estejam em memória, desde que não tenham
sido efetivadas com o Commit. Neste caso o Rollback não funcionará.
E caso todas as alterações no banco tenham ocorrido corretamente, o commit efetivará
a gravação dos dados no arquivo.

No Isql, o comando Exit é similar ao Commit, e o Quit ao Rollback, ou seja, se sair do


Isql utilizando Exit, os dados alterados serão gravados, caso contrário, todas as
alterações serão perdidas, desde o último Commit dado.

2
Parte 4. Utilização do IBConsole

Como eu já havia dito no início desta apostila, o Firebird não tem nenhuma interface
gráfica para manipulação de dados nativa. Porém aplicativos com este fim podem ser
encontrados na internet. Estarei mostrando brevemente a utilização do programa
IBConsole, da Borland, que é Open Source, e pode ser obtido no endereço:
http://info.borland.com/devsupport/interbase/opensource/ . A versão disponível é a
1.0.0.320.

Descompacte o arquivo em uma pasta específica, e execute o aplicativo (não é


necessário instalar).

Criando um novo banco:

Com o IBConsole aberto, temos na tela à esquerda a lista de servidores.


Vá ao menu Server e escolha Register.
Na tela que aparece, escolha Local Server; na descrição informe Banco, e SYSDBA e
masterkey para User Name e Password, respectivamente.
Um banco de dados local será adicionado à lista.

Agora, vá ao menu Database, e escolha Create Database. Informe um Alias de sua


preferência, e em File(s), adicione os nomes dos arquivos pertencentes ao banco de
dados, com seu caminho completo, como na figura:

2
Neste ponto, você pode definir o tamanho das páginas de dados do banco, bem como
o Character Set e o Dialeto. O dialeto deve ser o 3, já o tamanho das páginas e o
Character Set pode ser definido segundo as necessidades do banco.
Depois de tudo configurado dê OK. O banco será criado, e o alias adicionado a guia
Databases.
Com o banco já criado, agora podemos criar as tabelas, procedimentos, domains, e
demais estruturas necessárias. Para tanto, vá ao menu Tools – Interactive SQL.
Uma tela com a seguir será mostrada:

Nesta tela você pode entrar com quaisquer comandos pertinentes a linguagem SQL,
tanto para criação dos objetos do banco, como na figura, como para extração de dados
com o comando Select e inclusão/alteração/exclusão.
No caso da extração de dados, os resultados são mostrados na guia Data na parte de
baixo da tela.

Para executar os comandos passados, vá ao menu Query – Execute.

Também é possível carregar e executar arquivos com comandos(scripts). Para isto, vá


ao menu Query – Load Script. O conteúdo aparecerá na tela, bastando então
executá-lo.

Abrindo um banco existente:

Selecione Local Server à esquerda, e no menu Server, vá em Login, e informe


SYSDBA e masterkey para User Name e Password, respectivamente.
Com Local Server selecionado, vá ao menu Database – Register, e informe o
caminho do banco(botão de reticências para localizá-lo), User Name e Password, como
na figura a seguir:

2
Dê OK, e o banco estará disponível para utilização.

Na guia Database, os objetos do banco estarão listados em cada subitem. Por


exemplo, no subitem Tables, temos a lista de tabelas do banco de dados. Clicando
com o botão direito sobre uma tabela existente, e escolhendo Properties, temos
acesso à definição dos campos da tabela, a suas triggers associadas, ao código dos
objetos associados a tabela, os registros da tabela, entre outras informações.

Algo sobre o Interactive SQL e Transações.

Vimos que através do menu Tools – Interative SQL podemos informar comandos SQL
válidos, tanto para alteração e criação de objetos como para dados do banco.
Todos os comandos anteriormente passados, para serem executados em linha de
comando, podem ser executados aqui. Mas no caso de consultas e alterações de dados
nas tabelas do banco, o IBConsole abre uma transação para o processo, transação esta
que pode ser finalizada tanto com Commit como com Rollback, ambos já discutidos.
O Firebird sempre utilizou transações em todos os processos, mas isso não se torna
transparente para o usuário, pois é ele quem controla isso. No momento que você
executa um comando Update pelo Isql por exemplo, o Firebird automaticamente inicia
uma transação(caso não exista nenhuma ativa), que deve ser finalizada com Commit
ou Rollback. Agora no Interactive SQL do IBConsole, ele informa que uma nova
transação foi iniciada, escrevendo Transaction is ATIVE na barra de status.

Mas o que é uma transação?


Transações são métodos adotados nos bancos de dados relacionais para garantir a
integridade de todos os dados alterados no banco.
Quando se inicia uma transação no banco, o servidor faz cache em memória de todos
os registros das tabelas que estão sendo atualizados/apagados. Os dados só são
permanentemente gravados no banco, quando a transação se completa com
sucesso(com o comando Commit). Caso algum erro venha a ocorrer no meio da
transação, todos os dados são abandonados, retornando as tabelas ao modo como
estavam antes, sem perda de dados, corrupção, ou erros nas tabelas.

2
O recurso de transação não existe em bancos Desktop(Paradox por exemplo), apenas
em bancos Cliente/Servidor, e tem a função principal de manter a integridade e
segurança dos dados, principalmente onde existem muitos clientes acessando as
mesmas informações ao mesmo tempo.
Quando você inicia uma nova transação, e executa um Select, os dados retornados,
serão os dados mais atuais gravados na(s) tabelas(s).

No IBConsole, as transações são transparentes ao usuário, porém ele não as controla


explicitamente.
O controle explícito de transações de ser feito no programa que trabalhará com o
banco de dados, para que a integridade dos dados seja a maior possível.

==========================================

Espero que este pequeno tutorial tenha sido proveitoso, que tire suas principais
dúvidas com relação ao banco de dados apresentado, ou que seja um ponto de partida
para o estudo deste sistema complexo que é um banco de dados relacional.
É isso! (;-)

Vous aimerez peut-être aussi