From: Peter Rabbitson <ribasushi@cpan.org>
Date: Sun, 17 Jan 2010 16:52:10 +0000 (+0000)
Subject: Real detabify
X-Git-Tag: v0.08119~9^2~30
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=a705b1758c359438b683daa2c2b1e8cb5a3377da;p=dbsrgits%2FDBIx-Class.git

Real detabify
---

diff --git a/lib/DBIx/Class/Admin.pm b/lib/DBIx/Class/Admin.pm
index f92c855..c2d9bb6 100644
--- a/lib/DBIx/Class/Admin.pm
+++ b/lib/DBIx/Class/Admin.pm
@@ -1,4 +1,4 @@
-# vim: et ts=2
+#
 #===============================================================================
 #
 #         FILE:  Admin.pm
@@ -18,7 +18,7 @@ package DBIx::Class::Admin;
 
 use Moose;
 use MooseX::Types 
--declare => [qw( DBICConnectInfo )];
+  -declare => [qw( DBICConnectInfo )];
 use MooseX::Types::Moose qw/Int HashRef ArrayRef Str Any/;
 use MooseX::Types::JSON qw(JSON);
 use MooseX::Types::Path::Class qw(Dir File);
@@ -33,27 +33,27 @@ use namespace::autoclean;
 my @_deps = qw(Moose MooseX::Types MooseX::Types::JSON MooseX::Types::Path::Class Try::Tiny parent JSON::Any Class::C3::Componentised namespace::autoclean);
 
 coerce ArrayRef,
-from JSON,
-via { _json_to_data ($_) };
+  from JSON,
+  via { _json_to_data ($_) };
 
 coerce HashRef,
-from JSON,
-via { _json_to_data($_) };
+  from JSON,
+  via { _json_to_data($_) };
 
 subtype DBICConnectInfo,
-as ArrayRef;
+  as ArrayRef;
 
 coerce DBICConnectInfo,
-from JSON,
-via { return _json_to_data($_) } ;
+  from JSON,
+   via { return _json_to_data($_) } ;
 
 coerce DBICConnectInfo,
-from Str,
-via { return _json_to_data($_) };
+  from Str,
+    via { return _json_to_data($_) };
 
 coerce DBICConnectInfo,
-from HashRef,
-via { [ $_->{dsn}, $_->{user}, $_->{password} ]  };
+  from HashRef,
+   via { [ $_->{dsn}, $_->{user}, $_->{password} ]  };
 
 =head1 NAME
 
@@ -89,15 +89,15 @@ DBIx::Class::Admin - Administration object for schemas
 add a library search path
 =cut
 has lib => (
-is		=> 'ro',
-isa		=> Dir,
-coerce	=> 1,
-trigger => \&_set_inc,
+  is    => 'ro',
+  isa    => Dir,
+  coerce  => 1,
+  trigger => \&_set_inc,
 );
 
 sub _set_inc {
-    my ($self, $lib) = @_;
-    push @INC, $lib->stringify;
+  my ($self, $lib) = @_;
+  push @INC, $lib->stringify;
 }
 
 =head2 schema_class
