simpleOracleJDBC 0.2.0 → 0.3.0

data/lib/simple_oracle_jdbc/ora_record.rb

@@ -0,0 +1,139 @@
+module SimpleOracleJDBC
+
+  class OraRecord
+    include TypeMap
+
+    attr_reader :ora_type
+
+    # This must be initialized with the name of the Oracle record type as defined
+    # on the database, ie something like:
+    #
+    #    create or replace type t_record as object (
+    #    p_varchar varchar2(10),
+    #    p_integer integer
+    #    );
+    #
+    # Values must be an array of Ruby objects, or nil. The values in the array
+    # will be cast into the appropriate Oracle type depending on the definition
+    # of the record defined in Oracle.
+    def initialize(ora_type, values)
+      @ora_type   = ora_type.upcase
+      self.values = values
+      @descriptor = nil
+      @type_attributes = nil
+    end
+
+    # Values must be a Ruby array of objects or nil.
+    #
+    # While the values can be set in upon object initialization, this method
+    # allows them to be changed. The one advantage is that it allows the
+    # object descriptor to be reused across many database calls. As this must
+    # be queried from the database, it requires 1 database round trip for each new object,
+    # but is cached inside the object once it is initialized.
+    def values=(value_array)
+      if value_array and !value_array.is_a? Array
+        raise "The values must be a Ruby array, not #{value_array.class}"
+      end
+      @values = value_array || Array.new
+    end
+
+    # Given a database connection, a prepared statement and a bind index,
+    # this method will bind the array of values (set at object initialization time
+    # or by the values= method) to the statement.
+    def bind_to_call(conn, stmt, index)
+      set_descriptor(conn)
+
+      # Avoid binding an empty record for OUT parameters
+      if @values.length == 0
+        return
+      end
+
+      ora_array = convert_to_oracle_struct(conn, @values)
+      stmt.set_object(index, ora_array)
+    end
+
+    # Given a ruby array, convert it into the Oracle STRUCT required
+    # when binding it to a procedure call
+    def convert_to_oracle_struct(conn, input)
+      set_descriptor(conn)
+
+      if @type_attributes.length != input.length
+        raise "Not enough values (#{input.length}) for Oracle record (#{@type_attributes.length})"
+      end
+
+      temp_array = Array.new
+      @type_attributes.each_with_index do |t, i|
+        if t == 'VARCHAR' or t == 'CHAR'
+          temp_array.push input[i]
+        elsif t == 'RAW'
+          temp_array.push ruby_raw_string_as_jdbc_raw(input[i])
+        elsif t == 'NUMBER' or t == 'INTEGER'
+          temp_array.push ruby_number_as_jdbc_number(input[i])
+        elsif t == 'DATE' or t == 'TIMESTAMP'
+          temp_array.push ruby_any_date_as_jdbc_date(input[i])
+        else
+          raise "#{base_type}: Unimplemented Record Type"
+        end
+      end
+      ora_array = STRUCT.new(@descriptor, conn, temp_array.to_java)
+    end
+
+    # Given a database connection, a prepared statement and a bind index,
+    # register the bind at that index as an out or inout parameter.
+    def register_as_out_parameter(conn, stmt, index)
+      set_descriptor(conn)
+      stmt.register_out_parameter(index, OracleTypes::STRUCT, @ora_type)
+    end
+
+    # After executing a statement, retrieve the resultant array from Oracle
+    # returning a Ruby array of Ruby objects.
+    def retrieve_out_value(conn, stmt, index)
+      set_descriptor(conn)
+      convert_struct_to_ruby(conn, stmt.get_struct(index))
+    end
+
+    def convert_struct_to_ruby(conn, struct)
+      set_descriptor(conn)
+      final_array = Array.new
+
+      ora_array = struct.get_attributes.to_a
+      ora_array.each_with_index do |v,i|
+        base_type = @type_attributes[i]
+        if base_type == 'VARCHAR' or base_type == 'CHAR'
+          final_array.push v
+        elsif base_type == 'RAW'
+          # RAW is a bit different as the default returned type is a byte array
+          # By extracting the results as 'oracle_attributes' you get a to_string
+          # method on the RAW type to turn it into a hex string.
+          temp_array = struct.get_oracle_attributes.to_a
+          final_array.push oracle_raw_as_string(temp_array[i])
+        elsif base_type == 'NUMBER' or base_type == 'INTEGER'
+          final_array.push java_number_as_float(v)
+        elsif base_type == 'DATE' or base_type == 'TIMESTAMP'
+          final_array.push java_date_as_time(v)
+        else
+          raise "#{base_type}: Unimplemented Record Type"
+        end
+      end
+      final_array
+    end
+
+    private
+
+    def set_descriptor(conn)
+      @descriptor ||= StructDescriptor.createDescriptor(@ora_type, conn);
+      set_type_attributes
+    end
+
+    def set_type_attributes
+      unless @type_attributes
+        @type_attributes = []
+        meta = @descriptor.get_meta_data
+        1.upto(meta.get_column_count) do |i|
+          @type_attributes.push(meta.get_column_type_name(i))
+        end
+      end
+    end
+
+  end
+end

