ruby-plsql 0.6.0 → 0.7.0

data/lib/plsql/oci8_patches.rb

@@ -21,5 +21,5 @@ if OCI8::VERSION == "2.0.3" &&
     end
     private :datetime_to_array_without_timestamp_patch, :datetime_to_array
   end
-  
-end
+
+end

data/lib/plsql/oci_connection.rb

@@ -18,17 +18,16 @@ require "plsql/oci8_patches"
 
 # check ruby-oci8 version
 required_oci8_version = [2, 0, 3]
-oci8_version_ints = OCI8::VERSION.scan(/\d+/).map{|s| s.to_i}
+oci8_version_ints = OCI8::VERSION.scan(/\d+/).map { |s| s.to_i }
 if (oci8_version_ints <=> required_oci8_version) < 0
   raise LoadError, "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version #{required_oci8_version.join('.')} or later."
 end
 
 module PLSQL
   class OCIConnection < Connection #:nodoc:
-
     def self.create_raw(params)
       connection_string = if params[:host]
-        "//#{params[:host]}:#{params[:port]||1521}/#{params[:database]}"
+        "//#{params[:host]}:#{params[:port] || 1521}/#{params[:database]}"
       else
         params[:database]
       end
@@ -47,7 +46,7 @@ module PLSQL
     def rollback
       raw_connection.rollback
     end
-    
+
     def autocommit?
       raw_connection.autocommit?
     end
@@ -86,7 +85,7 @@ module PLSQL
         self.new(conn, raw_cursor)
       end
 
-      def self.new_from_query(conn, sql, bindvars=[], options={})
+      def self.new_from_query(conn, sql, bindvars = [], options = {})
         cursor = new_from_parse(conn, sql)
         if prefetch_rows = options[:prefetch_rows]
           cursor.prefetch_rows = prefetch_rows
@@ -104,7 +103,7 @@ module PLSQL
         ora_value = @connection.ruby_value_to_ora_value(value, type)
         @raw_cursor.bind_param(arg, ora_value, type, length)
       end
-      
+
       def exec(*bindvars)
         @raw_cursor.exec(*bindvars)
       end
@@ -115,11 +114,11 @@ module PLSQL
 
       def fetch
         row = @raw_cursor.fetch
-        row && row.map{|v| @connection.ora_value_to_ruby_value(v)}
+        row && row.map { |v| @connection.ora_value_to_ruby_value(v) }
       end
 
       def fields
-        @fields ||= @raw_cursor.get_col_names.map{|c| c.downcase.to_sym}
+        @fields ||= @raw_cursor.get_col_names.map { |c| c.downcase.to_sym }
       end
 
       def close_raw_cursor
@@ -133,14 +132,13 @@ module PLSQL
         end
         close_raw_cursor
       end
-
     end
 
     def parse(sql)
       Cursor.new_from_parse(self, sql)
     end
 
-    def cursor_from_query(sql, bindvars=[], options={})
+    def cursor_from_query(sql, bindvars = [], options = {})
       Cursor.new_from_query(self, sql, bindvars, options)
     end
 
@@ -174,18 +172,16 @@ module PLSQL
       end
     end
 
-    def ruby_value_to_ora_value(value, type=nil)
+    def ruby_value_to_ora_value(value, type = nil)
       type ||= value.class
       case type.to_s.to_sym
-      when :Fixnum, :BigDecimal, :String
+      when :Integer, :BigDecimal, :String
         value
       when :OraNumber
         # pass parameters as OraNumber to avoid rounding errors
         case value
-        when Bignum
-          OraNumber.new(value.to_s)
         when BigDecimal
-          OraNumber.new(value.to_s('F'))
+          OraNumber.new(value.to_s("F"))
         when TrueClass
           OraNumber.new(1)
         when FalseClass
@@ -218,7 +214,7 @@ module PLSQL
             raise ArgumentError, "You should pass Array value for collection type parameter" unless value.is_a?(Array)
             elem_list = value.map do |elem|
               if (attr_tdo = tdo.coll_attr.typeinfo)
-                attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr_tdo.typename)
+                attr_type, _ = plsql_to_ruby_data_type(data_type: "OBJECT", sql_type_name: attr_tdo.typename)
               else
                 attr_type = elem.class
               end
@@ -227,7 +223,7 @@ module PLSQL
             # construct collection value
             # TODO: change setting instance variable to appropriate ruby-oci8 method call when available
             collection = type.new(raw_oci_connection)
