activerecord-jdbc-adapter-ficoh 1.3.21-java

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -0,0 +1,44 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def postgresql_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::PostgreSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    driver = config[:driver] ||= 'org.postgresql.Driver'
+    ArJdbc.load_driver(:Postgres) if driver.start_with?('org.postgresql.') && config[:load_driver] != false
+
+    host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
+    port = config[:port] ||= ( ENV['PGPORT'] || 5432 )
+    database = config[:database] || config[:dbname] || ENV['PGDATABASE']
+
+    config[:url] ||= "jdbc:postgresql://#{host}:#{port}/#{database}"
+    config[:url] << config[:pg_params] if config[:pg_params]
+
+    config[:username] ||= ( config[:user] || ENV['PGUSER'] || ENV_JAVA['user.name'] )
+    config[:password] ||= ENV['PGPASSWORD'] unless config.key?(:password)
+    properties = ( config[:properties] ||= {} )
+    # PG :connect_timeout - maximum time to wait for connection to succeed
+    if connect_timeout = ( config[:connect_timeout] || ENV['PGCONNECT_TIMEOUT'] )
+      properties['socketTimeout'] ||= connect_timeout
+    end
+    if login_timeout = config[:login_timeout]
+      properties['loginTimeout'] ||= login_timeout
+    end
+    sslmode = config.key?(:sslmode) ? config[:sslmode] : config[:requiressl]
+    # NOTE: makes not much sense since this needs some JVM options :
+    # sslmode = ENV['PGSSLMODE'] || ENV['PGREQUIRESSL'] if sslmode.nil?
+    unless sslmode.nil? # PG :sslmode - disable|allow|prefer|require
+      # JRuby/JVM needs to be started with :
+      #  -Djavax.net.ssl.trustStore=mystore -Djavax.net.ssl.trustStorePassword=...
+      # or a non-validating connection might be used (for testing) :
+      #  :sslfactory = 'org.postgresql.ssl.NonValidatingFactory'
+      properties['ssl'] ||= 'true' if sslmode == true || sslmode.to_s == 'require'
+    end
+    properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
+    properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
+
+    jdbc_connection(config)
+  end
+  alias_method :jdbcpostgresql_connection, :postgresql_connection
+end

data/lib/arjdbc/postgresql/explain_support.rb

@@ -0,0 +1,53 @@
+module ArJdbc
+  module PostgreSQL
+    # @private
+    module ExplainSupport
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN #{to_sql(arel, binds)}"
+        result = exec_query(sql, "EXPLAIN", binds)
+        ExplainPrettyPrinter.new.pp result # we can assume AR >= 3.1
+      end
+      # @private
+      class ExplainPrettyPrinter
+        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+        # PostgreSQL shell:
+        #
+        # QUERY PLAN
+        # ------------------------------------------------------------------------------
+        # Nested Loop Left Join (cost=0.00..37.24 rows=8 width=0)
+        # Join Filter: (posts.user_id = users.id)
+        # -> Index Scan using users_pkey on users (cost=0.00..8.27 rows=1 width=4)
+        # Index Cond: (id = 1)
+        # -> Seq Scan on posts (cost=0.00..28.88 rows=8 width=4)
+        # Filter: (posts.user_id = 1)
+        # (6 rows)
+        #
+        def pp(result)
+          header = result.columns.first
+          lines = result.rows.map(&:first)
+
+          # We add 2 because there's one char of padding at both sides, note
+          # the extra hyphens in the example above.
+          width = [header, *lines].map(&:length).max + 2
+
+          pp = []
+
+          pp << header.center(width).rstrip
+          pp << '-' * width
+
+          pp += lines.map {|line| " #{line}"}
+
+          nrows = result.rows.length
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          pp << "(#{nrows} #{rows_label})"
+
+          pp.join("\n") + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/oid/bytea.rb

