X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSet.pm;h=9faf8ba2b94db0237be52231360deb2d49c03503;hb=20f67ac70020b74aa6cacc7b339da66a138eddda;hp=af6cf027175acea982c0aa22757ac45b8562d189;hpb=c7ce65e6f0d957656f8e3ca26944cd9c1f03ddbc;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/ResultSet.pm b/lib/DBIx/Class/ResultSet.pm index af6cf02..9faf8ba 100644 --- a/lib/DBIx/Class/ResultSet.pm +++ b/lib/DBIx/Class/ResultSet.pm @@ -7,6 +7,29 @@ use overload fallback => 1; use Data::Page; +=head1 NAME + +DBIX::Class::Recordset - Responsible for fetching and creating recordsets. + +=head1 SYNOPSIS; + +$rs=MyApp::DB::Class->search(registered=>1); + +=head1 DESCRIPTION + +The recordset is also know as an iterator. + +=head1 METHODS + +=over 4 + +=item new + +The recordset constructor. Takes a db class and an +attribute hash (see below for more info on attributes) + +=cut + sub new { my ($it_class, $db_class, $attrs) = @_; #use Data::Dumper; warn Dumper(@_); @@ -31,7 +54,7 @@ sub new { unless $seen{$pre}; push(@{$attrs->{cols}}, map { "$pre.$_" } - $db_class->_relationships->{$pre}->{class}->columns); + $db_class->_relationships->{$pre}->{class}->_select_columns); } my $new = { class => $db_class, @@ -46,6 +69,12 @@ sub new { return $new; } +=item cursor + +Return a storage driven cursor to the given record set. + +=cut + sub cursor { my ($self) = @_; my ($db_class, $attrs) = @{$self}{qw/class attrs/}; @@ -58,6 +87,12 @@ sub cursor { $attrs->{where},$attrs); } +=item slice + +return a number of elements from the given record set. + +=cut + sub slice { my ($self, $min, $max) = @_; my $attrs = { %{ $self->{attrs} || {} } }; @@ -68,6 +103,12 @@ sub slice { return (wantarray ? $slice->all : $slice); } +=item next + +Returns the next element in this record set. + +=cut + sub next { my ($self) = @_; my @row = $self->cursor->next; @@ -77,34 +118,51 @@ sub next { sub _construct_object { my ($self, @row) = @_; - my @cols = $self->{class}->_select_columns; + my @cols = @{ $self->{attrs}{cols} }; + s/^me\.// for @cols; + @cols = grep { /\(/ or ! /\./ } @cols; + my $new; unless ($self->{attrs}{prefetch}) { - return $self->{class}->_row_to_object(\@cols, \@row); + $new = $self->{class}->_row_to_object(\@cols, \@row); } else { my @main = splice(@row, 0, scalar @cols); - my $new = $self->{class}->_row_to_object(\@cols, \@main); + $new = $self->{class}->_row_to_object(\@cols, \@main); PRE: foreach my $pre (@{$self->{attrs}{prefetch}}) { my $rel_obj = $self->{class}->_relationships->{$pre}; - my @pre_cols = $rel_obj->{class}->columns; + my $pre_class = $self->{class}->resolve_class($rel_obj->{class}); + my @pre_cols = $pre_class->_select_columns; my @vals = splice(@row, 0, scalar @pre_cols); - my $fetched = $rel_obj->{class}->_row_to_object(\@pre_cols, \@vals); + my $fetched = $pre_class->_row_to_object(\@pre_cols, \@vals); $self->{class}->throw("No accessor for prefetched $pre") unless defined $rel_obj->{attrs}{accessor}; if ($rel_obj->{attrs}{accessor} eq 'single') { foreach my $pri ($rel_obj->{class}->primary_columns) { - next PRE unless defined $fetched->get_column($pri); + unless (defined $fetched->get_column($pri)) { + undef $fetched; + last; + } } $new->{_relationship_data}{$pre} = $fetched; } elsif ($rel_obj->{attrs}{accessor} eq 'filter') { $new->{_inflated_column}{$pre} = $fetched; } else { - $self->{class}->throw("Don't know to to store prefetched $pre"); + $self->{class}->throw("Don't know how to store prefetched $pre"); } } - return $new; } + $new = $self->{attrs}{record_filter}->($new) + if exists $self->{attrs}{record_filter}; + return $new; } +=item count + +Performs an SQL count with the same query as the resultset was built +with to find the number of elements. + +=cut + + sub count { my ($self) = @_; my $db_class = $self->{class}; @@ -124,22 +182,47 @@ sub count { : $self->{count}; } +=item all + +Returns all elements in the recordset. Is called implictly if the search +method is used in list context. + +=cut + sub all { my ($self) = @_; return map { $self->_construct_object(@$_); } $self->cursor->all; } +=item reset + +Reset this recordset's cursor, so you can iterate through the elements again. + +=cut + sub reset { my ($self) = @_; $self->cursor->reset; return $self; } +=item first + +resets the recordset and returns the first element. + +=cut + sub first { return $_[0]->reset->next; } +=item delete + +Deletes all elements in the recordset. + +=cut + sub delete { my ($self) = @_; $_->delete for $self->all; @@ -148,6 +231,13 @@ sub delete { *delete_all = \&delete; # Yeah, yeah, yeah ... +=item pager + +Returns a L object for the current resultset. Only makes +sense for queries with page turned on. + +=cut + sub pager { my ($self) = @_; my $attrs = $self->{attrs}; @@ -159,6 +249,12 @@ sub pager { return $self->{pager}; } +=item page + +Returns a new recordset representing a given page. + +=cut + sub page { my ($self, $page) = @_; my $attrs = $self->{attrs}; @@ -166,4 +262,49 @@ sub page { return $self->new($self->{class}, $attrs); } +=back + +=head1 Attributes + +The recordset is responsible for handling the various attributes that +can be passed in with the search functions. Here's an overview of them: + +=over 4 + +=item order_by + +Which column to order the results by. + +=item cols + +Which cols should be retrieved on the first search. + +=item join + +Contains a list of relations that should be joined for this query. Can also +contain a hash referece to refer to that relation's relations. + +=item from + +This attribute can contain a arrayref of elements. each element can be another +arrayref, to nest joins, or it can be a hash which represents the two sides +of the join. + +*NOTE* Use this on your own risk. This allows you to shoot your foot off! + +=item page + +Should the resultset be paged? This can also be enabled by using the +'page' option. + +=item rows + +For paged resultsset, how many rows per page + +=item offset + +For paged resultsset, which page to start on. + +=back + 1;