sequel 3.27.0 → 3.28.0

data/lib/sequel/adapters/jdbc/as400.rb

@@ -88,13 +88,6 @@ module Sequel
         def supports_window_functions?
           true
         end
-          
-        private
-        
-        # The alias to use for the row_number column when emulating LIMIT and OFFSET
-        def row_number_column
-          :x_sequel_row_number_x
-        end
       end
     end
   end

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

@@ -0,0 +1,49 @@
+Sequel.require 'adapters/shared/db2'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    class Database
+      # Alias the generic JDBC versions so they can be called directly later
+      alias jdbc_schema_parse_table schema_parse_table
+      alias jdbc_tables tables
+      alias jdbc_views views
+      alias jdbc_indexes indexes
+    end
+    
+    # Database and Dataset instance methods for DB2 specific
+    # support via JDBC.
+    module DB2
+      # Database instance methods for DB2 databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::DB2::DatabaseMethods
+        include Sequel::JDBC::Transactions
+        
+        # Return instance of Sequel::JDBC::DB2::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::DB2::Dataset.new(self, opts)
+        end
+        
+        %w'schema_parse_table tables views indexes'.each do |s|
+          class_eval("def #{s}(*a) jdbc_#{s}(*a) end", __FILE__, __LINE__)
+        end
+
+        private
+        
+        def last_insert_id(conn, opts={})
+          statement(conn) do |stmt|
+            sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          end
+        end
+      end
+      
+      # Dataset class for DB2 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::DB2::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/firebird.rb

@@ -0,0 +1,34 @@
+Sequel.require 'adapters/shared/firebird'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for Firebird specific
+    # support via JDBC.
+    module Firebird
+      # Database instance methods for Firebird databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Firebird::DatabaseMethods
+        include Sequel::JDBC::Transactions
+        
+        # Add the primary_keys and primary_key_sequences instance variables,
+        # so we can get the correct return values for inserted rows.
+        def self.extended(db)
+          db.instance_eval do
+            @primary_keys = {}
+          end
+        end
+        
+        # Return instance of Sequel::JDBC::Firebird::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Firebird::Dataset.new(self, opts)
+        end
+      end
+      
+      # Dataset class for Firebird datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Firebird::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/shared/oracle'
+Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
@@ -7,38 +8,12 @@ module Sequel
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+        include Sequel::JDBC::Transactions
         
         # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::Oracle::Dataset.new(self, opts)
         end
-        
-        private
-        
-        # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts={})
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-          conn
-        end
-        
-        # Use JDBC connection's commit method to commit transactions
-        def commit_transaction(conn, opts={})
-          log_yield(TRANSACTION_COMMIT){conn.commit}
-        end
-        
-        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
-        def remove_transaction(conn)
-          conn.setAutoCommit(true) if conn
-          @transactions.delete(Thread.current)
-        end
-        
-        # Use JDBC connection's rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
-        end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.

data/lib/sequel/adapters/jdbc/transactions.rb

@@ -0,0 +1,34 @@
+module Sequel
+  module JDBC
+    module Transactions
+      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+
+      private
+
+      # Use JDBC connection's setAutoCommit to false to start transactions
+      def begin_transaction(conn, opts={})
+        log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+        conn
+      end
+      
+      # Use JDBC connection's commit method to commit transactions
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){conn.commit}
+      end
+      
+      # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+      def remove_transaction(conn)
+        conn.setAutoCommit(true) if conn
+        @transactions.delete(Thread.current)
+      end
+      
+      # Use JDBC connection's rollback method to rollback transactions
+      def rollback_transaction(conn, opts={})
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+      end
+    end
+  end
+end
+

data/lib/sequel/adapters/mysql.rb

