activerecord-jdbc-adapter-ficoh 1.3.21-java

data/lib/arjdbc/firebird/connection_methods.rb

@@ -0,0 +1,20 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def firebird_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::Firebird
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::FirebirdAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    config[:driver] ||= 'org.firebirdsql.jdbc.FBDriver'
+    ArJdbc.load_driver(:Firebird) unless config[:load_driver] == false
+
+    config[:host] ||= 'localhost'
+    config[:port] ||= 3050
+    config[:url] ||= begin
+      "jdbc:firebirdsql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    end
+
+    jdbc_connection(config)
+  end
+  # alias_method :jdbcfirebird_connection, :firebird_connection
+end

data/lib/arjdbc/h2.rb

@@ -0,0 +1,3 @@
+require 'arjdbc'
+require 'arjdbc/h2/adapter'
+require 'arjdbc/h2/connection_methods'

data/lib/arjdbc/h2/adapter.rb

@@ -0,0 +1,335 @@
+ArJdbc.load_java_part :H2
+require 'arjdbc/hsqldb/adapter'
+
+module ArJdbc
+  module H2
+    include HSQLDB
+
+    JdbcConnection = ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class; JdbcConnection end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /\.h2\./i, lambda { |config, column| column.extend(ColumnMethods) } ]
+    end
+
+    # @since 1.4.0
+    # @private Internal - mostly due {#column_selector}.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module ColumnMethods
+
+      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
+
+    # H2's (JDBC) column class
+    # @since 1.4.0
+    class Column < ::ActiveRecord::ConnectionAdapters::JdbcColumn
+      include ColumnMethods
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/h2'; ::Arel::Visitors::H2
+    end
+
+    ADAPTER_NAME = 'H2'.freeze
+
+    # @override
+    def adapter_name
+      ADAPTER_NAME
+    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(schema = current_schema)
+      @connection.tables(nil, schema)
+    end
+
+    # @override
+    def columns(table_name, name = nil)
+      schema, table = extract_schema_and_table(table_name.to_s)
+      schema = current_schema if schema.nil?
+      @connection.columns_internal(table, nil, 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
+
+    # @return [String] the current schema name
+    def current_schema
+      @current_schema ||= execute('CALL SCHEMA()', 'SCHEMA')[0].values[0] # PUBLIC (default)
+    end
+
+    # Change the (current) schema to be used for this connection.
+    def set_schema(schema = 'PUBLIC')
+      @current_schema = nil
+      execute "SET SCHEMA #{schema}", 'SCHEMA'
+    end
+    alias_method :current_schema=, :set_schema
+
+    def create_schema(schema)
+      execute "CREATE SCHEMA #{schema}", 'SCHEMA'
+    end
+
+    def drop_schema(schema)
+      @current_schema = nil if current_schema == schema
+      execute "DROP SCHEMA #{schema}", 'SCHEMA'
+    end
+
+    def configure_connection
+      # NOTE: just to support the config[:schema] setting
+      # it's likely better to append this to the JDBC URL :
+      # jdbc:h2:test;SCHEMA=MY_SCHEMA
+      if schema = config[:schema]
+        set_schema(schema) # if schema.uppercase != 'PUBLIC'
+      end
+    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 extract_schema_and_table(name)
+      result = name.scan(/[^".\s]+|"[^"]*"/)[0, 2]
+      result.each { |m| m.gsub!(/(^"|"$)/, '') }
+      result.unshift(nil) if result.size == 1 # schema == nil
+      result # [schema, table]
+    end
+
+  end
+end
+
+module ActiveRecord::ConnectionAdapters
+  class H2Adapter < JdbcAdapter
+    include ::ArJdbc::H2
+  end
+end

data/lib/arjdbc/h2/connection_methods.rb

@@ -0,0 +1,22 @@
+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)
+
+    ArJdbc.load_driver(:H2) unless config[:load_driver] == false
+    config[:driver] ||= 'org.h2.Driver'
+    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
+    end
+
+    embedded_driver(config)
+  end
+  alias_method :jdbch2_connection, :h2_connection
+end

data/lib/arjdbc/hsqldb.rb

@@ -0,0 +1,3 @@
+require 'arjdbc'
+require 'arjdbc/hsqldb/adapter'
+require 'arjdbc/hsqldb/connection_methods'

data/lib/arjdbc/hsqldb/adapter.rb

@@ -0,0 +1,304 @@
+ArJdbc.load_java_part :HSQLDB
+require 'arjdbc/hsqldb/explain_support'
+require 'arjdbc/hsqldb/schema_creation' # AR 4.x
+
+module ArJdbc
+  module HSQLDB
+    include ExplainSupport
+
+    JdbcConnection = ::ActiveRecord::ConnectionAdapters::JdbcConnection
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /hsqldb/i, lambda { |config, column| column.extend(ColumnMethods) } ]
+    end
+
+    # @since 1.4.0
+    # @private Internal - mostly due {#column_selector}.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module ColumnMethods
+
+      private
+
+      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
+          # 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
+
+      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.
+        return $1 if value =~ /^'(.*)'$/
+        value
+      end
+
+    end
+
+    # HSQLDB's (JDBC) column class
+    # @since 1.4.0
+    class Column < ::ActiveRecord::ConnectionAdapters::JdbcColumn
+      include ColumnMethods
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/hsqldb'; ::Arel::Visitors::HSQLDB
+    end
+
+    ADAPTER_NAME = 'HSQLDB'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    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
+
+    # @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
+        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
+
+    # 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}"}
+      else
+        name
+      end
+    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 unless const_defined? :SchemaCreation
+
+    # @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
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      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
+
+    # @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
+      identity = select_value("CALL IDENTITY()")
+      Integer(identity.nil? ? 0 : identity)
+    end
+
+    # @private
+    def _execute(sql, name = nil)
+      result = super
+      self.class.insert?(sql) ? last_insert_id : result
+    end
+    private :_execute
+
+    # @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
+        if limit = options[:limit]
+          sql.replace "SELECT LIMIT #{offset} #{limit} #{sql[7..-1]}"
+        elsif offset > 0
+          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
+
+    # We filter out HSQLDB's system tables (named "SYSTEM.*").
+    # @override
+    def tables
+      @connection.tables.select { |row| row.to_s !~ /^system_/i }
+    end
+
+    # @override
+    def remove_index!(table_name, index_name)
+      execute "DROP INDEX #{quote_column_name(index_name)}"
+    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
+  end
+end