activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

data/lib/arjdbc/h2/adapter.rb

@@ -1,3 +1,4 @@
+ArJdbc.load_java_part :H2
 require 'arjdbc/hsqldb/adapter'
 
 module ArJdbc
@@ -11,11 +12,11 @@ module ArJdbc
     def self.column_selector
       [ /\.h2\./i, lambda { |cfg, column| column.extend(::ArJdbc::H2::Column) } ]
     end
-    
+
     module Column
-      
+
       private
-      
+
       def extract_limit(sql_type)
         limit = super
         case @sql_type = sql_type.downcase
@@ -34,14 +35,14 @@ module ArJdbc
         when /blob|image|oid/i then @sql_type = 'blob'; limit = nil
         when /clob|text/i      then @sql_type = 'clob'; limit = nil
         # NOTE: use lower-case due SchemaDumper not handling it's decimal/integer
-        # optimization case-insensitively due : column.type == :integer && 
+        # optimization case-insensitively due : column.type == :integer &&
         # [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
         when /^decimal\(65535,32767\)/i
           @sql_type = 'decimal'; nil
         end
         limit
       end
-      
+
       def simplified_type(field_type)
         case field_type
         when /^bit|bool/i         then :boolean
@@ -54,7 +55,7 @@ module ArJdbc
           super
         end
       end
-      
+
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # H2 auto-generated key default value
@@ -63,11 +64,11 @@ module ArJdbc
         return $1 if value =~ /^'(.*)'$/
         value
       end
-      
+
     end
-    
+
     ADAPTER_NAME = 'H2' # :nodoc:
-    
+
     def adapter_name # :nodoc:
       ADAPTER_NAME
     end
@@ -79,14 +80,14 @@ module ArJdbc
         'jdbch2' => ::Arel::Visitors::HSQLDB,
       })
     end
