jdbc-helper 0.5.1 → 0.6.0

data/lib/jdbc-helper/connection/callable_statement.rb

@@ -5,69 +5,69 @@ module JDBCHelper
 class Connection
 # Interface to Java CallableStatment
 class CallableStatement < ParameterizedStatement
-	# Array or Hash (for named parameters)
-	# - IN parameter: value
-	# - OUT parameter: class
-	# - INOUT parameter: [value, class]
-	#   (Although class can be inferred from the value, 
-	#   we still need a way to figure out if it's INOUT parameter)
-	def call *params
-		check_closed
+  # Array or Hash (for named parameters)
+  # - IN parameter: value
+  # - OUT parameter: class
+  # - INOUT parameter: [value, class]
+  #   (Although class can be inferred from the value, 
+  #   we still need a way to figure out if it's INOUT parameter)
+  def call *params
+    check_closed
 
-		out_params = set_params(params)
-		measure_exec(:call) { @java_obj.execute }
+    out_params = set_params(params)
+    measure_exec(:call) { @java_obj.execute }
 
-		result = {}
-		out_params.each do |idx, jtype|
-			getter = JDBCHelper::Connection::GETTER_MAP.fetch(jtype, :get_string)
-			value = @java_obj.send(getter, idx.is_a?(Symbol) ? idx.to_s : idx)
-			result[idx] = @java_obj.was_null ? nil : value
-		end
-		result
-	end
+    result = {}
+    out_params.each do |idx, jtype|
+      getter = JDBCHelper::Connection::GETTER_MAP.fetch(jtype, :get_string)
+      value = @java_obj.send(getter, idx.is_a?(Symbol) ? idx.to_s : idx)
+      result[idx] = @java_obj.was_null ? nil : value
+    end
+    result
+  end
 
 private
-	def set_params(params) # :nodoc:
-		hash_params = 
-			if params.first.kind_of? Hash
-				raise ArgumentError.new("More than one Hash given") if params.length > 1
-				params.first
-			else
-				params.each_with_index.inject({}) { |hash, pair|
-					hash[pair.last + 1] = pair.first
-					hash
-				}
-			end
+  def set_params(params) # :nodoc:
+    hash_params = 
+      if params.first.kind_of? Hash
+        raise ArgumentError.new("More than one Hash given") if params.length > 1
+        params.first
+      else
+        params.each_with_index.inject({}) { |hash, pair|
+          hash[pair.last + 1] = pair.first
+          hash
+        }
+      end
 
-		out_params = {}
-		hash_params.each do | idx, value |
-			# Symbols need to be transformed into string
-			idx_ = idx.is_a?(Symbol) ? idx.to_s : idx
-			case value
-			# OUT parameter
-			when Class
-				jtype = JDBCHelper::Connection::RUBY_SQL_TYPE_MAP[value] || java.sql.Types::VARCHAR
-				@java_obj.registerOutParameter(idx_, jtype)
-				out_params[idx] = jtype
+    out_params = {}
+    hash_params.each do | idx, value |
+      # Symbols need to be transformed into string
+      idx_ = idx.is_a?(Symbol) ? idx.to_s : idx
+      case value
+      # OUT parameter
+      when Class
+        jtype = JDBCHelper::Connection::RUBY_SQL_TYPE_MAP[value] || java.sql.Types::VARCHAR
+        @java_obj.registerOutParameter(idx_, jtype)
+        out_params[idx] = jtype
 
-			# INOUT parameter
-			when Array
-				set_param(idx_, value.first)
-				jtype = JDBCHelper::Connection::RUBY_SQL_TYPE_MAP[value.last] || java.sql.Types::VARCHAR
-				@java_obj.registerOutParameter(idx_, jtype)
-				out_params[idx] = jtype
-						
-			# IN parameter
-			else
-				set_param(idx_, value)
-			end
-		end
-		out_params
-	end
+      # INOUT parameter
+      when Array
+        set_param(idx_, value.first)
+        jtype = JDBCHelper::Connection::RUBY_SQL_TYPE_MAP[value.last] || java.sql.Types::VARCHAR
+        @java_obj.registerOutParameter(idx_, jtype)
+        out_params[idx] = jtype
+            
+      # IN parameter
+      else
+        set_param(idx_, value)
+      end
+    end
+    out_params
+  end
 
-	def initialize(*args)
-		super(*args)
-	end
+  def initialize(*args)
+    super(*args)
+  end
 end#CallableStatment
 end#Connection
 end#JDBCHelper

data/lib/jdbc-helper/connection/parameterized_statement.rb

@@ -6,60 +6,71 @@ class Connection
 # Base class for CallableStatement and PreparedStatment
 # @abstract
 class ParameterizedStatement
-	# SQL string
-	# @return [String]
-	attr_reader :sql
+  # SQL string
+  # @return [String]
+  attr_reader :sql
 
