ruby-plsql 0.5.3 → 0.8.0

data/lib/plsql/connection.rb

@@ -25,20 +25,20 @@ module PLSQL
 
     def self.create_new(params) #:nodoc:
       conn = case driver_type
-      when :oci
-        OCIConnection.create_raw(params)
-      when :jdbc
-        JDBCConnection.create_raw(params)
-      else
-        raise ArgumentError, "Unknown raw driver"
+             when :oci
+               OCIConnection.create_raw(params)
+             when :jdbc
+               JDBCConnection.create_raw(params)
+             else
+               raise ArgumentError, "Unknown raw driver"
       end
-      conn.set_time_zone(params[:time_zone])
+      conn.set_time_zone(params[:time_zone] || ENV["ORA_SDTZ"])
       conn
     end
 
     def self.driver_type #:nodoc:
-      # MRI 1.8.6 or YARV 1.9.1
-      @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") && defined?(OCI8)
+      # MRI 1.8.6 or YARV 1.9.1 or TruffleRuby
+      @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby") && defined?(OCI8)
         :oci
       # JRuby
       elsif (defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby")
@@ -66,7 +66,7 @@ module PLSQL
     def jdbc?
       @raw_driver == :jdbc
     end
-    
+
     def logoff #:nodoc:
       # Rollback any uncommited transactions
       rollback
@@ -99,14 +99,14 @@ module PLSQL
     end
 
     def select_first(sql, *bindvars) #:nodoc:
-      cursor = cursor_from_query(sql, bindvars, :prefetch_rows => 1)
+      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(sql, bindvars, :prefetch_rows => 1)
+      cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch_hash
     ensure
       cursor.close rescue nil
@@ -183,7 +183,7 @@ module PLSQL
     # 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",
+        "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
 
@@ -197,9 +197,8 @@ module PLSQL
       @session_id ||= select_first("SELECT TO_NUMBER(USERENV('SESSIONID')) FROM dual")[0]
     end
 
-    # Set time zone (default taken from TZ environment variable)
-    def set_time_zone(time_zone=nil)
-      time_zone ||= ENV['TZ']
+    # Set time zone
+    def set_time_zone(time_zone = nil)
       exec("alter session set time_zone = '#{time_zone}'") if time_zone
     end
 
@@ -208,12 +207,12 @@ module PLSQL
       select_first("SELECT SESSIONTIMEZONE FROM dual")[0]
     end
 
-    RUBY_TEMP_TABLE_PREFIX = 'ruby_'
+    RUBY_TEMP_TABLE_PREFIX = "ruby_"
 
     # Drop all ruby temporary tables that are used for calling packages with table parameter types defined in packages
     def drop_all_ruby_temporary_tables
       select_all("SELECT table_name FROM user_tables WHERE temporary='Y' AND table_name LIKE :table_name",
-                  RUBY_TEMP_TABLE_PREFIX.upcase+'%').each do |row|
+                  RUBY_TEMP_TABLE_PREFIX.upcase + "%").each do |row|
         exec "TRUNCATE TABLE #{row[0]}"
         exec "DROP TABLE #{row[0]}"
       end
@@ -222,12 +221,10 @@ module PLSQL
     # Drop ruby temporary tables created in current session that are used for calling packages with table parameter types defined in packages
     def drop_session_ruby_temporary_tables
       select_all("SELECT table_name FROM user_tables WHERE temporary='Y' AND table_name LIKE :table_name",
-                  RUBY_TEMP_TABLE_PREFIX.upcase+"#{session_id}_%").each do |row|
+                  RUBY_TEMP_TABLE_PREFIX.upcase + "#{session_id}_%").each do |row|
         exec "TRUNCATE TABLE #{row[0]}"
         exec "DROP TABLE #{row[0]}"
       end
     end
-
   end
-
-end
+end

data/lib/plsql/helpers.rb

@@ -1,9 +1,7 @@
 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
+end

data/lib/plsql/jdbc_connection.rb

@@ -5,21 +5,31 @@ begin
   # ojdbc6.jar or ojdbc5.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
 
   java_version = java.lang.System.getProperty("java.version")