-            collection.instance_variable_set('@attributes', elem_list)
+            collection.instance_variable_set("@attributes", elem_list)
             collection
           else # object type
             raise ArgumentError, "You should pass Hash value for object type parameter" unless value.is_a?(Hash)
@@ -237,7 +233,7 @@ module PLSQL
               case attr.datatype
               when OCI8::TDO::ATTR_NAMED_TYPE, OCI8::TDO::ATTR_NAMED_COLLECTION
                 # nested object type or collection
-                attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr.typeinfo.typename)
+                attr_type, _ = plsql_to_ruby_data_type(data_type: "OBJECT", sql_type_name: attr.typeinfo.typename)
                 object_attrs[key] = ruby_value_to_ora_value(object_attrs[key], attr_type)
               end
             end
@@ -266,7 +262,7 @@ module PLSQL
       when OCI8::Object::Base
         tdo = raw_oci_connection.get_tdo_by_class(value.class)
         if tdo.is_collection?
-          value.to_ary.map{|e| ora_value_to_ruby_value(e)}
+          value.to_ary.map { |e| ora_value_to_ruby_value(e) }
         else # object type
           tdo.attributes.inject({}) do |hash, attr|
             hash[attr.name] = ora_value_to_ruby_value(value.instance_variable_get(:@attributes)[attr.name])
@@ -280,63 +276,49 @@ module PLSQL
       end
     end
 
-    def describe_synonym(schema_name, synonym_name)
-      if schema_name == 'PUBLIC'
-        full_name = synonym_name.to_s
-      else
-        full_name = "#{schema_name}.#{synonym_name}"
-      end
-      metadata = raw_connection.describe_synonym(full_name)
-      [metadata.schema_name, metadata.name]
-    rescue OCIError
-      nil
-    end
-
     def database_version
-      @database_version ||= (version = raw_connection.oracle_server_version) && 
+      @database_version ||= (version = raw_connection.oracle_server_version) &&
         [version.major, version.minor, version.update, version.patch]
     end
 
     private
-    
-    def raw_oci_connection
-      if raw_connection.is_a? OCI8
-        raw_connection
-      # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
-      # in this case we need to pass original OCI8 connection
-      else
-        raw_connection.instance_variable_get(:@connection)
-      end
-    end
-    
-    def ora_number_to_ruby_number(num)
-      # return BigDecimal instead of Float to avoid rounding errors
-      num == (num_to_i = num.to_i) ? num_to_i : (num.is_a?(BigDecimal) ? num : BigDecimal.new(num.to_s))
-    end
-    
-    def ora_date_to_ruby_date(val)
-      case val
-      when DateTime
-        # similar implementation as in oracle_enhanced adapter
-        begin
-          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.min, val.sec)
-        rescue
-          offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
-          DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, offset)
-        end
-      when OraDate
-        # similar implementation as in oracle_enhanced adapter
-        begin
-          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.minute, val.second)
-        rescue
-          offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
-          DateTime.civil(val.year, val.month, val.day, val.hour, val.minute, val.second, offset)
+
+      def raw_oci_connection
+        if raw_connection.is_a? OCI8
+          raw_connection
+        # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
+        # in this case we need to pass original OCI8 connection
+        else
+          raw_connection.instance_variable_get(:@connection)
         end
-      else
-        val
       end
-    end
 
+      def ora_number_to_ruby_number(num)
+        # return BigDecimal instead of Float to avoid rounding errors
+        num == (num_to_i = num.to_i) ? num_to_i : (num.is_a?(BigDecimal) ? num : BigDecimal(num.to_s))
+      end
+
+      def ora_date_to_ruby_date(val)
+        case val
+        when DateTime
+          # similar implementation as in oracle_enhanced adapter
+          begin
+            Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.min, val.sec)
+          rescue
+            offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
+            DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, offset)
+          end
+        when OraDate
+          # similar implementation as in oracle_enhanced adapter
+          begin
+            Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.minute, val.second)
+          rescue
+            offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
+            DateTime.civil(val.year, val.month, val.day, val.hour, val.minute, val.second, offset)
+          end
+        else
+          val
+        end
+      end
   end
-  
 end

data/lib/plsql/package.rb

@@ -1,5 +1,4 @@
 module PLSQL
-
   module PackageClassMethods #:nodoc:
     def find(schema, package)
       package_name = package.to_s.upcase