@@ -0,0 +1,3 @@
+class ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea
+  remove_method :type_cast_from_database
+end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -0,0 +1,265 @@
+require 'thread'
+
+module ArJdbc
+  module PostgreSQL
+
+    if AR42
+      require 'active_record/connection_adapters/postgresql/oid'
+      require 'arjdbc/postgresql/base/pgconn'
+      require 'arjdbc/postgresql/oid/bytea.rb'
+    else
+      require 'arjdbc/postgresql/base/oid'
+    end
+
+    require 'arjdbc/postgresql/base/pgconn'
+
+    # @private
+    OID = ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+
+    # @private
+    module OIDTypes
+
+      # @override
+      def enable_extension(name)
+        result = super(name)
+        @extensions = nil
+        reload_type_map
+        result
+      end
+
+      # @override
+      def disable_extension(name)
+        result = super(name)
+        @extensions = nil
+        reload_type_map
+        result
+      end
+
+      # @override
+      def extensions
+        @extensions ||= super
+      end
+
+      # @override
+      def lookup_cast_type(sql_type)
+        oid = execute("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA")
+        super oid.first['oid'].to_i
+      end if AR42
+
+      def get_oid_type(oid, fmod, column_name)
+        type_map.fetch(oid, fmod) {
+          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+          type_map[oid] = OID::Identity.new
+        }
+      end unless AR42
+
+      def get_oid_type(oid, fmod, column_name, sql_type = '')
+        if !type_map.key?(oid)
+          load_additional_types(type_map, [oid])
+        end
+
+        type_map.fetch(oid, fmod, sql_type) {
+          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+          Type::Value.new.tap do |cast_type|
+            type_map.register_type(oid, cast_type)
+          end
+        }
+      end if AR42
+
+      @@type_map_cache = {}
+      @@type_map_cache_lock = Mutex.new
+
+      if AR42
+        TypeMap = ActiveRecord::Type::HashLookupTypeMap
+      else
+        TypeMap = OID::TypeMap
+      end
+
+      # @see #type_map
+      # @private
+      TypeMap.class_eval do
+        def dup
+          dup = super # make sure @mapping is not shared
+          dup.instance_variable_set(:@mapping, @mapping.dup)
+          dup
+        end
+      end
+
+      def type_map
+        # NOTE: our type_map is lazy (on AR < 4.2)
+        # ... since it's only used for `adapter.accessor`
+        @type_map ||= begin
+          if type_map = @@type_map_cache[ type_cache_key ]
+            type_map.dup
+          else
+            type_map = TypeMap.new
+            initialize_type_map(type_map)
+            cache_type_map(type_map)
+            type_map
+          end
+        end
+      end
+
+      def reload_type_map
+        if ( @type_map ||= nil )
+          @type_map.clear
+          initialize_type_map(@type_map)
+        end
+      end
+
+      private
+
+      def cache_type_map(type_map)
+        @@type_map_cache_lock.synchronize do
+          @@type_map_cache[ type_cache_key ] = type_map
+        end
+      end
+
+      def type_cache_key
+        config.hash + ( 7 * extensions.hash )
+      end
+
+      def add_oid(row, records_by_oid, type_map)
+        return type_map if type_map.key? row['type_elem'].to_i
+
+        if OID.registered_type? typname = row['typname']
+          # this composite type is explicitly registered
+          vector = OID::NAMES[ typname ]
+        else
+          # use the default for composite types
+          unless type_map.key? typelem = row['typelem'].to_i
+            add_oid records_by_oid[ row['typelem'] ], records_by_oid, type_map
+          end
+
+          vector = OID::Vector.new row['typdelim'], type_map[typelem]
+        end
+
+        type_map[ row['oid'].to_i ] = vector
+        type_map
+      end
+
+      def initialize_type_map(type_map)
+        result = execute('SELECT oid, typname, typelem, typdelim, typinput FROM pg_type', 'SCHEMA')
+        leaves, nodes = result.partition { |row| row['typelem'].to_s == '0' }
+        # populate the leaf nodes
+        leaves.find_all { |row| OID.registered_type? row['typname'] }.each do |row|
+          type_map[ row['oid'].to_i ] = OID::NAMES[ row['typname'] ]
+        end
+
+        records_by_oid = result.group_by { |row| row['oid'] }
+
+        arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+
+        # populate composite types
+        nodes.each { |row| add_oid row, records_by_oid, type_map }
+
+        # populate array types
+        arrays.find_all { |row| type_map.key? row['typelem'].to_i }.each do |row|
+          array = OID::Array.new  type_map[ row['typelem'].to_i ]
+          type_map[ row['oid'].to_i ] = array
+        end
+      end unless AR42
+
+      def initialize_type_map(m)
+        register_class_with_limit m, 'int2', OID::Integer
+        register_class_with_limit m, 'int4', OID::Integer
+        register_class_with_limit m, 'int8', OID::Integer
+        m.alias_type 'oid', 'int2'
+        m.register_type 'float4', OID::Float.new
+        m.alias_type 'float8', 'float4'
+        m.register_type 'text', Type::Text.new
+        register_class_with_limit m, 'varchar', Type::String
+        m.alias_type 'char', 'varchar'
+        m.alias_type 'name', 'varchar'
+        m.alias_type 'bpchar', 'varchar'
+        m.register_type 'bool', Type::Boolean.new
+        register_class_with_limit m, 'bit', OID::Bit
+        register_class_with_limit m, 'varbit', OID::BitVarying
+        m.alias_type 'timestamptz', 'timestamp'
+        m.register_type 'date', OID::Date.new
+        m.register_type 'time', OID::Time.new
+
+        m.register_type 'money', OID::Money.new
+        m.register_type 'bytea', OID::Bytea.new
+        m.register_type 'point', OID::Point.new
+        m.register_type 'hstore', OID::Hstore.new
+        m.register_type 'json', OID::Json.new
+        m.register_type 'jsonb', OID::Jsonb.new
+        m.register_type 'cidr', OID::Cidr.new
+        m.register_type 'inet', OID::Inet.new
+        m.register_type 'uuid', OID::Uuid.new
+        m.register_type 'xml', OID::Xml.new
+        m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
+        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'citext', OID::SpecializedString.new(:citext)
+        m.register_type 'ltree', OID::SpecializedString.new(:ltree)
+
+        # FIXME: why are we keeping these types as strings?
+        m.alias_type 'interval', 'varchar'
+        m.alias_type 'path', 'varchar'
+        m.alias_type 'line', 'varchar'
+        m.alias_type 'polygon', 'varchar'
+        m.alias_type 'circle', 'varchar'
+        m.alias_type 'lseg', 'varchar'
+        m.alias_type 'box', 'varchar'
+
+        m.register_type 'timestamp' do |_, _, sql_type|
+          precision = extract_precision(sql_type)
+          OID::DateTime.new(precision: precision)
+        end
+
+        m.register_type 'numeric' do |_, fmod, sql_type|
+          precision = extract_precision(sql_type)
+          scale = extract_scale(sql_type)
+
+          # The type for the numeric depends on the width of the field,
+          # so we'll do something special here.
+          #
+          # When dealing with decimal columns:
+          #
+          # places after decimal  = fmod - 4 & 0xffff
+          # places before decimal = (fmod - 4) >> 16 & 0xffff
+          if fmod && (fmod - 4 & 0xffff).zero?
+            # FIXME: Remove this class, and the second argument to
+            # lookups on PG
+            Type::DecimalWithoutScale.new(precision: precision)
+          else
+            OID::Decimal.new(precision: precision, scale: scale)
+          end
+        end
+
+        load_additional_types(m)
+      end if AR42
+
+      def load_additional_types(type_map, oids = nil)
+        if supports_ranges?
+          query = <<-SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+          SQL
+        else
+          query = <<-SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
+            FROM pg_type as t
+          SQL
+        end
+
+        initializer = OID::TypeMapInitializer.new(type_map)
+
+        if oids
+          query << ( "WHERE t.oid::integer IN (%s)" % oids.join(", ") )
+        else
+          # query_conditions_for_initial_load only available since AR > 4.2.1
+          if initializer.respond_to?(:query_conditions_for_initial_load)
+            query << initializer.query_conditions_for_initial_load(type_map)
+          end
+        end
+
+        records = execute(query, 'SCHEMA')
+        initializer.run(records)
+      end if AR42
+
+    end
+  end
+end