-	# Underlying Java object
-	attr_reader :java_obj
+  # Underlying Java object
+  attr_reader :java_obj
 
-	# @param [JDBCHelper::Connection] conn
-	# @param [String] cstmt_str
-	def initialize(conn, sql, obj)
-		@conn = conn
-		@sql = sql
-		@java_obj = obj
-	end
+  # @param [JDBCHelper::Connection] conn
+  # @param [String] cstmt_str
+  def initialize(conn, sql, obj)
+    @conn = conn
+    @sql = sql
+    @java_obj = obj
+  end
 
-	def set_param(idx, param)
-		if setter = (JDBCHelper::Connection::SETTER_MAP[param.class] || 
-							JDBCHelper::Connection::SETTER_MAP[param.class.to_s])
-			case setter
-			when :setNull
-				return @java_obj.send setter, idx, java.sql.Types::NULL
-			when :setBinaryStream
-				return @java_obj.send setter, idx, param.getBinaryStream, param.length
-			when :setTimestamp
-				if param.kind_of?(Time)
-					return @java_obj.send setter, idx, java.sql.Timestamp.new(param.to_i * 1000)
-				end
-			end
+  def set_param(idx, param)
+    case param
+    when NilClass
+      @java_obj.setNull idx, java.sql.Types::NULL
+    when Fixnum
+      @java_obj.setLong idx, param
+    when Bignum
+      @java_obj.setString idx, param.to_s # Safer
+    when BigDecimal
+      @java_obj.setBigDecimal idx, param.to_java
+    when String
+      @java_obj.setString idx, param
+    when Float
+      @java_obj.setDouble idx, param
+    when Time
+      @java_obj.setTimestamp idx, java.sql.Timestamp.new((param.to_f * 1000).to_i)
+    when java.sql.Date
+      @java_obj.setDate idx, param
+    when java.sql.Time
+      @java_obj.setTime idx, param
+    when java.sql.Timestamp
+      @java_obj.setTimestamp idx, param
+    when java.sql.Blob
+      @java_obj.setBinaryStream idx, param.getBinaryStream#, param.length
+    when java.io.InputStream
+      @java_obj.setBinaryStream idx, param
+    else
+      @java_obj.setString idx, param.to_s
+    end
+  end
 
-			@java_obj.send setter, idx, param
-		else
-			@java_obj.set_string idx, param.to_s
-		end
-	end
+  # @return [NilClass]
+  def close
+    @java_obj.close
+    @java_obj = nil
+  end
 
-	# @return [NilClass]
-	def close
-		@java_obj.close
-		@java_obj = nil
-	end
-
-	# @return [Boolean]
-	def closed?
-		@java_obj.nil?
-	end
+  # @return [Boolean]
+  def closed?
+    @java_obj.nil? || @java_obj.isClosed
+  end
 
 private
-	def measure_exec(type, &blk)	# :nodoc:
-		@conn.send(:measure_exec, type, &blk)
-	end
+  def measure_exec(type, &blk)  # :nodoc:
+    @conn.send(:measure_exec, type, &blk)
+  end
 
-	def check_closed
-		raise RuntimeError.new("Object already closed") if closed?
-	end
+  def check_closed
+    raise RuntimeError.new("Object already closed") if closed?
+  end
 
 end#ParameterizedStatement
 end#Connection

data/lib/jdbc-helper/connection/prepared_statement.rb

@@ -12,96 +12,96 @@ class Connection
 #   rows = pstmt.query(10, 20)
 #   enum = pstmt.enumerate(10, 20)
 class PreparedStatement < ParameterizedStatement
-	# Returns the number of parameters required
-	# @return [Fixnum]
-	def parameter_count
-		@pmd ||= @java_obj.get_parameter_meta_data
-		@pmd.get_parameter_count
-	end
-
-	# @return [NilClass]
-	def close
+  # Returns the number of parameters required
+  # @return [Fixnum]
+  def parameter_count
+    @pmd ||= @java_obj.get_parameter_meta_data
+    @pmd.get_parameter_count
+  end
+
+  # @return [NilClass]
+  def close
     @conn.send(:close_pstmt, self)