@@ -105,9 +105,9 @@ sub _set_inc {
 the class of the schema to load
 =cut
 has 'schema_class' => (
-is		=> 'ro',
-isa		=> 'Str',
-coerce	=> 1,
+  is    => 'ro',
+  isa    => 'Str',
+  coerce  => 1,
 );
 
 =head2 schema
@@ -115,17 +115,17 @@ coerce	=> 1,
 A pre-connected schema object can be provided for manipulation
 =cut
 has 'schema' => (
-is			=> 'ro',
-isa			=> 'DBIx::Class::Schema',
-lazy_build	=> 1,
+  is      => 'ro',
+  isa      => 'DBIx::Class::Schema',
+  lazy_build  => 1,
 );
 
 sub _build_schema {
-    my ($self)  = @_;
-    $self->ensure_class_loaded($self->schema_class);
+  my ($self)  = @_;
+  $self->ensure_class_loaded($self->schema_class);
 
-    $self->connect_info->[3]->{ignore_version} =1;
-    return $self->schema_class->connect(@{$self->connect_info()} ); # ,  $self->connect_info->[3], { ignore_version => 1} );
+  $self->connect_info->[3]->{ignore_version} =1;
+  return $self->schema_class->connect(@{$self->connect_info()} ); # ,  $self->connect_info->[3], { ignore_version => 1} );
 }
 
 =head2 resultset
@@ -133,8 +133,8 @@ sub _build_schema {
 a resultset from the schema to operate on
 =cut
 has 'resultset' => (
-is			=> 'rw',
-isa			=> Str,
+  is      => 'rw',
+  isa      => Str,
 );
 
 =head2 where
@@ -143,9 +143,9 @@ a hash ref or json string to be used for identifying data to manipulate
 =cut
 
 has 'where' => (
-is			=> 'rw',
-isa			=> HashRef,
-coerce		=> 1,
+  is      => 'rw',
+  isa      => HashRef,
+  coerce    => 1,
 );
 
 =head2 set
@@ -153,18 +153,18 @@ a hash ref or json string to be used for inserting or updating data
 =cut
 
 has 'set' => (
-is			=> 'rw',
-isa			=> HashRef,
-coerce		=> 1,
+  is      => 'rw',
+  isa      => HashRef,
+  coerce    => 1,
 );
 
 =head2 attrs
 a hash ref or json string to be used for passing additonal info to the ->search call
 =cut
 has 'attrs' => (
-is 			=> 'rw',
-isa			=> HashRef,
-coerce		=> 1,
+  is       => 'rw',
+  isa      => HashRef,
+  coerce    => 1,
 );
 =head2 connect_info
 
@@ -173,15 +173,15 @@ connect_info the arguments to provide to the connect call of the schema_class
 
 
 has 'connect_info' => (
-is			=> 'ro',
-isa			=> DBICConnectInfo,
-lazy_build	=> 1,
-coerce		=> 1,
+  is      => 'ro',
+  isa      => DBICConnectInfo,
+  lazy_build  => 1,
+  coerce    => 1,
 );
 
 sub _build_connect_info {
-    my ($self) = @_;
-    return $self->_find_stanza($self->config, $self->config_stanza);
+  my ($self) = @_;
+  return $self->_find_stanza($self->config, $self->config_stanza);
 }
 
 =head2 config_file
@@ -191,9 +191,9 @@ config_stanze should also be provided to locate where the connect_info is in the
 The config file should be in a format readable by Config::General
 =cut
 has config_file => (
-is			=> 'ro',
-isa			=> File,
-coerce		=> 1,
+  is      => 'ro',
+  isa      => File,
+  coerce    => 1,
 );
 
 =head2 config_stanza
@@ -202,8 +202,8 @@ config_stanza for use with config_file should be a '::' deliminated 'path' to th
 designed for use with catalyst config files
 =cut
 has 'config_stanza' => (
-is			=> 'ro',
-isa			=> 'Str',
+  is      => 'ro',
+  isa      => 'Str',
 );
 
 =head2 config
@@ -212,20 +212,20 @@ Instead of loading from a file the configuration can be provided directly as a h
 config_stanza will still be required.
 =cut
 has config => (
-is			=> 'ro',
-isa			=> HashRef,
-lazy_build	=> 1,
+  is      => 'ro',
+  isa      => HashRef,
+  lazy_build  => 1,
 );
 
 sub _build_config {
-    my ($self) = @_;
-    try { require 'Config::Any'; } catch { die "Config::Any is required to parse the config file"; };
+  my ($self) = @_;
+  try { require 'Config::Any'; } catch { die "Config::Any is required to parse the config file"; };
 
-    my $cfg = Config::Any->load_files ( {files => [$self->config_file], use_ext =>1, flatten_to_hash=>1});
+  my $cfg = Config::Any->load_files ( {files => [$self->config_file], use_ext =>1, flatten_to_hash=>1});
 
-    # just grab the config from the config file
-    $cfg = $cfg->{$self->config_file};
-    return $cfg;
+  # just grab the config from the config file
+  $cfg = $cfg->{$self->config_file};
+  return $cfg;
 }
 
 =head2 sql_dir
@@ -233,9 +233,9 @@ sub _build_config {
 The location where sql ddl files should be created or found for an upgrade.
 =cut
 has 'sql_dir' => (
-is			=> 'ro',
-isa			=> Dir,
-coerce		=> 1,
+  is      => 'ro',
+  isa      => Dir,
+  coerce    => 1,
 );
 
 =head2 version
@@ -243,8 +243,8 @@ coerce		=> 1,
 Used for install, the version which will be 'installed' in the schema
 =cut
 has version => (
-is			=> 'rw',
-isa			=> 'Str',
+  is      => 'rw',
+  isa      => 'Str',
 );
 
 =head2 preversion
@@ -252,8 +252,8 @@ isa			=> 'Str',
 Previouse version of the schema to create an upgrade diff for, the full sql for that version of the sql must be in the sql_dir
 =cut
 has preversion => (
-is			=> 'rw',
-isa			=> 'Str',
+  is      => 'rw',
+  isa      => 'Str',
 );
 
 =head2 force
@@ -261,8 +261,8 @@ isa			=> 'Str',
 Try and force certain operations.
 =cut
 has force => (
-is			=> 'rw',
-isa			=> 'Bool',
+  is      => 'rw',
+  isa      => 'Bool',
 );
 
 =head2 quiet
@@ -270,13 +270,13 @@ isa			=> 'Bool',
 Be less verbose about actions
 =cut
 has quiet => (
-is			=> 'rw',
-isa			=> 'Bool',
+  is      => 'rw',
+  isa      => 'Bool',
 );
 
 has '_confirm' => (
-is		=> 'bare',
-isa		=> 'Bool',
+  is    => 'bare',
+  isa    => 'Bool',
 );
 
 =head1 METHODS
@@ -298,15 +298,15 @@ Optional preversion can be supplied to generate a diff to be used by upgrade.
 =cut
 
 sub create {
-    my ($self, $sqlt_type, $sqlt_args, $preversion) = @_;
+  my ($self, $sqlt_type, $sqlt_args, $preversion) = @_;
 
-    $preversion ||= $self->preversion();
+  $preversion ||= $self->preversion();
 
-    my $schema = $self->schema();
-    # create the dir if does not exist
-    $self->sql_dir->mkpath() if ( ! -d $self->sql_dir);
+  my $schema = $self->schema();
+  # create the dir if does not exist
+  $self->sql_dir->mkpath() if ( ! -d $self->sql_dir);
 
-    $schema->create_ddl_dir( $sqlt_type, (defined $schema->schema_version ? $schema->schema_version : ""), $self->sql_dir->stringify, $preversion, $sqlt_args );
+  $schema->create_ddl_dir( $sqlt_type, (defined $schema->schema_version ? $schema->schema_version : ""), $self->sql_dir->stringify, $preversion, $sqlt_args );
 }
 
 =head2 upgrade
@@ -322,15 +322,15 @@ B<MAKE SURE YOU BACKUP YOUR DB FIRST>
 =cut
 
 sub upgrade {
-    my ($self) = @_;
-    my $schema = $self->schema();
-    if (!$schema->get_db_version()) {
-        # schema is unversioned
-        die "could not determin current schema version, please either install or deploy";
-    } else {
-        my $ret = $schema->upgrade();
-        return $ret;
-    }
+  my ($self) = @_;
+  my $schema = $self->schema();
+  if (!$schema->get_db_version()) {
+    # schema is unversioned
+    die "could not determin current schema version, please either install or deploy";
+  } else {
+    my $ret = $schema->upgrade();
+    return $ret;
+  }
 }
 
 =head2 install
@@ -347,26 +347,26 @@ further ddl modification takes place.  Setting the force attribute to a true val
 already versioned databases.
 =cut
 sub install {
-    my ($self, $version) = @_;
-
-    my $schema = $self->schema();
-    $version ||= $self->version();
-    if (!$schema->get_db_version() ) {
-        # schema is unversioned
-        print "Going to install schema version\n";
-        my $ret = $schema->install($version);
-        print "retun is $ret\n";
-    }
-    elsif ($schema->get_db_version() and $self->force ) {
-        warn "forcing install may not be a good idea";
-        if($self->_confirm() ) {
-            # FIXME private api
-            $self->schema->_set_db_version({ version => $version});
-        }
-    }
-    else {
-        die "schema already has a version not installing, try upgrade instead";
+  my ($self, $version) = @_;
+
+  my $schema = $self->schema();
+  $version ||= $self->version();
+  if (!$schema->get_db_version() ) {
+    # schema is unversioned
+    print "Going to install schema version\n";
+    my $ret = $schema->install($version);
+    print "retun is $ret\n";
+  }
+  elsif ($schema->get_db_version() and $self->force ) {
+    warn "forcing install may not be a good idea";
+    if($self->_confirm() ) {
+      # FIXME private api
+      $self->schema->_set_db_version({ version => $version});
     }
+  }
+  else {
+    die "schema already has a version not installing, try upgrade instead";
+  }
 
 }
 
@@ -382,15 +382,15 @@ deploy will create the schema at the connected database.  C<$args> are passed st
 L<DBIx::Class::Schema/deploy>.  
 =cut
 sub deploy {
-    my ($self, $args) = @_;
-    my $schema = $self->schema();
-    if (!$schema->get_db_version() ) {
-        # schema is unversioned
-        $schema->deploy( $args, $self->sql_dir)
-            or die "could not deploy schema";
-    } else {
-        die "there already is a database with a version here, try upgrade instead";
-    }
+  my ($self, $args) = @_;
+  my $schema = $self->schema();
+  if (!$schema->get_db_version() ) {
+    # schema is unversioned
+    $schema->deploy( $args, $self->sql_dir)
+      or die "could not deploy schema";
+  } else {
+    die "there already is a database with a version here, try upgrade instead";
+  }
 }
 
 
@@ -411,13 +411,13 @@ into that resultset
 
 =cut
 sub insert {
-    my ($self, $rs, $set) = @_;
+  my ($self, $rs, $set) = @_;
 
-    $rs ||= $self->resultset();
-    $set ||= $self->set();
-    my $resultset = $self->schema->resultset($rs);
-    my $obj = $resultset->create( $set );
-    print ''.ref($resultset).' ID: '.join(',',$obj->id())."\n" if (!$self->quiet);
+  $rs ||= $self->resultset();
+  $set ||= $self->set();
+  my $resultset = $self->schema->resultset($rs);
+  my $obj = $resultset->create( $set );
+  print ''.ref($resultset).' ID: '.join(',',$obj->id())."\n" if (!$self->quiet);
 }
 
 
@@ -433,20 +433,20 @@ update takes the name of a resultset from the schema_class, a hashref of data to
 a where hash used to form the search for the rows to update. 
 =cut
 sub update {
-    my ($self, $rs, $set, $where) = @_;
+  my ($self, $rs, $set, $where) = @_;
 
-    $rs ||= $self->resultset();
-    $where ||= $self->where();
-    $set ||= $self->set();
-    my $resultset = $self->schema->resultset($rs);
-    $resultset = $resultset->search( ($where||{}) );
+  $rs ||= $self->resultset();
+  $where ||= $self->where();
+  $set ||= $self->set();
+  my $resultset = $self->schema->resultset($rs);
+  $resultset = $resultset->search( ($where||{}) );
 
-    my $count = $resultset->count();
-    print "This action will modify $count ".ref($resultset)." records.\n" if (!$self->quiet);
+  my $count = $resultset->count();
+  print "This action will modify $count ".ref($resultset)." records.\n" if (!$self->quiet);
 
-    if ( $self->force || $self->_confirm() ) {
-        $resultset->update_all( $set );
-    }
+  if ( $self->force || $self->_confirm() ) {
+    $resultset->update_all( $set );
+  }
 }
 
 # FIXME
@@ -463,20 +463,20 @@ delete takes the name of a resultset from the schema_class, a where hashref and
 The found data is deleted and cannot be recovered.
 =cut
 sub delete {
-    my ($self, $rs, $where, $attrs) = @_;
+  my ($self, $rs, $where, $attrs) = @_;
 
-    $rs ||= $self->resultset();
-    $where ||= $self->where();
-    $attrs ||= $self->attrs();
-    my $resultset = $self->schema->resultset($rs);
-    $resultset = $resultset->search( ($where||{}), ($attrs||()) );
+  $rs ||= $self->resultset();
+  $where ||= $self->where();
+  $attrs ||= $self->attrs();
+  my $resultset = $self->schema->resultset($rs);
+  $resultset = $resultset->search( ($where||{}), ($attrs||()) );
 
-    my $count = $resultset->count();
-    print "This action will delete $count ".ref($resultset)." records.\n" if (!$self->quiet);
+  my $count = $resultset->count();
+  print "This action will delete $count ".ref($resultset)." records.\n" if (!$self->quiet);
 
-    if ( $self->force || $self->_confirm() ) {
-        $resultset->delete_all();
-    }
+  if ( $self->force || $self->_confirm() ) {
+    $resultset->delete_all();
+  }
 }
 
 =head2 select
@@ -492,58 +492,58 @@ The found data is returned in a array ref where the first row will be the column
 
 =cut
 sub select {
-    my ($self, $rs, $where, $attrs) = @_;
-
-    $rs ||= $self->resultset();
-    $where ||= $self->where();
-    $attrs ||= $self->attrs();
-    my $resultset = $self->schema->resultset($rs);
-    $resultset = $resultset->search( ($where||{}), ($attrs||()) );
-
-    my @data;
-    my @columns = $resultset->result_source->columns();
-    push @data, [@columns];# 
-
-    while (my $row = $resultset->next()) {
-        my @fields;
-        foreach my $column (@columns) {
-            push( @fields, $row->get_column($column) );
-        }
-        push @data, [@fields];
+  my ($self, $rs, $where, $attrs) = @_;
+
+  $rs ||= $self->resultset();
+  $where ||= $self->where();
+  $attrs ||= $self->attrs();
+  my $resultset = $self->schema->resultset($rs);
+  $resultset = $resultset->search( ($where||{}), ($attrs||()) );
+
+  my @data;
+  my @columns = $resultset->result_source->columns();
+  push @data, [@columns];# 
+
+  while (my $row = $resultset->next()) {
+    my @fields;
+    foreach my $column (@columns) {
+      push( @fields, $row->get_column($column) );
     }
+    push @data, [@fields];
+  }
 
-    return \@data;
+  return \@data;
 }
 
 sub _confirm {
-    my ($self) = @_;
-    print "Are you sure you want to do this? (type YES to confirm) \n";
-    # mainly here for testing
-    return 1 if ($self->meta->get_attribute('_confirm')->get_value($self));
-    my $response = <STDIN>;
-    return 1 if ($response=~/^YES/);
-    return;
+  my ($self) = @_;
+  print "Are you sure you want to do this? (type YES to confirm) \n";
+  # mainly here for testing
+  return 1 if ($self->meta->get_attribute('_confirm')->get_value($self));
+  my $response = <STDIN>;
+  return 1 if ($response=~/^YES/);
+  return;
 }
 
 sub _find_stanza {
-    my ($self, $cfg, $stanza) = @_;
-    my @path = split /::/, $stanza;
-    while (my $path = shift @path) {
-        if (exists $cfg->{$path}) {
-            $cfg = $cfg->{$path};
-        }
-        else {
-            die "could not find $stanza in config, $path did not seem to exist";
-        }
+  my ($self, $cfg, $stanza) = @_;
+  my @path = split /::/, $stanza;
+  while (my $path = shift @path) {
+    if (exists $cfg->{$path}) {
+      $cfg = $cfg->{$path};
+    }
+    else {
+      die "could not find $stanza in config, $path did not seem to exist";
     }
-    return $cfg;
+  }
+  return $cfg;
 }
 
 sub _json_to_data {
-    my ($json_str) = @_;
-    my $json = JSON::Any->new(allow_barekey => 1, allow_singlequote => 1, relaxed=>1);
-    my $ret = $json->jsonToObj($json_str);
-    return $ret;
+  my ($json_str) = @_;
+  my $json = JSON::Any->new(allow_barekey => 1, allow_singlequote => 1, relaxed=>1);
+  my $ret = $json->jsonToObj($json_str);
+  return $ret;
 }
 
 
@@ -551,14 +551,14 @@ sub _json_to_data {
 
 my @_missing_deps;
 foreach my $dep (@_deps) {
-    eval "require $dep";
-    if ($@) {
-        push @_missing_deps, $dep;
-    }
+  eval "require $dep";
+  if ($@) {
+    push @_missing_deps, $dep;
+  }
 }
 
 if (@_missing_deps > 0) {
-    die "The following dependecies are missing " . join ",", @_missing_deps;
+  die "The following dependecies are missing " . join ",", @_missing_deps;
 }
 
 
diff --git a/lib/DBIx/Class/Relationship/ManyToMany.pm b/lib/DBIx/Class/Relationship/ManyToMany.pm
index 07a244a..137fb30 100644
--- a/lib/DBIx/Class/Relationship/ManyToMany.pm
+++ b/lib/DBIx/Class/Relationship/ManyToMany.pm
@@ -64,15 +64,15 @@ EOW
       my $rs = $self->search_related($rel)->search_related(
         $f_rel, @_ > 0 ? @_ : undef, { %{$rel_attrs||{}}, %$attrs }
       );
-	  return $rs;
+      return $rs;
     };
 
     my $meth_name = join '::', $class, $meth;
     *$meth_name = Sub::Name::subname $meth_name, sub {
-		my $self = shift;
-		my $rs = $self->$rs_meth( @_ );
-  		return (wantarray ? $rs->all : $rs);
-	};
+      my $self = shift;
+      my $rs = $self->$rs_meth( @_ );
+      return (wantarray ? $rs->all : $rs);
+    };
 
     my $add_meth_name = join '::', $class, $add_meth;
     *$add_meth_name = Sub::Name::subname $add_meth_name, sub {
@@ -102,7 +102,7 @@ EOW
       my $link = $self->search_related($rel)->new_result($link_vals);
       $link->set_from_related($f_rel, $obj);
       $link->insert();
-	  return $obj;
+      return $obj;
     };
 
     my $set_meth_name = join '::', $class, $set_meth;
diff --git a/lib/DBIx/Class/Schema/Versioned.pm b/lib/DBIx/Class/Schema/Versioned.pm
index e6af6e0..e315b63 100644
--- a/lib/DBIx/Class/Schema/Versioned.pm
+++ b/lib/DBIx/Class/Schema/Versioned.pm
@@ -268,7 +268,7 @@ and the schema_version which is retrieved via $self->schema_version
 =cut
 
 sub create_upgrade_path {
-	## override this method
+  ## override this method
 }
 
 =head2 upgrade
diff --git a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
index fe81851..55cad0e 100644
--- a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
+++ b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
@@ -209,11 +209,15 @@ sub connect_call_datetime_setup {
   my $timestamp_tz_format = $ENV{NLS_TIMESTAMP_TZ_FORMAT} ||=
     'YYYY-MM-DD HH24:MI:SS.FF TZHTZM';
 
-  $self->_do_query("alter session set nls_date_format = '$date_format'");
   $self->_do_query(
-"alter session set nls_timestamp_format = '$timestamp_format'");
+    "alter session set nls_date_format = '$date_format'"
+  );
   $self->_do_query(
-"alter session set nls_timestamp_tz_format='$timestamp_tz_format'");
+    "alter session set nls_timestamp_format = '$timestamp_format'"
+  );
+  $self->_do_query(
+    "alter session set nls_timestamp_tz_format='$timestamp_tz_format'"
+  );
 }
 
 =head2 source_bind_attributes
@@ -235,35 +239,35 @@ table with more than one LOB column.
 
 sub source_bind_attributes
 {
-	require DBD::Oracle;
-	my $self = shift;
-	my($source) = @_;
+  require DBD::Oracle;
+  my $self = shift;
+  my($source) = @_;
 
-	my %bind_attributes;
+  my %bind_attributes;
 
-	foreach my $column ($source->columns) {
-		my $data_type = $source->column_info($column)->{data_type} || '';
-		next unless $data_type;
+  foreach my $column ($source->columns) {
+    my $data_type = $source->column_info($column)->{data_type} || '';
+    next unless $data_type;
 
-		my %column_bind_attrs = $self->bind_attribute_by_data_type($data_type);
+    my %column_bind_attrs = $self->bind_attribute_by_data_type($data_type);
 
-		if ($data_type =~ /^[BC]LOB$/i) {
-			$column_bind_attrs{'ora_type'} = uc($data_type) eq 'CLOB' ?
-				DBD::Oracle::ORA_CLOB() :
-				DBD::Oracle::ORA_BLOB();
-			$column_bind_attrs{'ora_field'} = $column;
-		}
+    if ($data_type =~ /^[BC]LOB$/i) {
+      $column_bind_attrs{'ora_type'} = uc($data_type) eq 'CLOB'
+        ? DBD::Oracle::ORA_CLOB()
+        : DBD::Oracle::ORA_BLOB()
+      ;
+      $column_bind_attrs{'ora_field'} = $column;
+    }
 
-		$bind_attributes{$column} = \%column_bind_attrs;
-	}
+    $bind_attributes{$column} = \%column_bind_attrs;
+  }
 
-	return \%bind_attributes;
+  return \%bind_attributes;
 }
 
 sub _svp_begin {
-    my ($self, $name) = @_;
-
-    $self->_get_dbh->do("SAVEPOINT $name");
+  my ($self, $name) = @_;
+  $self->_get_dbh->do("SAVEPOINT $name");
 }
 
 # Oracle automatically releases a savepoint when you start another one with the
@@ -271,9 +275,8 @@ sub _svp_begin {
 sub _svp_release { 1 }
 
 sub _svp_rollback {
-    my ($self, $name) = @_;
-
-    $self->_get_dbh->do("ROLLBACK TO SAVEPOINT $name")
+  my ($self, $name) = @_;
+  $self->_get_dbh->do("ROLLBACK TO SAVEPOINT $name")
 }
 
 =head2 relname_to_table_alias
diff --git a/lib/DBIx/Class/Storage/DBI/Replicated.pm b/lib/DBIx/Class/Storage/DBI/Replicated.pm
index 200483d..f8958da 100644
--- a/lib/DBIx/Class/Storage/DBI/Replicated.pm
+++ b/lib/DBIx/Class/Storage/DBI/Replicated.pm
@@ -409,7 +409,7 @@ bits get put into the correct places.
 =cut
 
 sub BUILDARGS {
-  my ($class, $schema, $storage_type_args, @args) = @_;	
+  my ($class, $schema, $storage_type_args, @args) = @_;  
 
   return {
     schema=>$schema,
diff --git a/lib/DBIx/Class/Storage/DBI/Replicated/Pool.pm b/lib/DBIx/Class/Storage/DBI/Replicated/Pool.pm
index a7a1dfa..a496512 100644
--- a/lib/DBIx/Class/Storage/DBI/Replicated/Pool.pm
+++ b/lib/DBIx/Class/Storage/DBI/Replicated/Pool.pm
@@ -280,16 +280,15 @@ sub _safely {
 
   eval {
     $code->()
-  }; 
+  };
   if ($@) {
-    $replicant
-      ->debugobj
-      ->print(
-        sprintf( "Exception trying to $name for replicant %s, error is %s",
-          $replicant->_dbi_connect_info->[0], $@)
-        );
-  	return;
+    $replicant->debugobj->print(sprintf(
+      "Exception trying to $name for replicant %s, error is %s",
+      $replicant->_dbi_connect_info->[0], $@)
+    );
+    return undef;
   }
+
   return 1;
 }
 
diff --git a/script/dbicadmin b/script/dbicadmin
index 15bec66..8c64dfd 100755
--- a/script/dbicadmin
+++ b/script/dbicadmin
@@ -1,5 +1,5 @@
-#!/usr/bin/perl
-# vim: ts=2 et
+#!/usr/bin/perl 
+
 use strict;
 use warnings;
 
@@ -8,47 +8,47 @@ use DBIx::Class::Admin;
 
 
 my ($opts, $usage) = describe_options(
-    "%c: %o",
-    (
-        ['Actions'],
-        ["action" => hidden => { one_of => [
-            ['create|c' => 'Create version diffs needs preversion',],
-            ['upgrade|u' => 'Upgrade the database to the current schema '],
-            ['install|i' => 'Install the schema to the database',],
-            ['deploy|d' => 'Deploy the a to the database',],
-            ['select|s'   => 'Select data from the schema', ],
-            ['insert|i'   => 'Insert data into the schema', ],
-            ['update|u'   => 'Update data in the schema', ], 
-            ['delete|D'   => 'Delete data from the schema',],
-            ['op:s' => 'compatiblity option all of the above can be suppied as --op=<action>'],
-            ['help|h' => 'display this help'],
-            ], required=> 1 }],
-        ['Options'],
-        ['schema-class|schema|C:s' => 'The class of the schema to load', { required => 1 } ],
-        ['resultset|resultset_class|class|r:s' => 'The resultset to operate on for data manipulation' ],
-        ['config-stanza|S:s' => 'Where in the config to find the connection_info, supply in form MyApp::Model::DB',],
-        ['config|f:s' => 'Supply the config file for parsing by Config::Any', { depends => 'config_stanza'} ],
-        ['connect-info|n:s%' => 'Supply the connect info as additonal options ie -I dsn=<dsn> user=<user> password=<pass> '],
-        ['connect:s' => 'Supply the connect info as a json string' ],
-        ['sql-dir|q:s' => 'The directory where sql diffs will be created'],
-        ['sql-type|t:s' => 'The RDBMs flavour you wish to use'],
-        ['version|v:i' => 'Supply a version install'],
-        ['preversion|p:s' => 'The previous version to diff against',],
-        ['set:s' => 'JSON data used to perform data operations' ],
-        ['lib|I:s' => 'Additonal library path to search in'], 
-        ['attrs:s' => 'JSON string to be used for the second argument for search'],
-        ['where:s' => 'JSON string to be used for the where clause of search'],
-        ['force' => 'Be forceful with some operations'],
-        ['trace' => 'Turn on DBIx::Class trace output'],
-        ['tlibs' => 'Include test dirs in @INC'],
-        ['quiet' => 'Be less verbose'],
-    )
+  "%c: %o",
+  (
+    ['Actions'],
+    ["action" => hidden => { one_of => [
+      ['create|c' => 'Create version diffs needs preversion',],
+      ['upgrade|u' => 'Upgrade the database to the current schema '],
+      ['install|i' => 'Install the schema to the database',],
+      ['deploy|d' => 'Deploy the a to the database',],
+      ['select|s'   => 'Select data from the schema', ],
+      ['insert|i'   => 'Insert data into the schema', ],
+      ['update|u'   => 'Update data in the schema', ], 
+      ['delete|D'   => 'Delete data from the schema',],
+      ['op:s' => 'compatiblity option all of the above can be suppied as --op=<action>'],
+      ['help|h' => 'display this help'],
+    ], required=> 1 }],
+    ['Options'],
+    ['schema-class|schema|C:s' => 'The class of the schema to load', { required => 1 } ],
+    ['resultset|resultset_class|class|r:s' => 'The resultset to operate on for data manipulation' ],
+    ['config-stanza|S:s' => 'Where in the config to find the connection_info, supply in form MyApp::Model::DB',],
+    ['config|f:s' => 'Supply the config file for parsing by Config::Any', { depends => 'config_stanza'} ],
+    ['connect-info|n:s%' => 'Supply the connect info as additonal options ie -I dsn=<dsn> user=<user> password=<pass> '],
+    ['connect:s' => 'Supply the connect info as a json string' ],
+    ['sql-dir|q:s' => 'The directory where sql diffs will be created'],
+    ['sql-type|t:s' => 'The RDBMs flavour you wish to use'],
+    ['version|v:i' => 'Supply a version install'],
+    ['preversion|p:s' => 'The previous version to diff against',],
+    ['set:s' => 'JSON data used to perform data operations' ],
+    ['lib|I:s' => 'Additonal library path to search in'], 
+    ['attrs:s' => 'JSON string to be used for the second argument for search'],
+    ['where:s' => 'JSON string to be used for the where clause of search'],
+    ['force' => 'Be forceful with some operations'],
+    ['trace' => 'Turn on DBIx::Class trace output'],
+    ['tlibs' => 'Include test dirs in @INC'],
+    ['quiet' => 'Be less verbose'],
+  )
 );
 
 
 if ($opts->{help}) {
-    print $usage->text;
-    exit 0;
+  print $usage->text;
+  exit 0;
 }
 
 if ($opts->{tlibs}) {
@@ -59,7 +59,7 @@ die "please only use one of --config or --connect-info" if ($opts->{config} and
 
 # option compatability mangle
 if($opts->{connect}) {
-    $opts->{connect_info} = delete $opts->{connect};
+  $opts->{connect_info} = delete $opts->{connect};
 }
 
 my $admin = DBIx::Class::Admin->new( %$opts );
@@ -73,24 +73,24 @@ my $res = $admin->$action();
 print "going to perform action $action\n";
 if ($action eq 'select') {
 
-    my $csv_class;
-    my $format = $opts->{format} || 'tsv';
-    die('Invalid format') if ($format!~/^tsv|csv$/s);
-    $csv_class = 'Text::CSV_XS';
-    eval{ require Text::CSV_XS };
-    if ($@) {
-        $csv_class = 'Text::CSV_PP';
-        eval{ require Text::CSV_PP };
-        die('The select op requires either the Text::CSV_XS or the Text::CSV_PP module') if ($@);
-    }
-
-    my $csv = $csv_class->new({
-            sep_char => ( $format eq 'tsv' ? "\t" : ',' ),
-        });
-    foreach my $row (@$res) {
-        $csv->combine( @$row );
-        print $csv->string()."\n";
-    }
+  my $csv_class;
+  my $format = $opts->{format} || 'tsv';
+  die('Invalid format') if ($format!~/^tsv|csv$/s);
+  $csv_class = 'Text::CSV_XS';
+  eval{ require Text::CSV_XS };
+  if ($@) {
+    $csv_class = 'Text::CSV_PP';
+    eval{ require Text::CSV_PP };
+    die('The select op requires either the Text::CSV_XS or the Text::CSV_PP module') if ($@);
+  }
+
+  my $csv = $csv_class->new({
+      sep_char => ( $format eq 'tsv' ? "\t" : ',' ),
+    });
+  foreach my $row (@$res) {
+    $csv->combine( @$row );
+    print $csv->string()."\n";
+  }
 }
 
 
diff --git a/t/89dbicadmin.t b/t/89dbicadmin.t
index 58b6c63..4d193ef 100644
--- a/t/89dbicadmin.t
+++ b/t/89dbicadmin.t
@@ -1,4 +1,4 @@
-# vim: filetype=perl et ts=2
+# vim: filetype=perl
 use strict;
 use warnings;  
 
@@ -64,8 +64,8 @@ sub test_dbicadmin {
         my $data = do { local $/; <$fh> };
         close($fh);
         if (!ok( ($data=~/Aran.*Trout/s), "$ENV{JSON_ANY_ORDER}: select with attrs" )) {
-            diag ("data from select is $data")
-        };
+			diag ("data from select is $data")
+		};
     }
 
     system( _prepare_system_args( qw|--op=delete --where={"name":"Trout"}| ) );
diff --git a/t/admin/02ddl.t b/t/admin/02ddl.t
index 873f24d..d65331f 100644
--- a/t/admin/02ddl.t
+++ b/t/admin/02ddl.t
@@ -1,4 +1,4 @@
-# vim: et ts=2
+#
 #===============================================================================
 #
 #         FILE:  02admin..t
@@ -40,24 +40,24 @@ use DBICTest;
 
 my $sql_dir = dir($Bin,"..","var");
 my @connect_info = DBICTest->_database(
-    no_deploy=>1,
-    no_populate=>1,
-    sqlite_use_file	=> 1,
+	no_deploy=>1,
+	no_populate=>1,
+	sqlite_use_file	=> 1,
 );
 { # create the schema
 
 #  make sure we are  clean
-    clean_dir($sql_dir);
+clean_dir($sql_dir);
 
 
-    my $admin = DBIx::Class::Admin->new(
-        schema_class=> "DBICTest::Schema",
-        sql_dir=> $sql_dir,
-        connect_info => \@connect_info, 
-    );
-    isa_ok ($admin, 'DBIx::Class::Admin', 'create the admin object');
-    lives_ok { $admin->create('MySQL'); } 'Can create MySQL sql';
-    lives_ok { $admin->create('SQLite'); } 'Can Create SQLite sql';
+my $admin = DBIx::Class::Admin->new(
+	schema_class=> "DBICTest::Schema",
+	sql_dir=> $sql_dir,
+	connect_info => \@connect_info, 
+);
+isa_ok ($admin, 'DBIx::Class::Admin', 'create the admin object');
+lives_ok { $admin->create('MySQL'); } 'Can create MySQL sql';
+lives_ok { $admin->create('SQLite'); } 'Can Create SQLite sql';
 }
 
 { # upgrade schema
@@ -68,77 +68,77 @@ my @connect_info = DBICTest->_database(
 #	sqlite_use_file	=> 1,
 #);
 
-    clean_dir($sql_dir);
-    require DBICVersionOrig;
+clean_dir($sql_dir);
+require DBICVersionOrig;
 
-    my $admin = DBIx::Class::Admin->new(
-        schema_class => 'DBICVersion::Schema', 
-        sql_dir =>  $sql_dir,
-        connect_info => \@connect_info,
-    );
+my $admin = DBIx::Class::Admin->new(
+	schema_class => 'DBICVersion::Schema', 
+	sql_dir =>  $sql_dir,
+	connect_info => \@connect_info,
+);
 
-    my $schema = $admin->schema();
+my $schema = $admin->schema();
 
-    lives_ok { $admin->create($schema->storage->sqlt_type(), {add_drop_table=>0}); } 'Can create DBICVersionOrig sql in ' . $schema->storage->sqlt_type;
-    lives_ok { $admin->deploy(  ) } 'Can Deploy schema';
+lives_ok { $admin->create($schema->storage->sqlt_type(), {add_drop_table=>0}); } 'Can create DBICVersionOrig sql in ' . $schema->storage->sqlt_type;
+lives_ok { $admin->deploy(  ) } 'Can Deploy schema';
 
 # connect to now deployed schema
-    lives_ok { $schema = DBICVersion::Schema->connect(@{$schema->storage->connect_info()}); } 'Connect to deployed Database';
+lives_ok { $schema = DBICVersion::Schema->connect(@{$schema->storage->connect_info()}); } 'Connect to deployed Database';
 
-    is($schema->get_db_version, $DBICVersion::Schema::VERSION, 'Schema deployed and versions match');
+is($schema->get_db_version, $DBICVersion::Schema::VERSION, 'Schema deployed and versions match');
 
 
-    require DBICVersionNew;
+require DBICVersionNew;
 
-    $admin = DBIx::Class::Admin->new(
-        schema_class => 'DBICVersion::Schema', 
-        sql_dir =>  "t/var",
-        connect_info => \@connect_info
-    );
+$admin = DBIx::Class::Admin->new(
+	schema_class => 'DBICVersion::Schema', 
+	sql_dir =>  "t/var",
+	connect_info => \@connect_info
+);
 
-    lives_ok { $admin->create($schema->storage->sqlt_type(), {}, "1.0" ); } 'Can create diff for ' . $schema->storage->sqlt_type;
+lives_ok { $admin->create($schema->storage->sqlt_type(), {}, "1.0" ); } 'Can create diff for ' . $schema->storage->sqlt_type;
 # sleep required for upgrade table to hold a distinct time of upgrade value
 # otherwise the returned of get_db_version can be undeterministic
-    sleep 1;
-    lives_ok {$admin->upgrade();} 'upgrade the schema';
+sleep 1;
+lives_ok {$admin->upgrade();} 'upgrade the schema';
 
-    is($schema->get_db_version, $DBICVersion::Schema::VERSION, 'Schema and db versions match');
+is($schema->get_db_version, $DBICVersion::Schema::VERSION, 'Schema and db versions match');
 
 }
 
 { # install
 
-    clean_dir($sql_dir);
-
-    my $admin = DBIx::Class::Admin->new(
-        schema_class	=> 'DBICVersion::Schema', 
-        sql_dir			=> $sql_dir,
-        _confirm		=> 1,
-        connect_info	=> \@connect_info,
-    );
-
-    $admin->version("3.0");
-    lives_ok { $admin->install(); } 'install schema version 3.0';
-    is($admin->schema->get_db_version, "3.0", 'db thinks its version 3.0');
-    dies_ok { $admin->install("4.0"); } 'cannot install to allready existing version';
-    sleep 1;
-    $admin->force(1);
-    lives_ok { $admin->install("4.0"); } 'can force install to allready existing version';
-    is($admin->schema->get_db_version, "4.0", 'db thinks its version 4.0');
+clean_dir($sql_dir);
+
+my $admin = DBIx::Class::Admin->new(
+	schema_class	=> 'DBICVersion::Schema', 
+	sql_dir			=> $sql_dir,
+	_confirm		=> 1,
+	connect_info	=> \@connect_info,
+);
+
+$admin->version("3.0");
+lives_ok { $admin->install(); } 'install schema version 3.0';
+is($admin->schema->get_db_version, "3.0", 'db thinks its version 3.0');
+dies_ok { $admin->install("4.0"); } 'cannot install to allready existing version';
+sleep 1;
+$admin->force(1);
+lives_ok { $admin->install("4.0"); } 'can force install to allready existing version';
+is($admin->schema->get_db_version, "4.0", 'db thinks its version 4.0');
 #clean_dir($sql_dir);
 }
 
 sub clean_dir {
-    my ($dir)  =@_;
-    $dir = $dir->resolve;
-    if ( ! -d $dir ) {
-        $dir->mkpath();
-    }
-    foreach my $file ($dir->children) {
-        # skip any hidden files
-        next if ($file =~ /^\./); 
-        unlink $file;
-    }
+	my ($dir)  =@_;
+	$dir = $dir->resolve;
+	if ( ! -d $dir ) {
+		$dir->mkpath();
+	}
+	foreach my $file ($dir->children) {
+		# skip any hidden files
+		next if ($file =~ /^\./); 
+		unlink $file;
+	}
 }
 
 done_testing;
diff --git a/t/admin/03data.t b/t/admin/03data.t
index b7f697d..1d51c26 100644
--- a/t/admin/03data.t
+++ b/t/admin/03data.t
@@ -1,4 +1,4 @@
-# vim: et ts=2
+#
 #===============================================================================
 #
 #         FILE:  03sql.t
@@ -40,49 +40,49 @@ use DBICTest;
 
 { # test data maniplulation functions
 
-    # create a DBICTest so we can steal its connect info
-    my $schema = DBICTest->init_schema(
-        #    no_deploy=>1,
-        #	no_populate=>1,
-        sqlite_use_file => 1,
-    );
-
-
-    my $admin = DBIx::Class::Admin->new(
-        schema_class=> "DBICTest::Schema",
-        connect_info => $schema->storage->connect_info(),
-        quiet	=> 1,
-        _confirm=>1,
-    );
-    isa_ok ($admin, 'DBIx::Class::Admin', 'create the admin object');
-
-    $admin->insert('Employee', { name => 'Matt' });
-    my $employees = $schema->resultset('Employee');
-    is ($employees->count(), 1, "insert okay" );
-
-    my $employee = $employees->find(1);
-    is($employee->name(),  'Matt', "insert valid" );
-
-    $admin->update('Employee', {name => 'Trout'}, {name => 'Matt'});
-
-    $employee = $employees->find(1);
-    is($employee->name(),  'Trout', "update Matt to Trout" );
-
-    $admin->insert('Employee', {name =>'Aran'});
-
-    my $expected_data = [ 
-    [$employee->result_source->columns() ],
-    [1,1,undef,undef,undef,'Trout'],
-    [2,2,undef,undef,undef,'Aran']
-    ];
-    my $data;
-    lives_ok { $data = $admin->select('Employee')} 'can retrive data from database';
-    cmp_deeply($data, $expected_data, 'DB matches whats expected');
-
-    $admin->delete('Employee', {name=>'Trout'});
-    my $del_rs  = $employees->search({name => 'Trout'});
-    is($del_rs->count(), 0, "delete Trout" );
-    is ($employees->count(), 1, "left Aran" );
+	# create a DBICTest so we can steal its connect info
+	my $schema = DBICTest->init_schema(
+	#    no_deploy=>1,
+	#	no_populate=>1,
+		sqlite_use_file => 1,
+		);
+
+
+	my $admin = DBIx::Class::Admin->new(
+		schema_class=> "DBICTest::Schema",
+		connect_info => $schema->storage->connect_info(),
+		quiet	=> 1,
+		_confirm=>1,
+	);
+	isa_ok ($admin, 'DBIx::Class::Admin', 'create the admin object');
+
+	$admin->insert('Employee', { name => 'Matt' });
+	my $employees = $schema->resultset('Employee');
+	is ($employees->count(), 1, "insert okay" );
+
+	my $employee = $employees->find(1);
+	is($employee->name(),  'Matt', "insert valid" );
+
+	$admin->update('Employee', {name => 'Trout'}, {name => 'Matt'});
+
+	$employee = $employees->find(1);
+	is($employee->name(),  'Trout', "update Matt to Trout" );
+
+	$admin->insert('Employee', {name =>'Aran'});
+
+	my $expected_data = [ 
+		[$employee->result_source->columns() ],
+		[1,1,undef,undef,undef,'Trout'],
+		[2,2,undef,undef,undef,'Aran']
+	];
+	my $data;
+	lives_ok { $data = $admin->select('Employee')} 'can retrive data from database';
+	cmp_deeply($data, $expected_data, 'DB matches whats expected');
+
+	$admin->delete('Employee', {name=>'Trout'});
+	my $del_rs  = $employees->search({name => 'Trout'});
+	is($del_rs->count(), 0, "delete Trout" );
+	is ($employees->count(), 1, "left Aran" );
 }
 
 
diff --git a/t/lib/DBICTest.pm b/t/lib/DBICTest.pm
index 66a79e8..8006961 100644
--- a/t/lib/DBICTest.pm
+++ b/t/lib/DBICTest.pm
@@ -32,7 +32,7 @@ DBIx::Class.
     no_populate=>1,
     storage_type=>'::DBI::Replicated',
     storage_type_args=>{
-    	balancer_type=>'DBIx::Class::Storage::DBI::Replicated::Balancer::Random'
+      balancer_type=>'DBIx::Class::Storage::DBI::Replicated::Balancer::Random'
     },
   );
 
@@ -48,7 +48,7 @@ default, unless the no_deploy or no_populate flags are set.
 =cut
 
 sub has_custom_dsn {
-	return $ENV{"DBICTEST_DSN"} ? 1:0;
+    return $ENV{"DBICTEST_DSN"} ? 1:0;
 }
 
 sub _sqlite_dbfilename {
@@ -59,7 +59,7 @@ sub _sqlite_dbname {
     my $self = shift;
     my %args = @_;
     return $self->_sqlite_dbfilename if $args{sqlite_use_file} or $ENV{"DBICTEST_SQLITE_USE_FILE"};
-	return ":memory:";
+    return ":memory:";
 }
 
 sub _database {
@@ -85,7 +85,7 @@ sub init_schema {
     my %args = @_;
 
     my $schema;
-    
+
     if ($args{compose_connection}) {
       $schema = DBICTest::Schema->compose_connection(
                   'DBICTest', $self->_database(%args)
@@ -94,8 +94,8 @@ sub init_schema {
       $schema = DBICTest::Schema->compose_namespace('DBICTest');
     }
     if( $args{storage_type}) {
-    	$schema->storage_type($args{storage_type});
-    }    
+      $schema->storage_type($args{storage_type});
+    }
     if ( !$args{no_connect} ) {
       $schema = $schema->connect($self->_database(%args));
       $schema->storage->on_connect_do(['PRAGMA synchronous = OFF'])
diff --git a/t/lib/DBICTest/Schema/ForceForeign.pm b/t/lib/DBICTest/Schema/ForceForeign.pm
index 8e2daeb..c340d8b 100644
--- a/t/lib/DBICTest/Schema/ForceForeign.pm
+++ b/t/lib/DBICTest/Schema/ForceForeign.pm
@@ -12,30 +12,21 @@ __PACKAGE__->set_primary_key(qw/artist/);
 
 # Normally this would not appear as a FK constraint
 # since it uses the PK
-__PACKAGE__->might_have(
-			'artist_1', 'DBICTest::Schema::Artist', {
-			    'foreign.artistid' => 'self.artist',
-			}, {
-			    is_foreign_key_constraint => 1,
-			},
+__PACKAGE__->might_have('artist_1', 'DBICTest::Schema::Artist',
+  { 'foreign.artistid' => 'self.artist' },
+  { is_foreign_key_constraint => 1 },
 );
 
 # Normally this would appear as a FK constraint
-__PACKAGE__->might_have(
-			'cd_1', 'DBICTest::Schema::CD', {
-			    'foreign.cdid' => 'self.cd',
-			}, {
-			    is_foreign_key_constraint => 0,
-			},
+__PACKAGE__->might_have('cd_1', 'DBICTest::Schema::CD',
+  { 'foreign.cdid' => 'self.cd' },
+  { is_foreign_key_constraint => 0 },
 );
 
 # Normally this would appear as a FK constraint
-__PACKAGE__->belongs_to(
-			'cd_3', 'DBICTest::Schema::CD', {
-			    'foreign.cdid' => 'self.cd',
-			}, {
-			    is_foreign_key_constraint => 0,
-			},
+__PACKAGE__->belongs_to('cd_3', 'DBICTest::Schema::CD',
+  { 'foreign.cdid' => 'self.cd' },
+  { is_foreign_key_constraint => 0 },
 );
 
 1;