-    
+
     # #deprecated
     def h2_adapter # :nodoc:
       true
     end
 
     NATIVE_DATABASE_TYPES = {
-      :primary_key => "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY",
+      :primary_key => "bigint identity",
       :boolean     => { :name => "boolean" },
       :tinyint     => { :name => "tinyint", :limit => 1 },
       :smallint    => { :name => "smallint", :limit => 2 },
@@ -115,11 +116,11 @@ module ArJdbc
     def native_database_types
       NATIVE_DATABASE_TYPES.dup
     end
-    
+
     def modify_types(types)
       types
     end
-    
+
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       case type.to_sym
       when :integer
@@ -146,6 +147,10 @@ module ArJdbc
         super
       end
     end
+
+    def empty_insert_statement_value
+      "VALUES ()"
+    end
     
     def tables
       @connection.tables(nil, h2_schema)
@@ -164,7 +169,7 @@ module ArJdbc
     def current_schema
       execute('CALL SCHEMA()')[0].values[0]
     end
-    
+
     def quote(value, column = nil) # :nodoc:
       case value
       when String
@@ -177,9 +182,9 @@ module ArJdbc
         super
       end
     end
-    
+
     # EXPLAIN support :
-    
+
     def supports_explain?; true; end
 
     def explain(arel, binds = [])
@@ -188,8 +193,37 @@ module ArJdbc
       raw_result[0].values.join("\n") # [ "SELECT \n ..." ].to_s
     end
     
-    private
+    def structure_dump
+      execute('SCRIPT SIMPLE').map do |result| 
+        # [ { 'script' => SQL }, { 'script' ... }, ... ]
+        case sql = result.first[1] # ['script']
+        when /CREATE USER IF NOT EXISTS SA/i then nil
+        else sql
+        end
+      end.compact.join("\n\n")
+    end
+
+    def structure_load(dump)
+      dump.each_line("\n\n") { |ddl| execute(ddl) }
+    end
+    
+    def shutdown
+      execute 'SHUTDOWN COMPACT'
+    end
+    
+    def recreate_database(name = nil, options = {}) # :nodoc:
+      drop_database(name)
+      create_database(name, options)
+    end
     
+    def create_database(name = nil, options = {}); end # :nodoc:
+    
+    def drop_database(name = nil) # :nodoc:
+      execute('DROP ALL OBJECTS')
+    end
+
+    private
+
     def change_column_null(table_name, column_name, null, default = nil)
       if !null && !default.nil?
         execute("UPDATE #{table_name} SET #{column_name}=#{quote(default)} WHERE #{column_name} IS NULL")
@@ -204,6 +238,6 @@ module ArJdbc
     def h2_schema
       @config[:schema] || ''
     end
-    
+
   end
 end

data/lib/arjdbc/h2/connection_methods.rb

@@ -6,9 +6,17 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
     
-    config[:url] ||= "jdbc:h2:#{config[:database]}"
+    config[:url] ||= begin
+      db = config[:database]
+      if db[0, 4] == 'mem:' || db[0, 5] == 'file:' || db[0, 5] == 'hsql:'
+        "jdbc:h2:#{db}"
+      else
+        "jdbc:h2:file:#{db}"
+      end
+    end
     config[:driver] ||= defined?(::Jdbc::H2.driver_name) ? ::Jdbc::H2.driver_name : 'org.h2.Driver'
-    config[:adapter_spec] = ::ArJdbc::H2
+    config[:adapter_spec] ||= ::ArJdbc::H2
+    
     embedded_driver(config)
   end
   alias_method :jdbch2_connection, :h2_connection

data/lib/arjdbc/hsqldb/adapter.rb

@@ -1,3 +1,4 @@
+ArJdbc.load_java_part :HSQLDB
 require 'arjdbc/hsqldb/explain_support'
 
 module ArJdbc
@@ -188,6 +189,12 @@ module ArJdbc
       end
     end
 
+    def empty_insert_statement_value
+      # on HSQLDB only work with tables that have a default value for each 
+      # and every column ... you'll need to avoid `Model.create!` on 4.0
+      'DEFAULT VALUES'
+    end
+    
     # filter out system tables (that otherwise end up in db/schema.rb)
     # JdbcConnection#tables
     # now takes an optional block filter so we can screen out
@@ -201,19 +208,36 @@ module ArJdbc
     def remove_index(table_name, options = {})
       execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
     end
+    
+    def structure_dump
+      execute('SCRIPT').map do |result| 
+        # [ { 'command' => SQL }, { 'command' ... }, ... ]
+        case sql = result.first[1] # ['command']
+        when /CREATE USER SA PASSWORD DIGEST .*?/i then nil
+        when /CREATE SCHEMA PUBLIC AUTHORIZATION DBA/i then nil
+        when /GRANT DBA TO SA/i then nil
+        else sql
+        end
+      end.compact.join("\n\n")
+    end
 
-    def recreate_database(name, options = {})
-      drop_database(name)
+    def structure_load(dump)
+      dump.each_line("\n\n") { |ddl| execute(ddl) }
     end
     
-    # do nothing since database gets created upon connection. However
-    # this method gets called by rails db rake tasks so now we're
-    # avoiding method_missing error
-    def create_database(name)
+    def shutdown
+      execute 'SHUTDOWN'
     end
-
-    def drop_database(name)
-      execute("DROP ALL OBJECTS")
+    
+    def recreate_database(name = nil, options = {}) # :nodoc:
+      drop_database(name)
+      create_database(name, options)
+    end
+    
+    def create_database(name = nil, options = {}); end # :nodoc:
+    
+    def drop_database(name = nil) # :nodoc:
+      execute('DROP SCHEMA PUBLIC CASCADE')
     end
     
   end

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -6,10 +6,18 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
     
-    config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+    config[:url] ||= begin
+      db = config[:database]
+      if db[0, 4] == 'mem:' || db[0, 5] == 'file:' || db[0, 5] == 'hsql:'
+        "jdbc:hsqldb:#{db}"
+      else
+        "jdbc:hsqldb:file:#{db}"
+      end
+    end
     config[:driver] ||= defined?(::Jdbc::HSQLDB.driver_name) ? ::Jdbc::HSQLDB.driver_name : 'org.hsqldb.jdbcDriver'
-    config[:adapter_spec] = ::ArJdbc::HSQLDB
+    config[:adapter_spec] ||= ::ArJdbc::HSQLDB
     config[:connection_alive_sql] ||= 'CALL PI()' # does not like 'SELECT 1'
+    
     embedded_driver(config)
   end
   alias_method :jdbchsqldb_connection, :hsqldb_connection

data/lib/arjdbc/informix.rb

@@ -1,3 +1,4 @@
 require 'arjdbc'
-require 'arjdbc/informix/connection_methods'
+ArJdbc.load_java_part :Informix
 require 'arjdbc/informix/adapter'
+require 'arjdbc/informix/connection_methods'

data/lib/arjdbc/jdbc.rb

@@ -1,2 +1,6 @@
 require 'arjdbc/jdbc/adapter'
-module ArJdbc; self.discover_extensions; end
+if Java::JavaLang::Boolean.getBoolean('arjdbc.extensions.discover')
+  module ArJdbc; self.discover_extensions; end
+else
+  require 'arjdbc/discover'
+end

data/lib/arjdbc/jdbc/adapter.rb

@@ -16,31 +16,42 @@ module ActiveRecord
   module ConnectionAdapters
     class JdbcAdapter < AbstractAdapter
       extend ShadowCoreMethods
-      include JdbcConnectionPoolCallbacks if JdbcConnectionPoolCallbacks.needed?
+      
+      include JdbcConnectionPoolCallbacks
       
       attr_reader :config
-
-      def initialize(connection, logger, config)
-        @config = config
-        spec = config[:adapter_spec] || adapter_spec(config)
-        config[:adapter_spec] ||= spec
-        unless connection
-          connection_class = jdbc_connection_class spec
-          connection = connection_class.new config
+      
+      def initialize(connection, logger, config = nil) # (logger, config)
+        if config.nil? && logger.respond_to?(:key?) # only 2 arguments given
+          config, logger, connection = logger, connection, nil
         end
+        
+        @config = config
+        
+        @config[:adapter_spec] = adapter_spec(@config) unless @config.key?(:adapter_spec)
+        spec = @config[:adapter_spec]
+        
+        connection ||= jdbc_connection_class(spec).new(@config)
+        
         super(connection, logger)
-        if spec && (config[:adapter_class].nil? || config[:adapter_class] == JdbcAdapter)
-          extend spec
-        end
-        configure_arel2_visitors(config)
-        connection.adapter = self
+        
+        # kind of like `extend ArJdbc::MyDB if self.class == JdbcAdapter` :
+        klass = @config[:adapter_class]
+        extend spec if spec && ( ! klass || klass == JdbcAdapter)
+        
+        connection.adapter = self # prepares native database types
+        
+        # NOTE: should not be necessary for JNDI due reconnect! on checkout :
+        configure_connection if respond_to?(:configure_connection)
+        
         JndiConnectionPoolCallbacks.prepare(self, connection)
+        
+        @visitor = new_visitor(@config) # nil if no AREL (AR-2.3)
       end
-
+      
       def jdbc_connection_class(spec)
         connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
-        connection_class = ::ActiveRecord::ConnectionAdapters::JdbcConnection unless connection_class
-        connection_class
+        connection_class ? connection_class : ::ActiveRecord::ConnectionAdapters::JdbcConnection
       end
 
       def jdbc_column_class
@@ -67,18 +78,17 @@ module ActiveRecord
       # Locate specialized adapter specification if one exists based on config data
       def adapter_spec(config)
         dialect = (config[:dialect] || config[:driver]).to_s
-        ::ArJdbc.constants.sort.each do |constant|
-          constant = ::ArJdbc.const_get(constant) # e.g. ArJdbc::MySQL
-
+        ::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[:dialect]
+        if (config[:jndi] || config[:data_source]) && ! config[:dialect]
           begin
-            data_source = Java::JavaxNaming::InitialContext.new.lookup(config[:jndi])
+            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
@@ -97,41 +107,99 @@ module ActiveRecord
         types
       end
 
-      def adapter_name #:nodoc:
+      def adapter_name # :nodoc:
         'JDBC'
       end
 
+      def self.arel2_visitors(config)
+        { 'jdbc' => ::Arel::Visitors::ToSql }
+      end
+
+      # NOTE: called from {ConnectionPool#checkout} (up till AR-3.2)
       def self.visitor_for(pool)
         config = pool.spec.config
-        adapter = config[:adapter]
-        adapter_spec = config[:adapter_spec] || self
-        if adapter =~ /^(jdbc|jndi)$/
-          adapter_spec.arel2_visitors(config).values.first.new(pool)
-        else
-          adapter_spec.arel2_visitors(config)[adapter].new(pool)
+        adapter = config[:adapter] # e.g. "sqlite3" (based on {#adapter_name})
+        unless visitor = ::Arel::Visitors::VISITORS[ adapter ]
+          adapter_spec = config[:adapter_spec] || self # e.g. ArJdbc::SQLite3
+          if adapter =~ /^(jdbc|jndi)$/
+            visitor = adapter_spec.arel2_visitors(config).values.first
+          else
+            visitor = adapter_spec.arel2_visitors(config)[adapter]
+          end
         end
+        ( prepared_statements?(config) ? visitor : bind_substitution(visitor) ).new(pool)
       end
 
-      def self.arel2_visitors(config)
-        { 'jdbc' => ::Arel::Visitors::ToSql }
+      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
 
-      def configure_arel2_visitors(config)
-        if defined?(::Arel::Visitors::VISITORS)
-          visitors = ::Arel::Visitors::VISITORS
-          visitor = nil
-          adapter_spec = [config[:adapter_spec], self.class].detect {|a| a && a.respond_to?(:arel2_visitors) }
-          adapter_spec.arel2_visitors(config).each do |k,v|
-            visitor = v
-            visitors[k] = v
+      def new_visitor(config = self.config)
+        visitor = ::Arel::Visitors::VISITORS[ adapter = config[:adapter] ]
+        unless visitor
+          visitor = self.class.configure_arel2_visitors(config)
+          unless visitor
+            raise "no visitor configured for adapter: #{adapter.inspect}"
           end
-          if visitor && config[:adapter] =~ /^(jdbc|jndi)$/
-            visitors[config[:adapter]] = visitor
+        end
+        ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
+      end
+      protected :new_visitor
+      
+      unless defined? ::Arel::Visitors::VISITORS # NO-OP when no AREL (AR-2.3)
+        def self.configure_arel2_visitors(config); end
+        def new_visitor(config = self.config); end
+      end
+      
+      @@bind_substitutions = nil
+      
+      # @return a {#Arel::Visitors::BindVisitor} class for given visitor type
+      def self.bind_substitution(visitor)
+        # NOTE: similar convention as in AR (but no base substitution type) :
+        # class BindSubstitution < ::Arel::Visitors::ToSql
+        #   include ::Arel::Visitors::BindVisitor
+        # end
+        return const_get(:BindSubstitution) if const_defined?(:BindSubstitution)
+        
+        @@bind_substitutions ||= Java::JavaUtil::HashMap.new
+        unless bind_visitor = @@bind_substitutions.get(visitor)
+          @@bind_substitutions.synchronized do
+            unless @@bind_substitutions.get(visitor)
+              bind_visitor = Class.new(visitor) do
+                include ::Arel::Visitors::BindVisitor
+              end
+              @@bind_substitutions.put(visitor, bind_visitor)
+            end
           end
-          @visitor = visitors[config[:adapter]].new(self)
+          bind_visitor = @@bind_substitutions.get(visitor)
         end
+        bind_visitor
       end
-
+      
+      begin 
+        require 'arel/visitors/bind_visitor'
+      rescue LoadError # AR-3.0
+        def self.bind_substitution(visitor); visitor; end
+      end
+      
+      def bind_substitution(visitor); self.class.bind_substitution(visitor); end
+      private :bind_substitution
+      
+      # @override default implementation (does nothing silently)
+      def structure_dump
+        raise NotImplementedError, "structure_dump not supported"
+      end
+      
       def is_a?(klass) # :nodoc:
         # This is to fake out current_adapter? conditional logic in AR tests
         if Class === klass && klass.name =~ /#{adapter_name}Adapter$/i
@@ -145,11 +213,11 @@ module ActiveRecord
         true
       end
 
-      def native_database_types #:nodoc:
+      def native_database_types # :nodoc:
         @connection.native_database_types
       end
 
-      def database_name #:nodoc:
+      def database_name # :nodoc:
         @connection.database_name
       end
 
@@ -193,8 +261,7 @@ module ActiveRecord
       end
 
       def reconnect!
-        @connection.reconnect!
-        configure_connection if respond_to?(:configure_connection)
+        @connection.reconnect! # handles adapter.configure_connection
         @connection
       end
 
@@ -207,61 +274,71 @@ module ActiveRecord
         def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])  # :nodoc:
           insert_sql(sql, name, pk, id_value, sequence_name, binds)
         end
