File Coverage

blib/lib/MySQL/Partition.pm

Criterion	Covered	Total	%
statement	57	83	68.6
branch	4	12	33.3
condition	3	9	33.3
subroutine	16	24	66.6
pod	3	5	60.0
total	83	133	62.4

package MySQL::Partition;
use 5.008001;
use strict;
use warnings;

our $VERSION = "1.0001";

use MySQL::Partition::Handle;

use Module::Load ();
use Class::Accessor::Lite (
    rw      => [qw/dry_run verbose/],
    ro      => [qw/type dbh table expression/],
);

sub dbname {
    my $self = shift;
    exists $self->{dbname} ? $self->{dbname} : $self->{dbname} ||= _get_dbname($self->dbh->{Name});
}

sub new {
    my $class = shift;
    die q[can't call new method directory in sub class] if $class ne __PACKAGE__;
    my %args = @_ == 1 ? %{$_[0]} : @_;

    $args{type} = uc $args{type};

    my ($type) = split /\s+/, $args{type};
    my $sub_class = __PACKAGE__ . '::Type::' . ucfirst( lc $type );
    Module::Load::load($sub_class);
    bless \%args, $sub_class;
}

__PACKAGE__->_grow_methods(qw/create_partitions add_partitions drop_partitions truncate_partitions/);

sub retrieve_partitions {
    my ($self, $table) = @_;

    my $parts = $self->{partitions} ||= do {
        my @parts;
        my $sth = $self->dbh->prepare('
            SELECT
              partition_name
            FROM
              information_schema.PARTITIONS
            WHERE
              table_name       = ? AND
              table_schema     = ? AND
              partition_method = ?
            ORDER BY
              partition_name
        ');
        $sth->execute($self->table, $self->dbname, $self->type);
        while (my $row = $sth->fetchrow_arrayref) {
            push @parts, $row->[0] if defined $row->[0];
        }
        \@parts;
    };
    @$parts;
}

sub is_partitioned {
    my $self = shift;
    $self->retrieve_partitions ? 1 : ();
}

sub has_partition {
    my ($self, $partition_name) = @_;
    grep {$_ eq $partition_name} $self->retrieve_partitions;
}

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

    if ($self->isa('MySQL::Partition::Type::Range') && $self->catch_all_partition_name) {
        push @args, $self->catch_all_partition_name, 'MAXVALUE';
    }
    sprintf 'ALTER TABLE %s PARTITION BY %s (%s) (%s)',
        $self->table, $self->type, $self->expression, $self->_build_partition_parts(@args);
}

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

    sprintf 'ALTER TABLE %s ADD PARTITION (%s)', $self->table, $self->_build_partition_parts(@args);
}

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

    my @parts;
    while (my ($partition_name, $partition_description) = splice @args, 0, 2) {
        push @parts, $self->_build_partition_part($partition_name, $partition_description);
    }
    join ', ', @parts;
}

sub _build_partition_part {
    die 'this is abstruct method';
}

sub _build_drop_partitions_sql {
    my ($self, @partition_names) = @_;

    sprintf 'ALTER TABLE %s DROP PARTITION %s', $self->table, join(', ', @partition_names);
}

sub _build_truncate_partitions_sql {
    my ($self, @partition_names) = @_;

    sprintf 'ALTER TABLE %s TRUNCATE PARTITION %s', $self->table, join(', ', @partition_names);
}

sub _grow_methods {
    my ($class, @methods) = @_;

    for my $method (@methods) {
        my $prepare_method = "prepare_$method";
        my $sql_builder_method   = "_build_${method}_sql";

        no strict 'refs';
        *{$class . '::' . $prepare_method} = sub {
            use strict 'refs';
            my ($self, @args) = @_;
            my $sql = $self->$sql_builder_method(@args);

            return MySQL::Partition::Handle->new(
                statement       => $sql,
                mysql_partition => $self,
            );
        };
        *{$class . '::' . $method} = sub {
            use strict 'refs';
            my ($self, @args) = @_;
            $self->$prepare_method(@args)->execute;
        };
    }
}

sub _get_dbname {
    my $connected_db = shift;

    # XXX can't parse 'host=hoge;database=fuga'
    my ($dbname) = $connected_db =~ m!^(?:(?:database|dbname)=)?([^;]*)!i;
    $dbname;
}

1;
__END__