-  ojdbc_jar = if java_version =~ /^1.5/
-    "ojdbc5.jar"
-  elsif java_version >= '1.6'
-    "ojdbc6.jar"
+  ojdbc_jars = if java_version =~ /^1.5/
+    %w(ojdbc5.jar)
+  elsif java_version =~ /^1.6/
+    %w(ojdbc6.jar)
+  elsif java_version >= "1.7"
+    # Oracle 11g client ojdbc6.jar is also compatible with Java 1.7
+    # Oracle 12c client provides new ojdbc7.jar
+    %w(ojdbc7.jar ojdbc6.jar)
   else
-    nil
+    []
   end
 
-  unless ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+  if ENV_JAVA["java.class.path"] !~ Regexp.new(ojdbc_jars.join("|"))
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
-    env_path = (ENV["PATH"] || ENV["Path"] || '').split(/[:;]/)
+    env_path = (ENV["PATH"] || ENV["Path"] || "").split(File::PATH_SEPARATOR)
     # Look for JDBC driver at first in lib subdirectory (application specific JDBC file version)
     # then in Ruby load path and finally in environment PATH
-    if ojdbc_jar_path = ['./lib'].concat($LOAD_PATH).concat(env_path).find{|d| File.exists?(File.join(d,ojdbc_jar))}
-      require File.join(ojdbc_jar_path,ojdbc_jar)
+    ["./lib"].concat($LOAD_PATH).concat(env_path).detect do |dir|
+      # check any compatible JDBC driver in the priority order
+      ojdbc_jars.any? do |ojdbc_jar|
+        if File.exists?(file_path = File.join(dir, ojdbc_jar))
+          require file_path
+          true
+        end
+      end
     end
   end
 
@@ -32,15 +42,14 @@ begin
 
 rescue LoadError, NameError
   # JDBC driver is unavailable.
-  raise LoadError, "ERROR: ruby-plsql could not load Oracle JDBC driver. Please install #{ojdbc_jar || "Oracle JDBC"} library."
+  raise LoadError, "ERROR: ruby-plsql could not load Oracle JDBC driver. Please install #{ojdbc_jars.empty? ? "Oracle JDBC" : ojdbc_jars.join(' or ') } library."
 end
 
 module PLSQL
   class JDBCConnection < Connection  #:nodoc:
-
     def self.create_raw(params)
       database = params[:database]
-      url = if ENV['TNS_ADMIN'] && database && !params[:host] && !params[:url]
+      url = if ENV["TNS_ADMIN"] && database && !params[:host] && !params[:url]
         "jdbc:oracle:thin:@#{database}"
       else
         database = ":#{database}" unless database.match(/^(\:|\/)/)
@@ -49,9 +58,8 @@ module PLSQL
       new(java.sql.DriverManager.getConnection(url, params[:username], params[:password]))
     end
 
-    def set_time_zone(time_zone=nil)
-      time_zone ||= ENV['TZ']
-      raw_connection.setSessionTimeZone(time_zone)
+    def set_time_zone(time_zone = nil)
+      raw_connection.setSessionTimeZone(time_zone) if time_zone
     end
 
     def logoff
@@ -91,7 +99,6 @@ module PLSQL
     end
 
     class CallableStatement #:nodoc:
-
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -108,11 +115,11 @@ module PLSQL
         if metadata[:in_out] =~ /OUT/
           @out_types[arg] = type || ora_value.class
           @out_index[arg] = bind_param_index(arg)
-          if ['TABLE','VARRAY','OBJECT'].include?(metadata[:data_type])
-            @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value,type),
+          if ["TABLE", "VARRAY", "OBJECT", "XMLTYPE"].include?(metadata[:data_type])
+            @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value, type),
               metadata[:sql_type_name])
           else
-            @statement.registerOutParameter(@out_index[arg],@connection.get_java_sql_type(ora_value,type))
+            @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value, type))
           end
         end
       end
@@ -131,11 +138,11 @@ module PLSQL
 
       private
 
-      def bind_param_index(key)
-        return key if key.kind_of? Integer
-        key = ":#{key.to_s}" unless key.to_s =~ /^:/
-        @params.index(key)+1
-      end
+        def bind_param_index(key)
+          return key if key.kind_of? Integer
+          key = ":#{key.to_s}" unless key.to_s =~ /^:/
+          @params.index(key) + 1
+        end
     end
 
     class Cursor #:nodoc:
@@ -151,11 +158,11 @@ module PLSQL
         @column_count = @metadata.getColumnCount
         @column_type_names = [nil] # column numbering starts at 1
         (1..@column_count).each do |i|
