use DBIx::Class::ResultClass::HashRefInflator;
use Scalar::Util qw/blessed weaken reftype/;
use DBIx::Class::_Util qw(
+ dbic_internal_try
fail_on_internal_wantarray fail_on_internal_call UNRESOLVABLE_CONDITION
);
use Try::Tiny;
$call_cond = shift;
}
# fish out attrs in the ($condref, $attr) case
- elsif (@_ == 2 and ( ! defined $_[0] or (ref $_[0]) ne '') ) {
+ elsif (@_ == 2 and ( ! defined $_[0] or length ref $_[0] ) ) {
($call_cond, $call_attrs) = @_;
}
elsif (@_ % 2) {
for my $i (0 .. $#_) {
next if $i % 2;
$self->throw_exception ('All keys in condition key/value pairs must be plain scalars')
- if (! defined $_[$i] or ref $_[$i] ne '');
+ if (! defined $_[$i] or length ref $_[$i] );
}
$call_cond = { @_ };
join "\x00", sort $rsrc->unique_constraint_columns($c_name)
}++;
- try {
+ dbic_internal_try {
push @unique_queries, $self->_qualify_cond_columns(
$self->result_source->_minimal_valueset_satisfying_constraint(
constraint_name => $c_name,
=cut
sub related_resultset {
- my ($self, $rel) = @_;
+ $_[0]->throw_exception(
+ 'Extra arguments to $rs->related_resultset() were always quietly '
+ . 'discarded without consideration, you need to switch to '
+ . '...->related_resultset( $relname )->search_rs( $search, $args ) instead.'
+ ) if @_ > 2;
+
+ return $_[0]->{related_resultsets}{$_[1]}
+ if defined $_[0]->{related_resultsets}{$_[1]};
- return $self->{related_resultsets}{$rel}
- if defined $self->{related_resultsets}{$rel};
+ my ($self, $rel) = @_;
return $self->{related_resultsets}{$rel} = do {
my $rsrc = $self->result_source;
my $attrs = $self->_chain_relationship($rel);
- my $join_count = $attrs->{seen_join}{$rel};
+ my $storage = $rsrc->schema->storage;
- my $alias = $self->result_source->storage
- ->relname_to_table_alias($rel, $join_count);
+ # Previously this atribute was deleted (instead of being set as it is now)
+ # Doing so seems to be harmless in all available test permutations
+ # See also 01d59a6a6 and mst's comment below
+ #
+ $attrs->{alias} = $storage->relname_to_table_alias(
+ $rel,
+ $attrs->{seen_join}{$rel}
+ );
# since this is search_related, and we already slid the select window inwards
# (the select/as attrs were deleted in the beginning), we need to flip all
# left joins to inner, so we get the expected results
# read the comment on top of the actual function to see what this does
- $attrs->{from} = $rsrc->schema->storage->_inner_join_to_node ($attrs->{from}, $alias);
-
+ $attrs->{from} = $storage->_inner_join_to_node( $attrs->{from}, $attrs->{alias} );
#XXX - temp fix for result_class bug. There likely is a more elegant fix -groditi
- delete @{$attrs}{qw(result_class alias)};
-
- my $rel_source = $rsrc->related_source($rel);
+ delete $attrs->{result_class};
my $new = do {
# source you need to know what alias it's -going- to have for things
# to work sanely (e.g. RestrictWithObject wants to be able to add
# extra query restrictions, and these may need to be $alias.)
-
- my $rel_attrs = $rel_source->resultset_attributes;
- local $rel_attrs->{alias} = $alias;
-
- $rel_source->resultset
- ->search_rs(
- undef, {
- %$attrs,
- where => $attrs->{where},
- });
+ # -- mst ~ 2007 (01d59a6a6)
+ #
+ # FIXME - this seems to be no longer neccessary (perhaps due to the
+ # advances in relcond resolution. Testing DBIC::S::RWO and its only
+ # dependent (as of Jun 2015 ) does not yield any difference with or
+ # without this line. Nevertheless keep it as is for now, to minimize
+ # churn, there is enough potential for breakage in 0.0829xx as it is
+ # -- ribasushi Jun 2015
+ #
+ my $rel_source = $rsrc->related_source($rel);
+ local $rel_source->resultset_attributes->{alias} = $attrs->{alias};
+
+ $rel_source->resultset->search_rs( undef, $attrs );
};
if (my $cache = $self->get_cache) {
});
}
+The alias of L<newly created resultsets|/search> can be altered by the
+L<alias attribute|/alias>.
+
=cut
sub current_source_alias {
$self->throw_exception("Specifying distinct => 1 in conjunction with collapse => 1 is unsupported")
if $attrs->{collapse} and $attrs->{distinct};
+
+ # Sanity check the paging attributes
+ # SQLMaker does it too, but in case of a software_limit we'll never get there
+ if (defined $attrs->{offset}) {
+ $self->throw_exception('A supplied offset attribute must be a non-negative integer')
+ if ( $attrs->{offset} =~ /[^0-9]/ or $attrs->{offset} < 0 );
+ }
+ if (defined $attrs->{rows}) {
+ $self->throw_exception("The rows attribute must be a positive integer if present")
+ if ( $attrs->{rows} =~ /[^0-9]/ or $attrs->{rows} <= 0 );
+ }
+
+
# default selection list
$attrs->{columns} = [ $source->columns ]
unless List::Util::first { exists $attrs->{$_} } qw/columns cols select as/;
];
}
+
for my $attr (qw(order_by group_by)) {
if ( defined $attrs->{$attr} ) {
}
}
- # generate selections based on the prefetch helper
- my ($prefetch, @prefetch_select, @prefetch_as);
- $prefetch = $self->_merge_joinpref_attr( {}, delete $attrs->{prefetch} )
- if defined $attrs->{prefetch};
-
- if ($prefetch) {
-
- $self->throw_exception("Unable to prefetch, resultset contains an unnamed selector $attrs->{_dark_selector}{string}")
- if $attrs->{_dark_selector};
+ # set collapse default based on presence of prefetch
+ my $prefetch;
+ if (
+ defined $attrs->{prefetch}
+ and
+ $prefetch = $self->_merge_joinpref_attr( {}, delete $attrs->{prefetch} )
+ ) {
$self->throw_exception("Specifying prefetch in conjunction with an explicit collapse => 0 is unsupported")
if defined $attrs->{collapse} and ! $attrs->{collapse};
$attrs->{collapse} = 1;
-
- # this is a separate structure (we don't look in {from} directly)
- # as the resolver needs to shift things off the lists to work
- # properly (identical-prefetches on different branches)
- my $join_map = {};
- if (ref $attrs->{from} eq 'ARRAY') {
-
- my $start_depth = $attrs->{seen_join}{-relation_chain_depth} || 0;
-
- for my $j ( @{$attrs->{from}}[1 .. $#{$attrs->{from}} ] ) {
- next unless $j->[0]{-alias};
- next unless $j->[0]{-join_path};
- next if ($j->[0]{-relation_chain_depth} || 0) < $start_depth;
-
- my @jpath = map { keys %$_ } @{$j->[0]{-join_path}};
-
- my $p = $join_map;
- $p = $p->{$_} ||= {} for @jpath[ ($start_depth/2) .. $#jpath]; #only even depths are actual jpath boundaries
- push @{$p->{-join_aliases} }, $j->[0]{-alias};
- }
- }
-
- my @prefetch = $source->_resolve_prefetch( $prefetch, $alias, $join_map );
-
- # save these for after distinct resolution
- @prefetch_select = map { $_->[0] } @prefetch;
- @prefetch_as = map { $_->[1] } @prefetch;
}
+
# run through the resulting joinstructure (starting from our current slot)
# and unset collapse if proven unnecessary
#
}
}
+
# generate the distinct induced group_by before injecting the prefetched select/as parts
if (delete $attrs->{distinct}) {
if ($attrs->{group_by}) {
}
}
- # inject prefetch-bound selection (if any)
- push @{$attrs->{select}}, @prefetch_select;
- push @{$attrs->{as}}, @prefetch_as;
+
+ # generate selections based on the prefetch helper
+ if ($prefetch) {
+
+ $self->throw_exception("Unable to prefetch, resultset contains an unnamed selector $attrs->{_dark_selector}{string}")
+ if $attrs->{_dark_selector};
+
+ # this is a separate structure (we don't look in {from} directly)
+ # as the resolver needs to shift things off the lists to work
+ # properly (identical-prefetches on different branches)
+ my $joined_node_aliases_map = {};
+ if (ref $attrs->{from} eq 'ARRAY') {
+
+ my $start_depth = $attrs->{seen_join}{-relation_chain_depth} || 0;
+
+ for my $j ( @{$attrs->{from}}[1 .. $#{$attrs->{from}} ] ) {
+ next unless $j->[0]{-alias};
+ next unless $j->[0]{-join_path};
+ next if ($j->[0]{-relation_chain_depth} || 0) < $start_depth;
+
+ my @jpath = map { keys %$_ } @{$j->[0]{-join_path}};
+
+ my $p = $joined_node_aliases_map;
+ $p = $p->{$_} ||= {} for @jpath[ ($start_depth/2) .. $#jpath]; #only even depths are actual jpath boundaries
+ push @{$p->{-join_aliases} }, $j->[0]{-alias};
+ }
+ }
+
+ ( push @{$attrs->{select}}, $_->[0] ) and ( push @{$attrs->{as}}, $_->[1] )
+ for $source->_resolve_selection_from_prefetch( $prefetch, $joined_node_aliases_map );
+ }
+
$attrs->{_simple_passthrough_construction} = !(
$attrs->{collapse}
grep { $_ =~ /\./ } @{$attrs->{as}}
);
+
# if both page and offset are specified, produce a combined offset
# even though it doesn't make much sense, this is what pre 081xx has
# been doing
... do stuff ...
}
- $rs->first; # without cache, this would issue a query
+ $resultset->first; # without cache, this would issue a query
By default, searches are not cached.
projects / dbsrgits/DBIx-Class.git / blobdiff