activerecord-jdbc-plsql 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17d26eaba8bff2c769aa318e98fbba4755d24e62
-  data.tar.gz: 9894527302f8c15e82cb1549f54b0ad63a188eae
+  metadata.gz: 0039923a88aaae3c4dfe23fd755a4db44ce3a345
+  data.tar.gz: 44df49c9eb526fcec5a9dd7365f13355e1b6d819
 SHA512:
-  metadata.gz: 7ae07feb06415c3866e2273752e1cde3e3202f1417d5910b2f8aeb8b73a034ebea4262ffad14ced609b04278dce660f2f00af5d6113eae35f0a8864e9a9f1906
-  data.tar.gz: 25ffe2207b0c87c947a6872910ab5a87116223ace7550b9b8eee82a6bf4d1a425a3012c48123aeb9cf0fa71de45cd765779db55e01deb14f0f49cb05105e3ef0
+  metadata.gz: 1314afbdc1d419798a2dd1171d1cedc93605607de3d9962e4a9e72de636fce394f237d3de509efa3c5f3e8f84bdf93a47b7d127bbf32d39566421146dfe3fe73
+  data.tar.gz: db0138c15966cbc325ef13c4794f8f621159f83bc6460280b1a2501975e6143ffb6988d7a83e7ac3afe98a28685004623e10ec8b340fc98b1d64d6b12c3e6c10

data/README.md

@@ -20,6 +20,22 @@ Or install it yourself as:
 
 activerecord-jdbc-plsql provide a new method to call PL/SQL programs. Use **call_procedure** from your models. Example:
 
+### Standard
+```ruby
+result = call_procedure('my_procedure', 'value1', 'value2', :integer)
+```
+
+This call will return this ruby hash:
+
+```ruby
+{
+    3 => 'the expected value'
+}
+```
+
+The key will be the parameter index starting at 1 ( accordance with JDBC API ).
+
+### With named parameters
 ```ruby
 result = call_procedure('my_procedure', an_input_parameter: 'value1', an_other_input_parameter: 'value2', an_output_parameter: :integer)
 ```

data/activerecord-jdbc-plsql.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
   spec.add_dependency "activerecord"
   spec.add_dependency "activerecord-jdbc-adapter"
   spec.add_development_dependency "bundler", "~> 1.3"

data/lib/activerecord/jdbc/plsql.rb

@@ -3,124 +3,135 @@ require "activerecord/jdbc/plsql/version"
 module ActiveRecord
   module Jdbc
     module PLSql
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-        SQL_TYPES = {
-            binary: java.sql.Types::BINARY,
-            boolean: java.sql.Types::BOOLEAN,
-            date: java.sql.Types::DATE,
-            datetime: java.sql.Types::TIMESTAMP,
-            decimal: java.sql.Types::DECIMAL,
-            float: java.sql.Types::FLOAT,
-            integer: java.sql.Types::INTEGER,
-            string: java.sql.Types::VARCHAR,
-            text: java.sql.Types::VARCHAR,
-            time: java.sql.Types::TIME,
-            timestamp: java.sql.Types::TIMESTAMP
-        }
-
-        # Create parameter part of call string
-        def stringify_parameters(attributes)
-          if attributes.is_a?(Hash) || attributes.is_a?(Array)
-            Array.new(attributes.size, '?').join(', ')
-          elsif !attributes.nil?
-            '?'
-          end
-        end
 
-        # Create request string
-        def create_request_string(name, attributes)
-          "{CALL #{name}(#{stringify_parameters(attributes)})}"
+      SQL_TYPES = {
+          binary: java.sql.Types::BINARY,
+          boolean: java.sql.Types::BOOLEAN,
+          date: java.sql.Types::DATE,
+          datetime: java.sql.Types::TIMESTAMP,
+          decimal: java.sql.Types::DECIMAL,
+          float: java.sql.Types::FLOAT,
+          integer: java.sql.Types::INTEGER,
+          string: java.sql.Types::VARCHAR,
+          text: java.sql.Types::VARCHAR,
+          time: java.sql.Types::TIME,
+          timestamp: java.sql.Types::TIMESTAMP
+      }
+
+      def parse_parameters(parameters)
+        if parameters.size == 1 and parameters[0].is_a? Hash
+          parameters[0]
+        else
+          parameters
         end
