=head1 SYNOPSIS
- my $users_rs = $schema->resultset('User');
+ my $users_rs = $schema->resultset('User');
while( $user = $users_rs->next) {
print $user->username;
}
- my $registered_users_rs = $schema->resultset('User')->search({ registered => 1 });
+ my $registered_users_rs = $schema->resultset('User')->search({ registered => 1 });
my @cds_in_2005 = $schema->resultset('CD')->search({ year => 2005 })->all();
=head1 DESCRIPTION
you want to check if a resultset has any results, you must use C<if $rs
!= 0>.
+=head1 CUSTOM ResultSet CLASSES THAT USE Moose
+
+If you want to make your custom ResultSet classes with L<Moose>, use a template
+similar to:
+
+ package MyApp::Schema::ResultSet::User;
+
+ use Moose;
+ use namespace::autoclean;
+ use MooseX::NonMoose;
+ extends 'DBIx::Class::ResultSet';
+
+ sub BUILDARGS { $_[2] }
+
+ ...your code...
+
+ __PACKAGE__->meta->make_immutable;
+
+ 1;
+
+The L<MooseX::NonMoose> is necessary so that the L<Moose> constructor does not
+clash with the regular ResultSet constructor. Alternatively, you can use:
+
+ __PACKAGE__->meta->make_immutable(inline_constructor => 0);
+
+The L<BUILDARGS|Moose::Manual::Construction/BUILDARGS> is necessary because the
+signature of the ResultSet C<new> is C<< ->new($source, \%args) >>.
+
=head1 EXAMPLES
=head2 Chaining resultsets
=over 4
-=item Arguments: $source, \%$attrs
+=item Arguments: L<$source|DBIx::Class::ResultSource>, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $rs
+=item Return Value: L<$resultset|/search>
=back
L</ATTRIBUTES> below). Does not perform any queries -- these are
executed as needed by the other methods.
-Generally you won't need to construct a resultset manually. You'll
-automatically get one from e.g. a L</search> called in scalar context:
+Generally you never construct a resultset manually. Instead you get one
+from e.g. a
+C<< $schema->L<resultset|DBIx::Class::Schema/resultset>('$source_name') >>
+or C<< $another_resultset->L<search|/search>(...) >> (the later called in
+scalar context):
my $rs = $schema->resultset('CD')->search({ title => '100th Window' });
-IMPORTANT: If called on an object, proxies to new_result instead so
+=over
+
+=item WARNING
+
+If called on an object, proxies to L</new_result> instead, so
my $cd = $schema->resultset('CD')->new({ title => 'Spoon' });
-will return a CD object, not a ResultSet.
+will return a CD object, not a ResultSet, and is equivalent to:
+
+ my $cd = $schema->resultset('CD')->new_result({ title => 'Spoon' });
+
+Please also keep in mind that many internals call L</new_result> directly,
+so overloading this method with the idea of intercepting new result object
+creation B<will not work>. See also warning pertaining to L</create>.
+
+=back
=cut
=over 4
-=item Arguments: $cond, \%attrs?
+=item Arguments: L<$cond|DBIx::Class::SQLMaker> | undef, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $resultset (scalar context) || @row_objs (list context)
+=item Return Value: $resultset (scalar context) | L<@result_objs|DBIx::Class::Manual::ResultClass> (list context)
=back
# year = 2005 OR year = 2004
In list context, C<< ->all() >> is called implicitly on the resultset, thus
-returning a list of row objects instead. To avoid that, use L</search_rs>.
+returning a list of L<result|DBIx::Class::Manual::ResultClass> objects instead.
+To avoid that, use L</search_rs>.
If you need to pass in additional attributes but no additional condition,
call it as C<search(undef, \%attrs)>.
Note that L</search> does not process/deflate any of the values passed in the
L<SQL::Abstract>-compatible search condition structure. This is unlike other
-condition-bound methods L</new>, L</create> and L</find>. The user must ensure
+condition-bound methods L</new_result>, L</create> and L</find>. The user must ensure
manually that any value passed to this method will stringify to something the
RDBMS knows how to deal with. A notable example is the handling of L<DateTime>
objects, for more info see:
-L<DBIx::Class::Manual::Cookbook/Formatting_DateTime_objects_in_queries>.
+L<DBIx::Class::Manual::Cookbook/Formatting DateTime objects in queries>.
=cut
=over 4
-=item Arguments: $cond, \%attrs?
+=item Arguments: L<$cond|DBIx::Class::SQLMaker>, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $resultset
+=item Return Value: L<$resultset|/search>
=back
$attrs->{'+columns'} = $self->_merge_attr($attrs->{'+columns'}, delete $attrs->{include_columns})
if exists $attrs->{include_columns};
- # columns are always placed first, however
+ # columns are always placed first, however
# Keep the X vs +X separation until _resolved_attrs time - this allows to
# delay the decision on whether to use a default select list ($rsrc->columns)
=head2 search_literal
+B<CAVEAT>: C<search_literal> is provided for Class::DBI compatibility and
+should only be used in that context. C<search_literal> is a convenience
+method. It is equivalent to calling C<< $schema->search(\[]) >>, but if you
+want to ensure columns are bound correctly, use L</search>.
+
+See L<DBIx::Class::Manual::Cookbook/Searching> and
+L<DBIx::Class::Manual::FAQ/Searching> for searching techniques that do not
+require C<search_literal>.
+
=over 4
-=item Arguments: $sql_fragment, @bind_values
+=item Arguments: $sql_fragment, @standalone_bind_values
-=item Return Value: $resultset (scalar context) || @row_objs (list context)
+=item Return Value: L<$resultset|/search> (scalar context) | L<@result_objs|DBIx::Class::Manual::ResultClass> (list context)
=back
Pass a literal chunk of SQL to be added to the conditional part of the
resultset query.
-CAVEAT: C<search_literal> is provided for Class::DBI compatibility and should
-only be used in that context. C<search_literal> is a convenience method.
-It is equivalent to calling $schema->search(\[]), but if you want to ensure
-columns are bound correctly, use C<search>.
-
Example of how to use C<search> instead of C<search_literal>
my @cds = $cd_rs->search_literal('cdid = ? AND (artist = ? OR artist = ?)', (2, 1, 2));
my @cds = $cd_rs->search(\[ 'cdid = ? AND (artist = ? OR artist = ?)', [ 'cdid', 2 ], [ 'artist', 1 ], [ 'artist', 2 ] ]);
-
-See L<DBIx::Class::Manual::Cookbook/Searching> and
-L<DBIx::Class::Manual::FAQ/Searching> for searching techniques that do not
-require C<search_literal>.
-
=cut
sub search_literal {
if ( @bind && ref($bind[-1]) eq 'HASH' ) {
$attr = pop @bind;
}
- return $self->search(\[ $sql, map [ __DUMMY__ => $_ ], @bind ], ($attr || () ));
+ return $self->search(\[ $sql, map [ {} => $_ ], @bind ], ($attr || () ));
}
=head2 find
=over 4
-=item Arguments: \%columns_values | @pk_values, \%attrs?
+=item Arguments: \%columns_values | @pk_values, { key => $unique_constraint, L<%attrs|/ATTRIBUTES> }?
-=item Return Value: $row_object | undef
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass> | undef
=back
you need to search with arbitrary conditions - use L</search>. If the query
resulting from this fallback produces more than one row, a warning to the
effect is issued, though only the first row is constructed and returned as
-C<$row_object>.
+C<$result_object>.
In addition to C<key>, L</find> recognizes and applies standard
L<resultset attributes|/ATTRIBUTES> in the same way as L</search> does.
my $rsrc = $self->result_source;
+ my $constraint_name;
+ if (exists $attrs->{key}) {
+ $constraint_name = defined $attrs->{key}
+ ? $attrs->{key}
+ : $self->throw_exception("An undefined 'key' resultset attribute makes no sense")
+ ;
+ }
+
# Parse out the condition from input
my $call_cond;
+
if (ref $_[0] eq 'HASH') {
$call_cond = { %{$_[0]} };
}
else {
- my $constraint = exists $attrs->{key} ? $attrs->{key} : 'primary';
- my @c_cols = $rsrc->unique_constraint_columns($constraint);
+ # if only values are supplied we need to default to 'primary'
+ $constraint_name = 'primary' unless defined $constraint_name;
+
+ my @c_cols = $rsrc->unique_constraint_columns($constraint_name);
$self->throw_exception(
- "No constraint columns, maybe a malformed '$constraint' constraint?"
+ "No constraint columns, maybe a malformed '$constraint_name' constraint?"
) unless @c_cols;
$self->throw_exception (
'find() expects either a column/value hashref, or a list of values '
- . "corresponding to the columns of the specified unique constraint '$constraint'"
+ . "corresponding to the columns of the specified unique constraint '$constraint_name'"
) unless @c_cols == @_;
$call_cond = {};
my $alias = exists $attrs->{alias} ? $attrs->{alias} : $self->{attrs}{alias};
my $final_cond;
- if (exists $attrs->{key}) {
+ if (defined $constraint_name) {
$final_cond = $self->_qualify_cond_columns (
$self->_build_unique_cond (
- $attrs->{key},
+ $constraint_name,
$call_cond,
),
and
!$ENV{DBIC_NULLABLE_KEY_NOWARN}
and
- my @undefs = grep { ! defined $final_cond->{$_} } (keys %$final_cond)
+ my @undefs = sort grep { ! defined $final_cond->{$_} } (keys %$final_cond)
) {
carp_unique ( sprintf (
"NULL/undef values supplied for requested unique constraint '%s' (NULL "
=over 4
-=item Arguments: $rel, $cond, \%attrs?
+=item Arguments: $rel_name, $cond?, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $new_resultset (scalar context) || @row_objs (list context)
+=item Return Value: L<$resultset|/search> (scalar context) | L<@result_objs|DBIx::Class::Manual::ResultClass> (list context)
=back
attributes for matching records. See L</ATTRIBUTES> for more information.
In list context, C<< ->all() >> is called implicitly on the resultset, thus
-returning a list of row objects instead. To avoid that, use L</search_related_rs>.
+returning a list of result objects instead. To avoid that, use L</search_related_rs>.
See also L</search_related_rs>.
=item Arguments: none
-=item Return Value: $cursor
+=item Return Value: L<$cursor|DBIx::Class::Cursor>
=back
=over 4
-=item Arguments: $cond?
+=item Arguments: L<$cond?|DBIx::Class::SQLMaker>
-=item Return Value: $row_object | undef
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass> | undef
=back
=over 4
-=item Arguments: $cond?
+=item Arguments: L<$cond?|DBIx::Class::SQLMaker>
-=item Return Value: $resultsetcolumn
+=item Return Value: L<$resultsetcolumn|DBIx::Class::ResultSetColumn>
=back
=over 4
-=item Arguments: $cond, \%attrs?
+=item Arguments: L<$cond|DBIx::Class::SQLMaker>, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $resultset (scalar context) || @row_objs (list context)
+=item Return Value: L<$resultset|/search> (scalar context) | L<@result_objs|DBIx::Class::Manual::ResultClass> (list context)
=back
=item Arguments: $first, $last
-=item Return Value: $resultset (scalar context) || @row_objs (list context)
+=item Return Value: L<$resultset|/search> (scalar context) | L<@result_objs|DBIx::Class::Manual::ResultClass> (list context)
=back
=item Arguments: none
-=item Return Value: $result | undef
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass> | undef
=back
=over 4
-=item Arguments: $result_source?
+=item Arguments: L<$result_source?|DBIx::Class::ResultSource>
-=item Return Value: $result_source
+=item Return Value: L<$result_source|DBIx::Class::ResultSource>
=back
=back
-An accessor for the class to use when creating row objects. Defaults to
+An accessor for the class to use when creating result objects. Defaults to
C<< result_source->result_class >> - which in most cases is the name of the
L<"table"|DBIx::Class::Manual::Glossary/"ResultSource"> class.
=over 4
-=item Arguments: $cond, \%attrs??
+=item Arguments: L<$cond|DBIx::Class::SQLMaker>, L<\%attrs?|/ATTRIBUTES>
=item Return Value: $count
=over 4
-=item Arguments: $cond, \%attrs??
+=item Arguments: L<$cond|DBIx::Class::SQLMaker>, L<\%attrs?|/ATTRIBUTES>
-=item Return Value: $count_rs
+=item Return Value: L<$count_rs|DBIx::Class::ResultSetColumn>
=back
# extra selectors do not go in the subquery and there is no point of ordering it, nor locking it
delete @{$sub_attrs}{qw/collapse columns as select _prefetch_selector_range order_by for/};
- # if we multi-prefetch we group_by primary keys only as this is what we would
+ # if we multi-prefetch we group_by something unique, as this is what we would
# get out of the rs via ->next/->all. We *DO WANT* to clobber old group_by regardless
if ( keys %{$attrs->{collapse}} ) {
- $sub_attrs->{group_by} = [ map { "$attrs->{alias}.$_" } ($rsrc->_pri_cols) ]
+ $sub_attrs->{group_by} = [ map { "$attrs->{alias}.$_" } @{
+ $rsrc->_identifying_column_set || $self->throw_exception(
+ 'Unable to construct a unique group_by criteria properly collapsing the '
+ . 'has_many prefetch before count()'
+ );
+ } ]
}
# Calculate subquery selector
=head2 count_literal
+B<CAVEAT>: C<count_literal> is provided for Class::DBI compatibility and
+should only be used in that context. See L</search_literal> for further info.
+
=over 4
-=item Arguments: $sql_fragment, @bind_values
+=item Arguments: $sql_fragment, @standalone_bind_values
=item Return Value: $count
=item Arguments: none
-=item Return Value: @objects
+=item Return Value: L<@result_objs|DBIx::Class::Manual::ResultClass>
=back
=item Arguments: none
-=item Return Value: $object | undef
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass> | undef
=back
-Resets the resultset and returns an object for the first result (or C<undef>
-if the resultset is empty).
+L<Resets|/reset> the resultset (causing a fresh query to storage) and returns
+an object for the first result (or C<undef> if the resultset is empty).
=cut
sub _rs_update_delete {
my ($self, $op, $values) = @_;
+ my $cond = $self->{cond};
my $rsrc = $self->result_source;
+ my $storage = $rsrc->schema->storage;
+
+ my $attrs = { %{$self->_resolved_attrs} };
+
+ my $existing_group_by = delete $attrs->{group_by};
+ my $needs_subq = defined $existing_group_by;
- my $needs_group_by_subq = $self->_has_resolved_attr (qw/collapse group_by -join/);
- my $needs_subq = $needs_group_by_subq || $self->_has_resolved_attr(qw/rows offset/);
+ # simplify the joinmap and maybe decide if a subquery is necessary
+ my $relation_classifications = {};
+
+ if (ref($attrs->{from}) eq 'ARRAY') {
+ # if we already know we need a subq, no point of classifying relations
+ if (!$needs_subq and @{$attrs->{from}} > 1) {
+ $attrs->{from} = $storage->_prune_unused_joins ($attrs->{from}, $attrs->{select}, $cond, $attrs);
+
+ $relation_classifications = $storage->_resolve_aliastypes_from_select_args (
+ [ @{$attrs->{from}}[1 .. $#{$attrs->{from}}] ],
+ $attrs->{select},
+ $cond,
+ $attrs
+ );
+ }
+ }
+ else {
+ $needs_subq ||= 1; # if {from} is unparseable assume the worst
+ }
- if ($needs_group_by_subq or $needs_subq) {
+ # do we need anything like a subquery?
+ if (
+ ! $needs_subq
+ and
+ ! keys %{ $relation_classifications->{restricting} || {} }
+ and
+ ! $self->_has_resolved_attr(qw/rows offset/) # limits call for a subq
+ ) {
+ # Most databases do not allow aliasing of tables in UPDATE/DELETE. Thus
+ # a condition containing 'me' or other table prefixes will not work
+ # at all. Tell SQLMaker to dequalify idents via a gross hack.
+ my $cond = do {
+ my $sqla = $rsrc->storage->sql_maker;
+ local $sqla->{_dequalify_idents} = 1;
+ \[ $sqla->_recurse_where($self->{cond}) ];
+ };
+ return $rsrc->storage->$op(
+ $rsrc,
+ $op eq 'update' ? $values : (),
+ $cond,
+ );
+ }
- # make a new $rs selecting only the PKs (that's all we really need)
- my $attrs = $self->_resolved_attrs_copy;
+ # we got this far - means it is time to wrap a subquery
+ my $idcols = $rsrc->_identifying_column_set || $self->throw_exception(
+ sprintf(
+ "Unable to perform complex resultset %s() without an identifying set of columns on source '%s'",
+ $op,
+ $rsrc->source_name,
+ )
+ );
+ # make a new $rs selecting only the PKs (that's all we really need for the subq)
+ delete $attrs->{$_} for qw/collapse _collapse_order_by select _prefetch_selector_range as/;
+ $attrs->{columns} = [ map { "$attrs->{alias}.$_" } @$idcols ];
+ $attrs->{group_by} = \ ''; # FIXME - this is an evil hack, it causes the optimiser to kick in and throw away the LEFT joins
+ my $subrs = (ref $self)->new($rsrc, $attrs);
- delete $attrs->{$_} for qw/collapse _collapse_order_by select _prefetch_selector_range as/;
- $attrs->{columns} = [ map { "$attrs->{alias}.$_" } ($self->result_source->_pri_cols) ];
+ if (@$idcols == 1) {
+ return $storage->$op (
+ $rsrc,
+ $op eq 'update' ? $values : (),
+ { $idcols->[0] => { -in => $subrs->as_query } },
+ );
+ }
+ elsif ($storage->_use_multicolumn_in) {
+ # This is hideously ugly, but SQLA does not understand multicol IN expressions
+ my $sql_maker = $storage->sql_maker;
+ my ($sql, @bind) = @${$subrs->as_query};
+ $sql = sprintf ('(%s) IN %s', # the as_query already comes with a set of parenthesis
+ join (', ', map { $sql_maker->_quote ($_) } @$idcols),
+ $sql,
+ );
- if ($needs_group_by_subq) {
- # make sure no group_by was supplied, or if there is one - make sure it matches
- # the columns compiled above perfectly. Anything else can not be sanely executed
- # on most databases so croak right then and there
+ return $storage->$op (
+ $rsrc,
+ $op eq 'update' ? $values : (),
+ \[$sql, @bind],
+ );
+ }
+ else {
- if (my $g = $attrs->{group_by}) {
+ # if all else fails - get all primary keys and operate over a ORed set
+ # wrap in a transaction for consistency
+ # this is where the group_by starts to matter
+ if (
+ $existing_group_by
+ or
+ keys %{ $relation_classifications->{multiplying} || {} }
+ ) {
+ # make sure if there is a supplied group_by it matches the columns compiled above
+ # perfectly. Anything else can not be sanely executed on most databases so croak
+ # right then and there
+ if ($existing_group_by) {
my @current_group_by = map
{ $_ =~ /\./ ? $_ : "$attrs->{alias}.$_" }
- @$g
+ @$existing_group_by
;
if (
);
}
}
- else {
- $attrs->{group_by} = $attrs->{columns};
- }
+
+ $subrs = $subrs->search({}, { group_by => $attrs->{columns} });
}
- my $subrs = (ref $self)->new($rsrc, $attrs);
- return $self->result_source->storage->_subq_update_delete($subrs, $op, $values);
- }
- else {
- # Most databases do not allow aliasing of tables in UPDATE/DELETE. Thus
- # a condition containing 'me' or other table prefixes will not work
- # at all. What this code tries to do (badly) is to generate a condition
- # with the qualifiers removed, by exploiting the quote mechanism of sqla
- #
- # this is atrocious and should be replaced by normal sqla introspection
- # one sunny day
- my ($sql, @bind) = do {
- my $sqla = $rsrc->storage->sql_maker;
- local $sqla->{_dequalify_idents} = 1;
- $sqla->_recurse_where($self->{cond});
- } if $self->{cond};
+ my $guard = $storage->txn_scope_guard;
- return $rsrc->storage->$op(
+ my @op_condition;
+ for my $row ($subrs->cursor->all) {
+ push @op_condition, { map
+ { $idcols->[$_] => $row->[$_] }
+ (0 .. $#$idcols)
+ };
+ }
+
+ my $res = $storage->$op (
$rsrc,
$op eq 'update' ? $values : (),
- $self->{cond} ? \[$sql, @bind] : (),
+ \@op_condition,
);
+
+ $guard->commit;
+
+ return $res;
}
}
=item Arguments: \%values
-=item Return Value: $storage_rv
+=item Return Value: $underlying_storage_rv
=back
Sets the specified columns in the resultset to the supplied values in a
single query. Note that this will not run any accessor/set_column/update
-triggers, nor will it update any row object instances derived from this
+triggers, nor will it update any result object instances derived from this
resultset (this includes the contents of the L<resultset cache|/set_cache>
if any). See L</update_all> if you need to execute any on-update
triggers or cascades defined either by you or a
-L<result component|DBIx::Class::Manual::Component/WHAT_IS_A_COMPONENT>.
+L<result component|DBIx::Class::Manual::Component/WHAT IS A COMPONENT>.
The return value is a pass through of what the underlying
storage backend returned, and may vary. See L<DBI/execute> for the most
ensure manually that any value passed to this method will stringify to
something the RDBMS knows how to deal with. A notable example is the
handling of L<DateTime> objects, for more info see:
-L<DBIx::Class::Manual::Cookbook/Formatting_DateTime_objects_in_queries>.
+L<DBIx::Class::Manual::Cookbook/Formatting DateTime objects in queries>.
=cut
=item Arguments: none
-=item Return Value: $storage_rv
+=item Return Value: $underlying_storage_rv
=back
Deletes the rows matching this resultset in a single query. Note that this
will not run any delete triggers, nor will it alter the
-L<in_storage|DBIx::Class::Row/in_storage> status of any row object instances
+L<in_storage|DBIx::Class::Row/in_storage> status of any result object instances
derived from this resultset (this includes the contents of the
L<resultset cache|/set_cache> if any). See L</delete_all> if you need to
execute any on-delete triggers or cascades defined either by you or a
-L<result component|DBIx::Class::Manual::Component/WHAT_IS_A_COMPONENT>.
+L<result component|DBIx::Class::Manual::Component/WHAT IS A COMPONENT>.
The return value is a pass through of what the underlying storage backend
returned, and may vary. See L<DBI/execute> for the most common case.
push(@created, $self->create($item));
}
return wantarray ? @created : \@created;
- }
+ }
else {
my $first = $data->[0];
=item Arguments: none
-=item Return Value: $pager
+=item Return Value: L<$pager|Data::Page>
=back
-Return Value a L<Data::Page> object for the current resultset. Only makes
+Returns a L<Data::Page> object for the current resultset. Only makes
sense for queries with a C<page> attribute.
To get the full count of entries for a paged resultset, call
=cut
-# make a wizard good for both a scalar and a hashref
-my $mk_lazy_count_wizard = sub {
- require Variable::Magic;
-
- my $stash = { total_rs => shift };
- my $slot = shift; # only used by the hashref magic
-
- my $magic = Variable::Magic::wizard (
- data => sub { $stash },
-
- (!$slot)
- ? (
- # the scalar magic
- get => sub {
- # set value lazily, and dispell for good
- ${$_[0]} = $_[1]{total_rs}->count;
- Variable::Magic::dispell (${$_[0]}, $_[1]{magic_selfref});
- return 1;
- },
- set => sub {
- # an explicit set implies dispell as well
- # the unless() is to work around "fun and giggles" below
- Variable::Magic::dispell (${$_[0]}, $_[1]{magic_selfref})
- unless (caller(2))[3] eq 'DBIx::Class::ResultSet::pager';
- return 1;
- },
- )
- : (
- # the uvar magic
- fetch => sub {
- if ($_[2] eq $slot and !$_[1]{inactive}) {
- my $cnt = $_[1]{total_rs}->count;
- $_[0]->{$slot} = $cnt;
-
- # attempting to dispell in a fetch handle (works in store), seems
- # to invariable segfault on 5.10, 5.12, 5.13 :(
- # so use an inactivator instead
- #Variable::Magic::dispell (%{$_[0]}, $_[1]{magic_selfref});
- $_[1]{inactive}++;
- }
- return 1;
- },
- store => sub {
- if (! $_[1]{inactive} and $_[2] eq $slot) {
- #Variable::Magic::dispell (%{$_[0]}, $_[1]{magic_selfref});
- $_[1]{inactive}++
- unless (caller(2))[3] eq 'DBIx::Class::ResultSet::pager';
- }
- return 1;
- },
- ),
- );
-
- $stash->{magic_selfref} = $magic;
- weaken ($stash->{magic_selfref}); # this fails on 5.8.1
-
- return $magic;
-};
-
-# the tie class for 5.8.1
-{
- package # hide from pause
- DBIx::Class::__DBIC_LAZY_RS_COUNT__;
- use base qw/Tie::Hash/;
-
- sub FIRSTKEY { my $dummy = scalar keys %{$_[0]{data}}; each %{$_[0]{data}} }
- sub NEXTKEY { each %{$_[0]{data}} }
- sub EXISTS { exists $_[0]{data}{$_[1]} }
- sub DELETE { delete $_[0]{data}{$_[1]} }
- sub CLEAR { %{$_[0]{data}} = () }
- sub SCALAR { scalar %{$_[0]{data}} }
-
- sub TIEHASH {
- $_[1]{data} = {%{$_[1]{selfref}}};
- %{$_[1]{selfref}} = ();
- Scalar::Util::weaken ($_[1]{selfref});
- return bless ($_[1], $_[0]);
- };
-
- sub FETCH {
- if ($_[1] eq $_[0]{slot}) {
- my $cnt = $_[0]{data}{$_[1]} = $_[0]{total_rs}->count;
- untie %{$_[0]{selfref}};
- %{$_[0]{selfref}} = %{$_[0]{data}};
- return $cnt;
- }
- else {
- $_[0]{data}{$_[1]};
- }
- }
-
- sub STORE {
- $_[0]{data}{$_[1]} = $_[2];
- if ($_[1] eq $_[0]{slot}) {
- untie %{$_[0]{selfref}};
- %{$_[0]{selfref}} = %{$_[0]{data}};
- }
- $_[2];
- }
-}
-
sub pager {
my ($self) = @_;
# with a subselect) to get the real total count
my $count_attrs = { %$attrs };
delete $count_attrs->{$_} for qw/rows offset page pager/;
- my $total_rs = (ref $self)->new($self->result_source, $count_attrs);
+ my $total_rs = (ref $self)->new($self->result_source, $count_attrs);
-### the following may seem awkward and dirty, but it's a thought-experiment
-### necessary for future development of DBIx::DS. Do *NOT* change this code
-### before talking to ribasushi/mst
-
- require Data::Page;
- my $pager = Data::Page->new(
- 0, #start with an empty set
+ require DBIx::Class::ResultSet::Pager;
+ return $self->{pager} = DBIx::Class::ResultSet::Pager->new(
+ sub { $total_rs->count }, #lazy-get the total
$attrs->{rows},
$self->{attrs}{page},
);
-
- my $data_slot = 'total_entries';
-
- # Since we are interested in a cached value (once it's set - it's set), every
- # technique will detach from the magic-host once the time comes to fire the
- # ->count (or in the segfaulting case of >= 5.10 it will deactivate itself)
-
- if ($] < 5.008003) {
- # 5.8.1 throws 'Modification of a read-only value attempted' when one tries
- # to weakref the magic container :(
- # tested on 5.8.1
- tie (%$pager, 'DBIx::Class::__DBIC_LAZY_RS_COUNT__',
- { slot => $data_slot, total_rs => $total_rs, selfref => $pager }
- );
- }
- elsif ($] < 5.010) {
- # We can use magic on the hash value slot. It's interesting that the magic is
- # attached to the hash-slot, and does *not* stop working once I do the dummy
- # assignments after the cast()
- # tested on 5.8.3 and 5.8.9
- my $magic = $mk_lazy_count_wizard->($total_rs);
- Variable::Magic::cast ( $pager->{$data_slot}, $magic );
-
- # this is for fun and giggles
- $pager->{$data_slot} = -1;
- $pager->{$data_slot} = 0;
-
- # this does not work for scalars, but works with
- # uvar magic below
- #my %vals = %$pager;
- #%$pager = ();
- #%{$pager} = %vals;
- }
- else {
- # And the uvar magic
- # works on 5.10.1, 5.12.1 and 5.13.4 in its current form,
- # however see the wizard maker for more notes
- my $magic = $mk_lazy_count_wizard->($total_rs, $data_slot);
- Variable::Magic::cast ( %$pager, $magic );
-
- # still works
- $pager->{$data_slot} = -1;
- $pager->{$data_slot} = 0;
-
- # this now works
- my %vals = %$pager;
- %$pager = ();
- %{$pager} = %vals;
- }
-
- return $self->{pager} = $pager;
}
=head2 page
=item Arguments: $page_number
-=item Return Value: $rs
+=item Return Value: L<$resultset|/search>
=back
=over 4
-=item Arguments: \%vals
+=item Arguments: \%col_data
-=item Return Value: $rowobject
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
-Creates a new row object in the resultset's result class and returns
+Creates a new result object in the resultset's result class and returns
it. The row is not inserted into the database at this point, call
L<DBIx::Class::Row/insert> to do that. Calling L<DBIx::Class::Row/in_storage>
-will tell you whether the row object has been inserted or not.
+will tell you whether the result object has been inserted or not.
Passes the hashref of input on to L<DBIx::Class::Row/new>.
sub new_result {
my ($self, $values) = @_;
- $self->throw_exception( "new_result needs a hash" )
+
+ $self->throw_exception( "new_result takes only one argument - a hashref of values" )
+ if @_ > 2;
+
+ $self->throw_exception( "new_result expects a hashref" )
unless (ref $values eq 'HASH');
my ($merged_cond, $cols_from_relations) = $self->_merge_with_rscond($values);
=item Arguments: none
-=item Return Value: \[ $sql, @bind ]
+=item Return Value: \[ $sql, L<@bind_values|/DBIC BIND VALUES> ]
=back
=over 4
-=item Arguments: \%vals, \%attrs?
+=item Arguments: \%col_data, { key => $unique_constraint, L<%attrs|/ATTRIBUTES> }?
-=item Return Value: $rowobject
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
=over 4
-=item Arguments: \%vals
+=item Arguments: \%col_data
-=item Return Value: a L<DBIx::Class::Row> $object
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
with an arbitrary depth and width, as long as the relationships actually
exists and the correct column data has been supplied.
-
Instead of hashrefs of plain related data (key/value pairs), you may
also pass new or inserted objects. New objects (not inserted yet, see
-L</new>), will be inserted into their appropriate tables.
+L</new_result>), will be inserted into their appropriate tables.
-Effectively a shortcut for C<< ->new_result(\%vals)->insert >>.
+Effectively a shortcut for C<< ->new_result(\%col_data)->insert >>.
Example of creating a new row.
When subclassing ResultSet never attempt to override this method. Since
it is a simple shortcut for C<< $self->new_result($attrs)->insert >>, a
lot of the internals simply never call it, so your override will be
-bypassed more often than not. Override either L<new|DBIx::Class::Row/new>
-or L<insert|DBIx::Class::Row/insert> depending on how early in the
-L</create> process you need to intervene.
+bypassed more often than not. Override either L<DBIx::Class::Row/new>
+or L<DBIx::Class::Row/insert> depending on how early in the
+L</create> process you need to intervene. See also warning pertaining to
+L</new>.
=back
=over 4
-=item Arguments: \%vals, \%attrs?
+=item Arguments: \%col_data, { key => $unique_constraint, L<%attrs|/ATTRIBUTES> }?
-=item Return Value: $rowobject
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
See also L</find> and L</update_or_create>. For information on how to declare
unique constraints, see L<DBIx::Class::ResultSource/add_unique_constraint>.
+If you need to know if an existing row was found or a new one created use
+L</find_or_new> and L<DBIx::Class::Row/in_storage> instead. Don't forget
+to call L<DBIx::Class::Row/insert> to save the newly created row to the
+database!
+
+ my $cd = $schema->resultset('CD')->find_or_new({
+ cdid => 5,
+ artist => 'Massive Attack',
+ title => 'Mezzanine',
+ year => 2005,
+ });
+
+ if( !$cd->in_storage ) {
+ # do some stuff
+ $cd->insert;
+ }
+
=cut
sub find_or_create {
=over 4
-=item Arguments: \%col_values, { key => $unique_constraint }?
+=item Arguments: \%col_data, { key => $unique_constraint, L<%attrs|/ATTRIBUTES> }?
-=item Return Value: $row_object
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
$resultset->update_or_create({ col => $val, ... });
Like L</find_or_create>, but if a row is found it is immediately updated via
-C<< $found_row->update (\%col_values) >>.
+C<< $found_row->update (\%col_data) >>.
Takes an optional C<key> attribute to search on a specific unique constraint.
See also L</find> and L</find_or_create>. For information on how to declare
unique constraints, see L<DBIx::Class::ResultSource/add_unique_constraint>.
+If you need to know if an existing row was updated or a new one created use
+L</update_or_new> and L<DBIx::Class::Row/in_storage> instead. Don't forget
+to call L<DBIx::Class::Row/insert> to save the newly created row to the
+database!
+
=cut
sub update_or_create {
=over 4
-=item Arguments: \%col_values, { key => $unique_constraint }?
+=item Arguments: \%col_data, { key => $unique_constraint, L<%attrs|/ATTRIBUTES> }?
-=item Return Value: $rowobject
+=item Return Value: L<$result|DBIx::Class::Manual::ResultClass>
=back
$resultset->update_or_new({ col => $val, ... });
Like L</find_or_new> but if a row is found it is immediately updated via
-C<< $found_row->update (\%col_values) >>.
+C<< $found_row->update (\%col_data) >>.
For example:
In normal usage, the value of such columns should NOT be included at
all in the call to C<update_or_new>, even when set to C<undef>.
-See also L</find>, L</find_or_create> and L</find_or_new>.
+See also L</find>, L</find_or_create> and L</find_or_new>.
=cut
=item Arguments: none
-=item Return Value: \@cache_objects | undef
+=item Return Value: L<\@result_objs|DBIx::Class::Manual::ResultClass> | undef
=back
=over 4
-=item Arguments: \@cache_objects
+=item Arguments: L<\@result_objs|DBIx::Class::Manual::ResultClass>
-=item Return Value: \@cache_objects
+=item Return Value: L<\@result_objs|DBIx::Class::Manual::ResultClass>
=back
Sets the contents of the cache for the resultset. Expects an arrayref
of objects of the same class as those produced by the resultset. Note that
-if the cache is set the resultset will return the cached objects rather
+if the cache is set, the resultset will return the cached objects rather
than re-querying the database even if the cache attr is not set.
The contents of the cache can also be populated by using the
=over 4
-=item Arguments: $relationship_name
+=item Arguments: $rel_name
-=item Return Value: $resultset
+=item Return Value: L<$resultset|/search>
=back
my $me = $self->current_source_alias;
- return $self->search(
+ return $self->search({
"$me.modified" => $user->id,
- );
+ });
}
=cut
=item Arguments: none
-=item Return Value: $resultset
+=item Return Value: L<$resultset|/search>
=back
if (my $cols = delete $attrs->{columns}) {
for my $c (ref $cols eq 'ARRAY' ? @$cols : $cols) {
if (ref $c eq 'HASH') {
- for my $as (keys %$c) {
+ for my $as (sort keys %$c) {
push @sel, $c->{$as};
push @as, $as;
}
$attrs->{_collapse_order_by} = \@$prefetch_ordering;
}
-
# if both page and offset are specified, produce a combined offset
# even though it doesn't make much sense, this is what pre 081xx has
# been doing
$position++;
}
my ($import_key) = ( ref $import_element eq 'HASH' ) ? keys %{$import_element} : ($import_element);
+ $import_key = '' if not defined $import_key;
if ($best_candidate->{score} == 0 || exists $seen_keys->{$import_key}) {
push( @{$orig}, $import_element );
# A cursor in progress can't be serialized (and would make little sense anyway)
delete $to_serialize->{cursor};
+ # nor is it sensical to store a not-yet-fired-count pager
+ if ($to_serialize->{pager} and ref $to_serialize->{pager}{total_entries} eq 'CODE') {
+ delete $to_serialize->{pager};
+ }
+
Storable::nfreeze($to_serialize);
}
C<\%attrs> argument. See L</search>, L</search_rs>, L</find>,
L</count>.
+Default attributes can be set on the result class using
+L<DBIx::Class::ResultSource/resultset_attributes>. (Please read
+the CAVEATS on that feature before using it!)
+
These are in no particular order:
=head2 order_by
If you want to fetch related objects from other tables as well, see C<prefetch>
below.
+ NOTE: An internal join-chain pruner will discard certain joins while
+ constructing the actual SQL query, as long as the joins in question do not
+ affect the retrieved result. This for example includes 1:1 left joins
+ that are not part of the restriction specification (WHERE/HAVING) nor are
+ a part of the query selection.
+
For more help on using joins with search, see L<DBIx::Class::Manual::Joining>.
=head2 prefetch
}
);
-In fact, C<DBIx::Class> will emit the following warning:
-
- Prefetching multiple has_many rels tracks and cd_to_producer at top
- level will explode the number of row objects retrievable via ->next
- or ->all. Use at your own risk.
-
The collapser currently can't identify duplicate tuples for multiple
L<has_many|DBIx::Class::Relationship/has_many> relationships and as a
result the second L<has_many|DBIx::Class::Relationship/has_many>
=back
+=head2 alias
+
+=over 4
+
+=item Value: $source_alias
+
+=back
+
+Sets the source alias for the query. Normally, this defaults to C<me>, but
+nested search queries (sub-SELECTs) might need specific aliases set to
+reference inner queries. For example:
+
+ my $q = $rs
+ ->related_resultset('CDs')
+ ->related_resultset('Tracks')
+ ->search({
+ 'track.id' => { -ident => 'none_search.id' },
+ })
+ ->as_query;
+
+ my $ids = $self->search({
+ -not_exists => $q,
+ }, {
+ alias => 'none_search',
+ group_by => 'none_search.id',
+ })->get_column('id')->as_query;
+
+ $self->search({ id => { -in => $ids } })
+
+This attribute is directly tied to L</current_source_alias>.
+
=head2 page
=over 4
Specifies the (zero-based) row number for the first row to be returned, or the
of the first row of the first page if paging is used.
+=head2 software_limit
+
+=over 4
+
+=item Value: (0 | 1)
+
+=back
+
+When combined with L</rows> and/or L</offset> the generated SQL will not
+include any limit dialect stanzas. Instead the entire result will be selected
+as if no limits were specified, and DBIC will perform the limit locally, by
+artificially advancing and finishing the resulting L</cursor>.
+
+This is the recommended way of performing resultset limiting when no sane RDBMS
+implementation is available (e.g.
+L<Sybase ASE|DBIx::Class::Storage::DBI::Sybase::ASE> using the
+L<Generic Sub Query|DBIx::Class::SQLMaker::LimitDialects/GenericSubQ> hack)
+
=head2 group_by
=over 4
Adds to the WHERE clause.
# only return rows WHERE deleted IS NULL for all searches
- __PACKAGE__->resultset_attributes({ where => { deleted => undef } }); )
+ __PACKAGE__->resultset_attributes({ where => { deleted => undef } });
Can be overridden by passing C<< { where => undef } >> as an attribute
to a resultset.
+For more complicated where clauses see L<SQL::Abstract/WHERE CLAUSES>.
+
=back
=head2 cache
=over 4
-=item Value: ( 'update' | 'shared' )
+=item Value: ( 'update' | 'shared' | \$scalar )
=back
Set to 'update' for a SELECT ... FOR UPDATE or 'shared' for a SELECT
-... FOR SHARED.
+... FOR SHARED. If \$scalar is passed, this is taken directly and embedded in the
+query.
+
+=head1 DBIC BIND VALUES
+
+Because DBIC may need more information to bind values than just the column name
+and value itself, it uses a special format for both passing and receiving bind
+values. Each bind value should be composed of an arrayref of
+C<< [ \%args => $val ] >>. The format of C<< \%args >> is currently:
+
+=over 4
+
+=item dbd_attrs
+
+If present (in any form), this is what is being passed directly to bind_param.
+Note that different DBD's expect different bind args. (e.g. DBD::SQLite takes
+a single numerical type, while DBD::Pg takes a hashref if bind options.)
+
+If this is specified, all other bind options described below are ignored.
+
+=item sqlt_datatype
+
+If present, this is used to infer the actual bind attribute by passing to
+C<< $resolved_storage->bind_attribute_by_data_type() >>. Defaults to the
+"data_type" from the L<add_columns column info|DBIx::Class::ResultSource/add_columns>.
+
+Note that the data type is somewhat freeform (hence the sqlt_ prefix);
+currently drivers are expected to "Do the Right Thing" when given a common
+datatype name. (Not ideal, but that's what we got at this point.)
+
+=item sqlt_size
+
+Currently used to correctly allocate buffers for bind_param_inout().
+Defaults to "size" from the L<add_columns column info|DBIx::Class::ResultSource/add_columns>,
+or to a sensible value based on the "data_type".
+
+=item dbic_colname
+
+Used to fill in missing sqlt_datatype and sqlt_size attributes (if they are
+explicitly specified they are never overriden). Also used by some weird DBDs,
+where the column name should be available at bind_param time (e.g. Oracle).
+
+=back
+
+For backwards compatibility and convenience, the following shortcuts are
+supported:
+
+ [ $name => $val ] === [ { dbic_colname => $name }, $val ]
+ [ \$dt => $val ] === [ { sqlt_datatype => $dt }, $val ]
+ [ undef, $val ] === [ {}, $val ]
+
+=head1 AUTHOR AND CONTRIBUTORS
+
+See L<AUTHOR|DBIx::Class/AUTHOR> and L<CONTRIBUTORS|DBIx::Class/CONTRIBUTORS> in DBIx::Class
+
+=head1 LICENSE
+
+You may distribute this code under the same terms as Perl itself.
=cut
projects / dbsrgits/DBIx-Class.git / blobdiff