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

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

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

data/lib/arjdbc/sqlite3/adapter.rb

@@ -1,226 +1,353 @@
-require 'arjdbc/jdbc/missing_functionality_helper'
+ArJdbc.load_java_part :SQLite3
+
+require "arjdbc/abstract/core"
+require "arjdbc/abstract/database_statements"
+require 'arjdbc/abstract/statement_cache'
+require "arjdbc/abstract/transaction_support"
+require "active_record/connection_adapters/statement_pool"
+require "active_record/connection_adapters/abstract/database_statements"
+require "active_record/connection_adapters/sqlite3/explain_pretty_printer"
+require "active_record/connection_adapters/sqlite3/quoting"
+require "active_record/connection_adapters/sqlite3/schema_creation"
+
+module ArJdbc
+  # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
+  # The constants at the front of this file are to allow the rest of the file to remain with no modifications
+  # from its original source.  If you hack on this file try not to modify this module and instead try and
+  # put those overrides in SQL3Adapter below.  We try and keep a copy of the Rails this adapter supports
+  # with the current goal of being able to diff changes easily over time and to also eventually remove
+  # this module from ARJDBC altogether.
+  module SQLite3
+    # DIFFERENCE: Some common constant names to reduce differences in rest of this module from AR5 version
+    ConnectionAdapters = ::ActiveRecord::ConnectionAdapters
+    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
+    Quoting = ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
+    RecordNotUnique = ::ActiveRecord::RecordNotUnique
+    SchemaCreation = ConnectionAdapters::SQLite3::SchemaCreation
+    SQLite3Adapter = ConnectionAdapters::AbstractAdapter
+
+    ADAPTER_NAME = 'SQLite'.freeze
+
+    include Quoting
+
+    NATIVE_DATABASE_TYPES = {
+        primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
+        string:       { name: "varchar" },
+        text:         { name: "text" },
+        integer:      { name: "integer" },
+        float:        { name: "float" },
+        decimal:      { name: "decimal" },
+        datetime:     { name: "datetime" },
+        time:         { name: "time" },
+        date:         { name: "date" },
+        binary:       { name: "blob" },
+        boolean:      { name: "boolean" }
+    }
+
+    class StatementPool < ConnectionAdapters::StatementPool
+      private
 
-module ActiveRecord::ConnectionAdapters
-  Sqlite3Adapter = Class.new(AbstractAdapter) unless const_defined?(:Sqlite3Adapter)
-end
+      def dealloc(stmt)
+        stmt[:stmt].close unless stmt[:stmt].closed?
+      end
+    end
 
-module ::ArJdbc
-  module SQLite3
-    def self.column_selector
-      [/sqlite/i, lambda {|cfg,col| col.extend(::ArJdbc::SQLite3::Column)}]
+    def schema_creation # :nodoc:
+      SQLite3::SchemaCreation.new self
     end
 
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::Sqlite3JdbcConnection
+    def arel_visitor # :nodoc:
+      Arel::Visitors::SQLite.new(self)
     end
 