@@ -56,11 +55,11 @@ module PLSQL
 
     private
 
-    def method_missing(method, *args, &block)
-      method = method.to_s
-      method.chop! if (assignment = method[/=$/])
+      def method_missing(method, *args, &block)
+        method = method.to_s
+        method.chop! if (assignment = method[/=$/])
 
-      case (object = self[method])
+        case (object = self[method])
         when Procedure
           if assignment
             raise ArgumentError, "Cannot assign value to package procedure '#{method.upcase}'"
@@ -82,9 +81,7 @@ module PLSQL
           end
         else
           raise ArgumentError, "No PL/SQL procedure or variable '#{method.upcase}' found"
+        end
       end
-    end
-
   end
-
 end

data/lib/plsql/procedure.rb

@@ -1,45 +1,44 @@
 module PLSQL
-
   module ProcedureClassMethods #:nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
-            "SELECT #{procedure_object_id_src(schema)}.object_id
-            FROM all_procedures p, all_objects o
-            WHERE p.owner = :owner
-              AND p.object_name = :object_name
-              AND o.owner = p.owner
-              AND o.object_name = p.object_name
-              AND o.object_type in ('PROCEDURE', 'FUNCTION')",
+          "SELECT #{procedure_object_id_src(schema)}.object_id
+          FROM all_procedures p, all_objects o
+          WHERE p.owner = :owner
+            AND p.object_name = :object_name
+            AND o.owner = p.owner
+            AND o.object_name = p.object_name
+            AND o.object_type in ('PROCEDURE', 'FUNCTION')",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, procedure, nil, nil, row[0])
         # search for synonym
         elsif (row = schema.select_first(
-            "SELECT o.owner, o.object_name, #{procedure_object_id_src(schema)}.object_id
-            FROM all_synonyms s, all_objects o, all_procedures p
-            WHERE s.owner IN (:owner, 'PUBLIC')
-              AND s.synonym_name = :synonym_name
-              AND o.owner = s.table_owner
-              AND o.object_name = s.table_name
-              AND o.object_type IN ('PROCEDURE','FUNCTION')
-              AND o.owner = p.owner
-              AND o.object_name = p.object_name
-              ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+          "SELECT o.owner, o.object_name, #{procedure_object_id_src(schema)}.object_id
+          FROM all_synonyms s, all_objects o, all_procedures p
+          WHERE s.owner IN (:owner, 'PUBLIC')
+            AND s.synonym_name = :synonym_name
+            AND o.owner = s.table_owner
+            AND o.object_name = s.table_name
+            AND o.object_type IN ('PROCEDURE','FUNCTION')
+            AND o.owner = p.owner
+            AND o.object_name = p.object_name
+            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, row[1], nil, row[0], row[2])
         else
           nil
         end
       elsif package && (row = schema.select_first(
-            # older Oracle versions do not have object_id column in all_procedures
-            "SELECT #{procedure_object_id_src(schema)}.object_id
-            FROM all_procedures p, all_objects o
-            WHERE p.owner = :owner
-              AND p.object_name = :object_name
-              AND p.procedure_name = :procedure_name
-              AND o.owner = p.owner
-              AND o.object_name = p.object_name
-              AND o.object_type = 'PACKAGE'",
+        # older Oracle versions do not have object_id column in all_procedures
+        "SELECT #{procedure_object_id_src(schema)}.object_id
+        FROM all_procedures p, all_objects o
+        WHERE p.owner = :owner
+          AND p.object_name = :object_name
+          AND p.procedure_name = :procedure_name
+          AND o.owner = p.owner
+          AND o.object_name = p.object_name
+          AND o.object_type = 'PACKAGE'",
             override_schema_name || schema.schema_name, package, procedure.to_s.upcase))
         new(schema, procedure, package, override_schema_name, row[0])
       else
@@ -49,9 +48,9 @@ module PLSQL
 
     private
 
-    def procedure_object_id_src(schema)
-      (schema.connection.database_version <=> [11, 1, 0, 0]) >= 0 ? "p" : "o"
-    end
+      def procedure_object_id_src(schema)
+        (schema.connection.database_version <=> [11, 1, 0, 0]) >= 0 ? "p" : "o"
+      end
   end
 
   module ProcedureCommon #:nodoc:
@@ -61,21 +60,21 @@ module PLSQL
     # return type string from metadata that can be used in DECLARE block or table definition
     def self.type_to_sql(metadata) #:nodoc:
       case metadata[:data_type]
-      when 'NUMBER'
+      when "NUMBER"
         precision, scale = metadata[:data_precision], metadata[:data_scale]
-        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}": ""})" : ""}"
-      when 'VARCHAR', 'VARCHAR2', 'CHAR'
+        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}" : ""})" : ""}"
+      when "VARCHAR", "VARCHAR2", "CHAR"
         length = case metadata[:char_used]
