activerecord-oracle_enhanced-adapter 1.5.5 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1f1f3ee668e111001b017dd37db4d5e70bb315f
-  data.tar.gz: 10e4fdff8ab461b4e48ac248e8a61ccaa4fd1870
+  metadata.gz: bf76a19860e42ac1474f054e8382f4f24ff8da03
+  data.tar.gz: 2f9b7008612855e77c716dc8aabbab07ec33f77a
 SHA512:
-  metadata.gz: 58dddb4992f8ae81c79ee379d0c26a0dcfe869df5e052e1892679a9f03ba440b623fe7b6b2d6c4a85e589bc80989b47e1285d8ad9139e19a64e249872701d566
-  data.tar.gz: d42acd789d7733e82e7e70d8c81c453e9dbd0a3a3dc0b196901ed9552ad09580540559ee5dbb0ec30102ef83d389b313ba932bfe22dc5c7ef0cefda1347ff1db
+  metadata.gz: ed5674fe99c4187285e6190faf54e3694da5ec8ea40aa945c375a895cf6c726559e7a04cc1209acdc3c8cf11f3d6408ed2f817e1cfe84537b5c54b9e2603a750
+  data.tar.gz: f7fabceab51daaff7562882012f538fd7dc977bf5f294f7350b41f2ec08aaa002db5844bdda9f7324cad2fcab4344f15eb69c584828b3b58146d7223b479d589

data/History.md

