ORMBr - Conhecendo o Outro Lado

Seja bem vindo, e ótima leitura. 

O combustível do ORMBr sempre será as classes modelos, e para que tenhamos alto desempenho, precisamos conhecer o que adicionar a esses modelos para que tenhamos sincronização com nosso banco de dados.
Apresento aqui para vocês as correspondências entre os tipos usados pelo ORMBr e os tipos criados no seu banco dados já existente.

procedure TFieldTypeRegister.GetFieldTypeDefinition(AColumn: TColumnMIK);
begin
  case AColumn.FieldType of
    ftByte, ftShortint, ftSmallint, ftWord:
    begin
      AColumn.TypeName := 'SMALLINT';
    end;
    ftInteger, ftLongWord:
    begin
      if      FDriverName = dnMSSQL then AColumn.TypeName := 'INT'
      else if FDriverName = dnMySQL then AColumn.TypeName := 'INT'
      else                               AColumn.TypeName := 'INTEGER';
    end;
    ftLargeint:      AColumn.TypeName := 'NUMERIC(%l)';
    ftString:        AColumn.TypeName := 'VARCHAR(%l)';
    ftWideString:    AColumn.TypeName := 'NVARCHAR(%l)';
    ftFixedChar:     AColumn.TypeName := 'CHAR(%l)';
    ftFixedWideChar: AColumn.TypeName := 'NCHAR(%l)';
    ftDate:          AColumn.TypeName := 'DATE';
    ftTime:          AColumn.TypeName := 'TIME';
    ftDateTime:      AColumn.TypeName := 'DATETIME';
    ftTimeStamp:     AColumn.TypeName := 'TIMESTAMP';
    ftFloat:
    begin
      if      FDriverName = dnMSSQL      then AColumn.TypeName := 'FLOAT'
      else if FDriverName = dnMySQL      then AColumn.TypeName := 'FLOAT'
      else if FDriverName = dnPostgreSQL then AColumn.TypeName := 'NUMERIC(%p,%s)'
      else                                    AColumn.TypeName := 'DECIMAL(%p,%s)';
    end;
    ftSingle:        AColumn.TypeName := 'REAL';
    ftExtended:
    begin
      if      FDriverName = dnMSSQL then AColumn.TypeName := 'DOUBLE'
      else if FDriverName = dnMySQL then AColumn.TypeName := 'DOUBLE'
      else                               AColumn.TypeName := 'DOUBLE PRECISION';
    end;
    ftCurrency:
    begin
      if      FDriverName = dnMSSQL      then AColumn.TypeName := 'MONEY'
      else if FDriverName = dnMySQL      then AColumn.TypeName := 'DECIMAL(%p,%s)'
      else                                    AColumn.TypeName := 'NUMERIC(%p,%s)';
    end;
    ftBCD, ftFMTBcd:
    begin
      if      FDriverName = dnPostgreSQL then AColumn.TypeName := 'MONEY'
      else if FDriverName = dnMSSQL      then AColumn.TypeName := 'MONEY'
      else                                    AColumn.TypeName := 'DECIMAL(%p,%s)';
    end;
    ftMemo:
    begin
      if FDriverName = dnFirebird then AColumn.TypeName := 'BLOB SUB_TYPE TEXT'
      else                             AColumn.TypeName := 'LOGBLOB';
    end;
    ftWideMemo, ftBlob:
    begin
      if FDriverName = dnFirebird then AColumn.TypeName := 'BLOB SUB_TYPE TEXT'
      else                             AColumn.TypeName := 'TEXT';
    end;
  else
    raise Exception.Create('Tipo da coluna definida, não existe no ORMBr.');
  end;
end;

Dependendo do tipo definido na propriedade da sua classe modelo, o ORMBr irá identificar o tipo do campos no seu banco de dados, exemplo, se definirmos a propriedade do tipo ftWideMemo ou ftBlob, o ORMBr irá identificar que no seu banco dados a coluna é BLOB SUB_TYPE TEXT no caso o banco seja Firebird caso contrário irá identificar como TEXT para os demais bancos. 
Vemos aqui que o tipo definido no ORMBr, poderá se comportar diferente dependendo do banco usado, então pessoal atenção a esse código, qualquer situação adversa me comunique, pois acredito que não pensei em todas as situações e tipos.

Continue...

ORMBr - Ao Usar, Perdemos em Performance?

Muitos pensam que usar o ORMBr perderia performance, gente o ORMBr trabalho com duas linhas de frente para vocês.

1a ) Ele fará de forma SUPER simples TUDO o que você teria que fazer manual, como SELECT, Adicionar TFields e configurar um a um, gerenciar abertura de subtabelas em mestre-detalhe, TUDO isso passa a ser automatizado.

2a) Ele fará de forma SURPER simples tudo o que os componentes DataSet já faz, pois o que você achar que um TFDQuery faz, quando você alimenta os TFields dele, em seguida dispara um Post e um ApplyUpdate?

Simplesmente montam o comando SQL internamente e mandam para o banco, é exatamente o que o ORMBr faz também.

Se é assim que funciona, como podemos perder performance ?

Continue...

ORMBr - TFields em Runtime

Em 2006 palestrei na Borcon e minha palestra foi sobre Multicamadas com Multibancos, na época só conseguia aplicar multibancos através de uma técnica criada por mim, que foi a criação de TFields em runtime. A Criação de TFields em Designer além de ser um CAUS para manutenções futuras em projetos, me trazia um problema de incompatibilidade entre os tipos de TFields que o Delphi criava para bancos diferentes, exemplo o tipo data, e té hoje isso acontece, só com a aquisição do FireDAC passou a ter um recurso nativo de mapeamento de tipos para os TFields, criados em designer, recurso esse que tem a mesma finalidade da que criei a mais de 10 anos atrás, resolver incompatibilidade de tipos em bancos diferentes. Porém a técnica usada por mim, elimina ainda outras situações como a manutenções futuras no projeto, mas que manutenções são essas que você diz Isaque? Se criar um campo no banco VARCHAR(10) em designer será criado um TField do tipo TStringField de size 10, esse TField pode ter sido adicionados em vários pontos do meu projeto, tela de cadastro, consultas etc..., se algum dia eu precisar mudar o tamanho desse campo no banco para 15, terá que lembrar todos os pontos do meu sistema que adicionou o TField para esse campo, caso contrário, mesmo no banco ele tendo tamanho 15, o delphi irá limitar a digitação em 10, esse é um dos exemplos simples, existem outras. Com a técnica de criar TFields em runtime, esse problema é TOTALMENTE resolvido, pois o TField será criado com base no campo atual do banco, sendo criado sempre de forma atual. Com o nascimento do ORMBr, isso ficou bem mais simples, pois além das grandes vantagens em agilidade que o ORMBr traz, ele trata, cria e configura cada TField em runtime, isso tudo com base no modelo, vejamos como podemos definir isso no modelo do ORMBr:

