activerecord-jdbc-adapter 5.0.pre1 → 51.0

data/README.md

@@ -1,31 +1,24 @@
 # ActiveRecord JDBC Adapter
 
-[![Gem Version](https://badge.fury.io/rb/activerecord-jdbc-adapter.png)][7]
-
-ActiveRecord-JDBC-Adapter (AR-JDBC) is a database adapter for Rails'
-*ActiveRecord* component that can be used with [JRuby][0]. It allows use of
-virtually any JDBC-compliant database with your JRuby on Rails application.
-
-We supports *ActiveRecord* **2.3**, **3.x** and **4.x** from a single code base.
-You'll need JRuby >= **1.6.8** (we recommend using the latest and greatest of
-JRubies) thus Java >= **1.6** is mandatory.
-
-#### AR-JDBC **1.3.x** is a recommended update for all **1.2.x** users.
-
-Our latest major version **1.3.x** represents a few months of refactoring and
-updates covering (not just) new/old *ActiveRecord* features. It tries to stay
-compatible with 1.2.9 as much as possible but please be aware that it's not always
-possible(mostly for the best), please read our [migration guide][8] for details.
-
-## Databases
+[![Gem Version](https://badge.fury.io/rb/activerecord-jdbc-adapter.svg)][7]
 
+ActiveRecord-JDBC-Adapter (AR-JDBC) is the main database adapter for Rails'
+*ActiveRecord* component that can be used with [JRuby][0].
 ActiveRecord-JDBC-Adapter provides full or nearly full support for:
-**MySQL**, **PostgreSQL**, **SQLite3**, **Oracle**, *MS-SQL** (SQL Server),
-**DB2**, **Firebird**, **Derby**, **HSQLDB**, **H2**, and **Informix**.
+**MySQL**, **PostgreSQL**, **SQLite3**.  In the near future there are plans to
+add support **MSSQL**. Unless we get more contributions we will not be going
+beyond these four adapters.  Note that the amount of work needed to get
+another adapter is not huge but the amount of testing required to make sure
+that adapter continues to work is not something we can do with the resources
+we currently have.
 
-Other databases will require testing and likely a custom configuration module.
-Please join the JRuby [mailing list][1] to help us discover support for more
-databases.
+For Oracle database users you are encouraged to use
+https://github.com/rsim/oracle-enhanced.
+
+Version 50.x supports Rails version 5.0.x and it lives on branch 50-stable.
+Version 51.x supports Rails version 5.1.x and is currently on master until
+its first release. The minimum version of JRuby for 50+ is JRuby 9.1.x and
+JRuby 9.1+ requires Java 7 or newer.
 
 ## Using ActiveRecord JDBC
 
@@ -36,39 +29,14 @@ To use AR-JDBC with JRuby on Rails:
 1. Choose the adapter you wish to gem install. The following pre-packaged
 adapters are available:
 
-  - Base JDBC (`activerecord-jdbc-adapter`) - supports all available databases
-    via JDBC, but requires you to download and manually setup a JDBC driver for
-    the database you're using
   - MySQL (`activerecord-jdbcmysql-adapter`)
   - PostgreSQL (`activerecord-jdbcpostgresql-adapter`)
   - SQLite3 (`activerecord-jdbcsqlite3-adapter`)
-  - Derby (`activerecord-jdbcderby-adapter`)
-  - HSQLDB (`activerecord-jdbchsqldb-adapter`)
-  - H2 (`activerecord-jdbch2-adapter`)
-  - MSSQL (`activerecord-jdbcmssql-adapter`) - uses the OSS jTDS driver by default
-    which might have issues with the latest SQLServer (but should work using the
-    Microsoft JDBC Driver for SQL Server - we recommend using 4.0)
 
-2a. If you're generating a new Rails application, use the following command:
+2. If you're generating a new Rails application, use the following command:
 
     jruby -S rails new sweetapp
 
-2b. Otherwise, you might need to perform some extra configuration steps
-to prepare your Rails application for JDBC.
-
-You'll need to modify your *Gemfile* to use the *activerecord-jdbc-adapter* gem
-(or one of the helper gems) under JRuby. Change your *Gemfile* to look something
-like the following:
-
-```ruby
-gem 'mysql2', platform: :ruby
-gem 'activerecord-jdbcmysql-adapter', platform: :jruby
-```
-
-If you're (stuck) using Rails 2.3, you might need to:
-
-    jruby script/generate jdbc
-
 3. Configure your *database.yml* in the normal Rails style:
 
 ```yml
@@ -79,22 +47,6 @@ development:
   password: 1234
 ```
 
-**Legacy Configuration:** If you use one of the *activerecord-jdbcxxx-adapter*
-gems, you can still put a 'jdbc' prefix in front of the database adapter name,
-e.g. `adapter: jdbcmysql`.
-
-For plain JDBC database configurations, you'll need to know the database driver
-class and URL (do not forget to put the driver .jar(s) on the class-path) e.g.:
-
-```yml
-development:
-  adapter: jdbc
-  username: blog
-  password: 1234
-  driver: com.mysql.jdbc.Driver
-  url: jdbc:mysql://localhost:3306/blog_development
-```
-
 For JNDI data sources, you may simply specify the JNDI location as follows, it's
 recommended to use the same adapter: setting as one would configure when using
 "bare" (JDBC) connections e.g. :
@@ -122,27 +74,6 @@ production:
     connectTimeout: 60000
 ```
 
-If you're really old school you might want to use AR-JDBC with a DB2 on z/OS:
-
-```yml
-development:
-  adapter: jdbc
-  url: jdbc:db2j:net://mightyzoshost:446/RAILS_DBT1
-  driver: com.ibm.db2.jcc.DB2Driver
-  schema: DB2XB12
-  database: RAILS_DB1
-  tablespace: TSDE911
-  lob_tablespaces:
-    first_table: TSDE912
-  username: business
-  password: machines
-  encoding: unicode
-  # you can force a (DB2) dialect using:
-  #dialect: as400
-```
-
-More information on (configuring) AR-JDBC might be found on our [wiki][5].
-
 ### Standalone with ActiveRecord
 
 Once the setup is made (see below) you can establish a JDBC connection like this
@@ -150,53 +81,34 @@ Once the setup is made (see below) you can establish a JDBC connection like this
 
 ```ruby
 ActiveRecord::Base.establish_connection(
-  adapter: 'derby',
+  adapter: 'sqlite3',
   database: 'db/my-database'
 )
 ```
 
-or using (requires that you manually put the driver jar on the class-path):
-
-```ruby
-ActiveRecord::Base.establish_connection(
-  :adapter => 'jdbc',
-  :driver => 'org.apache.derby.jdbc.EmbeddedDriver',
-  :url => 'jdbc:derby:sample_db;create=true'
-)
-```
-
 #### Using Bundler
 
 Proceed as with Rails; specify `ActiveRecord` in your Bundle along with the
 chosen JDBC adapter(s), this time sample *Gemfile* for MySQL:
 
 ```ruby
-gem 'activerecord', '~> 3.2.14'
+gem 'activerecord', '~> 5.0.6'
 gem 'activerecord-jdbcmysql-adapter', :platform => :jruby
 ```
 
 When you `require 'bundler/setup'` everything will be set up for you as expected.
 
-You do not need to use the 'helper' *activerecord-jdbcxxx-adapter* gem we provide
-but than should make sure an appropriate JDBC driver is available at runtime, in
-that case simply setup your *Gemfile* as:
-
-```ruby
-gem 'activerecord', '~> 4.0.0'
-gem 'activerecord-jdbc-adapter', '~> 1.3.2', platform: :jruby
-```
-
 #### Without Bundler
 
 Install the needed gems with JRuby, for example:
 
-    gem install activerecord -v "~> 3.2.10"
+    gem install activerecord -v "~> 5.0.6"
     gem install activerecord-jdbc-adapter --ignore-dependencies
 
 If you wish to use the adapter for a specific database, you can install it
 directly and the (jdbc-) driver gem (dependency) will be installed as well:
 
-    jruby -S gem install activerecord-jdbcderby-adapter
+    jruby -S gem install activerecord-jdbcmysql-adapter
 
 Your program should include:
 
@@ -204,16 +116,9 @@ Your program should include:
 require 'active_record'
 require 'activerecord-jdbc-adapter' if defined? JRUBY_VERSION
 # or in case you're using the pre-packaged adapter gem :
-require 'activerecord-jdbcderby-adapter' if defined? JRUBY_VERSION
+require 'activerecord-jdbcmysql-adapter' if defined? JRUBY_VERSION
 ```
 
-## Extending AR-JDBC
-
-You can create your own extension to AR-JDBC for a JDBC-based database that core
-AR-JDBC does not support. We've created an example project for the Intersystems
-Cache database that you can examine as a template.
-See the [cachedb-adapter project][4] for more information.
-
 ## Source
 
 The source for activerecord-jdbc-adapter is available using git:
@@ -263,4 +168,4 @@ license the database's drivers are licensed. See each driver gem's LICENSE.txt.
 [5]: https://github.com/jruby/activerecord-jdbc-adapter/wiki
 [6]: https://webchat.freenode.net/?channels=#jruby
 [7]: http://badge.fury.io/rb/activerecord-jdbc-adapter
-[8]: https://github.com/jruby/activerecord-jdbc-adapter/wiki/Migrating-from-1.2.x-to-1.3.0
+[8]: https://github.com/jruby/activerecord-jdbc-adapter/wiki/Migrating-from-1.2.x-to-1.3.0

data/RUNNING_TESTS.md

@@ -29,52 +29,57 @@ export ORACLE_PASS=sample
 export ORACLE_SID=MAIN
 ```
 
-Tests are by default run against the "current" ActiveRecord version locked down
-by Bundler, however since we usually do support more versions from a single code
-base run those with the (appraisal) provided task e.g. for MySQL :
+Tests are run by calling the rake task corresponding the database adapter being
+tested, e.g. for MySQL :
 
-    rake appraisal:rails31 test_mysql TEST=test/db/mysql/rake_test.rb
+    rake test_mysql TEST=test/db/mysql/rake_test.rb
 
 Observe the **TEST** variable used to specify a single file to be used to resolve
 test cases, you pick tests by matching their names as well using **TESTOPTS** :
 
-    rake appraisal:rails40 test_postgres TESTOPTS="--name=/integer/"
+    rake test_postgres TESTOPTS="--name=/integer/"
 
-This of course also works when running the "plain" test (no appraisal:xxx) task.
+Since 1.3.0 we also support prepared statements, these are enabled by default (AR)
+but one can easily run tests with prepared statements disabled using env vars :
 
-Since 1.3.0 we also support prepared statements, these are off by default (AR)
-but one can easily run tests with prepared statements enabled using env vars :
-
-    rake test_derby PS=true # or PREPARED_STATEMENTS=true
+    rake test_derby PREPARED_STATEMENTS=false
 
 
 ### ActiveRecord (Rails) Tests
 
-It's very desirable to pass all unit tests from ActiveRecord's own test suite.
-Unfortunately it's been a while since we have accomplished that, luckily a lot
-of failures are artificial (and would require tweaks at the Rails repo itself),
-others simply need quality time spent to get them in shape and address issues.
-
-First make sure you have the ActiveRecord (Rails) sources cloned locally :
+We also have the ability to run our adapters against Rails ActiveRecord
+tests as well.  First, make sure you have the Rails repository cloned locally:
 
     git clone git://github.com/rails/rails.git
 
-To run the AR-JDBC's sources agains AR tests, use the **rails:test** task, be
-sure to specify a **DRIVER** and the **RAILS** sources path on the file system :
+If you clone Rails to the same parent directory this project is cloned to
+then you may do either:
+
+    jruby -S rake rails:test:sqlite
+    jruby -S rake rails:test:postgres
+    jruby -S rake rails:test:mysql
+
+If you have your rails source in another directory then you can pass
+in **RAILS**:
+
+    jruby -S rake rails:test:sqlite RAILS=../../somewhere/rails
+
+If you are working on a more exotic adapter you can also pass in **DRIVER**:
 
-    jruby -S rake rails:test DRIVER=derby RAILS=path/to/rails_source_dir
+    jruby -S rake rails:test:all DRIVER=derby
 
-There's even tasks for Rails built-in adapters e.g. `rake rails:test_mysql`
+Note, that if you want to test against particular version of Rails you need
+to check out the proper branch in Rails source (e.g. v5.0.2).  If you are
+just starting to debug an adapter then running:
 
-You will likely only be able to run the Rails suite against the latest (stable)
-ActiveRecord ~> version we support (check the *Gemfile.lock*) e.g. for
-**activerecord (3.2.13)** you want to **git checkout 3-2-stable** branch.
+    jruby -S rake rails:test:sqlite:basic_test
+    jruby -S rake rails:test:postgres:basic_test
+    jruby -S rake rails:test:mysql:basic_test
 
-We strive to not stub and include native (MRI) test required artefacts into
-(non-test) code e.g. the `Mysql` module, instead put that into **test/rails**.
+is helpful since basic_test in active-record hits that 80% sweet spot.
 
 [![Build Status][0]](http://travis-ci.org/#!/jruby/activerecord-jdbc-adapter)
 
 Happy Testing!
 
-[0]: https://secure.travis-ci.org/jruby/activerecord-jdbc-adapter.png
+[0]: https://secure.travis-ci.org/jruby/activerecord-jdbc-adapter.png

data/Rakefile

@@ -8,15 +8,14 @@ require 'bundler/gem_helper'
 Bundler::GemHelper.install_tasks
 
 require 'bundler/setup'
-require 'appraisal'
 
 task :default => [:jar, :test]
 
 task :build => :jar
 task :install => :jar
 
-ADAPTERS = %w[derby h2 hsqldb mssql mysql postgresql sqlite3].map { |a| "activerecord-jdbc#{a}-adapter" }
-DRIVERS  = %w[derby h2 hsqldb jtds mysql postgres sqlite3].map { |a| "jdbc-#{a}" }
+ADAPTERS = %w[mysql postgresql sqlite3].map { |a| "activerecord-jdbc#{a}-adapter" }
+DRIVERS  = %w[mysql postgres sqlite3].map { |a| "jdbc-#{a}" }
 TARGETS = ( ADAPTERS + DRIVERS )
 
 rake = lambda { |task| ruby "-S", "rake", task }

data/activerecord-jdbc-adapter.gemspec

@@ -29,8 +29,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  # NOTE: 1.3.0 only supports >= 2.3 but users report it works with 2.2 :
-  gem.add_dependency 'activerecord', '>= 2.2'
+  gem.add_dependency 'activerecord', '~> 5.1.0'
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arjdbc/abstract/connection_management.rb

@@ -0,0 +1,21 @@
+module ArJdbc
+  module Abstract
+    module ConnectionManagement
+
+      def active?
+        @connection.active?
+      end
+
+      def disconnect!
+        super
+        @connection.disconnect!
+      end
+
+      def reconnect!
+        super
+        @connection.reconnect! # handles adapter.configure_connection
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/core.rb

@@ -0,0 +1,62 @@
+module ArJdbc
+  module Abstract
+
+    # This is minimum amount of code needed from base JDBC Adapter class to make common adapters
+    # work.  This replaces using jdbc/adapter as a base class for all adapters.
+    module Core
+
+      attr_reader :config
+
+      def initialize(connection, logger = nil, config = {})
+        @config = config
+
+        connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)
+
+        super(connection, logger, config)
+
+        # NOTE: should not be necessary for JNDI due reconnect! on checkout :
+        configure_connection if respond_to?(:configure_connection)
+      end
+
+      # 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
+      def jdbc_connection(unwrap = false)
+        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
+
+      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?(Java::JavaLang::Throwable)
+
+        case e
+          when ActiveModel::RangeError, TypeError, SystemExit, SignalException, NoMemoryError then e
+          # NOTE: wraps AR::JDBCError into AR::StatementInvalid, desired ?!
+          else super
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/database_statements.rb

@@ -0,0 +1,46 @@
+module ArJdbc
+  module Abstract
+
+    # This provides the basic interface for interacting with the
+    # database for JDBC based adapters
+    module DatabaseStatements
+
+      # It appears that at this point (AR 5.0) "prepare" should only ever be true
+      # if prepared statements are enabled
+      def exec_query(sql, name = nil, binds = [], prepare: false)
+        if without_prepared_statement?(binds)
+          execute(sql, name)
+        else
+          binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+          log(sql, name, binds) do
+            # It seems that #supports_statement_cache? is defined but isn't checked before setting "prepare" (AR 5.0)
+            cached_statement = fetch_cached_statement(sql) if prepare && supports_statement_cache?
+            @connection.execute_prepared(sql, binds, cached_statement)
+          end
+        end
+      end
+
+      def exec_update(sql, name = nil, binds = [])
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_update(sql, nil) }
+        else
+          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        end
+      end
+      alias :exec_delete :exec_update
+
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      private
+
+      def convert_legacy_binds_to_attributes(binds)
+        binds.map do |column, value|
+          ActiveRecord::Relation::QueryAttribute.new(nil, type_cast(value, column), ActiveModel::Type::Value.new)
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -0,0 +1,58 @@
+require 'active_record/connection_adapters/statement_pool'
+
+module ArJdbc
+  module Abstract
+    module StatementCache
+
+      # This works a little differently than the AR implementation in that
+      # we are storing an actual PreparedStatement object instead of just
+      # the name of the prepared statement
+      class StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
+
+        private
+
+        def dealloc(statement)
+          statement.close
+        end
+
+      end
+
+      def initialize(connection, logger, config)
+        super
+
+        # Only say we support the statement cache if we are using prepared statements
+        # and have a max number of statements defined
+        statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
+        @jdbc_statement_cache_enabled = config[:prepared_statements] && (statement_limit.nil? || statement_limit > 0)
+
+        @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
+      end
+
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.clear
+      end
+
+      def delete_cached_statement(sql)
+        @statements.delete(cached_statement_key(sql))
+      end
+
+      def fetch_cached_statement(sql)
+        @statements[cached_statement_key(sql)] ||= @connection.connection.prepare_statement(sql)
+      end
+
+      def supports_statement_cache?
+        @jdbc_statement_cache_enabled
+      end
+
+      private
+
+      # This should be overridden by the adapter if the sql itself
+      # is not enough to make the key unique
+      def cached_statement_key(sql)
+        sql
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/transaction_support.rb

@@ -0,0 +1,86 @@
+module ArJdbc
+  module Abstract
+
+    # Provides the basic interface needed to support transactions for JDBC based adapters
+    module TransactionSupport
+
+      ########################## Support Checks #################################
+
+      # Does our database (+ its JDBC driver) support save-points?
+      # @since 1.3.0
+      # @override
+      def supports_savepoints?
+        @connection.supports_savepoints?
+      end
+
+      # 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
+      def supports_transaction_isolation?(level = nil)
+        return false unless level
+        @connection.supports_transaction_isolation?(level)
+      end
+
+      ########################## Transaction Interface ##########################
+
+      # Starts a database transaction.
+      # @override
+      def begin_db_transaction
+        log('BEGIN TRANSACTION'.freeze, nil) { @connection.begin }
+      end
+
+      # Starts a database transaction.
+      # @param isolation the transaction isolation to use
+      def begin_isolated_db_transaction(isolation)
+        log("BEGIN ISOLATED TRANSACTION - #{isolation}", nil) { @connection.begin(isolation) }
+      end
+
+      # Commits the current database transaction.
+      # @override
+      def commit_db_transaction
+        log('COMMIT TRANSACTION'.freeze, nil) { @connection.commit }
+      end
+
+      # Rolls back the current database transaction.
+      # Called from 'rollback_db_transaction' in the AbstractAdapter
+      # @override
+      def exec_rollback_db_transaction
+        log('ROLLBACK TRANSACTION'.freeze, nil) { @connection.rollback }
+      end
+
+      ########################## Savepoint Interface ############################
+
+      # 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
+      def create_savepoint(name = current_savepoint_name)
+        log("SAVEPOINT #{name}", 'Savepoint') { @connection.create_savepoint(name) }
+      end
+
+      # Transaction rollback to a given (previously created) save-point.
+      # If no save-point name given rollback to the last created one.
+      # Called from 'rollback_to_savepoint' in AbstractAdapter
+      # @param name the save-point name
+      # @extension added optional name parameter
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        log("ROLLBACK TO SAVEPOINT #{name}", 'Savepoint') { @connection.rollback_savepoint(name) }
+      end
+
+      # 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
+      # @extension added optional name parameter
+      def release_savepoint(name = current_savepoint_name)
+        log("RELEASE SAVEPOINT #{name}", 'Savepoint') { @connection.release_savepoint(name) }
+      end
+
+    end
+  end
+end

data/lib/arjdbc/derby/adapter.rb

@@ -175,10 +175,15 @@ module ArJdbc
       NATIVE_DATABASE_TYPES
     end
 
+    # UNTESTED
+    def existing_savepoint_name?(name)
+      (@connection.instance_variable_get('@savepoints') || {}).key? name
+    end
+
     # Ensure the savepoint name is unused before creating it.
     # @override
     def create_savepoint(name = current_savepoint_name(true))
-      release_savepoint(name) if @connection.marked_savepoint_names.include?(name)
+      release_savepoint(name) if existing_savepoint_name?(name)
       super(name)
     end
 

data/lib/arjdbc/discover.rb

@@ -75,13 +75,6 @@ module ArJdbc
     end
   end
 
-  extension :Oracle do |name|
-    if name =~ /oracle/i
-      require 'arjdbc/oracle'
-      true
-    end
-  end
-  
   # NOTE: following ones are likely getting deprecated :
   
   extension :FireBird do |name|

data/lib/arjdbc/firebird/adapter.rb

@@ -413,7 +413,7 @@ module ActiveRecord::ConnectionAdapters
     #   ActiveRecord::ConnectionAdapters::FirebirdAdapter.emulate_booleans = false
     #
     def self.emulate_booleans?; ::ArJdbc::Firebird.emulate_booleans?; end
-    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end # oracle-enhanced
+    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end
     def self.emulate_booleans=(emulate); ::ArJdbc::Firebird.emulate_booleans = emulate; end
 
     def initialize(*args)
@@ -431,4 +431,4 @@ module ActiveRecord::ConnectionAdapters
     include ::ArJdbc::Firebird::Column
   end
 
-end
+end