pmacs-activerecord-oracle_enhanced-adapter 1.5.6.1 → 1.6.2.1

data/lib/active_record/connection_adapters/oracle_enhanced_database_statements.rb

@@ -1,262 +0,0 @@
-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_dirty.rb

@@ -1,45 +0,0 @@
-module ActiveRecord #:nodoc:
-  module ConnectionAdapters #:nodoc:
-    module OracleEnhancedDirty #:nodoc:
-
-      module InstanceMethods #:nodoc:
-        private
-
-        def _field_changed?(attr, old, value)
-          if column = column_for_attribute(attr)
-            # Added also :decimal type
-            if ([:integer, :decimal, :float].include? column.type) && column.null && (old.nil? || old == 0) && value.blank?
-              # For nullable integer/decimal/float columns, NULL gets stored in database for blank (i.e. '') values.
-              # Hence we don't record it as a change if the value changes from nil to ''.
-              # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-              # be typecast back to 0 (''.to_i => 0)
-              value = nil
-            elsif column.type == :string && column.null && old.nil?
-              # Oracle stores empty string '' as NULL
-              # therefore need to convert empty string value to nil if old value is nil
-              value = nil if value == ''
-            elsif old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
-              value = nil
-            else
-              value = column.type_cast(value)
-            end
-          end
-
-          old != value
-        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_schema_definitions.rb