[Column('price', ftFloat, 18, 3)]
[Dictionary('Preço Unitário','Mensagem de validação','0','#,###,##0.00','',
taRightJustify)]
property price: Double Index 4 read Fprice write Fprice;

Vejamos os atributos:
Column : Informo o nome do campo, o tipo que quero e tamanho, pronto o ORMBr faz o resto
Dictionary : Informo o DisplayLabel, Mensagem de validação, Valor Default, DisplayFormat, EditMask, e o alinhamento.

Continue...

Técnica Para Ajudar no Dia Dia

Seja bem vindo a mais esse artigo, e boa leitura. 

Desenvolvedores, vive seu dia dia escrevendo código, mas claro o foco sempre na lógica e na melhor forma de fazer, e na maioria das vezes tem que recorrer a uma ajudinha, seja ela no help da linguagem ou no Google, para lembrar da sintaxe correta de um comando, procedure ou função. O sábio não é aquele que sabe e faz tudo, mas aquele que lembra que existe, e tem a coragem de procurar, e se não existe, a coragem de estudar para conseguir aprender e fazer. 

Existem situações das quais ao escrever um código, nos deparamos com a dúvida e o esquecimento de até mesmo o que nós criamos, exemplo o nome de uma coluna no banco de dados, e é nessa situação que vou passar uma dica de um possível recurso para ajudar no seu dia dia.
Em um ponto do código, precisa escrever um comando SQL, do qual vai selecionar varias colunas de uma determinada tabela do banco de dados, então faz:

'SELECT TableName.Codigo, TableName.Nome, TableName.Endereco FROM TableName'

Simples, mas nem toda vez irá lembrar de todos os nomes e de todas as tabelas do banco de dados, dai tende a parar, e ir olhar no banco qual o nome correto para a determinada coluna, e quando esse banco for dados manutenção por mais de uma pessoa, só tende piorando. 

Você já pensou em uma técnica para te ajudar no dia dia nesse caso? Não, então vou te dar uma dica, segue abaixo:

...
Type
  TMyTable = class
  private
    class function GetTableName: string;
    class function GetCodigo: string;
    class function GetNome: string;
    class function GetEndereco: string;
  public
    class property TableName: string read GetTableName;
    class property Codigo: string read GetCodigo;
    class property Nome: string read GetNome;
    class property Endereco: string read GetEndereco;
  end;

implementation

class function TMyTable.GetTableName: string;
begin
  Result := 'TableName';
end;  

class function TMyTable.GetCodigo: string;
begin
  Result := 'TableName.Codigo';
end;  

class function TMyTable.GetNome: string;
begin
  Result := 'TableName.Nome';
end;  

class function TMyTable.GetEndereco: string;
begin
  Result := 'TableName.Endereco';
end;  

end.

Usando a class: 'SELECT ' + TMyTable.Codigo + ',' +
                            TMyTable.Nome + ',' +
                            TMyTable.Endereco + 
                ' FROM ' + TMyTable.TableName;

Qual a vantagem? como criamos a class, nela estará todas as propriedades com os nomes dos campos da tabela, então ao precisarmos podemos pedir a ajuda do Delphi ao recurso "Code Completion" e ele mostrará todos os possíveis nomes existentes na class, facilitando assim nossa busca.

Continue...

ORMBr - Gerenciamento DB (Interbase e PostgreSQL)

Seja bem vindo a mais esse artigo, e boa leitura. 

Lancei hoje os drivers para gerenciamento de banco de dados para Interbase e PostgreSQL, já estão disponíveis no repositório, dúvidas, perguntas, bugs, sugestões, gentileza podem ser postados no Fórum http://www.ormbr.com.br/forum e os fontes podem ser baixados no site http://www.ormbr.com.br no menu Download. 

Quero aqui deixar meus agradecimentos ao Juliomar Marchetti, mais informações sobre ele podes ser encontradas no seu blog http://www.juliomarmarchetti.com.br, ele foi quem teve a ideia e colocou mão na massa para aproximar os interessados no projeto ORMBr ao seu autor, ele criou um Canal e um Grupo no Telegram o link para o Canal https://telegram.me/canalormbr e para o Grupo https://telegram.me/ormbr, convido a todos interessados a participar. 

O ORMBr já da suporta a gerenciamento a banco de dados com base no modelo criado, até o momento já temos os drivers para os bancos: MSSQL, MySQL, Firebird, Interbase, SQLite e PostgreSQL, o recurso oferecido até o momento são criação de tabelas com sua estrutura completa e com todos os recursos de coluna como TIPOS, NOT NULL, DEFAULT, juntamente com recursos como criação de PrimaryKey, ForeignKey, Indexe e Check, isso funcional e testado, e não acabou por ai, tem ainda o recurso de ADD COLUMN nova a estrutura, caso a coluna seja adicionado ao modelo e ser rodado o recurso de verificação de metadata, segue abaixo um exemplo de como usar o recurso:

procedure TForm1.Button1Click(Sender: TObject);
var
  oManager: TDatabaseAbstract;
  oConnection: IDBConnection;
begin
  // Instância da class de conexão via FireDAC, segundo parametro
  // o Driver de qual Banco usado
  oConnection := TFactoryFireDAC.Create(FDConnection1, dnPostgreSQL);

  oManager := TDatabaseManager.Create(oConnection);
  oManager.BuildDatabase;

  for cDDL in oManager.GetCommandList do
      Memo1.Lines.Add(cDDL.Command);

  oManager.Free;
