Acessando Banco de Dados - Mysql e Postgresql

Accessing Database - Mysql and Postgresql

Luiz Sérgio Araújo Morais - netmoraisap@gmail.com

Resumo

Este artigo tem o objetivo de demonstrar, de um modo prático, que é possível por meio de interfaces simples acessar e manipular dados nos bancos mais populares, utilizando recursos básicos e linguagens comuns, sem a necessidade de drives especiais, que geralmente são pagos, possibilitando um custo de desenvolvimento e manutenção reduzidos e padronizados.

Metodologia

Para materializar o proposto será construída uma "interface servidora" em C, utilizando os recursos da biblioteca "mysqlclient", composta de funções que permitem o acesso ao banco de dados Mysql. Veja: Usando MySQL na linguagem C. É importante destacar que existem soluções análogas para outros bancos de dados, tais como a biblioteca "libpq" do Postgresql, para detahes veja: Acessando PostgreSQL com C.

Do lado da aplicação serão construídos duas "consoles clientes", uma em Cobol e outra com o Bash, a fim de demonstrar a independência da metodologia com respeito à linguagem utilizada. As "consoles" representam o lado da aplicação, e podem ser vistas como os "Controle de Clientes, de Fornecedores, etc". Já a comunicação entre os módulos cliente e servidor será feita através de um sistema de mensagens baseado em arquivos, mas pode ser substituído por métodos mais eficientes, tais como: chamada direta da interface pelo módulo cliente, passando e recebendo as informações via memória, tal como por exemplo no caso do Cobol, "call interface using solicitação retorno", ou utilizando um protocolo de envio e recebimento de dados, como Tcp. A seguir, procedimentos de instalação encontrados em "dem_pt.tar.gz".

Requisitos

Distribuição Linux, com o Bash, Mysql com Mysqlclient e Cobol Micro Focus instalados.

Procedimentos

Copiar para uma pasta os arquivos descritos a seguir:

1. demosh - script para executar a aplicacao em bash

#!/bin/bash

# demosh - script utlizando bash

# identifica o id do processo

idproc=$$;

# cria os arquivos

mkfifo -m 777 democ-$idproc ; > demoi-$idproc ; > demoo-$idproc

> demof-$idproc ; chmod 777 demoi-$idproc demoo-$idproc demof-$idproc

# displara a interface servidora

demosrv.exe $idproc &

# executa a aplicacao cliente

sh ./democon.sh $idproc ;

# remove os arquivos

if test democ-$idproc ; then rm -f democ-$idproc ; fi

if test -f demoi-$idproc ; then rm -f demoi-$idproc ; fi

if test -f demoo-$idproc ; then rm -f demoo-$idproc ; fi

if test -f demof-$idproc ; then rm -f demof-$idproc ; fi

2. democob - script em bash para executar a aplicação em cobol

#!/bin/bash

# democob - script utlizando cobol

# identifica o id do processo

idproc=$$;

# cria os arquivos

mkfifo -m 777 democ-$idproc ; > demoi-$idproc ; > demoo-$idproc

> demof-$idproc ; chmod 777 demoi-$idproc demoo-$idproc demof-$idproc

# displara a interface servidora

demosrv.exe $idproc &

# executa a aplicacao cliente

cobrun democon.int $idproc,,, ;

# remove os arquivos

if test democ-$idproc ; then rm -f democ-$idproc ; fi

if test -f demoi-$idproc ; then rm -f demoi-$idproc ; fi

if test -f demoo-$idproc ; then rm -f demoo-$idproc ; fi

if test -f demof-$idproc ; then rm -f demof-$idproc ; fi

3. democon.sh - script da "console cliente" em bash

#!/bin/bash

# democon

# recebe id do processo

idproc=$1;

mpro="bash-mysql: informe comando ou f para encerrar"

# prepara nomes de arquivos

democ=`echo "democ-$idproc"`

demoi=`echo "demoi-$idproc"`

demoo=`echo "demoo-$idproc"`

demof=`echo "demof-$idproc"`

clear

while true ; do

# recebe comando sql

echo "$mpro"; read ope

# grava no arquivo de solicitacoes

echo "$ope" > $demoi

# libera servidor

echo > $democ

# verifica solicitacao de fim

if [ "$ope" == "f" ] ; then break ; fi

# aguarda o servidor

read < $democ

# le arquivo de estado e exibe

echo "estado" ; cat $demof

# le arquivo de saida e exibe

echo "resultado" ; cat $demoo

done

