jdbc-helper 0.1.2

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

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# An encapsulation of Java PreparedStatment object.
+# Used to execute parameterized queries efficiently.
+# Has a very similar set of interface as JDBCHelper::Connection.
+#
+# e.g.
+#
+#   pstmt = conn.prepare("SELECT * FROM T WHERE a = ? and b = ?")
+#   rows = pstmt.query(10, 20)
+#   enum = pstmt.enumerate(10, 20)
+#
+class Connection
+class PreparedStatement
+	attr_reader :sql
+
+	# Returns the encapsulated JDBC PreparedStatement object.
+	def java_obj
+		@pstmt
+	end
+
+	# Returns the number of parameters required
+	def parameter_count
+		@pmd ||= @pstmt.get_parameter_meta_data
+		@pmd.get_parameter_count
+	end
+
+	def update(*params)
+		check_closed
+
+		set_params(params)
+		measure(:p_update) { @pstmt.execute_update }
+	end
+
+	def query(*params, &blk)
+		check_closed
+
+		set_params(params)
+		# sorry, ignoring privacy
+		@conn.send(:process_and_close_rset,
+				   measure(:p_query) { @pstmt.execute_query }, &blk)
+	end
+
+	def enumerate(*params, &blk)
+		check_closed
+
+		return query(*params, &blk) if block_given?
+
+		set_params(params)
+		ResultSetEnumerator.new(measure(:p_query) { @pstmt.execute_query })
+	end
+
+	# batch interface
+	def add_batch(*params)
+		check_closed
+
+		set_params(params)
+		@pstmt.add_batch
+	end
+	def execute_batch
+		check_closed
+
+		measure(:p_execute_batch) {
+			@pstmt.executeBatch
+		}
+	end
+	def clear_batch
+		check_closed
+
+		@pstmt.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.
+	def set_fetch_size(fsz)
+		check_closed
+
+		@pstmt.set_fetch_size fsz
+	end
+
+	def close
+		return if closed?
+		@pstmt.close
+		@pstmts.delete @sql
+		@pstmt = @pstmts = nil
+	end
+
+	def closed?
+		@pstmt.nil?
+	end
+private
+	def initialize(conn, pstmts, sql, pstmt) # :nodoc:
+		@conn = conn
+		@pstmts = pstmts
+		@sql = sql
+		@pstmt = pstmt
+	end
+
+	def set_params(params) # :nodoc:
+		idx = 0
+		params.each do | param |
+			if param.nil?
+				@pstmt.set_null(idx += 1, java.sql.Types::NULL)
+			elsif setter = SETTER_MAP[param.class.to_s]
+				if setter == :setBinaryStream
+					@pstmt.send(setter, idx += 1,
+								param.getBinaryStream, param.length)
+				else
+					@pstmt.send(setter, idx += 1, param)
+				end
+			else
+				@pstmt.set_string(idx += 1, param.to_s)
+			end
+		end
+	end
+
+	def measure(type, &blk)	# :nodoc:
+		@conn.send(:measure, type, &blk)
+	end
+
+	def check_closed
+		raise RuntimeError.new("Prepared statement already closed") if closed?
+	end
+
+	SETTER_MAP =
+	{
+ 		'java.sql.Date' => :setDate,
+ 		'java.sql.Time' => :setTime,
+ 		'java.sql.Timestamp' => :setTimestamp,
+		'java.sql.Blob' => :setBinaryStream,
+
+		'com.mysql.jdbc.Blob' => :setBinaryStream
+		# FIXME-MORE
+	} # :nodoc:
+
+end#PreparedStatment
+end#Connection
+end#JDBCHelper
+

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

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Class for enumerating query results
+# Automatically closed after used. When not used, you must close it explicitly by calling "close".
+class Connection
+class ResultSetEnumerator
+	include Enumerable
+
+	def each
+		return if closed?
+
+		count = -1
+		begin
+			while @rset.next
+				yield Connection::Row.new(
+						@col_labels,
+						(1..@num_col).map { | i |
+							v = @rset.send(GETTER_MAP.fetch(@cols_meta[i-1], :get_string), i)
+							@rset.was_null ? nil : v
+						},
+						count += 1)
+			end
+		ensure			
+			close
+		end
+	end
+
+	def close
+		return if closed?
+
+		@rset.close
+		@close_callback.call if @close_callback
+		@closed = true
+	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
+
+		@close_callback = close_callback
+		@rset = rset
+		@rsmd = @rset.get_meta_data
+		@num_col = @rsmd.get_column_count
+		@cols_meta = []
+		@col_labels = []
+		(1..@num_col).each do | i |
+			@cols_meta << @rsmd.get_column_type(i)
+			@col_labels << @rsmd.get_column_label(i)
+		end
+
+		@closed = false
+	end
+
+	GETTER_MAP =
+	{
+		java.sql.Types::TINYINT => :get_int,
+		java.sql.Types::SMALLINT => :get_int,
+		java.sql.Types::INTEGER => :get_int,
+		java.sql.Types::BIGINT => :get_long,
+
+		java.sql.Types::CHAR => :get_string,
+		java.sql.Types::VARCHAR => :get_string,
+		java.sql.Types::LONGVARCHAR => :get_string,
+		(java.sql.Types::NCHAR        rescue nil) => :get_string,
+		(java.sql.Types::NVARCHAR     rescue nil) => :get_string,
+		(java.sql.Types::LONGNVARCHAR rescue nil) => :get_blob, # FIXME: MySQL
+		java.sql.Types::BINARY => :get_string,
+		java.sql.Types::VARBINARY => :get_string,
+		java.sql.Types::LONGVARBINARY => :get_blob,	# FIXME: MySQL
+
+		java.sql.Types::REAL => :get_double,
+		java.sql.Types::FLOAT => :get_float,
+		java.sql.Types::DOUBLE => :get_double,
+		java.sql.Types::NUMERIC => :get_string, # FIXME
+		java.sql.Types::DECIMAL => :get_string, # FIXME
+
+		java.sql.Types::DATE => :get_date,
+		java.sql.Types::TIME => :get_time,
+		java.sql.Types::TIMESTAMP => :get_timestamp,
+
+		java.sql.Types::BLOB => :get_blob,
+		java.sql.Types::CLOB => :get_string,
+		(java.sql.Types::NCLOB rescue nil) => :get_string,
+
+		java.sql.Types::BOOLEAN => :get_boolean
+	} # :nodoc:
+end#ResultSetEnumerator
+end#Connection
+end#JDBCHelper
+

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

