class ActiveRecord::ConnectionAdapters::JdbcAdapter

Built on top of `ActiveRecord::ConnectionAdapters::AbstractAdapter` which provides the abstract interface for database-specific functionality, this class serves 2 purposes in AR-JDBC :

Historically this class is mostly been used standalone and that's still a valid use-case esp. since (with it's `arjdbc.jdbc.RubyJdbcConnectionClass`) JDBC provides a unified interface for all databases in Java it tries to do it's best implementing all `ActiveRecord` functionality on top of that. This might no be perfect that's why it checks for a `config` module (or tries to resolve one from the JDBC driver's meta-data) and if the database has “extended” AR-JDBC support mixes in the given module for each adapter instance. This is sufficient for most database specific specs we support, but for compatibility with native (MRI) adapters it's perfectly fine to sub-class the adapter and override some of its API methods.

Constants

ADAPTER_NAME

Attributes

config[R]

Public Class Methods

arel2_visitors(config) click to toggle source

@deprecated re-implemented - no longer used @return [Hash] the AREL visitor to use If there's a `self.arel2_visitors(config)` method on the adapter spec than it is preferred and will be used instead of this one.

# File lib/arjdbc/jdbc/adapter.rb, line 193
def self.arel2_visitors(config)
  { 'jdbc' => ::Arel::Visitors::ToSql }
end
configure_arel2_visitors(config) click to toggle source

@deprecated re-implemented - no longer used @see arel2_visitors

# File lib/arjdbc/jdbc/adapter.rb, line 199
def self.configure_arel2_visitors(config)
  visitors = ::Arel::Visitors::VISITORS
  klass = config[:adapter_spec]
  klass = self unless klass.respond_to?(:arel2_visitors)
  visitor = nil
  klass.arel2_visitors(config).each do |name, arel|
    visitors[name] = ( visitor = arel )
  end
  if visitor && config[:adapter] =~ /^(jdbc|jndi)$/
    visitors[ config[:adapter] ] = visitor
  end
  visitor
end
new(connection, logger = nil, pool = nil) click to toggle source
Calls superclass method
# File lib/arjdbc/jdbc/adapter.rb, line 43
def self.new(connection, logger = nil, pool = nil)
  adapter = super
  Jdbc::JndiConnectionPoolCallbacks.prepare(adapter, adapter.instance_variable_get(:@connection))
  adapter
end
new(connection, logger, config = nil) click to toggle source

Initializes the (JDBC connection) adapter instance. The passed configuration Hash's keys are symbolized, thus changes to the original `config` keys won't be reflected in the adapter. If the adapter's sub-class or the spec module that this instance will extend in responds to `configure_connection` than it will be called. @param connection an (optional) connection instance @param logger the `ActiveRecord::Base.logger` to use (or nil) @param config the database configuration @note `initialize(logger, config)` with 2 arguments is supported as well

Calls superclass method
# File lib/arjdbc/jdbc/adapter.rb, line 58
def initialize(connection, logger, config = nil)
  # AR : initialize(connection, logger = nil, pool = nil)
  # AR < 3.2 : initialize(connection, logger = nil)
  if config.nil? && logger.respond_to?(:key?) # (logger, config)
    config, logger, connection = logger, connection, nil
  end

  @config = config.respond_to?(:symbolize_keys) ? config.symbolize_keys : config
  # NOTE: JDBC 4.0 drivers support checking if connection isValid
  # thus no need to @config[:connection_alive_sql] ||= 'SELECT 1'
  #
  # NOTE: setup to retry 5-times previously - maybe do not set at all ?
  @config[:retry_count] ||= 1

  @config[:adapter_spec] = adapter_spec(@config) unless @config.key?(:adapter_spec)
  spec = @config[:adapter_spec]

  # NOTE: adapter spec's init_connection only called if instantiated here :
  connection ||= jdbc_connection_class(spec).new(@config, self)

  super(connection, logger)

  # kind of like `extend ArJdbc::MyDB if self.class == JdbcAdapter` :
  klass = @config[:adapter_class]
  extend spec if spec && ( ! klass || klass == JdbcAdapter)

  # NOTE: should not be necessary for JNDI due reconnect! on checkout :
  configure_connection if respond_to?(:configure_connection)

  @visitor = new_visitor # nil if no AREL (AR-2.3)
end

Protected Class Methods

insert?(sql) click to toggle source

@return whether the given SQL string is an 'INSERT' query

# File lib/arjdbc/jdbc/adapter.rb, line 896
def self.insert?(sql)
  JdbcConnection::insert?(sql)
end
prepared_statements?(config) click to toggle source
Allows changing the prepared statements setting for this connection.
@see #prepared_statements?

def prepared_statements=(statements)

@prepared_statements = statements

end

# File lib/arjdbc/jdbc/adapter.rb, line 823
def self.prepared_statements?(config)
  config.key?(:prepared_statements) ?
    type_cast_config_to_boolean(config.fetch(:prepared_statements)) :
      false # off by default - NOTE: on AR 4.x it's on by default !?
end
select?(sql) click to toggle source

@return whether the given SQL string is a 'SELECT' like query (returning a result set)

# File lib/arjdbc/jdbc/adapter.rb, line 891
def self.select?(sql)
  JdbcConnection::select?(sql)
end
suble_binds=(flag) click to toggle source
# File lib/arjdbc/jdbc/adapter.rb, line 835
def self.suble_binds=(flag); @@suble_binds = flag; end
suble_binds?() click to toggle source
# File lib/arjdbc/jdbc/adapter.rb, line 834
def self.suble_binds?; @@suble_binds; end
type_cast_config_to_boolean(config) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 915
def self.type_cast_config_to_boolean(config)
  config == 'false' ? false : (config == 'true' ? true : config)
end
type_cast_config_to_integer(config) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 908
def self.type_cast_config_to_integer(config)
  config =~ /\A\d+\z/ ? config.to_i : config
end
update?(sql) click to toggle source

@return whether the given SQL string is an 'UPDATE' (or 'DELETE') query

# File lib/arjdbc/jdbc/adapter.rb, line 901
def self.update?(sql)
  ! select?(sql) && ! insert?(sql)
end

Public Instance Methods

_string_to_date(value) click to toggle source

@note Used by Java API to convert dates from (custom) SELECTs (might get refactored). @private

# File lib/arjdbc/jdbc/adapter.rb, line 923
def _string_to_date(value); jdbc_column_class.string_to_date(value) end
_string_to_time(value) click to toggle source

@note Used by Java API to convert times from (custom) SELECTs (might get refactored). @private

# File lib/arjdbc/jdbc/adapter.rb, line 927
def _string_to_time(value); jdbc_column_class.string_to_dummy_time(value) end
_string_to_timestamp(value) click to toggle source

@note Used by Java API to convert times from (custom) SELECTs (might get refactored). @private

# File lib/arjdbc/jdbc/adapter.rb, line 931
def _string_to_timestamp(value); jdbc_column_class.string_to_time(value) end
active?() click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 293
def active?
  @connection.active?
end
adapter_name() click to toggle source

@return [String] the 'JDBC' adapter name.

# File lib/arjdbc/jdbc/adapter.rb, line 168
def adapter_name
  ADAPTER_NAME
end
adapter_spec(config) click to toggle source

Locate the specialized (database specific) adapter specification module if one exists based on provided configuration data. This module will than extend an instance of the adapter (unless an `:adapter_class` provided).

This method is called during {#initialize} unless an explicit `config` is set. @param config the configuration to check for `:adapter_spec` @return [Module] the database specific module

# File lib/arjdbc/jdbc/adapter.rb, line 138
def adapter_spec(config)
  dialect = (config[:dialect] || config[:driver]).to_s
  ::ArJdbc.modules.each do |constant| # e.g. ArJdbc::MySQL
    if constant.respond_to?(:adapter_matcher)
      spec = constant.adapter_matcher(dialect, config)
      return spec if spec
    end
  end

  if (config[:jndi] || config[:data_source]) && ! config[:dialect]
    begin
      data_source = config[:data_source] ||
        Java::JavaxNaming::InitialContext.new.lookup(config[:jndi])
      connection = data_source.getConnection
      config[:dialect] = connection.getMetaData.getDatabaseProductName
    rescue Java::JavaSql::SQLException => e
      warn "failed to set database :dialect from connection meda-data (#{e})"
    else
      return adapter_spec(config) # re-try matching a spec with set config[:dialect]
    ensure
      connection.close if connection  # return to the pool
    end
  end

  nil
end
begin_db_transaction() click to toggle source

Starts a database transaction. @override

# File lib/arjdbc/jdbc/adapter.rb, line 343
def begin_db_transaction
  @connection.begin
end
begin_isolated_db_transaction(isolation) click to toggle source

Starts a database transaction. @param isolation the transaction isolation to use @since 1.3.0 @override on *AR-4.0*

# File lib/arjdbc/jdbc/adapter.rb, line 363
def begin_isolated_db_transaction(isolation)
  @connection.begin(isolation)
end
columns(table_name, name = nil) click to toggle source
# File lib/arjdbc/jdbc/adapter.rb, line 337
def columns(table_name, name = nil)
  @connection.columns(table_name.to_s)
end
commit_db_transaction() click to toggle source

Commits the current database transaction. @override

# File lib/arjdbc/jdbc/adapter.rb, line 349
def commit_db_transaction
  @connection.commit
end
create_savepoint(name = current_savepoint_name(true)) click to toggle source

Creates a (transactional) save-point one can rollback to. Unlike 'plain' `ActiveRecord` it is allowed to pass a save-point name. @param name the save-point name @return save-point name (even if nil passed will be generated) @since 1.3.0 @extension added optional name parameter

# File lib/arjdbc/jdbc/adapter.rb, line 390
def create_savepoint(name = current_savepoint_name(true))
  @connection.create_savepoint(name)
end
current_savepoint_name(compat = true) click to toggle source

Due tracking of save-points created in a LIFO manner, always returns the correct name if any (last) save-point has been marked and not released. Otherwise when creating a save-point same naming convention as `ActiveRecord` uses (“active_record_” prefix) will be returned. @return [String] the current save-point name @since 1.3.0 @override

# File lib/arjdbc/jdbc/adapter.rb, line 420
def current_savepoint_name(compat = true)
  open_tx = open_transactions
  return "active_record_#{open_tx}" if compat # by default behave like AR

  sp_names = @connection.marked_savepoint_names
  sp_names.last || "active_record_#{open_tx}"
  # should (open_tx- 1) here but we play by AR's rules as it might fail
end
data_source_exists?(name) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 627
def data_source_exists?(name)
  table_exists?(name)
end
data_sources() click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 622
def data_sources
  tables
end
database_name() click to toggle source

Returns the underlying database name. @override

# File lib/arjdbc/jdbc/adapter.rb, line 252
def database_name
  @connection.database_name
end
disconnect!() click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 304
def disconnect!
  @connection.disconnect!
end
exec_delete(sql, name, binds) click to toggle source

Executes a delete statement in the context of this connection. @param sql the query string (or AREL object) @param name logging marker for the executed SQL statement log entry @param binds the bind parameters @override available since *AR-3.1*

# File lib/arjdbc/jdbc/adapter.rb, line 481
def exec_delete(sql, name, binds)
  if sql.respond_to?(:to_sql)
    sql = to_sql(sql, binds); to_sql = true
  end
  if prepared_statements?
    log(sql, name || 'SQL', binds) { @connection.execute_delete(sql, binds) }
  else
    sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
    log(sql, name || 'SQL') { @connection.execute_delete(sql) }
  end
end
exec_insert(sql, name, binds, pk = nil, sequence_name = nil) click to toggle source

Executes an insert statement in the context of this connection. @param sql the query string (or AREL object) @param name logging marker for the executed SQL statement log entry @param binds the bind parameters @override available since *AR-3.1*

# File lib/arjdbc/jdbc/adapter.rb, line 464
def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
  if sql.respond_to?(:to_sql)
    sql = to_sql(sql, binds); to_sql = true
  end
  if prepared_statements?
    log(sql, name || 'SQL', binds) { @connection.execute_insert(sql, binds) }
  else
    sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
    log(sql, name || 'SQL') { @connection.execute_insert(sql) }
  end
end
exec_query(sql, name = 'SQL', binds = []) click to toggle source

Executes a SQL query in the context of this connection using the bind substitutes. @param sql the query string (or AREL object) @param name logging marker for the executed SQL statement log entry @param binds the bind parameters @return [ActiveRecord::Result] or [Array] on *AR-2.3* @override available since *AR-3.1*

# File lib/arjdbc/jdbc/adapter.rb, line 447
def exec_query(sql, name = 'SQL', binds = [])
  if sql.respond_to?(:to_sql)
    sql = to_sql(sql, binds); to_sql = true
  end
  if prepared_statements?
    log(sql, name, binds) { @connection.execute_query(sql, binds) }
  else
    sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
    log(sql, name) { @connection.execute_query(sql) }
  end
end
exec_query_raw(sql, name = 'SQL', binds = [], &block) click to toggle source

Similar to {#exec_query} except it returns “raw” results in an array where each rows is a hash with keys as columns (just like Rails used to do up until 3.0) instead of wrapping them in a {#ActiveRecord::Result}. @param sql the query string (or AREL object) @param name logging marker for the executed SQL statement log entry @param binds the bind parameters @yield [v1, v2] depending on the row values returned from the query In case a block is given it will yield each row from the result set instead of returning mapped query results in an array. @return [Array] unless a block is given

# File lib/arjdbc/jdbc/adapter.rb, line 520
def exec_query_raw(sql, name = 'SQL', binds = [], &block)
  if sql.respond_to?(:to_sql)
    sql = to_sql(sql, binds); to_sql = true
  end
  if prepared_statements?
    log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
  else
    sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
    log(sql, name) { @connection.execute_query_raw(sql, &block) }
  end
end
exec_update(sql, name, binds) click to toggle source

# Executes an update statement in the context of this connection. @param sql the query string (or AREL object) @param name logging marker for the executed SQL statement log entry @param binds the bind parameters @override available since *AR-3.1*

# File lib/arjdbc/jdbc/adapter.rb, line 498
def exec_update(sql, name, binds)
  if sql.respond_to?(:to_sql)
    sql = to_sql(sql, binds); to_sql = true
  end
  if prepared_statements?
    log(sql, name || 'SQL', binds) { @connection.execute_update(sql, binds) }
  else
    sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
    log(sql, name || 'SQL') { @connection.execute_update(sql) }
  end
end
execute(sql, name = nil, binds = nil) click to toggle source

Executes the SQL statement in the context of this connection. The return value from this method depends on the SQL type (whether it's a SELECT, INSERT etc.). For INSERTs a generated id might get returned while for UPDATE statements the affected row count. Please note that this method returns “raw” results (in an array) for statements that return a result set, while {#exec_query} is expected to return a `ActiveRecord::Result` (since AR 3.1). @note This method does not use prepared statements. @note The method does not emulate various “native” `execute` results on MRI. @see exec_query @see exec_insert @see exec_update

# File lib/arjdbc/jdbc/adapter.rb, line 566
def execute(sql, name = nil, binds = nil)
  sql = suble_binds to_sql(sql, binds), binds if binds
  if name == :skip_logging
    _execute(sql, name)
  else
    log(sql, name) { _execute(sql, name) }
  end
end
execute_quietly(sql, name = 'SQL') click to toggle source

Kind of `execute(sql) rescue nil` but logging failures at debug level only.

# File lib/arjdbc/jdbc/adapter.rb, line 600
def execute_quietly(sql, name = 'SQL')
  log(sql, name) do
    begin
      _execute(sql)
    rescue => e
      logger.debug("#{e.class}: #{e.message}: #{sql}")
    end
  end
end
foreign_keys(table_name) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 652
def foreign_keys(table_name)
  @connection.foreign_keys(table_name)
end
indexes(table_name, name = nil, schema_name = nil) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 632
def indexes(table_name, name = nil, schema_name = nil)
  @connection.indexes(table_name, name, schema_name)
end
insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) click to toggle source

@note Used on AR 2.3 and 3.0 @override

# File lib/arjdbc/jdbc/adapter.rb, line 332
def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
  id = execute(sql, name)
  id_value || id
end
is_a?(klass) click to toggle source

@override Will return true even when native adapter classes passed in e.g. `jdbc_adapter.is_a? ConnectionAdapter::PostgresqlAdapter`

This is only necessary (for built-in adapters) when `config` is forced to `nil` and the `:adapter_spec` module is used to extend the `JdbcAdapter`, otherwise we replace the class constants for built-in adapters (MySQL, PostgreSQL and SQLite3).

Calls superclass method
# File lib/arjdbc/jdbc/adapter.rb, line 180
def is_a?(klass)
  # This is to fake out current_adapter? conditional logic in AR tests
  if klass.is_a?(Class) && klass.name =~ /#{adapter_name}Adapter$/i
    true
  else
    super
  end
end
jdbc_column_class() click to toggle source

Returns the (JDBC) `ActiveRecord` column class for this adapter. This is used by (database specific) spec modules to override the class. @see ActiveRecord::ConnectionAdapters::JdbcColumn

# File lib/arjdbc/jdbc/adapter.rb, line 102
def jdbc_column_class
  ::ActiveRecord::ConnectionAdapters::JdbcColumn
end
jdbc_connection(unwrap = nil) click to toggle source

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. @param unwrap [true, false] whether to unwrap the connection object @return [Java::JavaSql::Connection] the JDBC connection

# File lib/arjdbc/jdbc/adapter.rb, line 111
def jdbc_connection(unwrap = nil)
  java_connection = raw_connection.connection
  return java_connection unless unwrap
  connection_class = java.sql.Connection.java_class
  begin
    if java_connection.wrapper_for?(connection_class)
      return java_connection.unwrap(connection_class) # java.sql.Wrapper.unwrap
    end
  rescue Java::JavaLang::AbstractMethodError => e
    ArJdbc.warn("driver/pool connection impl does not support unwrapping (#{e})")
  end
  if java_connection.respond_to?(:connection)
    # e.g. org.apache.tomcat.jdbc.pool.PooledConnection
    java_connection.connection # getConnection
  else
    java_connection
  end
end
jdbc_connection_class(spec) click to toggle source

Returns the (JDBC) connection class to be used for this adapter. This is used by (database specific) spec modules to override the class used assuming some of the available methods have been re-defined. @see ActiveRecord::ConnectionAdapters::JdbcConnection

# File lib/arjdbc/jdbc/adapter.rb, line 94
def jdbc_connection_class(spec)
  connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
  connection_class ? connection_class : ::ActiveRecord::ConnectionAdapters::JdbcConnection
end
jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 311
def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
  insert_sql(sql, name, pk, id_value, sequence_name)
end
jdbc_select_all(sql, name = nil, binds = []) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 323
def jdbc_select_all(sql, name = nil, binds = [])
  select(sql, name, binds)
end
jdbc_update(sql, name = nil, binds = []) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 317
def jdbc_update(sql, name = nil, binds = [])
  execute(sql, name, binds)
end
modify_types(types) click to toggle source

Allows for modification of the detected native types. @param types the resolved native database types @see native_database_types

# File lib/arjdbc/jdbc/adapter.rb, line 233
def modify_types(types)
  types
end
native_database_types() click to toggle source

DB specific types are detected but adapter specs (or extenders) are expected to hand tune these types for concrete databases. @return [Hash] the native database types @override

# File lib/arjdbc/jdbc/adapter.rb, line 217
def native_database_types
  @native_database_types ||= begin
    types = @connection.native_database_types
    modify_types(types)
    types
  end
end
native_sql_to_type(type) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 257
def native_sql_to_type(type)
  if /^(.*?)\(([0-9]+)\)/ =~ type
    tname, limit = $1, $2.to_i
    ntypes = native_database_types
    if ntypes[:primary_key] == type
      return :primary_key, nil
    else
      ntypes.each do |name, val|
        if name == :primary_key
          next
        end
        if val[:name].downcase == tname.downcase &&
            ( val[:limit].nil? || val[:limit].to_i == limit )
          return name, limit
        end
      end
    end
  elsif /^(.*?)/ =~ type
    tname = $1
    ntypes = native_database_types
    if ntypes[:primary_key] == type
      return :primary_key, nil
    else
      ntypes.each do |name, val|
        if val[:name].downcase == tname.downcase && val[:limit].nil?
          return name, nil
        end
      end
    end
  else
    return :string, 255
  end
  return nil, nil
end
pk_and_sequence_for(table) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 637
def pk_and_sequence_for(table)
  ( key = primary_key(table) ) ? [ key, nil ] : nil
end
primary_key(table) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 642
def primary_key(table)
  primary_keys(table).first
end
primary_keys(table) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 647
def primary_keys(table)
  @connection.primary_keys(table)
end
reconnect!() click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 298
def reconnect!
  @connection.reconnect! # handles adapter.configure_connection
  @connection
end
release_savepoint(name = current_savepoint_name(false)) click to toggle source

Release a previously created save-point. @note Save-points are auto-released with the transaction they're created in (on transaction commit or roll-back). @param name the save-point name @since 1.3.0 @extension added optional name parameter

# File lib/arjdbc/jdbc/adapter.rb, line 409
def release_savepoint(name = current_savepoint_name(false))
  @connection.release_savepoint(name)
end
rollback_db_transaction() click to toggle source

Rolls back the current database transaction. @override

# File lib/arjdbc/jdbc/adapter.rb, line 355
def rollback_db_transaction
  @connection.rollback
end
rollback_to_savepoint(name = current_savepoint_name(true)) click to toggle source

Transaction rollback to a given (previously created) save-point. If no save-point name given rollback to the last created one. @param name the save-point name @since 1.3.0 @extension added optional name parameter

# File lib/arjdbc/jdbc/adapter.rb, line 399
def rollback_to_savepoint(name = current_savepoint_name(true))
  @connection.rollback_savepoint(name)
end
select(sql, name = nil, binds = []) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 541
def select(sql, name = nil, binds = [])
  exec_query(to_sql(sql, binds), name, binds)
end
select_rows(sql, name = nil, binds = []) click to toggle source

@private @override

# File lib/arjdbc/jdbc/adapter.rb, line 534
def select_rows(sql, name = nil, binds = [])
  exec_query_raw(sql, name, binds).map!(&:values)
end
structure_dump() click to toggle source

Abstract adapter default implementation does nothing silently. @override

# File lib/arjdbc/jdbc/adapter.rb, line 239
def structure_dump
  raise NotImplementedError, "structure_dump not supported"
end
supports_foreign_keys?() click to toggle source

Does our database (+ its JDBC driver) support foreign-keys? @since 1.3.18 @override

# File lib/arjdbc/jdbc/adapter.rb, line 659
def supports_foreign_keys?
  @connection.supports_foreign_keys?
end
supports_migrations?() click to toggle source

JDBC adapters support migration. @return [true] @override

# File lib/arjdbc/jdbc/adapter.rb, line 246
def supports_migrations?
  true
end
supports_savepoints?() click to toggle source

Does our database (+ its JDBC driver) support save-points? @since 1.3.0 @override

# File lib/arjdbc/jdbc/adapter.rb, line 380
def supports_savepoints?
  @connection.supports_savepoints?
end
supports_transaction_isolation?(level = nil) click to toggle source

Does this adapter support setting the isolation level for a transaction? Unlike 'plain' `ActiveRecord` we allow checking for concrete transaction isolation level support by the database. @param level optional to check if we support a specific isolation level @since 1.3.0 @extension added optional level parameter

# File lib/arjdbc/jdbc/adapter.rb, line 373
def supports_transaction_isolation?(level = nil)
  @connection.supports_transaction_isolation?(level)
end
supports_views?() click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 436
def supports_views?
  @connection.supports_views?
end
table_exists?(name) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 616
def table_exists?(name)
  return false unless name
  @connection.table_exists?(name) # schema_name = nil
end
tables(name = nil) click to toggle source

@override

# File lib/arjdbc/jdbc/adapter.rb, line 611
def tables(name = nil)
  @connection.tables
end
to_sql(arel, binds = nil) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 680
def to_sql(arel, binds = nil)
  # NOTE: can not handle `visitor.accept(arel.ast)` right
  arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
end
update_lob_value(record, column, value) click to toggle source

@param record the record e.g. `User.find(1)` @param column the model's column e.g. `User.columns_hash` @param value the lob value - string or (IO or Java) stream

# File lib/arjdbc/jdbc/adapter.rb, line 671
def update_lob_value(record, column, value)
  @connection.update_lob_value(record, column, value)
end
valid_type?(type) click to toggle source

@override introduced in AR 4.2

# File lib/arjdbc/jdbc/adapter.rb, line 226
def valid_type?(type)
  ! native_database_types[type].nil?
end
write_large_object(*args) click to toggle source

@deprecated Rather use {#update_lob_value} instead.

# File lib/arjdbc/jdbc/adapter.rb, line 664
def write_large_object(*args)
  @connection.write_large_object(*args)
end

Protected Instance Methods

add_column_options!(sql, options) click to toggle source

Provides backwards-compatibility on ActiveRecord 4.1 for DB adapters that override this and than call super expecting to work. @note This method is available in 4.0 but won't be in 4.1 @private

# File lib/arjdbc/jdbc/adapter.rb, line 776
def add_column_options!(sql, options)
  sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
  # must explicitly check for :null to allow change_column to work on migrations
  sql << " NOT NULL" if options[:null] == false
  sql << " AUTO_INCREMENT" if options[:auto_increment] == true
end
create_table_definition(*args) click to toggle source

`TableDefinition.new #native_database_types, name, temporary, options` and ActiveRecord 4.1 supports optional `as` argument (which defaults to nil) to provide the SQL to use to generate the table: `TableDefinition.new #native_database_types, name, temporary, options, as` @private

# File lib/arjdbc/jdbc/adapter.rb, line 752
def create_table_definition(*args)
  table_definition(*args)
end
Also aliased as: table_definition
last_inserted_id(result) click to toggle source

Take an id from the result of an INSERT query. @return [Integer, NilClass]

# File lib/arjdbc/jdbc/adapter.rb, line 723
def last_inserted_id(result)
  if result.is_a?(Hash) || result.is_a?(ActiveRecord::Result)
    result.first.first[1] # .first = { "id"=>1 } .first = [ "id", 1 ]
  else
    result
  end
end
log(sql, name = nil, binds = []) click to toggle source

@override so that we do not have to care having 2 arguments on 3.0

Calls superclass method
# File lib/arjdbc/jdbc/adapter.rb, line 697
def log(sql, name = nil, binds = [])
  unless binds.blank?
    binds = binds.map do |column, value|
      column ? [column.name, value] : [nil, value]
    end
    sql = "#{sql} #{binds.inspect}"
  end
  super(sql, name || 'SQL') # `log(sql, name)` on AR <= 3.0
end
new_index_definition(table, name, unique, columns, lengths, orders = nil, where = nil, type = nil, using = nil) click to toggle source

@private

# File lib/arjdbc/jdbc/adapter.rb, line 764
def new_index_definition(table, name, unique, columns, lengths,
    orders = nil, where = nil, type = nil, using = nil)
  IndexDefinition.new(table, name, unique, columns, lengths, orders, where, type, using)
end
new_table_definition(table_definition, *args) click to toggle source

@note AR-4x arguments expected: `(name, temporary, options)` @private documented bellow

# File lib/arjdbc/jdbc/adapter.rb, line 758
def new_table_definition(table_definition, *args)
  table_definition.new native_database_types, *args
end
prepared_statements?() click to toggle source

@return whether `:prepared_statements` are to be used

# File lib/arjdbc/jdbc/adapter.rb, line 812
def prepared_statements?
  return @prepared_statements unless (@prepared_statements ||= nil).nil?
  @prepared_statements = self.class.prepared_statements?(config)
end
table_definition(*args)
translate_exception(e, message) click to toggle source
Calls superclass method
# File lib/arjdbc/jdbc/adapter.rb, line 708
def translate_exception(e, message)
  # we shall not translate native "Java" exceptions as they might
  # swallow an ArJdbc / driver bug into a AR::StatementInvalid ...
  return e if e.is_a?(NativeException) # JRuby 1.6
  return e if e.is_a?(Java::JavaLang::Throwable)

  case e
  when SystemExit, SignalException, NoMemoryError then e
  # NOTE: wraps AR::JDBCError into AR::StatementInvalid, desired ?!
  else super
  end
end

Private Instance Methods

_execute(sql, name = nil) click to toggle source

We need to do it this way, to allow Rails stupid tests to always work even if we define a new `execute` method. Instead of mixing in a new `execute`, an `_execute` should be mixed in. @deprecated it was only introduced due tests @private

# File lib/arjdbc/jdbc/adapter.rb, line 594
def _execute(sql, name = nil)
  @connection.execute(sql)
end
extract_sql(arel) click to toggle source

@deprecated No longer used, kept for 1.2 API compatibility.

# File lib/arjdbc/jdbc/adapter.rb, line 868
def extract_sql(arel)
  arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
end
get_time(value) click to toggle source

Helper to get local/UTC time (based on `ActiveRecord::Base.default_timezone`).

# File lib/arjdbc/jdbc/adapter.rb, line 882
def get_time(value)
  get = ::ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
  value.respond_to?(get) ? value.send(get) : value
end
sql_literal?(value) click to toggle source

Helper useful during {#quote} since AREL might pass in it's literals to be quoted, fixed since AREL 4.0.0.beta1 : git.io/7gyTig

# File lib/arjdbc/jdbc/adapter.rb, line 875
def sql_literal?(value); ::Arel::Nodes::SqlLiteral === value; end
suble_binds(sql, binds) click to toggle source

@note Since AR 4.0 we (finally) do not “sub” SQL's '?' parameters ! @deprecated This should go away (hopefully), now here due 1.2.x.

# File lib/arjdbc/jdbc/adapter.rb, line 841
def suble_binds(sql, binds)
  return sql if ! @@suble_binds || binds.nil? || binds.empty?
  binds = binds.dup; warn = nil
  result = sql.gsub('?') { warn = true; quote(*binds.shift.reverse) }
  ActiveSupport::Deprecation.warn(
    "string binds substitution is deprecated - please refactor your sql", caller[1..-1]
  ) if warn
  result
end
substitute_binds(sql, binds) click to toggle source

@deprecated No longer used, will be removed. @see suble_binds

# File lib/arjdbc/jdbc/adapter.rb, line 862
def substitute_binds(sql, binds)
  return sql if binds.nil? || binds.empty?; binds = binds.dup
  extract_sql(sql).gsub('?') { quote(*binds.shift.reverse) }
end