sequel 3.21.0 → 3.29.0

data/lib/sequel/adapters/postgres.rb

@@ -93,13 +93,14 @@ module Sequel
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-      def numeric(s) ::BigDecimal.new(s) end
-      def date(s) ::Sequel.string_to_date(s) end
-      def date_iso(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
+      def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
     end.new
 
+    # Hash with type name symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {}
+
     # Hash with integer keys and callable values for converting PostgreSQL types.
     PG_TYPES = {}
     {
@@ -107,9 +108,8 @@ module Sequel
       [17] => tt.method(:bytea),
       [20, 21, 22, 23, 26] => tt.method(:integer),
       [700, 701] => tt.method(:float),
-      [790, 1700] => tt.method(:numeric),
-      [1083, 1266] => tt.method(:time),
-      [1114, 1184] => tt.method(:timestamp)
+      [790, 1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
@@ -123,7 +123,7 @@ module Sequel
 
     # Modify the type translator for the date type depending on the value given.
     def self.use_iso_date_format=(v)
-      PG_TYPES[1082] = TYPE_TRANSLATOR.method(v ? :date_iso : :date)
+      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
       @use_iso_date_format = v
     end
     self.use_iso_date_format = true
@@ -131,7 +131,10 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
+      DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
+      
       include Sequel::Postgres::AdapterMethods
+
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -150,20 +153,23 @@ module Sequel
         end
         @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
       end
-      
+
       # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
       # the connection status cannot be determined or it is not OK.
       def check_disconnect_errors
         begin
           yield
         rescue PGError =>e
+          disconnect = false
           begin
             s = status
           rescue PGError
-            raise Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)
+            disconnect = true
           end
           status_ok = (s == Adapter::CONNECTION_OK)
-          status_ok ? raise : raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+          disconnect ||= !status_ok
+          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
         ensure
           block if status_ok
         end
@@ -176,7 +182,7 @@ module Sequel
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
-          q.clear
+          q.clear if q
         end
       end
 
@@ -194,6 +200,10 @@ module Sequel
       include Sequel::Postgres::DatabaseMethods
       
       set_adapter_scheme :postgres
+
+      # A hash of conversion procs, keyed by type integer (oid) and
+      # having callable values for the conversion proc for that type.
+      attr_reader :conversion_procs
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
@@ -225,14 +235,10 @@ module Sequel
         end
         conn.db = self
         conn.apply_connection_settings
+        @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
       
-      # Return instance of Sequel::Postgres::Dataset with the given options.
-      def dataset(opts = nil)
-        Postgres::Dataset.new(self, opts)
-      end
-      
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts={}, &block)
         check_database_errors do
@@ -253,6 +259,119 @@ module Sequel
         end
       end
       
+      if SEQUEL_POSTGRES_USES_PG
+        # +copy_table+ uses PostgreSQL's +COPY+ SQL statement to return formatted
+        # results directly to the caller.  This method is only supported if pg is the
+        # underlying ruby driver.  This method should only be called if you want
+        # results returned to the client.  If you are using +COPY FROM+ or +COPY TO+
+        # with a filename, you should just use +run+ instead of this method.  This
+        # method does not currently support +COPY FROM STDIN+, but that may be supported
+        # in the future.
+        #
+        # The table argument supports the following types:
+        #
+        # String :: Uses the first argument directly as literal SQL. If you are using
+        #           a version of PostgreSQL before 9.0, you will probably want to
+        #           use a string if you are using any options at all, as the syntax
+        #           Sequel uses for options is only compatible with PostgreSQL 9.0+.
+        # Dataset :: Uses a query instead of a table name when copying.
+        # other :: Uses a table name (usually a symbol) when copying.
+        # 
+        # The following options are respected:
+        #
+        # :format :: The format to use.  text is the default, so this should be :csv or :binary.
+        # :options :: An options SQL string to use, which should contain comma separated options.
+        # :server :: The server on which to run the query.
+        #
+        # If a block is provided, the method continually yields to the block, one yield
+        # per row.  If a block is not provided, a single string is returned with all
+        # of the data.
+        def copy_table(table, opts={})
+          sql = if table.is_a?(String)
+            sql = table
+          else
+            if opts[:options] || opts[:format]
+              options = " ("
+              options << "FORMAT #{opts[:format]}" if opts[:format]
+              options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+              options << ')'
+            end
+            table = if table.is_a?(::Sequel::Dataset)
+              "(#{table.sql})"
+            else
+              literal(table)
+            end
+           sql = "COPY #{table} TO STDOUT#{options}"
+          end
+          synchronize(opts[:server]) do |conn| 
+            conn.execute(sql)
+            begin
+              if block_given?
+                while buf = conn.get_copy_data
+                  yield buf
+                end
+                nil
+              else
+                b = ''
+                b << buf while buf = conn.get_copy_data
+                b
+              end
+            ensure
+              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+            end
+          end 
+        end
+
+        # Listens on the given channel (or multiple channels if channel is an array), waiting for notifications.
+        # After a notification is received, or the timeout has passed, stops listening to the channel. Options:
+        #
+        # :after_listen :: An object that responds to +call+ that is called with the underlying connection after the LISTEN
+        #                  statement is sent, but before the connection starts waiting for notifications.
+        # :loop :: Whether to continually wait for notifications, instead of just waiting for a single
+        #          notification. If this option is given, a block must be provided.  If this object responds to call, it is
+        #          called with the underlying connection after each notification is received (after the block is called).
+        #          If a :timeout option is used, and a callable object is given, the object will also be called if the
+        #          timeout expires.  If :loop is used and you want to stop listening, you can either break from inside the
+        #          block given to #listen, or you can throw :stop from inside the :loop object's call method or the block.
+        # :server :: The server on which to listen, if the sharding support is being used.
+        # :timeout :: How long to wait for a notification, in seconds (can provide a float value for
+        #             fractional seconds).  If not given or nil, waits indefinitely.
+        #
+        # This method is only supported if pg is used as the underlying ruby driver.  It returns the
+        # channel the notification was sent to (as a string), unless :loop was used, in which case it returns nil.
+        # If a block is given, it is yielded 3 arguments:
+        # * the channel the notification was sent to (as a string)
+        # * the backend pid of the notifier (as an integer),
+        # * and the payload of the notification (as a string or nil).
+        def listen(channels, opts={}, &block)
+          check_database_errors do
+            synchronize(opts[:server]) do |conn|
+              begin
+                channels = Array(channels)
+                channels.each{|channel| conn.execute("LISTEN #{channel}")}
+                opts[:after_listen].call(conn) if opts[:after_listen]
+                timeout = opts[:timeout] ? [opts[:timeout]] : []
+                if l = opts[:loop]
+                  raise Error, 'calling #listen with :loop requires a block' unless block
+                  loop_call = l.respond_to?(:call)
+                  catch(:stop) do
+                    loop do
+                      conn.wait_for_notify(*timeout, &block)
+                      l.call(conn) if loop_call
+                    end
+                  end
+                  nil
+                else
+                  conn.wait_for_notify(*timeout, &block)
+                end
+              ensure
+                conn.execute("UNLISTEN *")
+              end
+            end
+          end
+        end
+      end
+        
       private
       
       # Convert exceptions raised from the block into DatabaseErrors.
@@ -305,12 +424,29 @@ module Sequel
           end
         end
       end
+
+      # Return the conversion procs hash to use for this database
+      def get_conversion_procs(conn)
+        procs = PG_TYPES.dup
+        procs[1114] = method(:to_application_timestamp)
+        procs[1184] = method(:to_application_timestamp)
+        conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
+          res.ntuples.times do |recnum|
+            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).untaint.to_sym]
+              procs[res.getvalue(recnum, 0).to_i] ||= pr
+            end
+          end
+        end
+        procs
+      end
     end
     
     # Dataset class for PostgreSQL datasets that use the pg, postgres, or
     # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -372,11 +508,17 @@ module Sequel
             end
             LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
           end
