Jump to content

Nova Loja Oficial
loja.projetoacbr.com.br
Ajude o projeto a crescer, com estilo

Comprar

Balança SM100 performance surpreendente

Tecnologia Japonesa   Teclado e Visor resistentes a água
Consumo inteligente de etiquetas   Baixo custo de manutenção
Comunicação Ethernet e WIFI independentes

Saiba mais

Impressora de Etiquetas ELGIN - L42 PRO

Protocolos PPLA, PPLB, ZPL, EPL (automático)
Porta USB padrão Opcionais: Ethernet, Serial, Paralela
Sensor de Etiquetas Móvel Garantia de 18 meses

Saiba mais

Recommended Posts

Bom dia.
Querendo agilizar o desenvolvimento, resolvi criar um gerador de Querys baseado na classe do FDQuery da Biblioteca do FireDac.
O meu gerador conecta na Tabela do banco de Dados e gera uma classe dessa tabela configurada para o uso no sistema, acho que é simples assim...
Do jeito que desenhei funciona muito bem, assim defino no meu gerador os Títulos dos campos e suas configurações, tudo em um lugar só...
Pra mim ficou muito bom, mas, nem sempre a facilidade vem acompanhada de maravilhas, o meu componente funciona do jeito que eu queria, gero as classe de minhas tabelas e aplico nos formulários já configurada e sem problema algum na manutenção de dados na hora da execução, mas, em  desenvolvimento, estou com um errinho chato...

image.png.8b263097bef56888c6d531e0f3428144.png

Todas as vezes que abro meu Data Modulo eu me deparo com esse erro para todos os campos da minha query, ai tenho que ignorar tudo e a vida continua, não afeta a aplicação, mas toda vez tenho que fazer isso ao entrar em algum formulário...
Então, o que eu quero e uma ajuda, pois não descobri como fazer com que a Query identifique que esses campos já existem nela ao abrir o DM...
Achei muitos exemplos na internet, mas que precisam dar close/open no componente pra adicionar cada campo, acredito eu, que deva ter um jeito mais simples, só não achei onde encaixar esses fields para que a Query o reconheça em Desenvolvimento
Estou postando o exemplo.
Grato pela ajuda, se conseguir depois posto o resultado final pra quem se interessar...

Estou usando banco de dados Firebird 2.5

CREATE TABLE DATA_TYPE_CODE (
    FIELD_SMALLINT          SMALLINT,
    FIELD_INTEGER           INTEGER,
    FIELD_BIGINT            BIGINT,
    FIELD_FLOAT             FLOAT,
    FIELD_DOUBLE_PRECISION  DOUBLE PRECISION,
    FIELD_NUMERIC           NUMERIC(16,8),
    FIELD_DECIMAL           DECIMAL(18,6),
    FIELD_DATE              DATE,
    FIELD_TIME              TIME,
    FIELD_TIMESTAMP         TIMESTAMP,
    FIELD_CHAR              CHAR(1),
    FIELD_VARCHAR           VARCHAR(100),
    FIELD_BLOB              BLOB SUB_TYPE 1 SEGMENT SIZE 1024
);

TESTE_COMPONENTE.rar

Edited by bilogyn
Incluir SQL da Tabela

Analysis and System Development - Delphi Programmer - Computer Technician - Developing solutions together

 

Share this post


Link to post
Share on other sites

Não vou ter tempo pra ver, mas achei muito interessante seu componente.

5 horas atrás, bilogyn disse:

estou com um errinho chato...

image.png.8b263097bef56888c6d531e0f3428144.png

Todas as vezes que abro meu Data Modulo eu me deparo com esse erro para todos os campos da minha query, ai tenho que ignorar tudo e a vida continua, não afeta a aplicação, mas toda vez tenho que fazer isso ao entrar em algum formulário...

Pelo erro, ou o arquivo dfm já possui o campo, ou o seu componente está criando os campos novamente. Então bastaria você tratar isso.

5 horas atrás, bilogyn disse:

pois não descobri como fazer com que a Query identifique que esses campos já existem nela ao abrir o DM...

Estritamente falando, os campos não existem "nela". Eles estão relacionados com ela. Então a ideia seria validar se eles já existem no form ou DM.

5 horas atrás, bilogyn disse:

Achei muitos exemplos na internet, mas que precisam dar close/open no componente pra adicionar cada campo, acredito eu, que deva ter um jeito mais simples, só não achei onde encaixar esses fields para que a Query o reconheça em Desenvolvimento

Bom, se não tiver jeito de fazer isso automaticamente, isso explica o motivo de não ser feito nos componentes do Delphi.

Mas caso contrário, se você tem o Delphi, você tem o código da VCL e assim pode verificar como é que um TDataSet implementa essa facilidade quando selecionamos "Add all Fields".


[]'s

Consultor SAC ACBr

Elton
Ajude o Projeto ACBr crescer - Assine o SAC

Projeto ACBr     Telefone:(15) 2105-0750 WhatsApp(15)99790-2976.

Um engenheiro de Controle de Qualidade(QA) entra num bar. Pede uma cerveja. Pede zero cervejas.
Pede 99999999 cervejas. Pede -1 cervejas. Pede um jacaré. Pede asdfdhklçkh.

Share this post


Link to post
Share on other sites

Boa noite.
Eu tentei validar se existem sim, mas não acertei o ponto, nem consegui descobrir como o Delphi faz no Fields Editor, até vasculhei o código por dias, o problema é que sempre que abro o Form proprietário a Query tenta recriar esses campos, é como se eles não estivessem registrados pra ela... 
O Field ao ser criado ele recebe o proprietário da Query como seu proprietário, isso faz com que ele apareça no DM ou Form, mas pra aparecer no Fields Editor eu seto somente .DataSet := Self, assim ele aparece la, creio eu, mas acredito que tenha mas algum detalhe, pois a Query não o reconhece em desenvolvimento...
Se eu descobrir esse ponto vai ficar muito legal montar uma query sem ter que configurar os Fields no Fields Editor do DataSet um por um...

😥


Analysis and System Development - Delphi Programmer - Computer Technician - Developing solutions together

 

Share this post


Link to post
Share on other sites

Boa noite.
Eu consegui resolver fazendo um "miau".
Depois de horas tentando fazer igual ao Fields Editor do Delphi eu percebi que não precisava  de nada disso,  o meu único problema era que, como eu crie uma propriedade que cria os Fields da minha classe e os configurava na query, ao abrir meu DM o componente é criado juntamente com suas propriedades, como eu coloquei no método "SET" da propriedade "ActiveFields" as funções que executavam a criação e as configurações dos Fields, dava o erro...
Resolvi criando uma variável que eu inicializo no create da classe pra não deixar executar novamente a criação dos Fields existente ao passar pela propriedade...
Mas nem tudo é perfeito, ao colocar uma classe no DM, eu só consigo criar os Fields na segunda tentativa, ou seja, tenho que ativa, desativar e ativar de novo pra que a propriedade funcione e crie os Fields, depois disso funciona 100%, porem não dá mais o erro na tela!
Mais ainda aguardo sugestões, pois pra mim ainda não ficou bom...

😜

UTypeCode.pas

  • Like 1

Analysis and System Development - Delphi Programmer - Computer Technician - Developing solutions together

 

Share this post


Link to post
Share on other sites

Pra ajudar quem se interessou a fazer sua classe, esta aqui o comando SQL para Firebird:

Só uma observação, o Nome da Tabela tem que ser exatamente igual ao que esta no banco respeitando palavras Maiúsculas / Minúsculas!

😉

 

