File Coverage

blib/lib/Alzabo/Column.pm

Criterion	Covered	Total	%
statement	15	50	30.0
branch	0	6	0.0
condition			n/a
subroutine	5	29	17.2
pod	24	24	100.0
total	44	109	40.3

package Alzabo::Column;

use strict;
use vars qw($VERSION);

use Alzabo;

use Tie::IxHash;

use Params::Validate qw( :all );
Params::Validate::validation_options( on_fail => sub { Alzabo::Exception::Params->throw( error => join '', @_ ) } );

$VERSION = 2.0;

1;

sub table
{
    $_[0]->{table};
}

sub name
{
    $_[0]->{name};
}

sub nullable
{
    $_[0]->{nullable};
}

sub attributes
{
    return keys %{ $_[0]->{attributes} };
}

sub has_attribute
{
    my $self = shift;
    my %p = validate( @_, { attribute => { type => SCALAR },
                            case_sensitive => { type => SCALAR,
                                                default => 0 } } );

    if ( $p{case_sensitive} )
    {
        return exists $self->{attributes}{ $p{attribute} };
    }
    else
    {
        return 1 if grep { lc $p{attribute} eq lc $_ } keys %{ $self->{attributes} };
    }
}

sub type
{
    $_[0]->definition->type;
}

sub sequenced
{
    $_[0]->{sequenced};
}

sub default
{
    $_[0]->{default};
}

sub default_is_raw
{
    $_[0]->{default_is_raw};
}

sub length
{
    $_[0]->definition->length;
}

sub precision
{
    $_[0]->definition->precision;
}

sub definition
{
    $_[0]->{definition};
}

sub is_primary_key
{
    $_[0]->table->column_is_primary_key($_[0]);
}

sub is_numeric
{
    $_[0]->table->schema->rules->type_is_numeric($_[0]);
}

sub is_integer
{
    $_[0]->table->schema->rules->type_is_integer($_[0]);
}

sub is_floating_point
{
    $_[0]->table->schema->rules->type_is_floating_point($_[0]);
}

sub is_character
{
    $_[0]->table->schema->rules->type_is_char($_[0]);
}

sub is_date
{
    $_[0]->table->schema->rules->type_is_date($_[0]);
}

sub is_datetime
{
    $_[0]->table->schema->rules->type_is_datetime($_[0]);
}

sub is_time
{
    $_[0]->table->schema->rules->type_is_time($_[0]);
}

sub is_time_interval
{
    $_[0]->table->schema->rules->type_is_time_interval($_[0]);
}

sub is_blob
{
    $_[0]->table->schema->rules->type_is_blob($_[0]);
}

sub generic_type
{
    my $self = shift;

    foreach my $type ( qw( integer floating_point character date datetime time blob ) )
    {
        my $method = "is_$type";
        return $type if $self->$method();
    }

    return 'unknown';
}

sub comment { $_[0]->{comment} }

__END__