X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultClass%2FHashRefInflator.pm;h=6d019ad83cc5441811d9d2b888858e81fb5eac84;hb=26283ee38f220f6c6bae720ea5a189c9c0f47f6f;hp=fb35d13f91acdd8fdf0b039aca0597e9c38d8bb7;hpb=2328814a26b6ee181d9999ddf57fc16d862c6ccd;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/ResultClass/HashRefInflator.pm b/lib/DBIx/Class/ResultClass/HashRefInflator.pm index fb35d13..6d019ad 100644 --- a/lib/DBIx/Class/ResultClass/HashRefInflator.pm +++ b/lib/DBIx/Class/ResultClass/HashRefInflator.pm @@ -3,26 +3,29 @@ package DBIx::Class::ResultClass::HashRefInflator; use strict; use warnings; -our %inflator_cache; -our $inflate_data; - =head1 NAME -DBIx::Class::ResultClass::HashRefInflator +DBIx::Class::ResultClass::HashRefInflator - Get raw hashrefs from a resultset =head1 SYNOPSIS - my $rs = $schema->resultset('CD'); + use DBIx::Class::ResultClass::HashRefInflator; + my $rs = $schema->resultset('CD'); $rs->result_class('DBIx::Class::ResultClass::HashRefInflator'); + while (my $hashref = $rs->next) { + ... + } =head1 DESCRIPTION -DBIx::Class is not built for speed: it's built for convenience and -ease of use. But sometimes you just need to get the data, and skip the -fancy objects. That is what this class provides. +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. +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. +There are two ways of applying this class to a resultset: =over @@ -39,53 +42,23 @@ recommended. =back -=head1 AUTOMATICALLY INFLATING COLUMN VALUES - -So you want to skip the DBIx::Class object creation part, but you still want -all your data to be inflated according to the rules you defined in your table -classes. Setting the global variable -C<$DBIx::Class::ResultClass::HashRefInflator::inflate_data> to a true value -will instruct L to interrogate the processed columns and apply any -inflation methods declared via L. - -For increased speed the inflation method lookups are cached in -C<%DBIx::Class::ResultClass::HashRefInflator::inflator_cache>. Make sure to -reset this hash if you modify column inflators at run time. - -=head1 METHODS - -=head2 inflate_result - -Inflates the result and prefetched data into a hash-ref using L. - -=cut - -sub inflate_result { - my ($self, $source, $me, $prefetch) = @_; - - my $hashref = mk_hash($me, $prefetch); - inflate_hash ($source->schema, $source->result_class, $hashref) if $inflate_data; - return $hashref; -} - -=head2 mk_hash - -This does all the work of inflating the (pre)fetched data. - =cut ############## # NOTE # -# Generally people use this to gain as much speed as possible. If a new mk_hash is +# 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 +# script (in addition to passing all tests of course :). Additional instructions are # provided in the script itself. # -sub mk_hash { +# This coderef is a simple recursive function +# Arguments: ($me, $prefetch) from inflate_result() below +my $mk_hash; +$mk_hash = sub { if (ref $_[0] eq 'ARRAY') { # multi relationship - return [ map { mk_hash (@$_) || () } (@_) ]; + return [ map { $mk_hash->(@$_) || () } (@_) ]; } else { my $hash = { @@ -94,60 +67,48 @@ sub mk_hash { # the second arg is a hash of arrays for each prefetched relation map - { $_ => mk_hash( @{$_[1]->{$_}} ) } + { $_ => $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) + # an empty arrayref is an empty multi-sub-prefetch - don't consider + # those either for (values %$hash) { - return $hash if defined $_; + if (ref $_ eq 'ARRAY') { + return $hash if @$_; + } + elsif (defined $_) { + return $hash; + } } return undef; } -} +}; -=head2 inflate_hash +=head1 METHODS -This walks through a hashref produced by L and inflates any data -for which there is a registered inflator in the C +=head2 inflate_result + +Inflates the result and prefetched data into a hash-ref (invoked by L) =cut -sub inflate_hash { - my ($schema, $rc, $data) = @_; +################################################################################## +# inflate_result is invoked as: +# HRI->inflate_result ($resultsource_instance, $main_data_hashref, $prefetch_data_hashref) +sub inflate_result { + return $mk_hash->($_[2], $_[3]); +} - foreach my $column (keys %{$data}) { - if (ref $data->{$column} eq 'HASH') { - inflate_hash ($schema, $schema->source ($rc)->related_class ($column), $data->{$column}); - } - elsif (ref $data->{$column} eq 'ARRAY') { - foreach my $rel (@{$data->{$column}}) { - inflate_hash ($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 $inflator_cache{$rc}{$column}) { - $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} - ; - } +=head1 CAVEATS - if ($inflator_cache{$rc}{$column}) { - $data->{$column} = $inflator_cache{$rc}{$column}->($data->{$column}); - } - } - } -} +=over -=head1 CAVEAT +=item * This will not work for relationships that have been prefetched. Consider the following: @@ -162,6 +123,14 @@ 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 * + +Column value inflation, e.g., using modules like +L, is not performed. +The returned hash contains the raw database values. + +=back + =cut 1;