Class: ActiveRecord::ConnectionAdapters::JdbcAdapter
- Inherits:
-
AbstractAdapter
- Object
- AbstractAdapter
- ActiveRecord::ConnectionAdapters::JdbcAdapter
- 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.
Direct Known Subclasses
FirebirdAdapter, H2Adapter, HsqldbAdapter, InformixAdapter, MSSQLAdapter, MysqlAdapter, OracleAdapter, PostgreSQLAdapter, SQLite3Adapter
Constant Summary collapse
- ADAPTER_NAME =
'JDBC'.freeze
- @@suble_binds =
due compatibility
ActiveRecord::VERSION::MAJOR < 4
Instance Attribute Summary collapse
-
#config ⇒ Object
readonly
Returns the value of attribute config.
Class Method Summary collapse
-
.arel2_visitors(config) ⇒ Hash
deprecated
Deprecated.
re-implemented - no longer used
-
.configure_arel2_visitors(config) ⇒ Object
deprecated
Deprecated.
re-implemented - no longer used
-
.insert?(sql) ⇒ Boolean
protected
Whether the given SQL string is an 'INSERT' query.
- .new(connection, logger = nil, pool = nil) ⇒ Object
-
.prepared_statements?(config) ⇒ Boolean
protected
Allows changing the prepared statements setting for this connection.
-
.select?(sql) ⇒ Boolean
protected
query (returning a result set).
- .suble_binds=(flag) ⇒ Object protected
- .suble_binds? ⇒ Boolean protected
-
.update?(sql) ⇒ Boolean
protected
Whether the given SQL string is an 'UPDATE' (or 'DELETE') query.
Instance Method Summary collapse
- #active? ⇒ Boolean
-
#adapter_name ⇒ String
The 'JDBC' adapter name.
-
#adapter_spec(config) ⇒ Module
Locate the specialized (database specific) adapter specification module if one exists based on provided configuration data.
-
#begin_db_transaction ⇒ Object
Starts a database transaction.
-
#begin_isolated_db_transaction(isolation) ⇒ Object
Starts a database transaction.
- #columns(table_name, name = nil) ⇒ Object
-
#commit_db_transaction ⇒ Object
Commits the current database transaction.
-
#create_savepoint(name = current_savepoint_name(true)) ⇒ Object
Creates a (transactional) save-point one can rollback to.
-
#current_savepoint_name(compat = true) ⇒ 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.
- #data_source_exists?(name) ⇒ Boolean
- #data_sources ⇒ Object
-
#database_name ⇒ Object
Returns the underlying database name.
- #disconnect! ⇒ Object
-
#exec_delete(sql, name, binds) ⇒ Object
Executes a delete statement in the context of this connection.
-
#exec_insert(sql, name, binds, pk = nil, sequence_name = nil) ⇒ Object
Executes an insert statement in the context of this connection.
-
#exec_query(sql, name = 'SQL', binds = []) ⇒ ActiveRecord::Result
Executes a SQL query in the context of this connection using the bind substitutes.
-
#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#ActiveRecord::Result.
-
#exec_update(sql, name, binds) ⇒ Object
Executes an update statement in the context of this connection.
-
#execute_quietly(sql, name = 'SQL') ⇒ Object
Kind of
execute(sql) rescue nil
but logging failures at debug level only. - #foreign_keys(table_name) ⇒ Object
- #indexes(table_name, name = nil, schema_name = nil) ⇒ Object
-
#initialize(connection, logger, config = nil) ⇒ JdbcAdapter
constructor
Initializes the (JDBC connection) adapter instance.
- #insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) ⇒ Object
-
#is_a?(klass) ⇒ Boolean
Will return true even when native adapter classes passed in e.g.
-
#jdbc_column_class ⇒ Object
Returns the (JDBC)
ActiveRecord
column class for this adapter. -
#jdbc_connection(unwrap = nil) ⇒ Java::JavaSql::Connection
Retrieve the raw
java.sql.Connection
object. -
#jdbc_connection_class(spec) ⇒ Object
Returns the (JDBC) connection class to be used for this adapter.
- #log(sql, name = nil, binds = []) ⇒ Object
-
#modify_types(types) ⇒ Object
Allows for modification of the detected native types.
-
#native_database_types ⇒ Hash
DB specific types are detected but adapter specs (or extenders) are expected to hand tune these types for concrete databases.
- #pk_and_sequence_for(table) ⇒ Object
-
#prepared_statements? ⇒ Boolean
protected
Whether
:prepared_statements
are to be used. - #primary_key(table) ⇒ Object
- #primary_keys(table) ⇒ Object
- #reconnect! ⇒ Object
-
#release_savepoint(name = current_savepoint_name(false)) ⇒ Object
Release a previously created save-point.
-
#rollback_db_transaction ⇒ Object
Rolls back the current database transaction.
-
#rollback_to_savepoint(name = current_savepoint_name(true)) ⇒ Object
Transaction rollback to a given (previously created) save-point.
-
#structure_dump ⇒ Object
Abstract adapter default implementation does nothing silently.
-
#supports_foreign_keys? ⇒ Boolean
Does our database (+ its JDBC driver) support foreign-keys?.
-
#supports_migrations? ⇒ true
JDBC adapters support migration.
-
#supports_savepoints? ⇒ Boolean
Does our database (+ its JDBC driver) support save-points?.
-
#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. - #supports_views? ⇒ Boolean
-
#table_definition ⇒ Object
protected
aliasing #create_table_definition as #table_definition :.
- #table_exists?(name) ⇒ Boolean
- #tables(name = nil) ⇒ Object
- #translate_exception(e, message) ⇒ Object protected
- #update_lob_value(record, column, value) ⇒ Object
- #valid_type?(type) ⇒ Boolean
-
#write_large_object(*args) ⇒ Object
deprecated
Deprecated.
Rather use #update_lob_value instead.
Methods included from ActiveRecord::ConnectionAdapters::Jdbc::ConnectionPoolCallbacks
Methods included from ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
Constructor Details
#initialize(connection, logger, config = nil) ⇒ JdbcAdapter
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.
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
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.
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
re-implemented - no longer used
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.
896 897 898 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 896 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
823 824 825 826 827 |
# 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) ⇒ Boolean (protected)
query (returning a result set)
891 892 893 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 891 def self.select?(sql) JdbcConnection::select?(sql) end |
.suble_binds=(flag) ⇒ Object (protected)
835 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 835 def self.suble_binds=(flag); @@suble_binds = flag; end |
.suble_binds? ⇒ Boolean (protected)
834 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 834 def self.suble_binds?; @@suble_binds; end |
.update?(sql) ⇒ Boolean (protected)
Returns whether the given SQL string is an 'UPDATE' (or 'DELETE') query.
901 902 903 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 901 def self.update?(sql) ! select?(sql) && ! insert?(sql) end |
Instance Method Details
#active? ⇒ 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.
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.
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.
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.
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(compat = true) ⇒ 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.
420 421 422 423 424 425 426 427 |
# 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) ⇒ Boolean
627 628 629 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 627 def data_source_exists?(name) table_exists?(name) end |
#data_sources ⇒ Object
622 623 624 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 622 def data_sources tables 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.
481 482 483 484 485 486 487 488 489 490 491 |
# 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) ⇒ Object
Executes an insert statement in the context of this connection.
464 465 466 467 468 469 470 471 472 473 474 |
# 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 = []) ⇒ ActiveRecord::Result
Executes a SQL query in the context of this connection using the bind substitutes.
447 448 449 450 451 452 453 454 455 456 457 |
# 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 = []) {|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.
520 521 522 523 524 525 526 527 528 529 530 |
# 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) ⇒ Object
Executes an update statement in the context of this connection.
498 499 500 501 502 503 504 505 506 507 508 |
# 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_quietly(sql, name = 'SQL') ⇒ Object
Kind of execute(sql) rescue nil
but logging failures at debug level only.
600 601 602 603 604 605 606 607 608 |
# 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.}: #{sql}") end end end |
#foreign_keys(table_name) ⇒ Object
652 653 654 |
# 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) ⇒ Object
632 633 634 |
# 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) ⇒ Object
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).
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.
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.
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.
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
697 698 699 700 701 702 703 704 705 |
# 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 |
#modify_types(types) ⇒ Object
Allows for modification of the detected native types.
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.
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
637 638 639 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 637 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.
812 813 814 815 |
# 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 |
#primary_key(table) ⇒ Object
642 643 644 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 642 def primary_key(table) primary_keys(table).first end |
#primary_keys(table) ⇒ Object
647 648 649 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 647 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(false)) ⇒ Object
Save-points are auto-released with the transaction they're created
Release a previously created save-point. in (on transaction commit or roll-back).
409 410 411 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 409 def release_savepoint(name = current_savepoint_name(false)) @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(true)) ⇒ Object
Transaction rollback to a given (previously created) save-point. If no save-point name given rollback to the last created one.
399 400 401 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 399 def rollback_to_savepoint(name = current_savepoint_name(true)) @connection.rollback_savepoint(name) end |
#structure_dump ⇒ Object
Abstract adapter default implementation does nothing silently.
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?
659 660 661 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 659 def supports_foreign_keys? @connection.supports_foreign_keys? end |
#supports_migrations? ⇒ true
JDBC adapters support migration.
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?
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.
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
436 437 438 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 436 def supports_views? @connection.supports_views? end |
#table_definition ⇒ Object (protected)
aliasing #create_table_definition as #table_definition :
745 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 745 alias table_definition create_table_definition |
#table_exists?(name) ⇒ Boolean
616 617 618 619 |
# 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) ⇒ Object
611 612 613 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 611 def tables(name = nil) @connection.tables end |
#translate_exception(e, message) ⇒ Object (protected)
708 709 710 711 712 713 714 715 716 717 718 719 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 708 def translate_exception(e, ) # 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
671 672 673 |
# 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) ⇒ 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
Rather use #update_lob_value instead.
664 665 666 |
# File 'lib/arjdbc/jdbc/adapter.rb', line 664 def write_large_object(*args) @connection.write_large_object(*args) end |