Embora eu sempre enxerguei como sendo meu último trabalho acadêmico a maioria dos meus professores vislumbraram que deveria ser o grande trabalho da minha vida. Ledo engano. Bom, fui aprovado, portanto não deve ter ficado tão ruim, principalmente porque apliquei nele diversas práticas que aprendi dentro e fora da instituição e se hoje fosse faze-lo novamente, estou certo de que escreveria uns 30% menos códigos, no mínimo.

De qualquer forma, eu compactei e coloco aqui como anexo. Podem baixar à vontade, só peço que, caso o utilizem de alguma forma como auxílio no seu trabalho, me citem de alguma forma como referência.

Projeto Completo

A documentação eu acrescento um outro dia.

function TServicoMinhaClasse.getMinhaClasseById(Id: Integer): TMinhaClasse;
var
   cls: TMinhaClasse;
begin
   cls := TMinhaClasse.Create;
   Result := cls;
end;

Esse seria um código legal, se a classe não tivesse atributos. Para piorar esses dados ficam guardados em banco de dados. Portanto, eu preciso criar a conexão (ou usar uma existente) e criar uma nova consulta ao banco, configurando o banco. Para o nosso exemplo, vamos imaginar que a MinhaClasse tenha código e descrição somente. O código da unit da classe ficaria como o abaixo:

unit unMinhaClasse;

interface

type
   TMinhaClasse = class(TObject)

   private
      FDescricao: String;
      FID: Integer;
      procedure SetID(const Value: Integer);
      procedure SetDescricao(const Value: String);
   public
      property ID: Integer read FID write SetID;
      property Descricao: String read FDescricao write SetDescricao;
   end;

implementation

{ TMinhaClasse }

procedure TMinhaClasse.SetID(const Value: Integer);
begin
  FID := Value;
end;

procedure TMinhaClasse.SetDescricao(const Value: String);
begin
  FDescricao := Value;
end;

end.

Assim, para preencher essas propriedades, vamos modificar o corpo da nossa função para algo assim:

(...)
var
   qry: TSQLQuery;
begin
   cls := TMinhaClasse.Create;

   qry := TSQLQuery.Create;

   try
      qry.Database    := dModule.Database;
      qry.Transaction := dModule.Transaction;
      qry.SQL.Add('select * from tabela where id = :id');
      qry.ParamByName('id').AsInteger := Id;
      qry.Open;

      if not qry.IsEmpty then
      begin
         cls.ID        := qry.FieldByName('id').AsInteger;
         cls.Descricao := qry.FieldByName('descricao').AsString;
      end
      else
      begin
         cls := nil;
      end;
   finally
      qry.Free;
   end;

   Result := cls;
end;

Ok, ficou bom, mas imagine a longo prazo. Para cada uma das vezes que eu precisar da classe, eu teria de criar uma nova instância de SQLQuery e configura-la. Isso pode (e quase sempre vai) me induzir a errar em algum momento, na hora que eu esquecer de passar algum parâmetro ou mesmo validar se o banco está conectado. Para evitar todos esses problemas, criaremos um Builder, que para nós será simplesmente um construtor melhor para nossa SQLQuery.

Esse construtor vai ser instanciado dentro do objeto de serviço que e será vinculado à esse. Assim, todas as querys serão filhas desse objeto e serão destruídas quando esse for. Nesse builder vou precisar de duas propriedades: BancoDeDados e Transação. Assim, no construtor desse meu builder eu já as preencho e garanto que todos as querys ali criadas saem já configuradas como deve ser.

Desse jeito, a classe builder fica assim:

unit unQueryBuilder;

interface

uses
  SysUtils, Classes, SqlExpr, DBXpress;