end;

Nota: Até o momento a criação do banco de dados, tem que ser feito manualmente, estou estudando a implementação desse recurso via ORMBr, após a criação do banco vazio, só configura-lo ao engine de conexão que no ORMBr podem ser: FireDAC, DBExpress ou Zeos até agora, em seguida criar a fabrica de conexão conforme engine de preferência e rodas a atualização conforme modelo criado. Abaixo um exemplo de um modelo bem completo para estudo e teste:

unit ormbr.model.person;

interface

uses
  Classes,
  DB,
  /// orm
  ormbr.mapping.attributes,
  ormbr.types.mapping,
  ormbr.mapping.register;

type
  [Entity]
  [Table('Person','Tabela de pessoas')]
  [PrimaryKey('Id', NoSort, False, 'Chave primária')]
  [Indexe('IDX_FirstName','FirstName', NoSort, True, 'Indexe por nome')]
  [Check('CHK_Age', 'Age >= 0')]
  TPerson = class
  private
    { Private declarations }
    FId: Integer;
    FFirstName: string;
    FLastName: string;
    FAge: Integer;
    FSalary: Double;
  public
    { Public declarations }
    [Restrictions([NoUpdate, NotNull])]
    [Column('Id', ftInteger)]
    [Dictionary('Código ID','Mensagem de validação','0','','',taCenter)]
    property Id: Integer Index 0 read FId write FId;

    [Restrictions([NotNull])]
    [Column('FirstName', ftString, 40)]
    [Dictionary('Primeiro nome','Mensagem de validação','','','',taLeftJustify)]
    property FirstName: String Index 1 read FFirstName write FFirstName;

    [Column('LastName', ftString, 30)]
    [Dictionary('Último nome','Mensagem de validação','','','',taLeftJustify)]
    property LastName: String Index 2 read FLastName write FLastName;

    [Restrictions([NotNull])]
    [Column('Age', ftInteger)]
    [Dictionary('Idade','Mensagem de validação','0','','',taCenter)]
    property Age: Integer Index 3 read FAge write FAge;

    [Restrictions([NotNull])]
    [Column('Salary', ftCurrency, 18, 3)]
    [Dictionary('Preço','Mensagem de validação','0','','',taRightJustify)]
    property Salary: Double Index 4 read FSalary write FSalary;
  end;

implementation

initialization
  TRegisterClass.RegisterEntity(TPerson);

end.

Continue...

ORMBr - Gerenciamento DB (Firebird e MySQL)

Seja bem vindo a mais esse artigo, e boa leitura. Como prometido, subi hoje os drivers para gerenciamento de banco de dados para Firebird e MySQL, próximo passo será PostgreSQL, os demais estão disponíveis no repositório, dúvidas, perguntas, bugs, sugestões, gentileza postarem no Fórum, conto com a ajuda de todos para fazermos juntos do ORMBr, um grande e respeitado ORM Framework. Baixe o ORMBr Framework

Continue...

ORMBr - Gerenciamento DB (MSSql e SQLite)

Seja bem vindo a mais esse artigo, e boa leitura.

Hoje quero passar para você, que o ORMBr agora conta com a 1a versão da camada de gerenciamento de banco de dados, após grande esforço e trabalho implementei o recurso para os bancos SQLite e SQLServer, logo logo sairá para Firebird e MySQL, essa versão que já está disponível no repositório você pode baixar pelo link www.ormbr.com.br menu Download. 

Nessa novidade temos a criação completa de tabela, PrimaryKey, ForeignKeys, Indexes e Checks, e ainda a adição de novos campos caso adicionados no modelo, e não exista no banco. Tem bastante recurso a ser feito, mas um passo a cada dia chegaremos ao nosso destino desejado, que é o gerenciamento total ao banco, pretendo ir até onde for possível, ir além de alguns ORMs do mercado como gerenciamento de Views, Triggers (esses já bem avançados) e quem sabe até Store de Procedures, mesmo que cada banco tendo sua sintaxe especifica, trabalho dará, mas acredito que é possível sim, por que não? 

Tenho uma frase que marcou muito minha vida de Albert Einstein "A mente que se abre a uma nova ideia jamais voltará ao seu tamanho original", então quero que você pense nessa frase, e abra sua mente para entender os benefícios que o ORMBr pode trazer para sua vida, no que diz respeito a desenvolvimento, agilizando, dando confiabilidade e economizando em algumas dezenas e quem sabe centenas de linhas. O ORMBr é puro delphi, você não deve ter medo usa-lo, no inicio por seguir padrões de projetos, ele pode parecer complexo, mas acreditem, não é, e um ditado cabe bem nessa afirmação, "quem vê cara não vê coração", o ORMBr tem seu código extremamente simples, ele usa Dataset nativo do Delphi, ele faz o mesmo que você faz no seu código já existente do seu dia ia, mas de forma extremamente mais simples, e econômico, pois esse mesmo código servirá para todo o seu projeto, o que é preciso, é de dedicação para testa-lo, debuga-lo e entender seu funcionamento, e dai terá a confiança do que estou falando. 

Abaixo um exemplo de um modelo bem completo, que servirá como base para o ORMBr para gerenciamento do banco de dados, nele teremos a criação de uma tabela completa com todos os atributos das colunas, uma PrimaryKey, um Indexe, um Check, esse mesmo modelo ainda servirá para definição dos TFields criados no Dataset usado, isso tudo feito automaticamente para ORMBr, de forma simples e eficaz, veja abaixo:

unit ormbr.model.person;

interface

uses
  Classes,
  DB,
  /// orm
  ormbr.mapping.attributes,
  ormbr.types.mapping,
  ormbr.mapping.register;

