Apresentação

O LUCAS-GABRIEL é um middleware com a finalidade de aumentar a escalabilidade associada a independência dos SGBDRs com arquitetura cliente-servidor de duas camadas.

O LUCAS-GABRIEL efetua a distribuição horizontal dos dados entre instâncias distintas de SGBDRs, mas sem interferir diretamente sobre o processamento dos SGBDRs. Ele atua numa camada intermediária entre o Sistema Cliente e os SGBDRs. Com esta camada intermediária o processo de comunicação entre o Sistema Cliente e SGBDR muda. Este novo processo é mostrado na seqüência:

Desta maneira o Sistema Cliente não se comunica diretamente com os SGBDRs, apenas através do LUCAS-GABRIEL. Em contrapartida, o LUCAS-GABRIEL deixa transparente ao Sistema Cliente a estrutura física dos dados persistidos. Também é possível incluir novas instâncias de SGBDRs na estrutura computacional sem que o Sistema Cliente perceba tal ação.

O LUCAS-GABRIEL também pode ser visto como uma interface ODBC1, uma vez que o Sistema Cliente pode acessar vários tipos de SGBDRs sem a necessidade de uma codificação de acesso especializada.

1. Esta versão do LUCAS-GABRIEL só usa os SGBDRs Firebird ou Interbase, mas estão previstos outros SGBDR populares (PostgreSQL, MySQL, SQLServer, Oracle) para as próximas versões

Instalação

No lado do Sistema Cliente não é instalado nenhum driver de conexão com o SGBDR. O único arquivo que deve está junto com o Sistema Cliente é a DLL onde o LUCAS está encapsulado.

Numa máquina entre o Sistema Cliente e os SGBDRs deve ser instalado o GABRIEL. Nesta mesma máquina devem ser instalados os drivers cliente do SGBDRs, uma vez que o GABRIEL é visto pelos SGBDRs com um sistema cliente comum.

Cada instância de SGBDR deve manter uma cópia do banco de dados com todas as tabelas e todos os atributos. A chave primária será gerada pelo GABRIEL, logo, o SGBDR não deve gerar nenhum valor para a chave primária. Tendo como exemplo o metadado abaixo, ele deve se repetir em todas as instâncias dos SGBDRs conectados ao GABRIEL, pois como já foi mencionado anteriormente, o LUCAS-GABRIEL efetua a distribuição horizontal dos dados entre instâncias distintas de SGBDRs.

create table CLIENTE (
  ID integer not null primary key,
  Nome varchar(50),
  Ender varchar(40),
  Bairro varchar(20),
  CEP varchar(10),
  Munic varchar(20),
  UF      char(2)
);

Diagrama de caso de uso

O middleware é dividido em duas partes, o LUCAS e o GABRIEL (figura 2). O LUCAS fica do lado cliente, isto quer dizer que cada cliente deve ter o LUCAS instalado localmente. Entre o LUCAS e os SGBDRs tem-se o GABRIEL, que é o núcleo do middleware.  O middleware não terá nada instalado do lado do SGBDR, para o SGBDR o GABRIEL é um cliente.

Funcionalidade

A troca de mensagens entre LUCAS e GABRIEL é realizada via socket. Nas consultas de dados, o GABRIEL consolida os dados num arquivo XML e envia ao LUCAS via socket. Um exemplo de um arquivo XML gerado pelo GABRIEL e enviado ao LUCAS pode ser visto na figura 3.

O esquema do arquivo XML gerado está diretamente relacionado com o metadado da origem dos dados, mas três tags são comuns a todos os arquivos XML gerados:

GABRIEL

As configurações e atributos do GABRIEL ficam visíveis constantemente. A figura 4 mostra uma instância do GABRIEL.

Os itens da interface do aplicativo são explicados na seqüência:

LUCAS

O LUCAS está encapsulado dentro de uma DLL. O aplicativo cliente deve utilizar a DLL para efetuar a chamada aos métodos do LUCAS. A Tabela 1 mostra os métodos do LUCAS e como devem ser invocados através da DLL.

Configurar o LUCAS

O Sistema Cliente deve configurar o LUCAS antes de iniciar as solicitações. O próximo código apresenta um exemplo para efetuar a configuração:

