sequel 3.21.0 → 3.31.0

data/lib/sequel/adapters/shared/postgres.rb

@@ -241,16 +241,6 @@ module Sequel
         self << drop_language_sql(name, opts)
       end
       
-      # Remove the cached entries for primary keys and sequences when dropping a table.
-      def drop_table(*names)
-        names.each do |name|
-          name = quote_schema_table(name)
-          @primary_keys.delete(name)
-          @primary_key_sequences.delete(name)
-        end
-        super
-      end
-
       # Drops a trigger from the database.  Arguments:
       # * table : table from which to drop the trigger
       # * name : name of the trigger to drop
@@ -294,6 +284,16 @@ module Sequel
         dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
       end
       
+      # Notifies the given channel.  See the PostgreSQL NOTIFY documentation. Options:
+      #
+      # :payload :: The payload string to use for the NOTIFY statement.  Only supported
+      #             in PostgreSQL 9.0+.
+      # :server :: The server to which to send the NOTIFY statement, if the sharding support
+      #            is being used.
+      def notify(channel, opts={})
+        execute_ddl("NOTIFY #{channel}#{", #{literal(opts[:payload].to_s)}" if opts[:payload]}", opts)
+      end
+
       # Return primary key for the given table.
       def primary_key(table, opts={})
         quoted_table = quote_schema_table(table)
@@ -345,8 +345,11 @@ module Sequel
           (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
-          m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
-          @server_version = (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+          @server_version = if m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
+            (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+          else
+            0
+          end
         end
         @server_version
       end
@@ -358,6 +361,11 @@ module Sequel
         @supports_prepared_transactions = self['SHOW max_prepared_transactions'].get.to_i > 0
       end
 
+      # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
+      def supports_create_table_if_not_exists?
+        server_version >= 90100
+      end
+
       # PostgreSQL supports savepoints
       def supports_savepoints?
         true
@@ -368,30 +376,24 @@ module Sequel
         true
       end
 
-      # Whether the given table exists in the database
+      # Array of symbols specifying table names in the current database.
+      # The dataset used is yielded to the block if one is provided,
+      # otherwise, an array of symbols of table names is returned.  
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def table_exists?(table, opts={})
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
-        opts[:schema] ||= schema
-        tables(opts){|ds| !ds.first(:relname=>im.call(table)).nil?}
+      def tables(opts={}, &block)
+        pg_class_relname('r', opts, &block)
       end
-      
-      # Array of symbols specifying table names in the current database.
-      # The dataset used is yielded to the block if one is provided,
-      # otherwise, an array of symbols of table names is returned.  
+
+      # Array of symbols specifying view names in the current database.
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def tables(opts={})
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
-        ds = filter_schema(ds, opts)
-        m = output_identifier_meth
-        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      def views(opts={})
+        pg_class_relname('v', opts)
       end
 
       private
@@ -399,8 +401,8 @@ module Sequel
       # If the :prepare option is given and we aren't in a savepoint,
       # prepare the transaction for a two-phase commit.
       def commit_transaction(conn, opts={})
-        if opts[:prepare] && Thread.current[:sequel_transaction_depth] <= 1
-          log_connection_execute(conn, "PREPARE TRANSACTION #{literal(opts[:prepare])}")
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+          log_connection_execute(conn, "PREPARE TRANSACTION #{literal(s)}")
         else
           super
         end
@@ -454,11 +456,6 @@ module Sequel
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
-      # Always CASCADE the table drop
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)} CASCADE"
-      end
-      
       # SQL for dropping a trigger from the database.
       def drop_trigger_sql(table, name, opts={})
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
@@ -499,7 +496,7 @@ module Sequel
         filter = " WHERE #{filter_expr(filter)}" if filter
         case index_type
         when :full_text
-          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{dataset.send(:full_text_string_join, cols)}))"
+          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(dataset.send(:full_text_string_join, cols))}))"
           index_type = :gin
         when :spatial
           index_type = :gist
@@ -540,12 +537,29 @@ module Sequel
         conn.execute(sql)
       end
       
+      # Backbone of the tables and views support.
+      def pg_class_relname(type, opts)
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
+        ds = filter_schema(ds, opts)
+        m = output_identifier_meth
+        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      end
+
       # Use a dollar sign instead of question mark for the argument
       # placeholder.
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER
       end
       
+      # Remove the cached entries for primary keys and sequences when a table is
+      # changed.
+      def remove_cached_schema(table)
+        tab = quote_schema_table(table)
+        @primary_keys.delete(tab)
+        @primary_key_sequences.delete(tab)
+        super
+      end
+
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
       # a rename table operation, so speciying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)
@@ -560,13 +574,14 @@ module Sequel
 
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        m2 = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
         ds = metadata_dataset.select(:pg_attribute__attname___name,
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key),
+            :pg_namespace__nspname).
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
@@ -578,7 +593,16 @@ module Sequel
           filter(:pg_class__relname=>m2.call(table_name)).
           order(:pg_attribute__attnum)
         ds = filter_schema(ds, opts)