type
  [Entity]
  [Table('Person','Tabela de pessoas')]
  [PrimaryKey('Id', NoSort, False, 'Chave primária')]
  [Indexe('IDX_FirstName','FirstNome', NoSort, True, 'Indexe por nome')]
  [Check('CHK_Age', 'Age >= 0')]
  TPerson = class
  private
    { Private declarations }
    FId: Integer;
    FFirstNome: string;
    FLastNome: string;
    FAge: Integer;
    FSalary: Double;
  public
    { Public declarations }
    [Restrictions([NoUpdate, NotNull])]
    [Column('Id', ftInteger)]
    [Dictionary('Código ID','Mensagem de validação','0','','',taCenter)]
    property Id: Integer Index 0 read FId write FId;

    [Restrictions([NotNull])]
    [Column('FirstNome', ftString, 40)]
    [Dictionary('Primeiro nome','Mensagem de validação','','','',taLeftJustify)]
    property FirstNome: String Index 1 read FFirstNome write FFirstNome;

    [Column('LastNome', ftString, 30)]
    [Dictionary('Último nome','Mensagem de validação','','','',taLeftJustify)]
    property LastNome: String Index 2 read FLastNome write FLastNome;

    [Restrictions([NotNull])]
    [Column('Age', ftInteger)]
    [Dictionary('Idade','Mensagem de validação','0','','',taCenter)]
    property Age: Integer Index 3 read FAge write FAge;

    [Restrictions([NotNull])]
    [Column('Salary', ftFloat, 18, 3)]
    [Dictionary('Preço','Mensagem de validação','0','','',taRightJustify)]
    property Salary: Double Index 4 read FSalary write FSalary;
  end;

implementation

initialization
  TRegisterClass.RegisterEntity(TPerson);

end.

No próximo artigo, vou falar para você tudo sobre os atributos do ORMBr, quais seus paramtros e para que serve cada um deles, verá que o ORMBr terá total controle com base no modelo criado, te proporcionado total funcionalidades de forma simples para ser usado.

Continue...

ORMBr - Criando Lookup Field

No delphi desde sempre existiu o lookup field, e como não podemos deixar no ORMBr podemos criar lookup field de forma simples, é o que vamos mostrar nesse artigo de hoje.
No nosso modelos teremos uma propriedade que receberá o ID da tabela lookup, ficando assim o exemplo:
   

    ...
    [Column('detail_lookup_id', ftInteger)]
    [Dictionary('detail_lookup_id','Mensagem de validação','','','',taCenter)]
    property detail_lookup_id: Integer Index 0 read Flookup_id write Flookup_id;
    ...

Continuando, teremos a tabela que irá receber o ID da tabela lookup que vou representa-la pela variável oDetail, ela é quem terá a propriedade acima no seu modelo.
Também teremos a tabela lookup, que mostrará todos os seus registros para que possamos selecionar um, vou representa-la pela variável oLookup, ficando assim o exemplo:

    ... 
    var
      oLookup: IContainerDataSet< tlookup >;
      oDetail: IContainerDataSet< tdetail >;
    begin
      oDetail := TContainerClientDataSet< tdetail >.Create(oConn, CDSDetail);
      oLookup := TContainerClientDataSet< tlookup >.Create(oConn, CDSLookup);
      oDetail.DataSet.AddLookupField('lookup_field',
                                     'detail_lookup_id',
                                     oLookup.DataSet,
                                     'lookup_id',
                                     'lookup_description');
      ...

Observe que as variáveis oDetail e oLookup, foram instanciadas recebendo dois parâmetros, de conexão e um TClientDataset para fazer cache, até ai normal como já mostrado em outro artigo. O segredo está aqui nessa linha:

  oDetail.DataSet.AddLookupField('lookup_field',
                                 'detail_lookup_id',
                                 oLookup.DataSet,
                                 'lookup_id',
                                 'lookup_description');

Como o campo ID será recebida pela tabela oDetail como falei acima, o campo lookup será criado nela, chamando o método AddLookupField, esse método receberá todos os parâmetros necessários para configurar um TField do tipo Lookup, os parâmetros são:

    
    procedure AddLookupField(AFieldName: string;
                             AKeyFields: string;
                             ALookupDataSet: TObject;
                             ALookupKeyFields: string;
                             ALookupResultField: string);

AFieldName: Nome para o TField campo; 
AKeyFields: Nome do campo que receberá o valor do campo que será definido em LookupKeyFields que virá da tabela lookup; 
ALookupDataSet: A variável que foi instanciada e terá os registros lookup, no nosso caso oLookup; 
ALookupKeyFields: Nome do campo chave que será o retorno da tabela lookup, para ser armazenado no AKeyFields; 
ALookupResultField: Nome do campo result para ser visualizado.

Continue...

ORMBr - Criando um Mestre-Detalhe

Mais uma dica do ORMBr.
Vamos hoje demonstrar como criar um mestre-detalhe de forma simples e eficaz, usando o ORMBr.
1o Passo: Criar a conexão com já mostrado no post ORMBr - Como criar uma conexão ? 
2o Passo: Adiciona em seu form dois TClientDataSet (podemos usar o TFDMemTable), vou usar o TClientDataSet nessa dica, adicione também dois TDataSource, em seguida configure suas propriedades ligando cada um ao seu TClientDataSet.
3o Passo: Adicione na clausula USES, as units:

ormbr.dependency.injection.clientdataset,
ormbr.dependecny.interfaces,
ormbr.factory.dbexpress;  // <= Aqui a fábrica de conexão escolhida por você.

4o Passo: Crie os modelos do mestre e do detalhe, veja o demo que segue junto aos fontes caso tenha dúvida nesse passo. 
5o Passo: Defina duas variáveis do tipo IContainerDataSet<T>, onde <T> devem ser os tipos dos modelos criados para mestre e detalhe, veja o código exemplo: 

oMestre: IContainerDataSet<TMestre>;
oDetalhe: IContainerDataSet<TDetalhe>;

6o Passo: No Create do Form, instancie a variável oMestre definida, passando para ela a variável de conexão, e o TClientDataSet1 que foi adicionado no inicio, veja o exemplo: 

oMestre := IContainerDataSet<TMestre>.Create(oConn, ClientDataSet1);

7o Passo: Também no Create do Form, instancie a variável oDetalhe definida, passando para ela a variável de conexão, e o TClientDataSet2 que foi adicionado no inicio e um terceiro parâmetro informando quem é o objeto MESTRE, veja o exemplo: 

oDetalhe := IContainerDataSet<TDetalhe>.Create(oConn, ClientDataSet2, oMestre);