LUCAS_SetAtivarSoquete(False);
LUCAS_SetMediador(‘10.30.0.45‘);
LUCAS_SetPorta(1010);
LUCAS_SetResposta(‘C:\Pasta_Resposta\‘);
LUCAS_SetAtivarSoquete(True);

Incluir registro independente

A figura 5 mostra o diagrama de seqüência para incluir um registro numa tabela sem chave estrangeira.

No caso de uma inclusão independente o Sistema Cliente deve invocar os métodos Clear e SetTabela do LUCAS, em seguida, para cada campo e valor que se deseja incluir no novo registro o método SetDados deve ser invocado.

Para entender melhor, imagine que se deseja incluir um registro na tabela Cliente com os dados da tabela 2.

O Sistema Cliente deve executar o código semelhante ao mostrado:

LUCAS_Clear;
LUCAS_SetTabela(‘Cliente’);
LUCAS_SetDados(‘Nome’, ‘José da Silva’);
LUCAS_SetDados(‘Endereco’, ‘Rua Todos os Santos’);
LUCAS_SetDados(‘Cidade’, ‘Juazeiro do Norte’);
LUCAS_SetDados(‘UF’, ‘CE’);
LUCAS_SetIncluir(True);

Incluir registro dependente

A figura 6 mostra o diagrama de seqüência para incluir um registro numa tabela que possua chave estrangeira, e onde esta chave estrangeira deve ser igual a chave primária de uma inclusão anterior, mas ainda desconhecida.

Uma venda via pedido é um cenário onde se inclui registros dependentes. A chave primária do pedido é chave estrangeira para seus itens, mas a chave primária só será conhecida no momento da inclusão.

O desconhecimento da chave primária do pedido pode causar inconsistência nos dados, uma vez que se forem incluídos dois ou mais pedidos num mesmo instante, não tem como saber qual a chave primária que os itens lançados nesses pedidos distintos devem obter, uma vez que um pedido pode ser persistido (i) antes de todos, (ii) após todos ou (iii) entre lançamentos.

Para simplificar, é mostrado como incluir dados em casos semelhantes, conforme tabela 3.

O código que deve ser executado pelo Sistema Cliente fica semelhante ao mostrado:

LUCAS_Clear;
LUCAS_SetTabela(‘Pedido’);
LUCAS_SetDados(‘DtPedido’, ‘01/01/2009’);
LUCAS_SetDados(‘ID_Vend’, ‘10’);
LUCAS_SetDados(‘ID_Cliente’, ‘153’);
LUCAS_SetIncluir(False);

