activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/firebird/connection_methods.rb

@@ -0,0 +1,23 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def firebird_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::Firebird
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/firebird'
+      ::Jdbc::Firebird.load_driver(:require)
+    rescue LoadError # assuming driver.jar is on the class-path
+    end
+
+    config[:host] ||= 'localhost'
+    config[:port] ||= 3050
+    config[:url] ||= begin
+      "jdbc:firebirdsql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    end
+    config[:driver] ||= ::Jdbc::Firebird.driver_name
+
+    jdbc_connection(config)
+  end
+  # alias_method :jdbcfirebird_connection, :firebird_connection
+end

data/lib/arjdbc/h2.rb

@@ -1,4 +1,3 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/h2'
-require 'arjdbc/h2/connection_methods'
+require 'arjdbc'
 require 'arjdbc/h2/adapter'
+require 'arjdbc/h2/connection_methods'

data/lib/arjdbc/h2/adapter.rb

@@ -1,36 +1,303 @@
+ArJdbc.load_java_part :H2
 require 'arjdbc/hsqldb/adapter'
+require 'arel/visitors/h2'
 
 module ArJdbc
   module H2
     include HSQLDB
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
     end
 
-    def adapter_name #:nodoc:
-      'H2'
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /\.h2\./i, lambda { |config, column| column.extend(Column) } ]
     end
 
