use strict;
use warnings;
-use base qw/DBIx::Class::Schema Class::Data::Accessor/;
+use base qw/DBIx::Class::Schema Class::Accessor::Grouped/;
+use MRO::Compat;
+use mro 'c3';
use Carp::Clan qw/^DBIx::Class/;
-use UNIVERSAL::require;
-use Class::C3;
-use Scalar::Util qw/ weaken /;
+use Scalar::Util 'weaken';
+use Sub::Util 'set_subname';
+use DBIx::Class::Schema::Loader::Utils 'array_eq';
+use Try::Tiny;
+use Hash::Merge 'merge';
+use namespace::clean;
# Always remember to do all digits for the version even if they're 0
# i.e. first release of 0.XX *must* be 0.XX000. This avoids fBSD ports
# brain damage and presumably various other packaging systems too
-our $VERSION = '0.04005';
+our $VERSION = '0.07047';
-__PACKAGE__->mk_classaccessor('_loader_args' => {});
-__PACKAGE__->mk_classaccessors(qw/dump_to_dir _loader_invoked _loader/);
+__PACKAGE__->mk_group_accessors('inherited', qw/
+ _loader_args
+ dump_to_dir
+ _loader_invoked
+ _loader
+ loader_class
+ naming
+ use_namespaces
+/);
+__PACKAGE__->_loader_args({});
+
+=encoding UTF-8
=head1 NAME
-DBIx::Class::Schema::Loader - Dynamic definition of a DBIx::Class::Schema
+DBIx::Class::Schema::Loader - Create a DBIx::Class::Schema based on a database
=head1 SYNOPSIS
- package My::Schema;
- use base qw/DBIx::Class::Schema::Loader/;
+ ### use this module to generate a set of class files
+
+ # in a script
+ use DBIx::Class::Schema::Loader qw/ make_schema_at /;
+ make_schema_at(
+ 'My::Schema',
+ { debug => 1,
+ dump_directory => './lib',
+ },
+ [ 'dbi:Pg:dbname="foo"', 'myuser', 'mypassword',
+ { loader_class => 'MyLoader' } # optionally
+ ],
+ );
- __PACKAGE__->loader_options(
- constraint => '^foo.*',
- # debug => 1,
- );
+ # from the command line or a shell script with dbicdump (distributed
+ # with this module). Do `perldoc dbicdump` for usage.
+ dbicdump -o dump_directory=./lib \
+ -o components='["InflateColumn::DateTime"]' \
+ -o debug=1 \
+ My::Schema \
+ 'dbi:Pg:dbname=foo' \
+ myuser \
+ mypassword
+
+ ### or generate and load classes at runtime
+ # note: this technique is not recommended
+ # for use in production code
+
+ package My::Schema;
+ use base qw/DBIx::Class::Schema::Loader/;
+
+ __PACKAGE__->loader_options(
+ constraint => '^foo.*',
+ # debug => 1,
+ );
- # in seperate application code ...
+ #### in application code elsewhere:
- use My::Schema;
+ use My::Schema;
- my $schema1 = My::Schema->connect( $dsn, $user, $password, $attrs);
- # -or-
- my $schema1 = "My::Schema"; $schema1->connection(as above);
+ my $schema1 = My::Schema->connect( $dsn, $user, $password, $attrs);
+ # -or-
+ my $schema1 = "My::Schema"; $schema1->connection(as above);
-=head1 DESCRIPTION
+=head1 DESCRIPTION
DBIx::Class::Schema::Loader automates the definition of a
-L<DBIx::Class::Schema> by scanning database table definitions and
-setting up the columns, primary keys, and relationships.
+L<DBIx::Class::Schema> by scanning database table definitions and setting up
+the columns, primary keys, unique constraints and relationships.
+
+See L<dbicdump> for the C<dbicdump> utility.
-DBIx::Class::Schema::Loader currently supports only the DBI storage type.
-It has explicit support for L<DBD::Pg>, L<DBD::mysql>, L<DBD::DB2>,
-L<DBD::SQLite>, and L<DBD::Oracle>. Other DBI drivers may function to
-a greater or lesser degree with this loader, depending on how much of the
-DBI spec they implement, and how standard their implementation is.
+DBIx::Class::Schema::Loader currently supports only the DBI storage type. It
+has explicit support for L<DBD::Pg>, L<DBD::mysql>, L<DBD::DB2>,
+L<DBD::Firebird>, L<DBD::InterBase>, L<DBD::Informix>, L<DBD::SQLAnywhere>,
+L<DBD::SQLite>, L<DBD::Sybase> (for Sybase ASE and MSSSQL), L<DBD::ODBC> (for
+MSSQL, MSAccess, Firebird and SQL Anywhere) L<DBD::ADO> (for MSSQL and
+MSAccess) and L<DBD::Oracle>. Other DBI drivers may function to a greater or
+lesser degree with this loader, depending on how much of the DBI spec they
+implement, and how standard their implementation is.
Patches to make other DBDs work correctly welcome.
See L<DBIx::Class::Schema::Loader::DBI::Writing> for notes on writing
your own vendor-specific subclass for an unsupported DBD driver.
-This module requires L<DBIx::Class> 0.07006 or later, and obsoletes
-the older L<DBIx::Class::Loader>.
+This module requires L<DBIx::Class> 0.08127 or later, and obsoletes the older
+L<DBIx::Class::Loader>.
-This module is designed more to get you up and running quickly against
-an existing database, or to be effective for simple situations, rather
-than to be what you use in the long term for a complex database/project.
-
-That being said, transitioning your code from a Schema generated by this
-module to one that doesn't use this module should be straightforward and
-painless, so don't shy away from it just for fears of the transition down
-the road.
+See L<DBIx::Class::Schema::Loader::Base> for available options.
=head1 METHODS
+=head2 loader
+
+The loader object, as class data on your Schema. For methods available see
+L<DBIx::Class::Schema::Loader::Base> and L<DBIx::Class::Schema::Loader::DBI>.
+
+=cut
+
+sub loader {
+ my $self = shift;
+ $self->_loader(@_);
+}
+
+=head2 loader_class
+
+=over 4
+
+=item Argument: $loader_class
+
+=back
+
+Set the loader class to be instantiated when L</connection> is called.
+If the classname starts with "::", "DBIx::Class::Schema::Loader" is
+prepended. Defaults to L<DBIx::Class::Schema/storage_type> (which must
+start with "::" when using L<DBIx::Class::Schema::Loader>).
+
+This is mostly useful for subclassing existing loaders or in conjunction
+with L</dump_to_dir>.
+
=head2 loader_options
+=over 4
+
+=item Argument: \%loader_options
+
+=back
+
Example in Synopsis above demonstrates a few common arguments. For
detailed information on all of the arguments, most of which are
only useful in fairly complex scenarios, see the
sub loader_options {
my $self = shift;
-
+
my %args = (ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
$self->_loader_args(\%args);
my $args = $self->_loader_args;
- # set up the schema/schema_class arguments
- $args->{schema} = $self;
+ # temporarily copy $self's storage to class
+ my $class_storage = $class->storage;
+ if (ref $self) {
+ $class->storage($self->storage);
+ $class->storage->set_schema($class);
+ }
+
+ $args->{schema} = $class;
$args->{schema_class} = $class;
- weaken($args->{schema}) if ref $self;
$args->{dump_directory} ||= $self->dump_to_dir;
+ $args->{naming} = $self->naming if $self->naming;
+ $args->{use_namespaces} = $self->use_namespaces if defined $self->use_namespaces;
# XXX this only works for relative storage_type, like ::DBI ...
- my $impl = "DBIx::Class::Schema::Loader" . $self->storage_type;
- $impl->require or
- croak qq/Could not load storage_type loader "$impl": / .
- qq/"$UNIVERSAL::require::ERROR"/;
+ my $loader_class = $self->loader_class;
+ if ($loader_class) {
+ $loader_class = "DBIx::Class::Schema::Loader${loader_class}" if $loader_class =~ /^::/;
+ $args->{loader_class} = $loader_class;
+ };
+
+ my $impl = $loader_class || "DBIx::Class::Schema::Loader" . $self->storage_type;
+ try {
+ $self->ensure_class_loaded($impl)
+ }
+ catch {
+ croak qq/Could not load loader_class "$impl": "$_"/;
+ };
- $self->_loader($impl->new(%$args));
- $self->_loader->load;
- $self->_loader_invoked(1);
+ $class->loader($impl->new(%$args));
+ $class->loader->load;
+ $class->_loader_invoked(1);
- $self;
+ # copy to $self
+ if (ref $self) {
+ $self->loader($class->loader);
+ $self->_loader_invoked(1);
+
+ $self->_merge_state_from($class);
+ }
+
+ # restore $class's storage
+ $class->storage($class_storage);
+
+ return $self;
+}
+
+# FIXME This needs to be moved into DBIC at some point, otherwise we are
+# maintaining things to do with DBIC guts, which we have no business of
+# maintaining. But at the moment it would be just dead code in DBIC, so we'll
+# maintain it here.
+sub _merge_state_from {
+ my ($self, $from) = @_;
+
+ my $orig_class_mappings = $self->class_mappings;
+ my $orig_source_registrations = $self->source_registrations;
+
+ $self->_copy_state_from($from);
+
+ $self->class_mappings(merge($orig_class_mappings, $self->class_mappings))
+ if $orig_class_mappings;
+
+ $self->source_registrations(merge($orig_source_registrations, $self->source_registrations))
+ if $orig_source_registrations;
+}
+
+sub _copy_state_from {
+ my $self = shift;
+ my ($from) = @_;
+
+ # older DBIC's do not have this method
+ if (try { DBIx::Class->VERSION('0.08197'); 1 }) {
+ return $self->next::method(@_);
+ }
+ else {
+ # this is a copy from DBIC git master pre 0.08197
+ $self->class_mappings({ %{$from->class_mappings} });
+ $self->source_registrations({ %{$from->source_registrations} });
+
+ foreach my $moniker ($from->sources) {
+ my $source = $from->source($moniker);
+ my $new = $source->new($source);
+ # we use extra here as we want to leave the class_mappings as they are
+ # but overwrite the source_registrations entry with the new source
+ $self->register_extra_source($moniker => $new);
+ }
+
+ if ($from->storage) {
+ $self->storage($from->storage);
+ $self->storage->set_schema($self);
+ }
+ }
}
=head2 connection
-See L<DBIx::Class::Schema> for basic usage.
+=over 4
+
+=item Arguments: @args
+
+=item Return Value: $new_schema
+
+=back
+
+See L<DBIx::Class::Schema/connection> for basic usage.
-If the final argument is a hashref, and it contains a key C<loader_options>,
-that key will be deleted, and its value will be used for the loader options,
-just as if set via the L</loader_options> method above.
+If the final argument is a hashref, and it contains the keys C<loader_options>
+or C<loader_class>, those keys will be deleted, and their values value will be
+used for the loader options or class, respectively, just as if set via the
+L</loader_options> or L</loader_class> methods above.
The actual auto-loading operation (the heart of this module) will be invoked
as soon as the connection information is defined.
=cut
sub connection {
- my $self = shift;
+ my $self = shift;
+ my $class = ref $self || $self;
if($_[-1] && ref $_[-1] eq 'HASH') {
- if(my $loader_opts = delete $_[-1]->{loader_options}) {
- $self->loader_options($loader_opts);
- pop @_ if !keys %{$_[-1]};
+ for my $option (qw/loader_class loader_options/) {
+ if(my $value = delete $_[-1]->{$option}) {
+ $self->$option($value);
+ }
}
+ pop @_ if !keys %{$_[-1]};
}
- $self = $self->next::method(@_);
+ # Make sure we inherit from schema_base_class and load schema_components
+ # before connecting.
+ require DBIx::Class::Schema::Loader::Base;
+ my $temp_loader = DBIx::Class::Schema::Loader::Base->new(
+ %{ $self->_loader_args },
+ schema => $self,
+ naming => 'current',
+ use_namespaces => 1,
+ );
+
+ my $modify_isa = 0;
+ my @components;
+
+ if ($temp_loader->schema_base_class || $temp_loader->schema_components) {
+ @components = @{ $temp_loader->schema_components }
+ if $temp_loader->schema_components;
+
+ push @components, ('+'.$temp_loader->schema_base_class)
+ if $temp_loader->schema_base_class;
+
+ my $class_isa = do {
+ no strict 'refs';
+ \@{"${class}::ISA"};
+ };
+
+ my @component_classes = map {
+ /^\+/ ? substr($_, 1, length($_) - 1) : "DBIx::Class::$_"
+ } @components;
+
+ $modify_isa++ if not array_eq([ @$class_isa[0..(@components-1)] ], \@component_classes)
+ }
+
+ if ($modify_isa) {
+ $class->load_components(@components);
+
+ # This hack is necessary because we changed @ISA of $self through
+ # ->load_components and we are now in a different place in the mro.
+ no warnings 'redefine';
+
+ local *connection = set_subname __PACKAGE__.'::connection' => sub {
+ my $self = shift;
+ $self->next::method(@_);
+ };
+
+ my @linear_isa = @{ mro::get_linear_isa($class) };
+
+ my $next_method;
+
+ foreach my $i (1..$#linear_isa) {
+ no strict 'refs';
+ $next_method = *{$linear_isa[$i].'::connection'}{CODE};
+ last if $next_method;
+ }
+
+ $self = $self->$next_method(@_);
+ }
+ else {
+ $self = $self->next::method(@_);
+ }
- my $class = ref $self || $self;
if(!$class->_loader_invoked) {
$self->_invoke_loader
}
=head2 clone
-See L<DBIx::Class::Schema>.
+See L<DBIx::Class::Schema/clone>.
=cut
=head2 dump_to_dir
-Argument: directory name.
+=over 4
+
+=item Argument: $directory
+
+=back
Calling this as a class method on either L<DBIx::Class::Schema::Loader>
-or any derived schema class will cause all affected schemas to dump
+or any derived schema class will cause all schemas to dump
manual versions of themselves to the named directory when they are
loaded. In order to be effective, this must be set before defining a
connection on this schema class or any derived object (as the loading
sub import {
my $self = shift;
+
return if !@_;
+
+ my $cpkg = (caller)[0];
+
foreach my $opt (@_) {
if($opt =~ m{^dump_to_dir:(.*)$}) {
$self->dump_to_dir($1)
}
elsif($opt eq 'make_schema_at') {
no strict 'refs';
- my $cpkg = (caller)[0];
*{"${cpkg}::make_schema_at"} = \&make_schema_at;
}
+ elsif($opt eq 'naming') {
+ no strict 'refs';
+ *{"${cpkg}::naming"} = sub { $self->naming(@_) };
+ }
+ elsif($opt eq 'use_namespaces') {
+ no strict 'refs';
+ *{"${cpkg}::use_namespaces"} = sub { $self->use_namespaces(@_) };
+ }
}
}
=head2 make_schema_at
-This simple function allows one to create a Loader-based schema
-in-memory on the fly without any on-disk class files of any
-kind. When used with the C<dump_directory> option, you can
-use this to generate a rough draft manual schema from a dsn
-without the intermediate step of creating a physical Loader-based
-schema class.
+=over 4
+
+=item Arguments: $schema_class_name, \%loader_options, \@connect_info
-The return value is the input class name.
+=item Return Value: $schema_class_name
-This function can be exported/imported by the normal means, as
-illustrated in these Examples:
+=back
+
+This function creates a DBIx::Class schema from an existing RDBMS
+schema. With the C<dump_directory> option, generates a set of
+DBIx::Class classes from an existing database schema read from the
+given dsn. Without a C<dump_directory>, creates schema classes in
+memory at runtime without generating on-disk class files.
+
+For a complete list of supported loader_options, see
+L<DBIx::Class::Schema::Loader::Base>
+
+The last hashref in the C<\@connect_info> can specify the L</loader_class>.
+
+This function can be imported in the usual way, as illustrated in
+these Examples:
# Simple example, creates as a new class 'New::Schema::Name' in
# memory in the running perl interpreter.
make_schema_at(
'New::Schema::Name',
{ debug => 1 },
- [ 'dbi:Pg:dbname="foo"','postgres' ],
+ [ 'dbi:Pg:dbname="foo"','postgres','',
+ { loader_class => 'MyLoader' } # optionally
+ ],
);
- # Complex: dump loaded schema to disk, all from the commandline:
- perl -MDBIx::Class::Schema::Loader=make_schema_at,dump_to_dir:./lib -e 'make_schema_at("New::Schema::Name", { debug => 1 }, [ "dbi:Pg:dbname=foo","postgres" ])'
-
- # Same, but inside a script, and using a different way to specify the
- # dump directory:
+ # Inside a script, specifying a dump directory in which to write
+ # class files
use DBIx::Class::Schema::Loader qw/ make_schema_at /;
make_schema_at(
'New::Schema::Name',
{ debug => 1, dump_directory => './lib' },
- [ 'dbi:Pg:dbname="foo"','postgres' ],
+ [ 'dbi:Pg:dbname="foo"','postgres','',
+ { loader_class => 'MyLoader' } # optionally
+ ],
);
+The last hashref in the C<\@connect_info> is checked for loader arguments such
+as C<loader_options> and C<loader_class>, see L</connection> for more details.
+
=cut
sub make_schema_at {
@{$target . '::ISA'} = qw/DBIx::Class::Schema::Loader/;
}
+ $target->_loader_invoked(0);
+
$target->loader_options($opts);
- $target->connection(@$connect_info);
+
+ my $temp_schema = $target->connect(@$connect_info);
+
+ $target->storage($temp_schema->storage);
+ $target->storage->set_schema($target);
+
+ return $target;
}
=head2 rescan
+=over 4
+
+=item Return Value: @new_monikers
+
+=back
+
Re-scans the database for newly added tables since the initial
load, and adds them to the schema at runtime, including relationships,
etc. Does not process drops or changes.
=cut
-sub rescan { my $self = shift; $self->_loader->rescan($self) }
+sub rescan { my $self = shift; $self->loader->rescan($self) }
-=head1 EXAMPLE
+=head2 naming
-Using the example in L<DBIx::Class::Manual::ExampleSchema> as a basis
-replace the DB::Main with the following code:
+=over 4
- package DB::Main;
+=item Arguments: \%opts | $ver
- use base qw/DBIx::Class::Schema::Loader/;
+=back
- __PACKAGE__->loader_options(
- debug => 1,
- );
- __PACKAGE__->connection('dbi:SQLite:example.db');
+Controls the naming options for backward compatibility, see
+L<DBIx::Class::Schema::Loader::Base/naming> for details.
- 1;
+To upgrade a dynamic schema, use:
-and remove the Main directory tree (optional). Every thing else
-should work the same
+ __PACKAGE__->naming('current');
-=head1 KNOWN ISSUES
+Can be imported into your dump script and called as a function as well:
-=head2 Multiple Database Schemas
+ naming('v4');
-Currently the loader is limited to working within a single schema
-(using the database vendors' definition of "schema"). If you
-have a multi-schema database with inter-schema relationships (which
-is easy to do in PostgreSQL or DB2 for instance), you only get to
-automatically load the tables of one schema, and any relationships
-to tables in other schemas will be silently ignored.
+=head2 use_namespaces
-At some point in the future, an intelligent way around this might be
-devised, probably by allowing the C<db_schema> option to be an
-arrayref of schemas to load.
+=over 4
-In "normal" L<DBIx::Class::Schema> usage, manually-defined
-source classes and relationships have no problems crossing vendor schemas.
+=item Arguments: 1|0
-=head1 AUTHOR
+=back
-Brandon Black, C<blblack@gmail.com>
+Controls the use_namespaces options for backward compatibility, see
+L<DBIx::Class::Schema::Loader::Base/use_namespaces> for details.
-Based on L<DBIx::Class::Loader> by Sebastian Riedel
+To upgrade a dynamic schema, use:
-Based upon the work of IKEBE Tomohiro
+ __PACKAGE__->use_namespaces(1);
-=head1 THANK YOU
+Can be imported into your dump script and called as a function as well:
+
+ use_namespaces(1);
+
+=head1 KNOWN ISSUES
+
+=head2 Multiple Database Schemas
+
+See L<DBIx::Class::Schema::Loader::Base/db_schema>.
+
+=head1 ACKNOWLEDGEMENTS
Matt S Trout, all of the #dbix-class folks, and everyone who's ever sent
in a bug report or suggestion.
-=head1 LICENSE
+Based on L<DBIx::Class::Loader> by Sebastian Riedel
+
+Based upon the work of IKEBE Tomohiro
+
+=head1 AUTHORS
+
+Caelum: Rafael Kitover <rkitover@cpan.org>
+
+Dag-Erling Smørgrav <des@des.no>
+
+Matias E. Fernandez <mfernandez@pisco.ch>
+
+SineSwiper: Brendan Byrd <byrd.b@insightcom.com>
+
+TSUNODA Kazuya <drk@drk7.jp>
+
+acmoore: Andrew Moore <amoore@cpan.org>
+
+alnewkirk: Al Newkirk <awncorp@cpan.org>
+
+andrewalker: André Walker <andre@andrewalker.net>
+
+angelixd: Paul C. Mantz <pcmantz@cpan.org>
+
+arc: Aaron Crane <arc@cpan.org>
+
+arcanez: Justin Hunter <justin.d.hunter@gmail.com>
+
+ash: Ash Berlin <ash@cpan.org>
+
+blblack: Brandon Black <blblack@gmail.com>
+
+bphillips: Brian Phillips <bphillips@cpan.org>
+
+btilly: Ben Tilly <btilly@gmail.com>
+
+domm: Thomas Klausner <domm@plix.at>
+
+gugu: Andrey Kostenko <a.kostenko@rambler-co.ru>
+
+hobbs: Andrew Rodland <arodland@cpan.org>
+
+ilmari: Dagfinn Ilmari MannsE<aring>ker <ilmari@ilmari.org>
+
+jhannah: Jay Hannah <jay@jays.net>
+
+jnap: John Napiorkowski <jjn1056@yahoo.com>
+
+kane: Jos Boumans <kane@cpan.org>
+
+mattp: Matt Phillips <mattp@cpan.org>
+
+mephinet: Philipp Gortan <philipp.gortan@apa.at>
+
+moritz: Moritz Lenz <moritz@faui2k3.org>
+
+mst: Matt S. Trout <mst@shadowcatsystems.co.uk>
+
+mstratman: Mark A. Stratman <stratman@gmail.com>
+
+oalders: Olaf Alders <olaf@wundersolutions.com>
+
+rbo: Robert Bohne <rbo@cpan.org>
+
+rbuels: Robert Buels <rbuels@gmail.com>
+
+ribasushi: Peter Rabbitson <ribasushi@cpan.org>
+
+schwern: Michael G. Schwern <mschwern@cpan.org>
+
+spb: Stephen Bennett <spb@exherbo.org>
+
+timbunce: Tim Bunce <timb@cpan.org>
+
+waawaamilk: Nigel McNie <nigel@mcnie.name>
+
+... and lots of other folks. If we forgot you, please write the current
+maintainer or RT.
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright (c) 2006 - 2015 by the aforementioned
+L<DBIx::Class::Schema::Loader/AUTHORS>.
This library is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=head1 SEE ALSO
-L<DBIx::Class>, L<DBIx::Class::Manual::ExampleSchema>
+L<DBIx::Class>, L<DBIx::Class::Manual::Intro>, L<DBIx::Class::Tutorial>,
+L<DBIx::Class::Schema::Loader::Base>
=cut
1;
+# vim:et sts=4 sw=4 tw=0:
projects / dbsrgits/DBIx-Class-Schema-Loader.git / blobdiff