pmacs-activerecord-oracle_enhanced-adapter 1.5.6.1 → 1.6.2.1

data/lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -0,0 +1,257 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module DatabaseStatements
+        # DATABASE STATEMENTS ======================================
+        #
+        # see: abstract/database_statements.rb
+
+        # Executes a SQL statement
+        def execute(sql, name = nil)
+          log(sql, name) { @connection.exec(sql) }
+        end
+
+        def clear_cache!
+          @statements.clear
+          reload_type_map
+        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 = new_column("returning_id", nil, Type::Value.new, "number", true, "dual", 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 exec_rollback_db_transaction #:nodoc:
+          @connection.rollback
+        ensure
+          @connection.autocommit = true
+        end
+
+        def create_savepoint(name = current_savepoint_name) #:nodoc:
+          execute("SAVEPOINT #{name}")
+        end
+
+        def exec_rollback_to_savepoint(name = current_savepoint_name) #:nodoc:
+          execute("ROLLBACK TO #{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
+end

data/lib/active_record/connection_adapters/oracle_enhanced/dirty.rb

@@ -0,0 +1,40 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedDirty #:nodoc:
+
+      module InstanceMethods #:nodoc:
+        private
+
+        def _field_changed?(attr, old_value)
+          new_value = read_attribute(attr)
+          raw_value = read_attribute_before_type_cast(attr)
+
+          if self.class.columns_hash.include?(attr.to_s)
+            column = column_for_attribute(attr)
+
+            # Oracle stores empty string '' as NULL
+            # therefore need to convert empty string value to nil if old value is nil
+            if column.type == :string && column.null && old_value.nil?
+              new_value = nil if new_value == ''
+            end
+            column.changed?(old_value, new_value, raw_value)
+          else
+            new_value != old_value
+          end
+        end
+
+        def non_zero?(value)
+          value !~ /\A0+(\.0+)?\z/
+        end 
+        
+      end
+
+    end
+  end
+end
+
+if ActiveRecord::Base.method_defined?(:changed?)
+  ActiveRecord::Base.class_eval do
+    include ActiveRecord::ConnectionAdapters::OracleEnhancedDirty::InstanceMethods
+  end
+end

data/lib/active_record/connection_adapters/{oracle_enhanced_procedures.rb → oracle_enhanced/procedures.rb}

@@ -150,9 +150,7 @@ module ActiveRecord #:nodoc:
           end
           # update just dirty attributes
           if partial_writes?
-            # Serialized attributes should always be written in case they've been
-            # changed in place.
-            update_using_custom_method(changed | (attributes.keys & self.class.serialized_attributes.keys))
+            update_using_custom_method(changed | attributes.keys)
           else
             update_using_custom_method(attribute_names)
           end

data/lib/active_record/connection_adapters/{oracle_enhanced_schema_creation.rb → oracle_enhanced/schema_creation.rb}

@@ -1,53 +1,47 @@
 module ActiveRecord
   module ConnectionAdapters
-    class OracleEnhancedAdapter < AbstractAdapter
+    module OracleEnhanced
       class SchemaCreation < AbstractAdapter::SchemaCreation
         private
 
         def visit_ColumnDefinition(o)
-          if o.type.to_sym == :virtual
-            sql_type = type_to_sql(o.default[:type], o.limit, o.precision, o.scale) if o.default[:type]
-            "#{quote_column_name(o.name)} #{sql_type} AS (#{o.default[:as]})"
-          else
-            super
+          case
+            when o.type.to_sym == :virtual
+              sql_type = type_to_sql(o.default[:type], o.limit, o.precision, o.scale) if o.default[:type]
+              return "#{quote_column_name(o.name)} #{sql_type} AS (#{o.default[:as]})"
+            when [:blob, :clob].include?(sql_type = type_to_sql(o.type.to_sym,  o.limit, o.precision, o.scale).downcase.to_sym)
+              if (tablespace = default_tablespace_for(sql_type))
+                @lob_tablespaces ||= {}
+                @lob_tablespaces[o.name] = tablespace
+              end
           end
+          super
         end
 
         def visit_TableDefinition(o)
-          tablespace = tablespace_for(:table, o.options[:tablespace])
           create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE "
           create_sql << "#{quote_table_name(o.name)} ("
           create_sql << o.columns.map { |c| accept c }.join(', ')
           create_sql << ")"
+
           unless o.temporary
+            @lob_tablespaces.each do |lob_column, tablespace|
+              create_sql << " LOB (#{quote_column_name(lob_column)}) STORE AS (TABLESPACE #{tablespace}) \n"
+            end if defined?(@lob_tablespaces)
             create_sql << " ORGANIZATION #{o.options[:organization]}" if o.options[:organization]
-            create_sql << "#{tablespace}"
+            if (tablespace = o.options[:tablespace] || default_tablespace_for(:table))
+              create_sql << " TABLESPACE #{tablespace}"
+            end
           end
           create_sql << " #{o.options[:options]}"
           create_sql
         end
 
-        def tablespace_for(obj_type, tablespace_option, table_name=nil, column_name=nil)
-          tablespace_sql = ''
-          if tablespace = (tablespace_option || default_tablespace_for(obj_type))
-            tablespace_sql << if [:blob, :clob].include?(obj_type.to_sym)
-              " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
-            else
-              " TABLESPACE #{tablespace}"
-            end
-          end
-          tablespace_sql
-        end
-
         def default_tablespace_for(type)
           (ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[type] || 
            ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[native_database_types[type][:name]]) rescue nil
         end
 
-        def foreign_key_definition(to_table, options = {})
-          @conn.foreign_key_definition(to_table, options)
-        end
-
         def add_column_options!(sql, options)
           type = options[:type] || ((column = options[:column]) && column.type)
           type = type && type.to_sym
@@ -56,8 +50,7 @@ module ActiveRecord
             if type == :text
               sql << " DEFAULT #{@conn.quote(options[:default])}"
             else
-              # from abstract adapter
-              sql << " DEFAULT #{@conn.quote(options[:default], options[:column])}"
+              sql << " DEFAULT #{quote_value(options[:default], options[:column])}"
             end
           end
           # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
@@ -72,18 +65,24 @@ module ActiveRecord
           end
         end
 
-        # This method does not exist in SchemaCreation at Rails 4.0
-        # It can be removed only when Oracle enhanced adapter supports Rails 4.1 and higher
-        def options_include_default?(options)
-          options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+        def action_sql(action, dependency)
+          if action == 'UPDATE'
+            raise ArgumentError, <<-MSG.strip_heredoc
+              '#{action}' is not supported by Oracle
+            MSG
+          end
+          case dependency
+          when :nullify then "ON #{action} SET NULL"
+          when :cascade  then "ON #{action} CASCADE"
+          else
+            raise ArgumentError, <<-MSG.strip_heredoc
+              '#{dependency}' is not supported for #{action}
+              Supported values are: :nullify, :cascade
+            MSG
+          end
         end
 
       end
-      
-      def schema_creation
-          SchemaCreation.new self
-      end
-
     end
   end
 end

data/lib/active_record/connection_adapters/oracle_enhanced/schema_definitions.rb

@@ -0,0 +1,95 @@
+module ActiveRecord
+  module ConnectionAdapters
+    #TODO: Overriding `aliased_types` cause another database adapter behavior changes
+    #It should be addressed by supporting `create_table_definition`
+    class TableDefinition
+      private
+      def aliased_types(name, fallback)
+        fallback
+      end
+    end
+
+    module OracleEnhanced
+
+      class ForeignKeyDefinition < ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+        def name
+          if options[:name].length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+            ActiveSupport::Deprecation.warn "Foreign key name #{options[:name]} is too long. It will not get shorten in later version of Oracle enhanced adapter"
+            'c'+Digest::SHA1.hexdigest(options[:name])[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
+          else
+            options[:name]
+          end
+        end
+      end
+
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_accessor :table, :name, :unique, :type, :parameters, :statement_parameters, :tablespace, :columns
+ 
+        def initialize(table, name, unique, type, parameters, statement_parameters, tablespace, columns)
+          @table = table
+          @name = name
+          @unique = unique
+          @type = type
+          @parameters = parameters
+          @statement_parameters = statement_parameters
+          @tablespace = tablespace
+          @columns = columns
+          super(table, name, unique, columns, nil, nil, nil, nil)
+        end
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
+        def raw(name, options={})
+          column(name, :raw, options)
+        end
+
+        def virtual(* args)
+          options = args.extract_options!
+          column_names = args
+          column_names.each { |name| column(name, :virtual, options) }
+        end
+
+        def column(name, type, options = {})
+          if type == :virtual
+            default = {:type => options[:type]}
+            if options[:as]
+              default[:as] = options[:as]
+            elsif options[:default]
+              warn "[DEPRECATION] virtual column `:default` option is deprecated.  Please use `:as` instead."
+              default[:as] = options[:default]
+            else
+              raise "No virtual column definition found."
+            end
+            options[:default] = default
+          end
+          super(name, type, options)
+        end
+
+      end
+
+      class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
+        def add_foreign_key(to_table, options)
+          @foreign_key_adds << OracleEnhanced::ForeignKeyDefinition.new(name, to_table, options)
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        def foreign_key(to_table, options = {})
+          ActiveSupport::Deprecation.warn "`foreign_key` option will be deprecated. Please use `references` option"
+          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+          @base.add_foreign_key(@name, to_table, options)
+        end
+
+        def remove_foreign_key(options = {})
+          ActiveSupport::Deprecation.warn "`remove_foreign_key` option will be deprecated. Please use `remove_references` option"
+          @base.remove_foreign_key(@name, options)
+        end
+      end
+
+    end
+  end
+end