X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultClass%2FHashRefInflator.pm;h=4d002abeeee030e9d03a3d840c38db1abdecde6b;hb=a6ef93cbf8182ed257e5a5e877835694a23b4e74;hp=9bbf65bd8878548f4048288f78ca58defe2863b0;hpb=a5b293612996cda25ce7e7bf1a5a5a23249c7b01;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/ResultClass/HashRefInflator.pm b/lib/DBIx/Class/ResultClass/HashRefInflator.pm index 9bbf65b..4d002ab 100644 --- a/lib/DBIx/Class/ResultClass/HashRefInflator.pm +++ b/lib/DBIx/Class/ResultClass/HashRefInflator.pm @@ -5,48 +5,35 @@ use warnings; =head1 NAME -DBIx::Class::ResultClass::HashRefInflator +DBIx::Class::ResultClass::HashRefInflator - Get raw hashrefs from a resultset =head1 SYNOPSIS use DBIx::Class::ResultClass::HashRefInflator; my $rs = $schema->resultset('CD'); - $rs->result_class('DBIx::Class::ResultClass::HashRefInflator'); - or - $rs->result_class(DBIx::Class::ResultClass::HashRefInflator->new (%args)); + while (my $hashref = $rs->next) { + ... + } + + OR as an attribute: + my $rs = $schema->resultset('CD')->search({}, { + result_class => 'DBIx::Class::ResultClass::HashRefInflator', + }); while (my $hashref = $rs->next) { - ... + ... } =head1 DESCRIPTION -DBIx::Class is faster than older ORMs like Class::DBI but it still isn't +DBIx::Class is faster than older ORMs like Class::DBI but it still isn't designed primarily for speed. Sometimes you need to quickly retrieve the data -from a massive resultset, while skipping the creation of fancy row objects. +from a massive resultset, while skipping the creation of fancy result objects. Specifying this class as a C for a resultset will change C<< $rs->next >> to return a plain data hash-ref (or a list of such hash-refs if C<< $rs->all >> is used). -There are two ways of using this class: - -=over - -=item * - -Supply an instance of DBIx::Class::ResultClass::HashRefInflator to -C<< $rs->result_class >>. See L for a list of valid -arguments to new(). - -=item * - -Another way is to simply supply the class name as a string to -C<< $rs->result_class >>. Equivalent to passing -DBIx::Class::ResultClass::HashRefInflator->new(). - -=back - There are two ways of applying this class to a resultset: =over @@ -71,104 +58,37 @@ recommended. # # Generally people use this to gain as much speed as possible. If a new &mk_hash is # implemented, it should be benchmarked using the maint/benchmark_hashrefinflator.pl -# script (in addition to passing all tests of course :). Additional instructions are -# provided in the script itself. -# +# script (in addition to passing all tests of course :) # This coderef is a simple recursive function -# Arguments: ($me, $prefetch) from inflate_result() below +# Arguments: ($me, $prefetch, $is_root) from inflate_result() below my $mk_hash; $mk_hash = sub { - if (ref $_[0] eq 'ARRAY') { # multi relationship - return [ map { $mk_hash->(@$_) || () } (@_) ]; - } - else { - my $hash = { - # the main hash could be an undef if we are processing a skipped-over join - $_[0] ? %{$_[0]} : (), - - # the second arg is a hash of arrays for each prefetched relation - map - { $_ => $mk_hash->( @{$_[1]->{$_}} ) } - ( $_[1] ? (keys %{$_[1]}) : () ) - }; - - # if there is at least one defined column consider the resultset real - # (and not an emtpy has_many rel containing one empty hashref) - for (values %$hash) { - return $hash if defined $_; - } - - return undef; - } -}; - -# This is the inflator -my $inflate_hash; -$inflate_hash = sub { - my ($hri_instance, $schema, $rc, $data) = @_; - - foreach my $column (keys %{$data}) { - - if (ref $data->{$column} eq 'HASH') { - $inflate_hash->($hri_instance, $schema, $schema->source ($rc)->related_class ($column), $data->{$column}); - } - elsif (ref $data->{$column} eq 'ARRAY') { - foreach my $rel (@{$data->{$column}}) { - $inflate_hash->($hri_instance, $schema, $schema->source ($rc)->related_class ($column), $rel); - } - } - else { - # "null is null is null" - next if not defined $data->{$column}; - - # cache the inflator coderef - unless (exists $hri_instance->{_inflator_cache}{$rc}{$column}) { - $hri_instance->{_inflator_cache}{$rc}{$column} = exists $schema->source ($rc)->_relationships->{$column} - ? undef # currently no way to inflate a column sharing a name with a rel - : $rc->column_info($column)->{_inflate_info}{inflate} - ; - } - - if ($hri_instance->{_inflator_cache}{$rc}{$column}) { - $data->{$column} = $hri_instance->{_inflator_cache}{$rc}{$column}->($data->{$column}); - } - } - } -}; - -=head1 METHODS - -=head2 new + my $hash = { - $class->new( %args ); - $class->new({ %args }); + # the main hash could be an undef if we are processing a skipped-over join + $_[0] ? %{$_[0]} : (), -Creates a new DBIx::Class::ResultClass::HashRefInflator object. Takes the following -arguments: + # the second arg is a hash of arrays for each prefetched relation + map { $_ => ( -=over + # null-branch or not + ref $_[1]->{$_} eq $DBIx::Class::ResultSource::RowParser::Util::null_branch_class -=item inflate_columns + ? ref $_[1]->{$_}[0] eq 'ARRAY' ? [] : undef -Sometimes you still want all your data to be inflated to the corresponding -objects according to the rules you defined in your table classes (e.g. you -want all dates in the resulting hash to be replaced with the equivalent -DateTime objects). Supplying C<< inflate_columns => 1 >> to the constructor will -interrogate the processed columns and apply any inflation methods declared -via L to the contents of the -resulting hash-ref. + : ref $_[1]->{$_}[0] eq 'ARRAY' + ? [ map { $mk_hash->( @$_ ) || () } @{$_[1]->{$_}} ] + : $mk_hash->( @{$_[1]->{$_}} ) -=back + ) } ($_[1] ? keys %{$_[1]} : ()) + }; -=cut + ($_[2] || keys %$hash) ? $hash : undef; +}; -sub new { - my $self = shift; - my $args = { (ref $_[0] eq 'HASH') ? %{$_[0]} : @_ }; - return bless ($args, $self) -} +=head1 METHODS =head2 inflate_result @@ -176,18 +96,11 @@ Inflates the result and prefetched data into a hash-ref (invoked by Linflate_result ($resultsource_instance, $main_data_hashref, $prefetch_data_hashref) sub inflate_result { - my ($self, $source, $me, $prefetch) = @_; - - my $hashref = $mk_hash->($me, $prefetch); - - # if $self is an instance and inflate_columns is set - if ( (ref $self) and $self->{inflate_columns} ) { - $inflate_hash->($self, $source->schema, $source->result_class, $hashref); - } - - return $hashref; + return $mk_hash->($_[2], $_[3], 'is_root'); } @@ -204,17 +117,17 @@ following: my $cds = $artist->cds; $cds->result_class('DBIx::Class::ResultClass::HashRefInflator'); - my $first = $cds->first; + my $first = $cds->first; -C<$first> will B be a hashref, it will be a normal CD row since +C<$first> will B be a hashref, it will be a normal CD row since HashRefInflator only affects resultsets at inflation time, and prefetch causes relations to be inflated when the master C<$artist> row is inflated. =item * -When using C, the inflation method lookups are cached in the -HashRefInflator object for additional speed. If you modify column inflators at run -time, make sure to grab a new instance of this class to avoid cached surprises. +Column value inflation, e.g., using modules like +L, is not performed. +The returned hash contains the raw database values. =back