SELECT SUBSTRING(A.RDB$FIELD_NAME FROM 1 FOR 4) AS MINEMONICO
      ,A.RDB$RELATION_NAME AS TABELA
      ,REPLACE(A.RDB$RELATION_NAME, '_', ' ') AS TABELA_TITULO
      ,CAST(E.RDB$DESCRIPTION AS VARCHAR(5000)) AS TABELA_DESCRICAO
      ,A.RDB$FIELD_NAME AS CAMPO
      ,A.RDB$FIELD_POSITION +1 AS POSICAO
      ,REPLACE(A.RDB$FIELD_NAME, '_', ' ') AS CAMPO_TITULO
      ,CAST(A.RDB$DESCRIPTION AS VARCHAR(5000)) AS CAMPO_DESCRICAO
      ,0 AS VISIVEL -- 0 - Não; 1 - Sim
      ,0 AS SOMENTE_LEITURA -- 0 - Não; 1 - Sim
      ,B.RDB$FIELD_TYPE AS CODIGO_TIPO
      ,CASE WHEN B.RDB$FIELD_TYPE = 007 THEN 'SMALLINT' 
            WHEN B.RDB$FIELD_TYPE = 008 THEN 'INTEGER' 
            WHEN B.RDB$FIELD_TYPE = 010 THEN 'FLOAT' 
            WHEN B.RDB$FIELD_TYPE = 012 THEN 'DATE' 
            WHEN B.RDB$FIELD_TYPE = 013 THEN 'TIME' 
            WHEN B.RDB$FIELD_TYPE = 014 THEN 'CHAR' 
            WHEN B.RDB$FIELD_TYPE = 016 THEN 'BIGINT' 
            WHEN B.RDB$FIELD_TYPE = 027 THEN 'DOUBLE PRECISION' 
            WHEN B.RDB$FIELD_TYPE = 035 THEN 'TIMESTAMP' 
            WHEN B.RDB$FIELD_TYPE = 037 THEN 'VARCHAR' 
            WHEN B.RDB$FIELD_TYPE = 261 THEN 'BLOB' 
            ELSE 'UNKNOWN' 
       END AS TIPO
      ,D.TIPO_CHAVE AS TIPO_CHAVE
      ,B.RDB$FIELD_LENGTH AS TAMANHO
      ,COALESCE(B.RDB$FIELD_PRECISION, 0)  AS PRECISAO
      ,COALESCE(B.RDB$FIELD_SCALE, 0) AS CASAS_DECIMAIS
      ,REPLACE(CAST(A.RDB$DEFAULT_SOURCE AS VARCHAR(100)), 'DEFAULT ', '') AS VALOR_PADRAO
      ,CASE WHEN A.RDB$NULL_FLAG = 1 THEN 1 ELSE 0 END AS OBRIGATORIO -- 0 - Não; 1 - Sim
      ,0  AS DINHEIRO -- 0 - Não; 1 - Sim
      ,'                                                   ' AS MASCARA
      ,D.UNICO AS UNICO -- 0 - Sim
  FROM RDB$RELATION_FIELDS A 
 INNER JOIN RDB$FIELDS B ON B.RDB$FIELD_NAME = A.RDB$FIELD_SOURCE 
 INNER JOIN RDB$TYPES C ON C.RDB$TYPE = B.RDB$FIELD_TYPE AND C.RDB$FIELD_NAME = 'RDB$FIELD_TYPE' 
 INNER JOIN RDB$RELATIONS E ON A.RDB$RELATION_NAME = E.RDB$RELATION_NAME 
 
 LEFT JOIN (SELECT DISTINCT(RDB$INDEX_SEGMENTS.RDB$FIELD_NAME)  AS CAMPO_CHAVE, 
                   CASE WHEN (RDB$RELATION_CONSTRAINTS.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY') THEN 'PRIMARY KEY' 
                        WHEN (RDB$RELATION_CONSTRAINTS.RDB$CONSTRAINT_TYPE = 'FOREIGN KEY') THEN 'FOREIGN KEY' 
                        WHEN (RDB$RELATION_CONSTRAINTS.RDB$CONSTRAINT_TYPE = 'UNIQUE') THEN 'UNIQUE' 
                        ELSE '' 
                   END AS TIPO_CHAVE, 
                   CASE WHEN (RDB$RELATION_CONSTRAINTS.RDB$CONSTRAINT_TYPE = 'UNIQUE') THEN 1 ELSE 0 END AS UNICO, 
                   RDB$RELATION_CONSTRAINTS.RDB$RELATION_NAME   AS TABELA 
              FROM RDB$RELATION_CONSTRAINTS, 
                   RDB$INDICES, 
                   RDB$INDEX_SEGMENTS 
             WHERE RDB$RELATION_CONSTRAINTS.RDB$INDEX_NAME = RDB$INDICES.RDB$INDEX_NAME 
               AND RDB$INDEX_SEGMENTS.RDB$INDEX_NAME = RDB$INDICES.RDB$INDEX_NAME) D ON D.TABELA = A.RDB$RELATION_NAME AND D.CAMPO_CHAVE = A.RDB$FIELD_NAME 
 
 WHERE A.RDB$RELATION_NAME = :NOME_TABELA 
 ORDER BY 6 --RDB$FIELD_POSITION 

 

Para facilitar as Pesquisas:
 

{---------------------------------------------------------}
{  Autor: Fabrício Melo                                   }
{  e-Mail: [email protected]                               }
{  skype: fabricio_ftm                                    }
{  Desenvolvedor Delphi                                   }
{                                                         }
{  Componente derivado da TFDQuery, exemplo de como       }
{ escrever uma Tabela e configurar seus campos sem a      }
{ necessidade de usar o Fields Editor do DataSet.         }
{ O Trablho esta em Criar um executável que conecte no    }
{ Banco de Dados e depois modifique essa classe para as   }
{ informaçoes da Tabela desejada, linha a linha. ;)       }
{---------------------------------------------------------}
unit UTypeCode;

interface 
 
uses 
  Classes, DB, SysUtils, MaskUtils, Math, DateUtils,
  FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Param,
  FireDAC.Stan.Error, FireDAC.DatS, FireDAC.Phys.Intf,
  FireDAC.DApt.Intf, FireDAC.Stan.Async, FireDAC.DApt,
  FireDAC.Comp.DataSet, FireDAC.Comp.Client;
 
const
  //Identificação da Tabela
  TBL_FIELD = 'DATA_TYPE_CODE';
  //Generators
  GEN_FIELD = 'GEN_FIELD_ID';
  //Campos da Tabela
  FDN_FIELD_SMALLINT = 'FIELD_SMALLINT';
  FDN_FIELD_INTEGER = 'FIELD_INTEGER';
  FDN_FIELD_BIGINT = 'FIELD_BIGINT';
  FDN_FIELD_FLOAT = 'FIELD_FLOAT';
  FDN_FIELD_DOUBLE_PRECISION = 'FIELD_DOUBLE_PRECISION';
  FDN_FIELD_NUMERIC = 'FIELD_NUMERIC';
  FDN_FIELD_DECIMAL = 'FIELD_DECIMAL';
  FDN_FIELD_DATE = 'FIELD_DATE';
  FDN_FIELD_TIME = 'FIELD_TIME';
  FDN_FIELD_TIMESTAMP = 'FIELD_TIMESTAMP';
  FDN_FIELD_CHAR = 'FIELD_CHAR';
  FDN_FIELD_VARCHAR = 'FIELD_VARCHAR';
  FDN_FIELD_BLOB = 'FIELD_BLOB';
  //Título dos Campos da Tabela
  CPT_FIELD_SMALLINT = 'Field Smallint';
  CPT_FIELD_INTEGER = 'Field Integer';
  CPT_FIELD_BIGINT = 'Field Bigint';
  CPT_FIELD_FLOAT = 'Field Float';
  CPT_FIELD_DOUBLE_PRECISION = 'Field Double Precision';
  CPT_FIELD_NUMERIC = 'Field Numeric';
  CPT_FIELD_DECIMAL = 'Field Decimal';
  CPT_FIELD_DATE = 'Field Date';
  CPT_FIELD_TIME = 'Field Time';
  CPT_FIELD_TIMESTAMP = 'Field Timestamp';
  CPT_FIELD_CHAR = 'Field Char';
  CPT_FIELD_VARCHAR = 'Field Varchar';
  CPT_FIELD_BLOB = 'Field Blob';