LUCAS_SetTabela(‘Pedido_Item');
LUCAS_SetChaveEstrangeira(‘Pedido’, 'ID_Pedido');
LUCAS_SetDados(‘ID_Produto’, ‘1234567890’);
LUCAS_SetDados(‘Quant’, ‘2’);
LUCAS_SetIncluir(False);

LUCAS_SetDados(‘ID_Produto’, ‘0987654321’);
LUCAS_SetDados(‘Quant’, ‘5’);
LUCAS_SetIncluir(False);

LUCAS_SetRequisitar;

Note que só foi preciso configurar o nome da tabela e a chave estrangeira (SetTabela e SetChaveEstrangeira) no primeiro item. Uma vez que o parâmetro do método SetIncluir recebeu o valor falso, o mesmo se encarrega de configurar estes valores (SetTabela e SetChaveEstrangeira) automaticamente, ficando por conta do Sistema Cliente informar apenas os campos e seus valores através do método SetDados. O método SetRequisitar envia as solicitações ao GABRIEL.

A figura 7 mostra o fluxograma para inclusão de dados.

Alterar registro

A figura 8 mostra o diagrama de seqüência da alteração de dados de uma tabela.

Tendo como base os dados da tabela 4, é mostrado a seguir como o Sistema Cliente deve efetuar a alteração neste registro.

O código que deverá ser executado pelo Sistema Cliente:

LUCAS_Clear;
LUCAS_SetTabela(‘Cliente’);
LUCAS_SetDados(‘Endereco’, ‘Rua Padre Cicero’);
LUCAS_SetAlterar(‘ID = 150’, True);

A figura 9 mostra o fluxograma para alteração de dados.

Excluir registro

A figura 10 mostra o diagrama de seqüência da exclusão de dados de uma tabela.

O código executado pelo Sistema Cliente deve ficar semelhante ao mostrado a seguir:

LUCAS_Clear;
LUCAS_SetTabela(‘Cliente’);
LUCAS_SetExcluir(‘ID = 150’, True);

A figura 11 mostra o fluxograma para exclusão de dados.

Consultar registro

A figura 12 mostra o diagrama de seqüência da consulta de dados de uma tabela.

O Sistema Cliente deve ficar com o código semelhante ao mostrado:

LUCAS_Clear;
LUCAS_SetTabela(‘Cliente’);
LUCAS_SetDados(‘ID’, ‘’);
LUCAS_SetDados(‘Nome’, ‘’);
LUCAS_SetDados(‘Endereco’, ‘’);
LUCAS_SetDados(‘Cidade’, ‘’);
LUCAS_SetDados(‘UF’, ‘’);
LUCAS_SetConsultar(‘ID between 100 and 1000’);

A figura 13 mostra o fluxograma para consulta de dados.

Fluxos alternativos e Funcionalidade

As solicitações de inclusão, alteração e exclusão podem ficar pendentes no LUCAS, bastando para isso informar como falso o parâmetro Requisitar dos métodos SetIncluir, SetAlterar e SetExcluir.

Para enviar as pendências ao GABRIEL o método SetRequisitar deve ser invocado de maneira direta ou indireta.  No primeiro caso o Sistema Cliente deve incorporar no seu código a chamada ao método SetRequisitar.  No outro caso basta informar o parâmetro Requisitar da do último método de solicitação (SetIncluir, SetAlterar e SetExcluir) como verdadeiro para invocar indiretamente o método SetRequisitar, que por sua vez envia as pendências ao GABRIEL.

Após o método SetRequisitar ser executado, o método Clear é invocado para apagar todas as solicitações enviadas.

O método SetChaveEstrangeira só é utilizado pelo LUCAS em conjunto com o método SetIncluir. Nos outros métodos (SetAlterar, SetExcluir e SetConsultar) ele é desprezado.

O segundo parâmetro do método SetDados (Valor) não é utilizado quando o método é usado em conjunto o SetConsultar.

Vantagens do LUCAS-GABRIEL

Embora existam outras propostas de distribuição de dados, o middleware LUCAS-GABRIEL apresenta um conjunto de benefícios não igualados pelos concorrentes:

A independência de linguagem de programação para o Sistema Cliente é um ponto forte do middleware, pois beneficiar sistemas legados.

Com a independência de SGBDR, as regras de acesso ao banco de dados, mantidas no Sistema Cliente, não precisam mudar quando o SGBDR for mudado.

A estrutura distribuída de armazenamento de dados aumenta o poder computacional de processamento, melhorando o desempenho quando comparado com uma estrutura centralizada.

O balanceamento dos dados entre os SGBDRs aumento o desempenho das solicitações feitas pelo Sistema Cliente. Uma vez que cada SGBDR tem apenas parte dos dados, o processamento das solicitações nesses dados exige um poder computacional menor.

O Sistema Cliente não precisa ficar preocupado em gerenciar os dados distribuídos, o middleware LUCAS-GABRIEL faz isso de maneira transparente.

Problemas de escalabilidade podem ser contornados incluindo novos servidores de dados na estrutura gerenciada pelo middleware LUCAS-GABRIEL.

Outra vantagem do middleware LUCAS-GABRIEL é a possibilidade de usá-lo como SOA em consultas entre empresas do mesmo grupo que retornem, por exemplo, o histórico de compras e pagamentos de um determinado cliente, conjuntura comum em empresas que tenham uma ou mais filiais, e que são obrigadas a utilizar soluções nem sempre práticas (consulta via telefone entre a matriz e as filiais, troca de mensagens instantâneas, etc.) para obter tais informações.

Implementações Previstas

O uso de esquemas pelo GABRIEL para gerenciar os dados e as instâncias dos SGBDRs possibilitando: