Share Button

Quando trabalha com FMX no delphi é praticamente obrigatório trabalhar com um arsenal de imagens para melhorar o visual. Imagens são usadas para botões, títulos, rodapés, fundo…. imagem, imagem, imagem….

Para manter um padrão de tamanho e mesmo visual de imagem o TimageList é fundamental… além de não carregar a mesma imagem em vários locais diferentes…

Para isto tudo ficar bom, precisamos retirar as imagens da lista e passar para um componente que na maioria não tem aquela propriedade experta para marcar qual o indice da imagem.

Imagine que vc queira um fundo em um TRectangle e a imagem desejada esteja em um TimageList…

var
   bmp:TCustomBitmapItem;
   n:TSize;
begin
   AImageList.BitmapItemByName(bgNome ,bmp,n);
   ABitmap.Assign( bmp.Bitmap );
end;

Nestes casos cai bem um TDatamodule para centralizar as imagens já que ele será utilizado em várias janelas do sistema.

Share Button

When I was preparing the sample code for the article on Forin to FireDAC , I remembered an article by my friend Marcos Douglas  published in Object Pascal Programming  that speaks of the Imperative or Structured programming.

In computer science, imperative programming is a programming paradigm that describes computation as actions, statements or commands that change the state (variables) of a program. Much like the imperative behavior of natural languages ​​that express orders, imperative programs are a sequence of commands to the computer running.  (Wikipedia)

The article has as objective to discuss the end of FreeAndNil proposing the use of Interface PASCAL programming. Extracting the concept is possible to write code using directly interface which demonstrates the power of language forward to the new paradigms.

Rewriting TFDQuery interface, we can do:

TQueryIntf.New (FDConnection1)
          .table ( 'sigcad a')
          .FieldNames ( 'code, name')
          .Where ( 'between code: codigo_de and: codigo_ate')
          .ParamValue ( 'codigo_de', 1)
          .ParamValue ( 'codigo_ate', 5)
          .open
          .DoQuery (Procedure (ds: TDataset)
                    begin
                         memo1.Lines.Add ( 'loaded' + IntToStr (ds.RecordCount))
                    end);

Share Button

Quando estava preparando os exemplos de código para o artigo sobre ForIn para FireDAC, lembrei de um artigo do meu amigo Marcos Douglas publicado no Object Pascal Programming que discorre sobre a programação Imperativa ou Estruturada.

Na Ciência da Computação, programação imperativa é um paradigma de programação que descreve a computação como ações, enunciados ou comandos que mudam o estado (variáveis) de um programa. Muito parecido com o comportamento imperativo das linguagens naturais que expressam ordens, programas imperativos são uma sequência de comandos para o computador executar. (Wikipedia)

O artigo traz como objetivo discutir o fim do FreeAndNil propondo a utilização de Interface na programação PASCAL. Extraindo o conceito é possível escrever código utilizando diretamente interface o que demostra o poder da linguagem frente aos novos paradigmas.

Reescrevendo TFDQuery com interface, podemos fazer:

   TQueryIntf.New(FDConnection1)
      .Table('sigcad a')
      .FieldNames('codigo,nome')
      .Where('codigo between :codigo_de and :codigo_ate')
      .ParamValue('codigo_de', 1)
      .ParamValue('codigo_ate',5)
      .open
      .DoQuery( procedure (ds:TDataset)
          begin
            memo1.Lines.Add( 'Carregou: '+intToStr(ds.RecordCount) )
          end);

 

Share Button

Recurso de loops com ForIn não estão disponível para os componentes TDataSet o que não permite usar:

var fld:TFields;
begin
    for fld in FQuery1 do
     begin
         memo1.lines.add( fld.fieldByName('nome').asString );
     end;
end;

