neo-activerecord-jdbc-adapter 5.0.pre2

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+\(.*\)} === default )
+      end
+
+    end
+
+  end
+end

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -0,0 +1,54 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def postgresql_connection(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
+    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 )
+    database = config[:database] || config[:dbname] || ENV['PGDATABASE']
+
+    config[:url] ||= "jdbc:postgresql://#{host}:#{port}/#{database}"
+    config[:url] << config[:pg_params] if config[:pg_params] # should go away
+
+    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'
+      properties['ssl'] ||= 'true' if sslmode == true || sslmode.to_s == 'require'
+    end
+    properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
+    properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
+
+    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

@@ -0,0 +1,178 @@
+require 'thread'
+
+module ArJdbc
+  module PostgreSQL
+
+    require 'active_record/connection_adapters/postgresql/oid'
+    require 'arjdbc/postgresql/base/pgconn'
+
+    def self.unescape_bytea(escaped)
+      String.from_java_bytes Java::OrgPostgresqlUtil::PGbytea.toBytes escaped.to_java_bytes
+    end
+
+    # @private
+    OID = ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+
+    # @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)
+
+      # @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 = '')
+        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 'time', Type::Time.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)
+
+        # 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 'timestamp' do |_, _, sql_type|
+          precision = extract_precision(sql_type)
+          OID::DateTime.new(precision: precision)
+        end
+
+        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)
+      end
+
+      def load_additional_types(type_map, oids = nil)
+        if supports_ranges?
+          query = <<-SQL
+            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
+          SQL
+        else
+          query = <<-SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
+            FROM pg_type as t
+          SQL
+        end
+
+        initializer = OID::TypeMapInitializer.new(type_map)
+
+        if oids
+          query << ( "WHERE t.oid::integer IN (%s)" % oids.join(", ") )
+        else
+          # query_conditions_for_initial_load only available since AR > 4.2.1
+          if initializer.respond_to?(:query_conditions_for_initial_load)
+            query << initializer.query_conditions_for_initial_load(type_map)
+          end
+        end
+
+        records = execute(query, 'SCHEMA')
+        initializer.run(records)
+      end
+
+    end
+  end
+end