type

 TFDQueryTypeCode = class(TFDQuery)
  private
    //Flag para não recriar os Fields ao Abrir o proprietário
    FActiveFieldsExecute: Boolean;
    //Armazenar o proprietário
    FOwner: TComponent;

    FActiveFields: Boolean;

    procedure SetActiveFields(const Value: Boolean);

  public
    //Criação do Objeto
    constructor Create(AOwner: TComponent); override;
    //Depois de Criado
    procedure AfterConstruction; override;
    //Criar os campos na Query...
    procedure CreateFields(AOwner: TComponent);
    //Validar as informações dos Campos
    procedure ValidateFields;
    //Valores Padrões dos Campos Obrigatórios
    procedure ValueDefault;
    //Comando SQL da Tabela
    procedure CommandSQL;

  protected
    //Antes de Gravar
    procedure DoBeforePost; override;
    //Inicializar Campos
    procedure DoAfterInsert; override;
    //Recarregar o Comando SQL Original
    procedure DoAfterClose; override;

  published
    //Criar os Campos
    property ActiveFields: Boolean read FActiveFields write SetActiveFields default False;

 end;

procedure Register;

implementation

{ TFDTaTypeCode }

procedure Register;
begin
  //Paleta de Ferramentas
  RegisterComponents('Minha Paleta Delphi', [ TFDQueryTypeCode ]);
 
end;

constructor TFDQueryTypeCode.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  //Armazenar o Form ou DM Proprietário
  FOwner                         := AOwner;
  //Aplicar as Configurações desejadas na Query
  UpdateOptions.GeneratorName    := GEN_FIELD;
  UpdateOptions.UpdateTableName  := TBL_FIELD;
  UpdateOptions.KeyFields        := FDN_FIELD_SMALLINT;
  UpdateOptions.AssignedValues   := [uvGeneratorName];
  CachedUpdates                  := True;
  AggregatesActive               := True;

  FActiveFieldsExecute           := False;

end; 
 
procedure TFDQueryTypeCode.AfterConstruction;
begin 
  inherited;
  //Carregar o Comando SQL
  CommandSQL; 
 
end; 
 
procedure TFDQueryTypeCode.CommandSQL;
{-- Tabela Exemplo - Firebird
  CREATE TABLE DATA_TYPE_CODE (
    FIELD_SMALLINT          SMALLINT,
    FIELD_INTEGER           INTEGER,
    FIELD_BIGINT            BIGINT,
    FIELD_FLOAT             FLOAT,
    FIELD_DOUBLE_PRECISION  DOUBLE PRECISION,
    FIELD_NUMERIC           NUMERIC(16,8),
    FIELD_DECIMAL           DECIMAL(18,6),
    FIELD_DATE              DATE,
    FIELD_TIME              TIME,
    FIELD_TIMESTAMP         TIMESTAMP,
    FIELD_CHAR              CHAR(1),
    FIELD_VARCHAR           VARCHAR(100),
    FIELD_BLOB              BLOB SUB_TYPE 1 SEGMENT SIZE 1024);
}
begin 
  inherited; 

  SQL.Add('SELECT '); 
  SQL.Add('       FIELD.FIELD_SMALLINT ');
  SQL.Add('      ,FIELD.FIELD_INTEGER ');
  SQL.Add('      ,FIELD.FIELD_BIGINT ');
  SQL.Add('      ,FIELD.FIELD_FLOAT ');
  SQL.Add('      ,FIELD.FIELD_DOUBLE_PRECISION ');
  SQL.Add('      ,FIELD.FIELD_NUMERIC ');
  SQL.Add('      ,FIELD.FIELD_DECIMAL ');
  SQL.Add('      ,FIELD.FIELD_DATE ');
  SQL.Add('      ,FIELD.FIELD_TIME ');
  SQL.Add('      ,FIELD.FIELD_TIMESTAMP ');
  SQL.Add('      ,FIELD.FIELD_CHAR ');
  SQL.Add('      ,FIELD.FIELD_VARCHAR ');
  SQL.Add('      ,FIELD.FIELD_BLOB ');
  SQL.Add('  FROM DATA_TYPE_CODE FIELD ');
  SQL.Add(' WHERE (1=1) ');

  {Para usar no form:
    Query.Close;
    Query.SQL.Add(' AND FIELD_SMALLINT = 1982 ');
    Query.Open;
  }
end; 

procedure TFDQueryTypeCode.SetActiveFields(const Value: Boolean);
begin

  FActiveFields := Value;
  //Flag pra controlar no Create do Proprietário
  if FActiveFieldsExecute then
    if FOwner <> nil then
      //Criando os Campos no DataSet em Desenvolvimento
      if ( csDesigning in Self.ComponentState ) then
      begin
        //Remove do DataSet e do Proprietário
        if Self.FieldCount > 0 then
          Self.Fields.Clear;
        //Criar os Campos Novamente no DataSet e no Proprietário
        if FActiveFields then
          CreateFields(FOwner);
      end;

  FActiveFieldsExecute := True;

end;

procedure TFDQueryTypeCode.CreateFields(AOwner: TComponent);
var
  FIELD_SMALLINT: TSmallintField;
  FIELD_INTEGER: TIntegerField;
  FIELD_BIGINT: TLargeintField;
  FIELD_FLOAT: TSingleField;
  FIELD_DOUBLE_PRECISION: TFloatField;
  FIELD_NUMERIC: TFMTBCDField;
  FIELD_DECIMAL: TFMTBCDField;
  FIELD_DATE: TDateField;
  FIELD_TIME: TTimeField;
  FIELD_TIMESTAMP: TSQLTimeStampField;
  FIELD_CHAR: TStringField;
  FIELD_VARCHAR: TStringField;
  FIELD_BLOB: TMemoField;
  FieldDef: TFieldDef;
