activerecord-jdbc-adapter 51.8-java → 52.0-java

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,7 +1,6 @@
 # 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 ;(
@@ -17,8 +16,7 @@ ArJdbc::ConnectionMethods.module_eval do
       ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
     end
-    driver = (config[:driver] ||=
-      defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver')
+    driver = config[:driver] ||= 'org.postgresql.Driver'
 
     host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
     port = config[:port] ||= ( ENV['PGPORT'] || 5432 )
@@ -53,15 +51,8 @@ ArJdbc::ConnectionMethods.module_eval do
     properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
     properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
 
-    prepared_statements = config.fetch(:prepared_statements) { true }
-    prepared_statements = false if prepared_statements == 'false'
-    if prepared_statements
-      # this makes the pgjdbc driver handle hot compatibility internally
-      properties['autosave'] ||= 'conservative'
-    else
-      # If prepared statements are off, lets make sure they are really *off*
-      properties['prepareThreshold'] = 0
-    end
+    # If prepared statements are off, lets make sure they are really *off*
+    properties['prepareThreshold'] ||= 0 unless config[:prepared_statements]
 
     jdbc_connection(config)
   end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -9,61 +9,6 @@ module ArJdbc
     # @private
     OID = ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    # this version makes sure to register the types by name as well
-    # we still need to version with OID since it's used from SchemaStatements as well
-    class ArjdbcTypeMapInitializer < OID::TypeMapInitializer
-      private
-
-      def name_with_ns(row)
-        if row['in_ns']
-          row['typname']
-        else
-          %Q("#{row['nspname']}"."#{row['typname']}")
-        end
-      end
-
-      def register_enum_type(row)
-        super
-        register name_with_ns(row), OID::Enum.new
-      end
-
-      def register_array_type(row)
-        super
-        register_with_subtype(name_with_ns(row), row['typelem'].to_i) do |subtype|
-          OID::Array.new(subtype, row['typdelim'])
-        end
-      end
-
-      def register_range_type(row)
-        super
-        name = name_with_ns(row)
-        register_with_subtype(name, row['rngsubtype'].to_i) do |subtype|
-          OID::Range.new(subtype, name.to_sym)
-        end
-      end
-
-      def register_domain_type(row)
-        if base_type = @store.lookup(row['typbasetype'].to_i)
-          register row['oid'], base_type
-          register name_with_ns(row), base_type
-        else
-          warn "unknown base type (OID: #{row['typbasetype']}) for domain #{row['typname']}."
-        end
-      end
-
-      def register_composite_type(row)
-        if subtype = @store.lookup(row['typelem'].to_i)
-          register row['oid'], OID::Vector.new(row['typdelim'], subtype)
-          register name_with_ns(row), OID::Vector.new(row['typdelim'], subtype)
-        end
-      end
-
-      def assert_valid_registration(oid, oid_type)
-        ret = super
-        ret == 0 ? oid : ret
-      end
-    end
-
     # @private
     module OIDTypes
 
@@ -96,7 +41,7 @@ module ArJdbc
 
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         if !type_map.key?(oid)
-          load_additional_types(type_map, oid)
+          load_additional_types([oid])
         end
 
         type_map.fetch(oid, fmod, sql_type) {
@@ -120,7 +65,7 @@ module ArJdbc
 
       private
 
-      def initialize_type_map(m)
+      def initialize_type_map(m = type_map)
         register_class_with_limit m, 'int2', Type::Integer
         register_class_with_limit m, 'int4', Type::Integer
         register_class_with_limit m, 'int8', Type::Integer
@@ -142,7 +87,7 @@ module ArJdbc
         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 'json', Type::Json.new
         m.register_type 'jsonb', OID::Jsonb.new
         m.register_type 'cidr', OID::Cidr.new
         m.register_type 'inet', OID::Inet.new
@@ -187,48 +132,29 @@ module ArJdbc
           end
         end
 
-        load_additional_types(m)
-
-        # pgjdbc returns these if the column is auto-incrmenting
-        m.alias_type 'serial', 'int4'
-        m.alias_type 'bigserial', 'int8'
+        load_additional_types
       end
 
-      def load_additional_types(type_map, oid = nil) # :nodoc:
-        initializer = ArjdbcTypeMapInitializer.new(type_map)
+      def load_additional_types(oids = nil) # :nodoc:
+        initializer = OID::TypeMapInitializer.new(type_map)
 
         if supports_ranges?
           query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
+              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
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
           SQL
         else
           query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
               FROM pg_type as t
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
           SQL
         end
 
-        if oid
-          if oid.is_a? Numeric || oid.match(/^\d+$/)
-            # numeric OID
-            query += "WHERE t.oid::integer = %s" % oid
-
-          elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
-            # namespace and type name
-            query += "WHERE ns.nspname = '%s' AND t.typname = '%s'" % [m[1], m[2]]
-
-          else
-            # only type name
-            query += "WHERE t.typname = '%s' AND ns.nspname = ANY(current_schemas(true))" % oid
-          end
+        if oids
+          query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
         else
-          query += initializer.query_conditions_for_initial_load(type_map)
+          query += initializer.query_conditions_for_initial_load
         end
 
         records = execute(query, 'SCHEMA')
@@ -247,7 +173,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(:json, OID::Json, 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)
       ActiveRecord::Type.register(:point, OID::Point, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -12,6 +12,7 @@ require "active_record/connection_adapters/sqlite3/schema_creation"
 require "active_record/connection_adapters/sqlite3/schema_definitions"
 require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
+require "active_support/core_ext/class/attribute"
 
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
@@ -33,11 +34,10 @@ module ArJdbc
 
     # DIFFERENCE: FQN
     include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::ColumnDumper
     include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
 
     NATIVE_DATABASE_TYPES = {
-        primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
+        primary_key:  "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
         string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
@@ -47,9 +47,13 @@ module ArJdbc
         time:         { name: "time" },
         date:         { name: "date" },
         binary:       { name: "blob" },
-        boolean:      { name: "boolean" }
+        boolean:      { name: "boolean" },
+        json:         { name: "json" },
     }
 
+    # DIFFERENCE: class_attribute in original adapter is moved down to our section which is a class
+    #  since we cannot define it here in the module (original source this is a class).
+
     class StatementPool < ConnectionAdapters::StatementPool
       private
 
@@ -58,24 +62,11 @@ module ArJdbc
       end
     end
 
-    def update_table_definition(table_name, base) # :nodoc:
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::Table.new(table_name, base)
-    end
-
-    def schema_creation # :nodoc:
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaCreation.new self
-    end
-
-    def arel_visitor # :nodoc:
-      Arel::Visitors::SQLite.new(self)
-    end
-
-    def initialize(connection, logger, connection_options, config)
+    # DIFFERENCE: we remove connection_options because we are not using it.
+    def initialize(connection, logger, config)
       super(connection, logger, config)
 
-      @active     = nil
+      @active     = true
       @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
 
       configure_connection
@@ -93,12 +84,6 @@ module ArJdbc
       sqlite_version >= "3.8.0"
     end
 
-    # Returns true, since this connection adapter supports prepared statement
-    # caching.
-    def supports_statement_cache?
-      true
-    end
-
     def requires_reloading?
       true
     end
@@ -120,7 +105,7 @@ module ArJdbc
     end
 
     def active?
-      @active != false
+      @active
     end
 
     # Disconnects from the database if already connected. Otherwise, this
@@ -248,53 +233,6 @@ module ArJdbc
 
     # SCHEMA STATEMENTS ========================================
 
-    def new_column_from_field(table_name, field) # :nondoc:
-      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
-
-    # Returns an array of indexes for the given table.
-    def indexes(table_name, name = nil) #:nodoc:
-      if name
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing name to #indexes is deprecated without replacement.
-          MSG
-      end
-
-      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 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"] }
@@ -314,19 +252,20 @@ module ArJdbc
       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_type?(type)
-      type.to_sym != :primary_key
+    # DIFFERENCE: deprecated causes a JRuby 9.1 bug where "super" calls itself -> do inline
+    def valid_alter_table_type?(type, options = {})
+      ActiveSupport::Deprecation.deprecation_warning(__method__)
+      !invalid_alter_table_type?(type, options)
     end
+    #deprecate :valid_alter_table_type?
 
     def add_column(table_name, column_name, type, options = {}) #:nodoc:
-      if valid_alter_table_type?(type) && !options[:primary_key]
-        super(table_name, column_name, type, options)
-      else
+      if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
           definition.column(column_name, type, options)
         end
+      else
+        super
       end
     end
 
@@ -391,8 +330,32 @@ module ArJdbc
         ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row["table"], options)
       end
     end
+
+    def insert_fixtures(rows, table_name)
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          `insert_fixtures` is deprecated and will be removed in the next version of Rails.
+          Consider using `insert_fixtures_set` for performance improvement.
+      MSG
+      insert_fixtures_set(table_name => rows)
+    end
+
+    def insert_fixtures_set(fixture_set, tables_to_delete = [])
+      disable_referential_integrity do
+        transaction(requires_new: true) do
+          tables_to_delete.each { |table| delete "DELETE FROM #{quote_table_name(table)}", "Fixture Delete" }
+
+          fixture_set.each do |table_name, rows|
+            rows.each { |row| insert_fixture(row, table_name) }
+          end
+        end
+      end
+    end
     
     private
+    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")
@@ -400,7 +363,13 @@ module ArJdbc
       table_structure_with_collation(table_name, structure)
     end
     alias column_definitions table_structure
-    
+
+    # 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]
+    end
+
     def alter_table(table_name, options = {}) #:nodoc:
       altered_table_name = "a#{table_name}"
       caller = lambda { |definition| yield definition if block_given? }
@@ -551,23 +520,28 @@ module ArJdbc
       end
     end
 
-    def create_table_definition(*args)
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::TableDefinition.new(*args)
-    end
-
-    def extract_foreign_key_action(specifier)
-      case specifier
-      when "CASCADE"; :cascade
-      when "SET NULL"; :nullify
-      when "RESTRICT"; :restrict
-      end
+    def arel_visitor
+      Arel::Visitors::SQLite.new(self)
     end
 
     def configure_connection
       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
 
 module ActiveRecord::ConnectionAdapters
@@ -677,6 +651,25 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
 
+    # Note: This is part of original AR sqlite3_adapter.rb and not an override by us.  This is to just
+    # work around our copy of Sqlite3Adapter being a module above and not a class.
+    ##
+    # :singleton-method:
+    # Indicates whether boolean values are stored in sqlite3 databases as 1
+    # and 0 or 't' and 'f'. Leaving <tt>ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer</tt>
+    # set to false is deprecated. SQLite databases have used 't' and 'f' to
+    # serialize boolean values and must have old data converted to 1 and 0
+    # (its native boolean serialization) before setting this flag to true.
+    # Conversion can be accomplished by setting up a rake task which runs
+    #
+    #   ExampleModel.where("boolean_column = 't'").update_all(boolean_column: 1)
+    #   ExampleModel.where("boolean_column = 'f'").update_all(boolean_column: 0)
+    # for all models and all boolean columns, after which the flag must be set
+    # to true by adding the following to your <tt>application.rb</tt> file:
+    #
+    #   Rails.application.config.active_record.sqlite3.represent_boolean_as_integer = true
+    class_attribute :represent_boolean_as_integer, default: false
+
     def supports_transaction_isolation?
       false
     end
@@ -704,5 +697,8 @@ module ActiveRecord::ConnectionAdapters
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
     end
+
+    # Note: This is not an override of ours but a moved line from AR Sqlite3Adapter to register ours vs our copied module (which would be their class).
+#    ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
   end
 end