-    def arel2_visitors
-      super.merge 'h2' => ::Arel::Visitors::HSQLDB, 'jdbch2' => ::Arel::Visitors::HSQLDB
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      private
+
+      def extract_limit(sql_type)
+        limit = super
+        case @sql_type = sql_type.downcase
+        # NOTE: JDBC driver f*cks sql_type up with limits (just like HSQLDB) :
+        when /^tinyint/i       then @sql_type = 'tinyint'; limit = 1
+        when /^smallint|int2/i then @sql_type = 'smallint'; limit = 2
+        when /^bigint|int8/i   then @sql_type = 'bigint'; limit = 8
+        when /^int|int4/i      then @sql_type = 'int'; limit = 4
+        when /^double/i        then @sql_type = 'double'; limit = 8
+        when /^real/i          then @sql_type = 'real'; limit = 4
+        when /^date/i          then @sql_type = 'date'; limit = nil
+        when /^timestamp/i     then @sql_type = 'timestamp'; limit = nil
+        when /^time/i          then @sql_type = 'time'; limit = nil
+        when /^boolean/i       then @sql_type = 'boolean'; limit = nil
+        when /^binary|bytea/i; then @sql_type = 'binary'; limit = 2 * 1024 * 1024
+        when /blob|image|oid/i then @sql_type = 'blob'; limit = nil
+        when /clob|text/i      then @sql_type = 'clob'; limit = nil
+        # NOTE: use lower-case due SchemaDumper not handling it's decimal/integer
+        # optimization case-insensitively due : column.type == :integer &&
+        # [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+        when /^decimal\(65535,32767\)/i
+          @sql_type = 'decimal'; nil
+        end
+        limit
+      end
+
+      def simplified_type(field_type)
+        case field_type
+        when /^bit|bool/i         then :boolean
+        when /^signed|year/i      then :integer
+        when /^real|double/i      then :float
+        when /^varchar/i          then :string
+        when /^longvarchar/i      then :text
+        when /^binary|raw|bytea/i then :binary
+        when /varbinary/i         then :binary # longvarbinary, varbinary
+        when /^blob|image|oid/i   then :binary
+        else
+          super
+        end
+      end
+
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # H2 auto-generated key default value
+        return nil if value =~ /^\(NEXT VALUE FOR/i
+        # JDBC returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+        value
+      end
+
     end
 
+    ADAPTER_NAME = 'H2'.freeze
+
+    # @override
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    # @deprecated no longer used. only here for backwards compatibility with 1.2
     def h2_adapter
       true
     end
 
+    NATIVE_DATABASE_TYPES = {
+      # "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
+      :primary_key => "bigint identity",
+      :boolean     => { :name => "boolean" },
+      :tinyint     => { :name => "tinyint", :limit => 1 },
+      :smallint    => { :name => "smallint", :limit => 2 },
+      :bigint      => { :name => "bigint", :limit => 8 },
+      :integer     => { :name => "int", :limit => 4 },
+      :decimal     => { :name => "decimal" }, # :limit => 2147483647
+      :numeric     => { :name => "numeric" }, # :limit => 2147483647
+      :float       => { :name => "float", :limit => 8 },
+      :double      => { :name => "double", :limit => 8 },
+      :real        => { :name => "real", :limit => 4 }, # :limit => 8
+      :date        => { :name => "date" },
+      :time        => { :name => "time" },
+      :timestamp   => { :name => "timestamp" },
+      :datetime    => { :name => "timestamp" },
+      :binary      => { :name => "binary" },
+      :string      => { :name => "varchar", :limit => 255 },
+      :char        => { :name => "char" }, # :limit => 2147483647
+      :blob        => { :name => "blob" },
+      :text        => { :name => "clob" },
+      :clob        => { :name => "clob" },
+      :uuid        => { :name => "uuid" }, # :limit => 2147483647
+      :other       => { :name => "other" }, # java.lang.Object
+      :array       => { :name => "array" }, # java.lang.Object[]
+      # NOTE: would be great if AR allowed as to refactor as :
+      #   t.column :string, :ignorecase => true
+      :varchar_casesensitive => { :name => 'varchar_casesensitive' },
+      :varchar_ignorecase => { :name => 'varchar_ignorecase' },
+      # :identity : { :name=>"identity", :limit => 19 }
+      # :result_set : { :name=>"result_set" }
+    }
+
+    # @override
+    def native_database_types
+      NATIVE_DATABASE_TYPES
+    end
+
+    # @override
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      case type.to_sym
+      when :integer
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when nil, 3, 4; 'int'
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        end
+      when :float
+        case limit
+        when 1..4; 'real'
+        when 5..8; 'double'
+        else raise(ActiveRecordError, "No float type has byte size #{limit}")
+        end
+      when :binary
+        if limit && limit < 2 * 1024 * 1024
+          'binary'
+        else
+          'blob'
+        end
+      else
+        super
+      end
+    end
+
+    # @override
+    def empty_insert_statement_value
+      "VALUES ()"
+    end
+
+    # @override
     def tables
       @connection.tables(nil, h2_schema)
     end
 
-    def columns(table_name, name=nil)
-      @connection.columns_internal(table_name.to_s, name, h2_schema)
+    # @override
+    def columns(table_name, name = nil)
+      @connection.columns_internal(table_name.to_s, nil, h2_schema)
+    end
+
+    # @override
+    def change_column(table_name, column_name, type, options = {})
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
+      change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+      change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+    end
+
+    def current_schema
+      execute('CALL SCHEMA()')[0].values[0]
+    end
+
+    # @override
+    def quote(value, column = nil)
+      case value
+      when String
+        if value.empty?
+          "''"
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    # @override
+    def supports_views?; true end
+
+    # EXPLAIN support :
+
+    # @override
+    def supports_explain?; true end
+
+    # @override
+    def explain(arel, binds = [])
+      sql = "EXPLAIN #{to_sql(arel, binds)}"
+      raw_result = exec_query_raw(sql, "EXPLAIN", binds)
+      raw_result[0].values.join("\n") # [ "SELECT \n ..." ].to_s
+    end
+
+    # @override
+    def structure_dump
+      execute('SCRIPT SIMPLE').map do |result|
+        # [ { 'script' => SQL }, { 'script' ... }, ... ]
+        case sql = result.first[1] # ['script']
+        when /CREATE USER IF NOT EXISTS SA/i then nil
+        else sql
+        end
+      end.compact.join("\n\n")
+    end
+
+    # @see #structure_dump
+    def structure_load(dump)
+      dump.each_line("\n\n") { |ddl| execute(ddl) }
+    end
+
+    def shutdown
+      execute 'SHUTDOWN COMPACT'
+    end
+
+    # @private
+    def recreate_database(name = nil, options = {})
+      drop_database(name)
+      create_database(name, options)
+    end
+
+    # @private
+    def create_database(name = nil, options = {}); end
+
+    # @private
+    def drop_database(name = nil)
+      execute('DROP ALL OBJECTS')
+    end
+
+    # @private
+    def database_path(base_only = false)
+      db_path = jdbc_connection(true).getSession.getDataHandler.getDatabasePath
+      return db_path if base_only
+      if File.exist?(mv_path = "#{db_path}.mv.db")
+        return mv_path
+      else
+        "#{db_path}.h2.db"
+      end
+    end
+
+    # @override
+    def jdbc_connection(unwrap = nil)
+      java_connection = raw_connection.connection
+      return java_connection unless unwrap
+      if java_connection.java_class.name == 'org.h2.jdbc.JdbcConnection'
+        return java_connection
+      end
+      connection_class = java.sql.Connection.java_class
+      if java_connection.wrapper_for?(connection_class)
+        java_connection.unwrap(connection_class) # java.sql.Wrapper.unwrap
+      elsif java_connection.respond_to?(:connection)
+        # e.g. org.apache.tomcat.jdbc.pool.PooledConnection
+        java_connection.connection # getConnection
+      else
+        java_connection
+      end
     end
 
     private
+
+    def change_column_null(table_name, column_name, null, default = nil)
+      if !null && !default.nil?
+        execute("UPDATE #{table_name} SET #{column_name}=#{quote(default)} WHERE #{column_name} IS NULL")
+      end
+      if null
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NULL"
+      else
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
+      end
+    end
+
     def h2_schema
       @config[:schema] || ''
     end
+
   end
 end
+
+module ActiveRecord::ConnectionAdapters
+
+  class H2Adapter < JdbcAdapter
+    include ArJdbc::H2
+
+    def arel_visitor
+      Arel::Visitors::H2.new(self)
+    end
+  end
+
+end

data/lib/arjdbc/h2/connection_methods.rb

@@ -1,12 +1,27 @@
-module ActiveRecord
-  class Base
-    class << self
-      def h2_connection(config)
-        config[:url] ||= "jdbc:h2:#{config[:database]}"
-        config[:driver] ||= "org.h2.Driver"
-        embedded_driver(config)
+ArJdbc::ConnectionMethods.module_eval do
+  def h2_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::H2
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::H2Adapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/h2'
+      ::Jdbc::H2.load_driver(:require) if defined?(::Jdbc::H2.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
+    end
+
+    config[:url] ||= begin
+      db = config[:database]
+      if db[0, 4] == 'mem:' || db[0, 5] == 'file:' || db[0, 5] == 'hsql:'
+        "jdbc:h2:#{db}"
+      else
+        "jdbc:h2:file:#{File.expand_path(db)}"
       end
-      alias_method :jdbch2_connection, :h2_connection
     end
+    config[:driver] ||= defined?(::Jdbc::H2.driver_name) ? ::Jdbc::H2.driver_name : 'org.h2.Driver'
+
+    embedded_driver(config)
   end
+  alias_method :jdbch2_connection, :h2_connection
 end

data/lib/arjdbc/hsqldb.rb

@@ -1,4 +1,3 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/hsqldb'
-require 'arjdbc/hsqldb/connection_methods'
+require 'arjdbc'
 require 'arjdbc/hsqldb/adapter'
+require 'arjdbc/hsqldb/connection_methods'

data/lib/arjdbc/hsqldb/adapter.rb

@@ -1,88 +1,155 @@
-module ::ArJdbc
+ArJdbc.load_java_part :HSQLDB
+require 'arjdbc/hsqldb/explain_support'
+require 'arjdbc/hsqldb/schema_creation' # AR 4.x
+require 'arel/visitors/hsqldb'
+
+module ArJdbc
   module HSQLDB
+    include ExplainSupport
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
     def self.column_selector
-      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::ArJdbc::HSQLDB::Column)}]
+      [ /hsqldb/i, lambda { |config, column| column.extend(Column) } ]
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
     module Column
