Class: ActiveRecord::ConnectionAdapters::JdbcAdapter

Inherits:
AbstractAdapter
  • Object
show all
Includes:
ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport, ActiveRecord::ConnectionAdapters::Jdbc::ConnectionPoolCallbacks
Defined in:
lib/arjdbc/jdbc/adapter.rb

Overview

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

  • as a base class for sub-classes
  • usable standalone (or with a mixed in adapter spec module)

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[:adapter_spec] 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.

Constant Summary collapse

ADAPTER_NAME = 
'JDBC'.freeze
@@suble_binds =

due compatibility

ActiveRecord::VERSION::MAJOR < 4

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ActiveRecord::ConnectionAdapters::Jdbc::ConnectionPoolCallbacks

#on_checkin, #on_checkout

Methods included from ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport

#unprepared_visitor

Constructor Details

#initialize(connection, logger, config = nil) ⇒ JdbcAdapter

Note:

initialize(logger, config) with 2 arguments is supported as well

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.

Parameters:

  • connection —

    an (optional) connection instance

  • logger —

    the ActiveRecord::Base.logger to use (or nil)

  • config (defaults to: nil) —

    the database configuration



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 52

def initialize(connection, logger, config = 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)

  Jdbc::JndiConnectionPoolCallbacks.prepare(self, connection)

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

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



41
42
43
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 41

def config
  @config
end

Class Method Details

.arel2_visitors(config) ⇒ Hash

Deprecated.

re-implemented - no longer used

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.

Returns:

  • (Hash) —

    the AREL visitor to use



182
183
184
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 182

def self.arel2_visitors(config)
  { 'jdbc' => ::Arel::Visitors::ToSql }
end

.configure_arel2_visitors(config) ⇒ Object

Deprecated.

re-implemented - no longer used

See Also:

  • #arel2_visitors


188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 188

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

.insert?(sql) ⇒ Boolean (protected)

Returns whether the given SQL string is an 'INSERT' query.

Returns:

  • (Boolean) —

    whether the given SQL string is an 'INSERT' query



818
819
820
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 818

def self.insert?(sql)
  JdbcConnection::insert?(sql)
end

.prepared_statements?(config) ⇒ Boolean (protected)

Allows changing the prepared statements setting for this connection. def prepared_statements=(statements) @prepared_statements = statements end

Returns:

  • (Boolean)

See Also:



745
746
747
748
749
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 745

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) ⇒ Boolean (protected)

query (returning a result set)

Returns:

  • (Boolean) —

    whether the given SQL string is a 'SELECT' like



813
814
815
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 813

def self.select?(sql)
  JdbcConnection::select?(sql)
end

.suble_binds=(flag) ⇒ Object (protected) 



757
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 757

def self.suble_binds=(flag); @@suble_binds = flag; end

.suble_binds? ⇒ Boolean (protected)

Returns:

  • (Boolean) 


756
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 756

def self.suble_binds?; @@suble_binds; end

.update?(sql) ⇒ Boolean (protected)

Returns whether the given SQL string is an 'UPDATE' (or 'DELETE') query.

Returns:

  • (Boolean) —

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



823
824
825
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 823

def self.update?(sql)
  ! select?(sql) && ! insert?(sql)
end

Instance Method Details

#active? ⇒ Boolean

Returns:

  • (Boolean) 


277
278
279
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 277

def active?
  @connection.active?
end

#adapter_name ⇒ String

Returns the 'JDBC' adapter name.

Returns:

  • (String) —

    the 'JDBC' adapter name.



157
158
159
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 157

def adapter_name
  ADAPTER_NAME
end

#adapter_spec(config) ⇒ Module

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[:adapter_spec] is set.

Parameters:

  • config —

    the configuration to check for :adapter_spec

Returns:

  • (Module) —

    the database specific module



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 127

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 ⇒ Object

Starts a database transaction.



327
328
329
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 327

def begin_db_transaction
  @connection.begin
end

#begin_isolated_db_transaction(isolation) ⇒ Object

Starts a database transaction.

Parameters:

  • isolation —

    the transaction isolation to use

Since:

  • 1.3.0



347
348
349
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 347

def begin_isolated_db_transaction(isolation)
  @connection.begin(isolation)
end

#columns(table_name, name = nil) ⇒ Object 



321
322
323
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 321

def columns(table_name, name = nil)
  @connection.columns(table_name.to_s)
end

#commit_db_transaction ⇒ Object

Commits the current database transaction.



333
334
335
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 333

def commit_db_transaction
  @connection.commit
end

