X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FSchema.pm;h=d492dc16059be76f3f74338428f9e21c1e74b91f;hb=762a7bb2be8c357381bbcb2b179443b3d519ba4e;hp=8385e1d8b2c83dfe98a4142681839a014ede5d18;hpb=87772e46b99bc03f36c5a82ec29282a3228c29c7;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/Schema.pm b/lib/DBIx/Class/Schema.pm
index 8385e1d..d492dc1 100644
--- a/lib/DBIx/Class/Schema.pm
+++ b/lib/DBIx/Class/Schema.pm
@@ -2,13 +2,14 @@ package DBIx::Class::Schema;
 
 use strict;
 use warnings;
-use DBIx::Class::DB;
+
+use Carp::Clan qw/^DBIx::Class/;
 
 use base qw/DBIx::Class/;
 
-__PACKAGE__->load_components(qw/Exception/);
-__PACKAGE__->mk_classdata('class_registrations' => {});
-__PACKAGE__->mk_classdata('storage_type' => 'DBI');
+__PACKAGE__->mk_classdata('class_mappings' => {});
+__PACKAGE__->mk_classdata('source_registrations' => {});
+__PACKAGE__->mk_classdata('storage_type' => '::DBI');
 __PACKAGE__->mk_classdata('storage');
 
 =head1 NAME
@@ -17,40 +18,35 @@ DBIx::Class::Schema - composable schemas
 
 =head1 SYNOPSIS
 
-in My/Schema.pm
-
   package My::Schema;
-
   use base qw/DBIx::Class::Schema/;
-
+  
+  # load My::Schema::Foo, My::Schema::Bar, My::Schema::Baz
   __PACKAGE__->load_classes(qw/Foo Bar Baz/);
 
-in My/Schema/Foo.pm
-
   package My::Schema::Foo;
-
   use base qw/DBIx::Class/;
-
   __PACKAGE__->load_components(qw/PK::Auto::Pg Core/); # for example
   __PACKAGE__->table('foo');
-  ...
-
-in My/DB.pm
 
-  use My::Schema;
+  my $schema1 = My::Schema->connect(
+    $dsn,
+    $user,
+    $password,
+    $attrs
+  );
 
-  My::Schema->compose_connection('My::DB', $dsn, $user, $pass, $attrs);
+  my $schema2 = My::Schema->connect( ... );
 
-then in app code
-
-  my @obj = My::DB::Foo->search({}); # My::DB::Foo isa My::Schema::Foo My::DB
+  # fetch objects using My::Schema::Foo
+  my $resultset = $schema1->resultset('Foo')->search( ... );
+  my @objects = $schema2->resultset('Foo')->search( ... );
 
 =head1 DESCRIPTION
 
-Creates database classes based on a schema. This allows you to have more than
-one concurrent connection using the same database classes, by making 
-subclasses under a new namespace for each connection. If you only need one 
-class, you should probably use L<DBIx::Class::DB> directly instead.
+Creates database classes based on a schema. This is the recommended way to
+use L<DBIx::Class> and allows you to use more than one concurrent connection
+with your classes.
 
 NB: If you're used to L<Class::DBI> it's worth reading the L</SYNOPSIS>
 carefully as DBIx::Class does things a little differently. Note in
@@ -58,45 +54,49 @@ particular which module inherits off which.
 
 =head1 METHODS
 
-=head2 register_class <component> <component_class>
+=head2 register_class <moniker> <component_class>
+
+Registers a class which isa ResultSourceProxy; equivalent to calling
 
-Registers the class in the schema's class_registrations. This is a hash
-containing database classes, keyed by their monikers. It's used by
-compose_connection to create/modify all the existing database classes.
+  $schema->register_source($moniker, $class->result_source_instance);
 
 =cut
 
 sub register_class {
-  my ($self, $name, $to_register) = @_;
-  my %reg = %{$self->class_registrations};
-  $reg{$name} = $to_register;
-  $self->class_registrations(\%reg);
-  $to_register->result_source->schema($self);
+  my ($self, $moniker, $to_register) = @_;
+  $self->register_source($moniker => $to_register->result_source_instance);
 }
 
-=head2 registered_classes
-
-Simple read-only accessor for the schema's registered classes. See 
-register_class above if you want to modify it.
+=head2 register_source <moniker> <result source>
 
+Registers the result source in the schema with the given moniker
 
 =cut
 