+
       private
-      def simplified_type(field_type)
-        case field_type
-        when /longvarchar/i
-          :text
-        when /tinyint/i
-          :boolean
-        when /real/i
-          :float
+
+      def extract_limit(sql_type)
+        limit = super
+        case @sql_type = sql_type.downcase
+        when /^tinyint/i     then @sql_type = 'tinyint'; limit = 1
+        when /^smallint/i    then @sql_type = 'smallint'; limit = 2
+        when /^bigint/i      then @sql_type = 'bigint'; limit = 8
+        when /^double/i      then @sql_type = 'double'; limit = 8
+        when /^real/i        then @sql_type = 'real'; limit = 8
+        # NOTE: once again we get incorrect "limits" from HypesSQL's JDBC
+        # thus yet again we need to fix incorrectly detected limits :
+        when /^integer/i     then @sql_type = 'integer'; limit = 4
+        when /^float/i       then @sql_type = 'float';   limit = 8
+        when /^decimal/i     then @sql_type = 'decimal';
+        when /^datetime/i    then @sql_type = 'datetime'; limit = nil
+        when /^timestamp/i   then @sql_type = 'timestamp'; limit = nil
+        when /^time/i        then @sql_type = 'time'; limit = nil
+        when /^date/i        then @sql_type = 'date'; limit = nil
         else