-          @column_type_names << {:type_name => @metadata.getColumnTypeName(i), :sql_type => @metadata.getColumnType(i)}
+          @column_type_names << { type_name: @metadata.getColumnTypeName(i), sql_type: @metadata.getColumnType(i) }
         end
       end
 
-      def self.new_from_query(conn, sql, bindvars=[], options={})
+      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)
@@ -195,14 +202,14 @@ module PLSQL
       CallableStatement.new(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
 
     def prepare_statement(sql, *bindvars)
       stmt = raw_connection.prepareStatement(sql)
       bindvars.each_with_index do |bv, i|
-        set_bind_variable(stmt, i+1, ruby_value_to_ora_value(bv))
+        set_bind_variable(stmt, i + 1, ruby_value_to_ora_value(bv))
       end
       stmt
     end
@@ -210,14 +217,12 @@ module PLSQL
     def prepare_call(sql, *bindvars)
       stmt = raw_connection.prepareCall(sql)
       bindvars.each_with_index do |bv, i|
-        set_bind_variable(stmt, i+1, bv)
+        set_bind_variable(stmt, i + 1, bv)
       end
       stmt
     end
 
     RUBY_CLASS_TO_SQL_TYPE = {
-      Fixnum => java.sql.Types::INTEGER,
-      Bignum => java.sql.Types::INTEGER,
       Integer => java.sql.Types::INTEGER,
       Float => java.sql.Types::FLOAT,
       BigDecimal => java.sql.Types::NUMERIC,
@@ -241,7 +246,7 @@ module PLSQL
       java.sql.Types::NVARCHAR => String,
       java.sql.Types::LONGVARCHAR => String,
       java.sql.Types::NUMERIC => BigDecimal,
-      java.sql.Types::INTEGER => Fixnum,
+      java.sql.Types::INTEGER => Integer,
       java.sql.Types::DATE => Time,
       java.sql.Types::TIMESTAMP => Time,
       Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ => Time,
@@ -257,8 +262,8 @@ module PLSQL
       RUBY_CLASS_TO_SQL_TYPE[type || value.class] || java.sql.Types::VARCHAR
     end
 
-    def set_bind_variable(stmt, i, value, type=nil, length=nil, metadata={})
-      key = i.kind_of?(Integer) ? nil : i.to_s.gsub(':','')
+    def set_bind_variable(stmt, i, value, type = nil, length = nil, metadata = {})
+      key = i.kind_of?(Integer) ? nil : i.to_s.gsub(":", "")
       type_symbol = (!value.nil? && type ? type : value.class).to_s.to_sym
       case type_symbol
       when :Fixnum, :Bignum, :Integer
@@ -278,10 +283,10 @@ module PLSQL
       when :Time, :'Java::JavaSql::Timestamp'
         stmt.send("setTimestamp#{key && "AtName"}", key || i, value)
       when :NilClass
-        if ['TABLE', 'VARRAY', 'OBJECT'].include?(metadata[:data_type])
+        if ["TABLE", "VARRAY", "OBJECT", "XMLTYPE"].include?(metadata[:data_type])
           stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type),
             metadata[:sql_type_name])
-        elsif metadata[:data_type] == 'REF CURSOR'
+        elsif metadata[:data_type] == "REF CURSOR"
           # TODO: cannot bind NULL value to cursor parameter, getting error
           # java.sql.SQLException: Unsupported feature: sqlType=-10
           # Currently do nothing and assume that NULL values will not be passed to IN parameters
@@ -305,12 +310,12 @@ module PLSQL
     def get_bind_variable(stmt, i, type)
       case type.to_s.to_sym
       when :Fixnum, :Bignum, :Integer
-        stmt.getInt(i)
+        stmt.getObject(i)
       when :Float
         stmt.getFloat(i)
       when :BigDecimal
         bd = stmt.getBigDecimal(i)
-        bd && BigDecimal.new(bd.to_s)
+        bd && BigDecimal(bd.to_s)
       when :String
         stmt.getString(i)
       when :'Java::OracleSql::CLOB'
@@ -337,13 +342,12 @@ module PLSQL
     end
 
     def result_set_to_ruby_data_type(column_type, column_type_name)
-
     end
 
     def plsql_to_ruby_data_type(metadata)
       data_type, data_length = metadata[:data_type], metadata[:data_length]
       case data_type