-sub registered_classes {
-  return values %{shift->class_registrations};
-}
+sub register_source {
+  my ($self, $moniker, $source) = @_;
+  my %reg = %{$self->source_registrations};
+  $reg{$moniker} = $source;
+  $self->source_registrations(\%reg);
+  $source->schema($self);
+  if ($source->result_class) {
+    my %map = %{$self->class_mappings};
+    $map{$source->result_class} = $moniker;
+    $self->class_mappings(\%map);
+  }
+} 
 
 =head2 class
 
   my $class = $schema->class('Foo');
 
-Shortcut to retrieve a single class by its registered name
+Retrieves the result class name for a given result source
 
 =cut
 
 sub class {
-  my ($self, $class) = @_;
-  return $self->class_registrations->{$class};
+  my ($self, $moniker) = @_;
+  return $self->source($moniker)->result_class;
 }
 
 =head2 source
@@ -108,25 +108,40 @@ Returns the result source object for the registered name
 =cut
 
 sub source {
-  my ($self, $class) = @_;
-  return $self->class_registrations->{$class}->result_source
-    if $self->class_registrations->{$class};
+  my ($self, $moniker) = @_;
+  my $sreg = $self->source_registrations;
+  return $sreg->{$moniker} if exists $sreg->{$moniker};
+
+  # if we got here, they probably passed a full class name
+  my $mapped = $self->class_mappings->{$moniker};
+  $self->throw_exception("Can't find source for ${moniker}")
+    unless $mapped && exists $sreg->{$mapped};
+  return $sreg->{$mapped};
 }
 
+=head2 sources
+
+  my @source_monikers = $schema->sources;
+
+Returns the source monikers of all source registrations on this schema
+
+=cut
+
+sub sources { return keys %{shift->source_registrations}; }
+
 =head2 resultset
 
   my $rs = $schema->resultset('Foo');
 
-Returns the resultset for the registered name
+Returns the resultset for the registered moniker
 
 =cut
 
 sub resultset {
-  my ($self, $class) = @_;
-  return $self->class_registrations->{$class}->result_source->resultset;
+  my ($self, $moniker) = @_;
+  return $self->source($moniker)->resultset;
 }
 
-
 =head2  load_classes [<classes>, (<class>, <class>), {<namespace> => [<classes>]}]
 
 Uses L<Module::Find> to find all classes under the database class' namespace,
@@ -168,7 +183,7 @@ sub load_classes {
     }
   } else {
     eval "require Module::Find;";
-    $class->throw("No arguments to load_classes and couldn't load".
+    $class->throw_exception("No arguments to load_classes and couldn't load".
       " Module::Find ($@)") if $@;
     my @comp = map { substr $_, length "${class}::"  } Module::Find::findallmod($class);
     $comps_for{$class} = \@comp;
@@ -182,6 +197,7 @@ sub load_classes {
         die $@ unless $@ =~ /Can't locate/;
       }
       $class->register_class($comp => $comp_class);
+      #  if $class->can('result_source_instance');
     }
   }
 }