data/lib/arjdbc/postgresql/schema_creation.rb

@@ -0,0 +1,60 @@
+module ArJdbc
+  module PostgreSQL
+    # @private copied (and adjusted) from native adapter 4.0/4.1/4.2
+    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+      private
+
+      def visit_AddColumn(o)
+        sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+        sql = "ADD COLUMN #{quote_column_name(o.name)} #{sql_type}"
+        add_column_options!(sql, column_options(o))
+      end unless AR42
+
+      def visit_ColumnDefinition(o)
+        sql = super
+        if o.primary_key? && o.type == :uuid
+          sql << " PRIMARY KEY "
+          add_column_options!(sql, column_options(o))
+        end
+        sql
+      end unless AR42
+
+      def visit_ColumnDefinition(o)
+        sql = super
+        if o.primary_key? && o.type != :primary_key
+          sql << " PRIMARY KEY "
+          add_column_options!(sql, column_options(o))
+        end
+        sql
+      end if AR42
+
+      def add_column_options!(sql, options)
+        if options[:array] || options[:column].try(:array)
+          sql << '[]'
+        end
+
+        column = options.fetch(:column) { return super }
+        if column.type == :uuid && options[:default] =~ /\(\)/
+          sql << " DEFAULT #{options[:default]}"
+        else
+          super
+        end
+      end
+
+      def type_for_column(column)
+        if column.array
+          @conn.lookup_cast_type("#{column.sql_type}[]")
+        else
+          super
+        end
+      end if AR42
+
+    end
+
+    def schema_creation
+      SchemaCreation.new self
+    end
+
+  end
+end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation

data/lib/arjdbc/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails/railtie'
+
+module ArJdbc
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      if defined? ActiveRecord::Railtie # only if AR being used
+        load File.expand_path('tasks.rb', File.dirname(__FILE__))
+      end
+    end
+  end
+end

data/lib/arjdbc/sqlite3.rb

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

data/lib/arjdbc/sqlite3/adapter.rb

@@ -0,0 +1,654 @@
+ArJdbc.load_java_part :SQLite3
+
+require 'arjdbc/sqlite3/explain_support'
+require 'arjdbc/util/table_copier'
+
+module ArJdbc
+  module SQLite3
+    include Util::TableCopier
+
+    JdbcConnection = ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
+
+    # @deprecated
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class; JdbcConnection end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /sqlite/i, lambda { |config, column| column.extend(ColumnMethods) } ]
+    end
+
+    # @private
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module ColumnMethods
+
+      # @override {ActiveRecord::ConnectionAdapters::JdbcColumn#init_column}
+      def init_column(name, default, *args)
+        if default =~ /NULL/
+          @default = nil
+        else
+          super
+        end
+      end
+
+      # @override {ActiveRecord::ConnectionAdapters::JdbcColumn#default_value}
+      def default_value(value)
+        # JDBC returns column default strings with actual single quotes :
+        return $1 if value =~ /^'(.*)'$/
+
+        value
+      end
+
+      # @override {ActiveRecord::ConnectionAdapters::Column#type_cast}
+      def type_cast(value)
+        return nil if value.nil?
+        case type
+        when :string then value
+        when :primary_key
+          value.respond_to?(:to_i) ? value.to_i : ( value ? 1 : 0 )
+        when :float    then value.to_f
+        when :decimal  then self.class.value_to_decimal(value)
+        when :boolean  then self.class.value_to_boolean(value)
+        else super
+        end
+      end
+
+      private
+
+      # @override {ActiveRecord::ConnectionAdapters::Column#simplified_type}
+      def simplified_type(field_type)
+        case field_type
+        when /boolean/i       then :boolean
+        when /text/i          then :text
+        when /varchar/i       then :string
+        when /int/i           then :integer
+        when /float/i         then :float
+        when /real|decimal/i  then
+          extract_scale(field_type) == 0 ? :integer : :decimal
+        when /datetime/i      then :datetime
+        when /date/i          then :date
+        when /time/i          then :time
+        when /blob/i          then :binary
+        else super
+        end
+      end
+
+      # @override {ActiveRecord::ConnectionAdapters::Column#extract_limit}
+      def extract_limit(sql_type)
+        return nil if sql_type =~ /^(real)\(\d+/i
+        super
+      end
+
+      def extract_precision(sql_type)
+        case sql_type
+          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i
+          else super
+        end
+      end
+
+      def extract_scale(sql_type)
+        case sql_type
+          when /^(real)\((\d+)\)/i then 0
+          when /^(real)\((\d+)(,(\d+))\)/i then $4.to_i
+          else super
+        end
+      end
+
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      ::Arel::Visitors::SQLite
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#bind_substitution
+    # @private
+    class BindSubstitution < ::Arel::Visitors::SQLite
+      include ::Arel::Visitors::BindVisitor
+    end if defined? ::Arel::Visitors::BindVisitor
+
+    ADAPTER_NAME = 'SQLite'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => nil,
+      :string => { :name => "varchar", :limit => 255 },
+      :text => { :name => "text" },
+      :integer => { :name => "integer" },
+      :float => { :name => "float" },
+      # :real => { :name=>"real" },
+      :decimal => { :name => "decimal" },
+      :datetime => { :name => "datetime" },
+      :timestamp => { :name => "datetime" },
+      :time => { :name => "time" },
+      :date => { :name => "date" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => "boolean" }
+    }
+    NATIVE_DATABASE_TYPES.update(
+      :string => { :name => "varchar" }
+    ) if AR42
+
+    # @override
+    def native_database_types
+      types = NATIVE_DATABASE_TYPES.dup
+      types[:primary_key] = default_primary_key_type
+      types
+    end
+
+    def default_primary_key_type
+      if supports_autoincrement?
+        'integer PRIMARY KEY AUTOINCREMENT NOT NULL'
+      else
+        'integer PRIMARY KEY NOT NULL'
+      end
+    end
+
+    # @override
+    def supports_ddl_transactions?
+      true
+    end
+
+    # @override
+    def supports_savepoints?
+      sqlite_version >= '3.6.8'
+    end
+
+    # @override
+    def supports_partial_index?
+      sqlite_version >= '3.8.0'
+    end
+
+    # @override
+    def supports_add_column?
+      true
+    end
+
+    # @override
+    def supports_count_distinct?
+      true
+    end
+
+    # @override
+    def supports_autoincrement?
+      true
+    end
+
+    # @override
+    def supports_migrations?
+      true
+    end
+
+    # @override
+    def supports_primary_key?
+      true
+    end
+
+    # @override
+    def supports_add_column?
+      true
+    end
+
+    # @override
+    def supports_count_distinct?
+      true
+    end
+
+    # @override
+    def supports_autoincrement?
+      true
+    end
+
+    # @override
+    def supports_index_sort_order?
+      true
+    end
+
+    # @override
+    def supports_views?
+      true
+    end
+
+    def sqlite_version
+      @sqlite_version ||= Version.new(select_value('SELECT sqlite_version(*)'))
+    end
+    private :sqlite_version
+
+    # @override
+    def quote(value, column = nil)
+      return value if sql_literal?(value)
+
+      if value.kind_of?(String)
+        column_type = column && column.type
+        if column_type == :binary
+          "x'#{value.unpack("H*")[0]}'"
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def quote_table_name_for_assignment(table, attr)
+      quote_column_name(attr)
+    end if ::ActiveRecord::VERSION::MAJOR >= 4
+
+    def type_cast(value, column)
+      return value.to_f if BigDecimal === value
+      return super unless String === value
+      return super unless column && value
+
+      value = super
+      if column.type == :string &&
+        value.respond_to?(:encoding) && value.encoding == Encoding::ASCII_8BIT
+        logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
+        value = value.encode Encoding::UTF_8
+      end
+      value
+    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)
+        "#{super}.#{sprintf("%06d", value.usec)}"
+      else
+        super
+      end
+    end if ::ActiveRecord::VERSION::MAJOR >= 3
+
+    # @override
+    def tables(name = nil, table_name = nil)
+      sql = "SELECT name FROM sqlite_master WHERE type = 'table'"
+      if table_name
+        sql << " AND name = #{quote_table_name(table_name)}"
+      else
+        sql << " AND NOT name = 'sqlite_sequence'"
+      end
+
+      select_rows(sql, name).map! { |row| row[0] }
+    end
+
+    # @override
+    def table_exists?(table_name)
+      table_name && tables(nil, table_name).any?
+    end
+
+    def truncate_fake(table_name, name = nil)
+      execute "DELETE FROM #{quote_table_name(table_name)}; VACUUM", name
+    end
+    # NOTE: not part of official AR (4.2) alias truncate truncate_fake
+
+    # Returns 62. SQLite supports index names up to 64 characters.
+    # The rest is used by Rails internally to perform temporary rename operations.
+    # @return [Fixnum]
+    def allowed_index_name_length
+      index_name_length - 2
+    end
+
+    # NOTE: handled by JdbcAdapter only to have statements in logs :
+
+    # @override
+    def begin_db_transaction
+      # NOTE: based on TX mode SQLite-JDBC does "begin;"
+      # "begin immediate;" or "begin exclusive;" on setAutoCommit(false)
+      log('BEGIN') { @connection.begin }
+    end
+
+    # @override
+    def commit_db_transaction
+      log('COMMIT') { @connection.commit }
+    end
+
+    # @override
+    def rollback_db_transaction
+      log('ROLLBACK') { @connection.rollback }
+    end
+
+    # @override on **AR-4.0**
+    def begin_isolated_db_transaction(isolation)
+      log("/* TRANSACTION_#{isolation.to_s.upcase} */; BEGIN") do
+        @connection.begin(isolation)
+      end
+    end
+
+    # @override
+    def create_savepoint(name = current_savepoint_name(true))
+      log("SAVEPOINT #{name}") { @connection.create_savepoint(name) }
+    end
+
+    # @override
+    def rollback_to_savepoint(name = current_savepoint_name(true))
+      log("ROLLBACK TO SAVEPOINT #{name}") { @connection.rollback_savepoint(name) }
+    end
+
+    # @override
+    def release_savepoint(name = current_savepoint_name(false))
+      log("RELEASE SAVEPOINT #{name}") { @connection.release_savepoint(name) }
+    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)
+      tables.each { |table| drop_table(table) }
+    end
+
+    def select(sql, name = nil, binds = [])
+      result = super # AR::Result (4.0) or Array (<= 3.2)
+      if result.respond_to?(:columns) # 4.0
+        result.columns.map! do |key| # [ [ 'id', ... ]
+          key.is_a?(String) ? key.sub(/^"?\w+"?\./, '') : key
+        end
+      else
+        result.map! do |row| # [ { 'id' => ... }, {...} ]
+          record = {}
+          row.each_key do |key|
+            if key.is_a?(String)
+              record[key.sub(/^"?\w+"?\./, '')] = row[key]
+            end
+          end
+          record
+        end
+      end
+      result
+    end
+
+    # @note We have an extra binds argument at the end due AR-2.3 support.
+    # @override
+    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      result = execute(sql, name, binds)
+      id_value || last_inserted_id(result)
+    end
+
+    # @note Does not support prepared statements for INSERT statements.
+    # @override
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+      # NOTE: since SQLite JDBC does not support executeUpdate but only
+      # statement.execute we can not support prepared statements here :
+      execute(sql, name, binds)
+    end
+
+    def table_structure(table_name)
+      sql = "PRAGMA table_info(#{quote_table_name(table_name)})"
+      log(sql, 'SCHEMA') { @connection.execute_query_raw(sql) }
+    rescue ActiveRecord::JDBCError => error
+      e = ActiveRecord::StatementInvalid.new("Could not find table '#{table_name}'")
+      e.set_backtrace error.backtrace
+      raise e
+    end
+
+    # @override
+    def columns(table_name, name = nil)
+      pass_cast_type = respond_to?(:lookup_cast_type)
+      table_structure(table_name).map do |field|
+        sql_type = field['type']
+        if pass_cast_type
+          cast_type = lookup_cast_type(sql_type)
+          Column.new(field['name'], field['dflt_value'], cast_type, sql_type, field['notnull'] == 0)
+        else
+          Column.new(field['name'], field['dflt_value'], sql_type, field['notnull'] == 0)
+        end
+      end
+    end
+
+    # @override
+    def primary_key(table_name)
+      column = table_structure(table_name).find { |field| field['pk'].to_i == 1 }
+      column && column['name']
+    end
+
+    # NOTE: do not override indexes without testing support for 3.7.2 & 3.8.7 !
+    # @override
+    def indexes(table_name, name = nil)
+      # on JDBC 3.7 we'll simply do super since it can not handle "PRAGMA index_info"
+      return @connection.indexes(table_name, name) if sqlite_version < '3.8' # super
+
+      name ||= 'SCHEMA'
+      exec_query_raw("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+        index_name = row['name']
+        sql = "SELECT sql FROM sqlite_master"
+        sql << " WHERE name=#{quote(index_name)} AND type='index'"
+        sql << " UNION ALL "
+        sql << "SELECT sql FROM sqlite_temp_master"
+        sql << " WHERE name=#{quote(index_name)} AND type='index'"
+        where = nil
+        exec_query_raw(sql, name) do |index_sql|
+          match = /\sWHERE\s+(.+)$/i.match(index_sql)
+          where = match[1] if match
+        end
+        begin
+          columns = exec_query_raw("PRAGMA index_info('#{index_name}')", name).map { |col| col['name'] }
+        rescue => e
+          # NOTE: JDBC <= 3.8.7 bug work-around :
+          if e.message && e.message.index('[SQLITE_ERROR] SQL error or missing database')
+            columns = []
+          end
+          raise e
+        end
+        new_index_definition(table_name, index_name, row['unique'] != 0, columns, nil, nil, where)
+      end
+    end
+
+    # @override
+    def remove_index!(table_name, index_name)
+      execute "DROP INDEX #{quote_column_name(index_name)}"
+    end
+
+    # @override
+    def rename_table(table_name, new_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
+      rename_table_indexes(table_name, new_name) if respond_to?(:rename_table_indexes) # AR-4.0 SchemaStatements
+    end
+
+    # SQLite has an additional restriction on the ALTER TABLE statement.
+    # @see http://www.sqlite.org/lang_altertable.html
+    def valid_alter_table_options( type, options)
+      type.to_sym != :primary_key
+    end
+
+    def add_column(table_name, column_name, type, options = {})
+      if supports_add_column? && valid_alter_table_options( type, options )
+        super(table_name, column_name, type, options)
+      else
+        alter_table(table_name) do |definition|
+          definition.column(column_name, type, options)
+        end
+      end
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+
+    # @private
+    def remove_column(table_name, column_name, type = nil, options = {})
+      alter_table(table_name) do |definition|
+        definition.remove_column column_name
+      end
+    end
+
+    else
+
+    # @private
+    def remove_column(table_name, *column_names)
+      if column_names.empty?
+        raise ArgumentError.new(
+          "You must specify at least one column name." +
+          "  Example: remove_column(:people, :first_name)"
+        )
+      end
+      column_names.flatten.each do |column_name|
+        alter_table(table_name) do |definition|
+          definition.columns.delete(definition[column_name])
+        end
+      end
+    end
+    alias :remove_columns :remove_column
+
+    end
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      alter_table(table_name) do |definition|
+        definition[column_name].default = default
+      end
+    end
+
+    def change_column_null(table_name, column_name, null, default = nil)
+      unless null || default.nil?
+        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+      end
+      alter_table(table_name) do |definition|
+        definition[column_name].null = null
+      end
+    end
+
+    def change_column(table_name, column_name, type, options = {})
+      alter_table(table_name) do |definition|
+        include_default = options_include_default?(options)
+        definition[column_name].instance_eval do
+          self.type    = type
+          self.limit   = options[:limit] if options.include?(:limit)
+          self.default = options[:default] if include_default
+          self.null    = options[:null] if options.include?(:null)
+          self.precision = options[:precision] if options.include?(:precision)
+          self.scale   = options[:scale] if options.include?(:scale)
+        end
+      end
+    end
+
+    def rename_column(table_name, column_name, new_column_name)
+      unless columns(table_name).detect{|c| c.name == column_name.to_s }
+        raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
+      end
+      alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
+      rename_column_indexes(table_name, column_name, new_column_name) if respond_to?(:rename_column_indexes) # AR-4.0 SchemaStatements
+    end
+
+    # @private
+    def add_lock!(sql, options)
+      sql # SELECT ... FOR UPDATE is redundant since the table is locked
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    def empty_insert_statement_value
+      # inherited (default) on 3.2 : "VALUES(DEFAULT)"
+      # inherited (default) on 4.0 : "DEFAULT VALUES"
+      # re-defined in native adapter on 3.2 "VALUES(NULL)"
+      # on 4.0 no longer re-defined (thus inherits default)
+      "DEFAULT VALUES"
+    end
+
+    def encoding
+      select_value 'PRAGMA encoding'
+    end
+
+    def last_insert_id
+      @connection.last_insert_rowid
+    end
+
+    protected
+
+    def last_inserted_id(result)
+      super || last_insert_id # NOTE: #last_insert_id call should not be needed
+    end
+
+    def translate_exception(exception, message)
+      if msg = exception.message
+        # SQLite 3.8.2 returns a newly formatted error message:
+        #   UNIQUE constraint failed: *table_name*.*column_name*
+        # Older versions of SQLite return:
+        #   column *column_name* is not unique
+        if msg.index('UNIQUE constraint failed: ') ||
+           msg =~ /column(s)? .* (is|are) not unique/
+          return ::ActiveRecord::RecordNotUnique.new(message, exception)
+        end
+      end
+      super
+    end
+
+    # @private available in native adapter way back to AR-2.3
+    class Version
+      include Comparable
+
+      def initialize(version_string)
+        @version = version_string.split('.').map!(&:to_i)
+      end
+
+      def <=>(version_string)
+        @version <=> version_string.split('.').map!(&:to_i)
+      end
+
+      def to_s
+        @version.join('.')
+      end
+
+    end
+
+  end
+end
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:SQLite3Adapter) if const_defined?(:SQLite3Adapter)
+  class SQLite3Adapter < JdbcAdapter
+    include ::ArJdbc::SQLite3
+    include ::ArJdbc::SQLite3::ExplainSupport
+
+    # @private
+    Version = ArJdbc::SQLite3::Version
+
+    class Column < JdbcColumn
+      include ::ArJdbc::SQLite3::ColumnMethods
+
+      def initialize(name, *args)
+        if Hash === name
+          super
+        else
+          super(nil, name, *args)
+        end
+      end
+
+      def self.string_to_binary(value)
+        value
+      end
+
+      def self.binary_to_string(value)
+        if value.respond_to?(:encoding) && value.encoding != Encoding::ASCII_8BIT
+          value = value.force_encoding(Encoding::ASCII_8BIT)
+        end
+        value
+      end
+    end
+
+  end
+
+  # NOTE: SQLite3Column exists in native adapter since AR 4.0
+  remove_const(:SQLite3Column) if const_defined?(:SQLite3Column)
+  SQLite3Column = SQLite3Adapter::Column
+
+  if ActiveRecord::VERSION::MAJOR <= 3
+    remove_const(:SQLiteColumn) if const_defined?(:SQLiteColumn)
+    SQLiteColumn = SQLite3Column
+
+    remove_const(:SQLiteAdapter) if const_defined?(:SQLiteAdapter)
+
+    SQLiteAdapter = SQLite3Adapter
+  end
+end
+
+module ArJdbc
+  module SQLite3
+    Column = ::ActiveRecord::ConnectionAdapters::SQLite3Adapter::Column
+  end
+end