-    module Column
-      def init_column(name, default, *args)
-        @default = '' if default =~ /NULL/
-      end
+    # Difference we remove connection_options because we are not using it.
+    def initialize(connection, logger, config)
+      super(connection, logger, config)
 
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :string   then value
-        when :primary_key then defined?(value.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
+      @active     = nil
+      @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
+    end
 
-      private
-      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/i                           then @scale == 0 ? :integer : :decimal
-        when /datetime/i                       then :datetime
-        when /date/i                           then :date
-        when /time/i                           then :time
-        when /blob/i                           then :binary
-        end
-      end
+    def supports_ddl_transactions?
+      true
+    end
 
-      def extract_precision(sql_type)
-        case sql_type
-          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i
-          else super
-        end
-      end
+    def supports_savepoints?
+      true
+    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
+    def supports_partial_index?
+      sqlite_version >= "3.8.0"
+    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 =~ /^'(.*)'$/
+    # Returns true, since this connection adapter supports prepared statement
+    # caching.
+    def supports_statement_cache?
+      true
+    end
 
-        value
-      end
+    # Returns true, since this connection adapter supports migrations.
+    def supports_migrations? #:nodoc:
+      true
     end
 
-    def adapter_name #:nodoc:
-      'SQLite'
+    def supports_primary_key? #:nodoc:
+      true
     end
 
-    def supports_add_column?
-      sqlite_version >= '3.1.6'
+    def requires_reloading?
+      true
     end
 
-    def supports_count_distinct? #:nodoc:
-      sqlite_version >= '3.2.6'
+    def supports_views?
+      true
     end
 
-    def supports_autoincrement? #:nodoc:
-      sqlite_version >= '3.1.0'
+    def supports_datetime_with_precision?
+      true
     end
 
-    def sqlite_version
-      @sqlite_version ||= select_value('select sqlite_version(*)')
+    def supports_multi_insert?
+      sqlite_version >= "3.7.11"
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL"
-      tp[:string] = { :name => "VARCHAR", :limit => 255 }
-      tp[:float] = { :name => "REAL" }
-      tp[:decimal] = { :name => "REAL" }
-      tp[:datetime] = { :name => "DATETIME" }
-      tp[:timestamp] = { :name => "DATETIME" }
-      tp[:time] = { :name => "TIME" }
-      tp[:date] = { :name => "DATE" }
-      tp[:boolean] = { :name => "BOOLEAN" }
-      tp[:binary] = { :name => "BLOB" }
-      tp
+    def active?
+      @active != false
     end
 
-    def quote_column_name(name) #:nodoc:
-      %Q("#{name}")
+    # Disconnects from the database if already connected. Otherwise, this
+    # method does nothing.
+    def disconnect!
+      super
+      @active = false
+      @connection.close rescue nil
     end
 
-    def quote_string(str)
-      str.gsub(/'/, "''")
+    # Clears the prepared statements cache.
+    def clear_cache!
+      @statements.clear
     end
 
-    def quoted_true
-      %Q{'t'}
+    def supports_index_sort_order?
+      true
     end
 
-    def quoted_false
-      %Q{'f'}
+    def valid_type?(type)
+      true
     end
 
-    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      @connection.execute_update(sql)
-      id_value || last_insert_id
+    # Returns 62. SQLite supports index names up to 64
+    # characters. The rest is used by Rails internally to perform
+    # temporary rename operations
+    def allowed_index_name_length
+      index_name_length - 2
     end
 
-    def last_insert_id
-      Integer(select_value("SELECT last_insert_rowid()"))
+    def native_database_types #:nodoc:
+      NATIVE_DATABASE_TYPES
     end
 
-    def tables(name = nil) #:nodoc:
-      sql = <<-SQL
-        SELECT name
-        FROM sqlite_master
-        WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-      SQL
+    # Returns the current database encoding format as a string, eg: 'UTF-8'
+    def encoding
+      @connection.encoding.to_s
+    end
 
-      select_rows(sql, name).map do |row|
-        row[0]
-      end
+    def supports_explain?
+      true
     end
 
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+    #--
+    # DATABASE STATEMENTS ======================================
+    #++
+
+    def explain(arel, binds = [])
+      sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
+      ::ActiveRecord::ConnectionAdapters::SQLite3::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", []))
     end
 
-    def indexes(table_name, name = nil)
-      result = select_rows("SELECT name, sql FROM sqlite_master WHERE tbl_name = '#{table_name}' AND type = 'index'", name)
+    def exec_query(sql, name = nil, binds = [], prepare: false)
+      type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
 
-      result.collect do |row|
-        name = row[0]
-        index_sql = row[1]
-        unique = (index_sql =~ /unique/i)
-        cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split.map do |c|
-          match = /^"(.+)"$/.match(c); match ? match[1] : c
+      log(sql, name, binds) do
+        # Don't cache statements if they are not prepared
+        unless prepare
+          stmt    = @connection.prepare(sql)
+          begin
+            cols    = stmt.columns
+            unless without_prepared_statement?(binds)
+              stmt.bind_params(type_casted_binds)
+            end
+            records = stmt.to_a
+          ensure
+            stmt.close
+          end
+          stmt = records
+        else
+          cache = @statements[sql] ||= {
+              :stmt => @connection.prepare(sql)
+          }
+          stmt = cache[:stmt]
+          cols = cache[:cols] ||= stmt.columns
+          stmt.reset!
+          stmt.bind_params(type_casted_binds)
         end
-        ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
+
+        ActiveRecord::Result.new(cols, stmt.to_a)
       end
     end
 
-    def primary_key(table_name) #:nodoc:
-      column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
-      column ? column['name'] : nil
+    def exec_delete(sql, name = 'SQL', binds = [])
+      exec_query(sql, name, binds)
+      @connection.changes
     end
+    alias :exec_update :exec_delete
 
-    def recreate_database(name)
-      tables.each{ |table| drop_table(table) }
+    def last_inserted_id(result)
+      @connection.last_insert_row_id
     end
 
-    def _execute(sql, name = nil)
-      result = super
-      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
+    def execute(sql, name = nil) #:nodoc:
+      log(sql, name) { @connection.execute(sql) }
     end
 
-    def select(sql, name=nil)
-      execute(sql, name).map do |row|
-        record = {}
-        row.each_key do |key|
-          if key.is_a?(String)
-            record[key.sub(/^"?\w+"?\./, '')] = row[key]
-          end
-        end
-        record
+    def begin_db_transaction #:nodoc:
+      log("begin transaction",nil) { @connection.transaction }
+    end
+
+    def commit_db_transaction #:nodoc:
+      log("commit transaction",nil) { @connection.commit }
+    end
+
+    def exec_rollback_db_transaction #:nodoc:
+      log("rollback transaction",nil) { @connection.rollback }
+    end
+
+    # SCHEMA STATEMENTS ========================================
+
+    def tables(name = nil) # :nodoc:
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          #tables currently returns both tables and views.
+          This behavior is deprecated and will be changed with Rails 5.1 to only return tables.
+          Use #data_sources instead.
+      MSG
+
+      if name
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing arguments to #tables is deprecated without replacement.
+        MSG
       end
+
+      data_sources
     end
 
-    def table_structure(table_name)
-      structure = @connection.execute_query("PRAGMA table_info(#{quote_table_name(table_name)})")
-      raise ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'" if structure.empty?
-      structure
+    def data_sources
+      select_values("SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'", "SCHEMA")
     end
 
-    def columns(table_name, name = nil) #:nodoc:
+    def table_exists?(table_name)
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          #table_exists? currently checks both tables and views.
+          This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
+          Use #data_source_exists? instead.
+      MSG
+
+      data_source_exists?(table_name)
+    end
+
+    def data_source_exists?(table_name)
+      return false unless table_name.present?
+
+      sql = "SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name <> 'sqlite_sequence'"
+      sql << " AND name = #{quote(table_name)}"
+
+      select_values(sql, "SCHEMA").any?
+    end
+
+    def views # :nodoc:
+      select_values("SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'", "SCHEMA")
+    end
+
+    def view_exists?(view_name) # :nodoc:
+      return false unless view_name.present?
+
+      sql = "SELECT name FROM sqlite_master WHERE type = 'view' AND name <> 'sqlite_sequence'"
+      sql << " AND name = #{quote(view_name)}"
+
+      select_values(sql, "SCHEMA").any?
+    end
+
+    # Returns an array of +Column+ objects for the table specified by +table_name+.
+    def columns(table_name) # :nodoc:
+      table_name = table_name.to_s
       table_structure(table_name).map do |field|
-        ::ActiveRecord::ConnectionAdapters::SQLite3Column.new(@config, field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
+        case field["dflt_value"]
+          when /^null$/i
+            field["dflt_value"] = nil
+          when /^'(.*)'$/m
+            field["dflt_value"] = $1.gsub("''", "'")
+          when /^"(.*)"$/m
+            field["dflt_value"] = $1.gsub('""', '"')
+        end
+
+        collation = field["collation"]
+        sql_type = field["type"]
+        type_metadata = fetch_type_metadata(sql_type)
+        new_column(field["name"], field["dflt_value"], type_metadata, field["notnull"].to_i == 0, table_name, nil, collation)
       end
     end
 
-    def primary_key(table_name) #:nodoc:
-      column = table_structure(table_name).find { |field|
-        field['pk'].to_i == 1
-      }
-      column && column['name']
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, name = nil) #:nodoc:
+      exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").map do |row|
+        sql = <<-SQL
+            SELECT sql
+            FROM sqlite_master
+            WHERE name=#{quote(row['name'])} AND type='index'
+            UNION ALL
+            SELECT sql
+            FROM sqlite_temp_master
+            WHERE name=#{quote(row['name'])} AND type='index'
+        SQL
+        index_sql = exec_query(sql).first["sql"]
+        match = /\sWHERE\s+(.+)$/i.match(index_sql)
+        where = match[1] if match
+        IndexDefinition.new(
+            table_name,
+            row["name"],
+            row["unique"] != 0,
+            exec_query("PRAGMA index_info('#{row['name']}')", "SCHEMA").map { |col|
+              col["name"]
+            }, nil, nil, where)
+      end
     end
 
-    def remove_index!(table_name, index_name) #:nodoc:
-      execute "DROP INDEX #{quote_column_name(index_name)}"
+    def primary_keys(table_name) # :nodoc:
+      pks = table_structure(table_name).select { |f| f["pk"] > 0 }
+      pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def rename_table(name, new_name)
-      execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
+    def remove_index(table_name, options = {}) #:nodoc:
+      index_name = index_name_for_remove(table_name, options)
+      exec_query "DROP INDEX #{quote_column_name(index_name)}"
+    end
+
+    # Renames a table.
+    #
+    # Example:
+    #   rename_table('octopuses', 'octopi')
+    def rename_table(table_name, new_name)
+      exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
+      rename_table_indexes(table_name, new_name)
     end
 
     # See: http://www.sqlite.org/lang_altertable.html
     # SQLite has an additional restriction on the ALTER TABLE statement
-    def valid_alter_table_options( type, options)
+    def valid_alter_table_type?(type)
       type.to_sym != :primary_key
     end
 
     def add_column(table_name, column_name, type, options = {}) #:nodoc:
-      if supports_add_column? && valid_alter_table_options( type, options )
+      if valid_alter_table_type?(type)
         super(table_name, column_name, type, options)
       else
         alter_table(table_name) do |definition|
@@ -229,25 +356,23 @@ module ::ArJdbc
       end
     end
 
-    def remove_column(table_name, *column_names) #:nodoc:
-      raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
-      column_names.flatten.each do |column_name|
-        alter_table(table_name) do |definition|
-          definition.columns.delete(definition[column_name])
-        end
+    def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+      alter_table(table_name) do |definition|
+        definition.remove_column column_name
       end
     end
-    alias :remove_columns :remove_column
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
+    def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
+      default = extract_new_default_value(default_or_changes)
+
       alter_table(table_name) do |definition|
         definition[column_name].default = default
       end
     end
 
-    def change_column_null(table_name, column_name, null, default = nil)
+    def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
       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")
+        exec_query("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
@@ -262,47 +387,166 @@ module ::ArJdbc
           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)
+          self.collation = options[:collation] if options.include?(:collation)
         end
       end
     end
 
     def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      unless columns(table_name).detect{|c| c.name == column_name.to_s }
-        raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
+      column = column_for(table_name, column_name)
+      alter_table(table_name, rename: { column.name => new_column_name.to_s })
+      rename_column_indexes(table_name, column.name, new_column_name)
+    end
+
+    protected
+
+    def table_structure(table_name)
+      structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
+      raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+      table_structure_with_collation(table_name, structure)
+    end
+
+    def alter_table(table_name, options = {}) #:nodoc:
+      altered_table_name = "a#{table_name}"
+      caller = lambda { |definition| yield definition if block_given? }
+
+      transaction do
+        move_table(table_name, altered_table_name,
+                   options.merge(temporary: true))
+        move_table(altered_table_name, table_name, &caller)
       end
-      alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
     end
 
-     # SELECT ... FOR UPDATE is redundant since the table is locked.
-    def add_lock!(sql, options) #:nodoc:
-      sql
+    def move_table(from, to, options = {}, &block) #:nodoc:
+      copy_table(from, to, options, &block)
+      drop_table(from)
+    end
+
+    def copy_table(from, to, options = {}) #:nodoc:
+      from_primary_key = primary_key(from)
+      options[:id] = false
+      create_table(to, options) do |definition|
+        @definition = definition
+        @definition.primary_key(from_primary_key) if from_primary_key.present?
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+              (options[:rename][column.name] ||
+                  options[:rename][column.name.to_sym] ||
+                  column.name) : column.name
+          next if column_name == from_primary_key
+
+          @definition.column(column_name, column.type,
+                             limit: column.limit, default: column.default,
+                             precision: column.precision, scale: column.scale,
+                             null: column.null, collation: column.collation)
+        end
+        yield @definition if block_given?
+      end
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+                          @definition.columns.map(&:name),
+                          options[:rename] || {})
+    end
+
+    def copy_table_indexes(from, to, rename = {}) #:nodoc:
+      indexes(from).each do |index|
+        name = index.name
+        if to == "a#{from}"
+          name = "t#{name}"
+        elsif from == "a#{to}"
+          name = name[1..-1]
+        end
+
+        to_column_names = columns(to).map(&:name)
+        columns = index.columns.map { |c| rename[c] || c }.select do |column|
+          to_column_names.include?(column)
+        end
+
+        unless columns.empty?
+          # index name can't be the same
+          opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          opts[:unique] = true if index.unique
+          add_index(to, columns, opts)
+        end
+      end
     end
 
-    def empty_insert_statement_value
-      "VALUES(NULL)"
+    def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
+      column_mappings = Hash[columns.map { |name| [name, name] }]
+      rename.each { |a| column_mappings[a.last] = a.first }
+      from_columns = columns(from).collect(&:name)
+      columns = columns.find_all { |col| from_columns.include?(column_mappings[col]) }
+      from_columns_to_copy = columns.map { |col| column_mappings[col] }
+      quoted_columns = columns.map { |col| quote_column_name(col) } * ","
+      quoted_from_columns = from_columns_to_copy.map { |col| quote_column_name(col) } * ","
+
+      exec_query("INSERT INTO #{quote_table_name(to)} (#{quoted_columns})
+                     SELECT #{quoted_from_columns} FROM #{quote_table_name(from)}")
     end
 
-    protected
-    include ArJdbc::MissingFunctionalityHelper
+    def sqlite_version
+      @sqlite_version ||= SQLite3Adapter::Version.new(select_value("select sqlite_version(*)"))
+    end
 
     def translate_exception(exception, message)
       case exception.message
-      when /column(s)? .* (is|are) not unique/
-        ActiveRecord::RecordNotUnique.new(message, exception)
+        # 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
+        when /column(s)? .* (is|are) not unique/, /UNIQUE constraint failed: .*/
+          RecordNotUnique.new(message)
+        else
+          super
+      end
+    end
+
+    private
+    COLLATE_REGEX = /.*\"(\w+)\".*collate\s+\"(\w+)\".*/i.freeze
+
+    def table_structure_with_collation(table_name, basic_structure)
+      collation_hash = {}
+      sql            = "SELECT sql FROM
+                              (SELECT * FROM sqlite_master UNION ALL
+                               SELECT * FROM sqlite_temp_master)
+                            WHERE type='table' and name='#{ table_name }' \;"
+
+      # Result will have following sample string
+      # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+      #                       "password_digest" varchar COLLATE "NOCASE");
+      result = exec_query(sql, 'SCHEMA').first
+
+      if result
+        # Splitting with left parentheses and picking up last will return all
+        # columns separated with comma(,).
+        columns_string = result["sql"].split('(').last
+
+        columns_string.split(',').each do |column_string|
+          # This regex will match the column name and collation type and will save
+          # the value in $1 and $2 respectively.
+          collation_hash[$1] = $2 if (COLLATE_REGEX =~ column_string)
+        end
+
+        basic_structure.map! do |column|
+          column_name = column['name']
+
+          if collation_hash.has_key? column_name
+            column['collation'] = collation_hash[column_name]
+          end
+
+          column
+        end
       else
-        super
+        basic_structure.to_hash
       end
     end
   end
 end
 
 module ActiveRecord::ConnectionAdapters
-  remove_const(:SQLite3Adapter) if const_defined?(:SQLite3Adapter)
-  remove_const(:SQLiteAdapter) if const_defined?(:SQLiteAdapter)
-
   class SQLite3Column < JdbcColumn
-    include ArJdbc::SQLite3::Column
-
     def initialize(name, *args)
       if Hash === name
         super
@@ -311,49 +555,125 @@ module ActiveRecord::ConnectionAdapters
       end
     end
 
-    def call_discovered_column_callbacks(*)
-    end
-
     def self.string_to_binary(value)
-      "\000b64" + [value].pack('m*').split("\n").join('')
+      value
     end
 
     def self.binary_to_string(value)
-      if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
+      if value.respond_to?(:encoding) && value.encoding != Encoding::ASCII_8BIT
         value = value.force_encoding(Encoding::ASCII_8BIT)
       end
+      value
+    end
 
-      if value[0..3] == "\000b64"
-        value[4..-1].unpack('m*').first
+    # @override {ActiveRecord::ConnectionAdapters::JdbcColumn#init_column}
+    def init_column(name, default, *args)
+      if default =~ /NULL/
+        @default = nil
       else
-        value
+        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
 
-  class SQLite3Adapter < JdbcAdapter
+  remove_const(:SQLite3Adapter) if const_defined?(:SQLite3Adapter)
+
+  # Currently our adapter is named the same as what AR5 names its adapter.  We will need to get
+  # this changed at some point so this can be a unique name and we can extend activerecord
+  # ActiveRecord::ConnectionAdapters::SQLite3Adapter.  Once we can do that we can remove the
+  # module SQLite3 above and remove a majority of this file.
+  class SQLite3Adapter < AbstractAdapter
+    include ArJdbc::Abstract::Core
     include ArJdbc::SQLite3
+    include ArJdbc::Abstract::DatabaseStatements
+    include ArJdbc::Abstract::StatementCache
+    include ArJdbc::Abstract::TransactionSupport
 
-    def adapter_spec(config)
-      # return nil to avoid extending ArJdbc::SQLite3, which we've already done
+    def begin_isolated_db_transaction(isolation)
+      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
     end
 
-    def jdbc_connection_class(spec)
-      ::ArJdbc::SQLite3.jdbc_connection_class
+    # SQLite driver doesn't support all types of insert statements with executeUpdate so
+    # make it act like a regular query and the ids will be returned from #last_inserted_id
+    # example: INSERT INTO "aircraft" DEFAULT VALUES
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+      exec_query(sql, name, binds)
     end
 
     def jdbc_column_class
-      ActiveRecord::ConnectionAdapters::SQLite3Column
+      ::ActiveRecord::ConnectionAdapters::SQLite3Column
     end
-  end
 
-  SQLiteAdapter = SQLite3Adapter
-end
+    def jdbc_connection_class(spec)
+      self.class.jdbc_connection_class
+    end
 
-# Fake out sqlite3/version driver for AR tests
-$LOADED_FEATURES << 'sqlite3/version.rb'
-module SQLite3
-  module Version
-    VERSION = '1.2.6' # query_cache_test.rb requires SQLite3::Version::VERSION > '1.2.5'
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
+    end
   end
 end