+        alias_chained_method :insert, :query_dirty, :jdbc_insert
         
         def jdbc_update(sql, name = nil, binds = []) # :nodoc:
           execute(sql, name, binds)
         end
+        alias_chained_method :update, :query_dirty, :jdbc_update
         
         def jdbc_select_all(sql, name = nil, binds = []) # :nodoc:
           select(sql, name, binds)
         end
-        
-        # Allow query caching to work even when we override alias_method_chain'd methods
         alias_chained_method :select_all, :query_cache, :jdbc_select_all
-        alias_chained_method :update, :query_dirty, :jdbc_update
-        alias_chained_method :insert, :query_dirty, :jdbc_insert
         
       end
-
-      def jdbc_columns(table_name, name = nil)
+      
+      def columns(table_name, name = nil)
         @connection.columns(table_name.to_s)
       end
-      alias_chained_method :columns, :query_cache, :jdbc_columns
       
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes.  +name+ is logged along with
       # the executed +sql+ statement.
       def exec_query(sql, name = 'SQL', binds = []) # :nodoc:
-        log(sql, name || 'SQL') { @connection.execute_query(to_sql(sql, binds)) }
+        sql = to_sql(sql, binds)
+        if prepared_statements?
+          log(sql, name, binds) { @connection.execute_query(sql, binds) }
+        else
+          sql = suble_binds(sql, binds)
+          log(sql, name) { @connection.execute_query(sql) }
+        end
       end
 
       # Executes insert +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is the logged along with
       # the executed +sql+ statement.
       def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
