activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -42,7 +42,16 @@ ArJdbc::ConnectionMethods.module_eval do
     properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
     properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
 
+    # If prepared statements are off, lets make sure they are really *off*
+    properties['prepareThreshold'] = 0 unless config[:prepared_statements]
+
     jdbc_connection(config)
+  rescue ActiveRecord::JDBCError => e
+    if e.message.include?('does not exist')
+      raise ActiveRecord::NoDatabaseError, e.message
+    else
+      raise
+    end
   end
   alias_method :jdbcpostgresql_connection, :postgresql_connection
 end

data/lib/arjdbc/postgresql/name.rb

@@ -0,0 +1,24 @@
+# This patches the Name class so that it doesn't use pg gem specific quoting
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      class Name
+
+        def quoted
+          if schema
+            "#{quote_identifier(schema)}#{SEPARATOR}#{quote_identifier(identifier)}"
+          else
+            quote_identifier(identifier)
+          end
+        end
+
+        private
+
+        def quote_identifier(name)
+          %("#{name.to_s.gsub("\"", "\"\"")}")
+        end
+
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -3,13 +3,7 @@ require 'thread'
 module ArJdbc
   module PostgreSQL
 
-    if AR42
-      require 'active_record/connection_adapters/postgresql/oid'
-      require 'arjdbc/postgresql/oid/bytea.rb'
-    else
-      require 'arjdbc/postgresql/base/oid'
-    end
-
+    require 'active_record/connection_adapters/postgresql/oid'
     require 'arjdbc/postgresql/base/pgconn'
 
     def self.unescape_bytea(escaped)
@@ -22,6 +16,13 @@ module ArJdbc
     # @private
     module OIDTypes
 
+      # Support arrays/ranges for defining attributes that don't exist in the db
+      Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
+      Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
+      Type.register(:enum, OID::Enum, adapter: :postgresql)
+      Type.register(:point, OID::Rails51Point, adapter: :postgresql)
+      Type.register(:legacy_point, OID::Point, adapter: :postgresql)
+
       # @override
       def enable_extension(name)
         result = super(name)
@@ -47,14 +48,7 @@ module ArJdbc
       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
+      end
 
       def get_oid_type(oid, fmod, column_name, sql_type = '')
         if !type_map.key?(oid)
@@ -67,40 +61,10 @@ module ArJdbc
             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
+        @type_map
       end
 
       def reload_type_map
@@ -112,57 +76,6 @@ module ArJdbc
 
       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', Type::Integer
         register_class_with_limit m, 'int4', Type::Integer
@@ -192,19 +105,25 @@ module ArJdbc
         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 'box', OID::SpecializedString.new(:box)
+        m.register_type 'circle', OID::SpecializedString.new(:circle)
         m.register_type 'citext', OID::SpecializedString.new(:citext)
+        m.register_type 'line', OID::SpecializedString.new(:line)
+        m.register_type 'lseg', OID::SpecializedString.new(:lseg)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
+        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'path', OID::SpecializedString.new(:path)
+        m.register_type 'polygon', OID::SpecializedString.new(:polygon)
+        m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
 
-        # 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'
+        # This is how Rails 5.1 handles it. In 5.0 SpecializedString doesn't take a precision option
+        # 5.0 actually leaves it as a regular String but we need it specialized
+        # to support prepared statements
+        # m.register_type 'interval' do |_, _, sql_type|
+        #   precision = extract_precision(sql_type)
+        #   OID::SpecializedString.new(:interval, precision: precision)
+        # end
+        m.register_type 'interval', OID::SpecializedString.new(:interval)
 
         m.register_type 'timestamp' do |_, _, sql_type|
           precision = extract_precision(sql_type)
@@ -232,7 +151,7 @@ module ArJdbc
         end
 
         load_additional_types(m)
-      end if AR42
+      end
 
       def load_additional_types(type_map, oids = nil)
         if supports_ranges?
@@ -261,7 +180,7 @@ module ArJdbc
 
         records = execute(query, 'SCHEMA')
         initializer.run(records)
-      end if AR42
+      end
 
     end
   end

