activerecord-jdbc-adapter 60.0-java → 61.0-java

data/lib/arjdbc/postgresql/column.rb

@@ -48,7 +48,7 @@ module ArJdbc
       end
 
       def has_default_function?(default_value, default)
-        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        !default_value && default && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
       end
     end
 

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def postgresql_connection(config)
+    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.postgresql_connection ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false)
     # ... while using symbols by default but than configurations returning string keys ;(

data/lib/arjdbc/postgresql/oid_types.rb

@@ -145,7 +145,7 @@ module ArJdbc
         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 'macaddr', OID::Macaddr.new
         m.register_type 'citext', OID::SpecializedString.new(:citext)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
         m.register_type 'line', OID::SpecializedString.new(:line)
@@ -155,9 +155,9 @@ module ArJdbc
         m.register_type 'polygon', OID::SpecializedString.new(:polygon)
         m.register_type 'circle', OID::SpecializedString.new(:circle)
 
-        m.register_type 'interval' do |_, _, sql_type|
+        m.register_type 'interval' do |*args, sql_type|
           precision = extract_precision(sql_type)
-          OID::SpecializedString.new(:interval, precision: precision)
+          OID::Interval.new(precision: precision)
         end
 
         register_class_with_precision m, 'time', Type::Time
@@ -213,7 +213,7 @@ module ArJdbc
         if oid
           if oid.is_a? Numeric || oid.match(/^\d+$/)
             # numeric OID
-            query += "WHERE t.oid::integer = %s" % oid
+            query += "WHERE t.oid = %s" % oid
 
           elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
             # namespace and type name
@@ -244,6 +244,7 @@ module ArJdbc
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
       ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
       ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
       ActiveRecord::Type.register(:json, Type::Json, adapter: :postgresql)
       ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
       ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -16,6 +16,33 @@ require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 
+module SQLite3
+  module Constants
+    module Open
+      READONLY       = 0x00000001
+      READWRITE      = 0x00000002
+      CREATE         = 0x00000004
+      DELETEONCLOSE  = 0x00000008
+      EXCLUSIVE      = 0x00000010
+      AUTOPROXY      = 0x00000020
+      URI            = 0x00000040
+      MEMORY         = 0x00000080
+      MAIN_DB        = 0x00000100
+      TEMP_DB        = 0x00000200
+      TRANSIENT_DB   = 0x00000400
+      MAIN_JOURNAL   = 0x00000800
+      TEMP_JOURNAL   = 0x00001000
+      SUBJOURNAL     = 0x00002000
+      MASTER_JOURNAL = 0x00004000
+      NOMUTEX        = 0x00008000
+      FULLMUTEX      = 0x00010000
+      SHAREDCACHE    = 0x00020000
+      PRIVATECACHE   = 0x00040000
+      WAL            = 0x00080000
+    end
+  end
+end
+
 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
@@ -69,6 +96,10 @@ module ArJdbc
       true
     end
 
+    def supports_transaction_isolation?
+      true
+    end
+
     def supports_partial_index?
       database_version >= "3.9.0"
     end
@@ -85,6 +116,10 @@ module ArJdbc
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_views?
       true
     end
@@ -97,6 +132,10 @@ module ArJdbc
       true
     end
 
+    def supports_common_table_expressions?
+      database_version >= "3.8.3"
+    end
+
     def supports_insert_on_conflict?
       database_version >= "3.24.0"
     end
@@ -110,13 +149,6 @@ module ArJdbc
       true
     end
 
-    # 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 native_database_types #:nodoc:
       NATIVE_DATABASE_TYPES
     end
@@ -154,7 +186,9 @@ module ArJdbc
     # DATABASE STATEMENTS ======================================
     #++
 
-    READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :pragma, :release, :savepoint, :rollback) # :nodoc:
+    READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+      :pragma
+    ) # :nodoc:
     private_constant :READ_QUERY
 
     def write_query?(sql) # :nodoc:
@@ -181,15 +215,15 @@ module ArJdbc
     #def execute(sql, name = nil) #:nodoc:
 
     def begin_db_transaction #:nodoc:
-      log("begin transaction", nil) { @connection.transaction }
+      log("begin transaction", 'TRANSACTION') { @connection.transaction }
     end
 
     def commit_db_transaction #:nodoc:
