activerecord-jdbc-adapter 5.0.pre1 → 51.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::Point, adapter: :postgresql)
+      Type.register(:legacy_point, OID::LegacyPoint, 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,62 +76,11 @@ 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
         register_class_with_limit m, 'int8', Type::Integer
-        m.alias_type 'oid', 'int2'
+        m.register_type 'oid', OID::Oid.new
         m.register_type 'float4', Type::Float.new
         m.alias_type 'float8', 'float4'
         m.register_type 'text', Type::Text.new
@@ -192,19 +105,21 @@ 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'
+        m.register_type 'interval' do |_, _, sql_type|
+          precision = extract_precision(sql_type)
+          OID::SpecializedString.new(:interval, precision: precision)
+        end
 
         m.register_type 'timestamp' do |_, _, sql_type|
           precision = extract_precision(sql_type)
@@ -232,7 +147,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 +176,7 @@ module ArJdbc
 
         records = execute(query, 'SCHEMA')
         initializer.run(records)
-      end if AR42
+      end
 
     end
   end