simpleOracleJDBC 0.1.3 → 0.2.0

data/README.md

@@ -130,7 +130,8 @@ The best way to learn how to use Simple Oracle JDBC is to read through the sampl
     #      Integer    => OracleTypes::INTEGER,
     #      Bignum     => OracleTypes::NUMERIC,
     #      Float      => OracleTypes::NUMERIC,
-    #      :refcursor => OracleTypes::CURSOR
+    #      :refcursor => OracleTypes::CURSOR,
+    #      :raw       => OracleTypes::RAW
     #    }
     #
     # The second element is the value, which should be nil for out parameters and can take a
@@ -201,4 +202,4 @@ Types that cannot be retrieved from an SQL result set
   * CLOB
   * Cursor
   * Long
-  * nvarchar etc
+  * nvarchar etc

data/lib/simple_oracle_jdbc/bindings.rb

@@ -13,7 +13,8 @@ module SimpleOracleJDBC
       Integer    => OracleTypes::INTEGER,
       Bignum     => OracleTypes::NUMERIC,
       Float      => OracleTypes::NUMERIC,
-      :refcursor => OracleTypes::CURSOR
+      :refcursor => OracleTypes::CURSOR,
+      :raw       => OracleTypes::RAW
     }
 
     # Given a JDBC prepared call or prepared statement, a value and a bind index, the value
@@ -45,7 +46,8 @@ module SimpleOracleJDBC
     #      Integer    => OracleTypes::INTEGER,
     #      Bignum     => OracleTypes::NUMERIC,
     #      Float      => OracleTypes::NUMERIC,
-    #      :refcursor => OracleTypes::CURSOR
+    #      :refcursor => OracleTypes::CURSOR,
+    #      :raw       => OracleTypes::RAW
     #    }
     #
     # Note that to bind a ref_cursor, there is no natural Ruby class, so it can only be bound using
@@ -78,6 +80,8 @@ module SimpleOracleJDBC
         bind_number(obj, value, i)
       elsif type == :refcursor
         bind_refcursor(obj, value, i)
+      elsif type == :raw
+        bind_raw(obj, value, i)
       else
         raise UnknownBindType, type.to_s
       end
@@ -101,6 +105,8 @@ module SimpleOracleJDBC
         retrieve_time(obj, i)
       when 'CHAR', 'VARCHAR2', 'CLOB'
         retrieve_string(obj, i)
+      when 'RAW'
+        retrieve_raw(obj, i)
       else
         raise UnknownSQLType, obj.get_meta_data.get_column_type_name(i)
       end
@@ -169,6 +175,16 @@ module SimpleOracleJDBC
       end
     end
 
+    def bind_raw(obj, v, i)
+      if v
+        raw = Java::OracleSql::RAW.new(v)
+        obj.set_raw(i, raw)
+      else
+        obj.set_null(i, OracleTypes::RAW)
+      end
+    end
+
+
     def retrieve_date(obj, i)
       jdate = obj.get_date(i)
       if jdate
@@ -216,5 +232,14 @@ module SimpleOracleJDBC
       results
     end
 
+    def retrieve_raw(obj, i)
+      v = obj.get_raw(i)
+      if v
+        v.string_value
+      else
+        nil
+      end
+    end
+
   end
 end

data/lib/simple_oracle_jdbc/db_call.rb

@@ -102,6 +102,8 @@ module SimpleOracleJDBC
           retrieve_number(@call, i)
         elsif bind[0] == :refcursor
           retrieve_refcursor(@call, i)
+        elsif bind[0] == :raw
+          retrieve_raw(@call, i)
         end
       else
         # If its not an array, it was just an IN, so just pull the bind

data/lib/simple_oracle_jdbc/result_set.rb

@@ -74,13 +74,14 @@ module SimpleOracleJDBC
 
     # Closes the result set if it exists, and also closes the SQL statement that created the result
     # set.
-    # TODO - does it make sense to close the statement here too?
     def close_result_set
       if @result_set
         @result_set.close
         @result_set = nil
       end
-      close_statement
+      if @auto_statement_close
+        close_statement
+      end
     end
 
     private

data/lib/simple_oracle_jdbc/sql.rb

@@ -31,12 +31,14 @@ module SimpleOracleJDBC
     # Creates a new instance of this class. Not intended to be used directly. Use the factory
     # class methods prepare or execute instead.
     def initialize
+      @auto_statement_close = true
     end
 
     # Takes a JDBC connection object and an SQL statement and returns a SimpleOracleJDBC::Sql
     # object with the prepared statement.
     def self.prepare(connection, sql)
       sql_object = self.new
+      sql_object.disable_auto_statement_close
       sql_object.prepare(connection,sql)
     end
 
@@ -71,7 +73,9 @@ module SimpleOracleJDBC
       unless @sql =~ /^\s*select/i
         @result_set = nil
         @statement.execute()
-        close_statement
+        if @auto_statement_close
+          close_statement
+        end
       else
         @result_set = @statement.execute_query()
       end