Um objeto que queira fazer uso de ForIn deve implementar a interface IEnumerator.
Fazendo uma adaptação útil para a classe TFDQuery do FireDAC é possível escrever os seguintes métodos para atender a condição do ForIn:

    function GetEnumerator: IQuery;
    function GetCurrent: TFields;
    property Current:TFields read GetCurrent;
    function MoveNext: boolean;
    procedure Reset;

Código Fonte no Git

A propriedade de colunas da tabela já implementa Enumerator o que permite usar:

   for f in query1.fields do
       begin
          memo1.Lines.add( f.FieldName );
       end;

Share Button

Sim…. replicação para firebird… não tem ? tem sim… só trabalhar um pouco – nem tudo é como visão de brigadeiro..

A replicação consistem manter DUAS ou mais tabelas com conteúdo iguais – de tal forma que se obtém o mesmo resultado em qualquer uma das duas bases de dados.

Existe dois lados na replicação – um que tem os dados que precisam ser levados para o outro (publisher-aquele que publica) – o outro que recebe os dados publicados pelo servidor (subscriptor-aquele que se candidata a receber os dados). Por último a combinação de ambos em um só – ele é tanto publisher como subscriptor da mesma tabela;


Fase do desenvolvimento

  1. Preparar o Publisher para publicar dados para replicação (banco de origem);
  2. Preparar o Subscriptor para receber os dados publicados (banco de destino);
  3. Codificar os componente que monitoram as alterações do Publisher;
  4. Codificar a transferências dos dados da origem para o destino;

 

A título ilustrativo, vou adotar a tabela de PEDIDOs como base

Considere a seguinte tabela:


create table  PEDIDOS  (dcto varchar(10), 
                        data Date, 
                        cliente integer, 
                        total numeric(15,4));


Preparando o banco de origem em firebird

Como base para a replicação, vou criar uma coluna nova na tabela de pedidos na origem para indicar a chave de referência para a replicação – para fugir dos tipos auto-incrementos (já escrevi como fazer isto aqui no blog) vou usar uma coluna para identificar a chave de replicação que receberá uma representação texto para um GUID

alter table PEDIDOS add GID varchar(38);

[OFF] antes que alguém questione… não dá para usar auto-incremento em razão de atender a pré-condição de que o dado dever ser o mesmo nos dois banco de dados (traduzindo – não podem ser diferentes)

A coluna GID vai receber um valor por “trigger” toda vez que for incluída na tabela

SET TERM ^ ;
ALTER TRIGGER REPL_PEDIDOS_GID ACTIVE
BEFORE INSERT OR UPDATE POSITION 0
AS 
begin 
  /* Trigger Utilizado para Replicacao */ 
  if ((new.gid is null)) then 
     new.gid =  UUID_TO_CHAR( gen_uuid() ); 
end^
SET TERM ; ^

[OFF] como se nota inclui na trigger o UPDATE – fiz isto para pegar linhas antigas que ainda não foram replicadas em nenhum processo anterior – caso ocorre uma replicação parcial;

Até aqui já temos a marcação de chave na tabela de origem para localizar as linhas que serão publicadas para replicação. Agora vamos criar uma tabela de controle de publicação das replicações

CREATE TABLE REPL_ITENS
  (
    TABELA Varchar(128),   // recebe o nome da tabela alvo
    GID Varchar(38),       // recebe o GID da tabela alvo 
    TIPO Char(1),          // I-insert U-update D-delete
    DATA Date,             // data e hora da alteração
    ID integer,            // sequencial interna
    SESSION_ID integer     // sessão da transação que criou - um luxo
  );
CREATE INDEX REPL_ITENSDATA ON REPL_ITENS (DATA);
CREATE INDEX REPL_ITENSGID ON REPL_ITENS (GID);
CREATE INDEX REPL_ITENSID ON REPL_ITENS (ID);
CREATE INDEX REPL_ITENSTABELA ON REPL_ITENS (TABELA);
GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE
ON REPL_ITENS TO SYSDBA WITH GRANT OPTION;

Vamos precisar de um GENERATOR para popular a coluna ID da tabela e uma trigger para popular com o valor do GENERATOR. ver também