@@ -212,41 +228,63 @@ you expect.
 
 sub compose_connection {
   my ($self, $target, @info) = @_;
-  my $conn_class = "${target}::_db";
-  $self->setup_connection_class($conn_class, @info);
-  my $schema = $self->compose_namespace($target, $conn_class);
-  $schema->storage($conn_class->storage);
-  foreach my $class ($schema->registered_classes) {
-    my $source = $class->result_source;
-    $source = $source->new($source);
-    $source->schema($schema);
-    $source->result_class($class);
-    $class->mk_classdata(result_source => $source);
+  my $base = 'DBIx::Class::ResultSetProxy';
+  eval "require ${base};";
+  $self->throw_exception("No arguments to load_classes and couldn't load".
+      " ${base} ($@)") if $@;
+
+  if ($self eq $target) {
+    # Pathological case, largely caused by the docs on early C::M::DBIC::Plain
+    foreach my $moniker ($self->sources) {
+      my $source = $self->source($moniker);
+      my $class = $source->result_class;
+      $self->inject_base($class, $base);
+      $class->mk_classdata(resultset_instance => $source->resultset);
+      $class->mk_classdata(class_resolver => $self);
+    }
+    $self->connection(@info);
+    return $self;
+  }
+
+  my $schema = $self->compose_namespace($target, $base);
+  {
+    no strict 'refs';
+    *{"${target}::schema"} = sub { $schema };
+  }
+
+  $schema->connection(@info);
+  foreach my $moniker ($schema->sources) {
+    my $source = $schema->source($moniker);
+    my $class = $source->result_class;
+    #warn "$moniker $class $source ".$source->storage;
+    $class->mk_classdata(result_source_instance => $source);
     $class->mk_classdata(resultset_instance => $source->resultset);
+    $class->mk_classdata(class_resolver => $schema);
   }
   return $schema;
 }
 
 sub compose_namespace {
-  my ($class, $target, $base) = @_;
-  my %reg = %{ $class->class_registrations };
+  my ($self, $target, $base) = @_;
+  my %reg = %{ $self->source_registrations };
   my %target;
   my %map;
-  my $schema = bless({ }, $class);
-  while (my ($comp, $comp_class) = each %reg) {
-    my $target_class = "${target}::${comp}";
-    $class->inject_base($target_class, $comp_class, ($base ? $base : ()));
-    @map{$comp, $comp_class} = ($target_class, $target_class);
+  my $schema = $self->clone;
+  foreach my $moniker ($schema->sources) {
+    my $source = $schema->source($moniker);
+    my $target_class = "${target}::${moniker}";
+    $self->inject_base(
+      $target_class => $source->result_class, ($base ? $base : ())
+    );
+    $source->result_class($target_class);
   }
-  $schema->class_registrations(\%map);
   {
     no strict 'refs';
-    *{"${target}::schema"} =
-      sub { $schema };
-    *{"${target}::class"} =
-      sub { shift->schema->class(@_) };
+    foreach my $meth (qw/class source resultset/) {
+      *{"${target}::${meth}"} =
+        sub { shift->schema->$meth(@_) };
+    }
   }
-  $base->class_resolver($target);
   return $schema;
 }
 
@@ -264,6 +302,115 @@ sub setup_connection_class {
   $target->connection(@info);
 }
 
+=head2 connection(@args)
+
+Instantiates a new Storage object of type storage_type and passes the
+arguments to $storage->connect_info. Sets the connection in-place on
+the schema.
+
+=cut
+
+sub connection {
+  my ($self, @info) = @_;
+  my $storage_class = $self->storage_type;
+  $storage_class = 'DBIx::Class::Storage'.$storage_class
+    if $storage_class =~ m/^::/;
+  eval "require ${storage_class};";
+  $self->throw_exception("No arguments to load_classes and couldn't load".
+      " ${storage_class} ($@)") if $@;
+  my $storage = $storage_class->new;
+  $storage->connect_info(\@info);
+  $self->storage($storage);
+  return $self;
+}
+
+=head2 connect(@info)
+
+Conveneience method, equivalent to $schema->clone->connection(@info)
+
+=cut
+
+sub connect { shift->clone->connection(@_) }
+
+=head2 txn_begin
+
+Begins a transaction (does nothing if AutoCommit is off).
+
+=cut
+
+sub txn_begin { shift->storage->txn_begin }
+
+=head2 txn_commit
+
+Commits the current transaction.
+
+=cut
+
+sub txn_commit { shift->storage->txn_commit }
+
+=head2 txn_rollback
+
+Rolls back the current transaction.
+
+=cut
+
+sub txn_rollback { shift->storage->txn_rollback }
+
+=head2 clone
+
+Clones the schema and its associated result_source objects and returns the
+copy.
+
+=cut
+
+sub clone {
+  my ($self) = @_;
+  my $clone = bless({ (ref $self ? %$self : ()) }, ref $self || $self);
+  foreach my $moniker ($self->sources) {
+    my $source = $self->source($moniker);
+    my $new = $source->new($source);
+    $clone->register_source($moniker => $new);
+  }
+  return $clone;
+}
+
+=head2 populate($moniker, \@data);
+
+Populates the source registered with the given moniker with the supplied data.
+@data should be a list of listrefs, the first containing column names, the
+second matching values - i.e.
+
+$schema->populate('Foo', [
+  [ qw/foo_id foo_string/ ],
+  [ 1, 'One' ],
+  [ 2, 'Two' ],
+  ...
+]);
+
+=cut
+
+sub populate {
+  my ($self, $name, $data) = @_;
+  my $rs = $self->resultset($name);
+  my @names = @{shift(@$data)};
+  foreach my $item (@$data) {
+    my %create;
+    @create{@names} = @$item;
+    $rs->create(\%create);
+  }
+}
+
+=head2 throw_exception
+
+Defaults to using Carp::Clan to report errors from user perspective.
+
+=cut
+
+sub throw_exception {
+  my ($self) = shift;
+  croak @_;
+}
+
 1;
 
 =head1 AUTHORS