view release on metacpan or  search on metacpan

lib/TreePath/Backend/DBIx.pm  view on Meta::CPAN

has 'schema'     => (
                     is        => 'rw',
                     predicate => 'has_schema',
                     lazy_build      => 1,
                    );

has '_source_name' => (
                is       => 'rw',
                isa      => 'Str',
               );

has '_populate_backend' => (
                is       => 'rw',
                isa      => 'Int',
               );

sub _build_model_config {
  my $self = shift;

  my $model_config = $self->conf->{$self->config->{backend}->{args}->{model}}
      or croak "'backend/args/model' is not defined in conf file !";
  return $model_config
}

sub _build_schema {
  my $self = shift;

  my($dsn, $user, $password, $allattrs) = $self->_connect_info;

  my $schema_class =  $self->model_config->{schema_class};
  eval "require $schema_class";
  if( $@ ){
    die("Cannot load $schema_class : $@");
  }
  return $schema_class->connect($dsn,$user,$password,$allattrs);
}


sub _connect_info {
  my $self = shift;

  my $model_config = $self->model_config;

  my ($dsn, $user, $password, $unicode_option, $db_type);
  eval {
    if (!$dsn)
      {
        if (ref $model_config->{'connect_info'}) {

          $dsn      = $model_config->{'connect_info'}->{dsn};
          $user     = $model_config->{'connect_info'}->{user};
          $password = $model_config->{'connect_info'}->{password};

          # Determine database type amongst: SQLite, Pg or MySQL
          $dsn =~ m/^dbi:(\w+)/;
          $db_type = lc($1);
          my %unicode_connection_for_db = (
                'sqlite' => { sqlite_unicode    => 1 },
                'pg'     => { pg_enable_utf8    => 1 },
                'mysql'  => { mysql_enable_utf8 => 1 },

                );
          $unicode_option = $unicode_connection_for_db{$db_type};
        }
        else {
          $dsn = $model_config->{'connect_info'};
        }
      }
  };

  if ($@) {
    die "Your DSN line in " . $self->conf . " doesn't look like a valid DSN.";
  }
  die "No valid Data Source Name (DSN).\n" if !$dsn;
  $dsn =~ s/__HOME__/$FindBin::Bin\/\.\./g;

  if ( $db_type eq 'sqlite' ){
    $dsn =~ m/.*:(.*)$/;
    my $dir = dir($1)->parent;
    $dir->mkpath;
  }

  my $merge    = Hash::Merge->new( 'LEFT_PRECEDENT' );
  my $allattrs = $merge->merge( $unicode_option, $attrs );

  return $dsn, $user, $password, $allattrs;
}



sub _load {
    my $self = shift;

    $self->_log("Loading tree from dbix");

    $self->_populate_backend($self->config->{backend}->{args}->{'populate_backend'})
        if ( $self->can('_populate_backend') && ! defined $self->_populate_backend && defined $self->config->{backend}->{args}->{'populate_backend'} );

    my $schema = $self->schema;
    my @sources_name = keys %{$self->config->{backend}->{args}->{sources_name}}
        or croak "'backend/args/sources_name' is not defined in conf file !";

    my @datas;
   foreach my $source_name ( @sources_name ) {

       my($dsn, $user, $password, $allattrs) = $self->_connect_info;
       $self->_source_name($source_name);
       eval { $schema->resultset($source_name)->count };

      if ( $@ ) {
          print "Deploy and populate $dsn\n" if $self->debug;
          $schema->deploy;
          $schema->_populate if ( $schema->can('_populate') && $self->_populate_backend);
      }
      my $rs = $self->schema->resultset($source_name)->search();

       my @primary_columns = $rs->result_source->primary_columns;
       croak "Multi-column primary keys are not supported." if (scalar @primary_columns > 1 );
       croak "No primary key found." if (scalar @primary_columns == 0 );
       my $primary_key = shift @primary_columns;