CREATE GENERATOR REPL_ITENS_GEN_ID;
SET TERM ^ ;
CREATE TRIGGER REPL_ITENS_ID FOR REPL_ITENS ACTIVE
BEFORE INSERT POSITION 0
AS 
begin /* Replicacao Storeware */ 
  new.id = gen_id(REPL_ITENS_GEN_ID,1); 
  new.session_id = rdb$get_context('SYSTEM','SESSION_ID'); 
  new.data = cast('now' as date); 
end^
SET TERM ; ^

[OFF] para este caso não usei o GUID – vamos precisar garantir uma sequência na tabela que seja em ordem crescente – isto vai facilitar a codificação a frente.

 

Para fechar, vamos ensinar a tabela PEDIDOS como publicar as suas alterações:

SET TERM ^ ;
CREATE TRIGGER REPL_PEDIDOS_REG FOR PEDIDOS ACTIVE
AFTER INSERT OR UPDATE OR DELETE POSITION 0
AS 
begin 
  /* Replicacao Storeware */ 
  in autonomous transaction do 
  begin 
   if (inserting) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',new.gid,'I'); 
   if (updating) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',new.gid,'U'); 
   if (deleting) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',old.gid,'D'); 
  end 
end 
^
SET TERM ; 

 

Preparando o banco de dados de destino

No banco de dados destino temos a mesma tabela de pedidos (o ideal que possua a mesma estrutura).

Considerando que durante a replicação dos dados ocorrerão momentos em que haverá UPDATEs e DELETEs para fazer – será necessário ter uma chave correspondente para a alteração do registro. Esta chave não pode ser controlado localmente pelo banco, ela precisa ser uma chave que tanto o banco de origem como o banco de destino sejam cooperativos. A este requisito a chave GID que recebe um GUID atente perfeitamente.

alter table PEDIDOS add GID varchar(38);

A “trigger” para gerenciar a coluna GID segue o mesmo comportamento do banco de origem.

SET TERM ^ ;
ALTER TRIGGER REPL_PEDIDOS_GID ACTIVE
BEFORE INSERT OR UPDATE POSITION 0
AS 
begin 
  /* Trigger Utilizado para Replicacao */ 
  if ((new.gid is null)) then 
     new.gid =  UUID_TO_CHAR( gen_uuid() ); 
end^
SET TERM ; ^

[OFF] Note que a trigger checa se o GID é null – isto é importante pois quem vai gerar a chave para o GID é o banco que criou o registro (onde ele nasceu) e durante toda a sua vida precisa receber o mesmo valor nos dois banco de dados.

Agora já temos tudo que precisamos no banco de dados para controlar o que será replicado. Passemos a construir os códigos que vão fazer a replicação em si.


Codificando o select para monitorar as alterações na Origem

O select na origem, ou no publisher, será feito considerando que queremos somente as linhas alteradas para serem transferidas para o banco de destino.

Para isto precisamos fazer controle de quais linhas foram e quais linhas ainda não foram para o destino. Para isto foi que usei um GENERATOR para a tabela de controle   REPL_ITEMS->id

Uma vez executado a replicação precisamos guardar qual foi o ultimo ID utilizado para ser utilizado na próxima chamada:

  select a.*, b.tipo repl_tipo from PEDIDOS a, REPL_ITEMS b
  where  a.gid = b.gid and b.id>:id
  order by b.id

Para tabelas com muitas linhas, pode ser interessante usar um derivação incluindo o número de linhas a sincronizar a cada chamada:

  select first 1000 a.*, b.tipo repl_tipo from PEDIDOS a, REPL_ITEMS b
  where  a.gid = b.gid and b.id>:id
  order by b.id

Codificando a transferência dos dados para o destino

Chegou o momento de enviar o dados da Origem para o Destino….
Dependendo da coluna REPL_TIPO que vem do Select na Origem:
I – Faz um INSERT na tabela de destino;
U – Faz um UPDATE;
D – Faz um DELETE;