4. democon.cbl - fonte da "console cliente" em cobol

identification division.

program-id. democon.

environment division.

configuration section.

special-names.

console is crt

decimal-point is comma.

input-output section.

file-control.

select opee assign to opee-dat

organization line sequential status est.

select opes assign to opes-dat

organization line sequential status est.

select opef assign to opef-dat

organization line sequential status est.

select opec assign to opec-dat

organization line sequential status est.

data division.

file section.

fd opee

record is varying 1 to 8192 depending on treg.

01 ropee pic x(8192).

fd opes

record is varying 1 to 8192 depending on treg.

01 ropes pic x(8192).

fd opef.

01 ropef pic x(35).

fd opec.

01 ropec pic x.

working-storage section.

01 est pic xx.

01 opee-dat pic x(35) value space.

01 opes-dat pic x(35) value space.

01 opef-dat pic x(35) value space.

01 opec-dat pic x(35) value space.

01 ope pic x(8192).

01 treg pic 9(4).

01 preg pic 9(4).

01 nproc pic x(35) value space.

01 cmd pic x(80).

01 mpro pic x(78).

01 par pic x(256) value space.

procedure division.

inicio.

accept par from command-line.

*******recebe id do processo

unstring par delimited by "," into nproc.

display space upon crt.

move "cobol-mysql: informe comando ou f para encerrar"

to mpro.

*******prepara nomes de arquivos

move space to opee-dat string "demoi-" nproc

delimited by " " into opee-dat.

move space to opes-dat string "demoo-" nproc

delimited by " " into opes-dat.

move space to opef-dat string "demof-" nproc

delimited by " " into opef-dat.

move space to opec-dat string "democ-" nproc

delimited by " " into opec-dat.

*******recebe comando sql

proc.

display mpro upon console.

move space to ope accept ope from console.

*******grava no arquivo de solicitacoes

abr-opee.

open output opee.

if est = "9a" close opee go to abr-opee.

if est not = "00"

display "erro na abertura da entrada"

upon console stop run.

move ope to ropee.

perform ver-topee thru fim-topee.

write ropee.

if est not = "00"

display "erro na gravacao da entrada"

upon console stop run.

close opee.

*******libera servidor

lib-srv.

open output opec.

if est = "9a" close opec go to vrf-fim.

if est not = "00"

display "erro na abertura do controle"

upon console stop run.

close opec.

*******verifica solicitacao de fim

vrf-fim.

if ope = "f" stop run.

*******aguarda o servidor

esp-srv.

open input opec.

if est = "9a" close opec go to esp-srv.

if est not = "00"

display "erro na abertura do controle"

upon console stop run.

ler-opec.

read opec end close opec go to abr-opef.

if est = "9d" go to ler-opec.

if est not = "00"

display "erro na leitura do controle"

upon console stop run.

close opec.

*******le arquivo de estado

abr-opef.

open input opef.

if est = "9a" close opef go to abr-opef.

if est not = "00"

display "erro na abertura do estado"

upon console stop run.

ler-opef.

read opef end close opef go to ler-opes.

if est = "9d" go to ler-opef.

if est not = "00"

display "erro na leitura do estado"

upon console stop run.

display "estado" upon console.

display ropef upon console.

close opef.

*******le arquivo de saida

abr-opes.

open input opes.

if est = "9a" close opes go to abr-opes.

if est not = "00"

display "erro na abertura da saida"

upon console stop run.

display "resultado" upon console.

ler-opes.

read opes end go to clo-opes.

if est = "9d" go to ler-opes.

if est not = "00"

display "erro na leitura da saida"

upon console stop run.

move ropes to ropee.

perform ver-topee thru fim-topee.

*******exibe a saida

display ropes (1:treg) upon console.

go to ler-opes.

*******fecha e retorna

clo-opes.

close opes go to proc.

*******verifica o tamanho p/ gravacao

ver-topee.

if ropee = space move zero to treg go to fim-topee.

move 0128 to treg.

if ropee (0129:8064) = space go to ver-topee1.

move 0256 to treg.

if ropee (0257:7936) = space go to ver-topee1.

move 0512 to treg.

if ropee (0513:7680) = space go to ver-topee1.

move 1024 to treg.

if ropee (1025:7168) = space go to ver-topee1.

move 2048 to treg.

if ropee (2049:6144) = space go to ver-topee1.

move 4096 to treg.

if ropee (4097:4096) = space go to ver-topee1.

move 8192 to treg.

ver-topee1.