@@ -1,223 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class OracleEnhancedForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
-    end
-
-    class OracleEnhancedSynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
-    end
-
-    class OracleEnhancedIndexDefinition < Struct.new(:table, :name, :unique, :type, :parameters, :statement_parameters,
-      :tablespace, :columns) #:nodoc:
-    end
-
-    module OracleEnhancedColumnDefinition
-       def self.included(base) #:nodoc:
-        base.class_eval do
-          #alias_method_chain :to_sql, :virtual_columns
-          #alias to_s :to_sql
-        end
-       end
-
-      def to_sql_with_virtual_columns
-        if type == :virtual
-          sql_type = base.type_to_sql(default[:type], limit, precision, scale) if default[:type]
-          "#{base.quote_column_name(name)} #{sql_type} AS (#{default[:as]})"
-        else
-          column_sql = to_sql_without_virtual_columns
-          if type==:primary_key
-            column_sql << base.table_definition_tablespace
-          end
-        end
-        column_sql
-      end
-
-      def lob?
-        ['CLOB', 'BLOB'].include?(sql_type)
-      end
-    end
-
-    module OracleEnhancedSchemaDefinitions #:nodoc:
-      def self.included(base)
-        base::TableDefinition.class_eval do
-          include OracleEnhancedTableDefinition
-        end
-
-        # Available starting from ActiveRecord 2.1
-        base::Table.class_eval do
-          include OracleEnhancedTable
-        end if defined?(base::Table)
-      end
-    end
-  
-    module OracleEnhancedTableDefinition
-      class ForeignKey < Struct.new(:base, :to_table, :options) #:nodoc:
-        def to_sql
-          base.foreign_key_definition(to_table, options) << base.table_definition_tablespace
-        end
-        alias to_s :to_sql
-      end
-
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          alias_method_chain :references, :foreign_keys
-          alias_method_chain :column, :virtual_columns
-        end
-      end
-
-      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_with_virtual_columns(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
-        column_without_virtual_columns(name, type, options)
-      end
-    
-      # Adds a :foreign_key option to TableDefinition.references.
-      # If :foreign_key is true, a foreign key constraint is added to the table.
-      # You can also specify a hash, which is passed as foreign key options.
-      # 
-      # ===== Examples
-      # ====== Add goat_id column and a foreign key to the goats table.
-      #  t.references(:goat, :foreign_key => true)
-      # ====== Add goat_id column and a cascading foreign key to the goats table.
-      #  t.references(:goat, :foreign_key => {:dependent => :delete})
-      # 
-      # Note: No foreign key is created if :polymorphic => true is used.
-      # Note: If no name is specified, the database driver creates one for you!
-      def references_with_foreign_keys(*args)
-        options = args.extract_options!
-        index_options = options[:index]
-        fk_options = options.delete(:foreign_key)
-
-        if fk_options && !options[:polymorphic]
-          fk_options = {} if fk_options == true
-          args.each do |to_table| 
-            foreign_key(to_table, fk_options) 
-            add_index(to_table, "#{to_table}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
-          end
-        end
-
-        references_without_foreign_keys(*(args << options))
-      end
-  
-      # Defines a foreign key for the table. +to_table+ can be a single Symbol, or
-      # an Array of Symbols. See SchemaStatements#add_foreign_key
-      #
-      # ===== Examples
-      # ====== Creating a simple foreign key
-      #  t.foreign_key(:people)
-      # ====== Defining the column
-      #  t.foreign_key(:people, :column => :sender_id)
-      # ====== Creating a named foreign key
-      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
-      # ====== Defining the column of the +to_table+.
-      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
-      def foreign_key(to_table, options = {})
-        #TODO
-        if ActiveRecord::Base.connection.supports_foreign_keys?
-          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
-          foreign_keys << ForeignKey.new(@base, to_table, options)
-        else
-          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
-        end
-      end
-    
-      def foreign_keys
-        @foreign_keys ||= []
-      end
-    end
-
-    module OracleEnhancedTable
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          alias_method_chain :references, :foreign_keys
-        end
-      end
-
-      # Adds a new foreign key to the table. +to_table+ can be a single Symbol, or
-      # an Array of Symbols. See SchemaStatements#add_foreign_key
-      #
-      # ===== Examples
-      # ====== Creating a simple foreign key
-      #  t.foreign_key(:people)
-      # ====== Defining the column
-      #  t.foreign_key(:people, :column => :sender_id)
-      # ====== Creating a named foreign key
-      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
-      # ====== Defining the column of the +to_table+.
-      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
-      def foreign_key(to_table, options = {})
-        if @base.respond_to?(:supports_foreign_keys?) && @base.supports_foreign_keys?
-          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
-          @base.add_foreign_key(@table_name, to_table, options)
-        else
-          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
-        end
-      end
-  
-      # Remove the given foreign key from the table.
-      #
-      # ===== Examples
-      # ====== Remove the suppliers_company_id_fk in the suppliers table.
-      #   t.remove_foreign_key :companies
-      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
-      #   remove_foreign_key :column => :branch_id
-      # ====== Remove the foreign key named party_foreign_key in the accounts table.
-      #   remove_index :name => :party_foreign_key
-      def remove_foreign_key(options = {})
-        @base.remove_foreign_key(@table_name, options)
-      end
-    
-      # Adds a :foreign_key option to TableDefinition.references.
-      # If :foreign_key is true, a foreign key constraint is added to the table.
-      # You can also specify a hash, which is passed as foreign key options.
-      # 
-      # ===== Examples
-      # ====== Add goat_id column and a foreign key to the goats table.
-      #  t.references(:goat, :foreign_key => true)
-      # ====== Add goat_id column and a cascading foreign key to the goats table.
-      #  t.references(:goat, :foreign_key => {:dependent => :delete})
-      # 
-      # Note: No foreign key is created if :polymorphic => true is used.
-      def references_with_foreign_keys(*args)
-        options = args.extract_options!
-        polymorphic = options[:polymorphic]
-        index_options = options[:index]
-        fk_options = options.delete(:foreign_key)
-
-        references_without_foreign_keys(*(args << options))
-        # references_without_foreign_keys adds {:type => :integer}
-        args.extract_options!
-        if fk_options && !polymorphic
-          fk_options = {} if fk_options == true
-          args.each do |to_table| 
-            foreign_key(to_table, fk_options) 
-            add_index(to_table, "#{to_table}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::ConnectionAdapters.class_eval do
-  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDefinitions
-end