type
   TQueryBuilder = class(TObject)
   private
      FTransacao: TTransactionDesc;
      FBancoDeDados: TSQLConnection;
      procedure SetBancoDeDados(const Value: TSQLConnection);
      procedure SetTransacao(const Value: TTransactionDesc);
   public
      property BancoDeDados: TSQLConnection read FBancoDeDados write SetBancoDeDados;
      property Transacao: TTransactionDesc read FTransacao write SetTransacao;
      function NovaInstancia(Dono: TComponent): TSQLQuery;
      constructor Create(Base: TSQLConnection; Trans: TTransactionDesc);
   end;

implementation

{ TQueryBuilder }

constructor TQueryBuilder.Create(Base: TSQLConnection; Trans: TTransactionDesc);
begin
   Self.BancoDeDados := Base;
   Self.Transacao := Trans;
end;

function TQueryBuilder.NovaInstancia(Dono: TComponent): TSQLQuery;
var
   pdsNovo: TSQLQuery;
begin
   pdsNovo := TSQLQuery.Create(Dono);
   pdsNovo.Database    := Self.BancoDeDados;
   pdsNovo.Transaction := Self.Transacao;
   Result := pdsNovo;
end;

procedure TQueryBuilder.SetBancoDeDados(const Value: TSQLConnection);
begin
   FBancoDeDados := Value;
end;

procedure TQueryBuilder.SetTransacao(const Value: TTransactionDesc);
begin
   FTransacao := Value;
end;

end.

Assim, toda vez que instanciar o novo serviço, devemos criar uma variável (ou propriedade) que armazene esse objeto Builder, mais ou menos assim:

   FabricaQuery := TQueryFactory.Create(Base, Trans);

Refatorando a chamada da função, teremos isso:

function TServicoMinhaClasse.getMinhaClasseById(Id: Integer): TMinhaClasse;
var
   qry: TSQLQuery;
   cls: TMinhaClasse;
begin
   qry := FabricaQuery.NovaInstancia(nil);

   try
      qry.SQL.Add('select * from tabela where id = :id');
      qry.ParamByName('id').AsInteger := Id;
      qry.Open;

      if not qry.IsEmpty then
      begin
         cls.ID        := qry.FieldByName('id').AsInteger;
         cls.Descricao := qry.FieldByName('descricao').AsString;
      end
      else
      begin
         cls := nil;
      end;
   finally
      qry.Free;
   end;

   result := cls;
end;

Talvez ainda tenha muito mais a melhorar, mas já está melhor do que inicial. Embora, aparentemente, o ganho tenha sido pouco, a vantagem desse padrão só seria sentida se não o utilizássemos. As propriedades poderiam ser preenchidas incorretamente e mais validações poderiam deixar de ser executadas. Dá para aprimorar muito mais. Mas eu vou até aqui, o resto deixo com vocês.

Pessoal, esse código pode gerar alguns erros. Ele foi originalmente escrito para a empresa que trabalho e por isso, muito do que era usado aqui foi substituído por componentes genéricos.

Depois de colocar uma listagem bem simples, buscando os dados do banco e montando numa tabela, eu vou colocar o resto da implementação, bem como os arquivos do projeto.

Nesse post vamos criar a lista, pagina, postando para uma página de tratamento fictícia. Vamos usar um pouco de Javascript e CSS, mas não é obrigatório, é só para dar alguma elegância ao projeto.

Como eu fiz esse artigo meio que de encomenda para um amigo, que não queria usar Ajax, eu não isso aqui. Portanto pense nisso antes das críticas .

Bom, vamos ao código. Para fazer a chamada eu criei um arquivo chamado lstEstado.php. Nesse arquivo, vou colocar a chamada, e um tratamento para que o controle da página seja feito por aqui (o que seria dispensável se usássemos Ajax).

<?php
	// Arquivo de listagem lstEstado.php. 

	// Arquivo de conexão, faça como achar melhor
	include_once('conexao.php'); 

	// Arquivo que irá conter a função CriarLista
	include('funcoes.php');

	// Controle para o caso da variável $pg vir vazia
	// na primeira chamada da lista pelo menu
	if (!isset($_GET['pg'])) {
		$pg = 1;
	} else {
		$pg = $_GET['pg'];
	}

	// A chamada da função. Parâmetros:
	// 1 - o nome da tabela no banco
	// 2 - a quantidade de linhas que serão exibidas por páginas
	// 3 - a página que se deseja exibir
	// 4 - o arquivo que trata a postagem da lista
	// 5 - o arquivo da listagem (para paginar)
	CriarLista('estado', 7, $pg, 'req.php', 'lstEstado.php');
