activerecord-jdbc-adapter 60.0.rc1-java → 60.1-java

data/lib/arjdbc/db2/column.rb

@@ -80,45 +80,6 @@ module ArJdbc
 
       private
 
-      def simplified_type(field_type)
-        case field_type
-        when /^decimal\(1\)$/i   then DB2.emulate_booleans? ? :boolean : :integer
-        when /smallint/i         then DB2.emulate_booleans? ? :boolean : :integer
-        when /boolean/i          then :boolean
-        when /^real|double/i     then :float
-        when /int|serial/i       then :integer
-        # if a numeric column has no scale, lets treat it as an integer.
-        # The AS400 rpg guys do this ALOT since they have no integer datatype ...
-        when /decimal|numeric|decfloat/i
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /timestamp/i        then :timestamp
-        when /datetime/i         then :datetime
-        when /time/i             then :time
-        when /date/i             then :date
-        # DB2 provides three data types to store these data objects as strings of up to 2 GB in size:
-        #  Character large objects (CLOBs)
-        #    Use the CLOB data type to store SBCS or mixed data, such as documents that contain
-        #    single character set. Use this data type if your data is larger (or might grow larger)
-        #    than the VARCHAR data type permits.
-        #  Double-byte character large objects (DBCLOBs)
-        #    Use the DBCLOB data type to store large amounts of DBCS data, such as documents that
-        #    use a DBCS character set.
-        #  Binary large objects (BLOBs)
-        #    Use the BLOB data type to store large amounts of noncharacter data, such as pictures,
-        #    voice, and mixed media.
-        when /clob|text/i        then :text # handles DBCLOB
-        when /^long varchar/i    then :text # :limit => 32700
-        when /blob|binary/i      then :binary
-        # varchar () for bit data, char () for bit data, long varchar for bit data
-        when /for bit data/i     then :binary
-        when /xml/i              then :xml
-        when /graphic/i          then :graphic # vargraphic, long vargraphic
-        when /rowid/i            then :rowid # rowid is a supported datatype on z/OS and i/5
-        else
-          super
-        end
-      end
-
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # IBM i (AS400) will return an empty string instead of null for no default

data/lib/arjdbc/derby/adapter.rb

@@ -65,25 +65,6 @@ module ArJdbc
         limit
       end
 
-      def simplified_type(field_type)
-        case field_type
-        when /^smallint/i    then Derby.emulate_booleans? ? :boolean : :integer
-        when /^bigint|int/i  then :integer
-        when /^real|double/i then :float
-        when /^dec/i         then # DEC is a DECIMAL alias
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /^timestamp/i   then :datetime
-        when /^xml/i         then :xml
-        when 'long varchar'  then :text
-        when /for bit data/i then :binary
-        # :name=>"long varchar for bit data", :limit=>32700
-        # :name=>"varchar() for bit data", :limit=>32672
-        # :name=>"char() for bit data", :limit=>254}
-        else
-          super
-        end
-      end
-
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # JDBC returns column default strings with actual single quotes around the value.
@@ -420,7 +401,7 @@ module ArJdbc
 
     # @override
     def supports_ddl_transactions?; true end
- 
+
     # @override
     def supports_foreign_keys?; true end
 

data/lib/arjdbc/firebird/adapter.rb

@@ -38,27 +38,6 @@ module ArJdbc
           return $1 unless $1.upcase == 'NULL'
         end
       end
-
-      private
-
-      def simplified_type(field_type)
-        case field_type
-        when /timestamp/i    then :datetime
-        when /^smallint/i    then :integer
-        when /^bigint|int/i  then :integer
-        when /^double/i      then :float # double precision
-        when /^decimal/i     then
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /^char\(1\)$/i  then Firebird.emulate_booleans? ? :boolean : :string
-        when /^char/i        then :string
-        when /^blob\ssub_type\s(\d)/i
-          return :binary if $1 == '0'
-          return :text   if $1 == '1'
-        else
-          super
-        end
-      end
-
     end
 
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class

data/lib/arjdbc/h2/adapter.rb

@@ -47,21 +47,6 @@ module ArJdbc
         limit
       end
 
-      def simplified_type(field_type)
-        case field_type
-        when /^bit|bool/i         then :boolean
-        when /^signed|year/i      then :integer
-        when /^real|double/i      then :float
-        when /^varchar/i          then :string
-        when /^longvarchar/i      then :text
-        when /^binary|raw|bytea/i then :binary
-        when /varbinary/i         then :binary # longvarbinary, varbinary
-        when /^blob|image|oid/i   then :binary
-        else
-          super
-        end
-      end
-
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # H2 auto-generated key default value

data/lib/arjdbc/hsqldb/adapter.rb

@@ -42,20 +42,6 @@ module ArJdbc
         limit
       end
 