8o Passo: Abra a tabela, chamando o método Open, veja o exemplo: 

oMestre.DataSet.Open;

A partir desse ponto, o ORMBr gerencia todo o resto, como abrir, relacionar, excluir e fechar a tabela DETALHE automaticamente.

Continue...

ORMBr - Select com paginação de registros.

Sabemos que banco de dados nenhum, conseguirá oferecer seus benefícios, em questão aqui sua velocidade de busca, se além de não for bem arquitetado, também for usado de forma incoerente, por um sistema mal projetado.

No ORMBr, temos o recurso de paginação para resolver isso, quando formos fazer um select de muitos registros, paginação é um recurso fundamental para que o sistema reflita a velocidade de retorno, o qual o banco de dados não faria sozinho, para definirmos esse recurso no ORMBr, usaremos um terceiro parâmetro na class de conexão.

// DBExpress de 10 em 10
oConnection := TFactoryDBExpress.Create(SQLConnection1, dnSQLite, 10); 

// ZeosLib de 50 em 50
oConnection := TFactoryZeos.Create(ZConnection1, dnSQLite, 50);

// FireDAC de 100 em 100
oConnection := TFactoryFireDAC.Create(FDConnection1, dnSQLite, 100);

Demostrei em cada tipo de fábrica que pode ser usado no ORMBr, um valor diferente, para ficar bem claro que você é quem decidirá a paginação desejada, trazendo assim agilidade nos selects de seu sistema, principalmente se seu cliente tenha uma rede precária.

Continue...

ORMBr - Como Incluir, Alterar e Excluir ?

Mais uma dica do ORMBr, vimos em um dos artigos escrito por mim sobre como criar uma conexão, para quem ainda não leu acesse ORMBr - Como criar uma conexão ?
Vamos hoje demonstrar o que temos que fazer para que possamos ter um DBGrid, onde nesse poderemos fazer Inclusão, Alteração e Exclusão de uma unica tabela no banco de dados, esse exemplo estará usando o recurso mais simples do ORMBr.
1o Passo: Criar a conexão com já mostrado no link como criar uma conexão.
2o Passo: Adiciona em seu form um TClientDataSet, (podemos usar o TFDMemTable), mas vou usar o TClientDataSet, pois este, está em todas as versões do Delphi desde a versão 3, adicione também um TDataSource, em seguida configure suas propriedades.
3o Passo: Adicione na clausula USES, as units:

ormbr.dependency.injection.clientdataset,
ormbr.dependecny.interfaces,
ormbr.factory.dbexpress;  // <= Aqui a fábrica de conexão escolhida por você.

4o Passo: Crie seu modelo, como exemplo abaixo:

unit ormbr.model.client;

interface

uses
  Classes, 
  DB, 
  SysUtils, 
  Generics.Collections, 
  /// orm 
  ormbr.mapping.attributes, 
  ormbr.mapping.classes,
  ormbr.types.nullable,
  ormbr.types.lazy,
  ormbr.types.mapping,
  ormbr.mapping.register;

type
  [Entity]
  [Table('client','')]
  [PrimaryKey('client_id', 'Chave primária')]
  [Indexe('idx_client_name','client_name')]
  Tclient = class
  private
    { Private declarations }
    Fclient_id: Integer;
    Fclient_name: String;
    Fclient_name_: String;
  public
    { Public declarations }
    [Restrictions([NoUpdate, NotNull])]
    [Column('client_id', ftInteger)]
    [Dictionary('client_id','Mensagem de validação','','','',taCenter)]
    property client_id: Integer Index 0 read Fclient_id write Fclient_id;

    [Column('client_name', ftString, 40)]
    [Dictionary('client_name','Mensagem de validação','','','',taLeftJustify)]
    property client_name: String Index 1 read Fclient_name write Fclient_name;
  end;

implementation

initialization
  TRegisterClass.RegisterEntity(Tclient);

end.

5o Passo: Defina uma variável do tipo IContainerDataSet<T>, onde <T> deve ser o tipo do modelo que será usado, exemplo IContainerDataSet<Tclient>, veja o código exemplo:

oClient: TContainerClientDataSet<Tclient>;

6o Passo: No Create do Form, instancie a variável definida, passando para ela a variável de conexão criada, e o TClientDataSet que foi adicionado no inicio, veja o exemplo:

oClient := TContainerTClientDataSet<Tclient>.Create(oConn, ClientDataSet1);

7o Passo: Abra a tabela, chamando o método Open, veja o exemplo:

oClient.DataSet.Open;

Com esse código você já está hapto a Inserir, Alterar e Excluir registro no banco de dados, aqui vocês poderão pensar, o Delphi faz o mesmo até de forma mais simples, mas o diferencial está no modelo, pois se observarem, não pedi para adicionar TFields no TClientDataSet, os TFields adicionados em designer são um caos na vida do desenvolvedor para manutenção, e no ORMBr os TFields são adicionados em runtime, e todas as características de cada TFields é passada usando o atributo Dictionary() que os parâmetros são:

property ConstraintErrorMessage: string read FConstraintErrorMessage write 
FConstraintErrorMessage;
property DefaultExpression: string read FDefaultExpression write 
FDefaultExpression;
property DisplayFormat: string read FDisplayFormat write FDisplayFormat;
property EditMask: string read FEditMask write FEditMask;
property Alignment: TAlignment read FAlignment write FAlignment;

É isso ai, fiquem atentos e aguardem as próximas dicas.

Continue...

ORMBr Residência Fixa

É com muito orgulho e alegria que informo a todos vocês, que o ORMBr agora tem uma residência fixa e desde já, deixo meus agradecimentos a um  amigo em particular o Jeickson, que fez com que isso se tornasse uma realidade de forma rápida, sem medir esforços.

Nossa nova casa está no endereço : http://www.ormbr.com.br/

Graças a Deus o ORMBr está sendo muito bem recebido pela comunidade Delphi, tenho recebido inúmeras solicitações de amizade no Facebook, cadastros no fórum, entre outros contatos.

Também quero convocar a todos que fizeram seus cadastros no fórum http://ormbr.forumeiros.com/, que refaça seu cadastro, mas agora no fórum do site, o link do novo fórum é http://ormbr.com.br/forum/, conto com a compreensão e paciência de todos para essa repetição, mas o motivo foi porque o fórum atual não me disponibilizou a opção de fazer um backup e restaurar no novo. 

