File Coverage

blib/lib/Geoffrey/Role/Converter.pm

Criterion	Covered	Total	%
statement	99	100	99.0
branch	22	28	78.5
condition	5	5	100.0
subroutine	33	33	100.0
pod	27	27	100.0
total	186	193	96.3

package Geoffrey::Role::Converter;

use utf8;
use Carp qw/croak/;
use strict;
use warnings;
use Perl::Version;

$Geoffrey::Role::Converter::VERSION = '0.000203';

sub new {
    my $class = shift;
    my $self  = {@_};
    return bless $self, $class;
}

sub changelog_table {
    $_[0]->{changelog_table} //= 'geoffrey_changelogs';
    return $_[0]->{changelog_table};
}

sub changelog_columns {
    return [{
            name       => 'id',
            type       => 'varchar',
            lenght     => 64,
            primarykey => 1,
            notnull    => 1,
            default    => '\'\''
        },
        {name => 'created_by', type => 'varchar', lenght => 128, notnull => 1, default => '\'\'',},
        {name => 'filename',   type => 'varchar', lenght => 255,},
        {name => 'md5sum',     type => 'varchar', lenght => 64,},
        {name => 'description', type => 'varchar', lenght => 255,},
        {name => 'comment',     type => 'varchar', lenght => 128,},
        {
            name    => 'geoffrey_version',
            type    => 'varchar',
            lenght  => 16,
            notnull => 1,
            default => '\'\''
        },
        {name => 'created', type => 'timestamp', default => 'current_timestamp', notnull => 1,},
    ];
}

sub origin_types {
    return [
        'abstime', 'aclitem',                                                      #Al
        'bigint', 'bigserial', 'bit', 'varbit', 'blob', 'bool', 'box', 'bytea',    #B
        'char', 'character', 'varchar', 'cid', 'cidr', 'circle',                   #C
        'date', 'daterange', 'double', 'double_precision', 'decimal',              #D
                                                                                   #E
                                                                                   #F
        'gtsvector',                                                               #G
                                                                                   #H
        'inet', 'int2vector', 'int4range', 'int8range', 'integer', 'interval',     #I
        'json',                                                                    #J
                                                                                   #K
        'line',    'lseg',                                                         #L
        'macaddr', 'money',                                                        #M
        'name',    'numeric', 'numrange',                                          #N
        'oid',     'oidvector',                                                    #O
        'path',    'pg_node_tree', 'point', 'polygon',                             #P
                                                                                   #Q
        'real', 'refcursor', 'regclass', 'regconfig', 'regdictionary', 'regoper', 'regoperator',
        'regproc', 'regprocedure', 'regtype',     'reltime',                       #R
        'serial',  'smallint',     'smallserial', 'smgr',                          #S
        'text', 'tid', 'timestamp', 'timestamp_tz', 'time', 'time_tz', 'tinterval', 'tsquery',
        'tsrange', 'tstzrange', 'tsvector', 'txid_snapshot',                       #T
        'uuid',                                                                    #U
                                                                                   #V
                                                                                   #W
        'xid',                                                                     #X
                                                                                   #Y
                                                                                   #Z
    ];
}

sub min_version { return shift->{min_version} }

sub max_version { return shift->{max_version} }

sub can_create_empty_table;

sub check_version {
    my ($self, $s_version) = @_;
    $s_version = Perl::Version->new($s_version);
    my ($s_max_version, $s_min_version) = undef;
    eval { $s_min_version = $self->min_version; } or do { };
    eval { $s_max_version = $self->max_version; } or do { };
    $s_min_version = Perl::Version->new($s_min_version);
    if ($s_max_version) {
        $s_max_version = Perl::Version->new($s_max_version);
        return 1 if ($s_min_version <= $s_version && $s_version <= $s_max_version);
        require Geoffrey::Exception::NotSupportedException;
        Geoffrey::Exception::NotSupportedException::throw_version($self, $s_min_version,
            $s_version, $s_max_version);
    }
    elsif ($s_min_version <= $s_version) {
        return 1;
    }
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_version($self, $s_min_version,
        $s_version);
}

sub type {
    my ($self, $hr_column_params) = @_;
    if (!$hr_column_params->{type}) {
        require Geoffrey::Exception::RequiredValue;
        Geoffrey::Exception::RequiredValue::throw_column_type($self);
    }
    my $s_column_type
        = (grep {/^$hr_column_params->{type}$/sxm} @{$self->origin_types()})
        ? $self->types()->{$hr_column_params->{type}}
        : undef;
    if (!$s_column_type) {
        require Geoffrey::Exception::NotSupportedException;
        Geoffrey::Exception::NotSupportedException::throw_column_type($hr_column_params->{type},
            $self);
    }
    $s_column_type .= $hr_column_params->{strict} ? '(strict)' : q//;
    $s_column_type
        .= defined $hr_column_params->{lenght} ? qq~($hr_column_params->{lenght})~ : q//;
    return $s_column_type;
}

sub _get_table_hashref {
    my ($self, $dbh, $s_name, $ar_columns, $s_schema) = @_;
    my $s_select_get_table = $self->select_get_table;
    my $sth                = $dbh->prepare($s_select_get_table);
    if ($s_schema) {
        $sth->execute($s_schema, $s_name) or Carp::confess $!;
    }
    else {
        $sth->execute($s_name) or Carp::confess $!;
    }
    my $hr_table = $sth->fetchrow_hashref();
    return if defined $hr_table;
    return {name => $s_name, columns => $ar_columns,};
}

sub get_changelog_table_hashref {
    my ($self, $o_dbh, $s_schema) = @_;
    return $self->_get_table_hashref(
        $o_dbh,
        $self->changelog_table(),
        $self->changelog_columns(), $s_schema
    );
}

sub constraints {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub index {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub table {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub view {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub foreign_key {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub trigger {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub primary_key {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub sequence {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub function {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub unique {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_converter();
}

sub colums_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information('colums_information',
        shift);
}

sub index_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information('index_information',
        shift);
}

sub view_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information('view_information',
        shift);
}

sub sequence_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information(
        'sequence_information', shift);
}

sub primary_key_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information(
        'primary_key_information', shift);
}

sub function_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information(
        'function_information', shift);
}

sub unique_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information('unique_information',
        shift);
}

sub trigger_information {
    require Geoffrey::Exception::NotSupportedException;
    return Geoffrey::Exception::NotSupportedException::throw_list_information(
        'trigger_information', shift);
}

1;    # End of Geoffrey::converter

__END__