begin
  //Tipos Comuns do Firebird
  FIELD_SMALLINT                := TSmallintField.Create(AOwner);
  FIELD_SMALLINT.FieldKind      := fkData;
  FIELD_SMALLINT.Origin         := FDN_FIELD_SMALLINT;
  FIELD_SMALLINT.fieldName      := FDN_FIELD_SMALLINT;
  FIELD_SMALLINT.DisplayLabel   := CPT_FIELD_SMALLINT;
  FIELD_SMALLINT.DisplayWidth   := 24;
  FIELD_SMALLINT.ProviderFlags  := [pfInUpdate];
  FIELD_SMALLINT.Required       := False;
  FIELD_SMALLINT.ReadOnly       := False;
  FIELD_SMALLINT.Visible        := True;
  FIELD_SMALLINT.Name           := Self.Name + FDN_FIELD_SMALLINT;
  FIELD_SMALLINT.Index          := Self.FieldCount;
  FIELD_SMALLINT.DataSet        := Self;

  FIELD_INTEGER                := TIntegerField.Create(AOwner);
  FIELD_INTEGER.FieldKind      := fkData;
  FIELD_INTEGER.Origin         := FDN_FIELD_INTEGER;
  FIELD_INTEGER.fieldName      := FDN_FIELD_INTEGER;
  FIELD_INTEGER.DisplayLabel   := CPT_FIELD_INTEGER;
  FIELD_INTEGER.DisplayWidth   := 23;
  FIELD_INTEGER.ProviderFlags  := [pfInUpdate];
  FIELD_INTEGER.Required       := False;
  FIELD_INTEGER.ReadOnly       := False;
  FIELD_INTEGER.Visible        := True;
  FIELD_INTEGER.Name           := Self.Name + FDN_FIELD_INTEGER;
  FIELD_INTEGER.Index          := Self.FieldCount;
  FIELD_INTEGER.DataSet        := Self; 
 
  FIELD_BIGINT                := TLargeintField.Create(AOwner);
  FIELD_BIGINT.FieldKind      := fkData; 
  FIELD_BIGINT.Origin         := FDN_FIELD_BIGINT;
  FIELD_BIGINT.fieldName      := FDN_FIELD_BIGINT;
  FIELD_BIGINT.DisplayLabel   := CPT_FIELD_BIGINT; 
  FIELD_BIGINT.DisplayWidth   := 22; 
  FIELD_BIGINT.ProviderFlags  := [pfInUpdate]; 
  FIELD_BIGINT.Required       := False; 
  FIELD_BIGINT.ReadOnly       := False; 
  FIELD_BIGINT.Visible        := True; 
  FIELD_BIGINT.Name           := Self.Name + FDN_FIELD_BIGINT;
  FIELD_BIGINT.Index          := Self.FieldCount; 
  FIELD_BIGINT.DataSet        := Self; 
 
  FIELD_FLOAT                := TSingleField.Create(AOwner);
  FIELD_FLOAT.FieldKind      := fkData; 
  FIELD_FLOAT.Origin         := FDN_FIELD_FLOAT;
  FIELD_FLOAT.fieldName      := FDN_FIELD_FLOAT;
  FIELD_FLOAT.DisplayLabel   := CPT_FIELD_FLOAT; 
  FIELD_FLOAT.DisplayWidth   := 21; 
  //FIELD_FLOAT.Size           := 4;
  FIELD_FLOAT.Precision      := 7;
  FIELD_FLOAT.ProviderFlags  := [pfInUpdate]; 
  FIELD_FLOAT.Required       := False; 
  FIELD_FLOAT.ReadOnly       := False; 
  FIELD_FLOAT.Visible        := True; 
  FIELD_FLOAT.Name           := Self.Name + FDN_FIELD_FLOAT;
  FIELD_FLOAT.Index          := Self.FieldCount; 
  FIELD_FLOAT.DataSet        := Self; 
 
  FIELD_DOUBLE_PRECISION                := TFloatField.Create(AOwner);
  FIELD_DOUBLE_PRECISION.FieldKind      := fkData; 
  FIELD_DOUBLE_PRECISION.Origin         := FDN_FIELD_DOUBLE_PRECISION;
  FIELD_DOUBLE_PRECISION.fieldName      := FDN_FIELD_DOUBLE_PRECISION;
  FIELD_DOUBLE_PRECISION.DisplayLabel   := CPT_FIELD_DOUBLE_PRECISION; 
  FIELD_DOUBLE_PRECISION.DisplayWidth   := 32; 
  //FIELD_DOUBLE_PRECISION.Size           := 8;
  FIELD_DOUBLE_PRECISION.Precision      := 15;
  FIELD_DOUBLE_PRECISION.ProviderFlags  := [pfInUpdate]; 
  FIELD_DOUBLE_PRECISION.Required       := False; 
  FIELD_DOUBLE_PRECISION.ReadOnly       := False; 
  FIELD_DOUBLE_PRECISION.Visible        := True; 
  FIELD_DOUBLE_PRECISION.Name           := Self.Name + FDN_FIELD_DOUBLE_PRECISION;
  FIELD_DOUBLE_PRECISION.Index          := Self.FieldCount; 
  FIELD_DOUBLE_PRECISION.DataSet        := Self; 
 
  FIELD_NUMERIC                    := TFMTBCDField.Create(AOwner);
  FIELD_NUMERIC.FieldKind          := fkData;
  FIELD_NUMERIC.Origin             := FDN_FIELD_NUMERIC;
  FIELD_NUMERIC.fieldName          := FDN_FIELD_NUMERIC;
  FIELD_NUMERIC.DisplayLabel       := CPT_FIELD_NUMERIC;
  FIELD_NUMERIC.DisplayWidth       := 23;
  //FIELD_DOUBLE_PRECISION.Size      := 8;
  FIELD_DOUBLE_PRECISION.Precision := 18;
  FIELD_NUMERIC.ProviderFlags      := [pfInUpdate];
  FIELD_NUMERIC.Required           := False;
  FIELD_NUMERIC.ReadOnly           := False;
  FIELD_NUMERIC.Visible            := True;
  FIELD_NUMERIC.Name               := Self.Name + FDN_FIELD_NUMERIC;
  FIELD_NUMERIC.Index              := Self.FieldCount;
  FIELD_NUMERIC.DataSet            := Self;
 
  FIELD_DECIMAL                    := TFMTBCDField.Create(AOwner);
  FIELD_DECIMAL.FieldKind          := fkData;
  FIELD_DECIMAL.Origin             := FDN_FIELD_DECIMAL;
  FIELD_DECIMAL.fieldName          := FDN_FIELD_DECIMAL;
  FIELD_DECIMAL.DisplayLabel       := CPT_FIELD_DECIMAL;
  FIELD_DECIMAL.DisplayWidth       := 23;
  //FIELD_DOUBLE_PRECISION.Size      := 6;
  FIELD_DOUBLE_PRECISION.Precision := 18;
  FIELD_DECIMAL.ProviderFlags      := [pfInUpdate];
  FIELD_DECIMAL.Required           := False;
  FIELD_DECIMAL.ReadOnly           := False;
  FIELD_DECIMAL.Visible            := True;
  FIELD_DECIMAL.Name               := Self.Name + FDN_FIELD_DECIMAL;
  FIELD_DECIMAL.Index              := Self.FieldCount;
  FIELD_DECIMAL.DataSet            := Self;
 
  FIELD_DATE                := TDateField.Create(AOwner);
  FIELD_DATE.FieldKind      := fkData; 
  FIELD_DATE.Origin         := FDN_FIELD_DATE;
  FIELD_DATE.fieldName      := FDN_FIELD_DATE;
  FIELD_DATE.DisplayLabel   := CPT_FIELD_DATE; 
  FIELD_DATE.DisplayWidth   := 20; 
  FIELD_DATE.ProviderFlags  := [pfInUpdate]; 
  FIELD_DATE.Required       := False; 
  FIELD_DATE.ReadOnly       := False; 
  FIELD_DATE.Visible        := True; 
  FIELD_DATE.Name           := Self.Name + FDN_FIELD_DATE;
  FIELD_DATE.Index          := Self.FieldCount; 
  FIELD_DATE.DataSet        := Self; 
 
  FIELD_TIME                := TTimeField.Create(AOwner);
  FIELD_TIME.FieldKind      := fkData; 
  FIELD_TIME.Origin         := FDN_FIELD_TIME;
  FIELD_TIME.fieldName      := FDN_FIELD_TIME;
  FIELD_TIME.DisplayLabel   := CPT_FIELD_TIME; 
  FIELD_TIME.DisplayWidth   := 20; 
  FIELD_TIME.ProviderFlags  := [pfInUpdate]; 
  FIELD_TIME.Required       := False; 
  FIELD_TIME.ReadOnly       := False; 
  FIELD_TIME.Visible        := True; 
  FIELD_TIME.Name           := Self.Name + FDN_FIELD_TIME;
  FIELD_TIME.Index          := Self.FieldCount; 
  FIELD_TIME.DataSet        := Self; 
 
  FIELD_TIMESTAMP                := TSQLTimeStampField.Create(AOwner);
  FIELD_TIMESTAMP.FieldKind      := fkData; 
  FIELD_TIMESTAMP.Origin         := FDN_FIELD_TIMESTAMP;
  FIELD_TIMESTAMP.fieldName      := FDN_FIELD_TIMESTAMP;
  FIELD_TIMESTAMP.DisplayLabel   := CPT_FIELD_TIMESTAMP; 
  FIELD_TIMESTAMP.DisplayWidth   := 25; 
  FIELD_TIMESTAMP.ProviderFlags  := [pfInUpdate]; 
  FIELD_TIMESTAMP.Required       := False; 
  FIELD_TIMESTAMP.ReadOnly       := False; 
  FIELD_TIMESTAMP.Visible        := True; 
  FIELD_TIMESTAMP.Name           := Self.Name + FDN_FIELD_TIMESTAMP;
  FIELD_TIMESTAMP.Index          := Self.FieldCount; 
  FIELD_TIMESTAMP.DataSet        := Self; 
 
  FIELD_CHAR                := TStringField.Create(AOwner);
  FIELD_CHAR.FieldKind      := fkData; 
  FIELD_CHAR.Origin         := FDN_FIELD_CHAR;
  FIELD_CHAR.fieldName      := FDN_FIELD_CHAR;
  FIELD_CHAR.DisplayLabel   := CPT_FIELD_CHAR; 
  FIELD_CHAR.DisplayWidth   := 20; 
  FIELD_CHAR.Size           := 1; 
  FIELD_CHAR.ProviderFlags  := [pfInUpdate]; 
  FIELD_CHAR.Required       := False; 
  FIELD_CHAR.ReadOnly       := False; 
  FIELD_CHAR.Visible        := True; 
  FIELD_CHAR.Name           := Self.Name + FDN_FIELD_CHAR;
  FIELD_CHAR.Index          := Self.FieldCount; 
  FIELD_CHAR.DataSet        := Self; 
 
  FIELD_VARCHAR                := TStringField.Create(AOwner);
  FIELD_VARCHAR.FieldKind      := fkData; 
  FIELD_VARCHAR.Origin         := FDN_FIELD_VARCHAR;
  FIELD_VARCHAR.fieldName      := FDN_FIELD_VARCHAR;
  FIELD_VARCHAR.DisplayLabel   := CPT_FIELD_VARCHAR; 
  FIELD_VARCHAR.DisplayWidth   := 40; 
  FIELD_VARCHAR.Size           := 100; 
  FIELD_VARCHAR.ProviderFlags  := [pfInUpdate]; 
  FIELD_VARCHAR.Required       := False; 
  FIELD_VARCHAR.ReadOnly       := False; 
  FIELD_VARCHAR.Visible        := True; 
  FIELD_VARCHAR.Name           := Self.Name + FDN_FIELD_VARCHAR;
  FIELD_VARCHAR.Index          := Self.FieldCount; 
  FIELD_VARCHAR.DataSet        := Self; 
 
  FIELD_BLOB                := TMemoField.Create(AOwner);
  FIELD_BLOB.FieldKind      := fkData; 
  FIELD_BLOB.Origin         := FDN_FIELD_BLOB;
  FIELD_BLOB.fieldName      := FDN_FIELD_BLOB;
  FIELD_BLOB.DisplayLabel   := CPT_FIELD_BLOB; 
  FIELD_BLOB.DisplayWidth   := 20; 
  FIELD_BLOB.ProviderFlags  := [pfInUpdate]; 
  FIELD_BLOB.Required       := False; 
  FIELD_BLOB.ReadOnly       := False; 
  FIELD_BLOB.Visible        := False; 
  FIELD_BLOB.Name           := Self.Name + FDN_FIELD_BLOB;
  FIELD_BLOB.Index          := Self.FieldCount; 
  FIELD_BLOB.DataSet        := Self; 
 