+
+          # Always assume a prepared argument.
+          def prepared_arg?(k)
+           true
+          end
         end
 
         # Allow use of bind arguments for PostgreSQL using the pg driver.
         module BindArgumentMethods
           include ArgumentMapper
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -400,7 +542,12 @@ module Sequel
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
-          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
+
+          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+          def call(*)
+            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+            super
+          end
           
           private
           
@@ -427,7 +574,7 @@ module Sequel
           ps.extend(BindArgumentMethods)
           ps.call(bind_vars, &block)
         end
-        
+
         # Prepare the given type of statement with the given name, and store
         # it in the database to be called later.
         def prepare(type, name=nil, *values)
@@ -483,8 +630,9 @@ module Sequel
       # field numers, type conversion procs, and name symbol arrays.
       def fetch_rows_set_cols(res)
         cols = []
+        procs = db.conversion_procs
         res.nfields.times do |fieldnum|
-          cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
         @columns = cols.map{|c| c.at(2)}
         cols

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

@@ -1,21 +1,17 @@
 module Sequel
   module Access
     module DatabaseMethods
+      # Access uses type :access as the database_type
       def database_type
         :access
       end
 
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
-
       # Doesn't work, due to security restrictions on MSysObjects
       def tables
         from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
       end
 
+      # Access uses type Counter for an autoincrementing keys
       def serial_primary_key_options
         {:primary_key => true, :type=>:Counter}
       end
@@ -34,16 +30,35 @@ module Sequel
     module DatasetMethods
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
 
+      # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
       private
 