+        current_schema = nil
         ds.map do |row|
+          sch = row.delete(:nspname)
+          if current_schema
+            if sch != current_schema
+              raise Error, "columns from tables in two separate schema were returned (please specify a schema): #{current_schema.inspect}, #{sch.inspect}"
+            end
+          else
+            current_schema = sch
+          end
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = schema_column_type(row[:db_type])
           [m.call(row.delete(:name)), row]
@@ -627,35 +651,59 @@ module Sequel
       BOOL_FALSE = 'false'.freeze
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from using where')
+      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with delete from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values')
+      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'insert into columns values returning')
+      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with insert into columns values returning')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
-      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with distinct columns from join where group having window compounds order limit lock')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
+      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having window compounds order limit lock')
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set from where')
+      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with update table set from where returning')
+      SPACE = Dataset::SPACE
+      FROM = Dataset::FROM
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      COMMA = Dataset::COMMA
+      AS = Dataset::AS
+      XOR_OP = ' # '.freeze
+      CRLF = "\r\n".freeze
+      BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
+      WINDOW = " WINDOW ".freeze
+      EMPTY_STRING = ''.freeze
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
+        def run(&block)
+          if @prepared_type == :insert && supports_insert_select?
+            fetch_rows(prepared_sql){|r| return r.values.first}
+          else
+            super
+          end
+        end
+
         def prepared_sql
           return @prepared_sql if @prepared_sql
+          @opts[:returning] = insert_pk if @prepared_type == :insert && supports_insert_select?
           super
-          if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
-            @prepared_sql = insert_returning_pk_sql(*@prepared_modify_values)
-            meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
-          end
           @prepared_sql
         end
       end
@@ -677,10 +725,16 @@ module Sequel
       
       # Handle converting the ruby xor operator (^) into the
       # PostgreSQL xor operator (#).
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :^
-          "(#{literal(args.at(0))} # #{literal(args.at(1))})"
+          j = XOR_OP
+          c = false
+          args.each do |a|
+            sql << j if c
+            literal_append(sql, a)
+            c ||= true
+          end
         else
           super
         end
@@ -693,7 +747,7 @@ module Sequel
 
       # Return the results of an EXPLAIN query as a string
       def explain(opts={})
-        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join("\r\n")
+        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
       end
       
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
@@ -705,29 +759,34 @@ module Sequel
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
         lang = opts[:language] || 'simple'