-          super(field_type)
+          # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns,
+          # which for AR purposes should be interpreted as "no limit" :
+          limit = nil if sql_type =~ /\(0\)$/
         end
+        limit
       end
 
-      # Override of ActiveRecord::ConnectionAdapters::Column
-      def extract_limit(sql_type)
-        # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns, which
-        # for AR purposes should be interpreted as "no limit"
-        return nil if sql_type =~ /\(0\)/
-        super
+      def simplified_type(field_type)
+        case field_type
+        when /^nvarchar/i    then :string
+        when /^character/i   then :string
+        when /^longvarchar/i then :text
+        when /int/i          then :integer # TINYINT, SMALLINT, BIGINT, INT
+        when /real|double/i  then :float
+        when /^bit/i         then :boolean
+        when /binary/i       then :binary # VARBINARY, LONGVARBINARY
+        else
+          super
+        end
       end
 
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
-        # jdbc returns column default strings with actual single quotes around the value.
+        # JDBC returns column default strings with actual single quotes around the value.
         return $1 if value =~ /^'(.*)'$/
-
         value
       end
-    end
 
-    def adapter_name #:nodoc:
-      'Hsqldb'
     end
 
-    def arel2_visitors
-      require 'arel/visitors/hsqldb'
-      {'hsqldb' => ::Arel::Visitors::HSQLDB, 'jdbchsqldb' => ::Arel::Visitors::HSQLDB}
+    ADAPTER_NAME = 'HSQLDB'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "INTEGER GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
-      tp[:integer][:limit] = nil
-      tp[:boolean][:limit] = nil
-      # set text and float limits so we don't see odd scales tacked on
-      # in migrations
-      tp[:boolean] = { :name => "tinyint" }
-      tp[:text][:limit] = nil
-      tp[:float][:limit] = 17 if defined?(::Jdbc::H2)
-      tp[:string][:limit] = 255
-      tp[:datetime] = { :name => "DATETIME" }
-      tp[:timestamp] = { :name => "DATETIME" }
-      tp[:time] = { :name => "TIME" }
-      tp[:date] = { :name => "DATE" }
-      tp
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY",
+      :string => { :name => "varchar", :limit => 255 }, # :limit => 2147483647
+      :text => { :name => "clob" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => "boolean" }, # :name => "tinyint", :limit => 1
+      :bit => { :name=>"bit" }, # stored as 0/1 on HSQLDB 2.2 (translates true/false)
+      :integer => { :name => "integer", :limit => 4 },
+      :decimal => { :name => "decimal" }, # :limit => 2147483647
+      :numeric => { :name => "numeric" }, # :limit => 2147483647
+      # NOTE: fix incorrectly detected limits :
+      :tinyint => { :name => "tinyint", :limit => 1 },
+      :smallint => { :name => "smallint", :limit => 2 },
+      :bigint => { :name => "bigint", :limit => 8 },
+      :float => { :name => "float" },
+      :double => { :name => "double", :limit => 8 },
+      :real => { :name => "real", :limit => 8 },
+      :date => { :name=>"date" },
+      :time => { :name=>"time" },
+      :timestamp => { :name=>"timestamp" },
+      :datetime => { :name=>"timestamp" },
+      :other => { :name=>"other" },
+      # NOTE: would be great if AR allowed as to refactor as :
+      #   t.column :string, :ignorecase => true
+      :character => { :name => "character" },
+      :varchar_ignorecase => { :name => "varchar_ignorecase" },
+    }
+
+    # @override
+    def native_database_types
+      NATIVE_DATABASE_TYPES
     end
 