Esteja preparado para tratar algumas exceções:

  • quando for fazer um UPDATE e o registro ainda não se encontra no destino, precisando fazer o INSERT para iniciar o registro;
  • quando for fazer DELETE de uma registro que não existe;
  • fazer INSERT de registro que já tem chave primária idêntica no destino;
  • se esta inciando a sincronização de uma tabela que já existe, sinalizar a tabela de eventos com os dados já existentes;

 


 

 

Projeto no Git

 

 

 

Share Button

Quando estamos rodando um código em um processo paralelo e internamente a Thread encontra pela frente uma EXCEPTION nada é apresentado para o usuário. Isto ocorre porque a Thread não tem como notificar a Thread Principal (do app) para mostrar a exceção ao usuário. Com isto não há um expediente para mostrar a exceção na thread principal.  escreve sobre o tema em seu blog Rob’s Technology Corner.

Robert propõe a rotina que gera erro para contextuar o problema:


procedure TForm5.Button1Click(Sender: TObject);
begin
  Button1.Enabled := False;
  SlowProc;
end;

procedure TForm5.FormDestroy(Sender: TObject);
begin
  Task.Cancel;
end;

procedure TForm5.SlowProc;
begin
 Task := TTask.Create( procedure
                var
                   I : Integer;
                begin
                  for I := 0 to 9 do
                  begin
                     if TTask.CurrentTask.Status = TTaskStatus.Canceled then
                        exit;
                     Sleep(1000);
                     if I = 2 then
                        raise EProgrammerNotFound.Create('Something bad just happened');
                  end;
                  if TTask.CurrentTask.Status <> TTaskStatus.Canceled then
                  begin
                    TThread.Queue(TThread.CurrentThread,
                    procedure
                    begin
                      if Assigned(ListBox1) then
                      begin
                        Listbox1.Items.Add('10 Seconds');
                        Button1.Enabled := True;
                      end;
                    end);
                 end;
              end);
 Task.Start;
end;

Executando o código é possível constatar que o procedimento levanta uma exceção e o usuário não recebe a informação de erro.

Stefan Glienke observando o que escreve Robert, propõe uma alteração em TTask para permitir tratar as exceções transparentes para o usuário e mais simples na implementação.
Glienke empresta de .NET uma implementação de Task.ContinueWith que permite continuar a execução após a ocorrência da exceção, veja como ficou.

unit ThreadingEx;
 
interface
 
uses
  SysUtils,
  Threading;
 
type
  TAction<T> = reference to procedure(const arg: T);
 
  TTaskContinuationOptions = (
    NotOnCompleted,
    NotOnFaulted,
    NotOnCanceled,
    OnlyOnCompleted,
    OnlyOnFaulted,
    OnlyOnCanceled
  );
 
  ITaskEx = interface(ITask)
    ['{3AE1A614-27AA-4B5A-BC50-42483650E20D}']
    function GetExceptObj: Exception;
    function GetStatus: TTaskStatus;
    function ContinueWith(const continuationAction: TAction<ITaskEx>;
      continuationOptions: TTaskContinuationOptions): ITaskEx;
 
    property ExceptObj: Exception read GetExceptObj;
    property Status: TTaskStatus read GetStatus;
  end;
 
  TTaskEx = class(TTask, ITaskEx)
  private
    fExceptObj: Exception;
    function GetExceptObj: Exception;
  protected
    function ContinueWith(const continuationAction: TAction<ITaskEx>;
      continuationOptions: TTaskContinuationOptions): ITaskEx;
  public
    destructor Destroy; override;
 
    class function Run(const action: TProc): ITaskEx; static;
  end;
 
implementation
 
uses
  Classes;
 
{ TTaskEx }
 
function TTaskEx.ContinueWith(const continuationAction: TAction<ITaskEx>;
  continuationOptions: TTaskContinuationOptions): ITaskEx;
begin
  Result := TTaskEx.Run(
    procedure
    var
      task: ITaskEx;
      doContinue: Boolean;
    begin
      task := Self;
      if not IsComplete then
        DoneEvent.WaitFor;
      fExceptObj := GetExceptionObject;
      case continuationOptions of
        NotOnCompleted:  doContinue := GetStatus <> TTaskStatus.Completed;
        NotOnFaulted:    doContinue := GetStatus <> TTaskStatus.Exception;
        NotOnCanceled:   doContinue := GetStatus <> TTaskStatus.Canceled;
        OnlyOnCompleted: doContinue := GetStatus = TTaskStatus.Completed;
        OnlyOnFaulted:   doContinue := GetStatus = TTaskStatus.Exception;
        OnlyOnCanceled:  doContinue := GetStatus = TTaskStatus.Canceled;
      else
        doContinue := False;
      end;
      if doContinue then
        continuationAction(task);
    end);
end;
 
destructor TTaskEx.Destroy;
begin
  fExceptObj.Free;
  inherited;
end;
 
function TTaskEx.GetExceptObj: Exception;
begin
  Result := fExceptObj;
end;
 
class function TTaskEx.Run(const action: TProc): ITaskEx;
var
  task: TTaskEx;
begin
  task := TTaskEx.Create(nil, TNotifyEvent(nil), action, TThreadPool.Default, nil);
  Result := task.Start as ITaskEx;
end;
 
end.

Como usar a nova implementação de TTask…

TTaskEx.Run(
  procedure
  begin
    Sleep(2000);
    raise EProgrammerNotFound.Create('whoops')
  end)
  .ContinueWith(
  procedure(const t: ITaskEx)
  begin
    TThread.Queue(nil,
      procedure
      begin
        ShowMessage(t.ExceptObj.Message);
      end);
  end, OnlyOnFaulted);

 

Ver PPL – TTask an example in how not to use

Share Button

A chave primária é responsável em manter a integridade da tabela no banco de dados e o índice de maior eficiência disponível.

Deveríamos ter uma regra obrigatória:
“NAO PODE DEIXAR DE INDICAR A CHAVE PRIMÁRIA”

Para localizar as tabelas que não possuem chave primária executar:

SELECT RDB$RELATION_NAME AS Tabela
 FROM RDB$RELATIONS
WHERE RDB$RELATION_TYPE IN (0, 4, 5)
 AND (RDB$SYSTEM_FLAG = 0 OR RDB$SYSTEM_FLAG IS NULL)
 AND RDB$RELATION_NAME NOT IN
 (SELECT RDB$RELATION_NAME FROM RDB$RELATION_CONSTRAINTS
 WHERE RDB$CONSTRAINT_TYPE = 'PRIMARY KEY')
ORDER BY RDB$RELATION_NAME;

fonte: Firebird Conference 2014 – Ivan Prenosil

Share Button

Este artigo foi revisão – acesse o link aqui

Sim…. replicação para firebird… não tem ? tem sim… só trabalhar um pouco – nem tudo é como visão de brigadeiro..

A replicação consistem manter DUAS ou mais tabelas com conteúdo iguais – de tal forma que se obtém o mesmo resultado em qualquer uma das duas bases de dados.

Existe dois lados na replicação – um que tem os dados que precisam ser levados para o outro (publisher-aquele que publica) – o outro que recebe os dados publicados pelo servidor (subscriptor-aquele que se candidata a receber os dados). Por último a combinação de ambos em um só – ele é tanto publisher como subscriptor da mesma tabela;


Fase do desenvolvimento

  1. Preparar o Publisher para publicar dados para replicação (banco de origem);
  2. Preparar o Subscriptor para receber os dados publicados (banco de destino);
  3. Codificar os componente que monitoram as alterações do Publisher;
  4. Codificar a transferências dos dados da origem para o destino;

 

A título ilustrativo, vou adotar a tabela de PEDIDOs como base