end; 

procedure TFDQueryTypeCode.DoAfterClose;
begin
  inherited;
  //Recarregar o Comando SQL Original
  CommandSQL;

end;

procedure TFDQueryTypeCode.DoAfterInsert;
begin
  inherited;
  //Definir os Valores Padrões dos Campos Obrigatórios
  ValueDefault;

end;

procedure TFDQueryTypeCode.DoBeforePost;
begin
  inherited;
  //Validar os Campos Obrigatórios
  ValidateFields;

end;

procedure TFDQueryTypeCode.ValidateFields;
begin 
  inherited; 
  //Testar aqui os Valores Obrigatórios
  if FindField(FDN_FIELD_SMALLINT) <> nil then
    if FieldByName(FDN_FIELD_SMALLINT).IsNull then
      FieldByName(FDN_FIELD_SMALLINT).AsInteger  := 0;
 
  if FindField(FDN_FIELD_INTEGER) <> nil then
    if FieldByName(FDN_FIELD_INTEGER).IsNull then
      FieldByName(FDN_FIELD_INTEGER).AsInteger := 0;
 
  if FindField(FDN_FIELD_BIGINT) <> nil then
    if FieldByName(FDN_FIELD_BIGINT).IsNull then
      FieldByName(FDN_FIELD_BIGINT).AsInteger := 0;
 
  if FindField(FDN_FIELD_FLOAT) <> nil then
    if FieldByName(FDN_FIELD_FLOAT).IsNull then
      FieldByName(FDN_FIELD_FLOAT).AsFloat := 0;
 
  if FindField(FDN_FIELD_DOUBLE_PRECISION) <> nil then
    if FieldByName(FDN_FIELD_DOUBLE_PRECISION).IsNull then
      FieldByName(FDN_FIELD_DOUBLE_PRECISION).AsCurrency := 0;
 
  if FindField(FDN_FIELD_NUMERIC) <> nil then
    if FieldByName(FDN_FIELD_NUMERIC).IsNull then
      FieldByName(FDN_FIELD_NUMERIC).AsInteger := 0;
 
  if FindField(FDN_FIELD_DECIMAL) <> nil then
    if FieldByName(FDN_FIELD_DECIMAL).IsNull then
      FieldByName(FDN_FIELD_DECIMAL).AsInteger := 0;
 
end; 
 
procedure TFDQueryTypeCode.ValueDefault;
begin 
  inherited; 
  //Inicializar aqui os Campos Obrigatórios
  if FindField(FDN_FIELD_DATE) <> nil then
    FieldByName(FDN_FIELD_DATE).AsDateTime := Date;

  if FindField(FDN_FIELD_TIME) <> nil then
    FieldByName(FDN_FIELD_TIME).AsDateTime := Time;

  if FindField(FDN_FIELD_TIMESTAMP) <> nil then
    FieldByName(FDN_FIELD_TIMESTAMP).AsDateTime := Now;

end;

end.

 


Analysis and System Development - Delphi Programmer - Computer Technician - Developing solutions together

 

Share this post


Link to post
Share on other sites

Na classe acima não tem a opção de modificar as informações depois de criado o componente e carregado os fields, então lembre que precisamos modificar em algum momento sem mexer no que esta pronto...

{---------------------------------------------------------}
{  Autor: Fabrício Melo                                   }
{  e-Mail: [email protected]                               }
{  skype: fabricio_ftm                                    }
{  Desenvolvedor Delphi                                   }
{                                                         }
{  Componente derivado da TFDQuery, exemplo de como       }
{ escrever uma Tabela e configurar seus campos sem a      }
{ necessidade de usar o Fields Editor do DataSet.         }
{ O Trablho esta em Criar um executável que conecte no    }
{ Banco de Dados e depois modifique essa classe para as   }
{ informaçoes da Tabela desejada, linha a linha. ;)       }
{---------------------------------------------------------}
unit UTypeCode;

interface 
 
uses 
  Classes, DB, SysUtils, MaskUtils, Math, DateUtils,
  FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Param,
  FireDAC.Stan.Error, FireDAC.DatS, FireDAC.Phys.Intf,
  FireDAC.DApt.Intf, FireDAC.Stan.Async, FireDAC.DApt,
  FireDAC.Comp.DataSet, FireDAC.Comp.Client;
 