@@ -12,25 +12,20 @@ module Sequel
   module MySQL
     TYPE_TRANSLATOR = tt = Class.new do
       def boolean(s) s.to_i != 0 end
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-      def decimal(s) ::BigDecimal.new(s) end
-      def date(s) ::Sequel.string_to_date(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
-      def date_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
-      def time_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
-      def timestamp_conv(s) ::Sequel::MySQL.convert_date_time(:database_to_application_timestamp, s) end
+      def date(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
+      def time(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
+      def timestamp(s) ::Sequel::MySQL.convert_date_time(:database_to_application_timestamp, s) end
     end.new
 
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
     {
-      [0, 246]  => tt.method(:decimal),
-      [2, 3, 8, 9, 13, 247, 248]  => tt.method(:integer),
-      [4, 5]  => tt.method(:float),
-      [249, 250, 251, 252]  => tt.method(:blob)
+      [0, 246] => ::BigDecimal.method(:new),
+      [2, 3, 8, 9, 13, 247, 248] => tt.method(:integer),
+      [4, 5] => tt.method(:float),
+      [249, 250, 251, 252] => ::Sequel::SQL::Blob.method(:new)
     }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
@@ -54,10 +49,10 @@ module Sequel
     # Modify the type translators for the date, time, and timestamp types
     # depending on the value given.
     def self.convert_invalid_date_time=(v)
-      MYSQL_TYPES[11] = TYPE_TRANSLATOR.method(v == false ? :time : :time_conv)
-      m = TYPE_TRANSLATOR.method(v == false ? :date : :date_conv)
+      MYSQL_TYPES[11] = (v != false) ?  TYPE_TRANSLATOR.method(:time) : ::Sequel.method(:string_to_time)
+      m = (v != false) ? TYPE_TRANSLATOR.method(:date) : ::Sequel.method(:string_to_date)
       [10, 14].each{|i| MYSQL_TYPES[i] = m}
-      m = TYPE_TRANSLATOR.method(v == false ? :timestamp : :timestamp_conv)
+      m = (v != false) ? TYPE_TRANSLATOR.method(:timestamp) : ::Sequel.method(:database_to_application_timestamp)
       [7, 12].each{|i| MYSQL_TYPES[i] = m}
       @convert_invalid_date_time = v
     end

data/lib/sequel/adapters/odbc.rb

@@ -128,8 +128,7 @@ module Sequel
         when ::ODBC::TimeStamp
           Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
-          now = ::Time.now
-          Sequel::SQLTime.local(now.year, now.month, now.day, v.hour, v.minute, v.second)
+          Sequel::SQLTime.create(v.hour, v.minute, v.second)
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else

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

@@ -1,20 +1,20 @@
+Sequel.require 'adapters/shared/db2'
+
 module Sequel
   module ODBC
     # Database and Dataset instance methods for DB2 specific
     # support via ODBC.
     module DB2
       module DatabaseMethods
+        include ::Sequel::DB2::DatabaseMethods
+
         def dataset(opts=nil)
           Sequel::ODBC::DB2::Dataset.new(self, opts)
         end
       end
       
       class Dataset < ODBC::Dataset
-        def select_limit_sql(sql)
-          if l = @opts[:limit]
-            sql << " FETCH FIRST #{l == 1 ? 'ROW' : "#{literal(l)} ROWS"} ONLY"
-          end
-        end
+        include ::Sequel::DB2::DatasetMethods
       end
     end
   end

data/lib/sequel/adapters/postgres.rb

@@ -93,11 +93,7 @@ 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.
@@ -112,9 +108,9 @@ 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),
+      [1114, 1184] => ::Sequel.method(:database_to_application_timestamp)
     }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
@@ -128,7 +124,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
@@ -244,6 +240,70 @@ module Sequel
         conn
       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 support 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
+      end
+        
       # Return instance of Sequel::Postgres::Dataset with the given options.
       def dataset(opts = nil)
         Postgres::Dataset.new(self, opts)
@@ -411,6 +471,7 @@ module Sequel
         # Allow use of bind arguments for PostgreSQL using the pg driver.
         module BindArgumentMethods
           include ArgumentMapper
+          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -434,7 +495,6 @@ module Sequel
         # pg driver.
         module PreparedStatementMethods
           include BindArgumentMethods
-          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
           
           private
           
@@ -461,7 +521,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)

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

@@ -0,0 +1,290 @@
+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
+        im = input_identifier_meth
+        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 :&, :|, :^, :'B~'
+          # works with db2 v9.5 and after
+          literal(SQL::Function.new(BITWISE_METHOD_MAP[op], *args))
+        when :<<
+          "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
+        when :>>
+          "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+        when :extract
+          "#{args.at(0)}(#{literal(args.at(1))})"
+        else
+          super
+        end
+      end
+
+      # Delete the row_number_column if offsets are being emulated with
+      # ROW_NUMBER.
+      def fetch_rows(sql, &block)
+        @opts[:offset] ? super(sql){|r| r.delete(row_number_column); yield r} : super(sql, &block)
+      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 uses "INSERT INTO "ITEMS" VALUES DEFAULT" for a record with default values to be inserted
+      def insert_values_sql(sql)
+        opts[:values].empty? ? sql << " VALUES DEFAULT" : super
+      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