if treg = zero go to fim-topee.

if ropee (treg:1) not = space go to fim-topee.

subtract 1 from treg go to ver-topee1.

fim-topee.

exit.

5. demosrv.c - fonte da "interface servidora" em c

/* demosrv */

#include <my_global.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <mysql.h>

MYSQL conn; MYSQL_RES *resp; MYSQL_FIELD *cpo; MYSQL_ROW lin;

char papl [35] = "", ent [8192] = "", cmd [8192] = "";

char opeedat [35] = "", opesdat [35] = "";

char opefdat [35] = "", opecdat [35] = "";

char terr [5] = "", cerr [5] = "", merr [70] = "", serr [70] = "";

char scmd [8192] = "";

int nlin, ncol, nerr, ind, res;

char m00501 [70] = "MENS: retorno nulo";

char eZZ001 [70] = "ERRO: entrada nao aberta";

char eZZ002 [70] = "ERRO: entrada nao lida";

char eZZ003 [70] = "ERRO: processo nao informado";

char eZZ004 [70] = "ERRO: conexao nao estabelecida";

char eZZ005 [70] = "ERRO: estado nao aberto";

char eZZ006 [70] = "ERRO: estado nao gravado";

char eZZ007 [70] = "ERRO: saida nao aberta";

char eZZ008 [70] = "ERRO: saida nao gravada";

char eZZ011 [70] = "ERRO: controle nao aberto";

char eZZ012 [70] = "ERRO: controle nao lido";

FILE *opee, *opes, *opef, *opec;

main (argc, argv)

int argc; char *argv[];

{

inicio:

/* verifica id do processo */

if (argc > 0 && argv [1] != NULL) {strcpy (papl, argv [1]);}

else {strcpy (cerr, "ZZ003"); strcpy (merr, eZZ003); goto erro;}

/* conecta banco */

mysql_init (&conn); mysql_real_connect (&conn, "localhost",

"demo", "demo", "demo", 0, NULL, 0); nerr = mysql_errno (&conn);

if (nerr != 0 )

{strcpy (cerr, "ZZ004"); strcpy (merr, eZZ004); goto erro;}

/* prepara nomes de arquivos */

strcpy (opeedat, "demoi-"); strcat (opeedat, papl);

strcpy (opesdat, "demoo-"); strcat (opesdat, papl);

strcpy (opefdat, "demof-"); strcat (opefdat, papl);

strcpy (opecdat, "democ-"); strcat (opecdat, papl);

proc0:

/* espera cliente */

strcpy (ent, ""); opec = fopen (opecdat, "r");

if (opec == NULL || ferror (opec))

{strcpy (cerr, "ZZ011"); strcpy (merr, eZZ011); goto erro;}

fgets (ent, 1, opec);

if (ferror (opec))

{strcpy (cerr, "ZZ012"); strcpy (merr, eZZ012); goto erro;}

fclose (opec);

/* abre e le arquivo entrada */

strcpy (ent, ""); opee = fopen (opeedat, "r+");

if (opee == NULL || ferror (opee))

{strcpy (cerr, "ZZ001"); strcpy (merr, eZZ001); goto erro;}

proc1:

fgets (ent, 8192, opee);

if (ferror (opee))

{strcpy (cerr, "ZZ002"); strcpy (merr, eZZ002); goto erro;}

fclose (opee);

if (strncmp ("f", ent, 1) == 0 && strlen (ent) == 2) {goto fim;}

/* executa o comando */

strcpy (cmd, ent); mysql_query (&conn, cmd);

/* verifica execucao */

nerr = mysql_errno (&conn);

resp = mysql_store_result (&conn);

if (resp == NULL) {nlin = 0;} else

{nlin = mysql_num_rows (resp);}

if (nerr == 0 && nlin != 0) {strcpy (cerr, "00000");}

if (nerr == 0 && nlin == 0) {strcpy (cerr, "00501");}

if (nerr != 0) {sprintf (terr, "%i", nerr);

strcpy (cerr, "0"); strcat (cerr, terr);}

/* abre e escreve estado */

opef = fopen (opefdat, "w+");

if (opef == NULL || ferror (opef))

{strcpy (cerr, "ZZ005"); strcpy (merr, eZZ005); goto erro;}

strcpy (serr, cerr); strcat (serr, "\n") ; fputs (serr, opef);

if (ferror (opef))

{strcpy (cerr, "ZZ006"); strcpy (merr, eZZ006); goto erro;}

fclose (opef);

/* abre e escreve saida */

opes = fopen (opesdat, "w+");

if (opes == NULL || ferror (opes))

{strcpy (cerr, "ZZ007"); strcpy (merr, eZZ007); goto erro;}

/* execucao com saida nula */

if (strncmp ("00501", cerr, 5) == 0)

{strcpy (serr, m00501); strcat (serr, "\n"); fputs (serr, opes);

if (ferror (opes))

{strcpy (cerr, "ZZ008"); strcpy (merr, eZZ008); goto erro;}

fclose (opes) ; goto proc2;}

/* execucao com erro */

if (strncmp ("00000", cerr, 5) != 0)

{strcpy (serr, "ERRO: "); strcat (serr, mysql_error (&conn));

strcat (serr, "\n"); fputs (serr, opes);

if (ferror (opes))

{strcpy (cerr, "ZZ008"); strcpy (merr, eZZ008); goto erro;}

fclose (opes) ; goto proc2;}

/* execucao com saida */

if (resp == NULL) {fclose (opes); goto proc2;}

while ((lin = mysql_fetch_row (resp)) != NULL)

{cpo = mysql_fetch_fields (resp); strcpy (scmd, "");

ncol = mysql_num_fields (resp);

for (ind = 0; ind < ncol; ind++)

{strcat (scmd, lin [ind]);

if (cpo [ind].length < 256 &&

strlen (lin [ind]) < cpo [ind].length)

{res = cpo [ind].length - strlen (lin [ind]);

while (res != 0) {strcat (scmd, " "); res--;}}}

strcat (scmd, "\n"); fputs (scmd, opes);

if (ferror (opes))

{strcpy (cerr, "ZZ008"); strcpy (merr, eZZ008); goto erro;}}

fclose (opes);

proc2:

/* libera objeto e cliente */

mysql_free_result (resp);

opec = fopen (opecdat, "w");

if (opec == NULL || ferror (opec))

{strcpy (cerr, "ZZ011"); strcpy (merr, eZZ011); goto erro;}

fclose (opec); goto proc0;

fim:

/* desfaz a conexao */

mysql_close (&conn);

exit (0);

erro:

/* abre e escreve estado */

opef = fopen (opefdat, "w+");

if (opef == NULL || ferror (opef)) {goto dspe;}

strcpy (serr, cerr); strcat (serr, "\n") ; fputs (serr, opef);

if (ferror (opef)) {goto dspe;}

fclose (opef);

/* abre e escreve saida */

opes = fopen (opesdat, "w+");

if (opes == NULL || ferror (opes)) {goto dspe;}

strcpy (serr, merr); strcat (serr, "\n"); fputs (serr, opes);

if (ferror (opes)) {goto dspe;}

fclose (opes) ; goto fim;

dspe:

printf ("%s\n%s\n", cerr, merr); goto fim;

}

