X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F746mssql.t;h=ab1bc200028454c94d81f6dfbc80c9da09336761;hb=aa1a762fbb2c083d8c88e35e334d525f02fbe6bc;hp=8ee8a23d225097aee157b2980acc2cc93fc03cf2;hpb=6bc666a5ec74e09c1aaf7053753637f9830a2cc9;p=dbsrgits%2FDBIx-Class.git diff --git a/t/746mssql.t b/t/746mssql.t index 8ee8a23..ab1bc20 100644 --- a/t/746mssql.t +++ b/t/746mssql.t @@ -28,6 +28,11 @@ my $schema = DBICTest::Schema->connect($dsn, $user, $pass); isa_ok( $schema->storage, 'DBIx::Class::Storage::DBI::ODBC::Microsoft_SQL_Server' ); +{ + my $schema2 = $schema->connect ($schema->storage->connect_info); + ok (! $schema2->storage->connected, 'a re-connected cloned schema starts unconnected'); +} + $schema->storage->dbh_do (sub { my ($storage, $dbh) = @_; eval { $dbh->do("DROP TABLE artist") }; @@ -173,10 +178,10 @@ is $rs->find($row->id)->amount, undef,'updated money value to NULL round-trip'; $schema->storage->dbh_do (sub { my ($storage, $dbh) = @_; - eval { $dbh->do("DROP TABLE Owners") }; - eval { $dbh->do("DROP TABLE Books") }; + eval { $dbh->do("DROP TABLE owners") }; + eval { $dbh->do("DROP TABLE books") }; $dbh->do(<<'SQL'); -CREATE TABLE Books ( +CREATE TABLE books ( id INT IDENTITY (1, 1) NOT NULL, source VARCHAR(100), owner INT, @@ -184,7 +189,7 @@ CREATE TABLE Books ( price INT NULL ) -CREATE TABLE Owners ( +CREATE TABLE owners ( id INT IDENTITY (1, 1) NOT NULL, name VARCHAR(100), ) @@ -200,10 +205,10 @@ lives_ok ( sub { [qw/1 wiggle/], [qw/2 woggle/], [qw/3 boggle/], - [qw/4 fREW/], - [qw/5 fRIOUX/], - [qw/6 fROOH/], - [qw/7 fRUE/], + [qw/4 fRIOUX/], + [qw/5 fRUE/], + [qw/6 fREW/], + [qw/7 fROOH/], [qw/8 fISMBoC/], [qw/9 station/], [qw/10 mirror/], @@ -215,11 +220,12 @@ lives_ok ( sub { ]); }, 'populate with PKs supplied ok' ); + lives_ok (sub { # start a new connection, make sure rebless works # test an insert with a supplied identity, followed by one without my $schema = DBICTest::Schema->connect($dsn, $user, $pass); - for (1..2) { + for (2, 1) { my $id = $_ * 20 ; $schema->resultset ('Owners')->create ({ id => $id, name => "troglodoogle $id" }); $schema->resultset ('Owners')->create ({ name => "troglodoogle " . ($id + 1) }); @@ -249,20 +255,129 @@ lives_ok ( sub { ]); }, 'populate without PKs supplied ok' ); -# make sure ordered subselects work +# plain ordered subqueries throw +throws_ok (sub { + $schema->resultset('Owners')->search ({}, { order_by => 'name' })->as_query +}, qr/ordered subselect encountered/, 'Ordered Subselect detection throws ok'); + +# make sure ordered subselects *somewhat* work { + my $owners = $schema->resultset ('Owners')->search ({}, { order_by => 'name', offset => 2, rows => 3, unsafe_subselect_ok => 1 }); + + my $al = $owners->current_source_alias; + my $sealed_owners = $owners->result_source->resultset->search ( + {}, + { + alias => $al, + from => [{ + -alias => $al, + -source_handle => $owners->result_source->handle, + $al => $owners->as_query, + }], + }, + ); + + is_deeply ( + [ map { $_->name } ($sealed_owners->all) ], + [ map { $_->name } ($owners->all) ], + 'Sort preserved from within a subquery', + ); +} + +TODO: { + local $TODO = "This porbably will never work, but it isn't critical either afaik"; + my $book_owner_ids = $schema->resultset ('BooksInLibrary') - ->search ({}, { join => 'owner', distinct => 1, order_by => { -desc => 'owner'} }) + ->search ({}, { join => 'owner', distinct => 1, order_by => 'owner.name', unsafe_subselect_ok => 1 }) ->get_column ('owner'); - my $owners = $schema->resultset ('Owners')->search ({ + my $book_owners = $schema->resultset ('Owners')->search ({ id => { -in => $book_owner_ids->as_query } }); - is ($owners->count, 8, 'Correct amount of book owners'); - is ($owners->all, 8, 'Correct amount of book owner objects'); + is_deeply ( + [ map { $_->id } ($book_owners->all) ], + [ $book_owner_ids->all ], + 'Sort is preserved across IN subqueries', + ); +} + +# This is known not to work - thus the negative test +{ + my $owners = $schema->resultset ('Owners')->search ({}, { order_by => 'name', offset => 2, rows => 3, unsafe_subselect_ok => 1 }); + my $corelated_owners = $owners->result_source->resultset->search ( + { + id => { -in => $owners->get_column('id')->as_query }, + }, + { + order_by => 'name' #reorder because of what is shown above + }, + ); + + cmp_ok ( + join ("\x00", map { $_->name } ($corelated_owners->all) ), + 'ne', + join ("\x00", map { $_->name } ($owners->all) ), + 'Sadly sort not preserved from within a corelated subquery', + ); + + cmp_ok ( + join ("\x00", sort map { $_->name } ($corelated_owners->all) ), + 'ne', + join ("\x00", sort map { $_->name } ($owners->all) ), + 'Which in fact gives a completely wrong dataset', + ); } + +# make sure right-join-side single-prefetch ordering limit works +{ + my $rs = $schema->resultset ('BooksInLibrary')->search ( + { + 'owner.name' => { '!=', 'woggle' }, + }, + { + prefetch => 'owner', + order_by => 'owner.name', + } + ); + # this is the order in which they should come from the above query + my @owner_names = qw/boggle fISMBoC fREW fRIOUX fROOH fRUE wiggle wiggle/; + + is ($rs->all, 8, 'Correct amount of objects from right-sorted joined resultset'); + is_deeply ( + [map { $_->owner->name } ($rs->all) ], + \@owner_names, + 'Rows were properly ordered' + ); + + my $limited_rs = $rs->search ({}, {rows => 7, offset => 2, unsafe_subselect_ok => 1}); + is ($limited_rs->count, 6, 'Correct count of limited right-sorted joined resultset'); + is ($limited_rs->count_rs->next, 6, 'Correct count_rs of limited right-sorted joined resultset'); + + my $queries; + $schema->storage->debugcb(sub { $queries++; }); + $schema->storage->debug(1); + + is_deeply ( + [map { $_->owner->name } ($limited_rs->all) ], + [@owner_names[2 .. 7]], + 'Limited rows were properly ordered' + ); + is ($queries, 1, 'Only one query with prefetch'); + + $schema->storage->debugcb(undef); + $schema->storage->debug(0); + + + is_deeply ( + [map { $_->name } ($limited_rs->search_related ('owner')->all) ], + [@owner_names[2 .. 7]], + 'Rows are still properly ordered after search_related' + ); +} + + # # try a prefetch on tables with identically named columns # @@ -275,15 +390,23 @@ $schema->storage->_sql_maker->{name_sep} = '.'; # try a ->has_many direction my $owners = $schema->resultset ('Owners')->search ( { - 'books.id' => { '!=', undef } + 'books.id' => { '!=', undef }, + 'me.name' => { '!=', 'somebogusstring' }, }, { prefetch => 'books', - order_by => 'name', + order_by => { -asc => \['name + ?', [ test => 'xxx' ]] }, # test bindvar propagation rows => 3, # 8 results total + unsafe_subselect_ok => 1, }, ); + my ($sql, @bind) = @${$owners->page(3)->as_query}; + is_deeply ( + \@bind, + [ ([ 'me.name' => 'somebogusstring' ], [ test => 'xxx' ]) x 2 ], # double because of the prefetch subq + ); + is ($owners->page(1)->all, 3, 'has_many prefetch returns correct number of rows'); is ($owners->page(1)->count, 3, 'has-many prefetch returns correct count'); @@ -299,14 +422,24 @@ $schema->storage->_sql_maker->{name_sep} = '.'; }, { distinct => 1, + having => \['1 = ?', [ test => 1 ] ], #test having propagation prefetch => 'owner', rows => 2, # 3 results total - order_by => { -desc => 'owner' }, - # there is no sane way to order by the right side of a grouped prefetch currently :( - #order_by => { -desc => 'owner.name' }, + order_by => { -desc => 'me.owner' }, + unsafe_subselect_ok => 1, }, ); + ($sql, @bind) = @${$books->page(3)->as_query}; + is_deeply ( + \@bind, + [ + # inner + [ 'owner.name' => 'wiggle' ], [ 'owner.name' => 'woggle' ], [ source => 'Library' ], [ test => '1' ], + # outer + [ 'owner.name' => 'wiggle' ], [ 'owner.name' => 'woggle' ], [ source => 'Library' ], + ], + ); is ($books->page(1)->all, 2, 'Prefetched grouped search returns correct number of rows'); is ($books->page(1)->count, 2, 'Prefetched grouped search returns correct count'); @@ -322,7 +455,7 @@ done_testing; END { if (my $dbh = eval { $schema->storage->_dbh }) { eval { $dbh->do("DROP TABLE $_") } - for qw/artist money_test Books Owners/; + for qw/artist money_test books owners/; } } # vim:sw=2 sts=2