-        filter("to_tsvector(#{literal(lang)}, #{full_text_string_join(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
+        terms = terms.join(' | ') if terms.is_a?(Array)
+        filter("to_tsvector(?, ?) @@ to_tsquery(?, ?)", lang, full_text_string_join(cols), lang, terms)
       end
       
       # Insert given values into the database.
-      def insert(*values)
-        if @opts[:sql]
-          execute_insert(insert_sql(*values))
-        elsif @opts[:disable_insert_returning] || server_version < 80200
-          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
+      def insert(*values, &block)
+        if @opts[:returning]
+          super
+        elsif !@opts[:sql] && supports_insert_select?
+          returning(insert_pk).insert(*values){|r| return r.values.first}
+        elsif (f = opts[:from]) && !f.empty?
+          v = if values.size == 1
+            values.first
+          elsif values.size == 2 && values.all?{|v0| v0.is_a?(Array)}
+            Hash[*values.first.zip(values.last).flatten]
+          else
+            values
+          end
+          execute_insert(insert_sql(*values), :table=>f.first, :values=>v)
         else
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
+          super
         end
       end
 
-      # Use the RETURNING clause to return the columns listed in returning.
-      def insert_returning_sql(returning, *values)
-        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
-      end
-
       # Insert a record returning the record inserted
       def insert_select(*values)
-        return if opts[:disable_insert_returning] || server_version < 80200
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
+        return unless supports_insert_select?
+        returning.insert(*values){|r| return r}
       end
 
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
@@ -749,9 +808,17 @@ module Sequel
         return super if server_version < 80200
         
         # postgresql 8.2 introduces support for multi-row insert
-        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
       end
       
+      # PostgreSQL supports using the WITH clause in subqueries if it
+      # supports using WITH at all (i.e. on PostgreSQL 8.4+).
+      def supports_cte_in_subqueries?
+        supports_cte?
+      end
+
       # DISTINCT ON is a PostgreSQL extension
       def supports_distinct_on?
         true
@@ -762,6 +829,14 @@ module Sequel
         true
       end
 
+      def supports_returning?(type)
+        if type == :insert
+          server_version >= 80200 && !opts[:disable_insert_returning]
+        else
+          server_version >= 80200
+        end
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -777,16 +852,40 @@ module Sequel
         clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
       
+      protected
+
+      # If returned primary keys are requested, use RETURNING unless already set on the
+      # dataset.  If RETURNING is already set, use existing returning values.  If RETURNING
+      # is only set to return a single columns, return an array of just that column.
+      # Otherwise, return an array of hashes.
+      def _import(columns, values, opts={})
+        if server_version >= 80200
+          if opts[:return] == :primary_key && !@opts[:returning]
+            returning(insert_pk)._import(columns, values, opts)
+          elsif @opts[:returning]
+            statements = multi_insert_sql(columns, values)
+            @db.transaction(opts.merge(:server=>@opts[:server])) do
+              statements.map{|st| returning_fetch_rows(st)}
+            end.first.map{|v| v.length == 1 ? v.values.first : v}
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
       private
       
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
-        DELETE_CLAUSE_METHODS
+        server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
       end 
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
-        sql << " FROM #{source_list(@opts[:from][0..0])}"
+        sql << FROM
+        source_list_append(sql, @opts[:from][0..0])
       end
 
       # Use USING to specify additional tables in a delete query
@@ -794,26 +893,38 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
-      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
-      def insert_returning_pk_sql(*values)
+      # PostgreSQL allows a RETURNING clause.
+      def insert_clause_methods
+        if server_version >= 90100
+          INSERT_CLAUSE_METHODS_91
+        elsif server_version >= 80200
+          INSERT_CLAUSE_METHODS_82
+        else
+          INSERT_CLAUSE_METHODS
+        end
+      end
+
+      # Return the primary key to use for RETURNING in an INSERT statement
+      def insert_pk
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
+        pk ? Sequel::SQL::Identifier.new(pk) : NULL
       end
-      
+
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.
       def join_from_sql(type, sql)
         if(from = @opts[:from][1..-1]).empty?
           raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
         else
-          sql << " #{type} #{source_list(from)}"
+          sql << SPACE << type.to_s << SPACE
+          source_list_append(sql, from)
           select_join_sql(sql)
         end
       end
 
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
-      def literal_blob(v)
-        "'#{v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
+      def literal_blob_append(sql, v)
+        sql << APOS << v.gsub(BLOB_RE){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << APOS
       end
 
       # PostgreSQL uses FALSE for false values
@@ -822,8 +933,8 @@ module Sequel
       end
 
       # Assume that SQL standard quoting is on, per Sequel's defaults
-      def literal_string(v)
-        "'#{v.gsub("'", "''")}'"
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
       end
 
       # PostgreSQL uses FALSE for false values
@@ -836,6 +947,14 @@ module Sequel
         server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
       end
       
+      # PostgreSQL requires parentheses around compound datasets if they use
+      # CTEs, and using them in other places doesn't hurt.
+      def compound_dataset_sql_append(sql, ds)
+        sql << PAREN_OPEN
+        super
+        sql << PAREN_CLOSE
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super
@@ -843,14 +962,26 @@ module Sequel
 
       # SQL fragment for named window specifications
       def select_window_sql(sql)
-        sql << " WINDOW #{@opts[:window].map{|name, window| "#{literal(name)} AS #{literal(window)}"}.join(', ')}" if @opts[:window]
+        if ws = @opts[:window]
+          sql << WINDOW
+          c = false
+          co = COMMA
+          as = AS
+          ws.map do |name, window| 
+            sql << co if c
+            literal_append(sql, name)
+            sql << as
+            literal_append(sql, window)
+            c ||= true
+          end
+        end
       end
       
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
         opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
       end
-      
+
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])
@@ -858,15 +989,15 @@ module Sequel
 
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
-        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}
-        cols = cols.zip([' '] * cols.length).flatten
+        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}
+        cols = cols.zip([SPACE] * cols.length).flatten
         cols.pop
-        literal(SQL::StringExpression.new(:'||', *cols))
+        SQL::StringExpression.new(:'||', *cols)
       end
 
       # PostgreSQL splits the main table from the joined tables
       def update_clause_methods
-        UPDATE_CLAUSE_METHODS
+        server_version >= 90100 ? UPDATE_CLAUSE_METHODS_91 : UPDATE_CLAUSE_METHODS
       end
 
       # Use FROM to specify additional tables in an update query
@@ -876,7 +1007,8 @@ module Sequel
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
-        sql << " #{source_list(@opts[:from][0..0])}"
+        sql << SPACE
+        source_list_append(sql, @opts[:from][0..0])
       end
     end
   end

data/lib/sequel/adapters/shared/progress.rb

@@ -6,12 +6,6 @@ module Sequel
       def database_type
         :progress
       end
-
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
     end
   
     module DatasetMethods
@@ -37,7 +31,10 @@ module Sequel
       # The Progress adapter targets Progress 9, so it silently ignores the option.
       def select_limit_sql(sql)
         raise(Error, "OFFSET not supported") if @opts[:offset]
-        #sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+        # if l = @opts[:limit]
+        #   sql << " TOP "
+        #   literal_append(sql, l)
+        # end
       end
     end
   end