view release on metacpan or  search on metacpan

lib/Alzabo/Schema.pm  view on Meta::CPAN

            or Alzabo::Exception::System->throw( error => "Unable to open $version_file: $!\n" );
        $version = join '', <$fh>;
        close $fh
            or Alzabo::Exception::System->throw( error => "Unable to close $version_file: $!" );
    }

    if ( $version < $Alzabo::VERSION )
    {
        require Alzabo::BackCompat;

        Alzabo::BackCompat::update_schema( name => $p{name},
                                           version => $version );
    }

    open $fh, "<$file"
        or Alzabo::Exception::System->throw( error => "Unable to open $file: $!" );
    my $schema = Storable::retrieve_fd($fh)
        or Alzabo::Exception::System->throw( error => "Can't retrieve from filehandle" );
    close $fh
        or Alzabo::Exception::System->throw( error => "Unable to close $file: $!" );

    my $rdbms_file = File::Spec->catfile( $schema_dir, $p{name}, "$p{name}.rdbms" );
    open $fh, "<$rdbms_file"
        or Alzabo::Exception::System->throw( error => "Unable to open $rdbms_file: $!\n" );
    my $rdbms = join '', <$fh>;
    close $fh
        or Alzabo::Exception::System->throw( error => "Unable to close $rdbms_file: $!" );

    $rdbms =~ s/\s//g;

    ($rdbms) = $rdbms =~ /(\w+)/;

    # This is important because if the user is using MethodMaker, they
    # might be calling this as My::Schema->load_from_file ...
    bless $schema, $class;

    $schema->{driver} = Alzabo::Driver->new( rdbms => $rdbms,
                                             schema => $schema );

    $schema->{rules} = Alzabo::RDBMSRules->new( rdbms => $rdbms );

    $schema->{sql} = Alzabo::SQLMaker->load( rdbms => $rdbms );

    $schema->_save_to_cache;

    return $schema;
}

sub _cached_schema
{
    my $class = shift->isa('Alzabo::Runtime::Schema') ? 'Alzabo::Runtime::Schema' : 'Alzabo::Create::Schema';

    validate_pos( @_, { type => SCALAR } );
    my $name = shift;

    my $schema_dir = Alzabo::Config::schema_dir();
    my $file = $class->_schema_filename($name);

    if (exists $CACHE{$name}{$class}{object})
    {
        my $mtime = (stat($file))[9]
            or Alzabo::Exception::System->throw( error => "can't stat $file: $!" );

        return $CACHE{$name}{$class}{object}
            if $mtime <= $CACHE{$name}{$class}{mtime};
    }
}

sub _schema_filename
{
    my $class = shift;

    return $class->_base_filename(shift) . '.' . $class->_schema_file_type . '.alz';
}

sub _base_filename
{
    shift;
    my $name = shift;

    return File::Spec->catfile( Alzabo::Config::schema_dir(), $name, $name );
}

sub _save_to_cache
{
    my $self = shift;
    my $class = $self->isa('Alzabo::Runtime::Schema') ? 'Alzabo::Runtime::Schema' : 'Alzabo::Create::Schema';
    my $name = $self->name;

    $CACHE{$name}{$class} = { object => $self,
                              mtime => time };
}

sub name
{
    my $self = shift;

    return $self->{name};
}

sub db_schema_name
{
    my $self = shift;

    return
        ( exists $self->{db_schema_name}
          ? $self->{db_schema_name}
          : $self->name
        );
}

sub has_table
{
    my $self = shift;

    validate_pos( @_, { type => SCALAR } );

    return $self->{tables}->FETCH(shift);
}

use constant TABLE_SPEC => { type => SCALAR };