6. demo.txt - tabela demo para ser carregada no banco

000001|MUOIL DTMANGOIS DU SALVU

000002|UPTLTNAT BUCASCU DT NUSEAMINCT

000003|U E PIRIARU

000004|U G V RIPRISINCUETIS I VINDUS

000005|U GUREAU LUJU LCDU

000006|UNDRI GTNSULVIS DI TLAVIARU

000007|U M ERASCTVUT & ERASCTVUT LCDU

000008|PRIFIACORU MONAEAPUL DI EOBUCU

000009|U P DI EUSCRT

000010|MURAT LTCCT

000011|U PIQOINANU EINCRT ISCICAET S/

000012|U CRUNSPTRCUDTRU I URROMUDTRU

000013|U CRABONU DI SUNCTS JTRNUL I I

000014|E S S

000015|JTSI GTNEULVIS

000016|U DU INEURNUEUT BIRNURDT & EAU

000017|U. FIRRIARU NICT

000018|JTSI RTGIRAT DI UMTRAM

000019|U.P. EURVULHT CRUNSPTRCIS LCDU

000020|U S KUMURUOSKUS

7. Abra uma sessão no Linux

7.1. Crie um usuario "demo" no Mysql

mysql -u root -p

grant all privileges on *.* to demo@localhost identified by 'demo';

flush privileges;

quit

7.2. Acesse o mysql como "demo" e crie o banco "demo"

mysql -u demo -p

create database demo;

quit

7.3. Crie a tabela demo e carregue demo.txt

mysql -u demo -p demo

create table demo (codigo char (0006), descricao char (0030));

load data infile 'pwd/demo.txt' into table demo fields terminated by '|' (codigo, descricao);