-      when "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
+      when "VARCHAR", "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
         [String, data_length || 32767]
       when "CLOB", "NCLOB"
         [Java::OracleSql::CLOB, nil]
@@ -351,8 +355,8 @@ module PLSQL
         [Java::OracleSql::BLOB, nil]
       when "NUMBER"
         [BigDecimal, nil]
-      when "PLS_INTEGER", "BINARY_INTEGER"
-        [Fixnum, nil]
+      when "NATURAL", "NATURALN", "POSITIVE", "POSITIVEN", "SIGNTYPE", "SIMPLE_INTEGER", "PLS_INTEGER", "BINARY_INTEGER"
+        [Integer, nil]
       when "DATE"
         [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
@@ -368,10 +372,10 @@ module PLSQL
       end
     end
 
-    def ruby_value_to_ora_value(value, type=nil, metadata={})
+    def ruby_value_to_ora_value(value, type = nil, metadata = {})
       type ||= value.class
       case type.to_s.to_sym
-      when :Fixnum
+      when :Integer
         value
       when :String
         value.to_s
@@ -420,9 +424,9 @@ module PLSQL
           elem_list = value.map do |elem|
             case elem_type
             when Java::oracle.jdbc.OracleTypes::ARRAY
-              ruby_value_to_ora_value(elem, Java::OracleSql::ARRAY, :sql_type_name => elem_type_name)
+              ruby_value_to_ora_value(elem, Java::OracleSql::ARRAY, sql_type_name: elem_type_name)
             when Java::oracle.jdbc.OracleTypes::STRUCT
-              ruby_value_to_ora_value(elem, Java::OracleSql::STRUCT, :sql_type_name => elem_type_name)
+              ruby_value_to_ora_value(elem, Java::OracleSql::STRUCT, sql_type_name: elem_type_name)
             else
               ruby_value_to_ora_value(elem)
             end
@@ -436,7 +440,7 @@ module PLSQL
           struct_metadata = descriptor.getMetaData
           struct_fields = (1..descriptor.getLength).inject({}) do |hash, i|
             hash[struct_metadata.getColumnName(i).downcase.to_sym] =
-              {:type => struct_metadata.getColumnType(i), :type_name => struct_metadata.getColumnTypeName(i)}
+              { type: struct_metadata.getColumnType(i), type_name: struct_metadata.getColumnTypeName(i) }
             hash
           end
           object_attrs = java.util.HashMap.new
@@ -445,10 +449,10 @@ module PLSQL
             case field[:type]
             when Java::oracle.jdbc.OracleTypes::ARRAY
               # nested collection
-              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::ARRAY, :sql_type_name => field[:type_name]))
+              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::ARRAY, sql_type_name: field[:type_name]))
             when Java::oracle.jdbc.OracleTypes::STRUCT
               # nested object type
-              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::STRUCT, :sql_type_name => field[:type_name]))
+              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::STRUCT, sql_type_name: field[:type_name]))
             else
               object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value))
             end
@@ -469,7 +473,7 @@ module PLSQL
       when Float, BigDecimal
         ora_number_to_ruby_number(value)
       when Java::JavaMath::BigDecimal
-        value && ora_number_to_ruby_number(BigDecimal.new(value.to_s))
+        value && ora_number_to_ruby_number(BigDecimal(value.to_s))
       when Java::OracleSql::DATE
         if value
           d = value.dateValue
@@ -494,12 +498,12 @@ module PLSQL
           String.from_java_bytes(value.getBytes(1, value.length))
         end
       when Java::OracleSql::ARRAY
-        value.getArray.map{|e| ora_value_to_ruby_value(e)}
+        value.getArray.map { |e| ora_value_to_ruby_value(e) }
       when Java::OracleSql::STRUCT
         descriptor = value.getDescriptor
         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)}
+        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) }
         ArrayHelpers::to_hash(field_names, field_values)
       when Java::java.sql.ResultSet
         Cursor.new(self, value)
@@ -524,23 +528,21 @@ module PLSQL
 
     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_date(value)
+        value && Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
+      end
 
-    def java_bigdecimal(value)
-      value && java.math.BigDecimal.new(value.to_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 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 java_bigdecimal(value)
+        value && java.math.BigDecimal.new(value.to_s)
+      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
   end
-
 end

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