activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arjdbc/postgresql/base/array_decoder.rb

@@ -0,0 +1,26 @@
+# This implements a basic decoder to work around ActiveRecord's dependence on the pg gem
+module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+  class Array < ActiveModel::Type::Value
+    module PG
+      module TextDecoder
+        class Array
+          # Loads pg_array_parser if available. String parsing can be
+          # performed quicker by a native extension, which will not create
+          # a large amount of Ruby objects that will need to be garbage
+          # collected. pg_array_parser has a C and Java extension
+          begin
+            require 'pg_array_parser'
+            include PgArrayParser
+          rescue LoadError
+            require_relative 'array_parser'
+            include ActiveRecord::ConnectionAdapters::PostgreSQL::ArrayParser
+          end
+
+          def initialize(name:, delimiter:); end
+
+          alias_method :decode, :parse_pg_array
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/base/array_encoder.rb

@@ -0,0 +1,25 @@
+# This implements a basic encoder to work around ActiveRecord's dependence on the pg gem
+module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+  class Array < ActiveModel::Type::Value
+    module PG
+      module TextEncoder
+        class Array
+
+          def initialize(name:, delimiter:)
+            @type = if name == 'string[]'.freeze
+                      'text'.freeze
+                    else
+                      base_type = name.chomp('[]'.freeze).to_sym
+                      ActiveRecord::Base.connection.native_database_types[base_type][:name]
+                    end
+          end
+
+          def encode(values)
+            ActiveRecord::Base.connection.jdbc_connection.create_array_of(@type, values.to_java).to_s
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/base/array_parser.rb

@@ -0,0 +1,95 @@
+# based on active_record/connection_adapters/postgresql/array_parser.rb
+# until it's some day shareable with Rails ... this is not public API !
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module ArrayParser
+
+        DOUBLE_QUOTE = '"'
+        BACKSLASH = "\\"
+        COMMA = ','
+        BRACKET_OPEN = '{'
+        BRACKET_CLOSE = '}'
+
+        def parse_pg_array(string)
+          local_index = 0
+          array = []
+          while(local_index < string.length)
+            case string[local_index]
+            when BRACKET_OPEN
+              local_index,array = parse_array_contents(array, string, local_index + 1)
+            when BRACKET_CLOSE
+              return array
+            end
+            local_index += 1
+          end
+
+          array
+        end
+
+        private
+
+          def parse_array_contents(array, string, index)
+            is_escaping  = false
+            is_quoted    = false
+            was_quoted   = false
+            current_item = ''
+
+            local_index = index
+            while local_index
+              token = string[local_index]
+              if is_escaping
+                current_item << token
+                is_escaping = false
+              else
+                if is_quoted
+                  case token
+                  when DOUBLE_QUOTE
+                    is_quoted = false
+                    was_quoted = true
+                  when BACKSLASH
+                    is_escaping = true
+                  else
+                    current_item << token
+                  end
+                else
+                  case token
+                  when BACKSLASH
+                    is_escaping = true
+                  when COMMA
+                    add_item_to_array(array, current_item, was_quoted)
+                    current_item = ''
+                    was_quoted = false
+                  when DOUBLE_QUOTE
+                    is_quoted = true
+                  when BRACKET_OPEN
+                    internal_items = []
+                    local_index,internal_items = parse_array_contents(internal_items, string, local_index + 1)
+                    array.push(internal_items)
+                  when BRACKET_CLOSE
+                    add_item_to_array(array, current_item, was_quoted)
+                    return local_index,array
+                  else
+                    current_item << token
+                  end
+                end
+              end
+
+              local_index += 1
+            end
+            return local_index,array
+          end
+
+          def add_item_to_array(array, current_item, quoted)
+            return if !quoted && current_item.length == 0
+
+            if !quoted && current_item == 'NULL'
+              array.push nil
+            else
+              array.push current_item
+            end
+          end
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/base/pgconn.rb

@@ -0,0 +1,11 @@
+module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+  class Bytea < ActiveModel::Type::Binary
+    module PG
+      class Connection # emulate PG::Connection#unescape_bytea due #652
+        def self.unescape_bytea(escaped)
+          ArJdbc::PostgreSQL.unescape_bytea(escaped)
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/postgresql/column.rb

