Share Button

Na versão XE7 foi incorporado ao Delphi o conceito de processamento paralelo. Antes já era
possível fazer algo parecido utilizando bibliotecas de terceiros
[http://www.omnithreadlibrary.com/index.htm http://andy.jgknet.de/blog/bugfix-units/asynccalls-
29-asynchronous-function-calls/].
Para tentar simplificar o conceito, diz paralelo quando consegue executar dois ou mais processos ao
mesmo tempo, daí o nome “paralelo”.

Exemplo utilizando TTask:

var
tsk: array [0 .. 2] of ITask;
i, n: integer;
begin
   tsk[0] := TTask.create(
       procedure
        begin
          TThread.Queue(nil, procedure
             begin
               caption := 'xxx'; // sincronizar a atualização da janela.
             end);
        end);
   tsk[0].Start; // inicia o processamento antes de criar as TTask seguintes
   tsk[2] := TTask.create(
       procedure
          var
          k: integer;
          begin
             i := 1;
             sleep(1000);
             for k := 0 to 10000 do
                inc(i);
          end);
tsk[1] := TTask.create(
          procedure
          var
          k: integer;
          begin
              n := n;
              for k := 0 to 1000 do
                inc(n);
              add( 'N');
          end);
tsk[2].Start; // inicia o processamento
tsk[1].Start;
TTask.WaitforAll(tsk); // quando quer aguardar o termino de todas as TTasks

Share Button

Houve um tempo que executar tarefas em “background” era um tortura.
Com a evolução de hardware e software, fazer uso de computação paralela passou a ser tão
fácil quanto um desafio em resistir ao seu uso.

Introduzida na versão XE7, um “thread” passou a rodar considerando o balanceamento entre
os processadores presentes na unidade de processamento.

Associar o uso de métodos anônimos facilitou em muito todo o trabalho:

TThread.CreateAnonymousThread(
procedure begin
    // execute aqui o seu código
      ....
    // se precisar sincronizar atualização de 
    // controles da janela
    TThread.Queue(nil,
             procedure begin
                     // aqui deve incluir a atualização 
                     //      dos controles da janela;
                     // ex: label1.caption := 'texto';
             end);
         end).Start;

Share Button

Assim como Class Helper extende classes, Record Helper permite extender
Records.

Quantas vezes já precisou fazer: total := total + x;
Utilizando helper poderia escrever assim: total.add( x );

Código Fonte no GIT

Share Button

A introdução de Class Helper no delphi ajudou o desenvolvedor a incluir novas
funcionalidades nas classes nativas do delphi – você tem uma idéia de um
recursos dos sonhos e gostaria de implementar lá na classe base, use Class
Helper.

Extendendo o TDataset:

TDatasetHelper = class helper for TDataset
public
   procedure Run(AProc:TProc<TDataset>);
end;

procedure TDatasetHelper.Run(AProc: TProc<TDataset>);
begin // executa em um thread separada
     TThread.CreateAnonymousThread(
         procedure begin
            if assigned(AProc) then
               AProc(self);
         end
     ).Start;
end;

O exemplo implementa a capacidade de uso da “procedure” RUN(…) por
qualquer classe com herança de TDataset.

Trabalhando com o novo procedimento:

O procedimento RUN por finalidade executar em um processo paralelo (uma
nova TThread) a rotina que estiver implementando no TProc.

var total:double;
begin
        query1.run(
                   procedure (ds:TDataset) // rotina a executar em paralelo.
                     begin
                       ds.first;
                       while ds.eof=false do
                       begin
                          total := total + xxxxx;
                          ds.next;
                       end;
                  end);
end;

Share Button

Usando a System.ZIP para gerar arquivo ZIPContinue reading

Share Button

Para descompactar um arquivo ZIPContinue reading

Share Button

O Firebird aceita usar o Order By indicando o nome da coluna (o mais conhecido), o número da coluna ou pelo apelido da coluna.

Exemplo usando o nome da coluna:

select
     codigo, nome, preco, (preco * 1.05) precoPrazo
from fb_prod
order by nome Rows 10

Exemplo usando o número da coluna

select
      codigo, nome, preco, (preco * 1.05) precoPrazo
from fb_prod
order by 4 Rows 10

Exemplo usando o apelido da coluna:

select
     codigo, nome, preco, (preco * 1.05) precoPrazo
from fb_prod
order by precoPrazo Rows 10

Share Button

O Firebird tem duas formas diferentes de limitar o número de linhas:

First/Skip   ou

Rows/To    (mais nova)

Exemplo:

select codigo, nome from clientes Rows 10 To 15

Retorna as linhas de número 10 até a linha 15 (primeira linha=1)

Se rows>0 sem indicar o To retorna as N linhas a partir do primeiro registro.

Se rows=0 não retorna nenhuma linha.

Se rows <0 vai gerar uma exceção.

 

DB_TDataSet
Share Button

Com a crescente número de amigos que estão navegando em serviços
cambiáveis entre aplicativos (ou linguagens), serializar um TDataset pode ser
uma solução simples e “stander” de mercado para troca de informações.
Depois de muitas idas e vindas vou deixar o resultado do trabalho que já fiz
sobre o assunto

uses System.uJson, Data.DB.Helper;
function DatasetToJson( const ADataset:TDataset ) : string;
begin
result := ADataset.ToJson;
end;

Fonte: Data.DB.Helper.pas System.uJSON.pas

Share Button

SWEEP é um recurso que limpa registros lixo do banco de dados. Quando um registro é excluído (DELETE) ou feito (UPDATE) o firebird mantem uma cópia antiga do registro no arquivo do banco de dados (MEUBANCO.FDB), ainda que esta cópia não seja visualizada ao fazer o SELECT no banco de dados.

Como a remoção de dados do arquivo consome tempo de processamento considerável, o Firebird não o faz constantemente, mas sim, de períodos em períodos. Se a instalação padrão do MEUBANCO.FDB for de 20.000 registro, ou seja, quando atinge este número de registro o banco executa automaticamente um SWEEP do banco de dados (limpa o lixo).

Como ele não escolhe a hora mais adequada para executar o SWEEP, muitas vezes o banco o executa exatamente quando o usuário mais esta precisando acessar o banco. Quando isto ocorre, o banco aumenta o tempo de resposta tornando perceptível ao usuário.

Em instalações de uso intenso, uma possibilidade é desabilitar este processo automático e passar a faze-lo em momento programados. Ex: quando liga a máquina, ou ainda, programada para executar fora do expediente.


*Como desabilitar o SWEEP

gfix -h 0 localhost:c:\dados\meubanco.fdb -user sysdba -password masterkey

Ao desabilitar o SWEEP o banco deixará de fazer limpeza dos registros inválidos, razão que é preciso montar um processo de execute o SWEEP manualmente (obrigatório). Se por o SWEEP deixar de ser feito por um período que acumule muitos registros inválidos, será afetado o desempenho do banco de dados, até que o SWEEP seja executa; Executar o SWEEP quando reinicia o banco de dados, pode ser uma opção bastante interessante.

*Para alterar o SWEEP para 1000

gfix -h 1000 localhost:c:\dados\meubanco.fdb -user sysdba -password masterkey

*Executar SWEEP Manual

gfix -sweep localhost:c:\dados\meubanco.fdb -user sysdba -password masterkey

Em uma estratégia de execução manual, pode gerar um script (uma bat) e registrar a execução no agendador de tarefas para fazer todos os dias a noite quando o uso do banco é baixo, assim irá manter melhor controle sobre a performance do banco durante os períodos de maior atividade.