-        log(sql, name || 'SQL') { @connection.execute_insert(to_sql(sql, binds)) }
+        sql = suble_binds to_sql(sql, binds), binds
+        log(sql, name || 'SQL') { @connection.execute_insert(sql) }
       end
 
       # Executes delete +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is the logged along with
       # the executed +sql+ statement.
       def exec_delete(sql, name, binds) # :nodoc:
-        log(sql, name || 'SQL') { @connection.execute_delete(to_sql(sql, binds)) }
+        sql = suble_binds to_sql(sql, binds), binds
+        log(sql, name || 'SQL') { @connection.execute_delete(sql) }
       end
 
       # Executes update +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is the logged along with
       # the executed +sql+ statement.
       def exec_update(sql, name, binds) # :nodoc:
-        log(sql, name || 'SQL') { @connection.execute_update(to_sql(sql, binds)) }
+        sql = suble_binds to_sql(sql, binds), binds
+        log(sql, name || 'SQL') { @connection.execute_update(sql) }
       end
       
       # Similar to {#exec_query} except it returns "raw" results in an array
       # where each rows is a hash with keys as columns (just like Rails used to 
       # do up until 3.0) instead of wrapping them in a {#ActiveRecord::Result}.
       def exec_query_raw(sql, name = 'SQL', binds = [], &block) # :nodoc:
