First of all, let me tell you about my old way of doing things in my database-powered applications. Let's imagine we're having a Group class and a Person class. The Group class should have a method, get_members(), which should return a list of Person objects;

Person.pm

package Group;
use strict;
use warnings;

use Person;

sub new {
    my $proto = shift;
    my $class = ref( $proto ) || $proto;

    my $self = {
        'group_id' =>  0,
        'name'     => '',

        '_members' => [],
    };
    bless( $self, $class );

    return $self;
}

sub get_members {
    my $self = shift;

    my $members = $dbh->selectcol_arrayref('SELECT person_id FROM grou
+p_member WHERE group_id = ' . $self->id());
    foreach my $person_id ( @{$members} ) {
        push( @members, Person->new($person_id) );
    }

    return \@members;
}

1;
[download]

The code above is quite truncated, but I'll bet you get the idea of how things are working.

The problem, however, is that a call to Person->new() generates a new SQL query (which reads in information about the wanted person record), and generally some extra "class overhead". After some though, I came up with the following solution:

Person.pm

package Person;
use strict;
use warnings;

use _Person;

sub read {
    my $self = shift;
    my $id   = shift || [];

    return [] unless ( $id );

    my @objects = ();

    my $stRead = $dbh->prepare('SELECT person_id, firstname, lastname 
+FROM person WHERE person_id IN (' . join(', ', @{$id}) . ')');
    $stRead->execute();
    while ( my ($person_id, $firstname, $lastname) = $stRead->fetchrow
+() ) {
        my $Person = _Person->new(person_id => $person_id,
                                  firstname => $firstname,
                                  lastname  => $lastname);
        push( @objects, $Person );
    }
    $stRead->finish();

    return ( wantarray ) ? @objects : pop( @objects );
}

1;
[download]

_Person.pm

package _Person;
use strict;
use warnings;

sub new {
    my $proto = shift;
    my $class = ref( $proto ) || $proto;

    my $self = {
        'person_id' =>  0,
        'firstname' => '',
        'lastname'  => '',
    };

    $self->_init( @_ );

    return $self;
}

sub _init {
    my $self = shift;
    my %args = @_;

    return unless ( %args );

    $self->person_id( $args{'person_id'} );
    $self->firstname( $args{'firstname'} );
    $self->lastname( $args{'lastname'} );
}

sub person_id {
    my $self = shift;
    my $data = shift;

    $self->{'person_id'} = $data if ( defined $data );

    return ( defined $self->{'person_id'} && $self->{'person_id'} =~ m
+,^\d+$, ) ? $self->{'person_id'} : 0;
}

sub firstname {
    # Same as person_id(), except the obvious
}

sub lastname {
    # Same as person_id() and firstname(), except the obvious
}

1;
[download]

Now, Group.pm's get_members() method would look something like this:

sub get_members {
    my $self = shift;

    my $members = $dbh->selectcol_arrayref('SELECT person_id FROM grou
+p_member WHERE group_id = ' . $self->id());

    return Person->read( $members );
}
[download]

This way, generating many Person objects requires only one call to the database.

Much of the code is very simplified, but I guess - and hope - you'll get the idea. I've become quite conservative in my OOP coding the last few years, and I have a feeling that the approach above is a bit hairy...?

Any comments, suggestions and general thoughts from those with more Perl wisdom than myself is highly appreciated!