t/prefetch/grouped.t

   1 use strict;
   2 use warnings;
   3
   4 use Test::More;
   5 use Test::Exception;
   6
   7 use lib qw(t/lib);
   8 use DBICTest;
   9 use DBIC::SqlMakerTest;
  10 use DBIx::Class::SQLMaker::LimitDialects;
  11
  12 my $ROWS = DBIx::Class::SQLMaker::LimitDialects->__rows_bindtype;
  13
  14 my $schema = DBICTest->init_schema();
  15 my $sdebug = $schema->storage->debug;
  16
  17 my $cd_rs = $schema->resultset('CD')->search (
  18   { 'tracks.cd' => { '!=', undef } },
  19   { prefetch => 'tracks' },
  20 );
  21
  22 # Database sanity check
  23 is($cd_rs->count, 5, 'CDs with tracks count');
  24 for ($cd_rs->all) {
  25   is ($_->tracks->count, 3, '3 tracks for CD' . $_->id );
  26 }
  27
  28 # Test a belongs_to prefetch of a has_many
  29 {
  30   my $track_rs = $schema->resultset ('Track')->search (
  31     { 'me.cd' => { -in => [ $cd_rs->get_column ('cdid')->all ] } },
  32     {
  33       select => [
  34         'me.cd',
  35         { count => 'me.trackid' },
  36       ],
  37       as => [qw/
  38         cd
  39         track_count
  40       /],
  41       group_by => [qw/me.cd/],
  42       prefetch => 'cd',
  43     },
  44   );
  45
  46   # this used to fuck up ->all, do not remove!
  47   ok ($track_rs->first, 'There is stuff in the rs');
  48
  49   is($track_rs->count, 5, 'Prefetched count with groupby');
  50   is($track_rs->all, 5, 'Prefetched objects with groupby');
  51
  52   {
  53     my $query_cnt = 0;
  54     $schema->storage->debugcb ( sub { $query_cnt++ } );
  55     $schema->storage->debug (1);
  56
  57     while (my $collapsed_track = $track_rs->next) {
  58       my $cdid = $collapsed_track->get_column('cd');
  59       is($collapsed_track->get_column('track_count'), 3, "Correct count of tracks for CD $cdid" );
  60       ok($collapsed_track->cd->title, "Prefetched title for CD $cdid" );
  61     }
  62
  63     is ($query_cnt, 1, 'Single query on prefetched titles');
  64     $schema->storage->debugcb (undef);
  65     $schema->storage->debug ($sdebug);
  66   }
  67
  68   # Test sql by hand, as the sqlite db will simply paper over
  69   # improper group/select combinations
  70   #
  71   is_same_sql_bind (
  72     $track_rs->count_rs->as_query,
  73     '(
  74       SELECT COUNT( * )
  75         FROM (
  76           SELECT me.cd
  77             FROM track me
  78             JOIN cd cd ON cd.cdid = me.cd
  79           WHERE ( me.cd IN ( ?, ?, ?, ?, ? ) )
  80           GROUP BY me.cd
  81         )
  82       me
  83     )',
  84     [ map { [ { sqlt_datatype => 'integer', dbic_colname => 'me.cd' }
  85       => $_ ] } ($cd_rs->get_column ('cdid')->all) ],
  86     'count() query generated expected SQL',
  87   );
  88
  89   is_same_sql_bind (
  90     $track_rs->as_query,
  91     '(
  92       SELECT me.cd, me.track_count, cd.cdid, cd.artist, cd.title, cd.year, cd.genreid, cd.single_track
  93         FROM (
  94           SELECT me.cd, COUNT (me.trackid) AS track_count
  95             FROM track me
  96             JOIN cd cd ON cd.cdid = me.cd
  97           WHERE ( me.cd IN ( ?, ?, ?, ?, ? ) )
  98           GROUP BY me.cd
  99           ) me
 100         JOIN cd cd ON cd.cdid = me.cd
 101       WHERE ( me.cd IN ( ?, ?, ?, ?, ? ) )
 102     )',
 103     [ map { [ { sqlt_datatype => 'integer', dbic_colname => 'me.cd' }
 104       => $_ ] } ( ($cd_rs->get_column ('cdid')->all) x 2 ) ],
 105     'next() query generated expected SQL',
 106   );
 107
 108
 109   # add an extra track to one of the cds, and then make sure we can get it on top
 110   # (check if limit works)
 111   my $top_cd = $cd_rs->slice (1,1)->next;
 112   $top_cd->create_related ('tracks', {
 113     title => 'over the top',
 114   });
 115
 116   my $top_cd_collapsed_track = $track_rs->search ({}, {
 117     rows => 2,
 118     order_by => [
 119       { -desc => 'track_count' },
 120     ],
 121   });
 122
 123   is ($top_cd_collapsed_track->count, 2);
 124
 125   is (
 126     $top_cd->title,
 127     $top_cd_collapsed_track->first->cd->title,
 128     'Correct collapsed track with prefetched CD returned on top'
 129   );
 130 }
 131
 132 # test a has_many/might_have prefetch at the same level
 133 # Note that one of the CDs now has 4 tracks instead of 3
 134 {
 135   my $most_tracks_rs = $schema->resultset ('CD')->search (
 136     {
 137       'me.cdid' => { '!=' => undef },  # duh - this is just to test WHERE
 138     },
 139     {
 140       prefetch => [qw/tracks liner_notes/],
 141       select => ['me.cdid', { count => 'tracks.trackid' }, { max => 'tracks.trackid', -as => 'maxtr'} ],
 142       as => [qw/cdid track_count max_track_id/],
 143       group_by => 'me.cdid',
 144       order_by => [ { -desc => 'track_count' }, { -asc => 'maxtr' } ],
 145       rows => 2,
 146     }
 147   );
 148
 149   is_same_sql_bind (
 150     $most_tracks_rs->count_rs->as_query,
 151     '(
 152       SELECT COUNT( * )
 153         FROM (
 154           SELECT me.cdid
 155             FROM cd me
 156           WHERE ( me.cdid IS NOT NULL )
 157           GROUP BY me.cdid
 158           LIMIT ?
 159         ) me
 160     )',
 161     [[$ROWS => 2]],
 162     'count() query generated expected SQL',
 163   );
 164
 165   is_same_sql_bind (
 166     $most_tracks_rs->as_query,
 167     '(
 168       SELECT  me.cdid, me.track_count, me.maxtr,
 169               tracks.trackid, tracks.cd, tracks.position, tracks.title, tracks.last_updated_on, tracks.last_updated_at,
 170               liner_notes.liner_id, liner_notes.notes
 171         FROM (
 172           SELECT me.cdid, COUNT( tracks.trackid ) AS track_count, MAX( tracks.trackid ) AS maxtr
 173             FROM cd me
 174             LEFT JOIN track tracks ON tracks.cd = me.cdid
 175           WHERE ( me.cdid IS NOT NULL )
 176           GROUP BY me.cdid
 177           ORDER BY track_count DESC, maxtr ASC
 178           LIMIT ?
 179         ) me
 180         LEFT JOIN track tracks ON tracks.cd = me.cdid
 181         LEFT JOIN liner_notes liner_notes ON liner_notes.liner_id = me.cdid
 182       WHERE ( me.cdid IS NOT NULL )
 183       ORDER BY track_count DESC, maxtr ASC, tracks.cd
 184     )',
 185     [[$ROWS => 2]],
 186     'next() query generated expected SQL',
 187   );
 188
 189   is ($most_tracks_rs->count, 2, 'Limit works');
 190   my $top_cd = $most_tracks_rs->first;
 191   is ($top_cd->id, 2, 'Correct cd fetched on top'); # 2 because of the slice(1,1) earlier
 192
 193   my $query_cnt = 0;
 194   $schema->storage->debugcb ( sub { $query_cnt++ } );
 195   $schema->storage->debug (1);
 196
 197   is ($top_cd->get_column ('track_count'), 4, 'Track count fetched correctly');
 198   is ($top_cd->tracks->count, 4, 'Count of prefetched tracks rs still correct');
 199   is ($top_cd->tracks->all, 4, 'Number of prefetched track objects still correct');
 200   is (
 201     $top_cd->liner_notes->notes,
 202     'Buy Whiskey!',
 203     'Correct liner pre-fetched with top cd',
 204   );
 205
 206   is ($query_cnt, 0, 'No queries executed during prefetched data access');
 207   $schema->storage->debugcb (undef);
 208   $schema->storage->debug ($sdebug);
 209 }
 210
 211 # make sure that distinct still works
 212 {
 213   my $rs = $schema->resultset("CD")->search({}, {
 214     prefetch => 'tags',
 215     order_by => 'cdid',
 216     distinct => 1,
 217   });
 218
 219   is_same_sql_bind (
 220     $rs->as_query,
 221     '(
 222       SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track,
 223              tags.tagid, tags.cd, tags.tag
 224         FROM (
 225           SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 226             FROM cd me
 227           GROUP BY me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 228           ORDER BY cdid
 229         ) me
 230         LEFT JOIN tags tags ON tags.cd = me.cdid
 231       ORDER BY cdid, tags.cd, tags.tag
 232     )',
 233     [],
 234     'Prefetch + distinct resulted in correct group_by',
 235   );
 236
 237   is ($rs->all, 5, 'Correct number of CD objects');
 238   is ($rs->count, 5, 'Correct count of CDs');
 239 }
 240
 241 # RT 47779, test group_by as a scalar ref
 242 {
 243   my $track_rs = $schema->resultset ('Track')->search (
 244     { 'me.cd' => { -in => [ $cd_rs->get_column ('cdid')->all ] } },
 245     {
 246       select => [
 247         'me.cd',
 248         { count => 'me.trackid' },
 249       ],
 250       as => [qw/
 251         cd
 252         track_count
 253       /],
 254       group_by => \'SUBSTR(me.cd, 1, 1)',
 255       prefetch => 'cd',
 256     },
 257   );
 258
 259   is_same_sql_bind (
 260     $track_rs->count_rs->as_query,
 261     '(
 262       SELECT COUNT( * )
 263         FROM (
 264           SELECT SUBSTR(me.cd, 1, 1)
 265             FROM track me
 266             JOIN cd cd ON cd.cdid = me.cd
 267           WHERE ( me.cd IN ( ?, ?, ?, ?, ? ) )
 268           GROUP BY SUBSTR(me.cd, 1, 1)
 269         )
 270       me
 271     )',
 272     [ map { [ { sqlt_datatype => 'integer', dbic_colname => 'me.cd' }
 273       => $_ ] } ($cd_rs->get_column ('cdid')->all) ],
 274     'count() query generated expected SQL',
 275   );
 276 }
 277
 278 {
 279     my $cd_rs = $schema->resultset('CD')->search({}, {
 280             distinct => 1,
 281             join     => [qw/ tracks /],
 282             prefetch => [qw/ artist /],
 283         });
 284     is($cd_rs->count, 5, 'complex prefetch + non-prefetching has_many join count correct');
 285     is($cd_rs->all, 5, 'complex prefetch + non-prefetching has_many join number of objects correct');
 286
 287     # make sure join tracks was thrown out
 288     is_same_sql_bind (
 289       $cd_rs->as_query,
 290       '(
 291         SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track,
 292                artist.artistid, artist.name, artist.rank, artist.charfield
 293           FROM (
 294             SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 295               FROM cd me
 296               JOIN artist artist ON artist.artistid = me.artist
 297             GROUP BY me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 298           ) me
 299           JOIN artist artist ON artist.artistid = me.artist
 300       )',
 301       [],
 302     );
 303
 304
 305
 306     # try the same as above, but add a condition so the tracks join can not be thrown away
 307     my $cd_rs2 = $cd_rs->search ({ 'tracks.title' => { '!=' => 'ugabuganoexist' } });
 308     is($cd_rs2->count, 5, 'complex prefetch + non-prefetching restricted has_many join count correct');
 309     is($cd_rs2->all, 5, 'complex prefetch + non-prefetching restricted has_many join number of objects correct');
 310
 311     # the outer group_by seems like a necessary evil, if someone can figure out how to take it away
 312     # without breaking compat - be my guest
 313     is_same_sql_bind (
 314       $cd_rs2->as_query,
 315       '(
 316         SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track,
 317                artist.artistid, artist.name, artist.rank, artist.charfield
 318           FROM (
 319             SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 320               FROM cd me
 321               LEFT JOIN track tracks ON tracks.cd = me.cdid
 322               JOIN artist artist ON artist.artistid = me.artist
 323             WHERE ( tracks.title != ? )
 324             GROUP BY me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track
 325           ) me
 326           LEFT JOIN track tracks ON tracks.cd = me.cdid
 327           JOIN artist artist ON artist.artistid = me.artist
 328         WHERE ( tracks.title != ? )
 329         GROUP BY me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track,
 330                  artist.artistid, artist.name, artist.rank, artist.charfield
 331       )',
 332       [ map { [ { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'tracks.title' }
 333             => 'ugabuganoexist' ] } (1,2)
 334       ],
 335     );
 336 }
 337
 338 {
 339     my $rs = $schema->resultset('CD')->search({},
 340         {
 341            '+select' => [{ count => 'tags.tag' }],
 342            '+as' => ['test_count'],
 343            prefetch => ['tags'],
 344            distinct => 1,
 345            order_by => {'-asc' => 'tags.tag'},
 346            rows => 1
 347         }
 348     );
 349     is_same_sql_bind($rs->as_query, q{
 350         (SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track, me.test_count, tags.tagid, tags.cd, tags.tag
 351           FROM (SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track, COUNT( tags.tag ) AS test_count
 352                 FROM cd me LEFT JOIN tags tags ON tags.cd = me.cdid
 353             GROUP BY me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track, tags.tag
 354             ORDER BY tags.tag ASC LIMIT ?)
 355             me
 356           LEFT JOIN tags tags ON tags.cd = me.cdid
 357          ORDER BY tags.tag ASC, tags.cd, tags.tag
 358         )
 359     }, [[$ROWS => 1]]);
 360 }
 361
 362 done_testing;