-    def quote(value, column = nil) # :nodoc:
+    # @override
+    def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
+      return value if sql_literal?(value)
 
       case value
       when String
-        if respond_to?(:h2_adapter) && value.empty?
-          "''"
-        elsif column && column.type == :binary
-          "'#{value.unpack("H*")}'"
-        elsif column && (column.type == :integer ||
-                         column.respond_to?(:primary) && column.primary && column.klass != String)
+        column_type = column && column.type
+        if column_type == :binary
+          "X'#{value.unpack("H*")[0]}'"
+        elsif column_type == :integer ||
+            column.respond_to?(:primary) && column.primary && column.klass != String
           value.to_i.to_s
         else
           "'#{quote_string(value)}'"
         end
+      when Time
+        column_type = column && column.type
+        if column_type == :time
+          "'#{value.strftime("%H:%M:%S")}'"
+        #elsif column_type == :timestamp # || column_type == :datetime
+          #value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+          #"'#{value.strftime("%Y-%m-%d %H:%M:%S")}.#{sprintf("%06d", value.usec)}'"
+        else
+          super
+        end
       else
         super
       end
     end
 
-    def quote_column_name(name) #:nodoc:
+    # Quote date/time values for use in SQL input.
+    # Includes microseconds if the value is a Time responding to usec.
+    # @override
+    def quoted_date(value)
+      if value.acts_like?(:time) && value.respond_to?(:usec)
+        usec = sprintf("%06d", value.usec)
+        value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+        "#{value.strftime("%Y-%m-%d %H:%M:%S")}.#{usec}"
+      else
+        super
+      end
+    end if ::ActiveRecord::VERSION::MAJOR >= 3
+
+    # @override
+    def quote_column_name(name)
       name = name.to_s
       if name =~ /[-]/
         %Q{"#{name.upcase}"}
@@ -91,25 +158,15 @@ module ::ArJdbc
       end
     end
 
-    def quote_string(str)
-      str.gsub(/'/, "''")
-    end
-
-    def quoted_true
-      '1'
-    end
-
-    def quoted_false
-      '0'
-    end
-
+    # @override
     def add_column(table_name, column_name, type, options = {})
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(add_column_sql, options)
       execute(add_column_sql)
-    end
+    end unless const_defined? :SchemaCreation
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # @override
+    def change_column(table_name, column_name, type, options = {})
       execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
     end
 
@@ -117,54 +174,124 @@ module ::ArJdbc
       execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{quote(default)}"
     end
 
+    # @override
     def rename_column(table_name, column_name, new_column_name) #:nodoc:
       execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} RENAME TO #{new_column_name}"
     end
 
