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

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

2

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 databaseSQL>

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].

_____________________________________________________________

1 - Criando o banco de dados_____________________________________________________________

no Windows:

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

3

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>

**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.

_____________________________________________________________

4

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]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:

5

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.

______________________________________________________________

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:

6

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; eafter 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 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.';

7

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)) asbegin 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:

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

Para executar a procedure:

8

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) asbegin 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) asbegin Select Nome, Cpf from Pessoa where Codigo = :Codigo;end$set term ; $

Para executar esta procedure:

SQL> execute procedure SelectPessoa(15);

_______________________________________________________________

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

9

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.:

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

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.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;

1

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’;

______________________________________________________________

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:

1

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:

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

1

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.

______________________________________________________________

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 asbegin 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;

1

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]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

1

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

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.

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:

1

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.

______________________________________________________________

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.

1

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%';

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;

1

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

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

1

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:

SQL> select codigo, nome, valor from pessoa;

CODIGO NOME VALOR========== =============== ============1 Ademar 15.602 Jose 14.2023 Antonio 8.403 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.60Antonio 8.40Jose 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.

2

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.

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

2

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.

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.

2

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:

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.

2

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.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! (;-)

2