Em nome do projeto ORMBr, deixo aqui meus agradecimento também a todos que tem tirado uma parte do seu tempo para baixar os fontes, ler os posts e até mesmo de qualquer forma tentar ajudar, nosso fórum é e sempre será o meios para que possamos colocar nossas dúvidas, sugestões e discussões, la tentarei responder o quanto antes possível os posts de vocês.

Continue...

ORMBr - Uma visão aérea

Neste arquivo vou tentar mostrar para você uma visão aérea do ORMBr Framework, ele é separado por camadas, e cada camada são independente uma da outra, proporcionando assim usar qualquer camada em outro projeto que eu queira e haja necessidade.

Nessa imagem most o fluxograma, das camadas existentes veja abaixo:

Como citei acima o fluxograma mostra as camadas existentes, cada camada tem suas Units, vou relacionar para que serve cada camada, mas não vou relacionar aqui quais units de cada camada.

Dependency Injection - Essa camada como o nome já diz, traz independência da criação das classe produtos concreto, diretos em nosso projeto, hoje as independências são duas uma para o TClientDataSet e outra para o TFDMenTable.

Driver - Essa camada cuida de tudo que se refere ao banco de dados, nela podemos definir nossa conexão, transações e executar os comando SQL que venham a ser necessários. Essa camada é expansível, podendo existir N drivers, hoje temos para os bancos MSSQL, FireBird, MySQL e SQLite.
Devemos considerar essa camada como unica, pois ela deverá servir para todo o projeto, seu uso foi mostrado no artigo ORMBr - Como criar uma conexão ?

Bind - Essa camada é responsável a nos proporcionar o usar pelo o ORMBr os famosos TDataSet e os componentes dbwares.
Na camada Bind teremos todos os recursos como Insert, Append, Edit, Delete, ApplayUpdates uso dos eventos do DataSet etc..., tudo o que já estamos acostumados, e nos bastidores essa camada trata tudo para se comunicar com a camada que irá fazer o tratamento para persistência das informações no banco.
Devemos ter uma instância do Bind para cada tabela(TDataSet) que precisarmos, no caso de mestre-detalhe por exemplo, vamos ter um Bind Mestre e outro para a Detalhe, passando assim como parâmetro para o Bind Detalhe o Bind Master.

Session - Essa camada é usada pela camada Bind, na verdade é essa camada, que tem o link direto para que o ORMBr faça tudo no banco de dados, ele é quem cuida dos objectos modelos e seus mapeamentos.
Bom ai podemos nos perguntar se é essa a camada que faz gerencia tudo como comandos, persistência etc.. no banco de dados, então para que a camada Bind acima? O motivo é que deixei essa camada para aqueles que não gostam de usar DataSet, com a existência dela, pode-se ter todos os recursos de um ORM, ignorando a camada Bind.

Metadata - Essa camada como o nome já diz, tratará de todos os recursos de gerenciamento do metadata do banco de dados, adicionando, alterando e excluindo, campos, tabelas, FK, PK etc..., a pretensão do ORMBr é ir até onde der para gerenciamento do metadata como exemplo gerenciamento de Views.

Criteria - Essa camada, já veio pronta e foi uma mão na roda para o ORMBr vui. Criteria é uma interface que criei para ser usada como esse nome, mas na verdade quem está por traz é a biblioteca GpSQLBuilder, (o uso do GpSQLBuilder, foi solicitado a autorização ao autor, que autorizou), mais informações em GpSQLBuilder.

Controller - Bom e por final, temos a camada Controller que servirá como base para que voçês possam criar seus controles herdando do TControllerBase, essa class base, já irá disponibilizar para vocês as propriedades que será alimentada após sua criação, o DataSet e o IDBConnection, disponibilizando assim dentro do seu controle o acesso necessários a essas instâncias.

É isso ai, e vamos que vamos, ainda tem muita coisa para eu passar para vocês :)

Continue...

ORMBr - Como criar uma conexão ?

Para conexão de dados no ORMBr, hoje podemos usar três suítes, DBX (TSQLConnection), FireDAC (TFDConnection) e ZeosLib (ZConnection).

1o Passo: A conexão deve ser parametrizada da forma que você já conhece no Delphi, ou seja colocando o componente de conexão no seu projeto e parametrizando suas propriedades, a forma que irá fazer isso não importa para o ORMBr.

2o Passo: Adicione no seu projeto as units do ORMBr, conforme a suite de acesso a dados escolhido, além das units necessárias por cada suite. 

// DBExpress
uses
  ormbr.factory.interfaces,
  ormbr.types.database,
  ormbr.factor.dbexpress;

// ZeosLib
uses
  ormbr.factory.interfaces,
  ormbr.types.database,
  ormbr.factor.zeos;

// FireDAC
uses
  ormbr.factory.interfaces,
  ormbr.types.database,
  ormbr.factor.firedac;

3o Passo: Crie uma variável global do tipo IDBConnection, da qual você terá acesso a ela em todo seu projeto, caso precise de algum recurso do banco, como StarTransaction, Commit, RollBack etc... 

...
// Variável de conexão global.
var
  oConnection: IDBConnection; 
...

4o Passo: Instanciar a variável de conexão, passando para ela dois parâmetros: O Componente usado para conexão das suítes citadas acima O Tipo do banco de dados que irá usar os tipo são: dnSQLite, dnFirebird, dnMySQL, dnMSSQL etc... 

// DBExpress 
oConnection := TFactoryDBExpress.Create(SQLConnection1, dnSQLite); 

// ZeosLib 
oConnection := TFactoryZeos.Create(ZConnection1, dnSQLite);

// FireDAC 
oConnection := TFactoryFireDAC.Create(FDConnection1, dnSQLite); 

Agora é só usar, lembrando que o ORMBr trabalha de forma desconectada, dessa forma você não precisa abrir a conexão, deixe que ele gerencie isso para você, ele irá abrir na hora que precisar e fechar quando não mais, isso automaticamente.

Continue...