-      def simplified_type(field_type)
-        case field_type
-        when /^nvarchar/i    then :string
-        when /^character/i   then :string
-        when /^longvarchar/i then :text
-        when /int/i          then :integer # TINYINT, SMALLINT, BIGINT, INT
-        when /real|double/i  then :float
-        when /^bit/i         then :boolean
-        when /binary/i       then :binary # VARBINARY, LONGVARBINARY
-        else
-          super
-        end
-      end
-
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # JDBC returns column default strings with actual single quotes around the value.

data/lib/arjdbc/informix/adapter.rb

@@ -28,11 +28,6 @@ module ArJdbc
       end
     end
 
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
-    def self.column_selector
-      [ /informix/i, lambda { |cfg, column| column.extend(ColumnMethods) } ]
-    end
-
     JdbcConnection = ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
 
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
@@ -45,20 +40,6 @@ module ArJdbc
       ::ActiveRecord::ConnectionAdapters::InformixColumn
     end
 
-    module ColumnMethods
-
-      private
-      # TODO: Test all Informix column types.
-      def simplified_type(field_type)
-        if field_type =~ /serial/i
-          :primary_key
-        else
-          super
-        end
-      end
-
-    end
-
     def modify_types(types)
       super(types)
       types[:primary_key] = "SERIAL PRIMARY KEY"
@@ -152,10 +133,6 @@ module ArJdbc
 end # module ::ArJdbc
 
 module ActiveRecord::ConnectionAdapters
-  class InformixColumn < JdbcColumn
-    include ::ArJdbc::Informix::ColumnMethods
-  end
-
   class InformixAdapter < JdbcAdapter
     include ::ArJdbc::Informix
   end

data/lib/arjdbc/jdbc.rb

@@ -2,12 +2,8 @@ require 'active_support/deprecation'
 
 module ArJdbc
 
-  # @private
-  AR40 = ::ActiveRecord::VERSION::MAJOR > 3
   # @private
   AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
-  # @private
-  AR50 = ::ActiveRecord::VERSION::MAJOR > 4
 
   # @private
   AR52 = ::ActiveRecord::VERSION::STRING >= '5.2'

data/lib/arjdbc/jdbc/adapter.rb

@@ -360,6 +360,10 @@ module ActiveRecord
       # @return [Integer, NilClass]
       def last_inserted_id(result)
         if result.is_a?(Hash) || result.is_a?(ActiveRecord::Result)
+          # If table does not have primary key defined
+          return nil if result.first.blank?
+
+
           result.first.first[1] # .first = { "id"=>1 } .first = [ "id", 1 ]
         else
           result

data/lib/arjdbc/jdbc/column.rb

@@ -30,17 +30,13 @@ module ActiveRecord
 
         if ArJdbc::AR52
           # undefined method `cast' for #<ActiveRecord::ConnectionAdapters::SqlTypeMetadata> on AR52
-        elsif ArJdbc::AR50
+        else
           default = args[0].cast(default)
 
           sql_type = args.delete_at(1)
           type = args.delete_at(0)
 
           args.unshift(SqlTypeMetadata.new(:sql_type => sql_type, :type => type))
-        elsif ArJdbc::AR42
-          default = args[0].type_cast_from_database(default)
-        else
-          default = default_value(default)
         end
 
         # super <= 4.1: (name, default, sql_type = nil, null = true)

data/lib/arjdbc/mysql/adapter.rb

@@ -40,6 +40,15 @@ module ActiveRecord
         # configure_connection taken care of at ArJdbc::Abstract::Core
       end
 
+      def self.database_exists?(config)
+        conn = ActiveRecord::Base.mysql2_connection(config)
+        conn && conn.really_valid?
+      rescue ActiveRecord::NoDatabaseError
+        false
+      ensure
+        conn.disconnect! if conn
+      end
+
       def check_version
         # for JNDI, don't check version as the whole connection should be lazy
         return if ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
@@ -78,7 +87,9 @@ module ActiveRecord
       # HELPER METHODS ===========================================
 
       # from MySQL::DatabaseStatements
-      READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
+      READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+        :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc
+      ) # :nodoc:
       private_constant :READ_QUERY
 
       def write_query?(sql) # :nodoc:

data/lib/arjdbc/mysql/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def mysql_connection(config)
+    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.mysql2_connection ActiveRecord::Base.configurations['arunit'].merge(database: ...)
     config = symbolize_keys_if_necessary(config)
@@ -10,11 +11,9 @@ ArJdbc::ConnectionMethods.module_eval do
 
     return jndi_connection(config) if jndi_config?(config)
 
-    driver = config[:driver] ||=
-      defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
-
-    mysql_driver = driver.start_with?('com.mysql.')
-    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
+    driver = config[:driver]
+    mysql_driver = driver.nil? || driver.to_s.start_with?('com.mysql.')
+    mariadb_driver = ! mysql_driver && driver.to_s.start_with?('org.mariadb.')
 
     begin
       require 'jdbc/mysql'