Considere a seguinte tabela:


create table &nbsp;PEDIDOS &nbsp;(dcto varchar(10), 
                        data Date, 
                        cliente integer, 
                        total numeric(15,4));


Preparando o banco de origem em firebird

Como base para a replicação, vou criar uma coluna nova na tabela de pedidos na origem para indicar a chave de referência para a replicação – para fugir dos tipos auto-incrementos (já escrevi como fazer isto aqui no blog) vou usar uma coluna para identificar a chave de replicação que receberá uma representação texto para um GUID

alter table PEDIDOS add GID varchar(38);

[OFF] antes que alguém questione… não dá para usar auto-incremento em razão de atender a pré-condição de que o dado dever ser o mesmo nos dois banco de dados (traduzindo – não podem ser diferentes)

A coluna GID  vai receber um valor por “trigger”  toda vez que for incluída na tabela

SET TERM ^ ;
ALTER TRIGGER REPL_PEDIDOS_GID ACTIVE
BEFORE INSERT OR UPDATE POSITION 0
AS 
begin 
  /* Trigger Utilizado para Replicacao */ 
  if ((new.gid is null)) then 
     new.gid =  UUID_TO_CHAR( gen_uuid() ); 
end^
SET TERM ; ^

[OFF] como se nota inclui na trigger o UPDATE – fiz isto para pegar linhas antigas que ainda não foram replicadas em nenhum processo anterior – caso ocorre uma replicação parcial;

Até aqui já temos a marcação de chave na tabela de origem para localizar as linhas que serão publicadas para replicação. Agora vamos criar uma tabela de controle de publicação das replicações

CREATE TABLE REPL_ITENS
  (
    TABELA Varchar(128),   // recebe o nome da tabela alvo
    GID Varchar(38),       // recebe o GID da tabela alvo 
    TIPO Char(1),          // I-insert U-update D-delete
    DATA Date,             // data e hora da alteração
    ID integer,            // sequencial interna
    SESSION_ID&nbsp;integer     // sessão da transação que criou - um luxo
  );
CREATE INDEX REPL_ITENSDATA ON REPL_ITENS (DATA);
CREATE INDEX REPL_ITENSGID ON REPL_ITENS (GID);
CREATE INDEX REPL_ITENSID ON REPL_ITENS (ID);
CREATE INDEX REPL_ITENSTABELA ON REPL_ITENS (TABELA);
GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE
ON REPL_ITENS TO SYSDBA WITH GRANT OPTION;

Vamos precisar de um GENERATOR para popular a coluna ID da tabela e uma trigger para popular com o valor do GENERATOR. ver também

CREATE GENERATOR REPL_ITENS_GEN_ID;
SET TERM ^ ;
CREATE TRIGGER REPL_ITENS_ID FOR REPL_ITENS ACTIVE
BEFORE INSERT POSITION 0
AS 
begin /* Replicacao Storeware */ 
  new.id = gen_id(REPL_ITENS_GEN_ID,1); 
  new.session_id = rdb$get_context('SYSTEM','SESSION_ID'); 
  new.data = cast('now' as date); 
end^
SET TERM ; ^

[OFF] para este caso não usei o GUID – vamos precisar garantir uma sequência na tabela que seja em ordem crescente – isto vai facilitar a codificação a frente.

 

Para fechar, vamos ensinar a tabela PEDIDOS como publicar as suas alterações:

SET TERM ^ ;
CREATE TRIGGER REPL_PEDIDOS_REG FOR PEDIDOS ACTIVE
AFTER INSERT OR UPDATE OR DELETE POSITION 0
AS 
begin 
  /* Replicacao Storeware */ 
  in autonomous transaction do 
  begin 
   if (inserting) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',new.gid,'I'); 
   if (updating) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',new.gid,'U'); 
   if (deleting) then 
     insert into repl_itens ( tabela,gid,tipo) 
            values('PEDIDOS',old.gid,'D'); 
  end 
