File Coverage

blib/lib/DBIx/MultiDB.pm

Criterion	Covered	Total	%
statement	38	59	64.4
branch	6	12	50.0
condition	6	12	50.0
subroutine	9	10	90.0
pod	5	5	100.0
total	64	98	65.3

package DBIx::MultiDB;

use warnings;
use strict;

use Carp;
use Data::Dumper;
use DBI;

our $VERSION = '0.06';

sub new {
    my ( $class, %param ) = @_;

    bless { base => {%param}, left_join => [] }, $class;
}

*attach = \&left_join;
*join   = \&left_join;

sub left_join {
    my ( $self, %param ) = @_;

    my $dbh = $param{dbh}
      || DBI->connect( $param{dsn}, $param{user}, $param{password}, { RaiseError => 1 } );

    # the preferred approach is to list the primary key on this table ("key")
    # and the foreign key in the base table ("referenced_by").

    # alternatively, we can specify the foreign key in the base table ("key")
    # and which key it "references" in this table ("references"):
    if ( $param{references} and $param{key} ) {
        $param{referenced_by} = delete $param{key};
        $param{key}           = delete $param{references};
    }

    warn "Retrieving left_join data ($param{key} referenced by $param{referenced_by})...\n" if $param{VERBOSE};

    # put everything in memory
    my $data = $dbh->selectall_hashref( $param{sql}, $param{key}, );

    push @{ $self->{left_join} }, { %param, data => $data };

    if ( $param{VERBOSE} and $param{VERBOSE} >= 2 ) {
        require Devel::Size;
        warn "Calculating memory usage...\n";
        my $memory_usage = sprintf( '%1.2f', ( Devel::Size::total_size($data) / ( 1024 * 1024 ) ) );    # MB
        warn "Memory usage: $memory_usage MB\n\n";
    }

    return;
}

sub prepare {
    my ( $self, $sql, $attr ) = @_;

    my $dbh = $self->{base}->{dbh}
      || DBI->connect( @{ $self->{base} }{ 'dsn', 'user', 'password' }, { RaiseError => 1 } );

    my $sth = $dbh->prepare($sql);

    if ( defined $attr ) {
        $self->{base}->{$_} = $attr->{$_} for keys %{$attr};
    }

    $self->{base}->{sth} = $sth;

    return $self;
}

sub execute {
    my $self = shift;

    if ( !$self->{base}->{sth} ) {
        $self->prepare( $self->{base}->{sql} );
    }

    $self->{base}->{sth}->execute();

    return $self;
}

sub fetchrow_hashref {
    my $self = shift;

    # get the base row
    my $row = $self->{base}->{sth}->fetchrow_hashref();

    return if !$row;

    # now we are going to attach the left_join data

    my %row = %{$row};

    for my $join ( @{ $self->{left_join} } ) {
        my $base_key   = $join->{referenced_by};
        my $base_value = $row{$base_key};

        # now, look up the base value in the cached join data...
        for my $joined_key ( keys %{ $join->{data}->{$base_value} } ) {
            my $joined_value = $join->{data}->{$base_value}->{$joined_key};
            $row{$joined_key} = $joined_value;
        }
    }

    return \%row;
}

1;

__END__