use strict;
use warnings;
-use DBIx::Class::Exception;
-use Carp::Clan qw/^DBIx::Class/;
-use Scalar::Util ();
-use File::Spec;
-use Sub::Name ();
-use Module::Find();
-
-use base qw/DBIx::Class/;
-
-__PACKAGE__->mk_classdata('class_mappings' => {});
-__PACKAGE__->mk_classdata('source_registrations' => {});
-__PACKAGE__->mk_classdata('storage_type' => '::DBI');
-__PACKAGE__->mk_classdata('storage');
-__PACKAGE__->mk_classdata('exception_action');
-__PACKAGE__->mk_classdata('stacktrace' => $ENV{DBIC_TRACE} || 0);
-__PACKAGE__->mk_classdata('default_resultset_attributes' => {});
+use base 'DBIx::Class';
+
+use DBIx::Class::Carp;
+use Try::Tiny;
+use Scalar::Util qw/weaken blessed/;
+use DBIx::Class::_Util qw(
+ refcount quote_sub scope_guard
+ is_exception dbic_internal_try
+ fail_on_internal_call emit_loud_diag
+);
+use Devel::GlobalDestruction;
+use namespace::clean;
+
+__PACKAGE__->mk_group_accessors( inherited => qw( storage exception_action ) );
+__PACKAGE__->mk_classaccessor('storage_type' => '::DBI');
+__PACKAGE__->mk_classaccessor('stacktrace' => $ENV{DBIC_TRACE} || 0);
+__PACKAGE__->mk_classaccessor('default_resultset_attributes' => {});
+
+# These two should have been private from the start but too late now
+# Undocumented on purpose, hopefully it won't ever be necessary to
+# screw with them
+__PACKAGE__->mk_classaccessor('class_mappings' => {});
+__PACKAGE__->mk_classaccessor('source_registrations' => {});
=head1 NAME
=back
+ package MyApp::Schema;
__PACKAGE__->load_namespaces();
__PACKAGE__->load_namespaces(
- result_namespace => 'Res',
- resultset_namespace => 'RSet',
- default_resultset_class => '+MyDB::Othernamespace::RSet',
- );
+ result_namespace => 'Res',
+ resultset_namespace => 'RSet',
+ default_resultset_class => '+MyApp::Othernamespace::RSet',
+ );
-With no arguments, this method uses L<Module::Find> to load all your
-Result classes from a sub-namespace F<Result> under your Schema class'
-namespace. Eg. With a Schema of I<MyDB::Schema> all files in
-I<MyDB::Schema::Result> are assumed to be Result classes.
+With no arguments, this method uses L<Module::Find> to load all of the
+Result and ResultSet classes under the namespace of the schema from
+which it is called. For example, C<My::Schema> will by default find
+and load Result classes named C<My::Schema::Result::*> and ResultSet
+classes named C<My::Schema::ResultSet::*>.
-It also finds all ResultSet classes in the namespace F<ResultSet> and
-loads them into the appropriate Result classes using for you. The
-matching is done by assuming the package name of the ResultSet class
-is the same as that of the Result class.
+ResultSet classes are associated with Result class of the same name.
+For example, C<My::Schema::Result::CD> will get the ResultSet class
+C<My::Schema::ResultSet::CD> if it is present.
-You will be warned if ResultSet classes are discovered for which there
-are no matching Result classes like this:
+Both Result and ResultSet namespaces are configurable via the
+C<result_namespace> and C<resultset_namespace> options.
- load_namespaces found ResultSet class $classname with no corresponding Result class
+Another option, C<default_resultset_class> specifies a custom default
+ResultSet class for Result classes with no corresponding ResultSet.
+
+All of the namespace and classname options are by default relative to
+the schema classname. To specify a fully-qualified name, prefix it
+with a literal C<+>. For example, C<+Other::NameSpace::Result>.
-If a Result class is found to already have a ResultSet class set using
-L</resultset_class> to some other class, you will be warned like this:
+=head3 Warnings
- We found ResultSet class '$rs_class' for '$result', but it seems
- that you had already set '$result' to use '$rs_set' instead
+You will be warned if ResultSet classes are discovered for which there
+are no matching Result classes like this:
-Both of the sub-namespaces are configurable if you don't like the defaults,
-via the options C<result_namespace> and C<resultset_namespace>.
+ load_namespaces found ResultSet class $classname with no corresponding Result class
-If (and only if) you specify the option C<default_resultset_class>, any found
-Result classes for which we do not find a corresponding
-ResultSet class will have their C<resultset_class> set to
-C<default_resultset_class>.
+If a ResultSource instance is found to already have a ResultSet class set
+using L<resultset_class|DBIx::Class::ResultSource/resultset_class> to some
+other class, you will be warned like this:
-All of the namespace and classname options to this method are relative to
-the schema classname by default. To specify a fully-qualified name, prefix
-it with a literal C<+>.
+ We found ResultSet class '$rs_class' for '$result_class', but it seems
+ that you had already set '$result_class' to use '$rs_set' instead
-Examples:
+=head3 Examples
# load My::Schema::Result::CD, My::Schema::Result::Artist,
# My::Schema::ResultSet::CD, etc...
resultset_namespace => '+Another::Place::RSets',
);
-If you'd like to use multiple namespaces of each type, simply use an arrayref
-of namespaces for that option. In the case that the same result
-(or resultset) class exists in multiple namespaces, the latter entries in
-your list of namespaces will override earlier ones.
+To search multiple namespaces for either Result or ResultSet classes,
+use an arrayref of namespaces for that option. In the case that the
+same result (or resultset) class exists in multiple namespaces, later
+entries in the list of namespaces will override earlier ones.
My::Schema->load_namespaces(
# My::Schema::Results_C::Foo takes precedence over My::Schema::Results_B::Foo :
# be stripped.
sub _expand_relative_name {
my ($class, $name) = @_;
- return if !$name;
- $name = $class . '::' . $name if ! ($name =~ s/^\+//);
+ $name =~ s/^\+// or $name = "${class}::${name}";
return $name;
}
# namespace of $class. Untaints all findings as they can be assumed
# to be safe
sub _findallmod {
- my $proto = shift;
- my $ns = shift || ref $proto || $proto;
-
- my @mods = Module::Find::findallmod($ns);
-
- # try to untaint module names. mods where this fails
- # are left alone so we don't have to change the old behavior
- no locale; # localized \w doesn't untaint expression
- return map { $_ =~ m/^( (?:\w+::)* \w+ )$/x ? $1 : $_ } @mods;
+ require Module::Find;
+ return map
+ { $_ =~ /(.+)/ } # untaint result
+ Module::Find::findallmod( $_[1] || ref $_[0] || $_[0] )
+ ;
}
# returns a hash of $shortname => $fullname for every package
# found in the given namespaces ($shortname is with the $fullname's
# namespace stripped off)
sub _map_namespaces {
- my ($class, @namespaces) = @_;
-
- my @results_hash;
- foreach my $namespace (@namespaces) {
- push(
- @results_hash,
- map { (substr($_, length "${namespace}::"), $_) }
- $class->_findallmod($namespace)
- );
+ my ($me, $namespaces) = @_;
+
+ my %res;
+ for my $ns (@$namespaces) {
+ $res{ substr($_, length "${ns}::") } = $_
+ for $me->_findallmod($ns);
}
- @results_hash;
+ \%res;
}
# returns the result_source_instance for the passed class/object,
# or dies with an informative message (used by load_namespaces)
sub _ns_get_rsrc_instance {
- my $class = shift;
- my $rs = ref ($_[0]) || $_[0];
-
- if ($rs->can ('result_source_instance') ) {
- return $rs->result_source_instance;
- }
- else {
- $class->throw_exception (
- "Attempt to load_namespaces() class $rs failed - are you sure this is a real Result Class?"
+ my $me = shift;
+ my $rs_class = ref ($_[0]) || $_[0];
+
+ return dbic_internal_try {
+ $rs_class->result_source_instance
+ } catch {
+ $me->throw_exception (
+ "Attempt to load_namespaces() class $rs_class failed - are you sure this is a real Result Class?: $_"
);
- }
+ };
}
sub load_namespaces {
my $result_namespace = delete $args{result_namespace} || 'Result';
my $resultset_namespace = delete $args{resultset_namespace} || 'ResultSet';
+
my $default_resultset_class = delete $args{default_resultset_class};
+ $default_resultset_class = $class->_expand_relative_name($default_resultset_class)
+ if $default_resultset_class;
+
$class->throw_exception('load_namespaces: unknown option(s): '
. join(q{,}, map { qq{'$_'} } keys %args))
if scalar keys %args;
- $default_resultset_class
- = $class->_expand_relative_name($default_resultset_class);
-
for my $arg ($result_namespace, $resultset_namespace) {
- $arg = [ $arg ] if !ref($arg) && $arg;
+ $arg = [ $arg ] if ( $arg and ! ref $arg );
$class->throw_exception('load_namespaces: namespace arguments must be '
. 'a simple string or an arrayref')
$_ = $class->_expand_relative_name($_) for (@$arg);
}
- my %results = $class->_map_namespaces(@$result_namespace);
- my %resultsets = $class->_map_namespaces(@$resultset_namespace);
+ my $results_by_source_name = $class->_map_namespaces($result_namespace);
+ my $resultsets_by_source_name = $class->_map_namespaces($resultset_namespace);
my @to_register;
{
- no warnings 'redefine';
- local *Class::C3::reinitialize = sub { };
- use warnings 'redefine';
+ no warnings qw/redefine/;
+ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
+ use warnings qw/redefine/;
# ensure classes are loaded and attached in inheritance order
- $class->ensure_class_loaded($_) foreach(values %results);
+ for my $result_class (values %$results_by_source_name) {
+ $class->ensure_class_loaded($result_class);
+ }
my %inh_idx;
- my @subclass_last = sort {
+ my @source_names_by_subclass_last = sort {
($inh_idx{$a} ||=
- scalar @{mro::get_linear_isa( $results{$a} )}
+ scalar @{mro::get_linear_isa( $results_by_source_name->{$a} )}
)
<=>
($inh_idx{$b} ||=
- scalar @{mro::get_linear_isa( $results{$b} )}
+ scalar @{mro::get_linear_isa( $results_by_source_name->{$b} )}
)
- } keys(%results);
+ } keys(%$results_by_source_name);
- foreach my $result (@subclass_last) {
- my $result_class = $results{$result};
+ foreach my $source_name (@source_names_by_subclass_last) {
+ my $result_class = $results_by_source_name->{$source_name};
- my $rs_class = delete $resultsets{$result};
- my $rs_set = $class->_ns_get_rsrc_instance ($result_class)->resultset_class;
+ my $preset_resultset_class = $class->_ns_get_rsrc_instance ($result_class)->resultset_class;
+ my $found_resultset_class = delete $resultsets_by_source_name->{$source_name};
- if($rs_set && $rs_set ne 'DBIx::Class::ResultSet') {
- if($rs_class && $rs_class ne $rs_set) {
- carp "We found ResultSet class '$rs_class' for '$result', but it seems "
- . "that you had already set '$result' to use '$rs_set' instead";
+ if($preset_resultset_class && $preset_resultset_class ne 'DBIx::Class::ResultSet') {
+ if($found_resultset_class && $found_resultset_class ne $preset_resultset_class) {
+ carp "We found ResultSet class '$found_resultset_class' matching '$results_by_source_name->{$source_name}', but it seems "
+ . "that you had already set the '$results_by_source_name->{$source_name}' resultet to '$preset_resultset_class' instead";
}
}
- elsif($rs_class ||= $default_resultset_class) {
- $class->ensure_class_loaded($rs_class);
- $class->_ns_get_rsrc_instance ($result_class)->resultset_class($rs_class);
+ # elsif - there may be *no* default_resultset_class, in which case we fallback to
+ # DBIx::Class::Resultset and there is nothing to check
+ elsif($found_resultset_class ||= $default_resultset_class) {
+ $class->ensure_class_loaded($found_resultset_class);
+ if(!$found_resultset_class->isa("DBIx::Class::ResultSet")) {
+ carp "load_namespaces found ResultSet class '$found_resultset_class' that does not subclass DBIx::Class::ResultSet";
+ }
+
+ $class->_ns_get_rsrc_instance ($result_class)->resultset_class($found_resultset_class);
}
- my $source_name = $class->_ns_get_rsrc_instance ($result_class)->source_name || $result;
+ my $source_name = $class->_ns_get_rsrc_instance ($result_class)->source_name || $source_name;
push(@to_register, [ $source_name, $result_class ]);
}
}
- foreach (sort keys %resultsets) {
- carp "load_namespaces found ResultSet class $_ with no "
- . 'corresponding Result class';
+ foreach (sort keys %$resultsets_by_source_name) {
+ carp "load_namespaces found ResultSet class '$resultsets_by_source_name->{$_}' "
+ .'with no corresponding Result class';
}
- Class::C3->reinitialize;
+ Class::C3->reinitialize if DBIx::Class::_ENV_::OLD_MRO;
+
$class->register_class(@$_) for (@to_register);
return;
If any classes found do not appear to be Result class files, you will
get the following warning:
- Failed to load $comp_class. Can't find source_name method. Is
+ Failed to load $comp_class. Can't find source_name method. Is
$comp_class really a full DBIC result class? Fix it, move it elsewhere,
or make your load_classes call more specific.
}
} else {
my @comp = map { substr $_, length "${class}::" }
- $class->_findallmod;
+ $class->_findallmod($class);
$comps_for{$class} = \@comp;
}
my @to_register;
{
no warnings qw/redefine/;
- local *Class::C3::reinitialize = sub { };
+ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
+ use warnings qw/redefine/;
+
foreach my $prefix (keys %comps_for) {
foreach my $comp (@{$comps_for{$prefix}||[]}) {
my $comp_class = "${prefix}::${comp}";
}
}
}
- Class::C3->reinitialize;
+ Class::C3->reinitialize if DBIx::Class::_ENV_::OLD_MRO;
foreach my $to (@to_register) {
$class->register_class(@$to);
- # if $class->can('result_source_instance');
}
}
=item Arguments: $storage_type|{$storage_type, \%args}
-=item Return value: $storage_type|{$storage_type, \%args}
+=item Return Value: $storage_type|{$storage_type, \%args}
=item Default value: DBIx::Class::Storage::DBI
Config::[class] or your choice. See
L<DBIx::Class::Storage::DBI::Replicated> for an example of this.
+=head2 default_resultset_attributes
+
+=over 4
+
+=item Arguments: L<\%attrs|DBIx::Class::ResultSet/ATTRIBUTES>
+
+=item Return Value: L<\%attrs|DBIx::Class::ResultSet/ATTRIBUTES>
+
+=item Default value: None
+
+=back
+
+Like L<DBIx::Class::ResultSource/resultset_attributes> stores a collection
+of resultset attributes, to be used as defaults for B<every> ResultSet
+instance schema-wide. The same list of CAVEATS and WARNINGS applies, with
+the extra downside of these defaults being practically inescapable: you will
+B<not> be able to derive a ResultSet instance with these attributes unset.
+
+Example:
+
+ package My::Schema;
+ use base qw/DBIx::Class::Schema/;
+ __PACKAGE__->default_resultset_attributes( { software_limit => 1 } );
+
=head2 exception_action
=over 4
=item Arguments: $code_reference
-=item Return value: $code_reference
+=item Return Value: $code_reference
=item Default value: None
=back
-If C<exception_action> is set for this class/object, L</throw_exception>
-will prefer to call this code reference with the exception as an argument,
-rather than L<DBIx::Class::Exception/throw>.
+When L</throw_exception> is invoked and L</exception_action> is set to a code
+reference, this reference will be called instead of
+L<DBIx::Class::Exception/throw>, with the exception message passed as the only
+argument.
-Your subroutine should probably just wrap the error in the exception
-object/class of your choosing and rethrow. If, against all sage advice,
-you'd like your C<exception_action> to suppress a particular exception
-completely, simply have it return true.
+Your custom throw code B<must> rethrow the exception, as L</throw_exception> is
+an integral part of DBIC's internal execution control flow.
Example:
my $schema_obj = My::Schema->connect( .... );
$schema_obj->exception_action(sub { My::ExceptionClass->throw(@_) });
- # suppress all exceptions, like a moron:
- $schema_obj->exception_action(sub { 1 });
-
=head2 stacktrace
=over 4
=back
-An optional sub which you can declare in your own Schema class that will get
+An optional sub which you can declare in your own Schema class that will get
passed the L<SQL::Translator::Schema> object when you deploy the schema via
L</create_ddl_dir> or L</deploy>.
-For an example of what you can do with this, see
+For an example of what you can do with this, see
L<DBIx::Class::Manual::Cookbook/Adding Indexes And Functions To Your SQL>.
Note that sqlt_deploy_hook is called by L</deployment_statements>, which in turn
=cut
-sub connect { shift->clone->connection(@_) }
+sub connect {
+ DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
+ shift->clone->connection(@_);
+}
=head2 resultset
=over 4
-=item Arguments: $source_name
+=item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
-=item Return Value: $resultset
+=item Return Value: L<$resultset|DBIx::Class::ResultSet>
=back
=cut
sub resultset {
- my ($self, $moniker) = @_;
+ my ($self, $source_name) = @_;
$self->throw_exception('resultset() expects a source name')
- unless defined $moniker;
- return $self->source($moniker)->resultset;
+ unless defined $source_name;
+ return $self->source($source_name)->resultset;
}
=head2 sources
=over 4
-=item Return Value: @source_names
+=item Return Value: L<@source_names|DBIx::Class::ResultSource/source_name>
=back
=cut
-sub sources { return keys %{shift->source_registrations}; }
+sub sources { keys %{shift->source_registrations} }
=head2 source
=over 4
-=item Arguments: $source_name
+=item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
-=item Return Value: $result_source
+=item Return Value: L<$result_source|DBIx::Class::ResultSource>
=back
=cut
sub source {
- 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};
+ my ($self, $source_name) = @_;
+
+ $self->throw_exception("source() expects a source name")
+ unless $source_name;
+
+ my $source_registrations;
+
+ my $rsrc =
+ ( $source_registrations = $self->source_registrations )->{$source_name}
+ ||
+ # if we got here, they probably passed a full class name
+ $source_registrations->{ $self->class_mappings->{$source_name} || '' }
+ ||
+ $self->throw_exception( "Can't find source for ${source_name}" )
+ ;
+
+ # DO NOT REMOVE:
+ # We need to prevent alterations of pre-existing $@ due to where this call
+ # sits in the overall stack ( *unless* of course there is an actual error
+ # to report ). set_mro does alter $@ (and yes - it *can* throw an exception)
+ # We do not use local because set_mro *can* throw an actual exception
+ # We do not use a try/catch either, as on one hand it would slow things
+ # down for no reason (we would always rethrow), but also because adding *any*
+ # try/catch block below will segfault various threading tests on older perls
+ # ( which in itself is a FIXME but ENOTIMETODIG )
+ my $old_dollarat = $@;
+
+ no strict 'refs';
+ mro::set_mro($_, 'c3') for
+ grep
+ {
+ # some pseudo-sources do not have a result/resultset yet
+ defined $_
+ and
+ (
+ (
+ ${"${_}::__INITIAL_MRO_UPON_DBIC_LOAD__"}
+ ||= mro::get_mro($_)
+ )
+ ne
+ 'c3'
+ )
+ }
+ map
+ { length ref $_ ? ref $_ : $_ }
+ ( $rsrc, $rsrc->result_class, $rsrc->resultset_class )
+ ;
+
+ # DO NOT REMOVE - see comment above
+ $@ = $old_dollarat;
+
+ $rsrc;
}
=head2 class
=over 4
-=item Arguments: $source_name
+=item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
=item Return Value: $classname
=cut
sub class {
- my ($self, $moniker) = @_;
- return $self->source($moniker)->result_class;
+ return shift->source(shift)->result_class;
}
=head2 txn_do
=head2 txn_scope_guard
-Runs C<txn_scope_guard> on the schema's storage. See
+Runs C<txn_scope_guard> on the schema's storage. See
L<DBIx::Class::Storage/txn_scope_guard>.
=cut
Begins a transaction (does nothing if AutoCommit is off). Equivalent to
calling $schema->storage->txn_begin. See
-L<DBIx::Class::Storage::DBI/"txn_begin"> for more information.
+L<DBIx::Class::Storage/"txn_begin"> for more information.
=cut
=head2 txn_commit
Commits the current transaction. Equivalent to calling
-$schema->storage->txn_commit. See L<DBIx::Class::Storage::DBI/"txn_commit">
+$schema->storage->txn_commit. See L<DBIx::Class::Storage/"txn_commit">
for more information.
=cut
Rolls back the current transaction. Equivalent to calling
$schema->storage->txn_rollback. See
-L<DBIx::Class::Storage::DBI/"txn_rollback"> for more information.
+L<DBIx::Class::Storage/"txn_rollback"> for more information.
=cut
=over 4
-=item Arguments: $source_name, \@data;
+=item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>, [ \@column_list, \@row_values+ ] | [ \%col_data+ ]
-=item Return value: \@$objects | nothing
+=item Return Value: L<\@result_objects|DBIx::Class::Manual::ResultClass> (scalar context) | L<@result_objects|DBIx::Class::Manual::ResultClass> (list context)
=back
-Pass this method a resultsource name, and an arrayref of
-arrayrefs. The arrayrefs should contain a list of column names,
-followed by one or many sets of matching data for the given columns.
-
-In void context, C<insert_bulk> in L<DBIx::Class::Storage::DBI> is used
-to insert the data, as this is a fast method. However, insert_bulk currently
-assumes that your datasets all contain the same type of values, using scalar
-references in a column in one row, and not in another will probably not work.
+A convenience shortcut to L<DBIx::Class::ResultSet/populate>. Equivalent to:
-Otherwise, each set of data is inserted into the database using
-L<DBIx::Class::ResultSet/create>, and a arrayref of the resulting row
-objects is returned.
+ $schema->resultset($source_name)->populate([...]);
-i.e.,
+=over 4
- $schema->populate('Artist', [
- [ qw/artistid name/ ],
- [ 1, 'Popular Band' ],
- [ 2, 'Indie Band' ],
- ...
- ]);
+=item NOTE
-Since wantarray context is basically the same as looping over $rs->create(...)
-you won't see any performance benefits and in this case the method is more for
-convenience. Void context sends the column information directly to storage
-using <DBI>s bulk insert method. So the performance will be much better for
-storages that support this method.
+The context of this method call has an important effect on what is
+submitted to storage. In void context data is fed directly to fastpath
+insertion routines provided by the underlying storage (most often
+L<DBI/execute_for_fetch>), bypassing the L<new|DBIx::Class::Row/new> and
+L<insert|DBIx::Class::Row/insert> calls on the
+L<Result|DBIx::Class::Manual::ResultClass> class, including any
+augmentation of these methods provided by components. For example if you
+are using something like L<DBIx::Class::UUIDColumns> to create primary
+keys for you, you will find that your PKs are empty. In this case you
+will have to explicitly force scalar or list context in order to create
+those values.
-Because of this difference in the way void context inserts rows into your
-database you need to note how this will effect any loaded components that
-override or augment insert. For example if you are using a component such
-as L<DBIx::Class::UUIDColumns> to populate your primary keys you MUST use
-wantarray context if you want the PKs automatically created.
+=back
=cut
sub populate {
+ DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
+
my ($self, $name, $data) = @_;
- if(my $rs = $self->resultset($name)) {
- if(defined wantarray) {
- return $rs->populate($data);
- } else {
- $rs->populate($data);
- }
- } else {
- $self->throw_exception("$name is not a resultset");
- }
+ my $rs = $self->resultset($name)
+ or $self->throw_exception("'$name' is not a resultset");
+
+ return $rs->populate($data);
}
=head2 connection
=item Arguments: @args
-=item Return Value: $new_schema
+=item Return Value: $self
=back
Similar to L</connect> except sets the storage object and connection
-data in-place on the Schema class. You should probably be calling
-L</connect> to get a proper Schema object instead.
+data B<in-place> on C<$self>. You should probably be calling
+L</connect> to get a properly L<cloned|/clone> Schema object instead.
=head3 Overloading
my ($self, @info) = @_;
return $self if !@info && $self->storage;
- my ($storage_class, $args) = ref $self->storage_type ?
- ($self->_normalize_storage_type($self->storage_type),{}) : ($self->storage_type, {});
+ my ($storage_class, $args) = ref $self->storage_type
+ ? $self->_normalize_storage_type($self->storage_type)
+ : $self->storage_type
+ ;
+
+ $storage_class =~ s/^::/DBIx::Class::Storage::/;
+
+ dbic_internal_try {
+ $self->ensure_class_loaded ($storage_class);
+ }
+ catch {
+ $self->throw_exception(
+ "Unable to load storage class ${storage_class}: $_"
+ );
+ };
- $storage_class = 'DBIx::Class::Storage'.$storage_class
- if $storage_class =~ m/^::/;
- eval { $self->ensure_class_loaded ($storage_class) };
- $self->throw_exception(
- "No arguments to load_classes and couldn't load ${storage_class} ($@)"
- ) if $@;
- my $storage = $storage_class->new($self=>$args);
+ my $storage = $storage_class->new( $self => $args||{} );
$storage->connect_info(\@info);
$self->storage($storage);
return $self;
=item Arguments: $target_namespace, $additional_base_class?
-=item Retur Value: $new_schema
+=item Return Value: $new_schema
=back
It also attaches a corresponding L<DBIx::Class::ResultSource> object to the
new $schema object. If C<$additional_base_class> is given, the new composed
-classes will inherit from first the corresponding classe from the current
+classes will inherit from first the corresponding class from the current
schema then the base class.
For example, for a schema with My::Schema::CD and My::Schema::Artist classes,
=cut
-# this might be oversimplified
-# sub compose_namespace {
-# my ($self, $target, $base) = @_;
-
-# 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);
-# $target_class->result_source_instance($source)
-# if $target_class->can('result_source_instance');
-# $schema->register_source($moniker, $source);
-# }
-# return $schema;
-# }
-
sub compose_namespace {
my ($self, $target, $base) = @_;
+
my $schema = $self->clone;
+
+ $schema->source_registrations({});
+
+ # the original class-mappings must remain - otherwise
+ # reverse_relationship_info will not work
+ #$schema->class_mappings({});
+
{
no warnings qw/redefine/;
-# local *Class::C3::reinitialize = sub { };
- 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 : ())
+ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
+ use warnings qw/redefine/;
+
+ foreach my $source_name ($self->sources) {
+ my $orig_source = $self->source($source_name);
+
+ my $target_class = "${target}::${source_name}";
+ $self->inject_base($target_class, $orig_source->result_class, ($base || ()) );
+
+ $schema->register_source(
+ $source_name,
+ $orig_source->clone(
+ result_class => $target_class
+ ),
);
- $source->result_class($target_class);
- $target_class->result_source_instance($source)
- if $target_class->can('result_source_instance');
- $schema->register_source($moniker, $source);
}
+
+ # Legacy stuff, not inserting INDIRECT assertions
+ quote_sub "${target}::${_}" => "shift->schema->$_(\@_)"
+ for qw(class source resultset);
}
-# Class::C3->reinitialize();
- {
- no strict 'refs';
- no warnings 'redefine';
- foreach my $meth (qw/class source resultset/) {
- *{"${target}::${meth}"} = Sub::Name::subname "${target}::${meth}" =>
- sub { shift->schema->$meth(@_) };
- }
+
+ Class::C3->reinitialize() if DBIx::Class::_ENV_::OLD_MRO;
+
+ # Give each composed class yet another *schema-less* source copy
+ # this is used for the freeze/thaw cycle
+ #
+ # This is not covered by any tests directly, but is indirectly exercised
+ # in t/cdbi/sweet/08pager by re-setting the schema on an existing object
+ # FIXME - there is likely a much cheaper way to take care of this
+ for my $source_name ($self->sources) {
+
+ my $target_class = "${target}::${source_name}";
+
+ $target_class->result_source_instance(
+ $self->source($source_name)->clone(
+ result_class => $target_class,
+ schema => ( ref $schema || $schema ),
+ )
+ );
}
+
return $schema;
}
+# LEGACY: The intra-call to this was removed in 66d9ef6b and then
+# the sub was de-documented way later in 249963d4. No way to be sure
+# nothing on darkpan is calling it directly, so keeping as-is
sub setup_connection_class {
my ($class, $target, @info) = @_;
$class->inject_base($target => 'DBIx::Class::DB');
=head2 svp_begin
-Creates a new savepoint (does nothing outside a transaction).
+Creates a new savepoint (does nothing outside a transaction).
Equivalent to calling $schema->storage->svp_begin. See
-L<DBIx::Class::Storage::DBI/"svp_begin"> for more information.
+L<DBIx::Class::Storage/"svp_begin"> for more information.
=cut
=head2 svp_release
-Releases a savepoint (does nothing outside a transaction).
+Releases a savepoint (does nothing outside a transaction).
Equivalent to calling $schema->storage->svp_release. See
-L<DBIx::Class::Storage::DBI/"svp_release"> for more information.
+L<DBIx::Class::Storage/"svp_release"> for more information.
=cut
=head2 svp_rollback
-Rollback to a savepoint (does nothing outside a transaction).
+Rollback to a savepoint (does nothing outside a transaction).
Equivalent to calling $schema->storage->svp_rollback. See
-L<DBIx::Class::Storage::DBI/"svp_rollback"> for more information.
+L<DBIx::Class::Storage/"svp_rollback"> for more information.
=cut
=over 4
+=item Arguments: %attrs?
+
=item Return Value: $new_schema
=back
Clones the schema and its associated result_source objects and returns the
-copy.
+copy. The resulting copy will have the same attributes as the source schema,
+except for those attributes explicitly overridden by the provided C<%attrs>.
=cut
sub clone {
- my ($self) = @_;
- my $clone = { (ref $self ? %$self : ()) };
+ my $self = shift;
+
+ my $clone = {
+ (ref $self ? %$self : ()),
+ (@_ == 1 && ref $_[0] eq 'HASH' ? %{ $_[0] } : @_),
+ };
bless $clone, (ref $self || $self);
- $clone->class_mappings({ %{$clone->class_mappings} });
- $clone->source_registrations({ %{$clone->source_registrations} });
- foreach my $moniker ($self->sources) {
- my $source = $self->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
- $clone->register_extra_source($moniker => $new);
- }
- $clone->storage->set_schema($clone) if $clone->storage;
+ $clone->$_(undef) for qw/class_mappings source_registrations storage/;
+
+ $clone->_copy_state_from($self);
+
return $clone;
}
+# Needed in Schema::Loader - if you refactor, please make a compatibility shim
+# -- Caelum
+sub _copy_state_from {
+ my ($self, $from) = @_;
+
+ $self->class_mappings({ %{$from->class_mappings} });
+ $self->source_registrations({ %{$from->source_registrations} });
+
+ # 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( $_ => $from->source($_) )
+ for $from->sources;
+
+ if ($from->storage) {
+ $self->storage($from->storage);
+ $self->storage->set_schema($self);
+ }
+}
+
=head2 throw_exception
=over 4
=back
-Throws an exception. Defaults to using L<Carp::Clan> to report errors from
-user's perspective. See L</exception_action> for details on overriding
+Throws an exception. Obeys the exemption rules of L<DBIx::Class::Carp> to report
+errors from outer-user's perspective. See L</exception_action> for details on overriding
this method's behavior. If L</stacktrace> is turned on, C<throw_exception>'s
default behavior will provide a detailed stack trace.
=cut
sub throw_exception {
- my $self = shift;
+ my ($self, @args) = @_;
+
+ if (
+ ! DBIx::Class::_Util::in_internal_try()
+ and
+ my $act = $self->exception_action
+ ) {
+
+ my $guard_disarmed;
+
+ my $guard = scope_guard {
+ return if $guard_disarmed;
+ emit_loud_diag( emit_dups => 1, msg => "
- DBIx::Class::Exception->throw($_[0], $self->stacktrace)
- if !$self->exception_action || !$self->exception_action->(@_);
+ !!! DBIx::Class INTERNAL PANIC !!!
+
+The exception_action() handler installed on '$self'
+aborted the stacktrace below via a longjmp (either via Return::Multilevel or
+plain goto, or Scope::Upper or something equally nefarious). There currently
+is nothing safe DBIx::Class can do, aside from displaying this error. A future
+version ( 0.082900, when available ) will reduce the cases in which the
+handler is invoked, but this is neither a complete solution, nor can it do
+anything for other software that might be affected by a similar problem.
+
+ !!! FIX YOUR ERROR HANDLING !!!
+
+This guard was activated starting",
+ );
+ };
+
+ dbic_internal_try {
+ # if it throws - good, we'll assign to @args in the end
+ # if it doesn't - do different things depending on RV truthiness
+ if( $act->(@args) ) {
+ $args[0] = (
+ "Invocation of the exception_action handler installed on $self did *not*"
+ .' result in an exception. DBIx::Class is unable to function without a reliable'
+ .' exception mechanism, ensure your exception_action does not hide exceptions'
+ ." (original error: $args[0])"
+ );
+ }
+ else {
+ carp_unique (
+ "The exception_action handler installed on $self returned false instead"
+ .' of throwing an exception. This behavior has been deprecated, adjust your'
+ .' handler to always rethrow the supplied error'
+ );
+ }
+
+ 1;
+ }
+ catch {
+ # We call this to get the necessary warnings emitted and disregard the RV
+ # as it's definitely an exception if we got as far as this catch{} block
+ is_exception(
+ $args[0] = $_
+ );
+ };
+
+ # Done guarding against https://github.com/PerlDancer/Dancer2/issues/1125
+ $guard_disarmed = 1;
+ }
+
+ DBIx::Class::Exception->throw( $args[0], $self->stacktrace );
}
=head2 deploy
See L<SQL::Translator/METHODS> for a list of values for C<\%sqlt_args>.
The most common value for this would be C<< { add_drop_table => 1 } >>
to have the SQL produced include a C<DROP TABLE> statement for each table
-created. For quoting purposes supply C<quote_table_names> and
-C<quote_field_names>.
+created. For quoting purposes supply C<quote_identifiers>.
-Additionally, the DBIx::Class parser accepts a C<sources> parameter as a hash
-ref or an array ref, containing a list of source to deploy. If present, then
+Additionally, the DBIx::Class parser accepts a C<sources> parameter as a hash
+ref or an array ref, containing a list of source to deploy. If present, then
only the sources listed will get deployed. Furthermore, you can use the
C<add_fk_index> parser parameter to prevent the parser from creating an index for each
FK.
=item Arguments: See L<DBIx::Class::Storage::DBI/deployment_statements>
-=item Return value: $listofstatements
+=item Return Value: $listofstatements
=back
A convenient shortcut to
C<< $self->storage->deployment_statements($self, @args) >>.
-Returns the SQL statements used by L</deploy> and
-L<DBIx::Class::Schema::Storage/deploy>.
+Returns the statements used by L</deploy> and
+L<DBIx::Class::Storage/deploy>.
=cut
$self->storage->deployment_statements($self, @_);
}
-=head2 create_ddl_dir (EXPERIMENTAL)
+=head2 create_ddl_dir
=over 4
=back
-A convenient shortcut to
+A convenient shortcut to
C<< $self->storage->create_ddl_dir($self, @args) >>.
Creates an SQL file based on the Schema, for each of the specified
=item Arguments: $database-type, $version, $directory, $preversion
-=item Return value: $normalised_filename
+=item Return Value: $normalised_filename
=back
my $filename = $table->ddl_filename($type, $dir, $version, $preversion)
In recent versions variables $dir and $version were reversed in order to
- bring the signature in line with other Schema/Storage methods. If you
+ bring the signature in line with other Schema/Storage methods. If you
really need to maintain backward compatibility, you can do the following
in any overriding methods:
sub ddl_filename {
my ($self, $type, $version, $dir, $preversion) = @_;
- my $filename = ref($self);
- $filename =~ s/::/-/g;
- $filename = File::Spec->catfile($dir, "$filename-$version-$type.sql");
- $filename =~ s/$version/$preversion-$version/ if($preversion);
+ $version = "$preversion-$version" if $preversion;
+
+ my $class = blessed($self) || $self;
+ $class =~ s/::/-/g;
- return $filename;
+ return "$dir/$class-$version-$type.sql";
}
=head2 thaw
-Provided as the recommended way of thawing schema objects. You can call
+Provided as the recommended way of thawing schema objects. You can call
C<Storable::thaw> directly if you wish, but the thawed objects will not have a
-reference to any schema, so are rather useless
+reference to any schema, so are rather useless.
=cut
=head2 freeze
-This doesn't actualy do anything more than call L<Storable/freeze>, it is just
-provided here for symetry.
+This doesn't actually do anything beyond calling L<nfreeze|Storable/SYNOPSIS>,
+it is just provided here for symmetry.
=cut
sub freeze {
- return Storable::freeze($_[1]);
+ return Storable::nfreeze($_[1]);
}
=head2 dclone
=over 4
-=item Arguments: $moniker, $component_class
+=item Arguments: $source_name, $component_class
=back
-This method is called by L</load_namespaces> and L</load_classes> to install the found classes into your Schema. You should be using those instead of this one.
+This method is called by L</load_namespaces> and L</load_classes> to install the found classes into your Schema. You should be using those instead of this one.
You will only need this method if you have your Result classes in
files which are not named after the packages (or all in the same
Registers a class which isa DBIx::Class::ResultSourceProxy. Equivalent to
calling:
- $schema->register_source($moniker, $component_class->result_source_instance);
+ $schema->register_source($source_name, $component_class->result_source_instance);
=cut
sub register_class {
- my ($self, $moniker, $to_register) = @_;
- $self->register_source($moniker => $to_register->result_source_instance);
+ my ($self, $source_name, $to_register) = @_;
+ $self->register_source($source_name => $to_register->result_source_instance);
}
=head2 register_source
=over 4
-=item Arguments: $moniker, $result_source
+=item Arguments: $source_name, L<$result_source|DBIx::Class::ResultSource>
=back
This method is called by L</register_class>.
Registers the L<DBIx::Class::ResultSource> in the schema with the given
-moniker.
+source name.
=cut
-sub register_source {
- my $self = shift;
+sub register_source { shift->_register_source(@_) }
- $self->_register_source(@_);
-}
+=head2 unregister_source
+
+=over 4
+
+=item Arguments: $source_name
+
+=back
+
+Removes the L<DBIx::Class::ResultSource> from the schema for the given source name.
+
+=cut
+
+sub unregister_source { shift->_unregister_source(@_) }
=head2 register_extra_source
=over 4
-=item Arguments: $moniker, $result_source
+=item Arguments: $source_name, L<$result_source|DBIx::Class::ResultSource>
=back
-As L</register_source> but should be used if the result class already
+As L</register_source> but should be used if the result class already
has a source and you want to register an extra one.
=cut
-sub register_extra_source {
- my $self = shift;
-
- $self->_register_source(@_, { extra => 1 });
-}
+sub register_extra_source { shift->_register_source(@_, { extra => 1 }) }
sub _register_source {
- my ($self, $moniker, $source, $params) = @_;
+ my ($self, $source_name, $supplied_rsrc, $params) = @_;
- my $orig_source = $source;
+ my $derived_rsrc = $supplied_rsrc->clone({
+ source_name => $source_name,
+ });
- $source = $source->new({ %$source, source_name => $moniker });
- $source->schema($self);
- Scalar::Util::weaken($source->{schema}) if ref($self);
+ # Do not move into the clone-hashref above: there are things
+ # on CPAN that do hook 'sub schema' </facepalm>
+ # https://metacpan.org/source/LSAUNDERS/DBIx-Class-Preview-1.000003/lib/DBIx/Class/ResultSource/Table/Previewed.pm#L9-38
+ $derived_rsrc->schema($self);
- my $rs_class = $source->result_class;
+ weaken $derived_rsrc->{schema}
+ if length ref($self);
my %reg = %{$self->source_registrations};
- $reg{$moniker} = $source;
+ $reg{$source_name} = $derived_rsrc;
$self->source_registrations(\%reg);
- return if ($params->{extra});
- return unless defined($rs_class) && $rs_class->can('result_source_instance');
+ return $derived_rsrc if $params->{extra};
- my %map = %{$self->class_mappings};
+ my( $result_class, $result_class_level_rsrc );
if (
- exists $map{$rs_class}
- and
- $map{$rs_class} ne $moniker
+ $result_class = $derived_rsrc->result_class
and
- $rs_class->result_source_instance ne $orig_source
+ # There are known cases where $rs_class is *ONLY* an inflator, without
+ # any hint of a rsrc (e.g. DBIx::Class::KiokuDB::EntryProxy)
+ $result_class_level_rsrc = dbic_internal_try { $result_class->result_source_instance }
) {
- carp "$rs_class already has a source, use register_extra_source for additional sources";
+ my %map = %{$self->class_mappings};
+
+ carp (
+ "$result_class already had a registered source which was replaced by "
+ . 'this call. Perhaps you wanted register_extra_source(), though it is '
+ . 'more likely you did something wrong.'
+ ) if (
+ exists $map{$result_class}
+ and
+ $map{$result_class} ne $source_name
+ and
+ $result_class_level_rsrc != $supplied_rsrc
+ );
+
+ $map{$result_class} = $source_name;
+ $self->class_mappings(\%map);
+ }
+
+ $derived_rsrc;
+}
+
+my $global_phase_destroy;
+sub DESTROY {
+ ### NO detected_reinvoked_destructor check
+ ### This code very much relies on being called multuple times
+
+ return if $global_phase_destroy ||= in_global_destruction;
+
+ my $self = shift;
+ my $srcs = $self->source_registrations;
+
+ for my $source_name (keys %$srcs) {
+ # find first source that is not about to be GCed (someone other than $self
+ # holds a reference to it) and reattach to it, weakening our own link
+ #
+ # during global destruction (if we have not yet bailed out) this should throw
+ # which will serve as a signal to not try doing anything else
+ # however beware - on older perls the exception seems randomly untrappable
+ # due to some weird race condition during thread joining :(((
+ if (length ref $srcs->{$source_name} and refcount($srcs->{$source_name}) > 1) {
+ local $SIG{__DIE__} if $SIG{__DIE__};
+ local $@ if DBIx::Class::_ENV_::UNSTABLE_DOLLARAT;
+ eval {
+ $srcs->{$source_name}->schema($self);
+ weaken $srcs->{$source_name};
+ 1;
+ } or do {
+ $global_phase_destroy = 1;
+ };
+
+ last;
+ }
}
- $map{$rs_class} = $moniker;
- $self->class_mappings(\%map);
+
+ # Dummy NEXTSTATE ensuring the all temporaries on the stack are garbage
+ # collected before leaving this scope. Depending on the code above, this
+ # may very well be just a preventive measure guarding future modifications
+ undef;
}
sub _unregister_source {
- my ($self, $moniker) = @_;
- my %reg = %{$self->source_registrations};
+ my ($self, $source_name) = @_;
+ my %reg = %{$self->source_registrations};
- my $source = delete $reg{$moniker};
+ my $source = delete $reg{$source_name};
$self->source_registrations(\%reg);
if ($source->result_class) {
my %map = %{$self->class_mappings};
=cut
-{
- my $warn;
-
- sub compose_connection {
- my ($self, $target, @info) = @_;
+sub compose_connection {
+ my ($self, $target, @info) = @_;
- carp "compose_connection deprecated as of 0.08000"
- unless ($INC{"DBIx/Class/CDBICompat.pm"} || $warn++);
+ carp_once "compose_connection deprecated as of 0.08000"
+ unless $INC{"DBIx/Class/CDBICompat.pm"};
- my $base = 'DBIx::Class::ResultSetProxy';
- eval "require ${base};";
+ dbic_internal_try {
+ require DBIx::Class::ResultSetProxy;
+ }
+ catch {
$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';
- my $name = join '::', $target, 'schema';
- *$name = Sub::Name::subname $name, sub { $schema };
- }
+ ("No arguments to load_classes and couldn't load DBIx::Class::ResultSetProxy ($_)")
+ };
- $schema->connection(@info);
- foreach my $moniker ($schema->sources) {
- my $source = $schema->source($moniker);
+ if ($self eq $target) {
+ # Pathological case, largely caused by the docs on early C::M::DBIC::Plain
+ foreach my $source_name ($self->sources) {
+ my $source = $self->source($source_name);
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);
+ $self->inject_base($class, 'DBIx::Class::ResultSetProxy');
+ $class->mk_classaccessor(resultset_instance => $source->resultset);
+ $class->mk_classaccessor(class_resolver => $self);
}
- return $schema;
+ $self->connection(@info);
+ return $self;
}
-}
-1;
+ my $schema = $self->compose_namespace($target, 'DBIx::Class::ResultSetProxy');
+ quote_sub "${target}::schema", '$s', { '$s' => \$schema };
+
+ $schema->connection(@info);
+ foreach my $source_name ($schema->sources) {
+ my $source = $schema->source($source_name);
+ my $class = $source->result_class;
+ #warn "$source_name $class $source ".$source->storage;
+
+ $class->mk_group_accessors( inherited => [ result_source_instance => '_result_source' ] );
+ # explicit set-call, avoid mro update lag
+ $class->set_inherited( result_source_instance => $source );
+
+ $class->mk_classaccessor(resultset_instance => $source->resultset);
+ $class->mk_classaccessor(class_resolver => $schema);
+ }
+ return $schema;
+}
-=head1 AUTHORS
+=head1 FURTHER QUESTIONS?
-Matt S. Trout <mst@shadowcatsystems.co.uk>
+Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
-=head1 LICENSE
+=head1 COPYRIGHT AND LICENSE
-You may distribute this code under the same terms as Perl itself.
+This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
+by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
+redistribute it and/or modify it under the same terms as the
+L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
=cut
+
+1;
projects / dbsrgits/DBIx-Class.git / blobdiff