const
  //Identificação da Tabela
  TBL_FIELD = 'DATA_TYPE_CODE';
  //Generators
  GEN_FIELD = 'GEN_FIELD_ID';
  //Campos da Tabela
  FDN_FIELD_SMALLINT = 'FIELD_SMALLINT';
  FDN_FIELD_INTEGER = 'FIELD_INTEGER';
  FDN_FIELD_BIGINT = 'FIELD_BIGINT';
  FDN_FIELD_FLOAT = 'FIELD_FLOAT';
  FDN_FIELD_DOUBLE_PRECISION = 'FIELD_DOUBLE_PRECISION';
  FDN_FIELD_NUMERIC = 'FIELD_NUMERIC';
  FDN_FIELD_DECIMAL = 'FIELD_DECIMAL';
  FDN_FIELD_DATE = 'FIELD_DATE';
  FDN_FIELD_TIME = 'FIELD_TIME';
  FDN_FIELD_TIMESTAMP = 'FIELD_TIMESTAMP';
  FDN_FIELD_CHAR = 'FIELD_CHAR';
  FDN_FIELD_VARCHAR = 'FIELD_VARCHAR';
  FDN_FIELD_BLOB = 'FIELD_BLOB';
  //Título dos Campos da Tabela
  CPT_FIELD_SMALLINT = 'Field Smallint';
  CPT_FIELD_INTEGER = 'Field Integer';
  CPT_FIELD_BIGINT = 'Field Bigint';
  CPT_FIELD_FLOAT = 'Field Float';
  CPT_FIELD_DOUBLE_PRECISION = 'Field Double Precision';
  CPT_FIELD_NUMERIC = 'Field Numeric';
  CPT_FIELD_DECIMAL = 'Field Decimal';
  CPT_FIELD_DATE = 'Field Date';
  CPT_FIELD_TIME = 'Field Time';
  CPT_FIELD_TIMESTAMP = 'Field Timestamp';
  CPT_FIELD_CHAR = 'Field Char';
  CPT_FIELD_VARCHAR = 'Field Varchar';
  CPT_FIELD_BLOB = 'Field Blob';

type

 TFDQueryTypeCode = class(TFDQuery)
  private
    //Flag para não recriar os Fields ao Abrir o proprietário
    FActiveFieldsExecute: Boolean;
    //Armazenar o proprietário
    FOwner: TComponent;
    //Fields
    FFIELD_SMALLINT: TSmallintField;
    FFIELD_INTEGER: TIntegerField;
    FFIELD_BIGINT: TLargeintField;
    FFIELD_FLOAT: TSingleField;
    FFIELD_DOUBLE_PRECISION: TFloatField;
    FFIELD_NUMERIC: TFMTBCDField;
    FFIELD_DECIMAL: TFMTBCDField;
    FFIELD_DATE: TDateField;
    FFIELD_TIME: TTimeField;
    FFIELD_TIMESTAMP: TSQLTimeStampField;
    FFIELD_CHAR: TStringField;
    FFIELD_VARCHAR: TStringField;
    FFIELD_BLOB: TMemoField;

    FActiveFields: Boolean;

    procedure SetActiveFields(const Value: Boolean);

  public
    //Criação do Objeto
    constructor Create(AOwner: TComponent); override;
    //Depois de Criado
    procedure AfterConstruction; override;
    //Criar os campos na Query...
    procedure CreateFields(AOwner: TComponent);
    //Configurar os campos na Query...
    procedure ConfigureFields;
    //Validar as informações dos Campos
    procedure ValidateFields;
    //Valores Padrões dos Campos Obrigatórios
    procedure ValueDefault;
    //Comando SQL da Tabela
    procedure CommandSQL;

  protected
    //Antes de Gravar
    procedure DoBeforePost; override;
    //Antes de Abrir
    procedure DoBeforeOpen; override;
    //Inicializar Campos
    procedure DoAfterInsert; override;
    //Recarregar o Comando SQL Original
    procedure DoAfterClose; override;

  published
    //Criar os Campos
    property ActiveFields: Boolean read FActiveFields write SetActiveFields default False;

 end;

procedure Register;

implementation

{ TFDTaTypeCode }

procedure Register;
begin
  //Paleta de Ferramentas
  RegisterComponents('Minha Paleta Delphi', [ TFDQueryTypeCode ]);
 
end;

constructor TFDQueryTypeCode.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  //Armazenar o Form ou DM Proprietário
  FOwner                         := AOwner;
  //Aplicar as Configurações desejadas na Query
  UpdateOptions.GeneratorName    := GEN_FIELD;
  UpdateOptions.UpdateTableName  := TBL_FIELD;
  UpdateOptions.KeyFields        := FDN_FIELD_SMALLINT;
  UpdateOptions.AssignedValues   := [uvGeneratorName];
  CachedUpdates                  := True;
  AggregatesActive               := True;

  FActiveFieldsExecute           := False;

end; 
 
procedure TFDQueryTypeCode.AfterConstruction;
begin 
  inherited;
  //Carregar o Comando SQL
  CommandSQL; 
 
end; 
 
procedure TFDQueryTypeCode.CommandSQL;
{-- Tabela Exemplo - Firebird
  CREATE TABLE DATA_TYPE_CODE (
    FIELD_SMALLINT          SMALLINT,
    FIELD_INTEGER           INTEGER,
    FIELD_BIGINT            BIGINT,
    FIELD_FLOAT             FLOAT,
    FIELD_DOUBLE_PRECISION  DOUBLE PRECISION,
    FIELD_NUMERIC           NUMERIC(16,8),
    FIELD_DECIMAL           DECIMAL(18,6),
    FIELD_DATE              DATE,
    FIELD_TIME              TIME,
    FIELD_TIMESTAMP         TIMESTAMP,
    FIELD_CHAR              CHAR(1),
    FIELD_VARCHAR           VARCHAR(100),
    FIELD_BLOB              BLOB SUB_TYPE 1 SEGMENT SIZE 1024);
}
begin 
  inherited; 

  SQL.Add('SELECT '); 
  SQL.Add('       FIELD.FIELD_SMALLINT ');
  SQL.Add('      ,FIELD.FIELD_INTEGER ');
  SQL.Add('      ,FIELD.FIELD_BIGINT ');
  SQL.Add('      ,FIELD.FIELD_FLOAT ');
  SQL.Add('      ,FIELD.FIELD_DOUBLE_PRECISION ');
  SQL.Add('      ,FIELD.FIELD_NUMERIC ');
  SQL.Add('      ,FIELD.FIELD_DECIMAL ');
  SQL.Add('      ,FIELD.FIELD_DATE ');
  SQL.Add('      ,FIELD.FIELD_TIME ');
  SQL.Add('      ,FIELD.FIELD_TIMESTAMP ');
  SQL.Add('      ,FIELD.FIELD_CHAR ');
  SQL.Add('      ,FIELD.FIELD_VARCHAR ');
  SQL.Add('      ,FIELD.FIELD_BLOB ');
  SQL.Add('  FROM DATA_TYPE_CODE FIELD ');
  SQL.Add(' WHERE (1=1) ');

  {Para usar no form:
    Query.Close;
    Query.SQL.Add(' AND FIELD_SMALLINT = 1982 ');
    Query.Open;
  }
end; 

procedure TFDQueryTypeCode.SetActiveFields(const Value: Boolean);
begin

  FActiveFields := Value;
  //Flag pra controlar no Create do Proprietário
  if FActiveFieldsExecute then
    if FOwner <> nil then
      //Criando os Campos no DataSet em Desenvolvimento
      if ( csDesigning in Self.ComponentState ) then
      begin
        //Remove do DataSet e do Proprietário
        if Self.FieldCount > 0 then
          Self.Fields.Clear;
        //Criar os Campos Novamente no DataSet e no Proprietário
        if FActiveFields then
          CreateFields(FOwner);
      end;

  FActiveFieldsExecute := True;

end;