-      log("commit transaction", nil) { @connection.commit }
+      log("commit transaction", 'TRANSACTION') { @connection.commit }
     end
 
     def exec_rollback_db_transaction #:nodoc:
-      log("rollback transaction", nil) { @connection.rollback }
+      log("rollback transaction", 'TRANSACTION') { @connection.rollback }
     end
 
     # SCHEMA STATEMENTS ========================================
@@ -199,8 +233,11 @@ module ArJdbc
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def remove_index(table_name, options = {}) #:nodoc:
-      index_name = index_name_for_remove(table_name, options)
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+      index_name = index_name_for_remove(table_name, column_name, options)
+
       exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
@@ -209,21 +246,23 @@ module ArJdbc
     # Example:
     #   rename_table('octopuses', 'octopi')
     def rename_table(table_name, new_name)
+      schema_cache.clear_data_source_cache!(table_name.to_s)
+      schema_cache.clear_data_source_cache!(new_name.to_s)
       exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
       rename_table_indexes(table_name, new_name)
     end
 
-    def add_column(table_name, column_name, type, options = {}) #:nodoc:
+    def add_column(table_name, column_name, type, **options) #:nodoc:
       if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
-          definition.column(column_name, type, options)
+          definition.column(column_name, type, **options)
         end
       else
         super
       end
     end
 
-    def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+    def remove_column(table_name, column_name, type = nil, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition.remove_column column_name
         definition.foreign_keys.delete_if do |_, fk_options|
@@ -249,16 +288,11 @@ module ArJdbc
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].instance_eval do
           self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if options.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)
+            self.options.merge!(options)
         end
       end
     end
@@ -307,21 +341,23 @@ module ArJdbc
         sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
       elsif insert.update_duplicates?
         sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
         sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
       end
 
       sql
     end
 
+    def shared_cache?
+      config[:properties] && config[:properties][:shared_cache] == true
+    end
+
     def get_database_version # :nodoc:
       SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
     end
 
-    def build_truncate_statements(*table_names)
-      truncate_tables = table_names.map do |table_name|
-        "DELETE FROM #{quote_table_name(table_name)}"
-      end
-      combine_multi_statements(truncate_tables)
+    def build_truncate_statement(table_name)
+      "DELETE FROM #{quote_table_name(table_name)}"
     end
 
     def check_version
@@ -337,11 +373,6 @@ module ArJdbc
       999
     end
 
-    def initialize_type_map(m = type_map)
-      super
-      register_class_with_limit m, %r(int)i, SQLite3Integer
-    end
-
     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?
@@ -352,10 +383,16 @@ module ArJdbc
     # See: https://www.sqlite.org/lang_altertable.html
     # SQLite has an additional restriction on the ALTER TABLE statement
     def invalid_alter_table_type?(type, options)
-      type.to_sym == :primary_key || options[:primary_key]
+      type.to_sym == :primary_key || options[:primary_key] ||
+        options[:null] == false && options[:default].nil?
     end
 
-    def alter_table(table_name, foreign_keys = foreign_keys(table_name), **options)
+    def alter_table(
+      table_name,
+      foreign_keys = foreign_keys(table_name),
+      check_constraints = check_constraints(table_name),
+      **options
+    )
       altered_table_name = "a#{table_name}"
 
       caller = lambda do |definition|
@@ -365,7 +402,11 @@ module ArJdbc
             fk.options[:column] = column
           end
           to_table = strip_table_name_prefix_and_suffix(fk.to_table)
-          definition.foreign_key(to_table, fk.options)
+          definition.foreign_key(to_table, **fk.options)
+        end
+
+        check_constraints.each do |chk|
+          definition.check_constraint(chk.expression, **chk.options)
         end
 
         yield definition if block_given?
@@ -387,11 +428,12 @@ module ArJdbc
     def copy_table(from, to, options = {})
       from_primary_key = primary_key(from)
       options[:id] = false
-      create_table(to, options) do |definition|
+      create_table(to, **options) do |definition|
         @definition = definition
         if from_primary_key.is_a?(Array)
           @definition.primary_keys from_primary_key
         end
