view release on metacpan or  search on metacpan

lib/DBIO/Storage.pm  view on Meta::CPAN

package DBIO::Storage;
# ABSTRACT: Generic Storage Handler

use strict;
use warnings;

use base qw/DBIO::Base/;
use mro 'c3';

{
  package # Hide from PAUSE
    DBIO::Storage::NESTED_ROLLBACK_EXCEPTION;
  use base 'DBIO::Exception';
}

use DBIO::Carp;
use DBIO::Storage::BlockRunner;
use Scalar::Util qw/blessed weaken/;
use DBIO::Storage::TxnScopeGuard;
use Try::Tiny;
use namespace::clean;

__PACKAGE__->mk_group_accessors(simple => qw/
  debug schema transaction_depth deferred_rollback auto_savepoint savepoints
  access_broker access_broker_mode
/);
__PACKAGE__->mk_group_accessors(component_class => 'cursor_class');

__PACKAGE__->cursor_class('DBIO::Cursor');

sub cursor { shift->cursor_class(@_); }



sub new {
  my ($self, $schema) = @_;

  $self = ref $self if ref $self;

  my $new = bless( {
    transaction_depth => 0,
    savepoints => [],
  }, $self);

  $new->set_schema($schema);
  $new->debug(1)
    if $ENV{DBIO_TRACE};

  $new;
}



sub set_schema {
  my ($self, $schema) = @_;
  $self->schema($schema);
  weaken $self->{schema} if ref $self->{schema};
}


sub set_access_broker {
  my ($self, $broker, $mode) = @_;

  $self->throw_exception('set_access_broker() requires a broker object')
    unless blessed($broker);

  $self->throw_exception(
    'set_access_broker() requires a DBIO::AccessBroker instance'
  ) unless $broker->isa('DBIO::AccessBroker');

  $self->access_broker($broker);
  $self->access_broker_mode($mode || 'write');
  $broker->set_storage($self);

  return $self;
}


sub clear_access_broker {
  my $self = shift;
  $self->access_broker(undef);
  $self->access_broker_mode(undef);
  return $self;
}


sub current_access_broker_connect_info {
  my ($self, $mode) = @_;
  my $broker = $self->access_broker or return;
  $mode ||= $self->access_broker_mode || 'write';
  return $broker->current_connect_info_for_storage($self, $mode);
}


sub connected { die "Virtual method!" }


sub disconnect { die "Virtual method!" }


sub ensure_connected { die "Virtual method!" }



sub throw_exception {
  my $self = shift;

  if (ref $self and $self->schema) {
    $self->schema->throw_exception(@_);
  }
  else {
    DBIO::Exception->throw(@_);
  }
}