simpleOracleJDBC 0.2.0 → 0.3.0

data/test/binding_test.rb

@@ -6,7 +6,7 @@ class BindingTest < Test::Unit::TestCase
 
   def setup
     @interface = @@interface
-    @sql = SimpleOracleJDBC::Sql.new
+    @sql = SimpleOracleJDBC::Sql.new(@interface.connection)
   end
 
   def teardown
@@ -42,7 +42,7 @@ class BindingTest < Test::Unit::TestCase
     call = @interface.prepare_proc("begin
                                      :l_date := :i_date;
                                    end;")
-    t = Time.now
+    t = Time.gm(2013,1,1,12,34,23)
     call.execute([Time, nil, :out], t)
     assert_equal(t, call[1])
     assert(call[1].is_a? Time)
@@ -250,6 +250,25 @@ class BindingTest < Test::Unit::TestCase
     assert_equal(results[0][0], nil)
   end
 
+  def test_array_can_be_bound_to_sql
+    sql = @interface.execute_sql("select * from table(:b_tab)", SimpleOracleJDBC::OraArray.new('t_varchar2_tab', ['abc', 'def']))
+    results = sql.all_array
+    assert_equal(2, results.length)
+    assert_equal('abc', results[0][0])
+    assert_equal('def', results[1][0])
+  end
+
+  def test_array_of_records_can_be_bound_to_sql
+    sql = @interface.execute_sql("select * from table(:b_tab)",
+                                 SimpleOracleJDBC::OraArray.new('t_record_tab', [
+                                                                  ["S1", nil, nil, nil, nil, nil, nil],
+                                                                  ["S2", nil, nil, nil, nil, nil, nil]                                                                                           ]))
+    results = sql.all_array
+    assert_equal(2, results.length)
+    assert_equal('S1', results[0][0])
+    assert_equal('S2', results[1][0])
+    assert_equal(nil, results[1][1])
+  end
 
   def test_unknown_data_type_from_sql_raises_exeception
     sql = @interface.execute_sql("select cast('hello there' as nvarchar2(1000)) from dual")

data/test/helper.rb

@@ -4,12 +4,13 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 require 'simple_oracle_jdbc'
 require 'test/unit'
 
+
 module TestHelper
 
   DB_USER     = 'sodonnel'
-  DB_PASSWORD = 'sodonnell'
+  DB_PASSWORD = 'sodonnel'
   DB_SERVICE  = 'local11gr2.world'
-  DB_HOST     = 'localhost'
+  DB_HOST     = '192.168.56.1'
   DB_PORT     = '1521'
 
   @@interface ||= SimpleOracleJDBC::Interface.create(DB_USER,

data/test/ora_array_test.rb

@@ -0,0 +1,257 @@
+require 'helper'
+
+class OraArrayTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @interface = @@interface
+    @sql = SimpleOracleJDBC::Sql.new(@interface.connection)
+  end
+
+  def teardown
+    @sql.close
+  end
+
+  def test_oracle_varchar_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_varchar(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_varchar2_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_varchar2_tab', ['abc', 'def', nil]))
+    return_array = call[1]
+    assert_equal('abc', return_array[0])
+    assert_equal('def', return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_varchar_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_varchar(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_varchar2_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_varchar2_tab', []))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_oracle_char_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_char(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_char_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_char_tab', ['abc', 'def', nil]))
+    return_array = call[1]
+    # chars are right padded. In this case to 100 characters
+    assert_match(/abc\s+/, return_array[0])
+    assert_match(/def\s+/, return_array[1])
+    assert_equal(100, return_array[0].length)
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_char_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_char(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_char_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_char_tab', []))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+
+  def test_nil_varchar_array_can_be_bound_and_retrieved_when_passed_as_nil
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_varchar(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_varchar2_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_varchar2_tab', nil))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_oracle_integer_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_integer(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_integer_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_integer_tab', [9, 10, nil]))
+    return_array = call[1]
+    assert_equal(9, return_array[0])
+    assert_equal(10, return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_order_integer_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_integer(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_integer_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_integer_tab', []))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_oracle_number_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_number(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_number_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_number_tab', [9.123456, 10.123456, nil]))
+    return_array = call[1]
+    assert_equal(9.123456, return_array[0])
+    assert_equal(10.123456, return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_oracle_number_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_number(:i_array);
+                                    end;")
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_number_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_number_tab', []))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+
+  def test_oracle_date_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_date(:i_array);
+                                    end;")
+    date_array = [Time.gm(2013,1,1,12,31), Time.gm(2014,1,1,12,31), nil]
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_date_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_date_tab', date_array))
+    return_array = call[1]
+    assert_equal(date_array[0], return_array[0])
+    assert_equal(date_array[1], return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_oracle_date_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_date(:i_array);
+                                    end;")
+    date_array = []
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_date_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_date_tab', date_array))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_oracle_timestamp_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_timestamp(:i_array);
+                                    end;")
+    date_array = [Time.gm(2013,1,1,12,31), Time.gm(2014,1,1,12,31), nil]
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_timestamp_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_timestamp_tab', date_array))
+    return_array = call[1]
+    assert_equal(date_array[0], return_array[0])
+    assert_equal(date_array[1], return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_oracle_timestamp_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_timestamp(:i_array);
+                                    end;")
+    date_array = []
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_timestamp_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_timestamp_tab', date_array))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+
+  def test_oracle_raw_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_raw(:i_array);
+                                    end;")
+
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_raw_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_raw_tab', ['ADEADEADE', '3E3E3E', nil]))
+    return_array = call[1]
+    assert_equal('0ADEADEADE', return_array[0]) # uneven number of bytes left padded with zero
+    assert_equal('3E3E3E', return_array[1])
+    assert_equal(nil, return_array[2])
+  end
+
+  def test_nil_oracle_raw_array_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_raw(:i_array);
+                                    end;")
+    date_array = []
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_raw_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_raw_tab', date_array))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_ora_array_object_can_be_reused_with_different_values
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_raw(:i_array);
+                                    end;")
+    data_array = ['DEDEDE', 'ABABAB']
+    input_array_obj =  SimpleOracleJDBC::OraArray.new('t_raw_tab', data_array)
+    output_array_obj = SimpleOracleJDBC::OraArray.new('t_raw_tab', nil)
+    call.execute([SimpleOracleJDBC::OraArray, output_array_obj, :out], input_array_obj)
+    return_array = call[1]
+    assert_equal(2, return_array.length)
+
+    input_array_obj.values= ["121212", "AADDAADD", "01"]
+    call.execute([SimpleOracleJDBC::OraArray, output_array_obj, :out], input_array_obj)
+    return_array = call[1]
+    assert_equal(3, return_array.length)
+  end
+
+  def test_exception_raised_if_values_passed_is_not_array
+    assert_raises RuntimeError do
+      input_array_obj =  SimpleOracleJDBC::OraArray.new('t_raw_tab', 'string')
+    end
+  end
+
+  def test_ora_array_of_records_can_be_bound_and_retrieved
+     call = @interface.prepare_proc("begin
+                                      :out_value := test_array_of_records(:i_array);
+                                    end;")
+    record = ["The String", 123, 456.789, 'THE CHAR', Time.gm(2013,11,23), Time.gm(2013,12,23,12,24,36), 'ED12ED12']
+    record2 = record.dup
+    record2[0] = "String2"
+
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_record_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_record_tab', [ record, record2 ]))
+    return_array = call[1]
+    assert_equal(2, return_array.length)
+    assert_equal("The String", return_array.first[0])
+    assert_equal(123, return_array.first[1])
+    assert_equal(456.789, return_array.first[2])
+
+    assert_equal("String2", return_array[1][0])
+  end
+
+  def test_empty_ora_array_of_records_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_of_records(:i_array);
+                                    end;")
+
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_record_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_record_tab', nil))
+    return_array = call[1]
+    assert_equal(0, return_array.length)
+  end
+
+  def test_ora_array_of_nil_records_can_be_bound_and_retrieved
+    call = @interface.prepare_proc("begin
+                                      :out_value := test_array_of_records(:i_array);
+                                    end;")
+    record = [nil, nil, nil, nil, nil, nil, nil]
+
+    call.execute([SimpleOracleJDBC::OraArray, SimpleOracleJDBC::OraArray.new('t_record_tab', nil), :out],
+                 SimpleOracleJDBC::OraArray.new('t_record_tab', [ record ]))
+    return_array = call[1]
+    assert_equal(1, return_array.length)
+    assert_equal(nil, return_array.first[0])
+  end
+
+end

data/test/ora_record_test.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class OraRecordTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @interface = @@interface
+    @sql = SimpleOracleJDBC::Sql.new(@interface.connection)
+    @call = @interface.prepare_proc("begin
+                                      :out_record := test_record(:i_record);
+                                    end;")
+  end
+
+  def teardown
+    @sql.close
+  end
+
+  def test_execption_raised_when_not_enough_values_for_record
+    record = ["hello"]
+    assert_raises RuntimeError do
+      @call.execute([SimpleOracleJDBC::OraRecord, SimpleOracleJDBC::OraRecord.new('t_record', nil), :out],
+                   SimpleOracleJDBC::OraRecord.new('t_record', record))
+    end
+  end
+
+  def test_oracle_record_can_be_bound_and_retrieved
+    record = ["The String", 123, 456.789, 'THE CHAR', Time.gm(2013,11,23), Time.gm(2013,12,23,12,24,36), 'ED12ED12']
+    @call.execute([SimpleOracleJDBC::OraRecord, SimpleOracleJDBC::OraRecord.new('t_record', nil), :out],
+                 SimpleOracleJDBC::OraRecord.new('t_record', record))
+    return_array = @call[1]
+    assert_equal(record[0], return_array[0])
+    assert_equal(record[1], return_array[1])
+    assert_equal(record[2], return_array[2])
+    assert_equal(record[3], return_array[3])
+    assert_equal(record[4], return_array[4])
+    assert_equal(record[5], return_array[5])
+    assert_equal(record[6], return_array[6])
+  end
+
+  def test_oracle_record_can_be_bound_and_retrieved_will_all_null_values
+    record = [nil, nil, nil, nil, nil, nil, nil]
+    @call.execute([SimpleOracleJDBC::OraRecord, SimpleOracleJDBC::OraRecord.new('t_record', nil), :out],
+                 SimpleOracleJDBC::OraRecord.new('t_record', record))
+    return_array = @call[1]
+    assert_equal(record[0], return_array[0])
+    assert_equal(record[1], return_array[1])
+    assert_equal(record[2], return_array[2])
+    assert_equal(record[3], return_array[3])
+    assert_equal(record[4], return_array[4])
+    assert_equal(record[5], return_array[5])
+    assert_equal(record[6], return_array[6])
+  end
+
+end

data/test/sql_test.rb

@@ -6,7 +6,7 @@ class SqlTest < Test::Unit::TestCase
 
   def setup
     @interface = @@interface
-    @sql = SimpleOracleJDBC::Sql.new
+    @sql = SimpleOracleJDBC::Sql.new(@interface.connection)
   end
 
   def teardown
@@ -34,9 +34,8 @@ class SqlTest < Test::Unit::TestCase
   end
 
   def test_prepare_method_available_and_returns_self
-    sql_obj = SimpleOracleJDBC::Sql.new
-    prepared = sql_obj.prepare(@interface.connection, 'select * from dual')
-    assert_equal(prepared, sql_obj)
+    prepared = @sql.prepare('select * from dual')
+    assert_equal(prepared, @sql)
   end
 
   def test_execute_method_avaliable_and_returns_self
@@ -57,9 +56,8 @@ class SqlTest < Test::Unit::TestCase
   end
 
   def test_close_does_not_error_when_no_statement
-    sql_obj = SimpleOracleJDBC::Sql.new
     assert_nothing_raised do
-      sql_obj.close
+      @sql.close
     end
   end
 

metadata

@@ -1,78 +1,82 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: simpleOracleJDBC
-version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.2.0
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
-authors:
+authors: 
 - Stephen O'Donnell
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-09 00:00:00.000000000 Z
+
+date: 2013-09-17 00:00:00 +01:00
+default_executable: 
 dependencies: []
+
 description: A lightweight wrapper around the JDBC interface to make it easier to make SQL and stored procedure calls.
 email: stephen@betteratoracle.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.md
-files:
-- !binary |-
-  dGVzdC9iaW5kaW5nX3Rlc3QucmI=
-- !binary |-
-  dGVzdC9kYl9jYWxsX3Rlc3QucmI=
-- !binary |-
-  dGVzdC9oZWxwZXIucmI=
-- !binary |-
-  dGVzdC9pbnRlcmZhY2VfdGVzdC5yYg==
-- !binary |-
-  dGVzdC9yZXN1bHRfc2V0X3Rlc3QucmI=
-- !binary |-
-  dGVzdC9zcWxfdGVzdC5yYg==
-- !binary |-
-  dGVzdC90ZXN0X3J1bm5lci5yYg==
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy5yYg==
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy9iaW5kaW5ncy5yYg==
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy9kYl9jYWxsLnJi
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy9pbnRlcmZhY2UucmI=
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy9yZXN1bHRfc2V0LnJi
-- !binary |-
-  bGliL3NpbXBsZV9vcmFjbGVfamRiYy9zcWwucmI=
-- !binary |-
-  UmFrZWZpbGUucmI=
-- !binary |-
-  UkVBRE1FLm1k
+files: 
+- test/binding_test.rb
+- test/db_call_test.rb
+- test/helper.rb
+- test/interface_test.rb
+- test/ora_array_test.rb
+- test/ora_record_test.rb
+- test/README
+- test/result_set_test.rb
+- test/sql_test.rb
+- test/test_runner.rb
+- lib/simple_oracle_jdbc/bindings.rb
+- lib/simple_oracle_jdbc/db_call.rb
+- lib/simple_oracle_jdbc/interface.rb
+- lib/simple_oracle_jdbc/ora_array.rb
+- lib/simple_oracle_jdbc/ora_record.rb
+- lib/simple_oracle_jdbc/result_set.rb
+- lib/simple_oracle_jdbc/sql.rb
+- lib/simple_oracle_jdbc/type_map.rb
+- lib/simple_oracle_jdbc.rb
+- Rakefile.rb
+- README.md
+has_rdoc: true
 homepage: http://betteratoracle.com
 licenses: []
-post_install_message:
+
+post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
-rubyforge_project:
-rubygems_version: 1.8.25
-signing_key:
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
 specification_version: 3
 summary: A gem to simplify JDBC database access to Oracle when using JRuby
 test_files: []
-has_rdoc: true
+