File Coverage

blib/lib/Starch/Store/DBI.pm

Criterion	Covered	Total	%
statement	59	62	95.1
branch	6	10	60.0
condition	1	3	33.3
subroutine	17	17	100.0
pod	2	2	100.0
total	85	94	90.4

package Starch::Store::DBI;

$Starch::Store::DBI::VERSION = '0.03';

=head1 NAME

Starch::Store::DBI - Starch storage backend using DBI.

=head1 SYNOPSIS

    my $starch = Starch->new(
        store => {
            class => '::DBI',
            dbh => [
                $dsn,
                $username,
                $password,
                { RaiseError => 1 },
            ],
            table => 'my_states',
        },
    );

=head1 DESCRIPTION

This L store uses L to set and get state data.

Consider using L instead
of this store as L provides superior re-connection
and transaction handling capabilities.

The table in your database should contain three columns.  This
is the SQLite syntax for creating a compatible table which you
can modify to work for your particular database's syntax:

    CREATE TABLE starch_states (
        key TEXT NOT NULL PRIMARY KEY,
        data TEXT NOT NULL,
        expiration INTEGER NOT NULL
    )

=cut

use DBI;
use Types::Standard -types;
use Types::Common::String -types;
use Scalar::Util qw( blessed );
use Data::Serializer::Raw;

use Moo;
use strictures 2;
use namespace::clean;

with qw(
    Starch::Store
);

=head1 REQUIRED ARGUMENTS

=head2 dbh

This must be set to either array ref arguments for L
or a pre-built object (often retrieved using a method proxy).

When configuring Starch from static configuration files using a
L
is a good way to link your existing L object constructor
in with Starch so that starch doesn't build its own.

=cut

has _dbh_arg => (
    is       => 'ro',
    isa      => (InstanceOf[ 'DBI::db' ]) | ArrayRef,
    init_arg => 'dbh',
    required => 1,
);

has dbh => (
    is       => 'lazy',
    isa      => InstanceOf[ 'DBI::db' ],
    init_arg => undef,
);
sub _build_dbh {
    my ($self) = @_;

    my $dbh = $self->_dbh_arg();
    return $dbh if blessed $dbh;

    return DBI->connect( @$dbh );
}

=head1 OPTIONAL ARGUMENTS

=head2 serializer

A L for serializing the state data for storage
in the L.  Can be specified as string containing the
serializer name, a hash ref of Data::Serializer::Raw arguments, or as a
pre-created Data::Serializer::Raw object.  Defaults to C.

Consider using the C or C serializers for speed.

C will likely be the fastest and produce the most compact data.

=cut

has _serializer_arg => (
    is       => 'ro',
    isa      => ((InstanceOf[ 'Data::Serializer::Raw' ]) | HashRef) | NonEmptySimpleStr,
    init_arg => 'serializer',
    default  => 'JSON',
);

has serializer => (
    is       => 'lazy',
    isa      => InstanceOf[ 'Data::Serializer::Raw' ],
    init_arg => undef,
);
sub _build_serializer {
    my ($self) = @_;

    my $serializer = $self->_serializer_arg();
    return $serializer if blessed $serializer;

    if (ref $serializer) {
        return Data::Serializer::Raw->new( %$serializer );
    }

    return Data::Serializer::Raw->new(
        serializer => $serializer,
    );
}

=head2 table

The table name where states are stored in the database.
Defaults to C.

=cut

has table => (
    is      => 'ro',
    isa     => NonEmptySimpleStr,
    default => 'starch_states',
);

=head2 key_column

The column in the L