X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2FMSSQL.pm;h=6779e864664097cd56d75e5b831ef21f93bfddbd;hb=406760d8097f4420dca9d141f7a397a290867938;hp=03311809716199c340e4b50580aca2428445caf7;hpb=010f82a001cea2c6067fd8a080e29eb3310c2ecb;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/Storage/DBI/MSSQL.pm b/lib/DBIx/Class/Storage/DBI/MSSQL.pm
index 0331180..6779e86 100644
--- a/lib/DBIx/Class/Storage/DBI/MSSQL.pm
+++ b/lib/DBIx/Class/Storage/DBI/MSSQL.pm
@@ -3,7 +3,7 @@ package DBIx::Class::Storage::DBI::MSSQL;
 use strict;
 use warnings;
 
-use base qw/DBIx::Class::Storage::DBI::AmbiguousGlob DBIx::Class::Storage::DBI/;
+use base qw/DBIx::Class::Storage::DBI/;
 use mro 'c3';
 
 use List::Util();
@@ -190,10 +190,10 @@ sub _select_args_to_query {
 
   # see if this is an ordered subquery
   my $attrs = $_[3];
-  if ( scalar $self->sql_maker->_order_by_chunks ($attrs->{order_by}) ) {
+  if ( scalar $self->_parse_order_by ($attrs->{order_by}) ) {
     $self->throw_exception(
-      'An ordered subquery encountered. Please see "Ordered Subqueries" in DBIx::Class::Storage::DBI::MSSQL
-    ') unless $attrs->{unsafe_subquery};
+      'An ordered subselect encountered - this is not safe! Please see "Ordered Subselects" in DBIx::Class::Storage::DBI::MSSQL
+    ') unless $attrs->{unsafe_subselect_ok};
     my $max = 2 ** 32;
     $sql =~ s/^ \s* SELECT \s/SELECT TOP $max /xi;
   }
@@ -308,44 +308,53 @@ $table_name ON>. Unfortunately this operation in MSSQL requires the
 C<db_ddladmin> privilege, which is normally not included in the standard
 write-permissions.
 
-=head2 Ordered Subqueries
+=head2 Ordered Subselects
+
+If you attempted the following query (among many others) in Microsoft SQL
+Server
 
- # this is deemed unsafe and throws under MSSQL
  $rs->search ({}, {
   prefetch => 'relation',
   rows => 2,
   offset => 3,
  });
 
- # however this should work (but please check what comes back from the db)
+You may be surprised to receive an exception. The reason for this is a quirk
+in the MSSQL engine itself, and sadly doesn't have a sensible workaround due
+to the way DBIC is built. DBIC can do truly wonderful things with the aid of
+subselects, and does so automatically when necessary. The list of situations
+when a subselect is necessary is long and still changes often, so it can not
+be exhaustively enumerated here. The general rule of thumb is a joined
+L<has_many|DBIx::Class::Relationship/has_many> relationship with limit/group
+applied to the left part of the join.
+
+In its "pursuit of standards" Microsft SQL Server goes to great lengths to
+forbid the use of ordered subselects. This breaks a very useful group of
+searches like "Give me things number 4 to 6 (ordered by name), and prefetch
+all their relations, no matter how many". While there is a hack which fools
+the syntax checker, the optimizer may B<still elect to break the subselect>.
+Testing has determined that while such breakage does occur (the test suite
+contains an explicit test which demonstrates the problem), it is relative
+rare. The benefits of ordered subselects are on the other hand too great to be
+outright disabled for MSSQL.
+
+Thus compromise between usability and perfection is the MSSQL-specific
+L<resultset attribute|DBIx::Class::ResultSet/ATTRIBUTES> C<unsafe_subselect_ok>.
+It is deliberately not possible to set this on the Storage level, as the user
+should inspect (and preferably regression-test) the return of every such
+ResultSet individually. The example above would work if written like:
+
  $rs->search ({}, {
-  unsafe_subquery => 1,
+  unsafe_subselect_ok => 1,
   prefetch => 'relation',
   rows => 2,
   offset => 3,
  });
 
-DBIC can do truly wonderful things with the aid of subqueries, and does so
-automatically when necessary. Especially useful are ordered subqueries,
-which allow searches like "Give me things number 4 to 6 (ordered by name), and
-prefetch all their relations, no matter how many". In its pursuit of standards
-Microsft SQL Server goes to great lengths to forbid the use of ordered
-subqueries. While there is a hack which fools the syntax checker, the optimizer
-may B<still elect to break the subquery>. Testing has determined that while
-such breakage does occur (the test suite contains an explicit test which
-demonstrates the problem), it is relative rare. The benefits of ordered
-subqueries are on the other hand too great to be outright disabled for MSSQL.
-
-Thus compromise between usability and perfection is the MSSQL-specific
-L<resultset attribute|DBIx::Class::ResultSet/ATTRIBUTES> C<unsafe_subquery>.
-It is deliberately not possible to set this on the Storage level, as the user
-should inspect (and preferrably regression-test) the return of every such
-ResultSet individually.
-
 If it is possible to rewrite the search() in a way that will avoid the need
 for this flag - you are urged to do so. If DBIC internals insist that an
-ordered subquery is necessary for an operation, and you believe there is a
-differnt/better way to get the same result - please file a bugreport.
+ordered subselect is necessary for an operation, and you believe there is a
+different/better way to get the same result - please file a bugreport.
 
 =head1 AUTHOR