Perl DBI alternativa a LongReadLen

Question

Mi piacerebbe sapere il modo più efficiente in termini di memoria per estrarre campi di dati arbitrariamente grandi da un db Oracle con Perl DBI. Il metodo che so usare è impostare l'attributo 'LongReadLen' sull'handle del database su qualcosa di sufficientemente grande. Tuttavia, la mia applicazione ha bisogno di tirare diverse migliaia di record, quindi fare questo in modo arbitrario è estremamente inefficiente.

Il doc suggerisce di eseguire una query in anticipo per trovare il valore potenziale più elevato e impostarlo.

$dbh->{LongReadLen} = $dbh->selectrow_array(qq{ 
    SELECT MAX(OCTET_LENGTH(long_column_name)) 
    FROM table WHERE ... 
}); 
$sth = $dbh->prepare(qq{ 
    SELECT long_column_name, ... FROM table WHERE ... 
}); 

Tuttavia, questo è ancora inefficiente, poiché i dati periferici non sono rappresentativi di ogni record. I valori più grandi sono superiori a un MB, ma il record medio è inferiore a un KB. Voglio essere in grado di estrarre tutta l'informazione (cioè senza troncamenti) mentre spreco il minor spazio possibile di memoria sui buffer inutilizzati.

Un metodo che ho considerato è quello di estrarre i dati in blocchi, ad esempio 50 record alla volta e impostare LongReadLen sulla lunghezza massima dei record di quel blocco. Un'altra soluzione, che potrebbe, ma non è necessario, basarsi sull'idea del blocco, sarebbe quella di eseguire il fork di un processo figlio, recuperare i dati e quindi uccidere il figlio (portando con sé la memoria sprecata). La cosa più meravigliosa sarebbe la possibilità di forzare i buffer DBI, ma non penso sia possibile.

Qualcuno ha affrontato un problema simile con un successo? Grazie per l'aiuto!

EDIT

Perl v5.8.8, DBI v1.52

Per chiarire: l'inefficienza di memoria è venuta da utilizzare 'LongReadLen' insieme {ora_pers_lob => 1} nel preparare. Utilizzando questo codice:

my $sql = "select myclob from my table where id = 68683"; 
my $dbh = DBI->connect("dbi:Oracle:$db", $user, $pass) or croak $DBI::errstr; 

print "before"; 
readline(*STDIN); 

$dbh->{'LongReadLen'} = 2 * 1024 * 1024; 
my $sth = $dbh->prepare($sql, {'ora_pers_lob' => 1}) or croak $dbh->errstr; 
$sth->execute() or croak('Cant execute_query '. $dbh->errstr . ' sql: ' . $sql); 
my $row = $sth->fetchrow_hashref; 

print "after"; 
readline(*STDIN); 

utilizzo della memoria residente "prima" è a 18MB e l'uso di "dopo" è a 30MB. Questo è inaccettabile per un numero elevato di query.

Answer 1

Le colonne sono con LOB di grandi dimensioni (CLOB o BLOB)? In tal caso, non è necessario utilizzare LongReadLen; DBD :: Oracle fornisce un'interfaccia di streaming LOB.

Quello che si vuole fare è bind the param come tipo ORA_CLOB o ORA_BLOB, che otterrà un "localizzatore LOB" restituito dalla query, anziché tex. Quindi si utilizza ora_lob_read insieme al localizzatore LOB per ottenere i dati. Ecco un esempio di codice che ha funzionato per me:

sub read_lob { 
    my ($dbh, $clob) = @_; 

    my $BLOCK_SIZE = 16384; 

    my $out; 
    my $offset = 1; 

    while (my $data = $dbh->ora_lob_read($clob, $offset, $BLOCK_SIZE)) { 
    $out .= $data; 
    $offset += $BLOCK_SIZE; 
    } 
    return $out; 
} 

Answer 2

ci penso in questo modo:

use Parallel::ForkManager 
use strict; 

# Max 50 processes for parallel data retrieving 
my $pm = new Parallel::ForkManager(50); 

# while loop goes here 
while (my @row = $sth->fetchrow_array) { 

# do the fork 
$pm->start and next; 

# 
# Data retreiving goes here 
# 

# do the exit in the child process 
$pm->finish; 
} 
$pm->wait_all_children; 

controllo Parallel::ForkManager in CPAN di saperne di più.