activerecord-oracle_enhanced-adapter 1.3.2 → 1.4.0

data/Rakefile

@@ -21,7 +21,7 @@ EOS
   gem.email = "raimonds.simanovskis@gmail.com"
   gem.homepage = "http://github.com/rsim/oracle-enhanced"
   gem.authors = ["Raimonds Simanovskis"]
-  gem.extra_rdoc_files = ['README.rdoc']
+  gem.extra_rdoc_files = ['README.md']
 end
 Jeweler::RubygemsDotOrgTasks.new
 

data/VERSION

@@ -1 +1 @@
-1.3.2
+1.4.0

data/activerecord-oracle_enhanced-adapter.gemspec

@@ -5,25 +5,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.3.2"
+  s.version = "1.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Raimonds Simanovskis"]
-  s.date = %q{2011-01-05}
+  s.date = %q{2011-08-09}
   s.description = %q{Oracle "enhanced" ActiveRecord adapter contains useful additional methods for working with new and legacy Oracle databases.
 This adapter is superset of original ActiveRecord Oracle adapter.
 }
   s.email = %q{raimonds.simanovskis@gmail.com}
   s.extra_rdoc_files = [
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".rspec",
     "Gemfile",
     "History.txt",
     "License.txt",
-    "README.rdoc",
-    "RUNNING_TESTS.rdoc",
+    "README.md",
+    "RUNNING_TESTS.md",
     "Rakefile",
     "VERSION",
     "activerecord-oracle_enhanced-adapter.gemspec",
@@ -66,7 +66,7 @@ This adapter is superset of original ActiveRecord Oracle adapter.
   ]
   s.homepage = %q{http://github.com/rsim/oracle-enhanced}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.1}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{Oracle enhanced adapter for ActiveRecord}
   s.test_files = [
     "spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb",
@@ -97,7 +97,6 @@ This adapter is superset of original ActiveRecord Oracle adapter.
       s.add_development_dependency(%q<actionpack>, [">= 0"])
       s.add_development_dependency(%q<railties>, [">= 0"])
       s.add_development_dependency(%q<arel>, [">= 0"])
-      s.add_development_dependency(%q<rack>, [">= 0"])
       s.add_development_dependency(%q<ruby-plsql>, [">= 0.4.4"])
       s.add_development_dependency(%q<ruby-oci8>, ["~> 2.0.4"])
     else
@@ -109,7 +108,6 @@ This adapter is superset of original ActiveRecord Oracle adapter.
       s.add_dependency(%q<actionpack>, [">= 0"])
       s.add_dependency(%q<railties>, [">= 0"])
       s.add_dependency(%q<arel>, [">= 0"])
-      s.add_dependency(%q<rack>, [">= 0"])
       s.add_dependency(%q<ruby-plsql>, [">= 0.4.4"])
       s.add_dependency(%q<ruby-oci8>, ["~> 2.0.4"])
     end
@@ -122,7 +120,6 @@ This adapter is superset of original ActiveRecord Oracle adapter.
     s.add_dependency(%q<actionpack>, [">= 0"])
     s.add_dependency(%q<railties>, [">= 0"])
     s.add_dependency(%q<arel>, [">= 0"])
-    s.add_dependency(%q<rack>, [">= 0"])
     s.add_dependency(%q<ruby-plsql>, [">= 0.4.4"])
     s.add_dependency(%q<ruby-oci8>, ["~> 2.0.4"])
   end

data/lib/active_record/connection_adapters/oracle_enhanced.rake

@@ -15,6 +15,39 @@ def redefine_task(*args, &block)
   end
 end
 
+# Creates database user with db:create
+def create_database_with_oracle_enhanced(config)
+  if config['adapter'] == 'oracle_enhanced'
+    print "Please provide the SYSTEM password for your oracle installation\n>"
+    system_password = $stdin.gets.strip
+    ActiveRecord::Base.establish_connection(config.merge('username' => 'SYSTEM', 'password' => system_password))
+    ActiveRecord::Base.connection.execute "DROP USER #{config['username']} CASCADE" rescue nil
+    ActiveRecord::Base.connection.execute "CREATE USER #{config['username']} IDENTIFIED BY #{config['password']}"
+    ActiveRecord::Base.connection.execute "GRANT unlimited tablespace TO #{config['username']}"
+    ActiveRecord::Base.connection.execute "GRANT create session TO #{config['username']}"
+    ActiveRecord::Base.connection.execute "GRANT create table TO #{config['username']}"
+    ActiveRecord::Base.connection.execute "GRANT create sequence TO #{config['username']}"
+  else
+    create_database_without_oracle_enhanced(config)
+  end
+end
+alias :create_database_without_oracle_enhanced :create_database
+alias :create_database :create_database_with_oracle_enhanced
+
+# Drops database user with db:drop
+def drop_database_with_oracle_enhanced(config)
+  if config['adapter'] == 'oracle_enhanced'
+    print "Please provide the SYSTEM password for your oracle installation\n>"
+    system_password = $stdin.gets.strip
+    ActiveRecord::Base.establish_connection(config.merge('username' => 'SYSTEM', 'password' => system_password))
+    ActiveRecord::Base.connection.execute "DROP USER #{config['username']} CASCADE"
+  else
+    drop_database_without_oracle_enhanced(config)
+  end
+end
+alias :drop_database_without_oracle_enhanced :drop_database
+alias :drop_database :drop_database_with_oracle_enhanced
+
 namespace :db do
 
   namespace :structure do
@@ -53,6 +86,7 @@ namespace :db do
       if abcs['test']['adapter'] == 'oracle_enhanced'
         ActiveRecord::Base.establish_connection(:test)
         ActiveRecord::Base.connection.execute_structure_dump(ActiveRecord::Base.connection.full_drop)
+        ActiveRecord::Base.connection.execute("PURGE RECYCLEBIN") rescue nil
       else
         Array(existing_actions).each{|action| action.call}
       end

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -131,6 +131,19 @@ module ActiveRecord
       # that Date columns are explicily defined with +set_date_columns+ method.
       cattr_accessor :emulate_dates
       self.emulate_dates = false
+      
+       ##
+        # :singleton-method:
+        # OracleEnhancedAdapter will use the default tablespace, but if you want specific types of
+        # objects to go into specific tablespaces, specify them like this in an initializer:
+        #
+        #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces =
+        #  {:clob => 'TS_LOB', :blob => 'TS_LOB', :index => 'TS_INDEX', :table => 'TS_DATA'}
+        # 
+        # Using the :tablespace option where available (e.g create_table) will take precedence
+        # over these settings.
+      cattr_accessor :default_tablespaces
+      self.default_tablespaces={}
 
       ##
       # :singleton-method:
@@ -229,6 +242,10 @@ module ActiveRecord
         @enable_dbms_output = false
       end
 
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::Oracle.new(pool)
+      end
+
       ADAPTER_NAME = 'OracleEnhanced'.freeze
       
       def adapter_name #:nodoc:
@@ -285,7 +302,8 @@ module ActiveRecord
         :time        => { :name => "DATE" },
         :date        => { :name => "DATE" },
         :binary      => { :name => "BLOB" },
-        :boolean     => { :name => "NUMBER", :limit => 1 }
+        :boolean     => { :name => "NUMBER", :limit => 1 },
+        :raw         => { :name => "RAW", :limit => 2000 }
       }
       # if emulate_booleans_from_strings then store booleans in VARCHAR2
       NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS = NATIVE_DATABASE_TYPES.dup.merge(
@@ -324,30 +342,42 @@ module ActiveRecord
       def in_clause_length
         1000
       end
+      alias ids_in_list_limit in_clause_length
 
       # QUOTING ==================================================
       #
       # see: abstract/quoting.rb
 
       def quote_column_name(name) #:nodoc:
-        # camelCase column names need to be quoted; not that anyone using Oracle
-        # would really do this, but handling this case means we pass the test...
         name = name.to_s
         @quoted_column_names[name] ||= begin
-          case name
-          # if only valid column characters in name
-          when /^[a-z][a-z_0-9\$#]*$/
+          # if only valid lowercase column characters in name
+          if name =~ /\A[a-z][a-z_0-9\$#]*\Z/
             "\"#{name.upcase}\""
-          when /^[a-z][a-z_0-9\$#\-]*$/i
-            "\"#{name}\""
-          # if other characters present then assume that it is expression
-          # which should not be quoted
           else
-            name
+            # remove double quotes which cannot be used inside quoted identifier
+            "\"#{name.gsub('"', '')}\""
           end
         end
       end
 
+      # This method is used in add_index to identify either column name (which is quoted)
+      # or function based index (in which case function expression is not quoted)
+      def quote_column_name_or_expression(name) #:nodoc:
+        name = name.to_s
+        case name
+        # if only valid lowercase column characters in name
+        when /^[a-z][a-z_0-9\$#]*$/
+          "\"#{name.upcase}\""
+        when /^[a-z][a-z_0-9\$#\-]*$/i
+          "\"#{name}\""
+        # if other characters present then assume that it is expression
+        # which should not be quoted
+        else
+          name
+        end
+      end
+
       # Names must be from 1 to 30 bytes long with these exceptions:
       # * Names of databases are limited to 8 bytes.
       # * Names of database links can be as long as 128 bytes.
@@ -395,6 +425,8 @@ module ActiveRecord
           # NLS_DATE_FORMAT independent DATE support
           when :date, :time, :datetime
             quote_date_with_to_date(value)
+          when :raw
+            quote_raw(value)
           when :string
             # NCHAR and NVARCHAR2 literals should be quoted with N'...'.
             # Read directly instance variable as otherwise migrations with table column default values are failing
@@ -429,12 +461,45 @@ module ActiveRecord
         "TO_DATE('#{value}','YYYY-MM-DD HH24:MI:SS')"
       end
 
+      # Encode a string or byte array as string of hex codes
+      def self.encode_raw(value)
+        # When given a string, convert to a byte array.
+        value = value.unpack('C*') if value.is_a?(String)
+        value.map { |x| "%02X" % x }.join
+      end
+
+      # quote encoded raw value
+      def quote_raw(value) #:nodoc:
+        "'#{self.class.encode_raw(value)}'"
+      end
+
       def quote_timestamp_with_to_timestamp(value) #:nodoc:
         # add up to 9 digits of fractional seconds to inserted time
         value = "#{quoted_date(value)}:#{("%.6f"%value.to_f).split('.')[1]}" if value.acts_like?(:time)
         "TO_TIMESTAMP('#{value}','YYYY-MM-DD HH24:MI:SS:FF6')"
       end
 
+      # Cast a +value+ to a type that the database understands.
+      def type_cast(value, column)
+        case value
+        when true, false
+          if emulate_booleans_from_strings || column && column.type == :string
+            self.class.boolean_to_string(value)
+          else
+            value ? 1 : 0
+          end
+        when Date, Time
+          if value.acts_like?(:time)
+            zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+            value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+          else
+            value
+          end
+        else
+          super
+        end
+      end
+
       # CONNECTION MANAGEMENT ====================================
       #
 
@@ -493,8 +558,8 @@ module ActiveRecord
         log(sql, name) { @connection.exec(sql) }
       end
 
-      def substitute_for(column, current_values)
-        Arel.sql(":a#{current_values.length + 1}")
+      def substitute_at(column, index)
+        Arel.sql(":a#{index + 1}")
       end
 
       def clear_cache!
@@ -505,7 +570,7 @@ module ActiveRecord
       end
 
       def exec_query(sql, name = 'SQL', binds = [])
-        log(sql, name) do
+        log(sql, name, binds) do
           cursor = nil
           cached = false
           if binds.empty?
@@ -517,10 +582,11 @@ module ActiveRecord
 
             cursor = @statements[sql]
 
-            binds = binds.map do |col, val|
-              col ? col.type_cast(val) : val
+            binds.each_with_index do |bind, i|
+              col, val = bind
+              cursor.bind_param(i + 1, type_cast(val, col), col && col.type)
             end
-            binds.each_with_index { |val, i| cursor.bind_param(i + 1, val) }
+
             cached = true
           end
 
@@ -570,6 +636,69 @@ module ActiveRecord
       end
       protected :insert_sql
 
+      # New method in ActiveRecord 3.1
+      # Will add RETURNING clause in case of trigger generated primary keys
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        unless id_value || pk.nil?
+          sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
+          (binds = binds.dup) << [:returning_id, nil]
+        end
+        [sql, binds]
+      end
+
+      EXEC_INSERT_RESULT_COLUMNS = %w(returning_id) #:nodoc:
+
+      # New method in ActiveRecord 3.1
+      def exec_insert(sql, name, binds)
+        log(sql, name, binds) do
+          returning_id_index = nil
+          cursor = if @statements.key?(sql)
+            @statements[sql]
+          else
+            @statements[sql] = @connection.prepare(sql)
+          end
+
+          binds.each_with_index do |bind, i|
+            col, val = bind
+            if col == :returning_id
+              returning_id_index = i + 1
+              cursor.bind_returning_param(returning_id_index, Integer)
+            else
+              cursor.bind_param(i + 1, type_cast(val, col), col && col.type)
+            end
+          end
+
+          cursor.exec_update
+
+          rows = []
+          if returning_id_index
+            returning_id = cursor.get_returning_param(returning_id_index, Integer)
+            rows << [returning_id]
+          end
+          ActiveRecord::Result.new(EXEC_INSERT_RESULT_COLUMNS, rows)
+        end
+      end
+
+      # New method in ActiveRecord 3.1
+      def exec_update(sql, name, binds)
+        log(sql, name, binds) do
+          cursor = if @statements.key?(sql)
+            @statements[sql]
+          else
+            @statements[sql] = @connection.prepare(sql)
+          end
+
+          binds.each_with_index do |bind, i|
+            col, val = bind
+            cursor.bind_param(i + 1, type_cast(val, col), col && col.type)
+          end
+
+          cursor.exec_update
+        end
+      end
+
+      alias :exec_delete :exec_update
+
       # use in set_sequence_name to avoid fetching primary key value from sequence
       AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze
 
@@ -617,11 +746,11 @@ module ActiveRecord
         limit = options[:limit]
         limit = limit.is_a?(String) && limit.blank? ? nil : limit && limit.to_i
         if limit && offset > 0
-          sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
+          sql.replace "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM (#{sql}) raw_sql_ WHERE ROWNUM <= #{offset+limit}) WHERE raw_rnum_ > #{offset}"
         elsif limit
-          sql.replace "select * from (#{sql}) where rownum <= #{limit}"
+          sql.replace "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
         elsif offset > 0
-          sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
+          sql.replace "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM (#{sql}) raw_sql_) WHERE raw_rnum_ > #{offset}"
         end
       end
 
@@ -630,7 +759,16 @@ module ActiveRecord
       # Returns true for Oracle adapter (since Oracle requires primary key
       # values to be pre-fetched before insert). See also #next_sequence_value.
       def prefetch_primary_key?(table_name = nil)
-        ! @@do_not_prefetch_primary_key[table_name.to_s]
+        return true if table_name.nil?
+        table_name = table_name.to_s
+        do_not_prefetch = @@do_not_prefetch_primary_key[table_name]
+        if do_not_prefetch.nil?
+          owner, desc_table_name, db_link = @connection.describe(table_name)
+          @@do_not_prefetch_primary_key[table_name] = do_not_prefetch =
+            !has_primary_key?(table_name, owner, desc_table_name, db_link) ||
+            has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
+        end
+        !do_not_prefetch
       end
 
       # used just in tests to clear prefetch primary key flag for all tables
@@ -650,7 +788,13 @@ module ActiveRecord
       def insert_fixture(fixture, table_name) #:nodoc:
         super
 
-        klass = fixture.class_name.constantize rescue nil
+        if ActiveRecord::Base.pluralize_table_names
+          klass = table_name.singularize.camelize
+        else
+          klass = table_name.camelize
+        end
+
+        klass = klass.constantize rescue nil
         if klass.respond_to?(:ancestors) && klass.ancestors.include?(ActiveRecord::Base)
           write_lobs(table_name, klass, fixture)
         end
@@ -684,22 +828,22 @@ module ActiveRecord
 
       # Current database name
       def current_database
-        select_value("select sys_context('userenv','db_name') from dual")
+        select_value("SELECT SYS_CONTEXT('userenv', 'db_name') FROM dual")
       end
 
       # Current database session user
       def current_user
-        select_value("select sys_context('userenv','session_user') from dual")
+        select_value("SELECT SYS_CONTEXT('userenv', 'session_user') FROM dual")
       end
 
       # Default tablespace name of current user
       def default_tablespace
-        select_value("select lower(default_tablespace) from user_users where username = sys_context('userenv','session_user')")
+        select_value("SELECT LOWER(default_tablespace) FROM user_users WHERE username = SYS_CONTEXT('userenv', 'session_user')")
       end
 
       def tables(name = nil) #:nodoc:
         select_values(
-        "select decode(table_name,upper(table_name),lower(table_name),table_name) from all_tables where owner = sys_context('userenv','session_user') and secondary='N'",
+        "SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name) FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'",
         name)
       end
 
@@ -712,7 +856,7 @@ module ActiveRecord
       end
 
       def materialized_views #:nodoc:
-        select_values("select lower(mview_name) from all_mviews where owner = sys_context('userenv','session_user')")
+        select_values("SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'session_user')")
       end
 
       cattr_accessor :all_schema_indexes #:nodoc:
@@ -723,7 +867,7 @@ module ActiveRecord
         (owner, table_name, db_link) = @connection.describe(table_name)
         unless all_schema_indexes
           default_tablespace_name = default_tablespace
-          result = select_all(<<-SQL)
+          result = select_all(<<-SQL.strip.gsub(/\s+/, ' '))
             SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
               i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
               LOWER(i.tablespace_name) AS tablespace_name,
@@ -749,13 +893,16 @@ module ActiveRecord
               statement_parameters = nil
               if row['index_type'] == 'DOMAIN' && row['ityp_owner'] == 'CTXSYS' && row['ityp_name'] == 'CONTEXT'
                 procedure_name = default_datastore_procedure(row['index_name'])
-                statement_parameters = select_value(<<-SQL)
-                  SELECT SUBSTR(text,LENGTH('-- add_context_index_parameters ')+1)
+                source = select_values(<<-SQL).join
+                  SELECT text
                   FROM all_source#{db_link}
                   WHERE owner = '#{owner}'
                     AND name = '#{procedure_name.upcase}'
-                    AND text LIKE '-- add_context_index_parameters %'
+                  ORDER BY line
                 SQL
+                if source =~ /-- add_context_index_parameters (.+)\n/
+                  statement_parameters = $1
+                end
               end
               all_schema_indexes << OracleEnhancedIndexDefinition.new(row['table_name'], row['index_name'],
                 row['uniqueness'] == "UNIQUE", row['index_type'] == 'DOMAIN' ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
@@ -855,22 +1002,23 @@ module ActiveRecord
 
         (owner, desc_table_name, db_link) = @connection.describe(table_name)
 
-        @@do_not_prefetch_primary_key[table_name] =
-          !has_primary_key?(table_name, owner, desc_table_name, db_link) ||
-          has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
+        # reset do_not_prefetch_primary_key cache for this table
+        @@do_not_prefetch_primary_key[table_name] = nil
 
-        table_cols = <<-SQL
-          select column_name as name, data_type as sql_type, data_default, nullable,
-                 decode(data_type, 'NUMBER', data_precision,
+        table_cols = <<-SQL.strip.gsub(/\s+/, ' ')
+          SELECT column_name AS name, data_type AS sql_type, data_default, nullable, virtual_column, hidden_column,
+                 DECODE(data_type, 'NUMBER', data_precision,
                                    'FLOAT', data_precision,
-                                   'VARCHAR2', decode(char_used, 'C', char_length, data_length),
-                                   'CHAR', decode(char_used, 'C', char_length, data_length),
-                                    null) as limit,
-                 decode(data_type, 'NUMBER', data_scale, null) as scale
-            from all_tab_columns#{db_link}
-           where owner      = '#{owner}'
-             and table_name = '#{desc_table_name}'
-           order by column_id
+                                   'VARCHAR2', DECODE(char_used, 'C', char_length, data_length),
+                                   'RAW', DECODE(char_used, 'C', char_length, data_length),
+                                   'CHAR', DECODE(char_used, 'C', char_length, data_length),
+                                    NULL) AS limit,
+                 DECODE(data_type, 'NUMBER', data_scale, NULL) AS scale
+            FROM all_tab_cols#{db_link}
+           WHERE owner      = '#{owner}'
+             AND table_name = '#{desc_table_name}'
+             AND hidden_column = 'NO'
+           ORDER BY column_id
         SQL
 
         # added deletion of ignored columns
@@ -899,7 +1047,7 @@ module ActiveRecord
                            # pass table name for table specific column definitions
                            table_name,
                            # pass column type if specified in class definition
-                           get_type_for_column(table_name, oracle_downcase(row['name'])))
+                           get_type_for_column(table_name, oracle_downcase(row['name'])), row['virtual_column']=='YES')
         end
       end
 
@@ -940,14 +1088,14 @@ module ActiveRecord
         (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
 
         # changed back from user_constraints to all_constraints for consistency
-        pks = select_values(<<-SQL, 'Primary Key')
-          select cc.column_name
-            from all_constraints#{db_link} c, all_cons_columns#{db_link} cc
-           where c.owner = '#{owner}'
-             and c.table_name = '#{desc_table_name}'
-             and c.constraint_type = 'P'
-             and cc.owner = c.owner
-             and cc.constraint_name = c.constraint_name
+        pks = select_values(<<-SQL.strip.gsub(/\s+/, ' '), 'Primary Key')
+          SELECT cc.column_name
+            FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
+           WHERE c.owner = '#{owner}'
+             AND c.table_name = '#{desc_table_name}'
+             AND c.constraint_type = 'P'
+             AND cc.owner = c.owner
+             AND cc.constraint_name = c.constraint_name
         SQL
 
         # only support single column keys
@@ -994,7 +1142,7 @@ module ActiveRecord
       end
 
       def temporary_table?(table_name) #:nodoc:
-        select_value("select temporary from user_tables where table_name = '#{table_name.upcase}'") == 'Y'
+        select_value("SELECT temporary FROM user_tables WHERE table_name = '#{table_name.upcase}'") == 'Y'
       end
 
       # ORDER BY clause for the passed order option.
@@ -1073,8 +1221,12 @@ module ActiveRecord
       end
 
       protected
-      def log(sql, name) #:nodoc:
-        super sql, name
+      def log(sql, name, binds = nil) #:nodoc:
+        if binds
+          super sql, name, binds
+        else
+          super sql, name
+        end
       ensure
         log_dbms_output if dbms_output_enabled?
       end