data/lib/arjdbc/sqlite3/adapter.rb

@@ -1,6 +1,9 @@
 ArJdbc.load_java_part :SQLite3
 
-require "arjdbc/common_jdbc_methods"
+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"
@@ -10,7 +13,10 @@ 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.
+  # 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
@@ -54,7 +60,8 @@ module ArJdbc
       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
@@ -639,52 +646,21 @@ module ActiveRecord::ConnectionAdapters
   # 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::CommonJdbcMethods
+    include ArJdbc::Abstract::Core
     include ArJdbc::SQLite3
+    include ArJdbc::Abstract::DatabaseStatements
+    include ArJdbc::Abstract::StatementCache
+    include ArJdbc::Abstract::TransactionSupport
+
+    def begin_isolated_db_transaction(isolation)
+      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+    end
 
     # FIXME: Add @connection.encoding then remove this method
     def encoding
       select_value 'PRAGMA encoding'
     end
 
-    def exec_query(sql, name = nil, binds = [], prepare: false)
-      use_prepared = prepare || !without_prepared_statement?(binds)
-
-      if use_prepared
-        type_casted_binds = prepare_binds_for_jdbc(binds)
-        log(sql, name, binds) { @connection.execute_prepared(sql, type_casted_binds) }
-      else
-        log(sql, name) { @connection.execute(sql) }
-      end
-    end
-
-    def exec_update(sql, name = nil, binds = [])
-      use_prepared = !without_prepared_statement?(binds)
-
-      if use_prepared
-        type_casted_binds = prepare_binds_for_jdbc(binds)
-        log(sql, name, binds) { @connection.execute_prepared_update(sql, type_casted_binds) }
-      else
-        log(sql, name) { @connection.execute_update(sql, nil) }
-      end
-    end
-    alias :exec_delete :exec_update
-
-    # Sqlite3 JDBC types in prepared statements seem to report blob as varchar (12).
-    # So to work around this we will pass attribute type in with the value so we can
-    # then remap to appropriate type in JDBC without needing to ask JDBC what type
-    # it should be using.  No one likes a stinking liar...
-    def prepare_binds_for_jdbc(binds)
-      binds.map do |attribute|
-        [attribute.type.type, type_cast(attribute.value_for_database)]
-      end
-    end
-
-    # last two values passed but not used so I cannot alias to exec_query
-    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-      exec_update(sql, name, binds)
-    end
-
     def indexes(table_name, name = nil) #:nodoc:
       # 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

data/lib/arjdbc/tasks/database_tasks.rb

@@ -32,11 +32,9 @@ module ArJdbc
     require 'arjdbc/tasks/h2_database_tasks'
     require 'arjdbc/tasks/hsqldb_database_tasks'
     require 'arjdbc/tasks/mssql_database_tasks'
-    require 'arjdbc/tasks/oracle_database_tasks'
 
     # re-invent built-in (but deprecated on 4.0) tasks :
     register_tasks(/sqlserver/, MSSQLDatabaseTasks)
-    register_tasks(/(oci|oracle)/, OracleDatabaseTasks)
     register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
     # tasks for custom (JDBC) adapters :
     register_tasks(/db2/, DB2DatabaseTasks)
@@ -51,4 +49,4 @@ module ArJdbc
     # - while on 2.3/3.x we keep the AR built-in task behavior
 
   end
-end
+end

data/lib/arjdbc/tasks/db2_database_tasks.rb

@@ -82,9 +82,9 @@ module ArJdbc
           ensure
             pk_rs.close
           end
-          primary_keys.each do |name, cols|
+          primary_keys.each do |constraint_name, cols|
             dump << "ALTER TABLE #{connection.quote_table_name(table_name)}\n"
-            dump << "  ADD CONSTRAINT #{name}\n"
+            dump << "  ADD CONSTRAINT #{constraint_name}\n"
             dump << "    PRIMARY KEY (#{cols.join(', ')});\n\n"
           end
         end

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 module ArJdbc
-  VERSION = "5.0.pre1"
+  VERSION = "50.0"
   # @deprecated
   module Version
     # @private 1.2.x compatibility

