File Coverage

blib/lib/DBIx/Core/Handle/ReturnValue.pm

Criterion	Covered	Total	%
statement	9	22	40.9
branch	0	14	0.0
condition	0	6	0.0
subroutine	3	4	75.0
pod	1	1	100.0
total	13	47	27.6

package DBIx::Core::Handle::ReturnValue;

use strict;
use warnings;

use parent qw(Dancer::Plugin::Database::Core::Handle);

our $VERSION = '0.01';

=head1 NAME

DBIx::Core::Handle::ReturnValue - subclassed DBI connection handle

=head1 DESCRIPTION

Subclassed DBI connection handle with added convenience features. In addition
to the features added by Dancer::Plugin::Database::Core::Handle, this module
adds a return value to C if requested.


=head1 SYNOPSIS

Set this Handle in you app config:


    plugins:
        Database:
            driver: 'Pg'
            database: 'postgres'
            host: '172.17.0.3'
            port: 5432
            username: 'postgres'
            password: 'pwd'
            dbi_params:
                RaiseError: 1
                AutoCommit: 1
            log_queries: 1
            handle_class: 'DBIx::Core::Handle::ReturnValue'



  # in your Dancer app:
  my $id = database->quick_insert($tablename, \%data, { last_insert_id => [ ... ] });

  my $uuid = database->quick_insert('mytable', { foo => 'Bar', baz => 5 }, { returning => 'entry_uuid' });


=head1 Added features

A C object is a subclassed L L
database handle, with the following added convenience methods in addition to
those added by Dancer::Plugin::Database::Core::Handle:

=over 4

=item quick_insert

  database->quick_insert('mytable', { foo => 'Bar', baz => 5 }, { returning => 'id' });

This is a PostgreSQL-specific functionality which is very flexible and easy. It is
especially useful when you use UUIDs as primary keys which are not returned by the
normal last_insert_id functionality.

  database->quick_insert('mytable', { foo => 'Bar', baz => 5 }, { last_insert_id => [ .. ] });

The C variant calls the DBI method C with the parameters
given in the array ref above. It depends on your database driver what needs to be filled
in there.

If no third parameter is given, the call acts like defined by
Dancer::Plugin::Database::Core::Handle

=back

=cut

sub quick_insert {
    my ($self, $table_name, $data, $options) = @_;
    my $type = 'INSERT';
    if (ref $options ne 'HASH' or (!exists $options->{returning} and !exists $options->{last_insert_id})) {
        return $self->_quick_query($type, $table_name, $data);
    }

    my ($sql, @bind_params) = $self->_generate_sql(
        $type, $table_name, $data
    );

    $sql .= ' RETURNING '.$options->{returning} if exists $options->{returning};

    # this is copied from Dancer::Plugin::Database::Core::Handle::_quick_query:
    if ($self->{private_dancer_plugin_database}{log_queries}) {
        $self->{private_dancer_plugin_database}{logger}->(debug =>
            "Executing $type query $sql with params " . join ',',
            map {
                defined $_ ?
                $_ =~ /^[[:ascii:]]+$/ ?
                    length $_ > 50 ? substr($_, 0, 47) . '...' : $_
                : "[non-ASCII data not logged]" : 'undef'
            } @bind_params
        );
    }

    return $self->selectrow_arrayref($sql, undef, @bind_params)->[0] if exists $options->{returning};

    $self->do($sql, undef, @bind_params);
    return $self->last_insert_id(@{ $options->{last_insert_id} });
}

1;
__END__