data fields Criando os Fields em Designing Time

Fabrício Melo · 6 Maio, 2019

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

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

Editado 6 Maio, 2019 por bilogyn
Incluir SQL da Tabela

EMBarbosa · 6 Maio, 2019

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

5 horas atrás, bilogyn disse:

estou com um errinho chato...

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

Fabrício Melo · 6 Maio, 2019

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

Fabrício Melo · 9 Maio, 2019

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

Fabrício Melo · 9 Maio, 2019

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.

Fabrício Melo · 9 Maio, 2019

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.

BigWings · 9 Maio, 2019

@bilogyn

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

Use a opção de anexar arquivos.

Entrar

Sobre nós...

data fields Criando os Fields em Designing Time

Recommended Posts

Fabrício Melo

EMBarbosa

Fabrício Melo

Fabrício Melo

Fabrício Melo

Fabrício Melo

BigWings

Crie uma conta ou entre para comentar

Criar uma conta

Entrar

Links Rápidos

Links Rápidos

ACBr Pro

SOBRE

Sobre nós...

Informação Importante

	BigWings Ajude o Projeto ACBr crescer - Assine o SAC