#create_savepoint(name = current_savepoint_name(true)) ⇒ Object

Creates a (transactional) save-point one can rollback to. Unlike 'plain' ActiveRecord it is allowed to pass a save-point name.

Parameters:

  • name (defaults to: current_savepoint_name(true)) —

    the save-point name

Returns:

  • save-point name (even if nil passed will be generated)

Since:

  • 1.3.0



374
375
376
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 374

def create_savepoint(name = current_savepoint_name(true))
  @connection.create_savepoint(name)
end

#current_savepoint_name(create = nil) ⇒ String

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.

Returns:

  • (String) —

    the current save-point name

Since:

  • 1.3.0



404
405
406
407
408
409
410
411
412
413
414
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 404

def current_savepoint_name(create = nil)
  open_tx = open_transactions
  return "active_record_#{open_tx}" if create

  sp_names = @connection.marked_savepoint_names
  unless sp_names.empty?
    sp_names[ -(sp_names.size - open_tx + 1) ]
  else
    "active_record_#{open_tx}"
  end
end

#database_name ⇒ Object

Returns the underlying database name.



236
237
238
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 236

def database_name
  @connection.database_name
end

#disconnect! ⇒ Object 



288
289
290
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 288

def disconnect!
  @connection.disconnect!
end

#exec_delete(sql, name, binds) ⇒ Object

Executes a delete statement in the context of this connection.

Parameters:

  • sql —

    the query string (or AREL object)

  • name —

    logging marker for the executed SQL statement log entry

  • binds —

    the bind parameters



457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 457

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) ⇒ Object

Executes an insert statement in the context of this connection.

Parameters:

  • sql —

    the query string (or AREL object)

  • name —

    logging marker for the executed SQL statement log entry

  • binds —

    the bind parameters



440
441
442
443
444
445
446
447
448
449
450
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 440

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 = []) ⇒ ActiveRecord::Result

Executes a SQL query in the context of this connection using the bind substitutes.

Parameters:

  • sql —

    the query string (or AREL object)

  • name (defaults to: 'SQL') —

    logging marker for the executed SQL statement log entry

  • binds (defaults to: []) —

    the bind parameters

Returns:

  • (ActiveRecord::Result) —

    or [Array] on AR-2.3



423
424
425
426
427
428
429
430
431
432
433
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 423

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 = []) {|v1, v2| ... } ⇒ Array

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::ConnectionAdapters::JdbcAdapter#ActiveRecord#ActiveRecord::Result. In case a block is given it will yield each row from the result set instead of returning mapped query results in an array.

Parameters:

  • sql —

    the query string (or AREL object)

  • name (defaults to: 'SQL') —

    logging marker for the executed SQL statement log entry

  • binds (defaults to: []) —

    the bind parameters

Yields:

  • (v1, v2) —

    depending on the row values returned from the query

Returns:

  • (Array) —

    unless a block is given



496
497
498
499
500
501
502
503
504
505
506
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 496

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) ⇒ Object

Executes an update statement in the context of this connection.

Parameters:

  • sql —

    the query string (or AREL object)

  • name —

    logging marker for the executed SQL statement log entry

  • binds —

    the bind parameters



474
475
476
477
478
479
480
481
482
483
484
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 474

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

#indexes(table_name, name = nil, schema_name = nil) ⇒ Object 



587
588
589
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 587

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) ⇒ Object

Note:

Used on AR 2.3 and 3.0



316
317
318
319
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 316

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) ⇒ Boolean

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[:adapter_class] 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).

Returns:

  • (Boolean) 


169
170
171
172
173
174
175
176
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 169

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 ⇒ Object

Returns the (JDBC) ActiveRecord column class for this adapter. This is used by (database specific) spec modules to override the class.

See Also:



96
97
98
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 96

def jdbc_column_class
  ::ActiveRecord::ConnectionAdapters::JdbcColumn
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



105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 105

def jdbc_connection(unwrap = nil)
  java_connection = raw_connection.connection
  return java_connection unless unwrap
  connection_class = java.sql.Connection.java_class
  if java_connection.wrapper_for?(connection_class)
    java_connection.unwrap(connection_class) # java.sql.Wrapper.unwrap
  elsif 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) ⇒ Object

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 Also:



88
89
90
91
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 88

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

#log(sql, name = nil, binds = []) ⇒ Object 



640
641
642
643
644
645
646
647
648
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 640

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

#modify_types(types) ⇒ Object

Allows for modification of the detected native types.

Parameters:

  • types —

    the resolved native database types

See Also:



217
218
219
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 217

