X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSource.pm;h=ee5704faed0af56be7a93ce3143c4a4677102742;hb=616ca57f8cd27f475da275bbef986fdd42d4069f;hp=d6ca1ed09f8f901370452862beba38554e808ae6;hpb=e570488ade8f327f47dd3318db3443a348d561d6;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/ResultSource.pm b/lib/DBIx/Class/ResultSource.pm index d6ca1ed..ee5704f 100644 --- a/lib/DBIx/Class/ResultSource.pm +++ b/lib/DBIx/Class/ResultSource.pm @@ -1,12 +1,28 @@ package DBIx::Class::ResultSource; +### !!!NOTE!!! +# +# Some of the methods defined here will be around()-ed by code at the +# end of ::ResultSourceProxy. The reason for this strange arrangement +# is that the list of around()s of methods in this class depends +# directly on the list of may-not-be-defined-yet methods within +# ::ResultSourceProxy itself. +# If this sounds terrible - it is. But got to work with what we have. +# + use strict; use warnings; use base 'DBIx::Class::ResultSource::RowParser'; use DBIx::Class::Carp; -use DBIx::Class::_Util qw( UNRESOLVABLE_CONDITION dbic_internal_try fail_on_internal_call ); +use DBIx::Class::_Util qw( + UNRESOLVABLE_CONDITION + dbic_internal_try fail_on_internal_call + refdesc emit_loud_diag +); +use DBIx::Class::SQLMaker::Util qw( normalize_sqla_condition extract_equality_conditions ); +use DBIx::Class::ResultSource::FromSpec::Util 'fromspec_columns_info'; use SQL::Abstract 'is_literal_value'; use Devel::GlobalDestruction; use Scalar::Util qw( blessed weaken isweak refaddr ); @@ -16,6 +32,13 @@ use DBIx::Class::ResultSet; use namespace::clean; +# This global is present for the afaik nonexistent, but nevertheless possible +# case of folks using stock ::ResultSet with a completely custom Result-class +# hierarchy, not derived from DBIx::Class::Row at all +# Instead of patching stuff all over the place - this would be one convenient +# place to override things if need be +our $__expected_result_class_isa = 'DBIx::Class::Row'; + my @hashref_attributes = qw( source_info resultset_attributes _columns _unique_constraints _relationships @@ -23,16 +46,16 @@ my @hashref_attributes = qw( my @arrayref_attributes = qw( _ordered_columns _primaries ); -__PACKAGE__->mk_group_accessors(simple => +__PACKAGE__->mk_group_accessors(rsrc_instance_specific_attribute => @hashref_attributes, @arrayref_attributes, qw( source_name name column_info_from_storage sqlt_deploy_callback ), ); -__PACKAGE__->mk_group_accessors(component_class => qw/ +__PACKAGE__->mk_group_accessors(rsrc_instance_specific_handler => qw( resultset_class result_class -/); +)); =head1 NAME @@ -200,7 +223,7 @@ Creates a new ResultSource object. Not normally called directly by end users. $self->{sqlt_deploy_callback} ||= 'default_sqlt_deploy_hook'; $self->{$_} = { %{ $self->{$_} || {} } } - for @hashref_attributes; + for @hashref_attributes, '__metadata_divergencies'; $self->{$_} = [ @{ $self->{$_} || [] } ] for @arrayref_attributes; @@ -217,11 +240,233 @@ Creates a new ResultSource object. Not normally called directly by end users. } values %$r } } + + + # needs direct access to $rsrc_registry under an assert + # + sub set_rsrc_instance_specific_attribute { + + # only mark if we are setting something different + if ( + ( + defined( $_[2] ) + xor + defined( $_[0]->{$_[1]} ) + ) + or + ( + # both defined + defined( $_[2] ) + and + ( + # differ in ref-ness + ( + length ref( $_[2] ) + xor + length ref( $_[0]->{$_[1]} ) + ) + or + # both refs (the mark-on-same-ref is deliberate) + length ref( $_[2] ) + or + # both differing strings + $_[2] ne $_[0]->{$_[1]} + ) + ) + ) { + + my $callsite; + # need to protect $_ here + for my $derivative ( + $_[0]->__derived_instances, + + # DO NOT REMOVE - this blob is marking *ancestors* as tainted, here to + # weed out any fallout from https://github.com/dbsrgits/dbix-class/commit/9e36e3ec + # Note that there is no way to kill this warning, aside from never + # calling set_primary_key etc more than once per hierarchy + # (this is why the entire thing is guarded by an assert) + ( + ( + DBIx::Class::_ENV_::ASSERT_NO_ERRONEOUS_METAINSTANCE_USE + and + grep { $_[1] eq $_ } qw( _unique_constraints _primaries source_info ) + ) + ? ( + map + { defined($_->{weakref}) ? $_->{weakref} : () } + grep + { defined( ( $_->{derivatives}{refaddr($_[0])} || {} )->{weakref} ) } + values %$rsrc_registry + ) + : () + ), + ) { + + $derivative->{__metadata_divergencies}{$_[1]}{ $callsite ||= do { + + # + # FIXME - this is horrible, but it's the best we can do for now + # Replace when Carp::Skip is written (it *MUST* take this use-case + # into consideration) + # + my ($cs) = DBIx::Class::Carp::__find_caller(__PACKAGE__); + + my ($fr_num, @fr) = 1; + while( @fr = CORE::caller($fr_num++) ) { + $cs =~ /^ \Qat $fr[1] line $fr[2]\E (?: $ | \n )/x + and + $fr[3] =~ s/.+::// + and + last + } + + # FIXME - using refdesc here isn't great, but I can't think of anything + # better at this moment + @fr + ? "@{[ refdesc $_[0] ]}->$fr[3](...) $cs" + : "$cs" + ; + } } = 1; + } + } + + $_[0]->{$_[1]} = $_[2]; + } +} + +sub get_rsrc_instance_specific_attribute { + + $_[0]->__emit_stale_metadata_diag( $_[1] ) if ( + ! $_[0]->{__in_rsrc_setter_callstack} + and + $_[0]->{__metadata_divergencies}{$_[1]} + ); + + $_[0]->{$_[1]}; +} + + +# reuse the elaborate set logic of instance_specific_attr +sub set_rsrc_instance_specific_handler { + $_[0]->set_rsrc_instance_specific_attribute($_[1], $_[2]); + + # trigger a load for the case of $foo->handler_accessor("bar")->new + $_[0]->get_rsrc_instance_specific_handler($_[1]) + if defined wantarray; +} + +# This is essentially the same logic as get_component_class +# (in DBIC::AccessorGroup). However the latter is a grouped +# accessor type, and here we are strictly after a 'simple' +# So we go ahead and recreate the logic as found in ::AG +sub get_rsrc_instance_specific_handler { + + # emit desync warnings if any + my $val = $_[0]->get_rsrc_instance_specific_attribute( $_[1] ); + + # plain string means class - load it + no strict 'refs'; + if ( + defined $val + and + # inherited CAG can't be set to undef effectively, so people may use '' + length $val + and + ! defined blessed $val + and + ! ${"${val}::__LOADED__BY__DBIC__CAG__COMPONENT_CLASS__"} + ) { + $_[0]->ensure_class_loaded($val); + + ${"${val}::__LOADED__BY__DBIC__CAG__COMPONENT_CLASS__"} + = do { \(my $anon = 'loaded') }; + } + + $val; +} + + +sub __construct_stale_metadata_diag { + return '' unless $_[0]->{__metadata_divergencies}{$_[1]}; + + my ($fr_num, @fr); + + # find the CAG getter FIRST + # allows unlimited user-namespace overrides without screwing around with + # $LEVEL-like crap + while( + @fr = CORE::caller(++$fr_num) + and + $fr[3] ne 'DBIx::Class::ResultSource::get_rsrc_instance_specific_attribute' + ) { 1 } + + Carp::confess( "You are not supposed to call __construct_stale_metadata_diag here..." ) + unless @fr; + + # then find the first non-local, non-private reportable callsite + while ( + @fr = CORE::caller(++$fr_num) + and + ( + $fr[2] == 0 + or + $fr[3] eq '(eval)' + or + $fr[1] =~ /^\(eval \d+\)$/ + or + $fr[3] =~ /::(?: __ANON__ | _\w+ )$/x + or + $fr[0] =~ /^DBIx::Class::ResultSource/ + ) + ) { 1 } + + my $by = ( @fr and $fr[3] =~ s/.+::// ) + # FIXME - using refdesc here isn't great, but I can't think of anything + # better at this moment + ? " by 'getter' @{[ refdesc $_[0] ]}->$fr[3](...)\n within the callstack beginning" + : '' + ; + + # Given the full stacktrace combined with the really involved callstack + # there is no chance the emitter will properly deduplicate this + # Only complain once per callsite per source + return( ( $by and $_[0]->{__encountered_divergencies}{$by}++ ) + + ? '' + + : "$_[0] (the metadata instance of source '@{[ $_[0]->source_name ]}') is " + . "*OUTDATED*, and does not reflect the modifications of its " + . "*ancestors* as follows:\n" + . join( "\n", + map + { " * $_->[0]" } + sort + { $a->[1] cmp $b->[1] } + map + { [ $_, ( $_ =~ /( at .+? line \d+)/ ) ] } + keys %{ $_[0]->{__metadata_divergencies}{$_[1]} } + ) + . "\nStale metadata accessed${by}" + ); +} + +sub __emit_stale_metadata_diag { + emit_loud_diag( + msg => ( + # short circuit: no message - no diag + $_[0]->__construct_stale_metadata_diag($_[1]) + || + return 0 + ), + # the constructor already does deduplication + emit_dups => 1, + confess => DBIx::Class::_ENV_::ASSERT_NO_ERRONEOUS_METAINSTANCE_USE, + ); } =head2 clone - $rsrc_instance->clone( atribute_name => overriden_value ); + $rsrc_instance->clone( atribute_name => overridden_value ); A wrapper around L inheriting any defaults from the callee. This method also not normally invoked directly by end users. @@ -443,6 +688,10 @@ info keys as L. sub add_columns { my ($self, @cols) = @_; + + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + $self->_ordered_columns(\@cols) unless $self->_ordered_columns; my ( @added, $colinfos ); @@ -470,10 +719,11 @@ sub add_columns { } push @{ $self->_ordered_columns }, @added; + $self->_columns($columns); return $self; } -sub add_column { +sub add_column :DBIC_method_is_indirect_sugar { DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call; shift->add_columns(@_) } @@ -517,7 +767,7 @@ contents of the hashref. =cut -sub column_info { +sub column_info :DBIC_method_is_indirect_sugar { DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call; #my ($self, $column) = @_; @@ -666,6 +916,9 @@ broken result source. sub remove_columns { my ($self, @to_remove) = @_; + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + my $columns = $self->_columns or return; @@ -678,7 +931,7 @@ sub remove_columns { $self->_ordered_columns([ grep { not $to_remove{$_} } @{$self->_ordered_columns} ]); } -sub remove_column { +sub remove_column :DBIC_method_is_indirect_sugar { DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call; shift->remove_columns(@_) } @@ -710,6 +963,9 @@ for more info. sub set_primary_key { my ($self, @cols) = @_; + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + my $colinfo = $self->columns_info(\@cols); for my $col (@cols) { carp_unique(sprintf ( @@ -792,6 +1048,9 @@ will be applied to the L of each L sub sequence { my ($self,$seq) = @_; + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + my @pks = $self->primary_columns or return; @@ -838,6 +1097,9 @@ the result source. sub add_unique_constraint { my $self = shift; + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + if (@_ > 2) { $self->throw_exception( 'add_unique_constraint() does not accept multiple constraints, use ' @@ -900,7 +1162,7 @@ See also L. =cut -sub add_unique_constraints { +sub add_unique_constraints :DBIC_method_is_indirect_sugar { DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call; my $self = shift; @@ -1329,10 +1591,11 @@ result source instance has been attached to. sub schema { if (@_ > 1) { - $_[0]->{schema} = $_[1]; + # invoke the mark-diverging logic + $_[0]->set_rsrc_instance_specific_attribute( schema => $_[1] ); } else { - $_[0]->{schema} || do { + $_[0]->get_rsrc_instance_specific_attribute( 'schema' ) || do { my $name = $_[0]->{source_name} || '_unnamed_'; my $err = 'Unable to perform storage-dependent operations with a detached result source ' . "(source '$name' is not associated with a schema)."; @@ -1362,7 +1625,7 @@ Returns the L for the current schema. =cut -sub storage { +sub storage :DBIC_method_is_indirect_sugar { DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call; $_[0]->schema->storage } @@ -1448,6 +1711,10 @@ be resolved. sub add_relationship { my ($self, $rel, $f_source_name, $cond, $attrs) = @_; + + local $self->{__in_rsrc_setter_callstack} = 1 + unless $self->{__in_rsrc_setter_callstack}; + $self->throw_exception("Can't create relationship without join condition") unless $cond; $attrs ||= {}; @@ -1670,7 +1937,7 @@ sub _minimal_valueset_satisfying_constraint { $args->{columns_info} ||= $self->columns_info; - my $vals = $self->schema->storage->_extract_fixed_condition_columns( + my $vals = extract_equality_conditions( $args->{values}, ($args->{carp_on_nulls} ? 'consider_nulls' : undef ), ); @@ -1684,7 +1951,7 @@ sub _minimal_valueset_satisfying_constraint { $cols->{$args->{carp_on_nulls} ? 'undefined' : 'missing'}{$col} = undef; } else { - # we need to inject back the '=' as _extract_fixed_condition_columns + # we need to inject back the '=' as extract_equality_conditions() # will strip it from literals and values alike, resulting in an invalid # condition in the end $cols->{present}{$col} = { '=' => $vals->{$col} }; @@ -2006,16 +2273,19 @@ sub _resolve_relationship_condition { $args->{require_join_free_condition} ||= !!$args->{infer_values_based_on}; - $self->throw_exception( "Argument 'self_result_object' must be an object inheriting from DBIx::Class::Row" ) + $self->throw_exception( "Argument 'self_result_object' must be an object inheriting from '$__expected_result_class_isa'" ) if ( exists $args->{self_result_object} and - ( ! defined blessed $args->{self_result_object} or ! $args->{self_result_object}->isa('DBIx::Class::Row') ) + ( + ! defined blessed $args->{self_result_object} + or + ! $args->{self_result_object}->isa( $__expected_result_class_isa ) + ) ) ; my $rel_rsrc = $self->related_source($args->{rel_name}); - my $storage = $self->schema->storage; if (exists $args->{foreign_values}) { @@ -2025,8 +2295,8 @@ sub _resolve_relationship_condition { } elsif (defined blessed $args->{foreign_values}) { - $self->throw_exception( "Objects supplied as 'foreign_values' ($args->{foreign_values}) must inherit from DBIx::Class::Row" ) - unless $args->{foreign_values}->isa('DBIx::Class::Row'); + $self->throw_exception( "Objects supplied as 'foreign_values' ($args->{foreign_values}) must inherit from '$__expected_result_class_isa'" ) + unless $args->{foreign_values}->isa( $__expected_result_class_isa ); carp_unique( "Objects supplied as 'foreign_values' ($args->{foreign_values}) " @@ -2046,7 +2316,7 @@ sub _resolve_relationship_condition { qw( columns relationships ) ; - my $equivalencies = $storage->_extract_fixed_condition_columns( + my $equivalencies = extract_equality_conditions( $args->{foreign_values}, 'consider nulls', ); @@ -2140,11 +2410,9 @@ sub _resolve_relationship_condition { ) for keys %$jfc; ( - length ref $_ - and defined blessed($_) and - $_->isa('DBIx::Class::Row') + $_->isa( $__expected_result_class_isa ) and $self->throw_exception ( "The join-free condition returned for $exception_rel_id may not " @@ -2262,10 +2530,10 @@ sub _resolve_relationship_condition { and $ret->{join_free_condition} ne UNRESOLVABLE_CONDITION and - my $jfc = $storage->_collapse_cond( $ret->{join_free_condition} ) + my $jfc = normalize_sqla_condition( $ret->{join_free_condition} ) ) { - my $jfc_eqs = $storage->_extract_fixed_condition_columns($jfc, 'consider_nulls'); + my $jfc_eqs = extract_equality_conditions( $jfc, 'consider_nulls' ); if (keys %$jfc_eqs) { @@ -2305,7 +2573,7 @@ sub _resolve_relationship_condition { # (may already be there, since easy to calculate on the fly in the HASH case) if ( ! $ret->{identity_map} ) { - my $col_eqs = $storage->_extract_fixed_condition_columns($ret->{condition}); + my $col_eqs = extract_equality_conditions($ret->{condition}); my $colinfos; for my $lhs (keys %$col_eqs) { @@ -2315,7 +2583,7 @@ sub _resolve_relationship_condition { # there is no way to know who is right and who is left in a cref # therefore a full blown resolution call, and figure out the # direction a bit further below - $colinfos ||= $storage->_resolve_column_info([ + $colinfos ||= fromspec_columns_info([ { -alias => $args->{self_alias}, -rsrc => $self }, { -alias => $args->{foreign_alias}, -rsrc => $rel_rsrc }, ]);