?>

Assim a chamada para o arquivo de listagem seria somente isso. Você poderia ter dois times de programação, um que usa as funções e outro que as desenvolve. No futuro eu oriento isso à objetos, para ficar mais interessante ainda.

No arquivo funções, eu vou ter dois blocos. O do Javascript e o do PHP propriamente dito. O bloco do Javascript, ao menos no meu arquivo, vai primeiro, mas aqui eu vou colocar depois por questões didáticas. Esse arquivo eu colocar ele inteiro aqui, mas com vários cortes para os meus comentários.

<?php
	include_once('conexao.php');

	// Criação da função...
	function CriarLista($tabela, $itemsPorPagina, $paginaAtual, $tratamento, $URL_Lista) {

		$sql = "select count(*) total from ".$tabela;
		$res = mysql_query($sql);
		$lin = mysql_fetch_assoc($res);
		$totalCidades = $lin['total'];

Nesse bloquinho acima, fizemos uma consulta ao banco para saber quantos registros eu tenho. Isso vai ser muito útil na hora de calcular a quantidade de páginas que teremos (dividindo esse total pela variável $itemsPorPagina).

No meio do código eu vou colocando imagens, que serão usadas para navegar nas páginas da listagem. Perceba que nessas eu uso a mesma $URL_Lista que recebi como parâmetro, acrescentando o parâmetro pg.

		echo "<a class=\"botao\" href=\"{$URL_Lista}?pg=1\" title=\"Primeira página\"><img src=\"navega/first.png\"></a>";

		if ($paginaAtual == 1) {
			echo "<img src=\"navega/stop.png\" />";
		} else {
			echo "<a class=\"botao\" href=\"{$URL_Lista}?pg=".($paginaAtual - 1)."\" title=\"Página anterior\"><img src=\"navega/previous.png\"></a>";
		}

Esse bloco acima, da condição da primeira página, bem como o do botão próximo, tem essa tratamento de condição somente para não deixar vazio o espaço desses botões e evitar problemas de consistência, como por exemplo, na primeira página existir um link para a página anterior que obviamente daria erro.

No bloco abaixo eu monto uma caixa de seleção com uma Option para cada página que pode existir, somente controlando a quantidade de itens que podem caber numa página. Caso a página atual seja o $i da vez naquele laço, o programa já o marca como selecionado.

Aproveitando que a última posição, que fica na variável $controle, guarda o número da última página, eu a coloco no último link do nosso navegadorzinho. Segue o código:

		echo " <select id=\"comboPagina\" onchange=\"javascript:window.location='{$URL_Lista}?pg='+(this.value)\">";

		for ($i = 1; $i <= $totalCidades; $i = $i + $itemsPorPagina) {
			$controle++;
			$selecionado = "";

			if ($paginaAtual == $controle) {
				$selecionado = " selected ";
			}

			echo "<option {$selecionado}>".$controle."</option>";
		}
		echo "</select>";

		if ($paginaAtual == $controle) {
			echo "<img src=\"navega/stop.png\" />";
		} else {
			echo "<a class=\"botao\" href=\"{$URL_Lista}?pg=".($paginaAtual + 1)."\" title=\"Próxima página\"><img src=\"navega/next.png\" /></a>";
		}

		echo "<a class=\"botao\" href=\"{$URL_Lista}?pg=".($controle)."\" title=\"Última página\"><img src=\"navega/last.png\" /></a></p>";

O código abaixo é muito semelhante ao que colocamos na semana passada. Nele, como já foi explicado, nós pegamos os dados da tabela citada no parâmetro. Com esses dados preenchemos um array, $estrutura, com os valores que essa consulta retorna (Field, Type, Collation, Null, Key, Default, Extra Privileges e Comment). Quando encontrar algum campo que na variável Key tenha o valor ‘PRI’ (Chave primária), ele o reserva na variável $campoChave (Tá, eu sei, só funciona para tabelas com uma chave única, simples, nunca composta, mas deixo isso para vocês resolverem).

No meio desse bloco já vou acrescentando os echos que vou precisar para a correta exibição do resultado. Acho que as tags falam por si.

		// *** Listagem *** //

		$sql = 'SHOW FULL COLUMNS FROM ' . $tabela;
		$res = mysql_query($sql);
		$sql = 'select ';
		$estrutura = array();
		$pos = 1;

		echo "
			<form action='{$tratamento}' method='post' id='frm1'>
				<input type='hidden' name='acao' id='acao' value='' />
				<input type='hidden' name='opcao' id='opcao' value='' />
				<table border='1'>
					<tr>";

		while ($lin = mysql_fetch_assoc($res)) {
			echo "<th>".$lin['Comment']."</th>";
			$estrutura[$pos++] = $lin;
			$sql .= $lin['Field'] . ', ';

			if ($lin['Key'] == 'PRI') {
				$campoChave = $lin['Field'];
			}
		}
		echo "</tr>";

Já que estava no laço que passava pelos nomes dos campos, já aproveitei e criei o início da tabela, com a linha que terá os <th>.

Veja que a variável $sql começou a ser preenchida com os nomes dos campos no bloco acima. Nesse ponto do código ela já deve estar mais ou menos assim:

SELECT CAMPO1, CAMPO2, CAMPOn,

Nosso próximo passo é tirar a vírgula que sobrou no final, acrescentar a tabela, juntamente com a limitação de páginas e mandar isso pro banco. A seguir eu preencho os dados da table, com o resultado do que veio da consulta que montamos. Para cada um daqueles campos, nós o colocamos dentro de uma tag <TD> para a correta exibição na tela.

		$sql = substr($sql, 0, strlen($sql) - 2);
		$sql .= " from ". $tabela ;
		$sql .= " limit ".(($paginaAtual - 1) * $itemsPorPagina).", ".$itemsPorPagina;
		$res = mysql_query($sql);

		while ($lin = mysql_fetch_assoc($res)) {
			echo "<tr onMouseOver=\"javascript:Sel('".$lin[$campoChave]."')\" >";
			foreach ($estrutura as $campo) {
				echo "<td>".$lin[$campo['Field']]."</td>";
			}
			echo "<td>";
			echo "<input type='button' value='altera' onclick=\"javascript:Posta('alterar')\" />";
			echo "<input type='button' value='excluir' onclick=\"javascript:Posta('excluir')\" />";
			echo "</td>";
			echo "</tr>";
		}
		echo "</table></form>";
	}
