Module: ArJdbc::Abstract::Core

Included in:
ActiveRecord::ConnectionAdapters::JdbcAdapter, ActiveRecord::ConnectionAdapters::MSSQLAdapter, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, ActiveRecord::ConnectionAdapters::SQLite3Adapter
Defined in:
lib/arjdbc/abstract/core.rb

Overview

This is minimum amount of code needed from base JDBC Adapter class to make common adapters work. This replaces using jdbc/adapter as a base class for all adapters.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



10
11
12
 
# File 'lib/arjdbc/abstract/core.rb', line 10

def config
  @config
end

Instance Method Details

#extract_raw_bind_values(binds) ⇒ Object (protected) 



64
65
66
 
# File 'lib/arjdbc/abstract/core.rb', line 64

def extract_raw_bind_values(binds)
  binds.map(&:value_for_database)
end

#initialize(connection, logger = nil, config = {}) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/arjdbc/abstract/core.rb', line 12

def initialize(connection, logger = nil, config = {})
  @config = config

  if self.class.equal? ActiveRecord::ConnectionAdapters::JdbcAdapter
    spec = @config.key?(:adapter_spec) ? @config[:adapter_spec] :
               ( @config[:adapter_spec] = adapter_spec(@config) ) # due resolving visitor
    extend spec if spec
  end

  connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)

  super(connection, logger, config) # AbstractAdapter

  connection.configure_connection # will call us (maybe)
end

#jdbc_connection(unwrap = nil) ⇒ Java::JavaSql::Connection

Retrieve the raw java.sql.Connection object. The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI) connection should be made - to really return the 'native' JDBC object.

Parameters:

  • unwrap (true, false) (defaults to: nil) —

    whether to unwrap the connection object

Returns:

  • (Java::JavaSql::Connection) —

    the JDBC connection



33
34
35
 
# File 'lib/arjdbc/abstract/core.rb', line 33

def jdbc_connection(unwrap = nil)
  raw_connection.jdbc_connection(unwrap)
end

#log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) ⇒ Object (protected)

this version of log() automatically fills type_casted_binds from binds if necessary



69
70
71
72
73
74
 
# File 'lib/arjdbc/abstract/core.rb', line 69

def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
  if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
    type_casted_binds = ->{ extract_raw_bind_values(binds) }
  end
  super
end

#translate_exception(exception, message:, sql:, binds:) ⇒ Object (protected) 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/arjdbc/abstract/core.rb', line 49

def translate_exception(exception, message:, sql:, binds:)
  # override in derived class

  # we shall not translate native "Java" exceptions as they might
  # swallow an ArJdbc / driver bug into an AR::StatementInvalid !
  return exception if exception.is_a?(Java::JavaLang::Throwable)

  case exception
    when SystemExit, SignalException, NoMemoryError then exception
    when ActiveModel::RangeError, TypeError, RuntimeError then exception
    when ActiveRecord::ConnectionNotEstablished then exception
    else super
  end
end

#translate_exception_class(e, sql, binds) ⇒ Object (protected) 



39
40
41
42
43
44
45
46
47
 
# File 'lib/arjdbc/abstract/core.rb', line 39

def translate_exception_class(e, sql, binds)
  message = "#{e.class.name}: #{e.message}"

  exception = translate_exception(
    e, message: message, sql: sql, binds: binds
  )
  exception.set_backtrace e.backtrace
  exception
end