ruby-plsql 0.4.0 → 0.4.1

data/History.txt

@@ -1,3 +1,22 @@
+== 0.4.1 2010-01-04
+
+* New features
+  * Call procedures from SYS.STANDARD without schema and package prefix
+  * DBMS_OUTPUT logging to specified IO stream (e.g. plsql.dbms_output_stream = STDOUT)
+  * Support table operations also on views
+  * Specify plsql.connection.prefetch_rows= to reduce network round trips when selecting large number of rows
+  * Support for PLS_INTEGER and BINARY_INTEGER parameters and return values
+  * Access to package variables (basic types, object types, %TYPE and %ROWTYPE)
+  * Table insert_values method
+  * Insert partial list of table column values (and use default values for missing columns)
+* Improvements
+  * Improved performance of table and synonyms metadata select
+  * Check required ruby-oci8 version
+* Bug fixes
+  * limit object types when selecting from all_objects to avoid getting irrelevant records with the same name
+  * select where condition :column => nil is transformed to "column IS NULL"
+  * TIMESTAMP fractional seconds patch for ruby-oci8 2.0.3
+
 == 0.4.0 2009-11-23
 
 * New features

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Raimonds Simanovskis
+Copyright (c) 2008-2010 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -6,9 +6,9 @@ Ruby API for calling Oracle PL/SQL procedures.
 
 ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures. It could be used both for accessing Oracle PL/SQL API procedures in legacy applications as well as it could be used to create PL/SQL unit tests using Ruby testing libraries.
 
-NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB, BOOLEAN, PL/SQL RECORD, TABLE, VARRAY, OBJECT and CURSOR types are supported for input and output parameters and return values of PL/SQL procedures and functions.
+NUMBER, BINARY_INTEGER, PLS_INTEGER, VARCHAR2, NVARCHAR2, CHAR, NCHAR, DATE, TIMESTAMP, CLOB, BLOB, BOOLEAN, PL/SQL RECORD, TABLE, VARRAY, OBJECT and CURSOR types are supported for input and output parameters and return values of PL/SQL procedures and functions.
 
-ruby-plsql support both Ruby 1.8 MRI, Ruby 1.9.1 YARV and JRuby 1.3/1.4 runtime environments.
+ruby-plsql supports both Ruby 1.8 MRI, Ruby 1.9.1 YARV and JRuby 1.3/1.4 runtime environments.
 
 == USAGE
 
@@ -36,7 +36,7 @@ ruby-plsql support both Ruby 1.8 MRI, Ruby 1.9.1 YARV and JRuby 1.3/1.4 runtime
 
   # Nested objects or arrays are also supported
   p_employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31),
-    :address => {:street => 'Street', :city => 'City', :country => 'Country},
+    :address => {:street => 'Street', :city => 'City', :country => 'Country'},
     :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'fixed', :phone_number => '654321'}]}
   plsql.test_store_employee(p_employee)
 
@@ -67,6 +67,11 @@ ruby-plsql also provides simple API for select/insert/update/delete table operat
   employees = [employee1, employee2, ... ]  # array of many Hashes
   plsql.employees.insert employees
 
+  # insert many records as list of values
+  plsql.employees.insert_values [:employee_id, :first_name, :last_name],
+    [1, 'First 1', 'Last 1'],
+    [2, 'First 2', 'Last 2']
+
   # select one record
   plsql.employees.first                     # SELECT * FROM employees
                                             # fetch first row => {:employee_id => ..., :first_name => '...', ...}
@@ -131,7 +136,7 @@ In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver t
 
 (The MIT License)
 
-Copyright (c) 2009 Raimonds Simanovskis
+Copyright (c) 2008-2010 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/plsql/connection.rb

@@ -65,22 +65,28 @@ module PLSQL
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
+    # Set number of rows to be prefetched. This can reduce the number of network round trips when fetching many rows.
+    # The default value is one. (If ActiveRecord oracle_enhanced connection is used then default is 100)
+    def prefetch_rows=(value)
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
     def select_first(sql, *bindvars) #:nodoc:
-      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor = cursor_from_query(sql, bindvars, :prefetch_rows => 1)
       cursor.fetch
     ensure
       cursor.close rescue nil
     end
 
     def select_hash_first(sql, *bindvars) #:nodoc:
-      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor = cursor_from_query(sql, bindvars, :prefetch_rows => 1)
       cursor.fetch_hash
     ensure
       cursor.close rescue nil
     end
 
     def select_all(sql, *bindvars, &block) #:nodoc:
-      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
       while row = cursor.fetch
@@ -97,7 +103,7 @@ module PLSQL
     end
 
     def select_hash_all(sql, *bindvars, &block) #:nodoc:
-      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
       while row = cursor.fetch_hash
@@ -121,10 +127,6 @@ module PLSQL
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def arrays_to_hash(keys, values) #:nodoc:
-      (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
-    end
-
     module CursorCommon
       # Fetch all rows from cursor, each row as array of values
       def fetch_all
@@ -146,10 +148,23 @@ module PLSQL
 
       # Fetch row from cursor as hash {:column => value, ...}
       def fetch_hash
-        (row = fetch) && @connection.arrays_to_hash(fields, row)
+        (row = fetch) && ArrayHelpers::to_hash(fields, row)
       end
     end
 
+    # all_synonyms view is quite slow therefore
+    # this implementation is overriden in OCI connection with faster native OCI method
+    def describe_synonym(schema_name, synonym_name) #:nodoc:
+      select_first(
+      "SELECT table_owner, table_name FROM all_synonyms WHERE owner = :owner AND synonym_name = :synonym_name",
+        schema_name.to_s.upcase, synonym_name.to_s.upcase)
+    end
+
+    # Returns array with major and minor version of database (e.g. [10, 2])
+    def database_version
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
   end
 
 end

data/lib/plsql/helpers.rb

@@ -0,0 +1,9 @@
+module PLSQL #:nodoc:
+  module ArrayHelpers #:nodoc:
+
+    def self.to_hash(keys, values) #:nodoc:
+      (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
+    end
+
+  end
+end

data/lib/plsql/jdbc_connection.rb

@@ -54,6 +54,10 @@ module PLSQL
       raw_connection.setAutoCommit(value)
     end
 
+    def prefetch_rows=(value)
+      raw_connection.setDefaultRowPrefetch(value)
+    end
+
     def exec(sql, *bindvars)
       cs = prepare_call(sql, *bindvars)
       cs.execute
@@ -127,8 +131,11 @@ module PLSQL
         end
       end
 
-      def self.new_from_query(conn, sql, *bindvars)
+      def self.new_from_query(conn, sql, bindvars=[], options={})
         stmt = conn.prepare_statement(sql, *bindvars)
+        if prefetch_rows = options[:prefetch_rows]
+          stmt.setRowPrefetch(prefetch_rows)
+        end
         cursor = Cursor.new(conn, stmt.executeQuery)
         cursor.statement = stmt
         cursor
@@ -164,8 +171,8 @@ module PLSQL
       CallableStatement.new(self, sql)
     end
 
-    def cursor_from_query(sql, *bindvars)
-      Cursor.new_from_query(sql, *bindvars)
+    def cursor_from_query(sql, bindvars=[], options={})
+      Cursor.new_from_query(self, sql, bindvars, options)
     end
 
     def prepare_statement(sql, *bindvars)
@@ -194,7 +201,7 @@ module PLSQL
       Java::OracleSql::CLOB => Java::oracle.jdbc.OracleTypes::CLOB,
       Java::OracleSql::BLOB => Java::oracle.jdbc.OracleTypes::BLOB,
       Date => java.sql.Types::DATE,
-      Time => java.sql.Types::DATE,
+      Time => java.sql.Types::TIMESTAMP,
       DateTime => java.sql.Types::DATE,
       Java::OracleSql::ARRAY => Java::oracle.jdbc.OracleTypes::ARRAY,
       Array => Java::oracle.jdbc.OracleTypes::ARRAY,
@@ -207,6 +214,7 @@ module PLSQL
       java.sql.Types::CHAR => String,
       java.sql.Types::VARCHAR => String,
       java.sql.Types::NUMERIC => BigDecimal,
+      java.sql.Types::INTEGER => Fixnum,
       java.sql.Types::DATE => Time,
       java.sql.Types::TIMESTAMP => Time,
       Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ => Time,
@@ -238,8 +246,10 @@ module PLSQL
         stmt.send("setClob#{key && "AtName"}", key || i, value)
       when :'Java::OracleSql::BLOB'
         stmt.send("setBlob#{key && "AtName"}", key || i, value)
-      when :Date, :Time, :DateTime, :'Java::OracleSql::DATE'
+      when :Date, :DateTime, :'Java::OracleSql::DATE'
         stmt.send("setDATE#{key && "AtName"}", key || i, value)
+      when :Time, :'Java::JavaSql::Timestamp'
+        stmt.send("setTimestamp#{key && "AtName"}", key || i, value)
       when :NilClass
         if ['TABLE', 'VARRAY', 'OBJECT'].include?(metadata[:data_type])
           stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type),
@@ -280,8 +290,10 @@ module PLSQL
         stmt.getClob(i)
       when :'Java::OracleSql::BLOB'
         stmt.getBlob(i)
-      when :Date, :Time, :DateTime
+      when :Date, :DateTime
         stmt.getDATE(i)
+      when :Time
+        stmt.getTimestamp(i)
       when :'Java::OracleSql::ARRAY'
         stmt.getArray(i)
       when :'Java::OracleSql::STRUCT'
@@ -312,8 +324,10 @@ module PLSQL
         [Java::OracleSql::BLOB, nil]
       when "NUMBER"
         [BigDecimal, nil]
+      when "PLS_INTEGER", "BINARY_INTEGER"
+        [Fixnum, nil]
       when "DATE"
-        [Time, nil]
+        [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
       when "TABLE", "VARRAY"
@@ -341,7 +355,7 @@ module PLSQL
         else
           java_bigdecimal(value)
         end
-      when :Time, :Date, :DateTime
+      when :Date, :DateTime
         case value
         when DateTime
           java_date(Time.send(plsql.default_timezone, value.year, value.month, value.day, value.hour, value.min, value.sec))
@@ -350,6 +364,8 @@ module PLSQL
         else
           java_date(value)
         end
+      when :Time
+        java_timestamp(value)
       when :'Java::OracleSql::CLOB'
         if value
           clob = Java::OracleSql::CLOB.createTemporary(raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
@@ -431,6 +447,11 @@ module PLSQL
           t = value.timeValue
           Time.send(plsql.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
         end
+      when Java::JavaSql::Timestamp
+        if value
+          Time.send(plsql.default_timezone, value.year + 1900, value.month + 1, value.date, value.hours, value.minutes, value.seconds,
+            value.nanos / 1000)
+        end
       when Java::OracleSql::CLOB
         if value.isEmptyLob
           nil
@@ -450,7 +471,7 @@ module PLSQL
         struct_metadata = descriptor.getMetaData
         field_names = (1..descriptor.getLength).map {|i| struct_metadata.getColumnName(i).downcase.to_sym}
         field_values = value.getAttributes.map{|e| ora_value_to_ruby_value(e)}
-        arrays_to_hash(field_names, field_values)
+        ArrayHelpers::to_hash(field_names, field_values)
       when Java::java.sql.ResultSet
         Cursor.new(self, value)
       else
@@ -458,12 +479,20 @@ module PLSQL
       end
     end
 
+    def database_version
+      @database_version ||= (md = raw_connection.getMetaData) && [md.getDatabaseMajorVersion, md.getDatabaseMinorVersion]
+    end
+
     private
     
     def java_date(value)
       value && Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
     end
 
+    def java_timestamp(value)
+      value && Java::java.sql.Timestamp.new(value.year-1900, value.month-1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
+    end
+
     def java_bigdecimal(value)
       value && java.math.BigDecimal.new(value.to_s)
     end

data/lib/plsql/oci8_patches.rb

@@ -0,0 +1,25 @@
+# apply TIMESTAMP fractional seconds patch to ruby-oci8 2.0.3
+# see http://rubyforge.org/forum/forum.php?thread_id=46576&forum_id=1078
+if OCI8::VERSION == "2.0.3" &&
+  !OCI8::BindType::Util.method_defined?(:datetime_to_array_without_timestamp_patch)
+
+  OCI8::BindType::Util.module_eval do
+    alias :datetime_to_array_without_timestamp_patch :datetime_to_array
+    def datetime_to_array(val, full)
+      result = datetime_to_array_without_timestamp_patch(val, full)
+      if result && result[6] == 0
+        if val.respond_to? :nsec
+          fsec = val.nsec
+        elsif val.respond_to? :usec
+          fsec = val.usec * 1000
+        else
+          fsec = 0
+        end
+        result[6] = fsec
+      end
+      result
+    end
+    private :datetime_to_array_without_timestamp_patch, :datetime_to_array
+  end
+  
+end

data/lib/plsql/oci_connection.rb

@@ -2,10 +2,16 @@ 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
+  raise LoadError, "ERROR: ruby-plsql could not load ruby-oci8 library. Please install ruby-oci8 gem."
+end
+
+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}
+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
@@ -31,6 +37,10 @@ module PLSQL
       raw_connection.autocommit = value
     end
 
+    def prefetch_rows=(value)
+      raw_connection.prefetch_rows = value
+    end
+
     def exec(sql, *bindvars)
       raw_connection.exec(sql, *bindvars)
       true
@@ -54,8 +64,17 @@ module PLSQL
         self.new(conn, raw_cursor)
       end
 
-      def self.new_from_query(conn, sql, *bindvars)
-        Cursor.new(conn, conn.raw_connection.exec(sql, *bindvars))
+      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
+        end
+        cursor.exec(*bindvars)
+        cursor
+      end
+
+      def prefetch_rows=(value)
+        @raw_cursor.prefetch_rows = value
       end
 
       def bind_param(arg, value, metadata)
@@ -99,24 +118,24 @@ module PLSQL
       Cursor.new_from_parse(self, sql)
     end
 
-    def cursor_from_query(sql, *bindvars)
-      Cursor.new_from_query(sql, *bindvars)
+    def cursor_from_query(sql, bindvars=[], options={})
+      Cursor.new_from_query(self, sql, bindvars, options)
     end
 
     def plsql_to_ruby_data_type(metadata)
       data_type, data_length = metadata[:data_type], metadata[:data_length]
       case data_type
-      when "VARCHAR2"
+      when "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
         [String, data_length || 32767]
-      when "CLOB"
+      when "CLOB", "NCLOB"
         [OCI8::CLOB, nil]
       when "BLOB"
         [OCI8::BLOB, nil]
-      when "NUMBER"
+      when "NUMBER", "PLS_INTEGER", "BINARY_INTEGER"
         [OraNumber, nil]
       when "DATE"
         [DateTime, nil]
-      when "TIMESTAMP"
+      when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
       when "TABLE", "VARRAY", "OBJECT"
         # create Ruby class for collection
@@ -240,6 +259,21 @@ 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) && [version.major, version.minor]
+    end
 
     private
     

data/lib/plsql/package.rb

@@ -2,16 +2,16 @@ module PLSQL
 
   module PackageClassMethods #:nodoc:
     def find(schema, package)
-      if schema.select_first("
-            SELECT object_name FROM all_objects
+      if schema.select_first(
+            "SELECT object_name FROM all_objects
             WHERE owner = :owner
               AND object_name = :package
               AND object_type = 'PACKAGE'",
             schema.schema_name, package.to_s.upcase)
         new(schema, package)
       # search for synonym
-      elsif (row = schema.select_first("
-            SELECT o.owner, o.object_name
+      elsif (row = schema.select_first(
+            "SELECT o.owner, o.object_name
             FROM all_synonyms s, all_objects o
             WHERE s.owner IN (:owner, 'PUBLIC')
               AND s.synonym_name = :synonym_name
@@ -34,22 +34,35 @@ module PLSQL
       @schema = schema
       @override_schema_name = override_schema_name
       @package = package.to_s.upcase
-      @procedures = {}
+      @package_objects = {}
     end
 
     private
     
     def method_missing(method, *args, &block)
-      if procedure = @procedures[method]
-        procedure.exec(*args, &block)
-      elsif procedure = Procedure.find(@schema, method, @package, @override_schema_name)
-        @procedures[method] = procedure
-        procedure.exec(*args, &block)
+      if assignment = (method.to_s[-1,1] == '=')
+        method = method.to_s.chop.to_sym
+      end
+      object = (@package_objects[method] ||=
+        Procedure.find(@schema, method, @package, @override_schema_name) ||
+        Variable.find(@schema, method, @package, @override_schema_name))
+      case object
+      when Procedure
+        raise ArgumentError, "Cannot assign value to package procedure '#{method.to_s.upcase}'" if assignment
+        object.exec(*args, &block)
+      when Variable
+        if assignment
+          raise ArgumentError, "Just one value can be assigned to package variable '#{method.to_s.upcase}'" unless args.size == 1 && block == nil
+          object.value = args[0]
+        else
+          raise ArgumentError, "Cannot pass arguments when getting package variable '#{method.to_s.upcase}' value" unless args.size == 0 && block == nil
+          object.value
+        end
       else
-        raise ArgumentError, "No PL/SQL procedure found"
+        raise ArgumentError, "No PL/SQL procedure or variable '#{method.to_s.upcase}' found"
       end
     end
-    
+
   end
 
 end