@@ -0,0 +1,110 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# The result of database queries.
+# Designed to be very flexible on its interface.
+# You can access it like an array, a hash or an ORM object.
+#
+# e.g.
+#
+#   conn.query('SELECT a, b, c FROM t') do | row |
+#       puts row.a
+#       puts row[1]
+#       puts row['c']
+#
+#       row.each do | value |
+#           # ...
+#       end
+#
+#       labels = row.labels   # equal to `row.keys`
+#       values = row.to_a     # equal to `row.values`
+#
+#       puts row.rownum
+#   end
+#
+class Connection
+class Row
+	attr_reader :labels, :values, :rownum
+	alias_method :keys, :labels
+
+	include Enumerable
+
+	def [](idx)
+		if idx.is_a? Fixnum
+			raise RangeError.new("Index out of bound") if idx >= @values.length
+			@values[idx]
+		else
+			# case-insensitive, assuming no duplicate labels
+			vidx = @labels_d.index(idx.downcase) or
+				raise NameError.new("Unknown column label: #{idx}")
+			@values[vidx]
+		end
+	end
+
+	def each(&blk)
+		@values.each { | v | yield v }
+
+		# @labels.each_with_index do | label, idx |
+		# 	yield label, @values[idx]
+		# end
+	end
+
+	def inspect
+		strs = []
+		@labels.each do | col |
+			strs << "#{col}: #{self[col] || '(null)'}"
+		end
+		'[' + strs.join(', ') + ']'
+	end
+
+	def to_s
+		@values.to_s
+	end
+
+	def to_a
+		@values
+	end
+
+	def join(sep = $,)
+		to_a.join(sep)
+	end
+
+	def eql?(other)
+		self.hash == other.hash
+	end
+
+	def hash # :nodoc:
+		@labels.zip(@values).sort.hash
+	end
+
+	alias :== :eql?
+
+private
+	def initialize(col_labels, values, rownum) # :nodoc:
+		@labels = col_labels
+		@labels_d = col_labels.map { | l | l.downcase }
+		@values = values
+		@rownum = rownum
+	end
+
+	def method_missing(symb, *args)
+		if vidx = @labels_d.index(symb.to_s.downcase)
+			@values[vidx]
+		elsif @values.respond_to?(symb)
+			@values.send(symb, *args)
+		else
+			raise NameError.new("Unknown method: #{symb}")
+		end
+	end
+
+	# Remove dangerous default methods
+	# excluding :object_id, :hash
+	[:id, :tap, :gem, :display, :class, :method, :methods, :trust].
+	select { | s | method_defined? s }.each do | m |
+		undef_method m
+	end
+end#Row
+end#Connection
+end#JDBCHelper
+

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

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Internal implementation for supporting query nesting.
+# Not thread-safe. Well, sharing a JDBC connection between threads is not the best idea anyway.
+class Connection
+class StatementPool # :nodoc:
+	def initialize(conn, max_size = 20)
+		@conn = conn
+		@max_size = max_size # TODO
+		@free = []
+		@occupied = []
+	end
+
+	def with
+		begin
+			yield stmt = take
+		ensure
+			give stmt
+		end
+	end
+
+	def take
+		if @free.empty?
+			raise Exception.new("Nesting too deep") if
+					@occupied.length >= @max_size
+			@occupied << nstmt = @conn.send(:create_statement)
+			nstmt
+		else
+			stmt = @free.pop
+			@occupied << stmt
+			stmt
+		end
+	end
+
+	def give(stmt)
+		raise Exception.new("Not my statement") unless
+				@occupied.include? stmt
+
+		@occupied.delete stmt
+		@free << stmt
+	end
+
+	def close
+		(@free + @occupied).each do | stmt |
+			stmt.close
+		end
+		@conn = nil
+		@free = []
+		@occupied = []
+	end
+
+	def each
+		(@free + @occupied).each do | stmt |
+			yield stmt
+		end
+	end
+end#StatementPool
+end#Connection
+end#JDBCHelper

data/lib/jdbc-helper/connector.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+require 'jdbc-helper/connector/oracle_connector'
+require 'jdbc-helper/connector/mysql_connector'
+

data/lib/jdbc-helper/connector/mysql_connector.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Shortcut connector for MySQL
+class MySQLConnector
+	include Constants
+	include Constants::Connector
+
+	def self.connect(host, user, password, db,
+					 timeout = DEFAULT_LOGIN_TIMEOUT, 
+					 extra_params = DEFAULT_PARAMETERS[:mysql])
+
+		if extra_params && extra_params.is_a?(Hash) == false
+			raise ArgumentError.new('extra_params must be a hash')
+		end
+
+		Connection.new(
+			(extra_params || {}).merge(
+				:driver   => JDBC_DRIVER[:mysql],
+				:url      => "jdbc:mysql://#{host}/#{db}",
+				:user     => user,
+				:password => password,
+				:timeout  => timeout))
+	end
+end#MySQLConnector
+end#JDBCHelper
+