def modify_types(types)
  types
end

#native_database_types ⇒ Hash

DB specific types are detected but adapter specs (or extenders) are expected to hand tune these types for concrete databases.

Returns:

  • (Hash) —

    the native database types



206
207
208
209
210
211
212
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 206

def native_database_types
  @native_database_types ||= begin
    types = @connection.native_database_types
    modify_types(types)
    types
  end
end

#pk_and_sequence_for(table) ⇒ Object 



592
593
594
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 592

def pk_and_sequence_for(table)
  ( key = primary_key(table) ) ? [ key, nil ] : nil
end

#prepared_statements? ⇒ Boolean (protected)

Returns whether :prepared_statements are to be used.

Returns:

  • (Boolean) —

    whether :prepared_statements are to be used



734
735
736
737
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 734

def prepared_statements?
  return @prepared_statements unless (@prepared_statements ||= nil).nil?
  @prepared_statements = self.class.prepared_statements?(config)
end

#primary_key(table) ⇒ Object 



597
598
599
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 597

def primary_key(table)
  primary_keys(table).first
end

#primary_keys(table) ⇒ Object 



602
603
604
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 602

def primary_keys(table)
  @connection.primary_keys(table)
end

#reconnect! ⇒ Object 



282
283
284
285
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 282

def reconnect!
  @connection.reconnect! # handles adapter.configure_connection
  @connection
end

#release_savepoint(name = current_savepoint_name) ⇒ Object

Note:

Save-points are auto-released with the transaction they're created

Release a previously created save-point. in (on transaction commit or roll-back).

Parameters:

  • name (defaults to: current_savepoint_name) —

    the save-point name

Since:

  • 1.3.0



393
394
395
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 393

def release_savepoint(name = current_savepoint_name)
  @connection.release_savepoint(name)
end

#rollback_db_transaction ⇒ Object

Rolls back the current database transaction.



339
340
341
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 339

def rollback_db_transaction
  @connection.rollback
end

#rollback_to_savepoint(name = current_savepoint_name) ⇒ Object

Transaction rollback to a given (previously created) save-point. If no save-point name given rollback to the last created one.

Parameters:

  • name (defaults to: current_savepoint_name) —

    the save-point name

Since:

  • 1.3.0



383
384
385
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 383

def rollback_to_savepoint(name = current_savepoint_name)
  @connection.rollback_savepoint(name)
end

#structure_dump ⇒ Object

Abstract adapter default implementation does nothing silently.

Raises:

  • (NotImplementedError) 


223
224
225
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 223

def structure_dump
  raise NotImplementedError, "structure_dump not supported"
end

#supports_migrations? ⇒ true

JDBC adapters support migration.

Returns:

  • (true) 


230
231
232
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 230

def supports_migrations?
  true
end

#supports_savepoints? ⇒ Boolean

Does our database (+ its JDBC driver) support save-points?

Returns:

  • (Boolean)

Since:

  • 1.3.0



364
365
366
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 364

def supports_savepoints?
  @connection.supports_savepoints?
end

#supports_transaction_isolation?(level = nil) ⇒ Boolean

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.

Parameters:

  • level (defaults to: nil) —

    optional to check if we support a specific isolation level

Returns:

  • (Boolean)

Since:

  • 1.3.0



357
358
359
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 357

def supports_transaction_isolation?(level = nil)
  @connection.supports_transaction_isolation?(level)
end

#table_definition ⇒ Object (protected)

aliasing #create_table_definition as #table_definition :



699
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 699

alias table_definition create_table_definition

#table_exists?(name) ⇒ Boolean

Returns:

  • (Boolean) 


581
582
583
584
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 581

def table_exists?(name)
  return false unless name
  @connection.table_exists?(name) # schema_name = nil
end

#tables(name = nil) ⇒ Object 



576
577
578
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 576

def tables(name = nil)
  @connection.tables
end

#translate_exception(e, message) ⇒ Object (protected) 



651
652
653
654
655
656
657
658
659
660
661
662
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 651

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

#update_lob_value(record, column, value) ⇒ Object

Parameters:

  • record —

    the record e.g. User.find(1)

  • column —

    the model's column e.g. User.columns_hash['photo']

  • value —

    the lob value - string or (IO or Java) stream



614
615
616
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 614

def update_lob_value(record, column, value)
  @connection.update_lob_value(record, column, value)
end

#write_large_object(*args) ⇒ Object

Deprecated.

Rather use #update_lob_value instead.



607
608
609
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 607

def write_large_object(*args)
  @connection.write_large_object(*args)
end