+      # Access uses # to quote dates
+      def literal_date(d)
+        d.strftime('#%Y-%m-%d#')
+      end
+
+      # Access uses # to quote datetimes
+      def literal_datetime(t)
+        t.strftime('#%Y-%m-%d %H:%M:%S#')
+      end
+      alias literal_time literal_datetime
+
+      # Access uses TOP for limits
+      def select_limit_sql(sql)
+        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+      end
+
+      # Access uses [] for quoting identifiers
       def quoted_identifier(v)
         "[#{v}]"
       end
 
+      # Access requires the limit clause come before other clauses
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end

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

@@ -0,0 +1,288 @@
+Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+
+module Sequel
+  module DB2
+    @use_clob_as_blob = true
+
+    class << self
+      # Whether to use clob as the generic File type, true by default.
+      attr_accessor :use_clob_as_blob
+    end
+
+    module DatabaseMethods
+      AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
+      NOT_NULL      = ' NOT NULL'.freeze
+      NULL          = ''.freeze
+
+      # DB2 always uses :db2 as it's database type
+      def database_type
+        :db2
+      end
+      
+      # Return the database version as a string.  Don't rely on this,
+      # it may return an integer in the future.
+      def db2_version
+        return @db2_version if @db2_version
+        @db2_version = metadata_dataset.with_sql("select service_level from sysibmadm.env_inst_info").first[:service_level]
+      end
+      alias_method :server_version, :db2_version
+
+      # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
+      def schema_parse_table(table, opts = {})
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
+        metadata_dataset.with_sql("SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = #{literal(im.call(table))} ORDER BY COLNO").
+          collect do |column| 
+            column[:db_type]     = column.delete(:typename)
+            if column[:db_type]  == "DECIMAL"
+              column[:db_type] << "(#{column[:longlength]},#{column[:scale]})"
+            end
+            column[:allow_null]  = column.delete(:nulls) == 'Y'
+            column[:primary_key] = column.delete(:identity) == 'Y' || !column[:keyseq].nil?
+            column[:type]        = schema_column_type(column[:db_type])
+            [ m.call(column.delete(:name)), column]
+          end
+      end
+
+      # Use SYSCAT.TABLES to get the tables for the database
+      def tables
+        metadata_dataset.
+          with_sql("SELECT TABNAME FROM SYSCAT.TABLES WHERE TYPE='T' AND OWNER = #{literal(input_identifier_meth.call(opts[:user]))}").
+          all.map{|h| output_identifier_meth.call(h[:tabname]) }
+      end
+
+      # Use SYSCAT.TABLES to get the views for the database
+      def views
+        metadata_dataset.
+          with_sql("SELECT TABNAME FROM SYSCAT.TABLES WHERE TYPE='V' AND OWNER = #{literal(input_identifier_meth.call(opts[:user]))}").
+          all.map{|h| output_identifier_meth.call(h[:tabname]) }
+      end
+
+      # Use SYSCAT.INDEXES to get the indexes for the table
+      def indexes(table, opts = {})
+        metadata_dataset.
+          with_sql("SELECT INDNAME,UNIQUERULE,MADE_UNIQUE,SYSTEM_REQUIRED FROM SYSCAT.INDEXES WHERE TABNAME = #{literal(input_identifier_meth.call(table))}").
+          all.map{|h| Hash[ h.map{|k,v| [k.to_sym, v]} ] }
+      end
+
+      private
+
+      # Handle DB2 specific alter table operations.
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          if op[:primary_key] && op[:auto_increment] && op[:type] == Integer
+            [
+            "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op.merge(:auto_increment=>false, :primary_key=>false, :default=>0, :null=>false))}",
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} DROP DEFAULT",
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} SET #{AUTOINCREMENT}"
+            ]
+          else
+            "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+          end
+        when :drop_column
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
+        when :rename_column       # renaming is only possible after db2 v9.7
+          "ALTER TABLE #{quote_schema_table(table)} RENAME COLUMN #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DATA TYPE #{type_literal(op)}"
+        when :set_column_default
+          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DEFAULT #{literal(op[:default])}"
+        when :add_constraint
+          if op[:type] == :unique
+            sqls = op[:columns].map{|c| ["ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(c)} SET NOT NULL", reorg_sql(table)]}
+            sqls << super
+            sqls.flatten
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # DB2 uses an identity column for autoincrement.
+      def auto_increment_sql
+        AUTOINCREMENT
+      end
+
+      # Add null/not null SQL fragment to column creation SQL.
+      def column_definition_null_sql(sql, column)
+        null = column.fetch(:null, column[:allow_null]) 
+        null = false  if column[:primary_key]
+
+        sql << NOT_NULL if null == false
+        sql << NULL if null == true
+      end
+
+      # Supply columns with NOT NULL if they are part of a composite
+      # primary/foreign key
+      def column_list_sql(g)
+        ks = []
+        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :foreign_key].include? c[:type]} 
+        g.columns.each{|c| c[:null] = false if ks.include?(c[:name]) }
+        super
+      end
+
+      # Here we use DGTT which has most backward compatibility, which uses
+      # DECLARE instead of CREATE. CGTT can only be used after version 9.7.
+      # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
+      def create_table_sql(name, generator, options)
+        if options[:temp]
+          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)} (#{column_list_sql(generator)})"
+        else
+          super
+        end
+      end
+
+      # DB2 has issues with quoted identifiers, so
+      # turn off database quoting by default.
+      def quote_identifiers_default
+        false
+      end
+
+      # DB2 uses RENAME TABLE to rename tables.
+      def rename_table_sql(name, new_name)
+        "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
+      end
+
+      # Run the REORG TABLE command for the table, necessary when
+      # the table has been altered.
+      def reorg(table)
+        synchronize(opts[:server]){|c| c.execute(reorg_sql(table))}
+      end
+
+      # The SQL to use for REORGing a table.
+      def reorg_sql(table)
+        "CALL ADMIN_CMD(#{literal("REORG TABLE #{table}")})"
+      end
+
+      # We uses the clob type by default for Files.
+      # Note: if user select to use blob, then insert statement should use 
+      # use this for blob value:
+      #     cast(X'fffefdfcfbfa' as blob(2G))
+      def type_literal_generic_file(column)
+        ::Sequel::DB2::use_clob_as_blob ? :clob : :blob
+      end
+
+      # DB2 uses smallint to store booleans.
+      def type_literal_generic_trueclass(column)
+        :smallint
+      end
+      alias type_literal_generic_falseclass type_literal_generic_trueclass
+    end
+
+    module DatasetMethods
+      include EmulateOffsetWithRowNumber
+
+      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      
+      # DB2 casts strings using RTRIM and CHAR instead of VARCHAR.
+      def cast_sql(expr, type)
+        type == String ?  "RTRIM(CHAR(#{literal(expr)}))" : super
+      end
+
+      # Handle DB2 specific LIKE and bitwise operator support, and
+      # emulate the extract method, which DB2 doesn't natively support.
+      def complex_expression_sql(op, args)
+        case op
+        when :ILIKE
+          super(:LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+        when :"NOT ILIKE"
+          super(:"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+        when :&, :|, :^
+          # works with db2 v9.5 and after
+          op = BITWISE_METHOD_MAP[op]
+          complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
+        when :<<
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+        when :>>
+          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+        when :'B~'
+          literal(SQL::Function.new(:BITNOT, *args))
+        when :extract
+          "#{args.at(0)}(#{literal(args.at(1))})"
+        else
+          super
+        end
+      end
+
+      # DB2 does not support IS TRUE.
+      def supports_is_true?
+        false
+      end
+
+      # DB2 does not support multiple columns in IN.
+      def supports_multiple_column_in?
+        false
+      end
+
+      # DB2 only allows * in SELECT if it is the only thing being selected.
+      def supports_select_all_and_column?
+        false
+      end
+
+      # DB2 does not support fractional seconds in timestamps.
+      def supports_timestamp_usecs?
+        false
+      end
+
+      # DB2 supports window functions
+      def supports_window_functions?
+        true
+      end
+
+      # DB2 does not support WHERE 1.
+      def supports_where_true?
+        false
+      end
+
+      private
+
+      # DB2 needs the standard workaround to insert all default values into
+      # a table with more than one column.
+      def insert_supports_empty_values?
+        false
+      end
+
+      # Use 0 for false on DB2
+      def literal_false
+        BOOL_FALSE
+      end
+
+      # Use 1 for true on DB2
+      def literal_true
+        BOOL_TRUE
+      end
+
+      # Add a fallback table for empty from situation
+      def select_from_sql(sql)
+        @opts[:from] ? super : (sql << ' FROM "SYSIBM"."SYSDUMMY1"')
+      end
+
+      # Modify the sql to limit the number of rows returned
+      # Note: 
+      #
+      #     After db2 v9.7, MySQL flavored "LIMIT X OFFSET Y" can be enabled using
+      #
+      #     db2set DB2_COMPATIBILITY_VECTOR=MYSQL
+      #     db2stop
+      #     db2start
+      #
+      #     Support for this feature is not used in this adapter however.
+      def select_limit_sql(sql)
+        if l = @opts[:limit]
+          sql << " FETCH FIRST #{l == 1 ? 'ROW' : "#{literal(l)} ROWS"} ONLY"
+        end
+      end
+      
+      def _truncate_sql(table)
+        # "TRUNCATE #{table} IMMEDIATE" is only for newer version of db2, so we
+        # use the following one
+        "ALTER TABLE #{quote_schema_table(table)} ACTIVATE NOT LOGGED INITIALLY WITH EMPTY TABLE"
+      end
+    end
+  end
+end