-        when 'C' then "#{metadata[:char_length]} CHAR"
-        when 'B' then "#{metadata[:data_length]} BYTE"
-        else
-          metadata[:data_length]
+                 when "C" then "#{metadata[:char_length]} CHAR"
+                 when "B" then "#{metadata[:data_length]} BYTE"
+                 else
+                   metadata[:data_length]
         end
         "#{metadata[:data_type]}#{length && "(#{length})"}"
-      when 'NVARCHAR2', 'NCHAR'
+      when "NVARCHAR2", "NCHAR"
         length = metadata[:char_length]
         "#{metadata[:data_type]}#{length && "(#{length})"}"
-      when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'OBJECT', 'XMLTYPE'
+      when "PL/SQL TABLE", "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
         metadata[:sql_type_name]
       else
         metadata[:data_type]
@@ -99,9 +98,9 @@ module PLSQL
       @tmp_tables_created = {}
 
       # subprogram_id column is available just from version 10g
-      subprogram_id_column = (@schema.connection.database_version <=> [10, 2, 0, 2]) >= 0 ? 'subprogram_id' : 'NULL'
+      subprogram_id_column = (@schema.connection.database_version <=> [10, 2, 0, 2]) >= 0 ? "subprogram_id" : "NULL"
       # defaulted is available just from version 11g
-      defaulted_column = (@schema.connection.database_version <=> [11, 0, 0, 0]) >= 0 ? 'defaulted' : 'NULL'
+      defaulted_column = (@schema.connection.database_version <=> [11, 0, 0, 0]) >= 0 ? "defaulted" : "NULL"
 
       @schema.select_all(
         "SELECT #{subprogram_id_column}, object_name, TO_NUMBER(overload), argument_name, position, data_level,
@@ -138,7 +137,7 @@ module PLSQL
             # then generate unique ID from object_name and overload
             subprogram_id ||= "#{object_name.hash % 10000}#{overload}"
             tmp_table_name = "#{Connection::RUBY_TEMP_TABLE_PREFIX}#{@schema.connection.session_id}_#{@object_id}_#{subprogram_id}_#{position}"
-          elsif data_type != 'PL/SQL RECORD'
+          elsif data_type != "PL/SQL RECORD"
             # raise exception only when there are no overloaded procedure definitions
             # (as probably this overload will not be used at all)
             raise ArgumentError, "Parameter type #{sql_type_name} definition inside package is not supported, use CREATE TYPE outside package" if overload == 0
@@ -146,19 +145,19 @@ module PLSQL
         end
 
         argument_metadata = {
-          :position => position && position.to_i,
-          :data_type => data_type,
-          :in_out => in_out,
-          :data_length => data_length && data_length.to_i,
-          :data_precision => data_precision && data_precision.to_i,
-          :data_scale => data_scale && data_scale.to_i,
-          :char_used => char_used,
-          :char_length => char_length && char_length.to_i,
-          :type_owner => type_owner,
-          :type_name => type_name,
-          :type_subname => type_subname,
-          :sql_type_name => sql_type_name,
-          :defaulted => defaulted
+          position: position && position.to_i,
+          data_type: data_type,
+          in_out: in_out,
+          data_length: data_length && data_length.to_i,
+          data_precision: data_precision && data_precision.to_i,
+          data_scale: data_scale && data_scale.to_i,
+          char_used: char_used,
+          char_length: char_length && char_length.to_i,
+          type_owner: type_owner,
+          type_name: type_name,
+          type_subname: type_subname,
+          sql_type_name: sql_type_name,
+          defaulted: defaulted
         }
         if tmp_table_name
           @tmp_table_names[overload] << [(argument_metadata[:tmp_table_name] = tmp_table_name), argument_metadata]
@@ -166,14 +165,14 @@ module PLSQL
 
         if composite_type?(data_type)
           case data_type
-          when 'PL/SQL RECORD'
+          when "PL/SQL RECORD"
             argument_metadata[:fields] = {}
           end
           previous_level_argument_metadata[data_level] = argument_metadata
         end
 
         # if function has return value
-        if argument_name.nil? && data_level == 0 && in_out == 'OUT'
+        if argument_name.nil? && data_level == 0 && in_out == "OUT"
           @return[overload] = argument_metadata
         # if parameter
         else
@@ -184,9 +183,9 @@ module PLSQL
           # or lower level part of composite type
           else
             case previous_level_argument_metadata[data_level - 1][:data_type]
-            when 'PL/SQL RECORD'
+            when "PL/SQL RECORD"
               previous_level_argument_metadata[data_level - 1][:fields][argument_name.downcase.to_sym] = argument_metadata
-            when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'REF CURSOR'
+            when "PL/SQL TABLE", "TABLE", "VARRAY", "REF CURSOR"
               previous_level_argument_metadata[data_level - 1][:element] = argument_metadata
             end
           end
@@ -201,8 +200,8 @@ module PLSQL
     def construct_argument_list_for_overloads #:nodoc:
       @overloads = @arguments.keys.sort
       @overloads.each do |overload|
-        @argument_list[overload] = @arguments[overload].keys.sort {|k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position]}
-        @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] =~ /OUT/}
+        @argument_list[overload] = @arguments[overload].keys.sort { |k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position] }
+        @out_list[overload] = @argument_list[overload].select { |k| @arguments[overload][k][:in_out] =~ /OUT/ }
       end
     end
 