+      end
 
-        # Register parameters for callable statement
-        def register_parameters(statement, attributes)
-          if attributes.is_a?(Hash)
-            attributes.each { |k, v| register_parameter(statement, k, v) }
-          elsif attributes.is_a?(Array)
-            attributes.each_with_index { |v, i| register_parameter(statement, i, v) }
-          elsif !attributes.nil?
-            statement.setString(1, attributes.to_s)
-          end
+      def parse_input_parameters(parameters)
+        input_parameters = Hash.new
+        if parameters.is_a? Hash
+          parameters.each { |k, v| input_parameters[k] = v unless SQL_TYPES.include? v}
+        else
+          parameters.each_with_index { |v, i| input_parameters[i + 1] = v unless SQL_TYPES.include? v }
         end
+        input_parameters
+      end
 
-        # Choose the best way to register parameter (IN or OUT)
-        def register_parameter(statement, key, value)
-          case value
-            when Symbol
-              statement.registerOutParameter(key.to_s, SQL_TYPES[value])
-            else
-              statement.setString(key.to_s, value.to_s)
-          end
+      def parse_output_parameters(parameters)
+        output_parameters = Hash.new
+        if parameters.is_a? Hash
+          parameters.each { |k, v| output_parameters[k] = v if SQL_TYPES.include? v}
+        else
+          parameters.each_with_index { |v, i| output_parameters[i + 1] = v if SQL_TYPES.include? v }
         end
+        output_parameters
+      end
 
-        # Store results in hash
-        def parse_results(statement, attributes)
-          result = Hash.new
-
-          if attributes.is_a?(Hash)
-            attributes.each { |k, v|
-              result[k] = parse_result(statement, k.to_s, v) if v.is_a? Symbol
-            }
-          elsif attributes.is_a?(Array)
-            attributes.each_with_index { |v, i|
-              result[i] = parse_result(statement, i, :string) if v.nil?
-            }
-          end
-
-          result
+      def create_request_string(name, attributes)
+        "{CALL #{name}(#{Array.new(attributes.size, '?').join(', ')})}"
+      end
+
+      def register_input_parameters(statement, input_parameters)
+        input_parameters.each do |k, v|
+          key = k.is_a?(Symbol) ? k.to_s : k
+          statement.setObject(key, v)
         end
+      end
 
-        # Choose the method to call with type
-        def parse_result(statement, key, type)
-          case type
-            when :binary
-              statement.getString(key)
-            when :boolean
-              statement.getBoolean(key)
-            when :date
-              statement.getDate(key)
-            when :datetime
-              statement.getTimestamp(key)
-            when :decimal
-              statement.getDouble(key)
-            when :float
-              statement.getFloat(key)
-            when :integer
-              statement.getInt(key)
-            when :string
-              statement.getString(key)
-            when :text
-              statement.getString(key)
-            when :time
-              statement.getTime(key)
-            when :timestamp
-              statement.getTimestamp(key)
-            else
-              statement.getObject(key)
-          end
+      def register_output_parameters(statement, output_parameters)
+        output_parameters.each do |k, v|
+          key = k.is_a?(Symbol) ? k.to_s : k
+          statement.registerOutParameter(key, SQL_TYPES[v])
         end
+      end
+
+      def register_parameters(statement, output_parameters, input_parameters)
+        # Order is important for INOUT parameters
+        register_output_parameters(statement, output_parameters)
+        register_input_parameters(statement, input_parameters)
+      end
 
-        # Entry point to call procedure
-        def call_procedure(name, attributes = nil)
-          request_string = create_request_string(name, attributes)
-          statement = connection.raw_connection.with_connection_retry_guard do |jdbc_connection|
-            jdbc_connection.prepareCall(request_string)
-          end
+      # Store results in hash
+      def get_results(statement, output_parameters)
+        results = Hash.new
+        output_parameters.each do |k, v|
+          key = k.is_a?(Symbol) ? k.to_s : k
+          results[k] = get_result(statement, key, v)
+        end
+        results
+      end
 
