lib/DBIx/Class/ResultSetColumn.pm

   1 package DBIx::Class::ResultSetColumn;
   2
   3 use strict;
   4 use warnings;
   5
   6 use base 'DBIx::Class';
   7 use DBIx::Class::Carp;
   8 use DBIx::Class::_Util qw( fail_on_internal_wantarray fail_on_internal_call );
   9 use namespace::clean;
  10
  11 =head1 NAME
  12
  13   DBIx::Class::ResultSetColumn - helpful methods for messing
  14   with a single column of the resultset
  15
  16 =head1 SYNOPSIS
  17
  18   $rs = $schema->resultset('CD')->search({ artist => 'Tool' });
  19   $rs_column = $rs->get_column('year');
  20   $max_year = $rs_column->max; #returns latest year
  21
  22 =head1 DESCRIPTION
  23
  24 A convenience class used to perform operations on a specific column of
  25 a resultset.
  26
  27 =cut
  28
  29 =head1 METHODS
  30
  31 =head2 new
  32
  33   my $obj = DBIx::Class::ResultSetColumn->new($rs, $column);
  34
  35 Creates a new resultset column object from the resultset and column
  36 passed as params. Used internally by L<DBIx::Class::ResultSet/get_column>.
  37
  38 =cut
  39
  40 sub new {
  41   my ($class, $rs, $column) = @_;
  42   $class = ref $class if ref $class;
  43
  44   $rs->throw_exception('column must be supplied') unless $column;
  45
  46   my $orig_attrs = $rs->_resolved_attrs;
  47   my $alias = $rs->current_source_alias;
  48   my $rsrc = $rs->result_source;
  49
  50   # If $column can be found in the 'as' list of the parent resultset, use the
  51   # corresponding element of its 'select' list (to keep any custom column
  52   # definition set up with 'select' or '+select' attrs), otherwise use $column
  53   # (to create a new column definition on-the-fly).
  54   my $as_list = $orig_attrs->{as} || [];
  55   my $select_list = $orig_attrs->{select} || [];
  56   my ($as_index) = grep { ($as_list->[$_] || "") eq $column } 0..$#$as_list;
  57   my $select = defined $as_index ? $select_list->[$as_index] : $column;
  58
  59   my $colmap;
  60   for ($rsrc->columns, $column) {
  61     if ($_ =~ /^ \Q$alias\E \. ([^\.]+) $ /x) {
  62       $colmap->{$_} = $1;
  63     }
  64     elsif ($_ !~ /\./) {
  65       $colmap->{"$alias.$_"} = $_;
  66       $colmap->{$_} = $_;
  67     }
  68   }
  69
  70   my $new_parent_rs;
  71   # analyze the order_by, and see if it is done over a function/nonexistentcolumn
  72   # if this is the case we will need to wrap a subquery since the result of RSC
  73   # *must* be a single column select
  74   if (
  75     scalar grep
  76       { ! exists $colmap->{$_->[0]} }
  77       ( $rsrc->schema->storage->_extract_order_criteria ($orig_attrs->{order_by} ) )
  78   ) {
  79     # nuke the prefetch before collapsing to sql
  80     my $subq_rs = $rs->search_rs;
  81     $subq_rs->{attrs}{join} = $subq_rs->_merge_joinpref_attr( $subq_rs->{attrs}{join}, delete $subq_rs->{attrs}{prefetch} );
  82     $new_parent_rs = $subq_rs->as_subselect_rs;
  83   }
  84
  85   $new_parent_rs ||= $rs->search_rs;
  86   my $new_attrs = $new_parent_rs->{attrs} ||= {};
  87
  88   # prefetch causes additional columns to be fetched, but we can not just make a new
  89   # rs via the _resolved_attrs trick - we need to retain the separation between
  90   # +select/+as and select/as. At the same time we want to preserve any joins that the
  91   # prefetch would otherwise generate.
  92   $new_attrs->{join} = $rs->_merge_joinpref_attr( $new_attrs->{join}, delete $new_attrs->{prefetch} );
  93
  94   # {collapse} would mean a has_many join was injected, which in turn means
  95   # we need to group *IF WE CAN* (only if the column in question is unique)
  96   if (!$orig_attrs->{group_by} && $orig_attrs->{collapse}) {
  97
  98     if ($colmap->{$select} and $rsrc->_identifying_column_set([$colmap->{$select}])) {
  99       $new_attrs->{group_by} = [ $select ];
 100       delete @{$new_attrs}{qw(distinct _grouped_by_distinct)}; # it is ignored when group_by is present
 101     }
 102     else {
 103       carp (
 104           "Attempting to retrieve non-unique column '$column' on a resultset containing "
 105         . 'one-to-many joins will return duplicate results.'
 106       );
 107     }
 108   }
 109
 110   return bless {
 111     _select => $select,
 112     _as => $column,
 113     _parent_resultset => $new_parent_rs
 114   }, $class;
 115 }
 116
 117 =head2 as_query
 118
 119 =over 4
 120
 121 =item Arguments: none
 122
 123 =item Return Value: \[ $sql, L<@bind_values|DBIx::Class::ResultSet/DBIC BIND VALUES> ]
 124
 125 =back
 126
 127 Returns the SQL query and bind vars associated with the invocant.
 128
 129 This is generally used as the RHS for a subquery.
 130
 131 =cut
 132
 133 sub as_query { return shift->_resultset->as_query(@_) }
 134
 135 =head2 next
 136
 137 =over 4
 138
 139 =item Arguments: none
 140
 141 =item Return Value: $value
 142
 143 =back
 144
 145 Returns the next value of the column in the resultset (or C<undef> if
 146 there is none).
 147
 148 Much like L<DBIx::Class::ResultSet/next> but just returning the
 149 one value.
 150
 151 =cut
 152
 153 sub next {
 154   my $self = shift;
 155
 156   # using cursor so we don't inflate anything
 157   my ($row) = $self->_resultset->cursor->next;
 158
 159   return $row;
 160 }
 161
 162 =head2 all
 163
 164 =over 4
 165
 166 =item Arguments: none
 167
 168 =item Return Value: @values
 169
 170 =back
 171
 172 Returns all values of the column in the resultset (or C<undef> if
 173 there are none).
 174
 175 Much like L<DBIx::Class::ResultSet/all> but returns values rather
 176 than result objects.
 177
 178 =cut
 179
 180 sub all {
 181   my $self = shift;
 182
 183   # using cursor so we don't inflate anything
 184   return map { $_->[0] } $self->_resultset->cursor->all;
 185 }
 186
 187 =head2 reset
 188
 189 =over 4
 190
 191 =item Arguments: none
 192
 193 =item Return Value: $self
 194
 195 =back
 196
 197 Resets the underlying resultset's cursor, so you can iterate through the
 198 elements of the column again.
 199
 200 Much like L<DBIx::Class::ResultSet/reset>.
 201
 202 =cut
 203
 204 sub reset {
 205   my $self = shift;
 206   $self->_resultset->cursor->reset;
 207   return $self;
 208 }
 209
 210 =head2 first
 211
 212 =over 4
 213
 214 =item Arguments: none
 215
 216 =item Return Value: $value
 217
 218 =back
 219
 220 Resets the underlying resultset and returns the next value of the column in the
 221 resultset (or C<undef> if there is none).
 222
 223 Much like L<DBIx::Class::ResultSet/first> but just returning the one value.
 224
 225 =cut
 226
 227 sub first {
 228   my $self = shift;
 229
 230   # using cursor so we don't inflate anything
 231   $self->_resultset->cursor->reset;
 232   my ($row) = $self->_resultset->cursor->next;
 233
 234   return $row;
 235 }
 236
 237 =head2 single
 238
 239 =over 4
 240
 241 =item Arguments: none
 242
 243 =item Return Value: $value
 244
 245 =back
 246
 247 Much like L<DBIx::Class::ResultSet/single> fetches one and only one column
 248 value using the cursor directly. If additional rows are present a warning
 249 is issued before discarding the cursor.
 250
 251 =cut
 252
 253 sub single {
 254   my $self = shift;
 255
 256   my $attrs = $self->_resultset->_resolved_attrs;
 257   my ($row) = $self->_resultset->result_source->schema->storage->select_single(
 258     $attrs->{from}, $attrs->{select}, $attrs->{where}, $attrs
 259   );
 260
 261   return $row;
 262 }
 263
 264 =head2 min
 265
 266 =over 4
 267
 268 =item Arguments: none
 269
 270 =item Return Value: $lowest_value
 271
 272 =back
 273
 274   my $first_year = $year_col->min();
 275
 276 Wrapper for ->func. Returns the lowest value of the column in the
 277 resultset (or C<undef> if there are none).
 278
 279 =cut
 280
 281 sub min {
 282   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 283   $_[0]->func('MIN');
 284 }
 285
 286 =head2 min_rs
 287
 288 =over 4
 289
 290 =item Arguments: none
 291
 292 =item Return Value: L<$resultset|DBIx::Class::ResultSet>
 293
 294 =back
 295
 296   my $rs = $year_col->min_rs();
 297
 298 Wrapper for ->func_rs for function MIN().
 299
 300 =cut
 301
 302 sub min_rs {
 303   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 304   $_[0]->func_rs('MIN')
 305 }
 306
 307 =head2 max
 308
 309 =over 4
 310
 311 =item Arguments: none
 312
 313 =item Return Value: $highest_value
 314
 315 =back
 316
 317   my $last_year = $year_col->max();
 318
 319 Wrapper for ->func. Returns the highest value of the column in the
 320 resultset (or C<undef> if there are none).
 321
 322 =cut
 323
 324 sub max {
 325   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 326   $_[0]->func('MAX');
 327 }
 328
 329 =head2 max_rs
 330
 331 =over 4
 332
 333 =item Arguments: none
 334
 335 =item Return Value: L<$resultset|DBIx::Class::ResultSet>
 336
 337 =back
 338
 339   my $rs = $year_col->max_rs();
 340
 341 Wrapper for ->func_rs for function MAX().
 342
 343 =cut
 344
 345 sub max_rs {
 346   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 347   $_[0]->func_rs('MAX')
 348 }
 349
 350 =head2 sum
 351
 352 =over 4
 353
 354 =item Arguments: none
 355
 356 =item Return Value: $sum_of_values
 357
 358 =back
 359
 360   my $total = $prices_col->sum();
 361
 362 Wrapper for ->func. Returns the sum of all the values in the column of
 363 the resultset. Use on varchar-like columns at your own risk.
 364
 365 =cut
 366
 367 sub sum {
 368   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 369   $_[0]->func('SUM');
 370 }
 371
 372 =head2 sum_rs
 373
 374 =over 4
 375
 376 =item Arguments: none
 377
 378 =item Return Value: L<$resultset|DBIx::Class::ResultSet>
 379
 380 =back
 381
 382   my $rs = $year_col->sum_rs();
 383
 384 Wrapper for ->func_rs for function SUM().
 385
 386 =cut
 387
 388 sub sum_rs {
 389   DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_INDIRECT_CALLS and fail_on_internal_call;
 390   $_[0]->func_rs('SUM')
 391 }
 392
 393 =head2 func
 394
 395 =over 4
 396
 397 =item Arguments: $function
 398
 399 =item Return Value: $function_return_value
 400
 401 =back
 402
 403   $rs = $schema->resultset("CD")->search({});
 404   $length = $rs->get_column('title')->func('LENGTH');
 405
 406 Runs a query using the function on the column and returns the
 407 value. Produces the following SQL:
 408
 409   SELECT LENGTH( title ) FROM cd me
 410
 411 =cut
 412
 413 sub func {
 414   my ($self,$function) = @_;
 415   my $cursor = $self->func_rs($function)->cursor;
 416
 417   if( wantarray ) {
 418     DBIx::Class::_ENV_::ASSERT_NO_INTERNAL_WANTARRAY and my $sog = fail_on_internal_wantarray;
 419     return map { $_->[ 0 ] } $cursor->all;
 420   }
 421
 422   return ( $cursor->next )[ 0 ];
 423 }
 424
 425 =head2 func_rs
 426
 427 =over 4
 428
 429 =item Arguments: $function
 430
 431 =item Return Value: L<$resultset|DBIx::Class::ResultSet>
 432
 433 =back
 434
 435 Creates the resultset that C<func()> uses to run its query.
 436
 437 =cut
 438
 439 sub func_rs {
 440   my ($self,$function) = @_;
 441
 442   my $rs = $self->{_parent_resultset};
 443   my $select = $self->{_select};
 444
 445   # wrap a grouped rs
 446   if ($rs->_resolved_attrs->{group_by}) {
 447     $select = $self->{_as};
 448     $rs = $rs->as_subselect_rs;
 449   }
 450
 451   $rs->search( undef, {
 452     columns => { $self->{_as} => { $function => $select } }
 453   } );
 454 }
 455
 456 =head2 throw_exception
 457
 458 See L<DBIx::Class::Schema/throw_exception> for details.
 459
 460 =cut
 461
 462 sub throw_exception {
 463   my $self = shift;
 464
 465   if (ref $self && $self->{_parent_resultset}) {
 466     $self->{_parent_resultset}->throw_exception(@_);
 467   }
 468   else {
 469     DBIx::Class::Exception->throw(@_);
 470   }
 471 }
 472
 473 # _resultset
 474 #
 475 # Arguments: none
 476 #
 477 # Return Value: $resultset
 478 #
 479 #  $year_col->_resultset->next
 480 #
 481 # Returns the underlying resultset. Creates it from the parent resultset if
 482 # necessary.
 483 #
 484 sub _resultset {
 485   my $self = shift;
 486
 487   return $self->{_resultset} ||= do {
 488
 489     my $select = $self->{_select};
 490
 491     if ($self->{_parent_resultset}{attrs}{distinct}) {
 492       my $alias = $self->{_parent_resultset}->current_source_alias;
 493       my $rsrc = $self->{_parent_resultset}->result_source;
 494       my %cols = map { $_ => 1, "$alias.$_" => 1 } $rsrc->columns;
 495
 496       unless( $cols{$select} ) {
 497         carp_unique(
 498           'Use of distinct => 1 while selecting anything other than a column '
 499         . 'declared on the primary ResultSource is deprecated (you selected '
 500         . "'$self->{_as}') - please supply an explicit group_by instead"
 501         );
 502
 503         # collapse the selector to a literal so that it survives the distinct parse
 504         # if it turns out to be an aggregate - at least the user will get a proper exception
 505         # instead of silent drop of the group_by altogether
 506         $select = \[ $rsrc->schema->storage->sql_maker->_recurse_fields($select) ];
 507       }
 508     }
 509
 510     $self->{_parent_resultset}->search(undef, {
 511       columns => { $self->{_as} => $select }
 512     });
 513   };
 514 }
 515
 516 =head1 FURTHER QUESTIONS?
 517
 518 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
 519
 520 =head1 COPYRIGHT AND LICENSE
 521
 522 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
 523 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
 524 redistribute it and/or modify it under the same terms as the
 525 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
 526
 527 =cut
 528
 529 1;
 530