ruby-plsql 0.3.1 → 0.4.0

data/lib/plsql/oci_connection.rb

@@ -1,5 +1,15 @@
+begin
+  require "oci8"
+rescue LoadError
+  # OCI8 driver is unavailable.
+  error_message = "ERROR: ruby-plsql could not load ruby-oci8 library. "+
+                  "Please install ruby-oci8 gem."
+  STDERR.puts error_message
+  raise LoadError
+end
+
 module PLSQL
-  class OCIConnection < Connection
+  class OCIConnection < Connection #:nodoc:
     
     def logoff
       raw_connection.logoff
@@ -21,71 +31,80 @@ module PLSQL
       raw_connection.autocommit = value
     end
 
-    def select_first(sql, *bindvars)
-      cursor = raw_connection.exec(sql, *bindvars)
-      result = cursor.fetch
-      if result
-        result.map { |val| ora_value_to_ruby_value(val) }
-      else
-        nil
-      end
-    ensure
-      cursor.close rescue nil
-    end
-
-    def select_all(sql, *bindvars, &block)
-      cursor = raw_connection.exec(sql, *bindvars)
-      results = []
-      row_count = 0
-      while row = cursor.fetch
-        row_with_typecast = row.map {|val| ora_value_to_ruby_value(val) }
-        if block_given?
-          yield(row_with_typecast)
-          row_count += 1
-        else
-          results << row_with_typecast
-        end
-      end
-      block_given? ? row_count : results
-    ensure
-      cursor.close rescue nil
-    end
-
     def exec(sql, *bindvars)
       raw_connection.exec(sql, *bindvars)
       true
     end
 
-    class Cursor
-      attr_accessor :raw_cursor
-      
-      def initialize(raw_cur)
-        @raw_cursor = raw_cur
+    class Cursor #:nodoc:
+      include Connection::CursorCommon
+
+      # stack of open cursors
+      @@open_cursors = []
+      attr_reader :raw_cursor
+
+      def initialize(conn, raw_cursor)
+        @connection = conn
+        @raw_cursor = raw_cursor
+        @@open_cursors.push self
       end
 
-      def bind_param(key, value, type=nil, length=nil, in_out='IN')
-        raw_cursor.bind_param(key, value, type, length)
+      def self.new_from_parse(conn, sql)
+        raw_cursor = conn.raw_connection.parse(sql)
+        self.new(conn, raw_cursor)
+      end
+
+      def self.new_from_query(conn, sql, *bindvars)
+        Cursor.new(conn, conn.raw_connection.exec(sql, *bindvars))
+      end
+
+      def bind_param(arg, value, metadata)
+        type, length = @connection.plsql_to_ruby_data_type(metadata)
+        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)
+        @raw_cursor.exec(*bindvars)
       end
 
       def [](key)
-        raw_cursor[key]
+        @connection.ora_value_to_ruby_value(@raw_cursor[key])
+      end
+
+      def fetch
+        row = @raw_cursor.fetch
+        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}
+      end
+
+      def close_raw_cursor
+        @raw_cursor.close
       end
 
       def close
-        raw_cursor.close
+        # close all cursors that were created after this one
+        while (open_cursor = @@open_cursors.pop) && !open_cursor.equal?(self)
+          open_cursor.close_raw_cursor
+        end
+        close_raw_cursor
       end
+
     end
 
     def parse(sql)
-      Cursor.new(raw_connection.parse(sql))
+      Cursor.new_from_parse(self, sql)
     end
-    
 
-    def plsql_to_ruby_data_type(data_type, data_length)
+    def cursor_from_query(sql, *bindvars)
+      Cursor.new_from_query(sql, *bindvars)
+    end
+
+    def plsql_to_ruby_data_type(metadata)
+      data_type, data_length = metadata[:data_type], metadata[:data_length]
       case data_type
       when "VARCHAR2"
         [String, data_length || 32767]
@@ -99,63 +118,125 @@ module PLSQL
         [DateTime, nil]
       when "TIMESTAMP"
         [Time, nil]
-      # CLOB
-      # BLOB
+      when "TABLE", "VARRAY", "OBJECT"
+        # create Ruby class for collection
+        klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
+        unless klass
+          klass = Class.new(OCI8::Object::Base)
+          klass.set_typename metadata[:sql_type_name]
+        end
+        [klass, nil]
+      when "REF CURSOR"
+        [OCI8::Cursor]
       else
         [String, 32767]
       end
     end
 
