use strict;
use warnings;
use overload
- '0+' => 'count',
+ '0+' => \&count,
'bool' => sub { 1; },
fallback => 1;
use Data::Page;
package MyApp::Schema::Artist;
use base qw/DBIx::Class/;
+ __PACKAGE__->load_components(qw/Core/);
__PACKAGE__->table('artist');
__PACKAGE__->add_columns(qw/artistid name/);
__PACKAGE__->set_primary_key('artistid');
package MyApp::Schema::CD;
use base qw/DBIx::Class/;
- __PACKAGE__->table('artist');
+ __PACKAGE__->load_components(qw/Core/);
+ __PACKAGE__->table('cd');
__PACKAGE__->add_columns(qw/cdid artist title year/);
__PACKAGE__->set_primary_key('cdid');
__PACKAGE__->belongs_to(artist => 'MyApp::Schema::Artist');
=head1 METHODS
-=head2 new($source, \%$attrs)
+=head2 new
+
+=head3 Arguments: ($source, \%$attrs)
The resultset constructor. Takes a source object (usually a
L<DBIx::Class::ResultSourceProxy::Table>) and an attribute hash (see L</ATRRIBUTES>
resultset.
=cut
-
+
sub search_literal {
my ($self, $cond, @vals) = @_;
my $attrs = (ref $vals[$#vals] eq 'HASH' ? { %{ pop(@vals) } } : {});
return $self->search(\$cond, $attrs);
}
-=head2 find(@colvalues), find(\%cols, \%attrs?)
+=head2 find
+
+=head3 Arguments: (@colvalues) | (\%cols, \%attrs?)
Finds a row based on its primary key or unique constraint. For example:
Also takes an optional C<key> attribute, to search by a specific key or unique
constraint. For example:
- my $cd = $schema->resultset('CD')->find_or_create(
+ my $cd = $schema->resultset('CD')->find(
{
artist => 'Massive Attack',
title => 'Mezzanine',
return $class->search($query, { %$attrs });
}
-=head2 slice($first, $last)
+=head2 slice
+
+=head3 Arguments: ($first, $last)
Returns a subset of elements from the resultset.
return $new;
}
-=head2 result_source
+=head2 result_source
Returns a reference to the result source for this recordset.
my $group_by;
my $select = { 'count' => '*' };
if( $group_by = delete $self->{attrs}{group_by} ) {
- my @distinct = @$group_by;
+ my @distinct = (ref $group_by ? @$group_by : ($group_by));
# todo: try CONCAT for multi-column pk
my @pk = $self->result_source->primary_columns;
if( scalar(@pk) == 1 ) {
my $pk = shift(@pk);
my $alias = $self->{attrs}{alias};
my $re = qr/^($alias\.)?$pk$/;
- foreach my $column ( @$group_by ) {
+ foreach my $column ( @distinct) {
if( $column =~ $re ) {
@distinct = ( $column );
last;
return $_[0]->reset->next;
}
-=head2 update(\%values)
+=head2 update
+
+=head3 Arguments: (\%values)
Sets the specified columns in the resultset to the supplied values.
$self->result_source->from, $values, $self->{cond});
}
-=head2 update_all(\%values)
+=head2 update_all
+
+=head3 Arguments: (\%values)
Fetches all objects and updates them one at a time. Note that C<update_all>
will run cascade triggers while L</update> will not.
$self->{count}, $attrs->{rows}, $self->{page});
}
-=head2 page($page_num)
+=head2 page
+
+=head3 Arguments: ($page_num)
Returns a new resultset for the specified page.
return (ref $self)->new($self->result_source, $attrs);
}
-=head2 new_result(\%vals)
+=head2 new_result
+
+=head3 Arguments: (\%vals)
Creates a result in the resultset's result class.
$obj;
}
-=head2 create(\%vals)
+=head2 create
+
+=head3 Arguments: (\%vals)
Inserts a record into the resultset and returns the object.
return $self->new_result($attrs)->insert;
}
-=head2 find_or_create(\%vals, \%attrs?)
+=head2 find_or_create
+
+=head3 Arguments: (\%vals, \%attrs?)
$class->find_or_create({ key => $val, ... });
-Searches for a record matching the search condition; if it doesn't find one,
-creates one and returns that instead.
+Searches for a record matching the search condition; if it doesn't find one,
+creates one and returns that instead.
my $cd = $schema->resultset('CD')->find_or_create({
cdid => 5,
Which column(s) to order the results by. This is currently passed through
directly to SQL, so you can give e.g. C<foo DESC> for a descending order.
-=head2 cols (arrayref)
+=head2 cols
+
+=head3 Arguments: (arrayref)
Shortcut to request a particular set of columns to be retrieved. Adds
C<me.> onto the start of any column without a C<.> in it and sets C<select>
from that, then auto-populates C<as> from C<select> as normal.
-=head2 include_columns (arrayref)
+=head2 include_columns
+
+=head3 Arguments: (arrayref)
Shortcut to include additional columns in the returned results - for example
would add a 'name' column to the information passed to object inflation
-=head2 select (arrayref)
+=head2 select
+
+=head3 Arguments: (arrayref)
Indicates which columns should be selected from the storage. You can use
column names, or in the case of RDBMS back ends, function or stored procedure
attribute, the column names returned are storage-dependent. E.g. MySQL would
return a column named C<count(column_to_count)> in the above example.
-=head2 as (arrayref)
+=head2 as
+
+=head3 Arguments: (arrayref)
Indicates column names for object inflation. This is used in conjunction with
C<select>, usually when C<select> contains one or more function or stored
If you want to fetch related objects from other tables as well, see C<prefetch>
below.
-=head2 prefetch arrayref/hashref
+=head2 prefetch
+
+=head3 Arguments: arrayref/hashref
Contains one or more relationships that should be fetched along with the main
query (when they are accessed afterwards they will have already been
C<has_one> (or if you're using C<add_relationship>, any relationship declared
with an accessor type of 'single' or 'filter').
-=head2 from (arrayref)
+=head2 from
+
+=head3 Arguments: (arrayref)
The C<from> attribute gives you manual control over the C<FROM> clause of SQL
statements generated by L<DBIx::Class>, allowing you to express custom C<JOIN>
]
],
{ 'mother.person_id' => 'child.mother_id' }
- ],
+ ],
]
},
);
Can also be used to simulate an SQL C<LIMIT>.
-=head2 group_by (arrayref)
+=head2 group_by
+
+=head3 Arguments: (arrayref)
A arrayref of columns to group by. Can include columns of joined tables.
projects / dbsrgits/DBIx-Class.git / blobdiff