-		@java_obj.close
-		@java_obj = nil
-	end
-
-	# @return [Fixnum]
-	def update(*params)
-		check_closed
-
-		set_params(params)
-		measure_exec(:p_update) { @java_obj.execute_update }
-	end
-
-	# @return [Array] Returns an Array if block is not given
-	def query(*params, &blk)
-		check_closed
-
-		set_params(params)
-		# sorry, ignoring privacy
-		@conn.send(:process_and_close_rset,
-				   measure_exec(:p_query) { @java_obj.execute_query }, &blk)
-	end
-
-	# @return [JDBCHelper::Connection::ResultSetEnumerator]
-	def enumerate(*params, &blk)
-		check_closed
-
-		return query(*params, &blk) if block_given?
-
-		set_params(params)
-		ResultSetEnumerator.new(measure_exec(:p_query) { @java_obj.execute_query })
-	end
-
-	# Adds to the batch
-	# @return [NilClass]
-	def add_batch(*params)
-		check_closed
-
-		set_params(params)
-		@java_obj.add_batch
-	end
-	# Executes the batch
-	def execute_batch
-		check_closed
-
-		measure_exec(:p_execute_batch) {
-			@java_obj.executeBatch
-		}
-	end
-	# Clears the batch
-	# @return [NilClass]
-	def clear_batch
-		check_closed
-
-		@java_obj.clear_batch
-	end
-
-	# Gives the JDBC driver a hint of the number of rows to fetch from the database by a single interaction.
-	# This is only a hint. It may no effect at all.
-	# @return [NilClass]
-	def set_fetch_size(fsz)
-		check_closed
-
-		@fetch_size = fsz
-		@java_obj.set_fetch_size fsz
-	end
-	alias fetch_size= set_fetch_size
-
-	# Returns the fetch size of the prepared statement. If not set, nil is returned.
-	# @return [Fixnum]
-	attr_reader :fetch_size
+    @java_obj.close
+    @java_obj = nil
+  end
+
+  # @return [Fixnum]
+  def update(*params)
+    check_closed
+
+    set_params(params)
+    measure_exec(:p_update) { @java_obj.execute_update }
+  end
+
+  # @return [Array] Returns an Array if block is not given
+  def query(*params, &blk)
+    check_closed
+
+    set_params(params)
+    # sorry, ignoring privacy
+    @conn.send(:process_and_close_rset,
+           measure_exec(:p_query) { @java_obj.execute_query }, &blk)
+  end
+
+  # @return [JDBCHelper::Connection::ResultSetEnumerator]
+  def enumerate(*params, &blk)
+    check_closed
+
+    return query(*params, &blk) if block_given?
+
+    set_params(params)
+    ResultSetEnumerator.new(measure_exec(:p_query) { @java_obj.execute_query })
+  end
+
+  # Adds to the batch
+  # @return [NilClass]
+  def add_batch(*params)
+    check_closed
+
+    set_params(params)
+    @java_obj.add_batch
+  end
+  # Executes the batch
+  def execute_batch
+    check_closed
+
+    measure_exec(:p_execute_batch) {
+      @java_obj.executeBatch
+    }
+  end
+  # Clears the batch
+  # @return [NilClass]
+  def clear_batch
+    check_closed
+
+    @java_obj.clear_batch
+  end
+
+  # Gives the JDBC driver a hint of the number of rows to fetch from the database by a single interaction.
+  # This is only a hint. It may no effect at all.
+  # @return [NilClass]
+  def set_fetch_size(fsz)
+    check_closed
+
+    @fetch_size = fsz
+    @java_obj.set_fetch_size fsz
+  end
+  alias fetch_size= set_fetch_size
+
+  # Returns the fetch size of the prepared statement. If not set, nil is returned.
+  # @return [Fixnum]
+  attr_reader :fetch_size
 private
-	def set_params(params) # :nodoc:
-		params.each_with_index do | param, idx |
-			set_param(idx + 1, param)
-		end
-	end
-
-	def initialize(*args)
-		super(*args)
-	end
+  def set_params(params) # :nodoc:
+    params.each_with_index do | param, idx |
+      set_param(idx + 1, param)
+    end
+  end
+
+  def initialize(*args)
+    super(*args)
+  end
 end#PreparedStatment
 end#Connection
 end#JDBCHelper

data/lib/jdbc-helper/connection/result_set_enumerator.rb

@@ -1,115 +1,126 @@
 # encoding: UTF-8
 # Junegunn Choi (junegunn.c@gmail.com)
 
+require 'bigdecimal'
+
 module JDBCHelper
 class Connection
 # Class for enumerating query results.
 # Automatically closed after used. When not used, you must close it explicitly by calling "close".
 class ResultSetEnumerator
-	include Enumerable
+  include Enumerable
 
-	def each
-		return if closed?
+  def each
+    return if closed?
 