-          register_parameters(statement, attributes)
+      # Choose the method to call with type
+      def get_result(statement, key, type)
+        case type
+          when :binary
+            statement.getString(key)
+          when :boolean
+            statement.getBoolean(key)
+          when :date
+            statement.getDate(key)
+          when :datetime
+            statement.getTimestamp(key)
+          when :decimal
+            statement.getDouble(key)
+          when :float
+            statement.getFloat(key)
+          when :integer
+            statement.getInt(key)
+          when :string
+            statement.getString(key)
+          when :text
+            statement.getString(key)
+          when :time
+            statement.getTime(key)
+          when :timestamp
+            statement.getTimestamp(key)
+          else
+            statement.getObject(key)
+        end
+      end
 
-          logger.info 'Call procedure: ' + request_string
-          statement.execute
+      # Entry point to call procedure
+      def call_procedure(name, *binds)
+        parameters = parse_parameters(binds)
 
-          parse_results(statement, attributes)
+        request_string = create_request_string(name, parameters)
+        statement = raw_connection.with_connection_retry_guard do |jdbc_connection|
+          jdbc_connection.prepareCall(request_string)
         end
 
+        output_parameters = parse_output_parameters(parameters)
+        input_parameters = parse_input_parameters(parameters)
+
+        register_parameters(statement, output_parameters, input_parameters)
+
+        logger.info 'Call procedure: ' + request_string
+        statement.execute
+
+        get_results(statement, output_parameters)
       end
+
     end
   end
 end
 
-ActiveRecord::Base.send(:include, ActiveRecord::Jdbc::PLSql)
+ActiveRecord::ConnectionAdapters::JdbcAdapter.send(:include, ActiveRecord::Jdbc::PLSql)

data/lib/activerecord/jdbc/plsql/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Jdbc
     module PLSql
-      VERSION = "0.0.2"
+      VERSION = "0.0.3"
     end
   end
 end

data/spec/plsql_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'PLSql' do
+  before do
+    @pl_sql = Object.new
+    @pl_sql.extend(ActiveRecord::Jdbc::PLSql)
+
+    @parameters = ['test', :integer]
+    @named_parameters = {test1: 'test', test2: :integer}
+  end
+
+  describe '#parse_input_parameters' do
+    it 'returns an input parameter array when parameters are named' do
+      input_parameters = @pl_sql.parse_input_parameters(@named_parameters)
+      expect(input_parameters.size).to be 1
+      expect(input_parameters.keys.first).to eq :test1
+      expect(input_parameters.values.first).to eq 'test'
+    end
+
+    it 'returns an input parameter array when parameters are unnamed' do
+      input_parameters = @pl_sql.parse_input_parameters(@parameters)
+      expect(input_parameters.size).to be 1
+      expect(input_parameters.keys.first).to eq 1
+      expect(input_parameters.values.first).to eq 'test'
+    end
+  end
+
+  describe '#parse_output_parameters' do
+    it 'returns an input parameter array when parameters are named' do
+      output_parameters = @pl_sql.parse_output_parameters(@named_parameters)
+      expect(output_parameters.size).to be 1
+      expect(output_parameters.keys.first).to eq :test2
+      expect(output_parameters.values.first).to be :integer
+    end
+
+    it 'returns an input parameter array when parameters are unnamed' do
+      output_parameters = @pl_sql.parse_output_parameters(@parameters)
+      expect(output_parameters.size).to be 1
+      expect(output_parameters.keys.first).to be 2
+      expect(output_parameters.values.first).to be :integer
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
 
-require 'active_support'
 require 'arjdbc'
 require 'activerecord/jdbc/plsql'
 

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-plsql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pierrick Rouxel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-25 00:00:00.000000000 Z
+date: 2013-07-26 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -110,6 +96,7 @@ files:
 - activerecord-jdbc-plsql.gemspec
 - lib/activerecord/jdbc/plsql.rb
 - lib/activerecord/jdbc/plsql/version.rb
+- spec/plsql_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/pierrickrouxel/activerecord-jdbc-plsql
 licenses:
@@ -136,4 +123,5 @@ signing_key:
 specification_version: 4
 summary: PL/SQL with Active Record
 test_files:
+- spec/plsql_spec.rb
 - spec/spec_helper.rb