activerecord-oracle_enhanced-adapter 1.5.5 → 1.5.6

data/lib/active_record/connection_adapters/oracle_enhanced_database_statements.rb

@@ -0,0 +1,262 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedDatabaseStatements
+      # DATABASE STATEMENTS ======================================
+      #
+      # see: abstract/database_statements.rb
+
+      # Executes a SQL statement
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.exec(sql) }
+      end
+
+      def substitute_at(column, index)
+        Arel::Nodes::BindParam.new (":a#{index + 1}")
+      end
+
+      def clear_cache!
+        @statements.clear
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        type_casted_binds = binds.map { |col, val|
+          [col, type_cast(val, col)]
+        }
+        log(sql, name, type_casted_binds) do
+          cursor = nil
+          cached = false
+          if without_prepared_statement?(binds)
+            cursor = @connection.prepare(sql)
+          else
+            unless @statements.key? sql
+              @statements[sql] = @connection.prepare(sql)
+            end
+
+            cursor = @statements[sql]
+
+            binds.each_with_index do |bind, i|
+              col, val = bind
+              cursor.bind_param(i + 1, type_cast(val, col), col)
+            end
+
+            cached = true
+          end
+
+          cursor.exec
+
+          if name == 'EXPLAIN' and sql =~ /^EXPLAIN/
+            res = true
+          else
+            columns = cursor.get_col_names.map do |col_name|
+              @connection.oracle_downcase(col_name)
+            end
+            rows = []
+            fetch_options = {:get_lob_value => (name != 'Writable Large Object')}
+            while row = cursor.fetch(fetch_options)
+              rows << row
+            end
+            res = ActiveRecord::Result.new(columns, rows)
+          end
+
+          cursor.close unless cached
+          res
+        end
+      end
+
+      def supports_statement_cache?
+        true
+      end
+
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
+        return if sql =~ /FROM all_/
+        if ORACLE_ENHANCED_CONNECTION == :jdbc
+          exec_query(sql, 'EXPLAIN', binds)
+        else
+          exec_query(sql, 'EXPLAIN')
+        end
+        select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
+      end
+
+      # Returns an array of arrays containing the field values.
+      # Order is the same as that returned by #columns.
+      def select_rows(sql, name = nil, binds = [])
+        exec_query(sql, name, binds).rows
+      end
+
+      # Executes an INSERT statement and returns the new record's ID
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        # if primary key value is already prefetched from sequence
+        # or if there is no primary key
+        if id_value || pk.nil?
+          execute(sql, name)
+          return id_value
+        end
+
+        sql_with_returning = sql + @connection.returning_clause(quote_column_name(pk))
+        log(sql, name) do
+          @connection.exec_with_returning(sql_with_returning)
+        end
+      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? || (defined?(CompositePrimaryKeys) && pk.kind_of?(CompositePrimaryKeys::CompositeKeys))
+          sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
+          returning_id_col = OracleEnhancedColumn.new("returning_id", nil, "number", true, "dual", :integer, true, true)
+          (binds = binds.dup) << [returning_id_col, nil]
+        end
+        [sql, binds]
+      end
+
+      # New method in ActiveRecord 3.1
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+        type_casted_binds = binds.map { |col, val|
+          [col, type_cast(val, col)]
+        }
+        log(sql, name, type_casted_binds) do
+          returning_id_col = returning_id_index = nil
+          if without_prepared_statement?(binds)
+            cursor = @connection.prepare(sql)
+          else
+            unless @statements.key? (sql)
+              @statements[sql] = @connection.prepare(sql)
+            end
+
+            cursor = @statements[sql]
+
+            binds.each_with_index do |bind, i|
+              col, val = bind
+              if col.returning_id?
+                returning_id_col = [col]
+                returning_id_index = i + 1
+                cursor.bind_returning_param(returning_id_index, Integer)
+              else
+                cursor.bind_param(i + 1, type_cast(val, col), col)
+              end
+            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(returning_id_col || [], rows)
+        end
+      end
+
+      # New method in ActiveRecord 3.1
+      def exec_update(sql, name, binds)
+        log(sql, name, binds) do
+          cached = false
+          if without_prepared_statement?(binds)
+            cursor = @connection.prepare(sql)
+          else
+            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)
+            end
+            cached = true
+          end
+
+          res = cursor.exec_update
+          cursor.close unless cached
+          res
+        end
+      end
+
+      alias :exec_delete :exec_update
+
+      def begin_db_transaction #:nodoc:
+        @connection.autocommit = false
+      end
+
+      def transaction_isolation_levels
+        # Oracle database supports `READ COMMITTED` and `SERIALIZABLE`
+        # No read uncommitted nor repeatable read supppoted
+        # http://docs.oracle.com/cd/E11882_01/server.112/e26088/statements_10005.htm#SQLRF55422
+        {
+          read_committed:   "READ COMMITTED",
+          serializable:     "SERIALIZABLE"
+        }
+      end
+
+      def begin_isolated_db_transaction(isolation)
+        begin_db_transaction
+        execute "SET TRANSACTION ISOLATION LEVEL  #{transaction_isolation_levels.fetch(isolation)}"
+      end
+
+      def commit_db_transaction #:nodoc:
+        @connection.commit
+      ensure
+        @connection.autocommit = true
+      end
+
+      def rollback_db_transaction #:nodoc:
+        @connection.rollback
+      ensure
+        @connection.autocommit = true
+      end
+
+      def create_savepoint(name = current_savepoint_name) #:nodoc:
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint(name = current_savepoint_name) #:nodoc:
+        execute("ROLLBACK TO #{current_savepoint_name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name) #:nodoc:
+        # there is no RELEASE SAVEPOINT statement in Oracle
+      end
+
+      # Returns default sequence name for table.
+      # Will take all or first 26 characters of table name and append _seq suffix
+      def default_sequence_name(table_name, primary_key = nil)
+        table_name.to_s.gsub /(^|\.)([\w$-]{1,#{sequence_name_length-4}})([\w$-]*)$/, '\1\2_seq'
+      end
+
+      # Inserts the given fixture into the table. Overridden to properly handle lobs.
+      def insert_fixture(fixture, table_name) #:nodoc:
+        super
+
+        if ActiveRecord::Base.pluralize_table_names
+          klass = table_name.to_s.singularize.camelize
+        else
+          klass = table_name.to_s.camelize
+        end
+
+        klass = klass.constantize rescue nil
+        if klass.respond_to?(:ancestors) && klass.ancestors.include?(ActiveRecord::Base)
+          write_lobs(table_name, klass, fixture, klass.lob_columns)
+        end
+      end
+
+      private
+
+      def select(sql, name = nil, binds = [])
+        exec_query(sql, name, binds)
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedDatabaseStatements
+end

data/lib/active_record/connection_adapters/oracle_enhanced_database_tasks.rb

@@ -1,3 +1,5 @@
+require 'active_record/base'
+
 module ActiveRecord
   module ConnectionAdapters
     class OracleEnhancedAdapter
@@ -9,8 +11,10 @@ module ActiveRecord
         end
 
         def create
-          print "Please provide the SYSTEM password for your Oracle installation\n>"
-          system_password = $stdin.gets.strip
+          system_password = ENV.fetch('ORACLE_SYSTEM_PASSWORD') {
+            print "Please provide the SYSTEM password for your Oracle installation (set ORACLE_SYSTEM_PASSWORD to avoid this prompt)\n>"
+            $stdin.gets.strip
+          }
           establish_connection(@config.merge('username' => 'SYSTEM', 'password' => system_password))
           begin
             connection.execute "CREATE USER #{@config['username']} IDENTIFIED BY #{@config['password']}"
@@ -24,6 +28,7 @@ module ActiveRecord
           connection.execute "GRANT unlimited tablespace TO #{@config['username']}"
           connection.execute "GRANT create session TO #{@config['username']}"
           connection.execute "GRANT create table TO #{@config['username']}"
+          connection.execute "GRANT create view TO #{@config['username']}"
           connection.execute "GRANT create sequence TO #{@config['username']}"
         end
 
@@ -40,9 +45,6 @@ module ActiveRecord
         def structure_dump(filename)
           establish_connection(@config)
           File.open(filename, 'w:utf-8') { |f| f << connection.structure_dump }
-          if connection.supports_migrations?
-            File.open(filename, 'a') { |f| f << connection.dump_schema_information }
-          end
           if @config['structure_dump'] == 'db_stored_code'
              File.open(filename, 'a') { |f| f << connection.structure_dump_db_stored_code }
           end
@@ -58,4 +60,3 @@ module ActiveRecord
 end
 
 ActiveRecord::Tasks::DatabaseTasks.register_task(/(oci|oracle)/, ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DatabaseTasks)
-

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -26,8 +26,6 @@ begin
       # check any compatible JDBC driver in the priority order
       ojdbc_jars.any? do |ojdbc_jar|
         if File.exists?(file_path = File.join(dir, ojdbc_jar))
-          puts "WARNING: JDK #{java_version} is not officially supported by #{ojdbc_jar}" if java_version >= '1.8'
-          puts "See http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-faq-090281.html#01_03 for supported versions"
           require file_path
           true
         end

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -2,9 +2,11 @@ require 'delegate'
 
 begin
   require "oci8"
-rescue LoadError
-  # OCI8 driver is unavailable.
-  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. Please install ruby-oci8 gem."
+rescue LoadError => e
+  # OCI8 driver is unavailable or failed to load a required library.
+  raise LoadError, "ERROR: '#{e.message}'. "\
+    "ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. "\
+    "You may need install ruby-oci8 gem."
 end
 
 # check ruby-oci8 version
@@ -275,7 +277,7 @@ module ActiveRecord
           value.hour == 0 && value.min == 0 && value.sec == 0
         end
       end
-      
+
       def create_time_with_default_timezone(value)
         year, month, day, hour, min, sec, usec = case value
         when Time
@@ -295,7 +297,7 @@ module ActiveRecord
       end
 
     end
-    
+
     # The OracleEnhancedOCIFactory factors out the code necessary to connect and
     # configure an Oracle/OCI connection.
     class OracleEnhancedOCIFactory #:nodoc:
@@ -342,8 +344,8 @@ module ActiveRecord
         conn
       end
     end
-    
-    
+
+
   end
 end
 

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements.rb

@@ -117,6 +117,8 @@ module ActiveRecord
         super(name)
         seq_name = options[:sequence_name] || default_sequence_name(name)
         execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
+      rescue ActiveRecord::StatementInvalid => e
+        raise e unless options[:if_exists]
       ensure
         clear_table_columns_cache(name)
         self.all_schema_indexes = nil

data/lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb

@@ -45,7 +45,7 @@ module ActiveRecord #:nodoc:
           col << "(#{column['data_precision'].to_i}"
           col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
           col << ')'
-        elsif column['data_type'].include?('CHAR')
+        elsif column['data_type'].include?('CHAR') || column['data_type'] == 'RAW'
           length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
           col <<  "(#{length})"
         end
@@ -61,7 +61,7 @@ module ActiveRecord #:nodoc:
           col << "(#{column['data_precision'].to_i}"
           col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
           col << ')'
-        elsif column['data_type'].include?('CHAR')
+        elsif column['data_type'].include?('CHAR') || column['data_type'] == 'RAW'
           length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
           col <<  "(#{length})"
         end
@@ -172,8 +172,8 @@ module ActiveRecord #:nodoc:
         select_all("SELECT owner, synonym_name, table_name, table_owner
                       FROM all_synonyms
                      WHERE owner = SYS_CONTEXT('userenv', 'session_user') ").each do |synonym|
-          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
-          structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
+          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}
+			FOR #{synonym['table_owner']}.#{synonym['table_name']}"
         end
 
         join_with_statement_token(structure)
@@ -240,7 +240,6 @@ module ActiveRecord #:nodoc:
 
       def execute_structure_dump(string)
         string.split(STATEMENT_TOKEN).each do |ddl|
-          ddl.chop! if ddl[-1,1] == ';'
           execute(ddl) unless ddl.blank?
         end
       end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -461,6 +461,9 @@ describe "OracleEnhancedAdapter" do
       @conn.tables.should include("CamelCase")
     end
 
+    it "properly quotes database links" do
+      @conn.quote_table_name('asdf@some.link').should eq('"ASDF"@"SOME.LINK"')
+    end
   end
 
   describe "access table over database link" do

data/spec/active_record/connection_adapters/oracle_enhanced_context_index_spec.rb

@@ -174,8 +174,6 @@ describe "OracleEnhancedAdapter context index" do
   describe "on multiple tables" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
-      @oracle12c = !! @conn.select_value(
-                      "select * from product_component_version where product like 'Oracle%' and to_number(substr(version,1,2)) = 12")
       create_tables
       class ::Post < ActiveRecord::Base
         has_many :comments, dependent: :destroy
@@ -200,7 +198,6 @@ describe "OracleEnhancedAdapter context index" do
     end
 
     it "should create multiple table index with specified main index column" do
-      pending "It always fails when Oracle 12c 12.1.0 used." if @oracle12c
       @conn.add_context_index :posts,
         [:title, :body,
         # specify aliases always with AS keyword
@@ -218,7 +215,6 @@ describe "OracleEnhancedAdapter context index" do
     end
 
     it "should create multiple table index with specified main index column (when subquery has newlines)" do
-      pending "It always fails when Oracle 12c 12.1.0 used." if @oracle12c
       @conn.add_context_index :posts,
         [:title, :body,
          # specify aliases always with AS keyword
@@ -381,9 +377,6 @@ describe "OracleEnhancedAdapter context index" do
 
     describe "with table prefix and suffix" do
       before(:all) do
-        @conn = ActiveRecord::Base.connection
-        @oracle12c = !! @conn.select_value(
-                        "select * from product_component_version where product like 'Oracle%' and to_number(substr(version,1,2)) = 12")
         ActiveRecord::Base.table_name_prefix = 'xxx_'
         ActiveRecord::Base.table_name_suffix = '_xxx'
         create_tables
@@ -408,7 +401,6 @@ describe "OracleEnhancedAdapter context index" do
       end
 
       it "should dump definition of multiple table index with options" do
-        pending "It always fails when Oracle 12c 12.1.0 used." if @oracle12c
         options = {
           name: 'xxx_post_and_comments_i',
           index_column: :all_text, index_column_trigger_on: :updated_at,