-    def ruby_value_to_ora_value(val, type)
-      if type == OraNumber
+    def ruby_value_to_ora_value(value, type=nil)
+      type ||= value.class
+      case type.to_s.to_sym
+      when :Fixnum, :BigDecimal, :String
+        value
+      when :OraNumber
         # pass parameters as OraNumber to avoid rounding errors
-        case val
+        case value
         when Bignum
-          OraNumber.new(val.to_s)
+          OraNumber.new(value.to_s)
         when BigDecimal
-          OraNumber.new(val.to_s('F'))
+          OraNumber.new(value.to_s('F'))
+        when TrueClass
+          OraNumber.new(1)
+        when FalseClass
+          OraNumber.new(0)
         else
-          val
+          value
         end
-      elsif type == DateTime
-        case val
+      when :DateTime
+        case value
         when Time
-          ::DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, Rational(val.utc_offset, 86400))
+          ::DateTime.civil(value.year, value.month, value.day, value.hour, value.min, value.sec, Rational(value.utc_offset, 86400))
         when DateTime
-          val
+          value
         when Date
-          ::DateTime.civil(val.year, val.month, val.day, 0, 0, 0, 0)
+          ::DateTime.civil(value.year, value.month, value.day, 0, 0, 0, 0)
         else
-          val
+          value
         end
-      elsif type == OCI8::CLOB
-        # ruby-oci8 cannot create CLOB from ''
-        val = nil if val == ''
-        OCI8::CLOB.new(raw_oci_connection, val)
-      elsif type == OCI8::BLOB
-        # ruby-oci8 cannot create BLOB from ''
-        val = nil if val == ''
-        OCI8::BLOB.new(raw_oci_connection, val)
+      when :"OCI8::CLOB", :"OCI8::BLOB"
+        # ruby-oci8 cannot create CLOB/BLOB from ''
+        value = nil if value == ''
+        type.new(raw_oci_connection, value)
+      when :"OCI8::Cursor"
+        value && value.raw_cursor
       else
-        val
+        # collections and object types
+        if type.superclass == OCI8::Object::Base
+          return nil if value.nil?
+          tdo = raw_oci_connection.get_tdo_by_class(type)
+          if tdo.is_collection?
+            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)
+              else
+                attr_type = elem.class
+              end
+              ruby_value_to_ora_value(elem, attr_type)
+            end
+            # 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
+          else # object type
+            raise ArgumentError, "You should pass Hash value for object type parameter" unless value.is_a?(Hash)
+            object_attrs = value.dup
+            object_attrs.keys.each do |key|
+              raise ArgumentError, "Wrong object type field passed to PL/SQL procedure" unless (attr = tdo.attr_getters[key])
+              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)
+                object_attrs[key] = ruby_value_to_ora_value(object_attrs[key], attr_type)
+              end
+            end
+            type.new(raw_oci_connection, object_attrs)
+          end
+        # all other cases
+        else
+          value
+        end
       end
     end
 
-    def ora_value_to_ruby_value(val)
-      case val
-      when Float, OraNumber
-        ora_number_to_ruby_number(val)
+    def ora_value_to_ruby_value(value)
+      case value
+      when Float, OraNumber, BigDecimal
+        ora_number_to_ruby_number(value)
       when DateTime, OraDate
-        ora_date_to_ruby_date(val)
+        ora_date_to_ruby_date(value)
       when OCI8::LOB
-        if val.available?
-          val.rewind
-          val.read
+        if value.available?
+          value.rewind
+          value.read
         else
           nil
         end
+      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)}
+        else # object type
+          tdo.attributes.inject({}) do |hash, attr|
+            hash[attr.name] = ora_value_to_ruby_value(value.instance_variable_get(:@attributes)[attr.name])
+            hash
+          end
+        end
+      when OCI8::Cursor
+        Cursor.new(self, value)
       else
-        val
+        value
       end
     end
 
@@ -174,8 +255,7 @@ module PLSQL
     
     def ora_number_to_ruby_number(num)
       # return BigDecimal instead of Float to avoid rounding errors
-      # num.to_i == num.to_f ? num.to_i : num.to_f
-      num == (num_to_i = num.to_i) ? num_to_i : BigDecimal.new(num.to_s)
+      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)

data/lib/plsql/package.rb

@@ -1,6 +1,6 @@
 module PLSQL
 