-        log(sql, name || 'SQL') do
-          @connection.execute_query_raw(to_sql(sql, binds), &block)
+        sql = to_sql(sql, binds)
+        if prepared_statements?
+          log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
+        else
+          sql = suble_binds(sql, binds)
+          log(sql, name) { @connection.execute_query_raw(sql, &block) }
         end
       end
       
@@ -289,7 +366,7 @@ module ActiveRecord
       
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil, binds = [])
-        sql = to_sql(sql, binds)
+        sql = suble_binds to_sql(sql, binds), binds
         if name == :skip_logging
           _execute(sql, name)
         else
@@ -304,7 +381,7 @@ module ActiveRecord
       
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil, binds = [])
-        sql = to_sql(sql, binds)
+        sql = suble_binds to_sql(sql, binds), binds
         if name == :skip_logging
           _execute(sql, name)
         else
@@ -386,37 +463,28 @@ module ActiveRecord
       if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
       
         #attr_reader :visitor unless method_defined?(:visitor) # not in 3.0
-
+        
         # Converts an AREL AST to SQL.
         def to_sql(arel, binds = [])
-          # NOTE: can not handle `visitor.accept(arel.ast)` right thus
-          # convert AREL to a SQL string and simply substitute binds :
-          sql = arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
-          return sql if binds.blank?
-          sql.gsub('?') { quote(*binds.shift.reverse) }
+          # NOTE: can not handle `visitor.accept(arel.ast)` right
+          arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
         end
         
       elsif ActiveRecord::VERSION::MAJOR >= 3 # AR >= 3.1 or 4.0
