X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBIHacks.pm;h=da09d12a0014570f42cb0db54bcd20ac2cdb7741;hb=135ac69ddafd158cbfa4082871599ee104bbd205;hp=d78ab7483a79c95598b7ea378bde20cef06e1435;hpb=302d35f8b3225b4da3755dd3e3f45efede130533;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBIHacks.pm b/lib/DBIx/Class/Storage/DBIHacks.pm index d78ab74..da09d12 100644 --- a/lib/DBIx/Class/Storage/DBIHacks.pm +++ b/lib/DBIx/Class/Storage/DBIHacks.pm @@ -15,8 +15,8 @@ use mro 'c3'; use List::Util 'first'; use Scalar::Util 'blessed'; -use Sub::Name 'subname'; -use DBIx::Class::_Util qw(is_plain_value is_literal_value); +use DBIx::Class::_Util qw(UNRESOLVABLE_CONDITION serialize); +use SQL::Abstract qw(is_plain_value is_literal_value); use namespace::clean; # @@ -111,8 +111,8 @@ sub _adjust_select_args_for_complex_prefetch { my $outer_attrs = { %$attrs }; delete @{$outer_attrs}{qw(from bind rows offset group_by _grouped_by_distinct having)}; - my $inner_attrs = { %$attrs }; - delete @{$inner_attrs}{qw(for collapse select as _related_results_construction)}; + my $inner_attrs = { %$attrs, _simple_passthrough_construction => 1 }; + delete @{$inner_attrs}{qw(for collapse select as)}; # there is no point of ordering the insides if there is no limit delete $inner_attrs->{order_by} if ( @@ -887,7 +887,7 @@ sub _order_by_is_stable { my @cols = ( ( map { $_->[0] } $self->_extract_order_criteria($order_by) ), - ( $where ? @{ $self->_extract_fixed_condition_columns($where) || [] } : () ), + ( $where ? keys %{ $self->_extract_fixed_condition_columns($where) } : () ), ) or return 0; my $colinfo = $self->_resolve_column_info($ident, \@cols); @@ -965,7 +965,7 @@ sub _extract_colinfo_of_stable_main_source_order_by_portion { ? $colinfos->{$_}{-colname} : () } - @{$self->_extract_fixed_condition_columns($attrs->{where}) || []} + keys %{ $self->_extract_fixed_condition_columns($attrs->{where}) } ) : () ]; @@ -986,6 +986,8 @@ sub _extract_colinfo_of_stable_main_source_order_by_portion { sub _collapse_cond { my ($self, $where, $where_is_anded_array) = @_; + my $fin; + if (! $where) { return; } @@ -998,17 +1000,17 @@ sub _collapse_cond { my $chunk = shift @pieces; if (ref $chunk eq 'HASH') { - push @pairs, map { [ $_ => $chunk->{$_} ] } sort keys %$chunk; + push @pairs, map { $_ => $chunk->{$_} } sort keys %$chunk; } elsif (ref $chunk eq 'ARRAY') { - push @pairs, [ -or => $chunk ] + push @pairs, -or => $chunk if @$chunk; } - elsif ( ! ref $chunk) { - push @pairs, [ $chunk, shift @pieces ]; + elsif ( ! length ref $chunk) { + push @pairs, $chunk, shift @pieces; } else { - push @pairs, [ '', $chunk ]; + push @pairs, '', $chunk; } } @@ -1018,25 +1020,31 @@ sub _collapse_cond { or return; # Consolidate various @conds back into something more compact - my $fin; - for my $c (@conds) { if (ref $c ne 'HASH') { push @{$fin->{-and}}, $c; } else { for my $col (sort keys %$c) { - if (exists $fin->{$col}) { - my ($l, $r) = ($fin->{$col}, $c->{$col}); - - (ref $_ ne 'ARRAY' or !@$_) and $_ = [ -and => $_ ] for ($l, $r); - if (@$l and @$r and $l->[0] eq $r->[0] and $l->[0] eq '-and') { - $fin->{$col} = [ -and => map { @$_[1..$#$_] } ($l, $r) ]; - } - else { - $fin->{$col} = [ -and => $fin->{$col}, $c->{$col} ]; - } + # consolidate all -and nodes + if ($col =~ /^\-and$/i) { + push @{$fin->{-and}}, + ref $c->{$col} eq 'ARRAY' ? @{$c->{$col}} + : ref $c->{$col} eq 'HASH' ? %{$c->{$col}} + : { $col => $c->{$col} } + ; + } + elsif ($col =~ /^\-/) { + push @{$fin->{-and}}, { $col => $c->{$col} }; + } + elsif (exists $fin->{$col}) { + $fin->{$col} = [ -and => map { + (ref $_ eq 'ARRAY' and ($_->[0]||'') =~ /^\-and$/i ) + ? @{$_}[1..$#$_] + : $_ + ; + } ($fin->{$col}, $c->{$col}) ]; } else { $fin->{$col} = $c->{$col}; @@ -1044,58 +1052,90 @@ sub _collapse_cond { } } } - - if ( ref $fin->{-and} eq 'ARRAY' and @{$fin->{-and}} == 1 ) { - my $piece = (delete $fin->{-and})->[0]; - if (ref $piece eq 'ARRAY') { - $fin->{-or} = $fin->{-or} ? [ $piece, $fin->{-or} ] : $piece; - } - elsif (! exists $fin->{''}) { - $fin->{''} = $piece; - } - } - - return $fin; } elsif (ref $where eq 'ARRAY') { - my @w = @$where; + # we are always at top-level here, it is safe to dump empty *standalone* pieces + my $fin_idx; - while ( @w and ( - (ref $w[0] eq 'ARRAY' and ! @{$w[0]} ) - or - (ref $w[0] eq 'HASH' and ! keys %{$w[0]}) - )) { shift @w }; + for (my $i = 0; $i <= $#$where; $i++ ) { - return unless @w; + my $logic_mod = lc ( ($where->[$i] =~ /^(\-(?:and|or))$/i)[0] || '' ); - if ( @w == 1 ) { - return ( ref $w[0] ) - ? $self->_collapse_cond($w[0]) - : { $w[0] => undef } - ; - } - elsif ( ref $w[0] ) { - return \@w; - } - elsif ( @w == 2 ) { - if ( ( $w[0]||'' ) =~ /^\-and$/i ) { - return (ref $w[1] eq 'HASH' or ref $w[1] eq 'ARRAY') - ? $self->_collapse_cond($w[1], (ref $w[1] eq 'ARRAY') ) - : $self->throw_exception("Unsupported top-level op/arg pair: [ $w[0] => $w[1] ]") - ; + if ($logic_mod) { + $i++; + $self->throw_exception("Unsupported top-level op/arg pair: [ $logic_mod => $where->[$i] ]") + unless ref $where->[$i] eq 'HASH' or ref $where->[$i] eq 'ARRAY'; + + my $sub_elt = $self->_collapse_cond({ $logic_mod => $where->[$i] }) + or next; + + $fin_idx->{ "SER_" . serialize $sub_elt } = $sub_elt; + } + elsif (! length ref $where->[$i] ) { + my $sub_elt = $self->_collapse_cond({ @{$where}[$i, $i+1] }) + or next; + + $fin_idx->{ "COL_$where->[$i]_" . serialize $sub_elt } = $sub_elt; + $i++; } else { - return $self->_collapse_cond({ @w }); + $fin_idx->{ "SER_" . serialize $where->[$i] } = $self->_collapse_cond( $where->[$i] ) || next; } } + + return unless $fin_idx; + + $fin = ( keys %$fin_idx == 1 ) ? (values %$fin_idx)[0] : { + -or => [ map + { ref $fin_idx->{$_} eq 'HASH' ? %{$fin_idx->{$_}} : $fin_idx->{$_} } + sort keys %$fin_idx + ] + }; } else { # not a hash not an array - return { '' => $where }; + $fin = { '' => $where }; + } + + # unroll single-element -and's + while ( + $fin->{-and} + and + @{$fin->{-and}} < 2 + ) { + my $and = delete $fin->{-and}; + last if @$and == 0; + + # at this point we have @$and == 1 + if ( + ref $and->[0] eq 'HASH' + and + ! grep { exists $fin->{$_} } keys %{$and->[0]} + ) { + $fin = { + %$fin, %{$and->[0]} + }; + } + } + + # compress same-column conds found in $fin + for my $col ( grep { $_ !~ /^\-/ } keys %$fin ) { + next unless ref $fin->{$col} eq 'ARRAY' and ($fin->{$col}[0]||'') =~ /^\-and$/i; + my $val_bag = { map { + (! defined $_ ) ? ( UNDEF => undef ) + : ( ! ref $_ or is_plain_value $_ ) ? ( "VAL_$_" => $_ ) + : ( ( 'SER_' . serialize $_ ) => $_ ) + } @{$fin->{$col}}[1 .. $#{$fin->{$col}}] }; + + if (keys %$val_bag == 1 ) { + ($fin->{$col}) = values %$val_bag; + } + else { + $fin->{$col} = [ -and => map { $val_bag->{$_} } sort keys %$val_bag ]; + } } - # catchall, some of the things above fall through - return $where; + return keys %$fin ? $fin : (); } sub _collapse_cond_unroll_pairs { @@ -1104,7 +1144,7 @@ sub _collapse_cond_unroll_pairs { my @conds; while (@$pairs) { - my ($lhs, $rhs) = @{ shift @$pairs }; + my ($lhs, $rhs) = splice @$pairs, 0, 2; if ($lhs eq '') { push @conds, $self->_collapse_cond($rhs); @@ -1121,25 +1161,36 @@ sub _collapse_cond_unroll_pairs { if (ref $rhs eq 'HASH' and ! keys %$rhs) { # FIXME - SQLA seems to be doing... nothing...? } + elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{-ident}) { + push @conds, { $lhs => { '=', $rhs } }; + } + elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{-value} and is_plain_value $rhs->{-value}) { + push @conds, { $lhs => $rhs->{-value} }; + } elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}) { - for my $p ($self->_collapse_cond_unroll_pairs([ [ $lhs => $rhs->{'='} ] ])) { - - # extra sanity check - if (keys %$p > 1) { - require Data::Dumper::Concise; - local $Data::Dumper::Deepcopy = 1; - $self->throw_exception( - "Internal error: unexpected collapse unroll:" - . Data::Dumper::Concise::Dumper { in => { $lhs => $rhs }, out => $p } - ); - } + if( is_literal_value $rhs->{'='}) { + push @conds, { $lhs => $rhs }; + } + else { + for my $p ($self->_collapse_cond_unroll_pairs([ $lhs => $rhs->{'='} ])) { + + # extra sanity check + if (keys %$p > 1) { + require Data::Dumper::Concise; + local $Data::Dumper::Deepcopy = 1; + $self->throw_exception( + "Internal error: unexpected collapse unroll:" + . Data::Dumper::Concise::Dumper { in => { $lhs => $rhs }, out => $p } + ); + } - my ($l, $r) = %$p; + my ($l, $r) = %$p; - push @conds, ( ! length ref $r or is_plain_value($r) ) - ? { $l => $r } - : { $l => { '=' => $r } } - ; + push @conds, ( ! length ref $r or is_plain_value($r) ) + ? { $l => $r } + : { $l => { '=' => $r } } + ; + } } } elsif (ref $rhs eq 'ARRAY') { @@ -1153,18 +1204,18 @@ sub _collapse_cond_unroll_pairs { if @$rhs == 1; if( $rhs->[0] =~ /^\-and$/i ) { - unshift @$pairs, map { [ $lhs => $_ ] } @{$rhs}[1..$#$rhs]; + unshift @$pairs, map { $lhs => $_ } @{$rhs}[1..$#$rhs]; } # if not an AND then it's an OR elsif(@$rhs == 2) { - unshift @$pairs, [ $lhs => $rhs->[1] ]; + unshift @$pairs, $lhs => $rhs->[1]; } else { - push @conds, { $lhs => $rhs }; + push @conds, { $lhs => [ @{$rhs}[1..$#$rhs] ] }; } } elsif (@$rhs == 1) { - unshift @$pairs, [ $lhs => $rhs->[0] ]; + unshift @$pairs, $lhs => $rhs->[0]; } else { push @conds, { $lhs => $rhs }; @@ -1179,48 +1230,81 @@ sub _collapse_cond_unroll_pairs { return @conds; } - -# returns an arrayref of column names which *definitely* have some -# sort of non-nullable *single* equality requested in the given condition -# specification. This is used to figure out if a resultset is -# constrained to a column which is part of a unique constraint, -# which in turn allows us to better predict how ordering will behave -# etc. +# Analyzes a given condition and attempts to extract all columns +# with a definitive fixed-condition criteria. Returns a hashref +# of k/v pairs suitable to be passed to set_columns(), with a +# MAJOR CAVEAT - multi-value (contradictory) equalities are still +# represented as a reference to the UNRESOVABLE_CONDITION constant +# The reason we do this is that some codepaths only care about the +# codition being stable, as opposed to actually making sense +# +# The normal mode is used to figure out if a resultset is constrained +# to a column which is part of a unique constraint, which in turn +# allows us to better predict how ordering will behave etc. +# +# With the optional "consider_nulls" boolean argument, the function +# is instead used to infer inambiguous values from conditions +# (e.g. the inheritance of resultset conditions on new_result) # -# this is a rudimentary, incomplete, and error-prone extractor -# however this is OK - it is conservative, and if we can not find -# something that is in fact there - the stack will recover gracefully sub _extract_fixed_condition_columns { - my $self = shift; - my $where_hash = $self->_collapse_cond(shift); - - my $res; - for my $c (keys %$where_hash) { - if (defined (my $v = $where_hash->{$c}) ) { - if ( - ! length ref $v - or - is_plain_value ($v) - or - ( - ref $v eq 'HASH' - and - keys %$v == 1 - and - ref $v->{'='} - and - is_literal_value($v->{'='}) - ) - ) { - $res->{$c} = 1; + my ($self, $where, $consider_nulls) = @_; + my $where_hash = $self->_collapse_cond($_[1]); + + my $res = {}; + my ($c, $v); + for $c (keys %$where_hash) { + my $vals; + + if (!defined ($v = $where_hash->{$c}) ) { + $vals->{UNDEF} = $v if $consider_nulls + } + elsif ( + ref $v eq 'HASH' + and + keys %$v == 1 + ) { + if (exists $v->{-value}) { + if (defined $v->{-value}) { + $vals->{"VAL_$v->{-value}"} = $v->{-value} + } + elsif( $consider_nulls ) { + $vals->{UNDEF} = $v->{-value}; + } } - elsif (ref $v eq 'ARRAY' and ($v->[0]||'') eq '-and') { - $res->{$_} = 1 for map { @{ $self->_extract_fixed_condition_columns({ $c => $_ }) } } @{$v}[1..$#$v]; + # do not need to check for plain values - _collapse_cond did it for us + elsif(length ref $v->{'='} and is_literal_value($v->{'='}) ) { + $vals->{ 'SER_' . serialize $v->{'='} } = $v->{'='}; } } + elsif ( + ! length ref $v + or + is_plain_value ($v) + ) { + $vals->{"VAL_$v"} = $v; + } + elsif (ref $v eq 'ARRAY' and ($v->[0]||'') eq '-and') { + for ( @{$v}[1..$#$v] ) { + my $subval = $self->_extract_fixed_condition_columns({ $c => $_ }, 'consider nulls'); # always fish nulls out on recursion + next unless exists $subval->{$c}; # didn't find anything + $vals->{ + ! defined $subval->{$c} ? 'UNDEF' + : ( ! length ref $subval->{$c} or is_plain_value $subval->{$c} ) ? "VAL_$subval->{$c}" + : ( 'SER_' . serialize $subval->{$c} ) + } = $subval->{$c}; + } + } + + if (keys %$vals == 1) { + ($res->{$c}) = (values %$vals) + unless !$consider_nulls and exists $vals->{UNDEF}; + } + elsif (keys %$vals > 1) { + $res->{$c} = UNRESOLVABLE_CONDITION; + } } - return [ sort keys %$res ]; + $res; } 1;