@@ -210,19 +209,19 @@ module PLSQL
       return if @tmp_tables_created.nil? || @tmp_tables_created[overload]
       @tmp_table_names[overload] && @tmp_table_names[overload].each do |table_name, argument_metadata|
         sql = "CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
-          element_metadata = argument_metadata[:element]
-          case element_metadata[:data_type]
-          when 'PL/SQL RECORD'
-            fields_metadata = element_metadata[:fields]
-            fields_sorted_by_position = fields_metadata.keys.sort_by{|k| fields_metadata[k][:position]}
-            sql << fields_sorted_by_position.map do |field|
-              metadata = fields_metadata[field]
-              "#{field} #{ProcedureCommon.type_to_sql(metadata)}"
-            end.join(",\n")
-          else
-            sql << "element #{ProcedureCommon.type_to_sql(element_metadata)}"
-          end
-          sql << ",\ni__ NUMBER(38)\n"
+        element_metadata = argument_metadata[:element]
+        case element_metadata[:data_type]
+        when "PL/SQL RECORD"
+          fields_metadata = element_metadata[:fields]
+          fields_sorted_by_position = fields_metadata.keys.sort_by { |k| fields_metadata[k][:position] }
+          sql << fields_sorted_by_position.map do |field|
+            metadata = fields_metadata[field]
+            "#{field} #{ProcedureCommon.type_to_sql(metadata)}"
+          end.join(",\n")
+        else
+          sql << "element #{ProcedureCommon.type_to_sql(element_metadata)}"
+        end
+        sql << ",\ni__ NUMBER(38)\n"
         sql << ") ON COMMIT PRESERVE ROWS\n"
         sql_block = "DECLARE\nPRAGMA AUTONOMOUS_TRANSACTION;\nBEGIN\nEXECUTE IMMEDIATE :sql;\nEND;\n"
         @schema.execute sql_block, sql
@@ -230,12 +229,12 @@ module PLSQL
       @tmp_tables_created[overload] = true
     end
 
-    PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'REF CURSOR'].freeze
+    PLSQL_COMPOSITE_TYPES = ["PL/SQL RECORD", "PL/SQL TABLE", "TABLE", "VARRAY", "REF CURSOR"].freeze
     def composite_type?(data_type) #:nodoc:
       PLSQL_COMPOSITE_TYPES.include? data_type
     end
 
-    PLSQL_COLLECTION_TYPES = ['PL/SQL TABLE', 'TABLE', 'VARRAY'].freeze
+    PLSQL_COLLECTION_TYPES = ["PL/SQL TABLE", "TABLE", "VARRAY"].freeze
     def collection_type?(data_type) #:nodoc:
       PLSQL_COLLECTION_TYPES.include? data_type
     end
@@ -266,7 +265,5 @@ module PLSQL
       call = ProcedureCall.new(self, args)
       call.exec(&block)
     end
-
   end
-
 end