-      
+        
         # Converts an AREL AST to SQL.
         def to_sql(arel, binds = [])
           if arel.respond_to?(:ast)
             visitor.accept(arel.ast) { quote(*binds.shift.reverse) }
-          else # for backwards compatibility :
-            sql = arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
-            return sql if binds.blank?
-            sql.gsub('?') { quote(*binds.shift.reverse) }
+          else
+            arel
           end
         end
       
       else # AR-2.3 no #to_sql method
         
-        # Substitutes SQL bind parameters.
-        def to_sql(sql, binds = [])
-          sql = sql.send(:to_sql) if sql.respond_to?(:to_sql)
-          return sql if binds.blank?
-          copy = binds.dup
-          sql.gsub('?') { quote(*copy.shift.reverse) }
+        def to_sql(sql, binds = nil)
+          sql
         end
         
       end
@@ -467,18 +535,28 @@ module ActiveRecord
     
       private
       
-      # #deprecated no longer used
-      def substitute_binds(sql, binds = [])
-        sql = extract_sql(sql)
-        if binds.empty?
-          sql
-        else
-          copy = binds.dup
-          sql.gsub('?') { quote(*copy.shift.reverse) }
-        end
+      def prepared_statements?
+        self.class.prepared_statements?(config)
+      end
+    
+      def self.prepared_statements?(config)
+        config.key?(:prepared_statements) ?
+          type_cast_config_to_boolean(config.fetch(:prepared_statements)) :
+            false # NOTE: off by default for now
+      end
+
+      def suble_binds(sql, binds)
+        return sql if binds.nil? || binds.empty?
+        copy = binds.dup
+        sql.gsub('?') { quote(*copy.shift.reverse) }
+      end
+      
+      # @deprecated replaced with {#suble_binds}
+      def substitute_binds(sql, binds)
+        suble_binds(extract_sql(sql), binds)
       end
 
-      # #deprecated no longer used
+      # @deprecated no longer used
       def extract_sql(obj)
         obj.respond_to?(:to_sql) ? obj.send(:to_sql) : obj
       end