?>

Você prestou atenção, reparou que eu coloquei uma pitadinha de Javascript dentro da nossa tabela.

	// Pitada número 1
	echo "<tr onMouseOver=\"javascript:Sel('".$lin[$campoChave]."')\" >";

	// (...)
	// Essa função vai setar um campo oculto do campo chamado "opcao" para o valor do ID daquela linha
	function Sel(id) {
		document.getElementById('opcao').value = id;
	}

Ficou claro, o código acima faz o truque de ao mover o mouse por sobre uma determinada linha da tabela, seja setado o valor do ID daquela pro campo oculto opcao.

E para que isso serve? Serve para o código a seguir, que envia o formulário todo que está envolta da tabela toda, envie os dados para o nosso arquivo de postagem.

	// Pitada número 1
	echo "<input type='button' value='altera' onclick=\"javascript:Posta('alterar')\" />";
	echo "<input type='button' value='excluir' onclick=\"javascript:Posta('excluir')\" />";

	// (...)
	function Posta(acao) {
		document.getElementById('acao').value = acao;
		document.getElementById('frm1').submit();
	}

E isso gera o resultado que vocês mesmos podem verificar ao implementar o código acima.

Conclusão

A finalidade desse código é facilitar aos programadores para não terem que nunca mais voltar a programar um administrador (simples) para pequenos sites. Baseado nos conceitos apresentados aqui, o exemplo pode ser muito ampliado para um ponto tal de que até mesmo os formulários sejam feitos por funções prontas, e até mesmo o arquivo de tratamento dos formulários seja feitos de maneira automática. O limite é a habilidade do programador (e a sua preguiça). Qualquer dúvida podem me procurar no Twitter ou mandem um e-mail.

