NAME

Data::Phrasebook::SQL - The SQL/DBI Phrasebook Model.

SYNOPSIS

    use Data::Phrasebook;
    use DBI;

    my $dbh = DBI->connect(...);

    my $book = Data::Phrasebook->new(
        class => 'SQL',
        dbh   => $dbh,
        file  => 'queries.txt',
    );
    my $q = $book->query( 'find_author', {
            author => "Lance Parkin"
        });
    while ( my $row = $q->fetchrow_hashref ) {
        print "He wrote $row->{title}\n";
    }
    $q->finish;

queries.txt:

    find_author=select title,author from books where author = :author

DESCRIPTION

In order to make use of features like placeholders in DBI in conjunction with phrasebooks, it's helpful to have a phrasebook be somewhat more aware of how DBI operates. Thus, you get Data::Phrasebook::SQL.

Data::Phrasebook::SQL has knowledge of how DBI works and creates and executes your queries appropriately.

CONSTRUCTOR

new

Not to be accessed directly, but via the parent the Data::Phrasebook manpage, by specifying the class as SQL.

Additional arguments to those described in the Data::Phrasebook::Generic manpage are:

• dbh - a DBI database handle.

METHODS

dbh

Set, or get, the current DBI handle.

query

Constructs a the Data::Phrasebook::SQL::Query manpage object from a template. Takes at least one argument, this being the identifier for the query. The identifier is used as a key into the phrasebook file. A second argument can be provided, which is an optional hashref of key to value mappings.

If phrasebook has a YAML source looking much like the following:

    ---
    find_author:
        sql: select class,title,author from books where author = :author

You could write:

    my $q = $book->query( 'find_author' );

    OR

    my $q = $book->query( 'find_author', {
        author => 'Lance Parkin'
    } );

    OR

    my $author = 'Lance Parkin';
    my $q = $book->query( 'find_author', {
        author => \$author,
    } );

    # sql  = select class,title,author from books where author = ?
    # args = 'Lance Parkin'

In the above examples, the parameters are bound to the SQL using the bind parameters functionality. This is more efficient in most cases where the same SQL is reused with different values for fields.

However, not all SQL statements just need to bind parameters, some may require the ability to replace parameters, such as a field list.

    ---
    find_author:
        sql: select :fields from books where author = :author

    my $q = $book->query( 'find_author', 
        replace => { fields => 'class,title,author' },
        bind    => { author => 'Lance Parkin' }
        );

    # sql  = select class,title,author from books where author = ?
    # args = 'Lance Parkin'

In all instances, if the SQL template requested does not exist or has no definition, then an error will be thrown.

Consult the Data::Phrasebook::SQL::Query manpage for what you can then do with your returned object.

For reference: the bind hashref argument, if it is given, is given to the query object's order_args and then args methods.

=cut

sub query { my ($self,$id,@args) = @_;

        $self->store(3,"->query IN")    if($self->debug);

    my $map = $self->data($id);
    croak "No mapping for '$id'" unless($map);
    my $sql;

    if($self->debug) {
                $self->store(4,"->query id=[$id]");
                $self->store(4,"->query map=[$map]");
        }

    if(ref $map eq 'HASH') {
        croak "No SQL content for '$id'." unless exists $map->{sql}
            and defined $map->{sql};
        $sql = $map->{sql};
    } else {
        $sql = $map;    # we assume sql string only
    }

    unshift @args, 'bind'   if(scalar(@args) == 1); # default is to bind parameters

    if($self->debug) {
        $self->store(4,"->query BEFORE methods");
        $self->store(4,"->query sql=[$sql]");
        $self->store(4,"->query args=[".$self->dumper(\@args)."]");
    }

    my (%args,$params,@order);
    while(@args) {
        # go backwards in case there are duplicate keys
        my $args   = pop @args;
        my $method = pop @args;

        for(keys %$args) {
            $args{$_}->{method} = $method;
            $args{$_}->{value} = $args->{$_};
        }

        $params = $args if($method eq 'bind');
            }

    my $delim_RE = $self->delimiters();
    $sql =~ s{$delim_RE}[
                {
                    if(defined $args{$1} && $args{$1}->{method} eq 'replace') {
                        $args{$1}->{value};
                    } else {
                        push @order, $1;
                        "?"
                    }
                };
            ]egx;

    if($self->debug) {
        $self->store(4,'->query AFTER methods');
        $self->store(4,"->query sql=[$sql]");
        $self->store(4,'->query order=['.join(',',@order).']');
        $self->store(4,'->query params=['.$self->dumper($params).']');
    }
    
    my $q = Data::Phrasebook::SQL::Query->new(
        sql => $sql,
        order => \@order,
        dbh => $self->dbh,
    );
    $q->args( $q->order_args( $params ) ) if($params);
    return $q;
    }

1;

__END__

SEE ALSO

the Data::Phrasebook manpage, the Data::Phrasebook::Generic manpage, the Data::Phrasebook::SQL::Query manpage.

SUPPORT

Please see the README file.

AUTHOR

  Original author: Iain Campbell Truskett (16.07.1979 - 29.12.2003)
  Maintainer: Barbie <barbie@cpan.org> since January 2004.
  for Miss Barbell Productions <http://www.missbarbell.co.uk>;.

COPYRIGHT AND LICENSE

  Copyright (C) 2003 Iain Truskett.
  Copyright (C) 2004-2007 Barbie for Miss Barbell Productions.

  This library is free software; you can redistribute it and/or modify
  it under the same terms as Perl itself.

The full text of the licenses can be found in the Artistic and COPYING files included with this module, or in the perlartistic manpage and the perlgpl manpage in Perl 5.8.1 or later.