+
         columns(from).each do |column|
           column_name = options[:rename] ?
             (options[:rename][column.name] ||
@@ -419,7 +461,7 @@ module ArJdbc
         name = index.name
         # indexes sqlite creates for internal use start with `sqlite_` and
         # don't need to be copied
-        next if name.starts_with?("sqlite_")
+        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
@@ -436,10 +478,10 @@ module ArJdbc
 
         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
-          opts[:where] = index.where if index.where
-          add_index(to, columns, opts)
+          options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          options[:unique] = true if index.unique
+          options[:where] = index.where if index.where
+          add_index(to, columns, **options)
         end
       end
     end
@@ -504,7 +546,7 @@ module ArJdbc
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
         end
 
-        basic_structure.map! do |column|
+        basic_structure.map do |column|
           column_name = column["name"]
 
           if collation_hash.has_key? column_name
@@ -526,18 +568,6 @@ module ArJdbc
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
-    # DIFFERENCE: FQN
-    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
-      private
-      def _limit
-        # INTEGER storage class can be stored 8 bytes value.
-        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-        limit || 8
-      end
-    end
-
-    # DIFFERENCE: FQN
-    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -658,7 +688,9 @@ module ActiveRecord::ConnectionAdapters
     end
 
     def begin_isolated_db_transaction(isolation)
-      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+      raise ActiveRecord::TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+      raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+      super
     end
 
     # SQLite driver doesn't support all types of insert statements with executeUpdate so
@@ -694,5 +726,23 @@ module ActiveRecord::ConnectionAdapters
         total_sql
       end
     end
+
+    def initialize_type_map(m = type_map)
+      super
+      register_class_with_limit m, %r(int)i, SQLite3Integer
+    end
+
+    # DIFFERENCE: FQN
+    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
+      private
+      def _limit
+        # INTEGER storage class can be stored 8 bytes value.
+        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        limit || 8
+      end
+    end
+
+    # DIFFERENCE: FQN
+    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
 end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
+    config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
 
@@ -34,7 +35,17 @@ ArJdbc::ConnectionMethods.module_eval do
       # * http://sqlite.org/c3ref/open.html
       # * http://sqlite.org/c3ref/c_open_autoproxy.html
       # => 0x01 = readonly, 0x40 = uri (default in JDBC)
-      config[:properties][:open_mode] = 0x01 | 0x40
+      config[:properties][:open_mode] = ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+    end
+
+    if config[:flags]
+      config[:properties][:open_mode] ||= 0
+      config[:properties][:open_mode] |= config[:flags]
+
+      # JDBC driver has an extra flag for it
+      if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+        config[:properties][:shared_cache] = true
+      end
     end
 
     timeout = config[:timeout]

data/lib/arjdbc/tasks/databases.rake

@@ -5,15 +5,17 @@ module ActiveRecord::Tasks
   DatabaseTasks.module_eval do
 
     # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment, spec_name = nil)
+    def each_current_configuration(environment, name = nil)
       environments = [environment]
       environments << 'test' if environment == 'development'
 
       environments.each do |env|
         ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
-          next if spec_name && spec_name != db_config.spec_name
+          next if name && name != db_config.name
 
-          yield adapt_jdbc_config(db_config.config), db_config.spec_name, env unless db_config.config['database'].blank?
+          if db_config.database
+            yield adapt_jdbc_config(db_config), db_config.name, env
+          end
         end
       end
     end
@@ -21,21 +23,24 @@ module ActiveRecord::Tasks
     # @override patched to adapt jdbc configuration
     def each_local_configuration
       ActiveRecord::Base.configurations.configs_for.each do |db_config|
-        next unless db_config.config['database']
+        next unless db_config.database
 
-        if local_database?(db_config.config)
-          yield adapt_jdbc_config(db_config.config)
+        if local_database?(db_config)
+          yield adapt_jdbc_config(db_config)
         else
-          $stderr.puts "This task only modifies local databases. #{db_config.config['database']} is on a remote host."
+          $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
         end
       end
     end
 
     private
 
-    def adapt_jdbc_config(config)
-      return config unless config['adapter']
-      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+    def adapt_jdbc_config(db_config)
+      if db_config.adapter.start_with? 'jdbc'
+        config = db_config.configuration_hash.merge(adapter: db_config.adapter.sub(/^jdbc/, ''))
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(db_config.env_name, db_config.name, config)
+      end
+      db_config
     end
 
   end