data/lib/simple_oracle_jdbc/sql.rb

@@ -24,29 +24,30 @@ module SimpleOracleJDBC
     include Binding
     include ResultSet
 
-    attr_reader :statement, :sql, :result_set
+    attr_reader :connection, :statement, :sql, :result_set
 
     attr_writer :result_set
 
     # Creates a new instance of this class. Not intended to be used directly. Use the factory
     # class methods prepare or execute instead.
-    def initialize
+    def initialize(connection)
+      @connection = connection
       @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 = self.new(connection)
       sql_object.disable_auto_statement_close
-      sql_object.prepare(connection,sql)
+      sql_object.prepare(sql)
     end
 
     # Takes a JDBC connection object, an SQL statement and an optional list of bind variables and
     # will prepare and execute the sql statement, returning an SimpleOracle::Sql object.
     def self.execute(connection, sql, *binds)
-      sql_object = self.new
-      sql_object.prepare(connection, sql)
+      sql_object = self.new(connection)
+      sql_object.prepare(sql)
       sql_object.execute(*binds)
     end
 
@@ -54,9 +55,9 @@ module SimpleOracleJDBC
     # and a JDBC prepared statement will be stored in @statement.
     #
     # This method returns self to allow calls to be chained.
-    def prepare(connection, sql)
+    def prepare(sql)
       @sql = sql
-      @statement = connection.prepare_statement(@sql)
+      @statement = @connection.prepare_statement(@sql)
       self
     end
 

data/lib/simple_oracle_jdbc/type_map.rb

@@ -0,0 +1,99 @@
+module SimpleOracleJDBC
+  module TypeMap
+
+    def java_date_as_date(v)
+      if v
+        Date.new(v.get_year+1900, v.get_month+1, v.get_date)
+      else
+        nil
+      end
+    end
+
+    def java_date_as_time(v)
+      if v
+        Time.at(v.get_time.to_f / 1000)
+      else
+        nil
+      end
+    end
+
+    def java_number_as_float(v)
+      if v
+        v.double_value
+      else
+        nil
+      end
+    end
+
+    def java_integer_as_integer(v)
+      # JRuby automatically converts INT to INT
+      v
+    end
+
+    def java_string_as_string(v)
+      # JRubyt automatically converts to a Ruby string
+      v
+    end
+
+    def oracle_raw_as_string(v)
+      if v
+        v.string_value
+      else
+        nil
+      end
+    end
+
+    def ruby_date_as_jdbc_date(v)
+      if v
+        jdbc_date = Java::JavaSql::Date.new(v.strftime("%s").to_f * 1000)
+      else
+        nil
+      end
+    end
+
+    def ruby_time_as_jdbc_timestamp(v)
+      if v
+        TIMESTAMP.new(Java::JavaSql::Timestamp.new(v.to_f * 1000))
+      else
+        nil
+      end
+    end
+
+    def ruby_any_date_as_jdbc_date(v)
+      if v
+        if v.is_a? Date
+          ruby_date_as_jdbc_date(v)
+        elsif v.is_a? Time
+          ruby_time_as_jdbc_timestamp(v)
+        else
+          raise "#{v.class}: unimplemented Ruby date type for arrays. Use Date or Time"
+        end
+      else
+        nil
+      end
+    end
+
+    def ruby_number_as_jdbc_number(v)
+      if v
+        # Avoid warning that appeared in JRuby 1.7.3. There are many signatures of
+        # Java::OracleSql::NUMBER and it has to pick one. This causes a warning. This
+        # technique works around the warning and forces it to the the signiture with a
+        # double input - see https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby
+        # under the Constructors section.
+        construct = Java::OracleSql::NUMBER.java_class.constructor(Java::double)
+        construct.new_instance(v)
+      else
+        nil
+      end
+    end
+
+    def ruby_raw_string_as_jdbc_raw(v)
+      if v
+        Java::OracleSql::RAW.new(v)
+      else
+        v
+      end
+    end
+
+  end
+end