end 
^
SET TERM ; 

Parte 2


Share Button

Algumas vezes já me declarei com pouca disposição em escrever uma infinidade de linhas de código para fazer coisas simples.
Depois de ver outros artigos tratando sobre a geração de chave de relacionamento em “Master x Detail” e ver códigos de colegas montando engenhocas para obter a chave gerada pelo banco de dados (auto incremento), vou arriscar por pimenta nesta conversa.

Contexto: É fato que é muito comum gerar colunas de auto incremento no banco de dados para criar o relacionamento entre tabelas. Dependendo do banco de dados isto é efetuado por tipagem da coluna direto na tabela como auto incremento (ex: mysql) ou em outros casos se usa triggers para gerar a sequência (ex: Firebird); Num ou outra situação ocorre a mesma coisa, o identificador é gerado pelo servidor sem conhecimento do aplicativo.
Neste contexto é possível obter a chave gerada diretamente na mesma instrução de INSERT como ocorre no Firebird ou ainda, através de recurso da API de acesso ao banco como existe no FIREDAC.

Como fazer com comando direto no Firebird

No FireDAC há a possibilidade de escrever diretamente por comandos para a API do FireDAC e instruí-lo a retornar através de “preprocessing”:

    insert into fb_pedido 
                         (codigo,qtde) 
                    value( :codigo, :qtde)  
                    returning id_pedido {into :id_pedido}

Documentação Embarcadero

Proposta para simplificar:
Já há algum tempo que as linguagens incluem um gerador de identificador único para múltiplos propósito – falando de GUID – que gera uma sequência única por máquina a cada chamada (ligado ao relógio).
Então a idéia é criar na tabela pedido uma coluna que recebe a nova chave única que servirá para o relacionamento do pedido (Master & Detail):
Firebird:

     // GID - coluna para receber o GUID (texto)
     alter table tb_pedido add GID varchar(38) not null;

usando o delphi, gerar localmente o GID e incluí-lo no insert.

     var gid:string;
     ...
     gid := GuidToString( TGuid.NewGuid );   //(SysUtils) chave de relacionamento do pedido
     ...
     insert into tb_pedido
                          ( gid, codigo, qtde) 
                    values( :gid, :codigo, :qtde)


Uma vez gerado a chave GID (GUID ID), os itens passam a receber a mesma informação para indicar o relacionamento entre as tabelas… ou seja, não precisamos daqueles “auto incrementos” que as vezes traz uma lista de códigos associados.

 

Share Button

Excluir uma chave primária quando se tem uma ferramenta visual a frente não é uma operação complicada de se fazer no Firebird.
O problema mesmo… é quando precisamos fazer isto por um script…
O Firebird usa um mapeamento de nomes para a chave primária que cria – diferente do nome do índice e passa a fazer parte da lista de “constraints” da tabela.
Para excluir uma “constraint” é necessário descobrir o seu nome e aplicar a “DROP” da constrait. A seguir código para um procedimento que procura o nome da “constraint” e executa o “DROP” da mesma.

Como usar: Execute Procedure RDB$DELETE_PRIMARYKEY(‘produtos’);


SET TERM ^;

CREATE OR ALTER PROCEDURE RDB$DELETE_PRIMARYKEY (
    tabela varchar(128))
as
declare variable nome varchar(128);
declare variable d  varchar(128);
declare variable stm varchar(1024);
begin

-- localiza o nome da constraint
select rdb$constraint_name from rdb$relation_constraints
where rdb$relation_name= UPPER(:tabela)
     AND rdb$constraint_type='PRIMARY KEY'
into :nome;

-- monta o comando
stm = 'ALTER TABLE '||:tabela||' DROP CONSTRAINT '|| coalesce(:nome,'INDEF');


  if (:nome is not null) then
  begin
    execute statement stm;
  end else
    exception erro 'Nao encontrei a chave primaria para apagar';

  suspend;
end^

SET TERM ; ^