-		count = -1
-		begin
-			while @rset.next
-				idx = 0
-				# Oracle returns numbers in NUMERIC type, which can be of any precision.
-				# So, we retrieve the numbers in String type not to lose their precision.
-				# This can be quite annoying when you're just working with integers,
-				# so I tried the following code to automatically convert integer string into integer
-				# when it's obvious. However, the performance drop is untolerable.
-				# Thus, commented out.
-				#
-				# if v && @cols_meta[i-1] == java.sql.Types::NUMERIC && v !~ /[\.e]/i
-				# 	v.to_i
-				# else
-				# 	v
-				# end
-				yield Connection::Row.new(
-						@col_labels,
-						@col_labels_d,
-						@getters.map { |gt|
-							v = @rset.send gt, idx+=1
-							@rset.was_null ? nil : v
-						},
-						count += 1)
-			end
-		ensure			
-			close
-		end
-	end
+    count = -1
+    begin
+      while @rset.next
+        idx = 0
+        # Oracle returns numbers in NUMERIC type, which can be of any precision.
+        # So, we retrieve the numbers in String type not to lose their precision.
+        # This can be quite annoying when you're just working with integers,
+        # so I tried the following code to automatically convert integer string into integer
+        # when it's obvious. However, the performance drop is untolerable.
+        # Thus, commented out.
+        #
+        # if v && @cols_meta[i-1] == java.sql.Types::NUMERIC && v !~ /[\.e]/i
+        #   v.to_i
+        # else
+        #   v
+        # end
+        yield Connection::Row.new(
+            @col_labels,
+            @col_labels_d,
+            @getters.map { |gt|
+              case gt
+              when :getBigNum
+                v = @rset.getBigDecimal idx+=1
+                @rset.was_null ? nil : BigDecimal.new(v.toPlainString).to_i
+              when :getBigDecimal
+                v = @rset.getBigDecimal idx+=1
+                @rset.was_null ? nil : BigDecimal.new(v.toPlainString)
+              else
+                v = @rset.send gt, idx+=1
+                @rset.was_null ? nil : v
+              end
+            },
+            count += 1)
+      end
+    ensure
+      close
+    end
+  end
 
-	def close
-		return if closed?
+  def close
+    return if closed?
 
-		@rset.close
-		@close_callback.call if @close_callback
-		@closed = true
-	end
+    @rset.close
+    @close_callback.call if @close_callback
+    @closed = true
+  end
 
-	def closed?
-		@closed
-	end
+  def closed?
+    @closed
+  end
 
 private
-	def initialize(rset, &close_callback) # :nodoc:
-		unless rset.respond_to? :get_meta_data
-			rset.close if rset
-			@closed = true
-			return
-		end
+  def initialize(rset, &close_callback) # :nodoc:
+    unless rset.respond_to? :get_meta_data
+      rset.close if rset
+      @closed = true
+      return
+    end
 
-		@close_callback = close_callback
-		@rset = rset
-		@rsmd = @rset.get_meta_data
-		@num_col = @rsmd.get_column_count
-		@getters = []
-		@col_labels = []
-		@col_labels_d = []
-		(1..@num_col).each do | i |
-			type = @rsmd.get_column_type(i)
+    @close_callback = close_callback
+    @rset = rset
+    @rsmd = @rset.get_meta_data
+    @num_col = @rsmd.get_column_count
+    @getters = []
+    @col_labels = []
+    @col_labels_d = []
+    (1..@num_col).each do | i |
+      type = @rsmd.get_column_type(i)
 
-			@getters <<
-				case type
-				when java.sql.Types::NUMERIC, java.sql.Types::DECIMAL
-					precision = @rsmd.get_precision(i)
-					scale = @rsmd.get_scale(i)
+      @getters <<
+        case type
+        when java.sql.Types::NUMERIC, java.sql.Types::DECIMAL
+          precision = @rsmd.get_precision(i)
+          scale = @rsmd.get_scale(i)
 
-					if precision > 0 && scale >= 0
-						# Numbers with fractional parts
-						if scale > 0
-							if precision <= 16
-								:getFloat
-							else
-								:getString
-							end
-						# Numbers without fractional parts
-						else
-							if precision <= 9
-								:getInt
-							elsif precision <= 18
-								:getLong
-							else
-								:getString
-							end
-						end
-					# No guarantee
-					else
-						:getString
-					end
-				else
-					JDBCHelper::Connection::GETTER_MAP.fetch(type, :get_string)
-				end
+          if precision > 0 && scale >= 0
+            # Numbers with fractional parts
+            if scale > 0
+              if precision <= 15
+                :getDouble
+              else
+                :getBigDecimal
+              end
+            # Numbers without fractional parts
+            else
+              if precision <= 9
+                :getInt
+              elsif precision <= 18
+                :getLong
+              else
+                :getBigNum
+              end
+            end
+          # No guarantee
+          else
+            :getBigDecimal
+          end
+        else
+          JDBCHelper::Connection::GETTER_MAP.fetch(type, :get_string)
+        end
 
-			@col_labels << @rsmd.get_column_label(i)
-			@col_labels_d << @col_labels.last.downcase
+      @col_labels << @rsmd.get_column_label(i)
+      @col_labels_d << @col_labels.last.downcase
 
-		end
+    end
 
-		@closed = false
-	end
+    @closed = false
+  end
 end#ResultSetEnumerator
 end#Connection
 end#JDBCHelper