@@ -0,0 +1,51 @@
+module ArJdbc
+  module PostgreSQL
+
+    # @private these are defined on the Adapter class since 4.2
+    module ColumnHelpers
+
+      def extract_limit(sql_type) # :nodoc:
+        case sql_type
+        when /^bigint/i, /^int8/i then 8
+        when /^smallint/i then 2
+        when /^timestamp/i then nil
+        else
+          super
+        end
+      end
+
+      # Extracts the value from a PostgreSQL column default definition.
+      def extract_value_from_default(default) # :nodoc:
+        case default
+          # Quoted types
+          when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
+            # The default 'now'::date is CURRENT_DATE
+            if $1 == "now".freeze && $2 == "date".freeze
+              nil
+            else
+              $1.gsub("''".freeze, "'".freeze)
+            end
+          # Boolean types
+          when 'true'.freeze, 'false'.freeze
+            default
+          # Numeric types
+          when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
+            $1
+          # Object identifier types
+          when /\A-?\d+\z/
+            $1
+          else
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            nil
+        end
+      end
+
+      def extract_default_function(default_value, default) # :nodoc:
+        default if ! default_value && ( %r{\w+\(.*\)|\(.*\)::\w+} === default )
+      end
+
+    end
+
+  end
+end

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+ArJdbc::ConnectionMethods.module_eval do
+  def postgresql_connection(config)
+    # 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 ;(
+    config = symbolize_keys_if_necessary(config)
+
+    config[:adapter_spec] ||= ::ArJdbc::PostgreSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/postgres'
+      ::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'
+
+    host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
+    port = config[:port] ||= ( ENV['PGPORT'] || 5432 )
+    database = config[:database] || config[:dbname] || ENV['PGDATABASE']
+
+    config[:url] ||= "jdbc:postgresql://#{host}:#{port}/#{database}"
+    config[:url] << config[:pg_params] if config[:pg_params]
+
+    config[:username] ||= ( config[:user] || ENV['PGUSER'] || ENV_JAVA['user.name'] )
+    config[:password] ||= ENV['PGPASSWORD'] unless config.key?(:password)
+    properties = ( config[:properties] ||= {} )
+    # PG :connect_timeout - maximum time to wait for connection to succeed
+    if connect_timeout = ( config[:connect_timeout] || ENV['PGCONNECT_TIMEOUT'] )
+      properties['socketTimeout'] ||= connect_timeout
+    end
+    if login_timeout = config[:login_timeout]
+      properties['loginTimeout'] ||= login_timeout
+    end
+    sslmode = config.key?(:sslmode) ? config[:sslmode] : config[:requiressl]
+    # NOTE: makes not much sense since this needs some JVM options :
+    sslmode = ENV['PGSSLMODE'] || ENV['PGREQUIRESSL'] if sslmode.nil?
+    unless sslmode.nil? # PG :sslmode - disable|allow|prefer|require
+      # JRuby/JVM needs to be started with :
+      #  -Djavax.net.ssl.trustStore=mystore -Djavax.net.ssl.trustStorePassword=...
+      # or a non-validating connection might be used (for testing) :
+      #  :sslfactory = 'org.postgresql.ssl.NonValidatingFactory'
+      if sslmode == true || sslmode.to_s == 'require'
+        properties['sslfactory'] ||= 'org.postgresql.ssl.NonValidatingFactory' if driver.start_with?('org.postgresql.')
+        properties['ssl'] ||= 'true'
+      end
+    end
+    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
+
+    jdbc_connection(config)
+  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