substitua "pwd" pelo "encaminhamento de sua pasta/diretorio, i.e /home/abc/..."

7.4. Verifique se os dados foram carregados e encerre

select * from demo limit 5;

codigo descricao

000001 MUOIL DTMANGOIS DU SALVU

000002 UPTLTNAT BUCASCU DT NUSEAMINCT

000003 U E PIRIARU

000004 U G V RIPRISINCUETIS I VINDUS

000005 U GUREAU & LUJU LCDU

quit

7.5. Compile a "inteface em c"

gcc demosrv.c -l mysqlclient -o demosrv.exe

7.6. Compile a "console em cobol"

cob -iv democon.cbl

7.7. Execute a aplicação em cobol ou bash

sh ./democob ou sh ./demosh

Informe um sql certo:

bash ou cobol-mysql: informe comando ou f para encerrar

select * from demo limit 10

estado

00000

resultado

000001MUOIL DTMANGOIS DU SALVU

000002UPTLTNAT BUCASCU DT NUSEAMINCT

000003U E PIRIARU

000004U G V RIPRISINCUETIS I VINDUS

000005U GUREAU & LUJU LCDU

000006UNDRI GTNSULVIS DI TLAVIARU

000007U M ERASCTVUT & ERASCTVUT LCDU

000008PRIFIACORU MONAEAPUL DI EOBUCU

000009U P DI EUSCRT

000010MURAT LTCCT

Informe um sql com retorno nulo:

bash ou cobol-mysql: informe comando ou f para encerrar

select * from demo where codigo > '90000'

estado

00502

resultado

MENS: retorno nulo

Informe um sql errado:

bash ou cobol-mysql: informe comando ou f para encerrar

comando errado

estado

01064

resultado

ERRO: You have an error in your SQL syntax; check the manual that corresponds to

your MySQL server version for the right syntax to use near 'comando errado' at

line 1

Solicite o encerramento:

bash ou cobol-mysql: informe comando ou f para encerrar

f

Utilização

A seguir, algumas propostas para utilização e melhoria da metodologia em sua totalidade, em parte ou com ajustes e otimizações:

Admite melhorias, como as já descritas, em relação ao meio de comunicaçao entre módulos, por meio do uso de memória compartilhada, utilização do protocólo Tcp, isoladamente ou combinados, isto é, a mesma interface pode trabalhar simultaneamente com mais de uma forma de comunicação, e esta forma pode ser decidida em tempo de execução.

Permite que aplicações construidas com linguagens distintas acessem o mesmo banco de dados. Isto pode ser observado, executando duas sessões simultâneas, uma com o Bash, "demosh" e outra com o Cobol, "democob" acessando o mesmo banco e tabela.

Viabiliza o acesso a bancos de dados diferentes pela mesma aplicação. Basta que consideremos por exemplo que sejam construidas duas interfaces servidoras distintas, uma para Mysql, já demonstrada, e outra para Postgresql, com a mesma metodologia, e que as duas interfaces, de acordo com algum critério pre-estabelecido, nome de banco por exemplo, use o Mysql ou Postgresql simultaneamente.

Consequentemente é possivel também a combinação das duas caracteristicas anteriores, ou seja multiplas aplicações com multiplos bancos,

facilitando por exemplo, a construção de aplicações como "e-commerce", onde queremos disponibilizar aos utilizadores uma informação que

quase sempre é oriunda de várias aplicações e vários bancos de dados diferentes, condensados em uma visão única.

Uso de esquemas middleware para a camada de acesso a dados, ou seja, a solução pode prever um lugar comum, um barramento de integração, local onde todos os sistemas envolvidos, por meio de por exemplo uma "metalinguagem de acesso", enviam e recebem suas requisições de acesso e manipulação de dados, de forma totalmente independente de qual banco irá providenciar as informações, veja uma solução análoga, com relação ao desenvolvimento de Interface Web para Usuários em: Migração de Aplicações para Ambiente Web.

Ainda com relação à "metalinguagem de acesso", sua utilização permite com segurança o uso das famosas "extenções sql", que são temidas pelos desenvolvedores pois são específicas, mas têm a vantagem de demonstrarem maior eficiência no seu uso em um determinado banco de dados.

Em relação especificamente ao Cobol Microfocus, os "reads" e "writes" podem ser vistos, do ponto de vista do Sql, como uma "metalinguagem". É possível então, construir um middleware para acesso à dados, com um módulo que intercepte as chamados ao "extfh", mecanismo de acesso nativo do sistema, e mapeie estes os comandos para os "equivalentes" em sql. O resultado prático desta metodologia encontra-se em "Testes" a seguir.

