ruby-plsql 0.6.0 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/Vagrantfile

@@ -25,11 +25,11 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
   config.vm.provision :shell, inline: "mkdir -p /opt/oracle"
   config.vm.provision :shell, inline: "unzip -o -q -d /opt/oracle /vagrant/oracle-xe-11.2.0-1.0.x86_64.rpm.zip"
   config.vm.provision :shell, inline: "cd /opt/oracle/Disk1 && rpm -ivh oracle-xe-11.2.0-1.0.x86_64.rpm"
-  config.vm.provision :shell, inline: %q{sed -i -E "s/<value required>/oracle/" /opt/oracle/Disk1/response/xe.rsp}
+  config.vm.provision :shell, inline: 'sed -i -E "s/<value required>/oracle/" /opt/oracle/Disk1/response/xe.rsp'
   config.vm.provision :shell, inline: "/etc/init.d/oracle-xe configure responseFile=/opt/oracle/Disk1/response/xe.rsp >> /opt/oracle/XEsilentinstall.log"
   config.vm.provision :shell, inline: ". /u01/app/oracle/product/11.2.0/xe/bin/oracle_env.sh"
   config.vm.provision :shell, inline: "touch /etc/profile.d/oracle_profile.sh && cat /u01/app/oracle/product/11.2.0/xe/bin/oracle_env.sh >> /etc/profile.d/oracle_profile.sh"
-  config.vm.provision :shell, inline: %q{sed -i -E "s/HOST = [^)]+/HOST = $HOSTNAME/g" /u01/app/oracle/product/11.2.0/xe/network/admin/listener.ora}
+  config.vm.provision :shell, inline: 'sed -i -E "s/HOST = [^)]+/HOST = $HOSTNAME/g" /u01/app/oracle/product/11.2.0/xe/network/admin/listener.ora'
   config.vm.provision :shell, inline: %q{sed -i -E "s/<ORACLE_BASE>/\/u01\/app\/oracle/" /u01/app/oracle/product/11.2.0/xe/dbs/init.ora}
 
   # Change password for Oracle user

data/gemfiles/Gemfile.activerecord-5.0

@@ -0,0 +1,21 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'juwelier', '~> 2.0'
+  gem 'rspec_junit_formatter'
+end
+
+group :test, :development do
+  gem 'rake', '>= 10.0'
+  gem 'rspec', '~> 3.1'
+
+  unless ENV['NO_ACTIVERECORD']
+    gem 'activerecord', '~> 5.0.0'
+    gem 'activerecord-oracle_enhanced-adapter', '~> 1.7.0'
+    gem 'simplecov', '>= 0'
+  end
+
+  platforms :ruby, :mswin, :mingw do
+    gem 'ruby-oci8', '~> 2.1'
+  end
+end

data/gemfiles/Gemfile.activerecord-5.1

@@ -0,0 +1,21 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'juwelier', '~> 2.0'
+  gem 'rspec_junit_formatter'
+end
+
+group :test, :development do
+  gem 'rake', '>= 10.0'
+  gem 'rspec', '~> 3.1'
+
+  unless ENV['NO_ACTIVERECORD']
+    gem 'activerecord', '~> 5.1.0'
+    gem 'activerecord-oracle_enhanced-adapter', '~> 1.8.0'
+    gem 'simplecov', '>= 0'
+  end
+
+  platforms :ruby, :mswin, :mingw do
+    gem 'ruby-oci8', '~> 2.1'
+  end
+end

data/gemfiles/Gemfile.activerecord-5.2

@@ -0,0 +1,21 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'juwelier', '~> 2.0'
+  gem 'rspec_junit_formatter'
+end
+
+group :test, :development do
+  gem 'rake', '>= 10.0'
+  gem 'rspec', '~> 3.1'
+
+  unless ENV['NO_ACTIVERECORD']
+    gem 'activerecord', '~> 5.2.0.beta'
+    gem 'activerecord-oracle_enhanced-adapter', '~> 5.2.0.beta'
+    gem 'simplecov', '>= 0'
+  end
+
+  platforms :ruby, :mswin, :mingw do
+    gem 'ruby-oci8', '~> 2.1'
+  end
+end

data/lib/plsql/connection.rb

@@ -25,14 +25,14 @@ 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]||ENV['ORA_SDTZ'])
+      conn.set_time_zone(params[:time_zone] || ENV["ORA_SDTZ"])
       conn
     end
 
@@ -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
 
@@ -198,7 +198,7 @@ module PLSQL
     end
 
     # Set time zone
-    def set_time_zone(time_zone=nil)
+    def set_time_zone(time_zone = nil)
       exec("alter session set time_zone = '#{time_zone}'") if time_zone
     end
 
@@ -207,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
@@ -221,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,7 +58,7 @@ module PLSQL
       new(java.sql.DriverManager.getConnection(url, params[:username], params[:password]))
     end
 
-    def set_time_zone(time_zone=nil)
+    def set_time_zone(time_zone = nil)
       raw_connection.setSessionTimeZone(time_zone) if time_zone
     end
 
@@ -90,7 +99,6 @@ module PLSQL
     end
 
     class CallableStatement #:nodoc:
-
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -107,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','XMLTYPE'].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
@@ -130,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:
@@ -150,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)
@@ -194,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
@@ -209,7 +217,7 @@ 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
@@ -240,7 +248,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,
@@ -256,8 +264,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
@@ -277,10 +285,10 @@ module PLSQL
       when :Time, :'Java::JavaSql::Timestamp'
         stmt.send("setTimestamp#{key && "AtName"}", key || i, value)
       when :NilClass
-        if ['TABLE', 'VARRAY', 'OBJECT','XMLTYPE'].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
@@ -309,7 +317,7 @@ module PLSQL
         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'
@@ -336,7 +344,6 @@ module PLSQL
     end
 
     def result_set_to_ruby_data_type(column_type, column_type_name)
-
     end
 
     def plsql_to_ruby_data_type(metadata)
@@ -351,7 +358,7 @@ module PLSQL
       when "NUMBER"
         [BigDecimal, nil]
       when "NATURAL", "NATURALN", "POSITIVE", "POSITIVEN", "SIGNTYPE", "SIMPLE_INTEGER", "PLS_INTEGER", "BINARY_INTEGER"
-        [Fixnum, nil]
+        [Integer, nil]
       when "DATE"
         [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
@@ -367,10 +374,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
@@ -419,9 +426,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
@@ -435,7 +442,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
@@ -444,10 +451,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
@@ -468,7 +475,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
@@ -493,12 +500,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)
@@ -523,23 +530,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