@@ -92,5 +96,17 @@ module SimpleOracleJDBC
       end
     end
 
+
+    # If a statement was prepared, it is likely it is going to be reused, so the statement
+    # handle should not be closed after execution.
+    #
+    # If the statement is directly executed, then the prepared handle was never requested
+    # and so it probably should be closed.
+    #
+    # This method is called by the prepare class/factory method
+    def disable_auto_statement_close
+      @auto_statement_close = false
+    end
+
   end
 end

data/test/binding_test.rb

@@ -127,6 +127,24 @@ class BindingTest < Test::Unit::TestCase
     assert_equal(rows[0][0], 'X')
   end
 
+  def test_raw_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                     :l_raw := :i_raw;
+                                   end;")
+    call.execute([:raw, nil, :out], [:raw, "DEDEDEDEFF"])
+    assert(call[1].is_a?(String), "Ensure a string is returned")
+    assert(call[1], "DEDEDEDEFF")
+  end
+
+  def test_null_raw_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                     :l_raw := :i_raw;
+                                   end;")
+    call.execute([:raw, nil, :out], [:raw, nil])
+    assert_nil(call[1])
+  end
+
+
   def test_unknown_data_type_raises_exeception_when_bound
     call = @interface.prepare_proc("begin
                                      :l_date := :i_date;
@@ -220,6 +238,19 @@ class BindingTest < Test::Unit::TestCase
     assert_equal(results[0][0], nil)
   end
 
+  def test_raw_is_retrieved_as_ruby_string
+    sql = @interface.execute_sql("select cast('DFDFDFDF' as raw(16)) from dual")
+    results = sql.all_array
+    assert_equal(results[0][0], "DFDFDFDF")
+  end
+
+  def test_null_raw_is_retrieved_as_nil
+    sql = @interface.execute_sql("select cast(null as raw(16)) from dual")
+    results = sql.all_array
+    assert_equal(results[0][0], nil)
+  end
+
+
   def test_unknown_data_type_from_sql_raises_exeception
     sql = @interface.execute_sql("select cast('hello there' as nvarchar2(1000)) from dual")
     assert_raises SimpleOracleJDBC::UnknownSQLType do

metadata

@@ -2,14 +2,14 @@
 name: simpleOracleJDBC
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephen O'Donnell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-08-09 00:00:00.000000000 Z
 dependencies: []
 description: A lightweight wrapper around the JDBC interface to make it easier to make SQL and stored procedure calls.
 email: stephen@betteratoracle.com
@@ -34,8 +34,6 @@ files:
   dGVzdC90ZXN0X3J1bm5lci5yYg==
 - !binary |-
   bGliL3NpbXBsZV9vcmFjbGVfamRiYy5yYg==
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy8jYmluZGluZ3MucmIj
 - !binary |-
   bGliL3NpbXBsZV9vcmFjbGVfamRiYy9iaW5kaW5ncy5yYg==
 - !binary |-

data/lib/simple_oracle_jdbc/#bindings.rb#

@@ -1,214 +0,0 @@
-module SimpleOracleJDBC
-  module Binding
-
-    # Provides a set of methods to map Ruby types to their JDBC equivalent and back again.
-
-
-    RUBY_TO_JDBC_TYPES = {
-      Date       => OracleTypes::DATE,
-      Time       => OracleTypes::TIMESTAMP,
-      String     => OracleTypes::VARCHAR,
-      Fixnum     => OracleTypes::INTEGER,
-      Integer    => OracleTypes::INTEGER,
-      Bignum     => OracleTypes::NUMERIC,
-      Float      => OracleTypes::NUMERIC,
-      :refcursor => OracleTypes::CURSOR
-    }
-
-    # Given a JDBC prepared call or prepared statement, a value and a bind index, the value
-    # will be bound to JDBC statement.
-    #
-    # If value is a single value, ie not an array in is considered an IN parameter.
-    #
-    # If value is an array, then it should have either 2 or 3 elements.
-    #
-    # * 2 elements indictes the value is an IN parameter, element 0 indicates the type
-    # of the bind variable, and element 1 is the value, eg:
-    #
-    #    [String, "Some_value"]
-    #
-    # * 3 elements indicates the value is an OUT or an IN OUT parameter (useful only when using
-    # stored procedures), eg:
-    #
-    #    [String, "Some_value", :out]
-    #    [:refcursor, nil, :out]
-    #
-    # When binding values, Ruby types are mapped to Java / JDBC types based on the type
-    # of the passed in Ruby object. The mapping is as follows:
-    #
-    #    RUBY_TO_JDBC_TYPES = {
-    #      Date       => OracleTypes::DATE,
-    #      Time       => OracleTypes::TIMESTAMP,
-    #      String     => OracleTypes::VARCHAR,
-    #      Fixnum     => OracleTypes::INTEGER,
-    #      Integer    => OracleTypes::INTEGER,
-    #      Bignum     => OracleTypes::NUMERIC,
-    #      Float      => OracleTypes::NUMERIC,
-    #      :refcursor => OracleTypes::CURSOR
-    #    }
-    #
-    # Note that to bind a ref_cursor, there is no natural Ruby class, so it can only be bound using
-    # the array form for values.
-    #
-    # Also note that in this version, it is not possible to bind a ref_cursor into a procedure - it can
-    # only be retrieved.
-    def bind_value(obj, v, i)
-      type  = v.class
-      value = v
-      if v.is_a? Array
-        # class is being overriden from the input
-        type = v[0]
-        value = v[1]
-
-        if v.length == 3
-          bind_out_parameter(obj, i, type)
-        end
-      end
-
-      if type == Date
-        bind_date(obj, value, i)
-      elsif type == Time
-        bind_time(obj, value, i)
-      elsif type == String
-        bind_string(obj, value, i)
-      elsif type == Fixnum or type == Integer
-        bind_int(obj, value, i)
-      elsif type == Float
-        bind_number(obj, value, i)
-      elsif type == :refcursor
-        bind_refcursor(obj, value, i)
-      else
-        raise UnknownBindType, type.to_s
-      end
-    end
-
-    # Given a open JDBC result set and a column index, the value is retrieved
-    # and mapped into a Ruby type.
-    #
-    # The columns are indexed from 1 in the array.
-    #
-    # If the retrieved value is null, nil is returned.
-    def retrieve_value(obj, i)
-      case obj.get_meta_data.get_column_type_name(i)
-      when 'NUMBER'
-        retrieve_number(obj, i)
-      when 'INTEGER'
-        retrieve_int(obj, i)
-      when 'DATE'
-        retrieve_time(obj, i)
-      when 'TIMESTAMP'
-        retrieve_time(obj, i)
-      when 'CHAR', 'VARCHAR2'
-        retrieve_string(obj, i)
-      else
-        raise UnknownSQLType, obj.get_meta_data.get_column_type_name(i)
-      end
-    end
-
-    # :nodoc:
-    def bind_out_parameter(obj, index, type)
-      internal_type = RUBY_TO_JDBC_TYPES[type] || OracleTypes::VARCHAR
-      obj.register_out_parameter(index, internal_type)
-    end
-
-    def bind_date(obj, v, i)
-      if v
-        # %Q is micro seconds since epoch. Divide by 1000 to get milli-sec
-        jdbc_date = Java::JavaSql::Date.new(v.strftime("%s").to_f * 1000)
-        obj.set_date(i, jdbc_date)
-      else
-        obj.set_null(i, OracleTypes::DATE)
-      end
-    end
-
-    def bind_time(obj, v, i)
-      if v
-        # Need to use an Oracle TIMESTAMP - dates don't allow a time to be specified
-        # for some reason, even though a date in Oracle contains a time.
-        jdbc_time = TIMESTAMP.new(Java::JavaSql::Timestamp.new(v.to_f * 1000))
-        obj.setTIMESTAMP(i, jdbc_time)
-      else
-        obj.set_null(i, OracleTypes::TIMESTAMP)
-      end
-    end
-
-    def bind_string(obj, v, i)
-      if v
-        obj.set_string(i, v)
-      else
-        obj.set_null(i, OracleTypes::VARCHAR)
-      end
-    end
-
-    def bind_int(obj, v, i)
-      if v
-        obj.set_int(i, v)
-      else
-        obj.set_null(i, OracleTypes::INTEGER)
-      end
-    end
-
-    def bind_number(obj, v, i)
-      if v
-        obj.set_number(i, Java::OracleSql::NUMBER.new(v))
-      else
-        obj.set_null(i, OracleTypes::NUMBER)
-      end
-    end
-
-    def bind_refcursor(obj, v, i)
-      if v
-        raise "not implemented"
-      end
-    end
-
-    def retrieve_date(obj, i)
-      jdate = obj.get_date(i)
-      if jdate
-        rt = Time.at(jdate.date_value.get_time.to_f / 1000)
-        Date.new(rt.year, rt.month, rt.day)
-      else
-        nil
-      end
-    end
-
-    def retrieve_time(obj, i)
-      jdate = obj.get_timestamp(i)
-      if jdate
-        Time.at(jdate.get_time.to_f / 1000)
-      else
-        nil
-      end
-    end
-
-    def retrieve_string(obj, i)
-      obj.get_string(i)
-    end
-
-    def retrieve_int(obj, i)
-      v = obj.get_int(i)
-      if obj.was_null
-        nil
-      else
-        v
-      end
-    end
-
-    def retrieve_number(obj, i)
-      v = obj.get_number(i)
-      if v
-        v.double_value
-      else
-        nil
-      end
-    end
-
-    def retrieve_refcursor(obj, i)
-      rset = obj.get_object(i)
-      results = Sql.new
-      results.result_set = rset
-      results
-    end
-
-  end
-end