procedure TFDQueryTypeCode.CreateFields(AOwner: TComponent);
begin
  //Tipos Comuns do Firebird
  FFIELD_SMALLINT             := TSmallintField.Create(AOwner);
  FFIELD_SMALLINT.FieldKind   := fkData;
  FFIELD_SMALLINT.Origin      := FDN_FIELD_SMALLINT;
  FFIELD_SMALLINT.fieldName   := FDN_FIELD_SMALLINT;
  FFIELD_SMALLINT.Name        := Self.Name + FDN_FIELD_SMALLINT;
  FFIELD_SMALLINT.Index       := Self.FieldCount;
  FFIELD_SMALLINT.DataSet     := Self;

  FFIELD_INTEGER              := TIntegerField.Create(AOwner);
  FFIELD_INTEGER.FieldKind    := fkData;
  FFIELD_INTEGER.Origin       := FDN_FIELD_INTEGER;
  FFIELD_INTEGER.fieldName    := FDN_FIELD_INTEGER;
  FFIELD_INTEGER.Name         := Self.Name + FDN_FIELD_INTEGER;
  FFIELD_INTEGER.Index        := Self.FieldCount;
  FFIELD_INTEGER.DataSet      := Self;

  FFIELD_BIGINT                 := TLargeintField.Create(AOwner);
  FFIELD_BIGINT.FieldKind       := fkData;
  FFIELD_BIGINT.Origin          := FDN_FIELD_BIGINT;
  FFIELD_BIGINT.fieldName       := FDN_FIELD_BIGINT;
  FFIELD_BIGINT.DisplayLabel    := CPT_FIELD_BIGINT;
  FFIELD_BIGINT.Name            := Self.Name + FDN_FIELD_BIGINT;
  FFIELD_BIGINT.Index           := Self.FieldCount;
  FFIELD_BIGINT.DataSet         := Self;

  FFIELD_FLOAT              := TSingleField.Create(AOwner);
  FFIELD_FLOAT.FieldKind    := fkData;
  FFIELD_FLOAT.Origin       := FDN_FIELD_FLOAT;
  FFIELD_FLOAT.fieldName    := FDN_FIELD_FLOAT;
  FFIELD_FLOAT.Name         := Self.Name + FDN_FIELD_FLOAT;
  FFIELD_FLOAT.Index        := Self.FieldCount;
  FFIELD_FLOAT.DataSet      := Self;

  FFIELD_DOUBLE_PRECISION             := TFloatField.Create(AOwner);
  FFIELD_DOUBLE_PRECISION.FieldKind   := fkData;
  FFIELD_DOUBLE_PRECISION.Origin      := FDN_FIELD_DOUBLE_PRECISION;
  FFIELD_DOUBLE_PRECISION.fieldName   := FDN_FIELD_DOUBLE_PRECISION;
  FFIELD_DOUBLE_PRECISION.Name        := Self.Name + FDN_FIELD_DOUBLE_PRECISION;
  FFIELD_DOUBLE_PRECISION.Index       := Self.FieldCount;
  FFIELD_DOUBLE_PRECISION.DataSet     := Self;

  FFIELD_NUMERIC                := TFMTBCDField.Create(AOwner);
  FFIELD_NUMERIC.FieldKind      := fkData;
  FFIELD_NUMERIC.Origin         := FDN_FIELD_NUMERIC;
  FFIELD_NUMERIC.fieldName      := FDN_FIELD_NUMERIC;
  FFIELD_NUMERIC.DisplayLabel   := CPT_FIELD_NUMERIC;
  FFIELD_NUMERIC.Name           := Self.Name + FDN_FIELD_NUMERIC;
  FFIELD_NUMERIC.Index          := Self.FieldCount;
  FFIELD_NUMERIC.DataSet        := Self;

  FFIELD_DECIMAL              := TFMTBCDField.Create(AOwner);
  FFIELD_DECIMAL.FieldKind    := fkData;
  FFIELD_DECIMAL.Origin       := FDN_FIELD_DECIMAL;
  FFIELD_DECIMAL.fieldName    := FDN_FIELD_DECIMAL;
  FFIELD_DECIMAL.Name         := Self.Name + FDN_FIELD_DECIMAL;
  FFIELD_DECIMAL.Index        := Self.FieldCount;
  FFIELD_DECIMAL.DataSet      := Self;

  FFIELD_DATE             := TDateField.Create(AOwner);
  FFIELD_DATE.FieldKind   := fkData;
  FFIELD_DATE.Origin      := FDN_FIELD_DATE;
  FFIELD_DATE.fieldName   := FDN_FIELD_DATE;
  FFIELD_DATE.Name        := Self.Name + FDN_FIELD_DATE;
  FFIELD_DATE.Index       := Self.FieldCount;
  FFIELD_DATE.DataSet     := Self;

  FFIELD_TIME             := TTimeField.Create(AOwner);
  FFIELD_TIME.FieldKind   := fkData;
  FFIELD_TIME.Origin      := FDN_FIELD_TIME;
  FFIELD_TIME.fieldName   := FDN_FIELD_TIME;
  FFIELD_TIME.Name        := Self.Name + FDN_FIELD_TIME;
  FFIELD_TIME.Index       := Self.FieldCount;
  FFIELD_TIME.DataSet     := Self;

  FFIELD_TIMESTAMP              := TSQLTimeStampField.Create(AOwner);
  FFIELD_TIMESTAMP.FieldKind    := fkData;
  FFIELD_TIMESTAMP.Origin       := FDN_FIELD_TIMESTAMP;
  FFIELD_TIMESTAMP.fieldName    := FDN_FIELD_TIMESTAMP;
  FFIELD_TIMESTAMP.Name         := Self.Name + FDN_FIELD_TIMESTAMP;
  FFIELD_TIMESTAMP.Index        := Self.FieldCount;
  FFIELD_TIMESTAMP.DataSet      := Self;

  FFIELD_CHAR             := TStringField.Create(AOwner);
  FFIELD_CHAR.FieldKind   := fkData;
  FFIELD_CHAR.Origin      := FDN_FIELD_CHAR;
  FFIELD_CHAR.fieldName   := FDN_FIELD_CHAR;
  FFIELD_CHAR.Name        := Self.Name + FDN_FIELD_CHAR;
  FFIELD_CHAR.Index       := Self.FieldCount;
  FFIELD_CHAR.DataSet     := Self;

  FFIELD_VARCHAR              := TStringField.Create(AOwner);
  FFIELD_VARCHAR.FieldKind    := fkData;
  FFIELD_VARCHAR.Origin       := FDN_FIELD_VARCHAR;
  FFIELD_VARCHAR.fieldName    := FDN_FIELD_VARCHAR;
  FFIELD_VARCHAR.Name         := Self.Name + FDN_FIELD_VARCHAR;
  FFIELD_VARCHAR.Index        := Self.FieldCount;
  FFIELD_VARCHAR.DataSet      := Self;

  FFIELD_BLOB                := TMemoField.Create(AOwner);
  FFIELD_BLOB.FieldKind      := fkData;
  FFIELD_BLOB.Origin         := FDN_FIELD_BLOB;
  FFIELD_BLOB.fieldName      := FDN_FIELD_BLOB;
  FFIELD_BLOB.Name           := Self.Name + FDN_FIELD_BLOB;
  FFIELD_BLOB.Index          := Self.FieldCount;
  FFIELD_BLOB.DataSet        := Self;

  ConfigureFields;

end;