-  module PackageClassMethods
+  module PackageClassMethods #:nodoc:
     def find(schema, package)
       if schema.select_first("
             SELECT object_name FROM all_objects
@@ -27,7 +27,7 @@ module PLSQL
     end
   end
 
-  class Package
+  class Package #:nodoc:
     extend PackageClassMethods
 
     def initialize(schema, package, override_schema_name = nil)
@@ -39,12 +39,12 @@ module PLSQL
 
     private
     
-    def method_missing(method, *args)
+    def method_missing(method, *args, &block)
       if procedure = @procedures[method]
-        procedure.exec(*args)
+        procedure.exec(*args, &block)
       elsif procedure = Procedure.find(@schema, method, @package, @override_schema_name)
         @procedures[method] = procedure
-        procedure.exec(*args)
+        procedure.exec(*args, &block)
       else
         raise ArgumentError, "No PL/SQL procedure found"
       end

data/lib/plsql/procedure.rb

@@ -1,6 +1,6 @@
 module PLSQL
 
-  module ProcedureClassMethods
+  module ProcedureClassMethods #:nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if schema.select_first("
@@ -38,9 +38,12 @@ module PLSQL
     end
   end
 
-  class Procedure
+  class Procedure #:nodoc:
     extend ProcedureClassMethods
 
+    attr_reader :arguments, :argument_list, :out_list, :return
+    attr_reader :schema, :schema_name, :package, :procedure
+
     def initialize(schema, procedure, package = nil, override_schema_name = nil)
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
@@ -51,6 +54,10 @@ module PLSQL
       @out_list = {}
       @return = {}
       @overloaded = false
+
+      # store reference to previous level record or collection metadata
+      previous_level_argument_metadata = {}
+
       # RSI: due to 10gR2 all_arguments performance issue SELECT split into two statements
       # added condition to ensure that if object is package then package specification not body is selected
       object_id = @schema.connection.select_first("
@@ -62,41 +69,68 @@ module PLSQL
         ", @schema_name, @package ? @package : @procedure
       )[0] rescue nil
       num_rows = @schema.connection.select_all("
-        SELECT a.argument_name, a.position, a.data_type, a.in_out, a.data_length, a.data_precision, a.data_scale, a.overload
-        FROM all_arguments a
-        WHERE a.object_id = :object_id
-        AND a.owner = :owner
-        AND a.object_name = :procedure_name
-        AND NVL(a.package_name,'nil') = :package
+        SELECT overload, argument_name, position, data_level,
+              data_type, in_out, data_length, data_precision, data_scale, char_used,
+              type_owner, type_name, type_subname
+        FROM all_arguments
+        WHERE object_id = :object_id
+        AND owner = :owner
+        AND object_name = :procedure_name
+        AND NVL(package_name,'nil') = :package
+        ORDER BY overload, sequence
         ", object_id, @schema_name, @procedure, @package ? @package : 'nil'
       ) do |r|
 
-        argument_name, position, data_type, in_out, data_length, data_precision, data_scale, overload = r
+        overload, argument_name, position, data_level,
+            data_type, in_out, data_length, data_precision, data_scale, char_used,
+            type_owner, type_name, type_subname = r
 
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
         overload ||= 0
         @arguments[overload] ||= {}
         @return[overload] ||= nil
-        
+
+        raise ArgumentError, "Parameter type definition inside package is not supported, use CREATE TYPE outside package" if type_subname
+
+        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,
+          :type_owner => type_owner,
+          :type_name => type_name,
+          :type_subname => type_subname,
+          :sql_type_name => "#{type_owner}.#{type_name}"
+        }
+        if composite_type?(data_type)
+          case data_type
+          when 'PL/SQL RECORD'
+            argument_metadata[:fields] = {}
+          end
+          previous_level_argument_metadata[data_level] = argument_metadata
+        end
+
+        # if parameter
         if argument_name
-          @arguments[overload][argument_name.downcase.to_sym] = {
-            :position => position,
-            :data_type => data_type,
-            :in_out => in_out,
-            :data_length => data_length,
-            :data_precision => data_precision,
-            :data_scale => data_scale
-          }
+          # top level parameter
+          if data_level == 0
+            @arguments[overload][argument_name.downcase.to_sym] = argument_metadata
+          # or lower level part of composite type
+          else
+            case previous_level_argument_metadata[data_level - 1][:data_type]
+            when 'PL/SQL RECORD'
+              previous_level_argument_metadata[data_level - 1][:fields][argument_name.downcase.to_sym] = argument_metadata
+            when 'TABLE', 'VARRAY'
+              previous_level_argument_metadata[data_level - 1][:element] = argument_metadata
+            end
+          end
         # if function has return value
-        elsif position == 0 && in_out == 'OUT'
-          @return[overload] = {
-            :data_type => data_type,
-            :in_out => in_out,
-            :data_length => data_length,
-            :data_precision => data_precision,
-            :data_scale => data_scale
-          }
+        elsif argument_name.nil? && data_level == 0 && in_out == 'OUT'
+          @return[overload] = argument_metadata
         end
       end
       # if procedure is without arguments then create default empty argument list for default overload