@@ -0,0 +1,266 @@
+require 'thread'
+
+module ArJdbc
+  module PostgreSQL
+
+    require 'active_record/connection_adapters/postgresql/oid'
+    require 'arjdbc/postgresql/base/pgconn'
+
+    # @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
+
+      # @override
+      def enable_extension(name)
+        result = super(name)
+        @extensions = nil
+        reload_type_map
+        result
+      end
+
+      # @override
+      def disable_extension(name)
+        result = super(name)
+        @extensions = nil
+        reload_type_map
+        result
+      end
+
+      # @override
+      def extensions
+        @extensions ||= super
+      end
+
+      # @override
+      def lookup_cast_type(sql_type)
+        oid = execute("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA")
+        super oid.first['oid'].to_i
+      end
+
+      def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
+        if !type_map.key?(oid)
+          load_additional_types(type_map, oid)
+        end
+
+        type_map.fetch(oid, fmod, sql_type) {
+          warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+          Type::Value.new.tap do |cast_type|
+            type_map.register_type(oid, cast_type)
+          end
+        }
+      end
+
+      def type_map
+        @type_map
+      end
+
+      def reload_type_map
+        if ( @type_map ||= nil )
+          @type_map.clear
+          initialize_type_map(@type_map)
+        end
+      end
+
+      private
+
+      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 'float4', Type::Float.new
+        m.alias_type 'float8', 'float4'
+        m.register_type 'text', Type::Text.new
+        register_class_with_limit m, 'varchar', Type::String
+        m.alias_type 'char', 'varchar'
+        m.alias_type 'name', 'varchar'
+        m.alias_type 'bpchar', 'varchar'
+        m.register_type 'bool', Type::Boolean.new
+        register_class_with_limit m, 'bit', OID::Bit
+        register_class_with_limit m, 'varbit', OID::BitVarying
+        m.alias_type 'timestamptz', 'timestamp'
+        m.register_type 'date', Type::Date.new
+
+        m.register_type 'money', OID::Money.new
+        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 'jsonb', OID::Jsonb.new
+        m.register_type 'cidr', OID::Cidr.new
+        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 'citext', OID::SpecializedString.new(:citext)
+        m.register_type 'ltree', OID::SpecializedString.new(:ltree)
+        m.register_type 'line', OID::SpecializedString.new(:line)
+        m.register_type 'lseg', OID::SpecializedString.new(:lseg)
+        m.register_type 'box', OID::SpecializedString.new(:box)
+        m.register_type 'path', OID::SpecializedString.new(:path)
+        m.register_type 'polygon', OID::SpecializedString.new(:polygon)
+        m.register_type 'circle', OID::SpecializedString.new(:circle)
+
+        #m.alias_type 'interval', 'varchar' # in Rails 5.0
+        # 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)
+
+        register_class_with_precision m, 'time', Type::Time
+        register_class_with_precision m, 'timestamp', OID::DateTime
+
+        m.register_type 'numeric' do |_, fmod, sql_type|
+          precision = extract_precision(sql_type)
+          scale = extract_scale(sql_type)
+
+          # The type for the numeric depends on the width of the field,
+          # so we'll do something special here.
+          #
+          # When dealing with decimal columns:
+          #
+          # places after decimal  = fmod - 4 & 0xffff
+          # places before decimal = (fmod - 4) >> 16 & 0xffff
+          if fmod && (fmod - 4 & 0xffff).zero?
+            # FIXME: Remove this class, and the second argument to
+            # lookups on PG
+            Type::DecimalWithoutScale.new(precision: precision)
+          else
+            OID::Decimal.new(precision: precision, scale: scale)
+          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'
+      end
+
+      def load_additional_types(type_map, oid = nil) # :nodoc:
+        initializer = ArjdbcTypeMapInitializer.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
+              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
+              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
+        else
+          query += initializer.query_conditions_for_initial_load(type_map)
+        end
+
+        records = execute(query, 'SCHEMA')
+        initializer.run(records)
+      end
+
+      # Support arrays/ranges for defining attributes that don't exist in the db
+      ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
+      ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
+      ActiveRecord::Type.register(:bit, OID::Bit, adapter: :postgresql)
+      ActiveRecord::Type.register(:bit_varying, OID::BitVarying, adapter: :postgresql)
+      ActiveRecord::Type.register(:binary, OID::Bytea, adapter: :postgresql)
+      ActiveRecord::Type.register(:cidr, OID::Cidr, adapter: :postgresql)
+      ActiveRecord::Type.register(:datetime, OID::DateTime, adapter: :postgresql)
+      ActiveRecord::Type.register(:decimal, OID::Decimal, adapter: :postgresql)
+      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(:jsonb, OID::Jsonb, adapter: :postgresql)
+      ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)
+      ActiveRecord::Type.register(:point, OID::Rails51Point, adapter: :postgresql)
+      ActiveRecord::Type.register(:legacy_point, OID::Point, adapter: :postgresql)
+      ActiveRecord::Type.register(:uuid, OID::Uuid, adapter: :postgresql)
+      ActiveRecord::Type.register(:vector, OID::Vector, adapter: :postgresql)
+      ActiveRecord::Type.register(:xml, OID::Xml, adapter: :postgresql)
+
+    end
+  end
+end