@@ -1,3 +1,28 @@
+## 1.5.6 / 2015-03-30
+
+* Enhancements
+ * Support Rails 4.1.10 [#530]
+ * Remove warning message when JDK 8 is used [#525]
+ * Support RAW column types [#471]
+ * Properly quote database links [#556]
+ * Grant create view privilege to db user [#528]
+ * Read SYSTEM password from ENV ORACLE_SYSTEM_PASSWORD optionally [#529]
+ * Show original error message when loading ruby-oci8 library fails [#532]
+ * Update README that `OracleEnhancedProcedures` is not auto loaded [#474]
+ * Fix legacy schema support syntax [#507]
+ * Peform all unit test when tested with Oracle 12c [#465]
+ * Add `:if_exists` option to `drop_table` [#541]
+ * Extract OracleEnhancedDatabaseStatements [#449]
+ * Removed self.visitor_for(pool) method [#501]
+
+* Bug Fix
+ * Fix serialized readonly lobs [#515]
+ * Do not dump schema information during structure dump [#558]
+ * Structure dump generates correct create or replace synonym [#453]
+ * Procedures and functions are created correctly by removing semi-colon [#456]
+ * Show support matrix of Java and JDBC Driver only when java_version >= '1.8' [#455]
+ * Update Gemfile dependencies so specs can run [#472]
+
 ## 1.5.5 / 2014-05-23
 
 * Enhancements

data/README.md

@@ -179,11 +179,11 @@ If you want to put Oracle enhanced adapter on top of existing schema tables then
 
     class Employee < ActiveRecord::Base
       # specify schema and table name
-      self.table_name "hr.hr_employees"
+      self.table_name = "hr.hr_employees"
       # specify primary key name
-      self.primary_key "employee_id"
+      self.primary_key = "employee_id"
       # specify sequence name
-      self.sequence_name "hr.hr_employee_s"
+      self.sequence_name = "hr.hr_employee_s"
       # set which DATE columns should be converted to Ruby Date
       set_date_columns :hired_on, :birth_date_on
       # set which DATE columns should be converted to Ruby Time
@@ -223,9 +223,10 @@ You can also access remote tables over database link using
 
 ### Custom create, update and delete methods
 
-If you have legacy schema and you are not allowed to do direct INSERTs, UPDATEs and DELETEs in legacy schema tables and need to use existing PL/SQL procedures for create, updated, delete operations then you should add `ruby-plsql` gem to your application and then define custom create, update and delete methods, see example:
+If you have legacy schema and you are not allowed to do direct INSERTs, UPDATEs and DELETEs in legacy schema tables and need to use existing PL/SQL procedures for create, updated, delete operations then you should add `ruby-plsql` gem to your application, include `ActiveRecord::OracleEnhancedProcedures` in your model and then define custom create, update and delete methods, see example:
 
     class Employee < ActiveRecord::Base
+      include ActiveRecord::OracleEnhancedProcedures
       # when defining create method then return ID of new record that will be assigned to id attribute of new object
       set_create_method do
         plsql.employees_pkg.create_employee(

data/VERSION

@@ -1 +1 @@
-1.5.5
+1.5.6

data/activerecord-oracle_enhanced-adapter.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.5.5"
+  s.version = "1.5.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.license = 'MIT'
   s.authors = [%q{Raimonds Simanovskis}]
-  s.date = %q{2014-05-23}
+  s.date = %q{2015-03-30}
   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.
 }
@@ -35,6 +35,7 @@ This adapter is superset of original ActiveRecord Oracle adapter.
     "lib/active_record/connection_adapters/oracle_enhanced_connection.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_context_index.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_cpk.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_database_statements.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_dirty.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb",

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -53,7 +53,7 @@ module ActiveRecord
     end
 
     # Specify which table columns should be typecasted to Date (without time), e.g.:
-    # 
+    #
     #   set_date_columns :created_on, :updated_on
     def self.set_date_columns(*args)
       connection.set_type_for_columns(table_name,:date,*args)
@@ -120,19 +120,18 @@ module ActiveRecord
     private
 
     def enhanced_write_lobs
-      if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) && 
+      if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
           !(
             (self.class.custom_create_method || self.class.custom_create_method) ||
             (self.class.custom_update_method || self.class.custom_update_method)
           )
-        self.class.connection.write_lobs(self.class.table_name, self.class, attributes, @changed_lob_columns || self.class.lob_columns)
+        self.class.connection.write_lobs(self.class.table_name, self.class, attributes, @changed_lob_columns)
       end
     end
 
     def record_changed_lobs
       @changed_lob_columns = self.class.lob_columns.select do |col|
-        self.class.serialized_attributes.keys.include?(col.name) ||
-          (self.send(:"#{col.name}_changed?") && !self.class.readonly_attributes.to_a.include?(col.name))
+        (self.class.serialized_attributes.keys.include?(col.name) || self.send(:"#{col.name}_changed?")) && !self.class.readonly_attributes.to_a.include?(col.name)
       end
     end
   end
@@ -402,10 +401,6 @@ module ActiveRecord
         end
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        Arel::Visitors::Oracle.new(pool)
-      end
-
       ADAPTER_NAME = 'OracleEnhanced'.freeze
 
       def adapter_name #:nodoc:
@@ -505,7 +500,7 @@ module ActiveRecord
         index_name_length
       end
 
-      # the maximum length of an index name 
+      # the maximum length of an index name
       # supported by this database
       def index_name_length
         IDENTIFIER_MAX_LENGTH
@@ -557,6 +552,18 @@ module ActiveRecord
         end
       end
 
+      # Used only for quoting database links as the naming rules for links
+      # differ from the rules for column names. Specifically, link names may
+      # include periods.
+      def quote_database_link(name)
+        case name
+        when NONQUOTED_DATABASE_LINK
+          %Q("#{name.upcase}")
+        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.
@@ -585,8 +592,8 @@ module ActiveRecord
       end
 
       def quote_table_name(name) #:nodoc:
-        name = name.to_s
-        @quoted_table_names[name] ||= name.split('.').map{|n| n.split('@').map{|m| quote_column_name(m)}.join('@')}.join('.')
+        name, link = name.to_s.split('@')
+        @quoted_table_names[name] ||= [name.split('.').map{|n| quote_column_name(n)}.join('.'), quote_database_link(link)].compact.join('@')
       end
 
       def quote_string(s) #:nodoc:
@@ -728,187 +735,6 @@ module ActiveRecord
         @connection.logoff rescue nil
       end
 
-      # 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
-
       # use in set_sequence_name to avoid fetching primary key value from sequence
       AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze
 
@@ -922,49 +748,6 @@ module ActiveRecord
         @connection.select_value("SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual")
       end
 
-      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
-
       @@do_not_prefetch_primary_key = {}
 
       # Returns true for Oracle adapter (since Oracle requires primary key
@@ -987,12 +770,6 @@ module ActiveRecord
         @@do_not_prefetch_primary_key = {}
       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
-
       def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nodoc:
         return nil unless table_exists?(table_name)
         unless primary_key and sequence_name
@@ -1017,27 +794,11 @@ module ActiveRecord
             select NVL(max(#{quote_column_name(primary_key)}),0) + 1 from #{quote_table_name(table_name)}
           ", new_start_value)
 
-          execute ("DROP SEQUENCE #{quote_table_name(sequence_name)}") 
+          execute ("DROP SEQUENCE #{quote_table_name(sequence_name)}")
           execute ("CREATE SEQUENCE #{quote_table_name(sequence_name)} START WITH #{new_start_value}")
         end
       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
-
       # Writes LOB values from attributes for specified columns
       def write_lobs(table_name, klass, attributes, columns) #:nodoc:
         # is class with composite primary key>
@@ -1400,16 +1161,16 @@ module ActiveRecord
             c = c.to_sql unless c.is_a?(String)
             # remove any ASC/DESC modifiers
             c.gsub(/\s+(ASC|DESC)\s*?/i, '')
-            }.reject(&:blank?).map.with_index { |c,i| 
-              "FIRST_VALUE(#{c}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__" 
+            }.reject(&:blank?).map.with_index { |c,i|
+              "FIRST_VALUE(#{c}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
             }
             [super].concat(order_columns).join(', ')
         end
-      end 
+      end
 
       def columns_for_distinct(columns, orders) #:nodoc:
-        # construct a valid columns name for DISTINCT clause, 
-        # ie. one that includes the ORDER BY columns, using FIRST_VALUE such that 
+        # construct a valid columns name for DISTINCT clause,
+        # ie. one that includes the ORDER BY columns, using FIRST_VALUE such that
         # the inclusion of these columns doesn't invalidate the DISTINCT
         #
         # It does not construct DISTINCT clause. Just return column names for distinct.
@@ -1459,16 +1220,6 @@ module ActiveRecord
 
       private
 
-      def select(sql, name = nil, binds = [])
-        if ActiveRecord.const_defined?(:Result)
-          exec_query(sql, name, binds)
-        else
-          log(sql, name) do
-            @connection.select(sql, name, false)
-          end
-        end
-      end
-
       def oracle_downcase(column_name)
         @connection.oracle_downcase(column_name)
       end
@@ -1570,3 +1321,6 @@ require 'active_record/connection_adapters/oracle_enhanced_column_dumper'
 
 # Moved SchemaCreation class
 require 'active_record/connection_adapters/oracle_enhanced_schema_creation'
+
+# Moved DatabaseStetements
+require 'active_record/connection_adapters/oracle_enhanced_database_statements'