@@ -108,118 +142,19 @@ module PLSQL
         @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] =~ /OUT/}
       end
     end
-    
+
+    PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'TABLE', 'VARRAY'].freeze
+    def composite_type?(data_type)
+      PLSQL_COMPOSITE_TYPES.include? data_type
+    end
+
     def overloaded?
       @overloaded
     end
 
-    def exec(*args)
-      # find which overloaded definition to use
-      # if definition is overloaded then match by number of arguments
-      if @overloaded
-        # named arguments
-        if args.size == 1 && args[0].is_a?(Hash)
-          number_of_args = args[0].keys.size
-          overload = @argument_list.keys.detect do |ov|
-            @argument_list[ov].size == number_of_args &&
-            @arguments[ov].keys.sort_by{|k| k.to_s} == args[0].keys.sort_by{|k| k.to_s}
-          end
-        # sequential arguments
-        # TODO: should try to implement matching by types of arguments
-        else
-          number_of_args = args.size
-          overload = @argument_list.keys.detect do |ov|
-            @argument_list[ov].size == number_of_args
-          end
-        end
-        raise ArgumentError, "Wrong number of arguments passed to overloaded PL/SQL procedure" unless overload
-      else
-        overload = 0
-      end
-
-      sql = "BEGIN\n"
-      sql << ":return := " if @return[overload]
-      sql << "#{@schema_name}." if @schema_name
-      sql << "#{@package}." if @package
-      sql << "#{@procedure}("
-
-      # Named arguments
-      args_list = []
-      args_hash = {}
-      if args.size == 1 and args[0].is_a?(Hash)
-        sql << args[0].map do |k,v|
-          raise ArgumentError, "Wrong argument passed to PL/SQL procedure" unless @arguments[overload][k]
-          args_list << k
-          args_hash[k] = v
-          "#{k.to_s} => :#{k.to_s}"
-        end.join(', ')
-      # Sequential arguments
-      else
-        raise ArgumentError, "Too many arguments passed to PL/SQL procedure" if args.size > @argument_list[overload].size
-        # Add missing arguments with nil value
-        args = args + [nil]*(@argument_list[overload].size-args.size) if args.size < @argument_list[overload].size
-        i = 0
-        sql << args.map do |v|
-          k = @argument_list[overload][i]
-          i += 1
-          args_list << k
-          args_hash[k] = v
-          ":#{k.to_s}"
-        end.join(', ')
-      end
-      sql << ");\n"
-      sql << "END;\n"
-
-      cursor = @schema.connection.parse(sql)
-      
-      args_list.each do |k|
-        data_type, data_length = plsql_to_ruby_data_type(@arguments[overload][k])
-        cursor.bind_param(":#{k.to_s}", ruby_value_to_ora_value(args_hash[k], data_type),
-                                        data_type, data_length, @arguments[overload][k][:in_out])
-      end
-      
-      if @return[overload]
-        data_type, data_length = plsql_to_ruby_data_type(@return[overload])
-        cursor.bind_param(":return", nil, data_type, data_length, 'OUT')
-      end
-      
-      cursor.exec
-
-      # if function with output parameters
-      if @return[overload] && @out_list[overload].size > 0
-        result = [ora_value_to_ruby_value(cursor[':return']), {}]
-        @out_list[overload].each do |k|
-          result[1][k] = ora_value_to_ruby_value(cursor[":#{k}"])
-        end
-      # if function without output parameters
-      elsif @return[overload]
-        result = ora_value_to_ruby_value(cursor[':return'])
-      # if procedure with output parameters
-      elsif @out_list[overload].size > 0
-        result = {}
-        @out_list[overload].each do |k|
-          result[k] = ora_value_to_ruby_value(cursor[":#{k}"])
-        end
-      # if procedure without output parameters
-      else
-        result = nil
-      end
-      cursor.close
-      result
-    end
-    
-    private
-    
-    def plsql_to_ruby_data_type(argument)
-      @schema.connection.plsql_to_ruby_data_type(argument[:data_type],argument[:data_length])
-    end
-    
-    def ruby_value_to_ora_value(val, type)
-      @schema.connection.ruby_value_to_ora_value(val, type)
-    end
-    
-    def ora_value_to_ruby_value(val)
-      @schema.connection.ora_value_to_ruby_value(val)
+    def exec(*args, &block)
+      call = ProcedureCall.new(self, args)
+      call.exec(&block)
     end
 
   end