Testes

Para execuçao de testes práticos com esta metodologia foi selecionada uma aplicação real composta de 27 tabelas, com aproximadamente 2 milhões de registros/linlhas instalada numa distribução Linux do mesmo perfil da demonstração já proposta obtendo-se o seguintes resultados:

1. Tempo de conversão dos programas da aplicação de Cobol para banco de dados Mysql e Postgressql - zero.

De fato, não existe tempo de conversão. Um programa escrito em Cobol intercepta as chamadas do "extfh" e com informações de que está em um "ambiente Mysql" por exemplo, mapeia com base numa tabela, veja abaixo, os "reads" e "whites" para os "selects" e "inserts", de acordo com as colunas descritas a seguir:

Op: código da operação; Descrição; Opm: modo de abertura; Lcm: modo de bloqueio; Etapa: etapas de mapeamento, por exemplo. cob - comandos cobol, lk? - sqls de controle de desbloqueio, bloqueio e liberação, sop - sql de abertura, sql - sql propriamente dito (read, write,...), etc; Mf ou Sql: resumo do comando Cobol ou Sql; Condições: condições esperadas com o resultado do comando; Sql c/r e s/r: código de retorno do banco de dados resultante das operações com e sem dado retornado; e St Mf: file-status padrão Micro Focus a ser retornado.

Tabela de mapeamento comandos Cobol MIcro Focus para Sql Mysql/Postgresql

2. Tempo de conversão dos dados de arquivos Cobol para banco de dados Mysql e Postgressql - média de 9 minutos.

Esta fase ocorre apenas na "carga" do sistema ou quando for necessária alguma alteração na estrutura das tabelas. Consiste da criação automática das descrições das tabelas, com base nas descrições dos arquivos Cobol pré-existentes e posterior cópia dos dados.

3. Na utilização normal do sistema, comparando os tempos de acesso do Cobol com o Mysq e Postgresq, nas opções de uso diário, tais como, manutenção da base, consultas e relatórios que em geral trabalham com um número reduzido de registros/linhas, a diferença é imperceptível. Já nos casos nos quais estão envolvidos grandes quantidades de resgistros/linhas, tais como, processos gerais de cálculo, nota-se lentidão nos acessos às tabelas dos bancos de dados. Para que se tenha uma idéia, um processo de simples cópia de uma tabela de 40.000 registros/linhas que no Cobol leva cerca de 6,40 segundos, no Mysql obtemos 245,34 segundos e no Postgresql 283,56 segundos o que é uma diferença bastante significativa.

Conclusões

A metodologia, embora atraente nas questões de custo e tempo de implantação e manutenção, facilidade de conversão e integração, não se comporta adequadamente para grandes volumes, no caso de conversão automática utilizando o Cobol. Ao se observar o ciclo de cópia, como o já apresentado, nota-se que dentro de cada ciclo, a fase que consome mais tempo é a de comunicação entre os módulos "mapeador cliente" e a "interface servidora" utilizando o sistema de mensagens em arquivos. Acredita-se que a adoção de outras técnicas de comunicação, substituindo ou combinando com a já existente, tais como as já mencionadas, venham minimizar bastante o problema. Por outro lado, este é um problema que ocorre em uma situação bastante específica, ou seja, no caso de utilização com o Cobol nas condições de conversão automática do sistema. Deve-se considerar que as aplicações escritas em Cobol têm em geral por natureza a característica de acessar os registros/linhas um a um, mesmo para grandes volumes, já os Bancos de Dados, acessados com o Sql trabalham naturalmente mais rápido quando os comandos para grandes volumes já forem escritos com a idéia de um conjunto de linhas de uma só vez. Nada impede portanto a utilização da metodologia, com qualquer linguagem, mesmo Cobol, na condição em que os procedimentos para grandes volumes tenham comandos Sqls específicos, o que implicaria na re-escrtita do código, portanto não se aproveitando na sua totalidade os benefícios apontados na conversão automática das aplicações.

Referências

1. Usando MySQL na linguagem C de Ricardo R Lucca. Usando MySQL na linguagem C

2. Acessando PostgreSQL com C - Poleto. Acessando PostgreSQL com C

3. Migração de Aplicações para Ambiente Web - Luiz Sérgio Araújo Morais. Migração de Aplicações para Ambiente Web - Uma Abordagem Prática