procedure TFDQueryTypeCode.ConfigureFields;
begin
  //Configurações específicas para cada Campo
  if FindField(FDN_FIELD_SMALLINT) <> nil then
  begin
    With TSmallintField(FieldByName(FDN_FIELD_SMALLINT)) do
    begin
      DisplayLabel  := CPT_FIELD_SMALLINT;
      DisplayWidth  := 24;
      ProviderFlags := [pfInUpdate];
      Required      := False;
      ReadOnly      := False;
      Visible       := True;
    end;
  end;

  if FindField(FDN_FIELD_INTEGER) <> nil then
  begin
    With TIntegerField(FieldByName(FDN_FIELD_INTEGER)) do
    begin
      DisplayLabel  := CPT_FIELD_INTEGER;
      DisplayWidth  := 23;
      ProviderFlags := [pfInUpdate];
      Required      := False;
      ReadOnly      := False;
      Visible       := True;
    end;
  end;

  if FindField(FDN_FIELD_BIGINT) <> nil then
  begin
    With TLargeintField(FieldByName(FDN_FIELD_BIGINT)) do
    begin
      DisplayLabel   := CPT_FIELD_BIGINT;
      DisplayWidth   := 22;
      ProviderFlags  := [pfInUpdate, pfInKey, pfInWhere];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_FLOAT) <> nil then
  begin
    With TSingleField(FieldByName(FDN_FIELD_FLOAT)) do
    begin
      DisplayLabel    := CPT_FIELD_FLOAT;
      DisplayWidth    := 21;
      //Size          := 4;
      Precision       := 7;
      ProviderFlags   := [pfInUpdate];
      Required        := False;
      ReadOnly        := False;
      Visible         := True;
    end;
  end;

  if FindField(FDN_FIELD_DOUBLE_PRECISION) <> nil then
  begin
    With TFloatField(FieldByName(FDN_FIELD_DOUBLE_PRECISION)) do
    begin
      DisplayLabel    := CPT_FIELD_DOUBLE_PRECISION;
      DisplayWidth    := 32;
      //Size            := 8;
      Precision       := 15;
      ProviderFlags   := [pfInUpdate];
      Required        := False;
      ReadOnly        := False;
      Visible         := True;
    end;
  end;

  if FindField(FDN_FIELD_NUMERIC) <> nil then
  begin
    With TFMTBCDField(FieldByName(FDN_FIELD_NUMERIC)) do
    begin
      DisplayLabel    := CPT_FIELD_NUMERIC;
      DisplayWidth    := 23;
      //Size            := 8;
      Precision       := 18;
      ProviderFlags   := [pfInUpdate];
      Required        := False;
      ReadOnly        := False;
      Visible         := True;
    end;
  end;

  if FindField(FDN_FIELD_DECIMAL) <> nil then
  begin
    With TFMTBCDField(FieldByName(FDN_FIELD_DECIMAL)) do
    begin
      DisplayLabel    := CPT_FIELD_DECIMAL;
      DisplayWidth    := 23;
      //Size            := 6;
      Precision       := 18;
      ProviderFlags   := [pfInUpdate];
      Required        := False;
      ReadOnly        := False;
      Visible         := True;
    end;
  end;

  if FindField(FDN_FIELD_DATE) <> nil then
  begin
    With TDateField(FieldByName(FDN_FIELD_DATE)) do
    begin
      DisplayLabel   := CPT_FIELD_DATE;
      DisplayWidth   := 20;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_TIME) <> nil then
  begin
    With TTimeField(FieldByName(FDN_FIELD_TIME)) do
    begin
      DisplayLabel   := CPT_FIELD_TIME;
      DisplayWidth   := 20;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_TIMESTAMP) <> nil then
  begin
    With TSQLTimeStampField(FieldByName(FDN_FIELD_TIMESTAMP)) do
    begin
      DisplayLabel   := CPT_FIELD_TIMESTAMP;
      DisplayWidth   := 25;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_CHAR) <> nil then
  begin
    With TStringField(FieldByName(FDN_FIELD_CHAR)) do
    begin
      DisplayLabel   := CPT_FIELD_CHAR;
      DisplayWidth   := 20;
      Size           := 1;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_VARCHAR) <> nil then
  begin
    With TStringField(FieldByName(FDN_FIELD_VARCHAR)) do
    begin
      DisplayLabel   := CPT_FIELD_VARCHAR;
      DisplayWidth   := 40;
      Size           := 100;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := True;
    end;
  end;

  if FindField(FDN_FIELD_BLOB) <> nil then
  begin
    With TMemoField(FieldByName(FDN_FIELD_BLOB)) do
    begin
      DisplayLabel   := CPT_FIELD_BLOB;
      DisplayWidth   := 20;
      ProviderFlags  := [pfInUpdate];
      Required       := False;
      ReadOnly       := False;
      Visible        := False;
    end;
  end;

end;

procedure TFDQueryTypeCode.DoAfterClose;
begin
  inherited;
  //Recarregar o Comando SQL Original
  CommandSQL;

end;

procedure TFDQueryTypeCode.DoAfterInsert;
begin
  inherited;
  //Definir os Valores Padrões dos Campos Obrigatórios
  ValueDefault;

end;

procedure TFDQueryTypeCode.DoBeforeOpen;
begin
  inherited;
  //Configurar os Campos
  ConfigureFields;

end;

procedure TFDQueryTypeCode.DoBeforePost;
begin
  inherited;
  //Validar os Campos Obrigatórios
  ValidateFields;

end;

procedure TFDQueryTypeCode.ValidateFields;
begin 
  inherited; 
  //Testar aqui os Valores Obrigatórios
  if FindField(FDN_FIELD_SMALLINT) <> nil then
    if FieldByName(FDN_FIELD_SMALLINT).IsNull then
      FieldByName(FDN_FIELD_SMALLINT).AsInteger  := 0;
 
  if FindField(FDN_FIELD_INTEGER) <> nil then
    if FieldByName(FDN_FIELD_INTEGER).IsNull then
      FieldByName(FDN_FIELD_INTEGER).AsInteger := 0;
 
  if FindField(FDN_FIELD_BIGINT) <> nil then
    if FieldByName(FDN_FIELD_BIGINT).IsNull then
      FieldByName(FDN_FIELD_BIGINT).AsInteger := 0;
 
  if FindField(FDN_FIELD_FLOAT) <> nil then
    if FieldByName(FDN_FIELD_FLOAT).IsNull then
      FieldByName(FDN_FIELD_FLOAT).AsFloat := 0;
 
  if FindField(FDN_FIELD_DOUBLE_PRECISION) <> nil then
    if FieldByName(FDN_FIELD_DOUBLE_PRECISION).IsNull then
      FieldByName(FDN_FIELD_DOUBLE_PRECISION).AsCurrency := 0;
 
  if FindField(FDN_FIELD_NUMERIC) <> nil then
    if FieldByName(FDN_FIELD_NUMERIC).IsNull then
      FieldByName(FDN_FIELD_NUMERIC).AsInteger := 0;

  if FindField(FDN_FIELD_DECIMAL) <> nil then
    if FieldByName(FDN_FIELD_DECIMAL).IsNull then
      FieldByName(FDN_FIELD_DECIMAL).AsInteger := 0;
 
end; 
 
procedure TFDQueryTypeCode.ValueDefault;
begin 
  inherited; 
  //Inicializar aqui os Campos Obrigatórios
  if FindField(FDN_FIELD_DATE) <> nil then
    FieldByName(FDN_FIELD_DATE).AsDateTime := Date;

  if FindField(FDN_FIELD_TIME) <> nil then
    FieldByName(FDN_FIELD_TIME).AsDateTime := Time;

  if FindField(FDN_FIELD_TIMESTAMP) <> nil then
    FieldByName(FDN_FIELD_TIMESTAMP).AsDateTime := Now;

end;

end.

 


Analysis and System Development - Delphi Programmer - Computer Technician - Developing solutions together

 

Share this post


Link to post
Share on other sites

@bilogyn

Obrigado por compartilhar, mas evite colar trechos grandes de código no corpo da mensagem.

Use a opção de anexar arquivos.

  • Like 2
  • Thanks 1

Equipe ACBr BigWings
Ajude o Projeto ACBr crescer - Assine o SAC

Projeto ACBr

 

 

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...