@@ -22,6 +21,11 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end if mysql_driver
 
+    if driver.nil?
+      config[:driver] ||=
+        defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
+    end
+
     config[:username] = 'root' unless config.key?(:username)
     # jdbc:mysql://[host][,failoverhost...][:port]/[database]
     # - if the host name is not specified, it defaults to 127.0.0.1
@@ -36,7 +40,8 @@ ArJdbc::ConnectionMethods.module_eval do
 
     properties = ( config[:properties] ||= {} )
     if mysql_driver
-      properties['zeroDateTimeBehavior'] ||= 'convertToNull'
+      properties['zeroDateTimeBehavior'] ||=
+        config[:driver].to_s.start_with?('com.mysql.cj.') ? 'CONVERT_TO_NULL' : 'convertToNull'
       properties['jdbcCompliantTruncation'] ||= false
       # NOTE: this is "better" than passing what users are used to set on MRI
       # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
@@ -108,7 +113,8 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
 
-    config[:driver] ||= 'org.mariadb.jdbc.Driver'
+    config[:driver] ||=
+      defined?(::Jdbc::MariaDB.driver_name) ? ::Jdbc::MariaDB.driver_name : 'org.mariadb.jdbc.Driver'
 
     mysql_connection(config)
   end

data/lib/arjdbc/postgresql/adapter.rb

@@ -365,7 +365,7 @@ module ArJdbc
       @use_insert_returning
     end
 
-    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
       val = super
       if !use_insert_returning? && pk
         unless sequence_name
@@ -384,24 +384,6 @@ module ArJdbc
       ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query("EXPLAIN #{sql}", 'EXPLAIN', binds))
     end
 
-    # @note Only for "better" AR 4.0 compatibility.
-    # @private
-    def query(sql, name = nil)
-      materialize_transactions
-
-      log(sql, name) do
-        result = []
-        @connection.execute_query_raw(sql, []) do |*values|
-          # We need to use #deep_dup here because it appears that
-          # the java method is reusing an object in some cases
-          # which makes all of the entries in the "result"
-          # array end up with the same values as the last row
-          result << values.deep_dup
-        end
-        result
-      end
-    end
-
     # from ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
     private_constant :READ_QUERY
@@ -698,6 +680,15 @@ module ActiveRecord::ConnectionAdapters
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
 
+    def self.database_exists?(config)
+      conn = ActiveRecord::Base.postgresql_connection(config)
+      conn && conn.really_valid?
+    rescue ActiveRecord::NoDatabaseError
+      false
+    ensure
+      conn.disconnect! if conn
+    end
+
     require 'active_record/connection_adapters/postgresql/schema_definitions'
 
     ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods

data/lib/arjdbc/postgresql/column.rb

@@ -17,7 +17,7 @@ module ArJdbc
       end
 
       # Extracts the value from a PostgreSQL column default definition.
-      def extract_value_from_default(default) # :nodoc:
+      def extract_value_from_default(default)
         case default
           # Quoted types
           when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
@@ -43,10 +43,13 @@ module ArJdbc
         end
       end
 
-      def extract_default_function(default_value, default) # :nodoc:
-        default if ! default_value && ( %r{\w+\(.*\)|\(.*\)::\w+} === default )
+      def extract_default_function(default_value, default)
+        default if has_default_function?(default_value, default)
       end
 
+      def has_default_function?(default_value, default)
+        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+      end
     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 ;(
@@ -16,7 +17,8 @@ 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] ||= 'org.postgresql.Driver'
+    driver = (config[:driver] ||=
+      defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver')
 
     host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
     port = config[:port] ||= ( ENV['PGPORT'] || 5432 )

data/lib/arjdbc/sqlite3/adapter.rb

@@ -494,9 +494,9 @@ module ArJdbc
       result = exec_query(sql, "SCHEMA").first
 
       if result
-        # Splitting with left parentheses and picking up last will return all
+        # Splitting with left parentheses and discarding the first part will return all
         # columns separated with comma(,).
-        columns_string = result["sql"].split("(").last
+        columns_string = result["sql"].split("(", 2).last
 
         columns_string.split(",").each do |column_string|
           # This regex will match the column name and collation type and will save
@@ -596,24 +596,6 @@ module ActiveRecord::ConnectionAdapters
 
     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
@@ -660,6 +642,17 @@ module ActiveRecord::ConnectionAdapters
       )
     end
 
+    def self.database_exists?(config)
+      config = config.symbolize_keys
+      if config[:database] == ":memory:"
+        return true
+      else
+        database_file = defined?(Rails.root) ? File.expand_path(config[:database], Rails.root) : config[:database]
+        File.exist?(database_file)
+      end
+    end
+
+
     def supports_transaction_isolation?
       false
     end
@@ -667,7 +660,7 @@ module ActiveRecord::ConnectionAdapters
     def begin_isolated_db_transaction(isolation)
       raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
     end
-    
+
     # 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