DBIx::Class::Schema::Loader automates the definition of a
L<DBIx::Class::Schema> by scanning database table definitions and
-setting up the columns and primary keys.
+setting up the columns, primary keys, and relationships.
-DBIx::Class::Schema::Loader currently supports DBI for MySQL,
-PostgreSQL, SQLite and DB2.
+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>, and
+L<DBD::SQLite>. 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.
only useful in fairly complex scenarios, see the
L<DBIx::Class::Schema::Loader::Base> documentation.
-This method is *required*, for backwards compatibility reasons. If
-you do not wish to change any options, just call it with an empty
-argument list during schema class initialization.
+This method is *required* at this time, for backwards compatibility
+reasons. If you do not wish to change any options, just call it
+with an empty argument list during schema class initialization.
+
+You should either specify this method before setting the connection
+information for your schema, or specify these options as a part of
+your connection information (see below). For now it will merely
+warn if the ordering is wrong, but in the future this will cause problems.
=cut
sub loader_options {
my $self = shift;
- my %args;
- if(ref $_[0] eq 'HASH') {
- %args = %{$_[0]};
- }
- else {
- %args = @_;
- }
+ my %args = (ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
my $class = ref $self || $self;
$args{schema} = $self;
weaken($args{schema}) if ref $self;
$self->_loader_args(\%args);
- $self->_invoke_loader if $self->storage && !$class->loader;
+ if($self->storage && !$class->loader) {
+ warn "Do not set loader_options after specifying the connection info";
+ $self->_invoke_loader;
+ }
$self;
}
=head2 connection
-See L<DBIx::Class::Schema>.
+See L<DBIx::Class::Schema> 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.
+
+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->next::method(@_);
+ my $self = shift;
+
+ if($_[-1] && ref $_[-1] eq 'HASH') {
+ if(my $loader_opts = delete $_[-1]->{loader_options}) {
+ $self->loader_options($loader_opts);
+ }
+ }
+
+ $self = $self->next::method(@_);
my $class = ref $self || $self;
$self->_invoke_loader if $self->_loader_args && !$class->loader;
version is intended to be backwards-compatible with pre-0.03 code, but
will issue warnings about your usage of deprecated features/methods.
+B<All of these deprecated methods will dissappear in version 0.04000>,
+and converting code that uses these methods should be trivial.
+
=head2 load_from_connection
This deprecated method is now roughly an alias for L</loader_options>.
-This method *will* disappear in a future version.
-
For now, using this method will invoke the legacy behavior for
backwards compatibility, and merely emit a warning about upgrading
your code.
module did.
You can force these legacy inflections with the
-option C<legacy_default_inflections>, even after switch over
-to the preferred L</loader_options> way of doing things.
+option L<DBIx::Class::Schema::Loader::Base/legacy_default_inflections>,
+even after switch over to the preferred L</loader_options> way of doing
+things. That option will not go away until at least 0.05.
See the source of this method for more details.
warn 'You should regenerate your Model files, which may eliminate'
. ' the following deprecation warning:';
}
- warn 'load_from_connection deprecated, please [re-]read the'
- . ' [new] DBIx::Class::Schema::Loader documentation';
+ warn 'load_from_connection deprecated, and will dissappear in 0.04000, '
+ . 'please [re-]read the [new] DBIx::Class::Schema::Loader '
+ . 'documentation';
# Support the old connect_info / dsn / etc args...
$args{connect_info} = [
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, or perhaps even offering schema
-constraint/exclusion options just like the table ones.
+arrayref of schemas to load.
In "normal" L<DBIx::Class::Schema> usage, manually-defined
source classes and relationships have no problems crossing vendor schemas.
=head1 THANK YOU
-Adam Anderson, Andy Grundman, Autrijus Tang, Dan Kubb, David Naughton,
-Randal Schwartz, Simon Flack, Matt S Trout, everyone on #dbix-class, and
-all the others who've helped.
+Matt S Trout, all of the #dbix-class folks, and everyone who's ever sent
+in a bug report or suggestion.
=head1 LICENSE
inflect_plural
debug
dump_directory
+ dump_overwrite
legacy_default_inflections
If set to true, each constructive L<DBIx::Class> statement the loader
decides to execute will be C<warn>-ed before execution.
+=head2 db_schema
+
+Set the name of the schema to load (schema in the sense that your database
+vendor means it). Does not currently support loading more than one schema
+name.
+
=head2 constraint
Only load tables matching regex. Best specified as a qr// regex.
don't wish to go around updating all your relationship names to the new
defaults.
+This option will continue to be supported until at least version 0.05xxx,
+but may dissappear sometime thereafter. It is recommended that you update
+your code to use the newer-style inflections when you have the time.
+
=head2 dump_directory
This option is designed to be a tool to help you transition from this
See L<DBIx::Class::Schema::Loader/dump_to_dir> for examples of the
recommended way to access this functionality.
+=head2 dump_overwrite
+
+If set to a true value, the dumping code will overwrite existing files.
+The default is false, which means the dumping code will die if it encounters
+an existing file.
+
=head1 DEPRECATED CONSTRUCTOR OPTIONS
+B<These will be removed in version 0.04000 !!!>
+
=head2 inflect_map
Equivalent to L</inflect_plural>.
You connect these schemas the same way you would any L<DBIx::Class::Schema>,
which is by calling either C<connect> or C<connection> on a schema class
or object. These options are only supported via the deprecated
-C<load_from_connection> interface, which will be removed in the future.
+C<load_from_connection> interface, which is also being removed in 0.04000.
=head1 METHODS
# Support deprecated arguments
for(qw/inflect_map inflect/) {
warn "Argument $_ is deprecated in favor of 'inflect_plural'"
- if $self->{$_};
+ . ", and will be removed in 0.04000"
+ if $self->{$_};
}
$self->{inflect_plural} ||= $self->{inflect_map} || $self->{inflect};
my ($self) = @_;
my $target_dir = $self->dump_directory;
+
my $schema_class = $self->schema_class;
croak "Must specify target directory for dumping!" if ! $target_dir;
$self->_ensure_dump_subdirs($schema_class);
my $schema_fn = $self->_get_dump_filename($schema_class);
- open(my $schema_fh, '>', $schema_fn)
+ croak "$schema_fn exists, will not overwrite"
+ if -f $schema_fn && !$self->dump_overwrite;
+ sysopen(my $schema_fh, '>', $schema_fn)
or croak "Cannot open $schema_fn for writing: $!";
print $schema_fh qq|package $schema_class;\n\n$tagline\n\n|;
print $schema_fh qq|use strict;\nuse warnings;\n\n|;
foreach my $src_class (sort keys %{$self->{_dump_storage}}) {
$self->_ensure_dump_subdirs($src_class);
my $src_fn = $self->_get_dump_filename($src_class);
+ croak "$src_fn exists, will not overwrite"
+ if -f $src_fn && !$self->dump_overwrite;
open(my $src_fh, '>', $src_fn)
or croak "Cannot open $src_fn for writing: $!";
print $src_fh qq|package $src_class;\n\n$tagline\n\n|;
projects / dbsrgits/DBIx-Class-Schema-Loader.git / commitdiff