ORMBr no Delphi 10.1 Berlin Starter Edition

No site da Embarcadero  diz :

"Delphi Starter Edition é uma ótima maneira de começar a construir aplicações de alto desempenho para o Windows sem conectividade de banco de dados."

Será ?

Não é bem assim :).

Para Lazarus existe uma suite de nome Zeos que é OpenSource, e é bem usada por quem usa Lazarus, essa mesma suite também existe para Delphi, e com ela podemos desenvolver aplicações de acesso a dados sim.
O Zeos pode ser baixado no link citado abaixo e instalado via IDE, abrir pacote, compilar e instalar.

E não para por ai, para temperar ainda mais essa ótima notícia, o ORMBr Framework juntamente com essa suite Zeos também pode ser usado no Delphi Starter, primeiro porque o ORMBr não precisa instalar nada, segundo porque o ORMBr usa para data bind o componente TClientDataSet, que vem nessa versão.

Teremos então, uma versão do Delphi atual, com suas limitações claro, mas com muito mais recurso que o Delphi 7, contando ainda com o desenvolvermos para as plataformas Windows 32 e 64bit, iOS e Android usando FireMonkey.

Gostou? Junte-se a nós.

Delphi Starter Edition até 20/09/2016 : Deplhi Starter Edition
Repositório do ORMBr Framework : ORMBr Framework
Fórum do ORMBr : ORMBr Fórum
Zeos : Zeos Lib

Continue...

ORMBr - Como Conhecer e Testar

O ORMBr você não precisa instalar nada no seu Delphi:

1) Usar Delphi XE ou superior

2) Baixe os fontes do projeto direto do repositório Download (ORMBr - Framework)

a) Uma outra opção é instalar o Git+TortoiseGit para sempre atualizar seus fontes como o do repositório, veja passo a passo nesse link Guia Git+TortoiseGit passo a passo, se não for suficiente, existem vários posts sobre o assunto.

3) Após baixar todo os fontes, junto irá ter alguns demos, um usando para acesso a dados o DBExpress, outro o FireDAC e outro usando o Zeos, os demos ficam dentro da pasta .\ORMBr\Demo\Data, escolha o de sua preferencia e abra pelo seu Delphi, em seguida basta compilar e estudar os fontes, como já dito não precisa instalar nada.

Nota: O ORMBr, pode usar dois componentes conhecidos por nós para fazer baind, com os componentes DBs (TDBEdit, TDBGrid, etc...) são eles : TClientDataSet ou TFDMenTable (esse do engine FireDAC), o componente fica a sua escolha, e ele é independente do engine de conexão que você usará seja ele DBExpress, FireDAC ou Zeos.

Continue...

FireDAC TFDMemTable - DataSets em Memória

O TFDMemTable bem como o TClientDataSet, podem ser usados no ORMBr para fazer cache em memória dos dados e bind com os componentes dataware, veja nesse vídeo com Fernando Rizzato seus recursos e saiba as vantagens de ter um ORM que usa um dataset já familiar para te trazer confiança ao usa-lo.

Continue...

RAD Studio Berlin 10.1 Update 1 Disponível

Hoje, Embarcadero lançou a primeira actualização do RAD Studio, Delphi e C ++ Builder 10,1 Berlin, com muitas melhorias de qualidade e algumas novas funcionalidades.

As novas características incluem uma versão do controle FireMonkey grade para iOS, com base no controle da plataforma nativa, várias outras melhorias FMX, e suporte para iOS 10 (em particular o simulador) e compatibilidade melhorada para a vinda MacOS Sierra.

Em termos de correções, compilador do C ++ tem várias melhorias (quase 20), mas também a Delphi tem algumas questões (cerca de 5) arredondado para cima. Todas as áreas do produto tem correções e melhorias, incluindo um problema DataSnap / REST irritante, FireDAC, VCL, RTL, o IDE, o instalador .... com mais de 100 pública relatado correções de bugs, e mais de 300 total (incluindo internamente relatado problemas ).

Fonte : Marco Tecnologia Blog

Continue...

ORMBr - Mapeamento objeto-relacional

Mapeamento objeto-relacional (ou ORM, do inglês: Object-relational mapping) é uma técnica de desenvolvimento utilizada para reduzir a impedância da programação orientada aos objetos utilizando bancos de dados relacionais. As tabelas do banco de dados são representadas através de classes e os registros de cada tabela são representados como instâncias das classes correspondentes.

Com esta técnica, o programador não precisa se preocupar com os comandos em linguagem SQL; ele irá usar uma interface de programação simples que faz todo o trabalho de persistência.

Não é necessária uma correspondência direta entre as tabelas de dados e as classes do programa. A relação entre as tabelas onde originam os dados e o objecto que os disponibiliza é configurada pelo programador, isolando o código do programa das alterações à organização dos dados nas tabelas do banco de dados.

ORM não é uma técnicas tão recentes, pois jé exitem a algum tempo em outras linguagens como Java, e C#, acredito que muitos já ouviram falar sobre Hibernate ORM para a linguagem Java, e Entity Framework para as linguagens .NET da Microsoft.

Já para o Delphi, essa técnica é mais recente, começou a se expandir a partir da versão Delphi 2010, após as enormes melhorias na RTTI e o recurso Generics.

Ultimamente, acredito que a maioria de vocês, tem lido ou ouvido algo sobre ORM, mas a questão é, qual seria as ventagens e quanto isso me custaria para implementar em meus sistemas já existentes, e por fim qual o melhor ORM para eu analisar?

Venho a algum tempo, analisando e estudando as vantagens e funcionalidades de alguns ORMs do mercado, assistindo videos, analisando exemplos etc... e cheguei a conclusão que o ORM seria um grande aliado para nós desenvolvedores, principalmente com a falta de profissionais qualificados no mercado para nos ajudar na continuidade em nossos projetos.

Vou citar aqui um ponto de vantagem, veja se concorda:

Muitos de nós somos desenvolvedores solitários, o qual temos um sistema e a N vezes pensamos em contratar alguém para nos ajudar a mantê-lo, mas nosso tempo é curto e nosso código é tão enraizado em nossos modo de desenvolvimento que ao pensar em ensinar alguém, até desanimamos, pois isso iria nos consumir tempo enorme, então  preferimos nós mesmos pegar e fazer.