data/pom.xml

@@ -12,7 +12,7 @@
   <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
 
   <properties>
-    <jruby.version>1.6.8</jruby.version>
+    <jruby.version>9.1.6.0</jruby.version>
   </properties>
 
   <issueManagement>
@@ -103,8 +103,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.5.1</version>
         <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
+          <source>1.7</source>
+          <target>1.7</target>
         </configuration>
       </plugin>
     </plugins>

data/rakelib/02-test.rake

@@ -17,15 +17,6 @@ task 'test_postgresql_with_hint' do
   end
 end
 
-task 'test_appraisal_hint' do
-  next if File.exists?('.disable-appraisal-hint')
-  unless (ENV['BUNDLE_GEMFILE'] || '') =~ /gemfiles\/.*?\.gemfile/
-    appraisals = []; Appraisal::File.each { |file| appraisals << file.name }
-    puts "HINT: specify AR version with `rake appraisal:{version} test_{adapter}'" +
-         " where version=(#{appraisals.join('|')}) (`touch .disable-appraisal-hint' to disable)"
-  end
-end
-
 Rake::TestTask.class_eval { attr_reader :test_files }
 
 def test_task_for(adapter, options = {})
@@ -34,9 +25,6 @@ def test_task_for(adapter, options = {})
   adapter = adapter.to_s.downcase
   driver = adapter if ( driver = options[:driver] ).nil?
   prereqs = options[:prereqs] || []
-  unless prereqs.frozen?
-    prereqs = [ prereqs ].flatten; prereqs << 'test_appraisal_hint'
-  end
   name = options[:name] || "test_#{adapter}"
   test_task = Rake::TestTask.new(name => prereqs) do |test_task|
     files = options[:files] || begin

data/rakelib/compile.rake

@@ -11,7 +11,7 @@ begin
   file jar_file => FileList['src/java/**/*.java', 'pkg/classes'] do
     rm_rf FileList["#{classes}/**/*"]
     ant.javac :srcdir => "src/java", :destdir => "pkg/classes",
-      :source => "1.6", :target => "1.6", :debug => true, :deprecation => true,
+      :source => "7", :target => "7", :debug => true, :deprecation => true,
       :classpath => "${java.class.path}:${sun.boot.class.path}:#{driver_jars.join(':')}",
       :includeantRuntime => false
 

data/rakelib/db.rake

@@ -6,6 +6,7 @@ namespace :db do
   task :mysql do
     fail "could not create test database: mysql executable not found" unless mysql = which('mysql')
     load 'test/db/mysql_config.rb' # rescue nil
+    puts MYSQL_CONFIG.inspect if $VERBOSE
     script = sql_script <<-SQL, 'mysql'
 DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
 CREATE USER #{MYSQL_CONFIG[:username]}@localhost;
@@ -15,13 +16,13 @@ GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
 SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
 SQL
     params = { '-u' => 'root' }
-    if ENV['DATABASE_YML']
-      require 'yaml'
-      password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
-      params['--password'] = password
+    if ENV['DATABASE_YML']; require 'yaml'
+      params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
     end
+    params['-u'] = ENV['MY_USER'] if ENV['MY_USER']
+    params['-p'] = ENV['MY_PASSWORD'] if ENV['MY_PASSWORD']
     puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
-    sh "cat #{script.path} | #{mysql} -f #{params.to_a.join(' ')}", :verbose => $VERBOSE # so password is not echoed
+    sh "cat #{script.path} | #{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}", :verbose => $VERBOSE # so password is not echoed
   end
 
   desc "Creates the test database for PostgreSQL"
@@ -29,6 +30,7 @@ SQL
     fail 'could not create test database: psql executable not found' unless psql = which('psql')
     fail 'could not create test database: missing "postgres" role' unless PostgresHelper.postgres_role?
     load 'test/db/postgres_config.rb' # rescue nil
+    puts POSTGRES_CONFIG.inspect if $VERBOSE
     script = sql_script <<-SQL, 'psql'
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
 DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};