-    # Maps logical Rails types to MySQL-specific data types.
+    # @override
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       return super if defined?(::Jdbc::H2) || type.to_s != 'integer' || limit == nil
-
       type
     end
 
+    # @override
     def rename_table(name, new_name)
       execute "ALTER TABLE #{name} RENAME TO #{new_name}"
     end
 
+    # @note AR API since 4.2
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    end
+
     def last_insert_id
-      Integer(select_value("CALL IDENTITY()"))
+      identity = select_value("CALL IDENTITY()")
+      Integer(identity.nil? ? 0 : identity)
     end
 
+    # @private
     def _execute(sql, name = nil)
       result = super
-      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
+      self.class.insert?(sql) ? last_insert_id : result
     end
+    private :_execute
 
-    def add_limit_offset!(sql, options) #:nodoc:
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::HSQLDB#limit_offset
+    def add_limit_offset!(sql, options)
       if sql =~ /^select/i
         offset = options[:offset] || 0
-        bef = sql[7..-1]
         if limit = options[:limit]
-          sql.replace "SELECT LIMIT #{offset} #{limit} #{bef}"
+          sql.replace "SELECT LIMIT #{offset} #{limit} #{sql[7..-1]}"
         elsif offset > 0
-          sql.replace "SELECT LIMIT #{offset} 0 #{bef}"
+          sql.replace "SELECT LIMIT #{offset} 0 #{sql[7..-1]}"
         end
       end
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    # @override
+    def empty_insert_statement_value
+      # on HSQLDB only work with tables that have a default value for each
+      # and every column ... you'll need to avoid `Model.create!` on 4.0
+      'DEFAULT VALUES'
     end
 
-    # override to filter out system tables that otherwise end
-    # up in db/schema.rb during migrations.  JdbcConnection#tables
-    # now takes an optional block filter so we can screen out
-    # rows corresponding to system tables.  HSQLDB names its
-    # system tables SYSTEM.*, but H2 seems to name them without
-    # any kind of convention
+    # We filter out HSQLDB's system tables (named "SYSTEM.*").
+    # @override
     def tables
-      @connection.tables.select {|row| row.to_s !~ /^system_/i }
+      @connection.tables.select { |row| row.to_s !~ /^system_/i }
     end
 
+    # @override
     def remove_index(table_name, options = {})
       execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
     end
+
+    # @override
+    def supports_views?; true end
+
+    # @override
+    def supports_foreign_keys?; true end
+
+    # @override
+    def structure_dump
+      execute('SCRIPT').map do |result|
+        # [ { 'command' => SQL }, { 'command' ... }, ... ]
+        case sql = result.first[1] # ['command']
+        when /CREATE USER SA PASSWORD DIGEST .*?/i then nil
+        when /CREATE SCHEMA PUBLIC AUTHORIZATION DBA/i then nil
+        when /GRANT DBA TO SA/i then nil
+        else sql
+        end
+      end.compact.join("\n\n")
+    end
+
+    # @see #structure_dump
+    def structure_load(dump)
+      dump.each_line("\n\n") { |ddl| execute(ddl) }
+    end
+
+    def shutdown
+      execute 'SHUTDOWN'
+    end
+
+    # @private
+    def recreate_database(name = nil, options = {})
+      drop_database(name)
+      create_database(name, options)
+    end
+
+    # @private
+    def create_database(name = nil, options = {}); end
+
+    # @private
+    def drop_database(name = nil)
+      execute('DROP SCHEMA PUBLIC CASCADE')
+    end
+
+  end
+end
+
+module ActiveRecord::ConnectionAdapters
+
+  class HsqldbAdapter < JdbcAdapter
+    include ArJdbc::HSQLDB
+
+    def arel_visitor # :nodoc:
+      Arel::Visitors::HSQLDB
+    end
   end
+
 end
+