Com um ORM, temos ventagens nesse ponto, pois um ORM irá exigir uma linha de aprendizado bem curta a um desenvolvedor que possamos contrata-lo para nos ajudar, isso porque o ORM irá fazer a parte pesada nos bastidores, aliviando e agilizando o aprendizado em um novo profissional.

Poderia ficar aqui citando várias situações das quais, acredito eu que 100% de nós desenvolvedores sofremos no dia dia para conseguirmos ajuda em nosso projetos, mas não vou fazer isso, o exemplo acima já nos mostrar uma visão geral de nossas dificuldades.

Bom, deixa eu mostrar agora para você como que seria simples explicar para um aprendiz, para ele fazer uma tela, o mais simples que seja usando um ORM.

Vou demostrar as imagens para que vocês tenham uma visão da funcionalidade e após vou postar o código usado para chegar a esse resultado.

Acima está a lista de clientes, os componentes usados para que os dados possam ser visualizados são os Dataware, já conhecidos de todos os desenvolvedores Delphi.

Essa tela é a página detalhe do clientes selecionado na lista na primeira imagem, através dessa tela podemos Incluir, Alterar e Excluir registros.

O que usamos para gerar essa tela usando o ORM? 

Um TFDConnection ou poderíamos usar no lugar um TSQLConnection ou ZConnection.

Dois TClientDataSet ou poderíamos usar no lugar um TFDMemTable. 

Dois TDatasources

TDBGrid, TDBEdits e um TDBNavigator, familiar, não ?

Observe aqui que estou usando componentes já conhecidos nosso, não existe uma componente criado especificamente para atender ao ORM.

Agora vamos ao código para que os dados apareçam na tela grade  e detalhe, e para que as modificações sejam persistidas no banco de dados.

procedure TFrmCadastroCliente.FormCreate(Sender: TObject);
begin
  oConn := TFactoryFireDAC.Create(FDConnection1, dnSQLite); 
  oCliente_Pesquisa := TContainerClientDataSet<tcliente>.Create(oConn, ClienteDataSet1);
  oCliente_Detalhe  := TContainerClientDataSet<tcliente>.Create(oConn, ClienteDataSet2);
  oCliente_Detalhe.Controller := TControllerCliente< tcliente >.Create;
  oCliente_Pesquisa.DataSet.Open;
end;

procedure TFrmCadastroCliente.Cliente_DetalheAfterDelete(DataSet: TDataSet);
begin
  oCliente_Detalhe.DataSet.ApplyUpdates(0);
end;

procedure TFrmCadastroCliente.Cliente_DetalheAfterPost(DataSet: TDataSet);
begin
  oCliente_Detalhe.DataSet.ApplyUpdates(0);
end;

Esse monte de código acima, irá proporcionar os recursos de Incluir, Alterar e Excluir, sem nem mais uma linha.
Cadê o comando "SELECT" ? O ORM irá cria-lo automaticamente.
Cadê o comando "DELETE", bem esse o Delphi já faz para nós, mas como no ORM se trabalha desconectado quem irá fazer é o próprio ORM.
Cadê o comando "UPDATE", mesma situações do comando "DELETE"

Mas como ele sabe como gerar o SELECT sabe qual tabela abrir, sabe quais campos mostrar, enfim como o ORM identifica tudo?

Bem o código acima mostra a simplicidade de uso para um desenvolvedor, seja ele um aprendiz, com conhecimento ou um expert, criar algo real.

Por traz disso existe o que chamamos de Modelo, o modelo irá dizer tudo para o ORM, dessa forma desenvolvedores mais experientes podem cuidar dos modelos, enquanto os demais fariam o designer de forma simples e funcional.

Veja como fica o modelo usado para esse exemplo na imagem abaixo:

unit ormbr.model.cliente;

interface

uses
  Classes,
  /// orm
  ormbr.mapping.attributes;

type
  [Entity]
  [Table('cliente','')]
  Tcliente = class
  private
    { Private declarations }
    Fcliente_id: Integer;
    Fcliente_nome: String;
    Fcliente_endereco: String;
  public
    { Public declarations }
    [PrimaryKey()]
    [Column('cliente_id', ftInteger)]
    [Dictionary('Código','Mensagem de validação','','','',taCenter)]
    property cliente_id: Integer Index 0 read Fcliente_id write Fcliente_id;

    [Column('Nome do Cliente', ftString)]
    [Dictionary('cliente_nome','Mensagem de validação','','','',
    taLeftJustify)]
    property cliente_nome: String Index 1 read Fcliente_nome write Fcliente_nome;

    [Column('Endereço', ftString)]
    [Dictionary('cliente_endereco','Mensagem de validação','','','',taLeftJustify)]
    property cliente_endereco: String Index 2 read Fcliente_endereco write Fcliente_endereco;
  end;

implementation

end.

Como vocês puderam vê, o desenvolvedor não precisou escrever um linha se quer de comando SQL, e convenhamos qual ser humano não teria condição de aprender a criar uma tela de cadastro desse, usando ORM? Se não fosse o ORM teríamos que ensinar ainda sobre tudo comando SQL aumentando assim consideravelmente a linha de aprendizado de um possível novo funcionário contratado, o ORM nos proporciona também criarmos linha de produção, definindo os setores de Tela, de Modelos e de Regras de Negócio separadamente, cada um, responsável por seu setor e código, isso não é um sonho? Confesse para si mesmo.

Bom, com isso venho apresentar para vocês:

ORMBr, como o nome já diz, e assina Brasil, é um Framework criado por mim, e apesar de ser uma criança ainda, já mostrou um QI acima da média, e a ótima notícia é que ele é OpenSource, podendo ser baixado direto no Bitbucket.

Estamos providenciando um Site e um Fórum para ele, para que possamos juntos, ver essa criança crescer e nos encher de orgulho por suas conquistas.

Download : https://bitbucket.org/isaquepinheiro/ormbr/downloads

Fórum Discussão : http://ormbr.forumeiros.com/ 

Vai lá se cadastre, baixe e teste, conto com todos vocês, e até breve.

Continue...