data/test/README

@@ -0,0 +1,165 @@
+For the test suit to run the Oracle objects below must be created upfront.
+
+  ** The test harness will not create them - maybe in the future ... **
+
+Right now, these objects are only needed to test the array functionality.
+
+
+create or replace type t_varchar2_tab is table of varchar2(100);
+/
+
+create or replace type t_char_tab is table of char(100);
+/
+
+create or replace type t_integer_tab is table of integer;
+/
+
+create or replace type t_number_tab is table of number;
+/
+
+create or replace type t_date_tab is table of date;
+/
+
+create or replace type t_timestamp_tab is table of timestamp;
+/
+
+create or replace type t_raw_tab is table of raw(100);
+/
+
+create or replace type t_record as object (
+  p_varchar varchar2(10),
+  p_integer integer,
+  p_number  number,
+  p_char    char(10),
+  p_date    date,
+  p_timestamp timestamp,
+  p_raw     raw(10)
+);
+/
+
+create or replace type t_record_tab as table of t_record;
+/
+
+create or replace function test_record(i_record t_record)
+  return t_record
+is
+begin
+  return i_record;
+end;
+/
+
+create or replace function test_array_of_records(i_array t_record_tab)
+  return t_record_tab
+is
+  v_return_value t_record_tab;
+begin
+  v_return_value := t_record_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+
+create or replace function test_array_varchar(i_array t_varchar2_tab)
+  return t_varchar2_tab
+is
+  v_return_value t_varchar2_tab;
+begin
+  v_return_value := t_varchar2_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+create or replace function test_array_char(i_array t_char_tab)
+  return t_char_tab
+is
+  v_return_value t_char_tab;
+begin
+  v_return_value := t_char_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+
+create or replace function test_array_integer(i_array t_integer_tab)
+  return t_integer_tab
+is
+  v_return_value t_integer_tab;
+begin
+  v_return_value := t_integer_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+
+create or replace function test_array_number(i_array t_number_tab)
+  return t_number_tab
+is
+  v_return_value t_number_tab;
+begin
+  v_return_value := t_number_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+
+create or replace function test_array_date(i_array t_date_tab)
+  return t_date_tab
+is
+  v_return_value t_date_tab;
+begin
+  v_return_value := t_date_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+create or replace function test_array_timestamp(i_array t_timestamp_tab)
+  return t_timestamp_tab
+is
+  v_return_value t_timestamp_tab;
+begin
+  v_return_value := t_timestamp_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/
+
+create or replace function test_array_raw(i_array t_raw_tab)
+  return t_raw_tab
+is
+  v_return_value t_raw_tab;
+begin
+  v_return_value := t_raw_tab();
+  for i in 1..i_array.count loop
+    v_return_value.extend(1);
+    v_return_value(v_return_value.count) := i_array(i);
+  end loop;
+  return v_return_value;
+end;
+/