From: Peter Rabbitson <ribasushi@cpan.org>
Date: Fri, 27 Aug 2010 10:49:38 +0000 (+0200)
Subject: Rename SQLAHacks to SQLMaker, shuffle around files, add extensive
X-Git-Tag: v0.08124~101^2
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=d5dedbd62928f65a9071b4d9b6d56c6b663a073b;p=dbsrgits%2FDBIx-Class.git

Rename SQLAHacks to SQLMaker, shuffle around files, add extensive
POD.
---

diff --git a/Makefile.PL b/Makefile.PL
index 8fa4ddb..ce27a84 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -221,15 +221,13 @@ resources 'bugtracker'  => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=DBIx-Class'
 # Deprecated/internal modules need no exposure
 no_index directory => $_ for (qw|
   lib/DBIx/Class/Admin
-  lib/DBIx/Class/SQLAHacks
   lib/DBIx/Class/PK/Auto
   lib/DBIx/Class/CDBICompat
 |);
 no_index package => $_ for (qw/
-  DBIx::Class::SQLAHacks DBIx::Class::Storage::DBIHacks
+  DBIx::Class::Storage::DBIHacks
 /);
 
-
 WriteAll();
 
 # Re-write META.yml to _exclude_ all forced requires (we do not want to ship this)
diff --git a/lib/DBIx/Class/Manual/Cookbook.pod b/lib/DBIx/Class/Manual/Cookbook.pod
index 72dba57..3e3f5db 100644
--- a/lib/DBIx/Class/Manual/Cookbook.pod
+++ b/lib/DBIx/Class/Manual/Cookbook.pod
@@ -1695,24 +1695,6 @@ this, you can also overload the C<connection> method for your schema class:
      return $rv;
  }
 
