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