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



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
83
84
85
86
87
88
 
# 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

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



193
194
195
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 193

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


199
200
201
202
203
204
205
206
207
208
209
210
211
 
# 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

.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



883
884
885
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 883

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

.new(connection, logger = nil, pool = nil) ⇒ Object 



43
44
45
46
47
 
# 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

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



810
811
812
813
814
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 810

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



878
879
880
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 878

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

.suble_binds=(flag) ⇒ Object (protected) 



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

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

.suble_binds? ⇒ Boolean (protected)

Returns:

  • (Boolean) 


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

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



888
889
890
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 888

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

Instance Method Details

#active? ⇒ Boolean

Returns:

  • (Boolean) 


293
294
295
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 293

def active?
  @connection.active?
end

#adapter_name ⇒ String

Returns the 'JDBC' adapter name.

Returns:

  • (String) —

    the 'JDBC' adapter name.



168
169
170
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 168

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



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# 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 ⇒ Object

Starts a database transaction.



343
344
345
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 343

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



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

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

#columns(table_name, name = nil) ⇒ Object 



337
338
339
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 337

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

#commit_db_transaction ⇒ Object

Commits the current database transaction.



349
350
351
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 349

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



390
391
392
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 390

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



420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 420

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.



252
253
254
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 252

def database_name
  @connection.database_name
end

#disconnect! ⇒ Object 



304
305
306
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 304

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



478
479
480
481
482
483
484
485
486
487
488
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 478

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



461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 461

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



444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 444

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



517
518
519
520
521
522
523
524
525
526
527
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 517

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



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

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_quietly(sql, name = 'SQL') ⇒ Object

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



597
598
599
600
601
602
603
604
605
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 597

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



639
640
641
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 639

def foreign_keys(table_name)
  @connection.foreign_keys(table_name)
end

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



619
620
621
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 619

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



332
333
334
335
 
# 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) ⇒ 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) 


180
181
182
183
184
185
186
187
 
# 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 ⇒ Object

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

See Also:



102
103
104
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 102

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



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# 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) ⇒ 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:



94
95
96
97
 
# 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

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



684
685
686
687
688
689
690
691
692
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 684

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:



233
234
235
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 233

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



217
218
219
220
221
222
223
 
# 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

#pk_and_sequence_for(table) ⇒ Object 



624
625
626
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 624

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



799
800
801
802
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 799

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

#primary_key(table) ⇒ Object 



629
630
631
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 629

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

#primary_keys(table) ⇒ Object 



634
635
636
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 634

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

#reconnect! ⇒ Object 



298
299
300
301
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 298

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



409
410
411
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 409

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

#rollback_db_transaction ⇒ Object

Rolls back the current database transaction.



355
356
357
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 355

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



399
400
401
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 399

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) 


239
240
241
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 239

def structure_dump
  raise NotImplementedError, "structure_dump not supported"
end

#supports_foreign_keys? ⇒ Boolean

Does our database (+ its JDBC driver) support foreign-keys?

Returns:

  • (Boolean)

Since:

  • 1.3.18



646
647
648
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 646

def supports_foreign_keys?
  @connection.supports_foreign_keys?
end

#supports_migrations? ⇒ true

JDBC adapters support migration.

Returns:

  • (true) 


246
247
248
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 246

def supports_migrations?
  true
end

#supports_savepoints? ⇒ Boolean

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

Returns:

  • (Boolean)

Since:

  • 1.3.0



380
381
382
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 380

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



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

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

#supports_views? ⇒ Boolean

Returns:

  • (Boolean) 


433
434
435
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 433

def supports_views?
  @connection.supports_views?
end

#table_definition ⇒ Object (protected)

aliasing #create_table_definition as #table_definition :



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

alias table_definition create_table_definition

#table_exists?(name) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#tables(name = nil) ⇒ Object 



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

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

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



695
696
697
698
699
700
701
702
703
704
705
706
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 695

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



658
659
660
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 658

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

#valid_type?(type) ⇒ Boolean

Returns:

  • (Boolean) 


226
227
228
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 226

def valid_type?(type)
  ! native_database_types[type].nil?
end

#write_large_object(*args) ⇒ Object

Deprecated.

Rather use #update_lob_value instead.



651
652
653
 
# File 'lib/arjdbc/jdbc/adapter.rb', line 651

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