-=head2 Setting limit dialect for SQL::Abstract::Limit
-
-In some cases, SQL::Abstract::Limit cannot determine the dialect of
-the remote SQL server by looking at the database handle. This is a
-common problem when using the DBD::JDBC, since the DBD-driver only
-know that in has a Java-driver available, not which JDBC driver the
-Java component has loaded.  This specifically sets the limit_dialect
-to Microsoft SQL-server (See more names in SQL::Abstract::Limit
--documentation.
-
-  __PACKAGE__->storage->sql_maker->limit_dialect('mssql');
-
-The JDBC bridge is one way of getting access to a MSSQL server from a platform
-that Microsoft doesn't deliver native client libraries for. (e.g. Linux)
-
-The limit dialect can also be set at connect time by specifying a
-C<limit_dialect> key in the final hash as shown above.
-
 =head2 Working with PostgreSQL array types
 
 You can also assign values to PostgreSQL array columns by passing array
diff --git a/lib/DBIx/Class/SQLAHacks.pm b/lib/DBIx/Class/SQLMaker.pm
similarity index 88%
rename from lib/DBIx/Class/SQLAHacks.pm
rename to lib/DBIx/Class/SQLMaker.pm
index 31e189a..d0fbc77 100644
--- a/lib/DBIx/Class/SQLAHacks.pm
+++ b/lib/DBIx/Class/SQLMaker.pm
@@ -1,14 +1,35 @@
-package # Hide from PAUSE
-  DBIx::Class::SQLAHacks;
+package DBIx::Class::SQLMaker;
 
-# This module is a subclass of SQL::Abstract and includes a number of
-# DBIC-specific workarounds, not yet suitable for inclusion into the
-# SQLA core.
-# It also provides all (and more than) the functionality of
-# SQL::Abstract::Limit, which proved to be very hard to keep updated
+=head1 NAME
+
+DBIx::Class::SQLMaker - An SQL::Abstract-based SQL maker class
+
+=head1 DESCRIPTION
+
+This module is a subclass of L<SQL::Abstract> and includes a number of
+DBIC-specific workarounds, not yet suitable for inclusion into the
+L<SQL::Abstract> core. It also provides all (and more than) the functionality
+of L<SQL::Abstract::Limit>, see L<DBIx::Class::SQLMaker::LimitDialects> for
+more info.
+
+Currently the enhancements to L<SQL::Abstract> are:
+
+=over
+
+=item * Support for C<JOIN> statements (via extended C<table/from> support)
+
+=item * Support of functions in C<SELECT> lists
+
+=item * C<GROUP BY>/C<HAVING> support (via extensions to the order_by parameter)
+
+=item * Support of C<...FOR UPDATE> type of select statement modifiers
+
+=back
+
+=cut
 
 use base qw/
-  DBIx::Class::SQLAHacks::LimitDialects
+  DBIx::Class::SQLMaker::LimitDialects
   SQL::Abstract
   Class::Accessor::Grouped
 /;
@@ -32,7 +53,7 @@ BEGIN {
     my $clan_import = \&{$f};
     *{"SQL::Abstract::$f"} = subname "SQL::Abstract::$f" =>
       sub {
-        if (Carp::longmess() =~ /DBIx::Class::SQLAHacks::[\w]+ .+? called \s at/x) {
+        if (Carp::longmess() =~ /DBIx::Class::SQLMaker::[\w]+ .+? called \s at/x) {
           $clan_import->(@_);
         }
         else {
@@ -85,7 +106,7 @@ sub select {
         my $dialect = $self->limit_dialect
           or croak "Unable to generate SQL-limit - no limit dialect specified on $self, and no emulate_limit method found";
         $self->can ("_$dialect")
-          or croak "SQLAHacks does not implement the requested dialect '$dialect'";
+          or croak (__PACKAGE__ . " does not implement the requested dialect '$dialect'");
       }
     ;
 
@@ -333,3 +354,13 @@ sub _join_condition {
 }
 
 1;
+
+=head1 AUTHORS
+
+See L<DBIx::Class/CONTRIBUTORS>.
+
+=head1 LICENSE
+
+You may distribute this code under the same terms as Perl itself.
+
+=cut
diff --git a/lib/DBIx/Class/SQLAHacks/LimitDialects.pm b/lib/DBIx/Class/SQLMaker/LimitDialects.pm
similarity index 81%
rename from lib/DBIx/Class/SQLAHacks/LimitDialects.pm
rename to lib/DBIx/Class/SQLMaker/LimitDialects.pm
index 2ca6fd5..d4689a7 100644
--- a/lib/DBIx/Class/SQLAHacks/LimitDialects.pm
+++ b/lib/DBIx/Class/SQLMaker/LimitDialects.pm
@@ -1,4 +1,4 @@
-package DBIx::Class::SQLAHacks::LimitDialects;
+package DBIx::Class::SQLMaker::LimitDialects;
 
 use warnings;
 use strict;
@@ -79,7 +79,39 @@ use namespace::clean;
 }
 ### end-of-FIXME
 
-# PostgreSQL and SQLite
+=head1 NAME
+
+DBIx::Class::SQLMaker::LimitDialects - SQL::Abstract::Limit-like functionality for DBIx::Class::SQLMaker
+
+=head1 DESCRIPTION
+
+This module replicates a lot of the functionality originally found in
+L<SQL::Abstract::Limit>. While simple limits would work as-is, the more
+complex dialects that require e.g. subqueries could not be reliably
+implemented without taking full advantage of the metadata locked within
+L<DBIx::Class::ResultSource> classes. After reimplementation of close to
+80% of the L<SQL::Abstract::Limit> functionality it was deemed more
+practical to simply make an independent DBIx::Class-specific limit-dialect
+provider.
+
+=head1 SQL LIMIT DIALECTS
+
+Note that the actual implementations listed below never use C<*> literally.
+Instead proper re-aliasing of selectors and order criteria is done, so that
+the limit dialect are safe to use on joined resultsets with clashing column
+names.
+
+Currently the provided dialects are:
+
+=cut
+
+=head2 LimitOffset
+
+ SELECT ... LIMIT $limit OFFSET $offset
+
+Supported by B<PostgreSQL> and B<SQLite>
+
+=cut
 sub _LimitOffset {
     my ( $self, $sql, $order, $rows, $offset ) = @_;
     $sql .= $self->_order_by( $order ) . " LIMIT $rows";
@@ -87,7 +119,13 @@ sub _LimitOffset {
     return $sql;
 }
 
-# MySQL and any SQL::Statement based DBD
+=head2 LimitXY
+
+ SELECT ... LIMIT $offset $limit
+
+Supported by B<MySQL> and any L<SQL::Statement> based DBD
+
+=cut
 sub _LimitXY {
     my ( $self, $sql, $order, $rows, $offset ) = @_;
     $sql .= $self->_order_by( $order ) . " LIMIT ";
@@ -95,7 +133,20 @@ sub _LimitXY {
     $sql .= $rows;
     return $sql;
 }
-# ANSI standard Limit/Offset implementation. DB2 and MSSQL >= 2005 use this
+
+=head2 RowNumberOver
+
+ SELECT * FROM (
+  SELECT *, ROW_NUMBER() OVER( ORDER BY ... ) AS RNO__ROW__INDEX FROM (
+   SELECT ...
+  )
+ ) WHERE RNO__ROW__INDEX BETWEEN ($offset+1) AND ($limit+$offset)
+
+
+ANSI standard Limit/Offset implementation. Supported by B<DB2> and
+B<< MSSQL >= 2005 >>.
+
+=cut
 sub _RowNumberOver {
   my ($self, $sql, $rs_attrs, $rows, $offset ) = @_;
 
@@ -160,9 +211,14 @@ sub _rno_default_order {
   return undef;
 }
 
-# Informix specific limit, almost like LIMIT/OFFSET
-# According to SQLA::Limit informix also supports
-# SKIP X LIMIT Y (in addition to SKIP X FIRST Y)
+=head2 SkipFirst
+
+ SELECT SKIP $offset FIRST $limit * FROM ...
+
+Suported by B<Informix>, almost like LimitOffset. According to
+L<SQL::Abstract::Limit> C<... SKIP $offset LIMIT $limit ...> is also supported.
+
+=cut
 sub _SkipFirst {
   my ($self, $sql, $rs_attrs, $rows, $offset) = @_;
 
@@ -180,9 +236,14 @@ sub _SkipFirst {
   );
 }
 
-# Firebird specific limit, reverse of _SkipFirst for Informix
-# According to SQLA::Limit firebird/interbase also supports
-# ROWS X TO Y (in addition to FIRST X SKIP Y)
+=head2 FirstSkip
+
+ SELECT FIRST $limit SKIP $offset * FROM ...
+
+Supported by B<Firebird/Interbase>, reverse of SkipFirst. According to
+L<SQL::Abstract::Limit> C<... ROWS $limit TO $offset ...> is also supported.
+
+=cut
 sub _FirstSkip {
   my ($self, $sql, $rs_attrs, $rows, $offset) = @_;
 
@@ -200,7 +261,17 @@ sub _FirstSkip {
   );
 }
 
-# WhOracle limits
+=head2 RowNum
+
+ SELECT * FROM (
+  SELECT *, ROWNUM rownum__index FROM (
+   SELECT ...
+  )
+ ) WHERE rownum__index BETWEEN ($offset+1) AND ($limit+$offset)
+
+Supported by B<Oracle>.
+
+=cut
 sub _RowNum {
   my ( $self, $sql, $rs_attrs, $rows, $offset ) = @_;
 
@@ -228,7 +299,24 @@ EOS
   return $sql;
 }
 
-# Crappy Top based Limit/Offset support. Legacy for MSSQL < 2005
+=head2 Top
+
+ SELECT * FROM
+
+ SELECT TOP $limit FROM (
+  SELECT TOP $limit FROM (
+   SELECT TOP ($limit+$offset) ...
+  ) ORDER BY $reversed_original_order
+ ) ORDER BY $original_order
+
+Unreliable Top-based implementation, supported by B<< MSSQL < 2005 >>.
+
+=head3 CAVEAT
+
+Due to its implementation, this limit dialect returns B<incorrect results>
+when $limit+$offset > total amount of rows in the resultset.
+
+=cut
 sub _Top {
   my ( $self, $sql, $rs_attrs, $rows, $offset ) = @_;
 
@@ -337,8 +425,18 @@ sub _Top {
   return $sql;
 }
 
-# This for Sybase ASE, to use SET ROWCOUNT when there is no offset, and
-# GenericSubQ otherwise.
+=head2 RowCountOrGenericSubQ
+
+This is not exactly a limit dialect, but more of a proxy for B<Sybase ASE>.
+If no $offset is supplied the limit is simply performed as:
+
+ SET ROWCOUNT $limit
+ SELECT ...
+ SET ROWCOUNT 0
+
+Otherwise we fall back to L</GenericSubQ>
+
+=cut
 sub _RowCountOrGenericSubQ {
   my $self = shift;
   my ($sql, $rs_attrs, $rows, $offset) = @_;
@@ -352,11 +450,25 @@ SET ROWCOUNT 0
 EOF
 }
 
-# This is the most evil limit "dialect" (more of a hack) for *really*
-# stupid databases. It works by ordering the set by some unique column,
-# and calculating amount of rows that have a less-er value (thus
-# emulating a RowNum-like index). Of course this implies the set can
-# only be ordered by a single unique columns.
+=head2 GenericSubQ
+
+ SELECT * FROM (
+  SELECT ...
+ )
+ WHERE (
+  SELECT COUNT(*) FROM $original_table cnt WHERE cnt.id < $original_table.id
+ ) BETWEEN $offset AND ($offset+$rows-1)
+
+This is the most evil limit "dialect" (more of a hack) for I<really> stupid
+databases. It works by ordering the set by some unique column, and calculating
+the amount of rows that have a less-er value (thus emulating a L</RowNum>-like
+index). Of course this implies the set can only be ordered by a single unique
+column. Also note that this technique can be and often is B<excruciatingly
+slow>.
+
+Currently used by B<Sybase ASE>, due to lack of any other option.
+
+=cut
 sub _GenericSubQ {
   my ($self, $sql, $rs_attrs, $rows, $offset) = @_;
 
@@ -574,3 +686,13 @@ sub _unqualify_colname {
 }
 
 1;
+
+=head1 AUTHORS
+
+See L<DBIx::Class/CONTRIBUTORS>.
+
+=head1 LICENSE
+
+You may distribute this code under the same terms as Perl itself.
+
+=cut
diff --git a/lib/DBIx/Class/SQLAHacks/MSSQL.pm b/lib/DBIx/Class/SQLMaker/MSSQL.pm
similarity index 72%
rename from lib/DBIx/Class/SQLAHacks/MSSQL.pm
rename to lib/DBIx/Class/SQLMaker/MSSQL.pm
index f1af970..30b0c96 100644
--- a/lib/DBIx/Class/SQLAHacks/MSSQL.pm
+++ b/lib/DBIx/Class/SQLMaker/MSSQL.pm
@@ -1,7 +1,7 @@
 package # Hide from PAUSE
-  DBIx::Class::SQLAHacks::MSSQL;
+  DBIx::Class::SQLMaker::MSSQL;
 
-use base qw( DBIx::Class::SQLAHacks );
+use base qw( DBIx::Class::SQLMaker );
 use Carp::Clan qw/^DBIx::Class|^SQL::Abstract/;
 
 #
diff --git a/lib/DBIx/Class/SQLAHacks/MySQL.pm b/lib/DBIx/Class/SQLMaker/MySQL.pm
similarity index 90%
rename from lib/DBIx/Class/SQLAHacks/MySQL.pm
rename to lib/DBIx/Class/SQLMaker/MySQL.pm
index cc177f1..16e47e7 100644
--- a/lib/DBIx/Class/SQLAHacks/MySQL.pm
+++ b/lib/DBIx/Class/SQLMaker/MySQL.pm
@@ -1,7 +1,7 @@
 package # Hide from PAUSE
-  DBIx::Class::SQLAHacks::MySQL;
+  DBIx::Class::SQLMaker::MySQL;
 
-use base qw( DBIx::Class::SQLAHacks );
+use base qw( DBIx::Class::SQLMaker );
 use Carp::Clan qw/^DBIx::Class|^SQL::Abstract/;
 
 #
diff --git a/lib/DBIx/Class/SQLAHacks/Oracle.pm b/lib/DBIx/Class/SQLMaker/Oracle.pm
similarity index 93%
rename from lib/DBIx/Class/SQLAHacks/Oracle.pm
rename to lib/DBIx/Class/SQLMaker/Oracle.pm
index 23c1285..0a773e7 100644
--- a/lib/DBIx/Class/SQLAHacks/Oracle.pm
+++ b/lib/DBIx/Class/SQLMaker/Oracle.pm
@@ -1,10 +1,10 @@
 package # Hide from PAUSE
-  DBIx::Class::SQLAHacks::Oracle;
+  DBIx::Class::SQLMaker::Oracle;
 
 use warnings;
 use strict;
 
-use base qw( DBIx::Class::SQLAHacks );
+use base qw( DBIx::Class::SQLMaker );
 use Carp::Clan qw/^DBIx::Class|^SQL::Abstract/;
 
 sub new {
@@ -184,18 +184,3 @@ sub _unqualify_colname {
 }
 
 1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-DBIx::Class::SQLAHacks::Oracle - adds hierarchical query support for Oracle to SQL::Abstract
-
-=head1 DESCRIPTION
-
-See L<DBIx::Class::Storage::DBI::Oracle::Generic> for more information about
-how to use hierarchical queries with DBIx::Class.
-
-=cut
diff --git a/lib/DBIx/Class/SQLAHacks/OracleJoins.pm b/lib/DBIx/Class/SQLMaker/OracleJoins.pm
similarity index 92%
rename from lib/DBIx/Class/SQLAHacks/OracleJoins.pm
rename to lib/DBIx/Class/SQLMaker/OracleJoins.pm
index 4254aba..8350198 100644
--- a/lib/DBIx/Class/SQLAHacks/OracleJoins.pm
+++ b/lib/DBIx/Class/SQLMaker/OracleJoins.pm
@@ -1,7 +1,7 @@
 package # Hide from PAUSE
-  DBIx::Class::SQLAHacks::OracleJoins;
+  DBIx::Class::SQLMaker::OracleJoins;
 
-use base qw( DBIx::Class::SQLAHacks );
+use base qw( DBIx::Class::SQLMaker );
 use Carp::Clan qw/^DBIx::Class|^SQL::Abstract/;
 
 sub select {
@@ -90,7 +90,7 @@ sub _recurse_oracle_joins {
 
 =head1 NAME
 
-DBIx::Class::SQLAHacks::OracleJoins - Pre-ANSI Joins-via-Where-Clause Syntax
+DBIx::Class::SQLMaker::OracleJoins - Pre-ANSI Joins-via-Where-Clause Syntax
 
 =head1 PURPOSE
 
@@ -124,7 +124,7 @@ it's already too late.
 
 =item select ($\@$;$$@)
 
-Replaces DBIx::Class::SQLAHacks's select() method, which calls _oracle_joins()
+Replaces DBIx::Class::SQLMaker's select() method, which calls _oracle_joins()
 to modify the column and table list before calling SUPER::select().
 
 =item _recurse_from ($$\@)
@@ -148,7 +148,7 @@ Probably lots more.
 
 =item L<DBIx::Class::Storage::DBI::Oracle::WhereJoins> - Storage class using this
 
-=item L<DBIx::Class::SQLAHacks> - Parent module
+=item L<DBIx::Class::SQLMaker> - Parent module
 
 =item L<DBIx::Class> - Duh
 
diff --git a/lib/DBIx/Class/SQLAHacks/SQLite.pm b/lib/DBIx/Class/SQLMaker/SQLite.pm
similarity index 82%
rename from lib/DBIx/Class/SQLAHacks/SQLite.pm
rename to lib/DBIx/Class/SQLMaker/SQLite.pm
index e260786..24b26ee 100644
--- a/lib/DBIx/Class/SQLAHacks/SQLite.pm
+++ b/lib/DBIx/Class/SQLMaker/SQLite.pm
@@ -1,7 +1,7 @@
 package # Hide from PAUSE
-  DBIx::Class::SQLAHacks::SQLite;
+  DBIx::Class::SQLMaker::SQLite;
 
-use base qw( DBIx::Class::SQLAHacks );
+use base qw( DBIx::Class::SQLMaker );
 use Carp::Clan qw/^DBIx::Class|^SQL::Abstract/;
 
 #
diff --git a/lib/DBIx/Class/Storage.pm b/lib/DBIx/Class/Storage.pm
index 7b7fa60..9f7ed68 100644
--- a/lib/DBIx/Class/Storage.pm
+++ b/lib/DBIx/Class/Storage.pm
@@ -336,7 +336,7 @@ sub txn_scope_guard {
 =head2 sql_maker
 
 Returns a C<sql_maker> object - normally an object of class
-C<DBIx::Class::SQLAHacks>.
+C<DBIx::Class::SQLMaker>.
 
 =cut
 
diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm
index b47c7cd..3440ebb 100644
--- a/lib/DBIx/Class/Storage/DBI.pm
+++ b/lib/DBIx/Class/Storage/DBI.pm
@@ -23,7 +23,7 @@ use namespace::clean;
 __PACKAGE__->cursor_class('DBIx::Class::Storage::DBI::Cursor');
 
 __PACKAGE__->mk_group_accessors('inherited' => qw/sql_maker_class sql_limit_dialect/);
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker');
 
 __PACKAGE__->mk_group_accessors('simple' => qw/
   _connect_info _dbi_connect_info _dbic_connect_attributes _driver_determined
@@ -448,9 +448,9 @@ statement handles via L<DBI/prepare_cached>.
 
 =item limit_dialect
 
-Sets the limit dialect. This is useful for JDBC-bridge among others
-where the remote SQL-dialect cannot be determined by the name of the
-driver alone. See also L<SQL::Abstract::Limit>.
+Sets a specific SQL::Abstract::Limit-style limit dialect, overriding the
+default L</sql_limit_dialect> setting of the storage (if any). For a list
+of available limit dialects see L<DBIx::Class::SQLMaker::LimitDialects>.
 
 =item quote_char
 
@@ -2019,7 +2019,7 @@ sub _select_args {
     }
   }
 
-  # Sanity check the attributes (SQLAHacks does it too, but
+  # Sanity check the attributes (SQLMaker does it too, but
   # in case of a software_limit we'll never reach there)
   if (defined $attrs->{offset}) {
     $self->throw_exception('A supplied offset attribute must be a non-negative integer')
@@ -2132,6 +2132,13 @@ sub select_single {
   return @row;
 }
 
+=head2 sql_limit_dialect
+
+This is an accessor for the default SQL limit dialect used by a particular
+storage driver. Can be overriden by supplying an explicit L</limit_dialect>
+to L<DBIx::Class::Schema/connect>. For a list of available limit dialects
+see L<DBIx::Class::SQLMaker::LimitDialects>.
+
 =head2 sth
 
 =over 4
diff --git a/lib/DBIx/Class/Storage/DBI/InterBase.pm b/lib/DBIx/Class/Storage/DBI/InterBase.pm
index cd50531..e14277a 100644
--- a/lib/DBIx/Class/Storage/DBI/InterBase.pm
+++ b/lib/DBIx/Class/Storage/DBI/InterBase.pm
@@ -15,8 +15,8 @@ DBIx::Class::Storage::DBI::InterBase - Driver for the Firebird RDBMS
 =head1 DESCRIPTION
 
 This class implements autoincrements for Firebird using C<RETURNING> as well as
-L<auto_nextval|DBIx::Class::ResultSource/auto_nextval> sets the limit dialect to
-C<FIRST X SKIP X> and provides L<DBIx::Class::InflateColumn::DateTime> support.
+L<auto_nextval|DBIx::Class::ResultSource/auto_nextval> and provides
+L<DBIx::Class::InflateColumn::DateTime> support.
 
 You need to use either the
 L<disable_sth_caching|DBIx::Class::Storage::DBI/disable_sth_caching> option or
diff --git a/lib/DBIx/Class/Storage/DBI/MSSQL.pm b/lib/DBIx/Class/Storage/DBI/MSSQL.pm
index 73298d7..9cde4b9 100644
--- a/lib/DBIx/Class/Storage/DBI/MSSQL.pm
+++ b/lib/DBIx/Class/Storage/DBI/MSSQL.pm
@@ -13,7 +13,7 @@ __PACKAGE__->mk_group_accessors(simple => qw/
   _identity _identity_method
 /);
 
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::MSSQL');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::MSSQL');
 
 sub _set_identity_insert {
   my ($self, $table) = @_;
diff --git a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
index 30d885b..786a000 100644
--- a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
+++ b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm
@@ -79,7 +79,7 @@ versions before 9.
 use base qw/DBIx::Class::Storage::DBI/;
 use mro 'c3';
 
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::Oracle');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::Oracle');
 
 sub deployment_statements {
   my $self = shift;;
diff --git a/lib/DBIx/Class/Storage/DBI/Oracle/WhereJoins.pm b/lib/DBIx/Class/Storage/DBI/Oracle/WhereJoins.pm
index 945d546..eace5ee 100644
--- a/lib/DBIx/Class/Storage/DBI/Oracle/WhereJoins.pm
+++ b/lib/DBIx/Class/Storage/DBI/Oracle/WhereJoins.pm
@@ -6,7 +6,7 @@ use warnings;
 use base qw( DBIx::Class::Storage::DBI::Oracle::Generic );
 use mro 'c3';
 
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::OracleJoins');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::OracleJoins');
 
 1;
 
@@ -48,7 +48,7 @@ it's already too late.
 
 =head1 METHODS
 
-See L<DBIx::Class::SQLAHacks::OracleJoins> for implementation details.
+See L<DBIx::Class::SQLMaker::OracleJoins> for implementation details.
 
 =head1 BUGS
 
@@ -59,9 +59,9 @@ Probably lots more.
 
 =over
 
-=item L<DBIx::Class::SQLAHacks>
+=item L<DBIx::Class::SQLMaker>
 
-=item L<DBIx::Class::SQLAHacks::OracleJoins>
+=item L<DBIx::Class::SQLMaker::OracleJoins>
 
 =item L<DBIx::Class::Storage::DBI::Oracle::Generic>
 
diff --git a/lib/DBIx/Class/Storage/DBI/SQLAnywhere.pm b/lib/DBIx/Class/Storage/DBI/SQLAnywhere.pm
index 2addde0..e2efa13 100644
--- a/lib/DBIx/Class/Storage/DBI/SQLAnywhere.pm
+++ b/lib/DBIx/Class/Storage/DBI/SQLAnywhere.pm
@@ -17,8 +17,7 @@ DBIx::Class::Storage::DBI::SQLAnywhere - Driver for Sybase SQL Anywhere
 
 =head1 DESCRIPTION
 
-This class implements autoincrements for Sybase SQL Anywhere, selects the
-RowNumberOver limit implementation and provides
+This class implements autoincrements for Sybase SQL Anywhere and provides
 L<DBIx::Class::InflateColumn::DateTime> support.
 
 You need the C<DBD::SQLAnywhere> driver that comes with the SQL Anywhere
diff --git a/lib/DBIx/Class/Storage/DBI/SQLite.pm b/lib/DBIx/Class/Storage/DBI/SQLite.pm
index 3bc3e2b..766eb13 100644
--- a/lib/DBIx/Class/Storage/DBI/SQLite.pm
+++ b/lib/DBIx/Class/Storage/DBI/SQLite.pm
@@ -10,7 +10,7 @@ use POSIX 'strftime';
 use File::Copy;
 use File::Spec;
 
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::SQLite');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::SQLite');
 __PACKAGE__->sql_limit_dialect ('LimitOffset');
 
 sub backup
diff --git a/lib/DBIx/Class/Storage/DBI/Sybase/ASE.pm b/lib/DBIx/Class/Storage/DBI/Sybase/ASE.pm
index e380740..0496634 100644
--- a/lib/DBIx/Class/Storage/DBI/Sybase/ASE.pm
+++ b/lib/DBIx/Class/Storage/DBI/Sybase/ASE.pm
@@ -1152,7 +1152,7 @@ Real limits and limited counts using stored procedures deployed on startup.
 
 =item *
 
-Adaptive Server Anywhere (ASA) support, with possible SQLA::Limit support.
+Adaptive Server Anywhere (ASA) support
 
 =item *
 
diff --git a/lib/DBIx/Class/Storage/DBI/mysql.pm b/lib/DBIx/Class/Storage/DBI/mysql.pm
index e50c487..2c49691 100644
--- a/lib/DBIx/Class/Storage/DBI/mysql.pm
+++ b/lib/DBIx/Class/Storage/DBI/mysql.pm
@@ -9,7 +9,7 @@ use base qw/
 /;
 use mro 'c3';
 
-__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::MySQL');
+__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::MySQL');
 __PACKAGE__->sql_limit_dialect ('LimitXY');
 
 sub with_deferred_fk_checks {
diff --git a/t/71mysql.t b/t/71mysql.t
index 8d5a323..0526dd8 100644
--- a/t/71mysql.t
+++ b/t/71mysql.t
@@ -332,6 +332,6 @@ ZEROINSEARCH: {
 
 my $schema2 = DBICTest::Schema->connect($dsn, $user, $pass);
 $schema2->resultset("Artist")->find(4);
-isa_ok($schema2->storage->sql_maker, 'DBIx::Class::SQLAHacks::MySQL');
+isa_ok($schema2->storage->sql_maker, 'DBIx::Class::SQLMaker::MySQL');
 
 done_testing;
diff --git a/t/76joins.t b/t/76joins.t
index 862fef3..88749b4 100644
--- a/t/76joins.t
+++ b/t/76joins.t
@@ -11,7 +11,7 @@ my $schema = DBICTest->init_schema();
 my $orig_debug = $schema->storage->debug;
 
 # test the abstract join => SQL generator
-my $sa = new DBIx::Class::SQLAHacks;
+my $sa = new DBIx::Class::SQLMaker;
 
 my @j = (
     { child => 'person' },
diff --git a/t/sqlahacks/sql_maker/sql_maker.t b/t/sqlmaker/core.t
similarity index 96%
rename from t/sqlahacks/sql_maker/sql_maker.t
rename to t/sqlmaker/core.t
index ec137e1..2cf88ba 100644
--- a/t/sqlahacks/sql_maker/sql_maker.t
+++ b/t/sqlmaker/core.t
@@ -69,7 +69,7 @@ my $sql_maker = $schema->storage->sql_maker;
   );
 }
 
-# Make sure the carp/croak override in SQLA works (via SQLAHacks)
+# Make sure the carp/croak override in SQLA works (via SQLMaker)
 my $file = quotemeta (__FILE__);
 throws_ok (sub {
   $schema->resultset ('Artist')->search ({}, { order_by => { -asc => 'stuff', -desc => 'staff' } } )->as_query;
diff --git a/t/sqlahacks/sql_maker/sql_maker_quote.t b/t/sqlmaker/core_quoted.t
similarity index 100%
rename from t/sqlahacks/sql_maker/sql_maker_quote.t
rename to t/sqlmaker/core_quoted.t
diff --git a/t/sqlmaker/limit_dialects/custom.t b/t/sqlmaker/limit_dialects/custom.t
new file mode 100644
index 0000000..4a78951
--- /dev/null
+++ b/t/sqlmaker/limit_dialects/custom.t
@@ -0,0 +1,50 @@
+use strict;
+use warnings;
+
+use Test::More;
+
+use lib qw(t/lib);
+use DBICTest::Schema;
+use DBIC::SqlMakerTest;
+
+# This is legacy stuff from SQL::Absract::Limit
+# Keep it around just in case someone is using it
+
+{
+  package DBICTest::SQLMaker::CustomDialect;
+  use base qw/DBIx::Class::SQLMaker/;
+  sub emulate_limit {
+    my ($self, $sql, $rs_attrs, $limit, $offset) = @_;
+    return sprintf ('shiny sproc ((%s), %d, %d)',
+      $sql,
+      $limit || 0,
+      $offset || 0,
+    );
+  }
+}
+
+my $s = DBICTest::Schema->connect ('dbi:SQLite::memory:');
+$s->storage->sql_maker_class ('DBICTest::SQLMaker::CustomDialect');
+
+my $rs = $s->resultset ('CD');
+is_same_sql_bind (
+  $rs->search ({}, { rows => 1, offset => 3,columns => [
+      { id => 'foo.id' },
+      { 'bar.id' => 'bar.id' },
+      { bleh => \ 'TO_CHAR (foo.womble, "blah")' },
+    ]})->as_query,
+  '(
+    shiny sproc (
+      (
+        SELECT foo.id, bar.id, TO_CHAR (foo.womble, "blah")
+          FROM cd me
+      ),
+      1,
+      3
+    )
+  )',
+  [],
+  'Rownum subsel aliasing works correctly'
+);
+
+done_testing;
diff --git a/t/sqlahacks/limit_dialects/generic_subq.t b/t/sqlmaker/limit_dialects/generic_subq.t
similarity index 100%
rename from t/sqlahacks/limit_dialects/generic_subq.t
rename to t/sqlmaker/limit_dialects/generic_subq.t
diff --git a/t/sqlahacks/limit_dialects/rno.t b/t/sqlmaker/limit_dialects/rno.t
similarity index 100%
rename from t/sqlahacks/limit_dialects/rno.t
rename to t/sqlmaker/limit_dialects/rno.t
diff --git a/t/sqlahacks/limit_dialects/rownum.t b/t/sqlmaker/limit_dialects/rownum.t
similarity index 100%
rename from t/sqlahacks/limit_dialects/rownum.t
rename to t/sqlmaker/limit_dialects/rownum.t
diff --git a/t/sqlahacks/limit_dialects/toplimit.t b/t/sqlmaker/limit_dialects/toplimit.t
similarity index 100%
rename from t/sqlahacks/limit_dialects/toplimit.t
rename to t/sqlmaker/limit_dialects/toplimit.t
diff --git a/t/sqlahacks/oracle.t b/t/sqlmaker/oracle.t
similarity index 94%
rename from t/sqlahacks/oracle.t
rename to t/sqlmaker/oracle.t
index 67a908e..6b9e6f9 100644
--- a/t/sqlahacks/oracle.t
+++ b/t/sqlmaker/oracle.t
@@ -6,7 +6,7 @@ use Test::Exception;
 use Data::Dumper::Concise;
 use lib qw(t/lib);
 use DBIC::SqlMakerTest;
-use DBIx::Class::SQLAHacks::Oracle;
+use DBIx::Class::SQLMaker::Oracle;
 
 # 
 #  Offline test for connect_by 
@@ -52,8 +52,8 @@ my @handle_tests = (
     # TODO: NOCYCLE parameter doesn't work
 );
 
-my $sqla_oracle = DBIx::Class::SQLAHacks::Oracle->new( quote_char => '"', name_sep => '.' );
-isa_ok($sqla_oracle, 'DBIx::Class::SQLAHacks::Oracle');
+my $sqla_oracle = DBIx::Class::SQLMaker::Oracle->new( quote_char => '"', name_sep => '.' );
+isa_ok($sqla_oracle, 'DBIx::Class::SQLMaker::Oracle');
 
 
 for my $case (@handle_tests) {
diff --git a/t/sqlahacks/oraclejoin.t b/t/sqlmaker/oraclejoin.t
similarity index 95%
rename from t/sqlahacks/oraclejoin.t
rename to t/sqlmaker/oraclejoin.t
index 83c8332..53ba94c 100644
--- a/t/sqlahacks/oraclejoin.t
+++ b/t/sqlmaker/oraclejoin.t
@@ -4,11 +4,11 @@ use warnings;
 use Test::More;
 
 use lib qw(t/lib);
-use DBIx::Class::SQLAHacks::OracleJoins;
+use DBIx::Class::SQLMaker::OracleJoins;
 use DBICTest;
 use DBIC::SqlMakerTest;
 
-my $sa = new DBIx::Class::SQLAHacks::OracleJoins;
+my $sa = new DBIx::Class::SQLMaker::OracleJoins;
 
 # search with undefined or empty $cond
 
diff --git a/t/sqlahacks/order_by_func.t b/t/sqlmaker/order_by_func.t
similarity index 100%
rename from t/sqlahacks/order_by_func.t
rename to t/sqlmaker/order_by_func.t
diff --git a/t/sqlahacks/quotes/quotes.t b/t/sqlmaker/quotes/quotes.t
similarity index 100%
rename from t/sqlahacks/quotes/quotes.t
rename to t/sqlmaker/quotes/quotes.t
diff --git a/t/sqlahacks/quotes/quotes_newstyle.t b/t/sqlmaker/quotes/quotes_newstyle.t
similarity index 100%
rename from t/sqlahacks/quotes/quotes_newstyle.t
rename to t/sqlmaker/quotes/quotes_newstyle.t
diff --git a/t/sqlahacks/sqlite.t b/t/sqlmaker/sqlite.t
similarity index 100%
rename from t/sqlahacks/sqlite.t
rename to t/sqlmaker/sqlite.t
diff --git a/xt/podcoverage.t b/xt/podcoverage.t
index 18df9cf..7f45665 100644
--- a/xt/podcoverage.t
+++ b/xt/podcoverage.t
@@ -113,9 +113,10 @@ my $exceptions = {
 
 # test some specific components whose parents are exempt below
     'DBIx::Class::Relationship::Base'               => {},
+    'DBIx::Class::SQLMaker::LimitDialects'          => {},
 
 # internals
-    'DBIx::Class::SQLAHacks*'                       => { skip => 1 },
+    'DBIx::Class::SQLMaker*'                        => { skip => 1 },
     'DBIx::Class::Storage::DBI*'                    => { skip => 1 },
     'SQL::Translator::*'                            => { skip => 1 },