<?php
	include_once('conexao.php');
	include('funcoes.php');

	CriarLista('Estado');
?>

A conexão é bem simples, faça como quiser.
Já a função, baseia-se na instrução SQL: SHOW FULL COLUMNS FROM TB_CLIENTE. Essa instrução retorna uma lista com os campos: Field, Type, Collation, Null, Key, Default, Extra Privileges e Comment. Para nós, nesse momento só interessam Field e Comment. Explico. Pegaremos os campos que retornam nessa SQL e com eles, comporemos a nova SQL com os campos que a primeira retornou, ficou claro?
Nos comments da tabela em questão, eu coloquei a descrição dos campos, tipo o campo EST_CODIGO tem o comentário “Código”.

Para usar, eu fiz o trechinho de código abaixo:

		$sql = 'SHOW FULL COLUMNS FROM ' . $tabela; // Crio a string
		$res = mysql_query($sql); // Envia a string para o banco e guarda o retorno
		$sql = 'select '; // Crio a nova SQL
		$estrutura = array(); // Inicializo o array
		$pos = 1; // Inicializa 1ª posição

		echo "<table border='1'>
				<tr>"; // Monta o início da tabela

		while ($lin = mysql_fetch_assoc($res)) {
			echo "<td>".$lin['Comment']."</td>";
			$estrutura[$pos++] = $lin;
			$sql .= $lin['Field'] . ', ';
		}
		echo "</tr>";
		$sql = substr($sql, 0, strlen($sql) - 2);
		$sql .= " from ". $tabela ;

Com esse código ai conseguimos compor uma nova SQL, algo como Select EST_CODIGO, EST_NOME from ESTADO. Assim, poderemos fazer a nova consulta como deve ser. Além disso, todo o resultado daquele resource fica armazenado em um array chamado estrutura, para consulta posterior.
Com esses dados em mãos, vamos simplesmente fazer a nova consulta no banco e trazer os dados para dentro da tabela. Veja como fica esse trecho:

		$res = mysql_query($sql);
		while ($lin = mysql_fetch_assoc($res)) {
			echo "<tr>";
			foreach ($estrutura as $campo) {
				echo "<td>".$lin[$campo['Field']]."</td>";
			}
			echo "</tr>";
		}
		echo "</table>";

e assim funciona, e no próximo post eu coloco o arquivo para download e também como paginar o resultado dessa função.

Até mais

procedure TForm1.ExecutaScript;
var
  ErrorCode: Integer;
begin
   try
      ErrorCode := Conexao.ExecuteDirect(MemoSQL.Text);
      // Conexao é um TSQLConnection já conectado ao banco.

      if ErrorCode = 0 then
          ShowMessage('Script rodado com sucesso');

      {Se retornar diferente de "0" é porque algo de errado aconteceu}
      if ErrorCode <> 0 then
         raise Exception.Create( 'Error: code = ' + IntToStr( ErrorCode ) )

   except
      on E: Exception do
         ShowMessage( E.Message );
   end
end;

Só testei em Oracle, mas não vejo motivos para não rodar em Interbase.

Abaixo seguem os slides. Qualquer dúvida podem perguntar que eu esclareço.

Talvez fique um pouco descontextualizado, porque os slides não são nada sem a narração, mas como me pediram, ai está.