jdbc-helper 0.5.1 → 0.6.0

data/README.markdown

@@ -0,0 +1,251 @@
+```
+    _     _ _                 _          _                 
+   (_)   | | |               | |        | |                
+    _  __| | |__   ___ ______| |__   ___| |_ __   ___ _ __ 
+   | |/ _` | '_ \ / __|______| '_ \ / _ \ | '_ \ / _ \ '__|
+   | | (_| | |_) | (__       | | | |  __/ | |_) |  __/ |   
+   | |\__,_|_.__/ \___|      |_| |_|\___|_| .__/ \___|_|   
+  _/ |                                    | |              
+ |__/                                     |_|              
+```
+
+# jdbc-helper
+
+A JDBC helper for Ruby/Database developers.
+JDBCHelper::Connection object wraps around a JDBC connection and provides much nicer interface to
+crucial database operations from primitive selects and updates to more complex ones involving
+batch updates, prepared statements and transactions.
+As the name implies, this gem only works on JRuby.
+
+## Installation
+### Install gem
+```
+gem install jdbc-helper
+```
+
+### Setting up CLASSPATH
+Add the appropriate JDBC drivers to the CLASSPATH.
+
+```
+export CLASSPATH=$CLASSPATH:~/lib/mysql-connector-java-5.1.16-bin.jar:~/lib/ojdbc6.jar
+```
+
+### In Ruby
+```ruby
+require 'jdbc-helper'
+```
+
+## Examples
+### Connecting to a database
+```ruby
+# :driver and :url must be given
+conn = JDBCHelper::Connection.new(
+             :driver => 'com.mysql.jdbc.Driver',
+             :url    => 'jdbc:mysql://localhost/test')
+conn.close
+
+
+# Optional :user and :password
+conn = JDBCHelper::Connection.new(
+             :driver   => 'com.mysql.jdbc.Driver',
+             :url      => 'jdbc:mysql://localhost/test',
+             :user     => 'mysql',
+             :password => '')
+conn.close
+
+
+# MySQL shortcut connector
+conn = JDBCHelper::MySQLConnector.connect('localhost', 'mysql', '', 'test')
+conn.close
+
+# Oracle shortcut connector
+conn = JDBCHelper::OracleConnector.connect(host, user, password, service_name)
+conn.close
+```
+
+### Querying database table
+
+```ruby
+conn.query("SELECT a, b, c FROM T") do |row|
+  row.labels
+  row.rownum
+
+  row.a, row.b, row.c          # Dot-notation
+  row[0], row[1], row[2]       # Numeric index
+  row['a'], row['b'], row['c'] # String index. Case-insensitive.
+  row[:a], row[:b], row[:c]    # Symbol index. Case-insensitive.
+
+  row[0..-1]                   # Range index. Returns an array of values.
+  row[0, 3]                    # Offset and length. Returns an array of values.
+end
+
+# Returns an array of rows when block is not given
+rows = conn.query("SELECT b FROM T")
+uniq_rows = rows.uniq
+
+# You can even nest queries
+conn.query("SELECT a FROM T") do |row1|
+  conn.query("SELECT * FROM T_#{row1.a}") do |row2|
+    # ...
+  end
+end
+
+# `enumerate' method returns an Enumerable object if block is not given.
+# When the result set of the query is expected to be large and you wish to
+# chain enumerators, `enumerate' is much preferred over `query'. (which returns the
+# array of the entire rows)
+conn.enumerate("SELECT * FROM LARGE_T").each_slice(1000) do |slice|
+  slice.each do | row |
+    # ...
+  end
+end
+```
+
+### Updating database table
+```ruby
+del_count = conn.update("DELETE FROM T")
+```
+
+### Transaction
+```ruby
+committed = conn.transaction do |tx|
+  # ...
+  # Transaction logic here
+  # ...
+
+  if success
+    tx.commit
+  else
+    tx.rollback
+  end
+  # You never reach here.
+end
+```
+
+### Using batch interface
+```ruby
+conn.add_batch("DELETE FROM T");
+conn.execute_batch
+conn.add_batch("DELETE FROM T");
+conn.clear_batch
+```
+
+### Using prepared statements
+```ruby
+p_sel = conn.prepare("SELECT * FROM T WHERE b = ? and c = ?")
+p_sel.query(100, 200) do |row|
+  p row
+end
+p_sel.close
+
+p_upd = conn.prepare("UPDATE T SET a = ? WHERE b = ?")
+count = 0
+100.times do |i|
+  count += p_upd.update('updated a', i)
+end
+
+p_upd.add_batch('pstmt + batch', 10)
+p_upd.add_batch('pstmt + batch', 20)
+p_upd.add_batch('pstmt + batch', 30)
+p_upd.execute_batch
+p_upd.close
+```
+
+### Using table wrappers (since 0.2.0)
+```ruby
+# For more complex examples, refer to test/test_object_wrapper.rb
+
+# Creates a table wrapper
+table = conn.table('test.data')
+
+# Counting the records in the table
+table.count
+table.count(:a => 10)
+table.where(:a => 10).count
+
+table.empty?
+table.where(:a => 10).empty?
+
+# Selects the table by combining select, where, and order methods
+table.select('a apple', :b).where(:c => (1..10)).order('b desc', 'a asc') do |row|
+  puts row.apple
+end
+
+# Build select SQL
+sql = table.select('a apple', :b).where(:c => (1..10)).order('b desc', 'a asc').sql
+
+# Updates with conditions
+table.update(:a => 'hello', :b => JDBCHelper::SQL('now()'), :where => { :c => 3 })
+# Or equivalently,
+table.where(:c => 3).update(:a => 'hello', :b => JDBCHelper::SQL('now()'))
+
+# Insert into the table
+table.insert(:a => 10, :b => 20, :c => JDBCHelper::SQL('10 + 20'))
+table.insert_ignore(:a => 10, :b => 20, :c => 30)
+table.replace(:a => 10, :b => 20, :c => 30)
+
+# Update with common default values
+with_defaults = table.default(:a => 10, :b => 20)
+with_defaults.insert(:c => 30)
+with_defaults.where('a != 10 or b != 20').update   # sets a => 10, b => 20
+
+# Batch updates with batch method
+table.batch.insert(:a => 10, :b => 20, :c => JDBCHelper::SQL('10 + 20'))
+table.batch.insert_ignore(:a => 10, :b => 20, :c => 30)
+conn.execute_batch
+
+# Delete with conditions
+table.delete(:c => 3)
+# Or equivalently,
+table.where(:c => 3).delete
+
+# Truncate or drop table (Cannot be undone)
+table.truncate!
+table.drop!
+```
+
+### Using function wrappers (since 0.2.2)
+```ruby
+conn.function(:mod).call 5, 3
+conn.function(:coalesce).call(nil, nil, 'king')
+```
+
+### Using procedure wrappers (since 0.3.0)
+```ruby
+# Working with IN/INOUT/OUT parameteres
+# Bind by ordinal number
+conn.procedure(:update_and_fetch_something).call(
+         100,                 # Input parameter 
+         ["value", String],   # Input/Output parameter
+         Fixnum               # Output parameter
+)
+
+# Bind by parameter name
+conn.procedure(:update_and_fetch_something).call(
+         :a => 100, :b => ["value", String], :c => Fixnum)
+```
+
+### Using sequence wrappers (since 0.4.2)
+```ruby
+seq = conn.sequence(:my_seq)
+next = seq.nextval
+curr = seq.currval
+seq.reset!
+seq.reset! 100
+```
+
+## Contributing to jdbc-helper
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
+further details.
+

data/lib/jdbc-helper.rb

@@ -2,19 +2,10 @@
 # Junegunn Choi (junegunn.c@gmail.com)
 
 if RUBY_PLATFORM.match(/java/).nil?
-	raise LoadError, 'JRuby is required for JDBC'
+  raise LoadError, 'JRuby is required for JDBC'
 end
 
 require 'java'
-
-module JavaLang # :nodoc:
-	include_package 'java.lang'
-end
-
-module JavaSql # :nodoc:
-	include_package 'java.sql'
-end
-
 require 'jdbc-helper/sql'
 require 'jdbc-helper/sql_prepared'
 require 'jdbc-helper/constants'

data/lib/jdbc-helper/connection.rb

@@ -46,7 +46,7 @@ module JDBCHelper
 #  # MySQL shortcut connector
 #  conn = JDBCHelper::MySQLConnector.connect('localhost', 'mysql', '', 'test')
 #  conn.close
-#	
+#  
 # @example Querying database table
 #
 #  conn.query("SELECT a, b, c FROM T") do | row |
@@ -109,89 +109,85 @@ module JDBCHelper
 #  p_upd.execute_batch
 #  p_upd.close
 class Connection
-	# Returns the statistics of the previous operation
-	# @return [JDBCHelper::Connection::Stat] The statistics of the previous operation.
-	def prev_stat
-		@prev_stat.dup
-	end
-
-	# Returns the accumulated statistics of each operation
-	# @return [Hash] Accumulated statistics of each type of operation
-	attr_reader :stats
-
-	# JDBC URL of the connection
-	# @return [String]
-	attr_reader :url
-
-	# JDBC driver of the connection
-	# @return [String]
-	attr_reader :driver
-
-	# Returns the underlying JDBC Connection object.
-	# Only use this when you really need to access it directly.
-	def jdbc_conn
-		@conn
-	end
-	alias java_obj jdbc_conn
-
-	# Creates a database connection.
-	# - `args` hash must include :driver (or "driver") and :url (or "url")
-	# - and takes optional :user and :password tuples (or "user", "password")
-	# - You can also specify :timeout (or "timeout") to override the default connection timeout (60 seconds)
-	#
-	# Must be closed explicitly if not used.
-	# If a block is given, the connection is automatically closed after executing the block.
-	# @param [Hash] args
-	def initialize(args = {})
-		# Subsequent deletes should not affect the input
+  # Returns the statistics of the previous operation
+  # @return [JDBCHelper::Connection::Stat] The statistics of the previous operation.
+  def prev_stat
+    @prev_stat.dup
+  end
+
+  # Returns the accumulated statistics of each operation
+  # @return [Hash] Accumulated statistics of each type of operation
+  attr_reader :stats
+
+  # JDBC URL of the connection
+  # @return [String]
+  attr_reader :url
+
+  # JDBC driver of the connection
+  # @return [String]
+  attr_reader :driver
+
+  # Returns the underlying JDBC Connection object.
+  # Only use this when you really need to access it directly.
+  def jdbc_conn
+    @conn
+  end
+  alias java_obj jdbc_conn
+
+  # Creates a database connection.
+  # - `args` hash must include :driver (or "driver") and :url (or "url")
+  # - and takes optional :user and :password tuples (or "user", "password")
+  # - You can also specify :timeout (or "timeout") to override the default connection timeout (60 seconds)
+  #
+  # Must be closed explicitly if not used.
+  # If a block is given, the connection is automatically closed after executing the block.
+  # @param [Hash] args
+  def initialize(args = {})
+    # Subsequent deletes should not affect the input
     @args = args.dup
-		args = @args.dup
+    args = @args.dup
 
-		# String/Symbol
-		%w[driver url user password timeout].each do | strk |
-			args[strk.to_sym] = args.delete strk if args.has_key? strk
-		end
+    # String/Symbol
+    %w[driver url user password timeout].each do | strk |
+      args[strk.to_sym] = args.delete strk if args.has_key? strk
+    end
 
-		raise ArgumentError.new("driver not given") unless args.has_key? :driver
-		raise ArgumentError.new("url not given") unless args.has_key? :url
+    raise ArgumentError.new("driver not given") unless args.has_key? :driver
+    raise ArgumentError.new("url not given") unless args.has_key? :url
 
-		@driver = args.delete :driver
-		@url = args.delete :url
+    @driver = args.delete :driver
+    @url = args.delete :url
 
-		begin
-			Java::JavaClass.for_name @driver
-		rescue Exception
-			# TODO
-			raise
-		end
+    # NameError will be thrown for invalid drivers
+    Java::JavaClass.for_name @driver
 
-		timeout = args.has_key?(:timeout) ? args.delete(:timeout) : Constants::DEFAULT_LOGIN_TIMEOUT
-		JavaSql::DriverManager.setLoginTimeout timeout if timeout
+    timeout = args.has_key?(:timeout) ? args.delete(:timeout) : Constants::DEFAULT_LOGIN_TIMEOUT
+    java.sql.DriverManager.setLoginTimeout timeout if timeout
 
-		props = java.util.Properties.new
-		(args.keys - [:url, :driver]).each do | key |
-			props.setProperty(key.to_s, args[key].to_s) if args[key]
-		end
-		
-		@conn = JavaSql::DriverManager.get_connection(@url, props)
-		@spool = StatementPool.send :new, self
-		@bstmt = nil
+    props = java.util.Properties.new
+    (args.keys - [:url, :driver]).each do | key |
+      props.setProperty(key.to_s, args[key].to_s) if args[key]
+    end
+    
+    @conn = java.sql.DriverManager.get_connection(@url, props)
+    @spool = StatementPool.send :new, self
+    @bstmt = nil
 
-		@stats = Hash.new { | h, k | h[k] = Stat.new(k, 0, 0, 0) }
-		@prev_stat = Stat.new(nil, 0, 0, 0)
+    @stats = Hash.new { | h, k | h[k] = Stat.new(k, 0, 0, 0) }
+    @prev_stat = Stat.new(nil, 0, 0, 0)
 
     @pstmts = []
     
     @table_wrappers = {}
 
-		if block_given?
-			begin
-				yield self
-			ensure
-				close rescue nil
-			end
-		end
-	end
+    if block_given?
+      begin
+        yield self
+      ensure
+        close rescue nil
+      end
+    end
+  end
 
   # Creates another connection with the same parameters as this Connection.
   # @return [JDBCHelper::Connection]
@@ -201,140 +197,140 @@ class Connection
     nc
   end
 
-	# Creates a prepared statement, which is also an encapsulation of Java PreparedStatement object
-	# @param [String] qstr SQL string
-	def prepare(qstr)
-		check_closed
+  # Creates a prepared statement, which is also an encapsulation of Java PreparedStatement object
+  # @param [String] qstr SQL string
+  def prepare(qstr)
+    check_closed
 
-		pstmt = PreparedStatement.send(:new, self, qstr,
-				measure_exec(:prepare) { @conn.prepare_statement(qstr) })
+    pstmt = PreparedStatement.send(:new, self, qstr,
+        measure_exec(:prepare) { @conn.prepare_statement(qstr) })
     @pstmts << pstmt
     pstmt
-	end
+  end
 
   # @return [Array] Prepared statements currently opened for this connection
   def prepared_statements
     @pstmts
   end
 
-	# Creates a callable statement.
-	# @param [String] qstr SQL string
-	def prepare_call(qstr)
-		check_closed
-
-		CallableStatement.send(:new, self, qstr,
-				measure_exec(:prepare_call) { @conn.prepare_call qstr })
-	end
-
-	# Executes the given code block as a transaction. Returns true if the transaction is committed.
-	# A transaction object is passed to the block, which only has commit and rollback methods.
-	# The execution breaks out of the code block when either of the methods is called.
-	# @yield [JDBCHelper::Connection::Transaction] Responds to commit and rollback.
-	# @return [Boolean] True if committed
-	def transaction
-		check_closed
-
-		raise ArgumentError.new("Transaction block not given") unless block_given?
-		tx = Transaction.send :new, @conn
-		ac = @conn.get_auto_commit
-		status = :unknown
-		begin
-			@conn.set_auto_commit false
-			yield tx
-			@conn.commit
-			status = :committed
-		rescue Transaction::Commit
-			status = :committed
-		rescue Transaction::Rollback
-			status = :rolledback
-		ensure
-			@conn.rollback if status == :unknown
-			@conn.set_auto_commit ac
-		end
-		status == :committed
-	end
-
-	# Executes an update and returns the count of the updated rows.
-	# @param [String] qstr SQL string
-	# @return [Fixnum] Count of affected records
-	def update(qstr)
-		check_closed
-
-		@spool.with do | stmt |
-			ret = measure_exec(:update) { stmt.execute_update(qstr) }
-		end
-	end
-
-	# Executes a select query.
-	# When a code block is given, each row of the result is passed to the block one by one.
-	# If a code block not given, this method will return the array of the entire result rows.
-	# (which can be pretty inefficient when the result set is large. In such cases, use enumerate instead.)
-	#
-	# The concept of statement object of JDBC is encapsulated, so there's no need to do additional task,
-	# when you nest select queries, for example.
-	#
-	#   conn.query("SELECT a FROM T") do | trow |
-	#       conn.query("SELECT * FROM U_#{trow.a}") do | urow |
-	#           # ... and so on ...
-	#       end
-	#   end
-	# @param [String] qstr SQL string
-	# @yield [JDBCHelper::Connection::Row]
-	# @return [Array]
-	def query(qstr, &blk)
-		check_closed
-
-		@spool.with do | stmt |
-			measure_exec(:query) { stmt.execute(qstr) }
-			process_and_close_rset(stmt.get_result_set, &blk)
-		end
-	end
-
-	# Returns an enumerable object of the query result.
-	# "enumerate" method is preferable when dealing with a large result set,
-	# since it doesn't have to build a large array.
-	#
-	# The returned enumerator is automatically closed after enumeration.
-	#
-	#   conn.enumerate('SELECT * FROM T').each_slice(10) do | slice |
-	#       slice.each { | row | print row }
-	#       puts
-	#   end
-	#
-	# @param [String] qstr SQL string
-	# @yield [JDBCHelper::Connection::Row] Yields each record if block is given
-	# @return [JDBCHelper::Connection::ResultSetEnumerator] Returns an enumerator if block is not given
-	def enumerate(qstr, &blk)
-		check_closed
-
-		return query(qstr, &blk) if block_given?
-
-		stmt = @spool.take
-		begin
-			measure_exec(:query) { stmt.execute(qstr) }
-		rescue Exception
-			@spool.give stmt
-			raise
-		end
-
-		ResultSetEnumerator.send(:new, stmt.get_result_set) { @spool.give stmt }
-	end
-
-	# Adds a statement to be executed in batch
-	# Adds to the batch
-	# @param [String] qstr
-	# @return [NilClass]
-	def add_batch(qstr)
-		check_closed
-
-		@bstmt ||= @spool.take
-		@bstmt.add_batch qstr
-	end
-
-	# Executes batched statements including prepared statements. No effect when no statment is added
-	# @return [NilClass]
-	def execute_batch
-		check_closed
+  # Creates a callable statement.
+  # @param [String] qstr SQL string
+  def prepare_call(qstr)
+    check_closed
+
+    CallableStatement.send(:new, self, qstr,
+        measure_exec(:prepare_call) { @conn.prepare_call qstr })
+  end
+
+  # Executes the given code block as a transaction. Returns true if the transaction is committed.
+  # A transaction object is passed to the block, which only has commit and rollback methods.
+  # The execution breaks out of the code block when either of the methods is called.
+  # @yield [JDBCHelper::Connection::Transaction] Responds to commit and rollback.
+  # @return [Boolean] True if committed
+  def transaction
+    check_closed
+
+    raise ArgumentError.new("Transaction block not given") unless block_given?
+    tx = Transaction.send :new, @conn
+    ac = @conn.get_auto_commit
+    status = :unknown
+    begin
+      @conn.set_auto_commit false
+      yield tx
+      @conn.commit
+      status = :committed
+    rescue Transaction::Commit
+      status = :committed
+    rescue Transaction::Rollback
+      status = :rolledback
+    ensure
+      @conn.rollback if status == :unknown
+      @conn.set_auto_commit ac
+    end
+    status == :committed
+  end
+
+  # Executes an update and returns the count of the updated rows.
+  # @param [String] qstr SQL string
+  # @return [Fixnum] Count of affected records
+  def update(qstr)
+    check_closed
+
+    @spool.with do | stmt |
+      ret = measure_exec(:update) { stmt.execute_update(qstr) }
+    end
+  end
+
+  # Executes a select query.
+  # When a code block is given, each row of the result is passed to the block one by one.
+  # If a code block not given, this method will return the array of the entire result rows.
+  # (which can be pretty inefficient when the result set is large. In such cases, use enumerate instead.)
+  #
+  # The concept of statement object of JDBC is encapsulated, so there's no need to do additional task,
+  # when you nest select queries, for example.
+  #
+  #   conn.query("SELECT a FROM T") do | trow |
+  #       conn.query("SELECT * FROM U_#{trow.a}") do | urow |
+  #           # ... and so on ...
+  #       end
+  #   end
+  # @param [String] qstr SQL string
+  # @yield [JDBCHelper::Connection::Row]
+  # @return [Array]
+  def query(qstr, &blk)
+    check_closed
+
+    @spool.with do | stmt |
+      measure_exec(:query) { stmt.execute(qstr) }
+      process_and_close_rset(stmt.get_result_set, &blk)
+    end
+  end
+
+  # Returns an enumerable object of the query result.
+  # "enumerate" method is preferable when dealing with a large result set,
+  # since it doesn't have to build a large array.
+  #
+  # The returned enumerator is automatically closed after enumeration.
+  #
+  #   conn.enumerate('SELECT * FROM T').each_slice(10) do | slice |
+  #       slice.each { | row | print row }
+  #       puts
+  #   end
+  #
+  # @param [String] qstr SQL string
+  # @yield [JDBCHelper::Connection::Row] Yields each record if block is given
+  # @return [JDBCHelper::Connection::ResultSetEnumerator] Returns an enumerator if block is not given
+  def enumerate(qstr, &blk)
+    check_closed
+
+    return query(qstr, &blk) if block_given?
+
+    stmt = @spool.take
+    begin
+      measure_exec(:query) { stmt.execute(qstr) }
+    rescue Exception
+      @spool.give stmt
+      raise
+    end
+
+    ResultSetEnumerator.send(:new, stmt.get_result_set) { @spool.give stmt }
+  end
+
+  # Adds a statement to be executed in batch
+  # Adds to the batch
+  # @param [String] qstr
+  # @return [NilClass]
+  def add_batch(qstr)
+    check_closed
+
+    @bstmt ||= @spool.take
+    @bstmt.add_batch qstr
+  end
+
+  # Executes batched statements including prepared statements. No effect when no statment is added
+  # @return [NilClass]
+  def execute_batch
+    check_closed
 
     if @bstmt
       measure_exec(:execute_batch) { @bstmt.execute_batch }
@@ -345,12 +341,12 @@ class Connection
     @pstmts.each do |stmt|
       measure_exec(:execute_batch) { stmt.execute_batch }
     end
-	end
+  end
 
-	# Clears the batched statements including prepared statements.
-	# @return [NilClass]
-	def clear_batch
-		check_closed
+  # Clears the batched statements including prepared statements.
+  # @return [NilClass]
+  def clear_batch
+    check_closed
 
     if @bstmt
       @bstmt.clear_batch
@@ -361,164 +357,164 @@ class Connection
     @pstmts.each do |stmt|
       measure_exec(:execute_batch) { stmt.clear_batch }
     end
-	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 have no effect at all.
-	# @param [Fixnum] fsz
-	# @return [NilClass]
-	def set_fetch_size(fsz)
-		check_closed
-
-		@fetch_size = fsz
-		@spool.each { | stmt | stmt.set_fetch_size @fetch_size }
-	end
-	alias fetch_size= set_fetch_size
-
-	# Returns the fetch size of the connection. If not set, nil is returned.
-	# @return [Fixnum]
-	attr_reader :fetch_size
-
-	# Closes the connection
-	# @return [NilClass]
-	def close
-		return if closed?
-		@spool.close
-		@conn.close
-		@conn = @spool = nil
-	end
-
-	# Returns if this connection is closed or not
-	# @return [Boolean]
-	def closed?
-		@conn.nil?
-	end
-
-	# Returns a table wrapper for the given table name
-	# @since 0.2.0
-	# @param [String/Symbol] table_name Name of the table to be wrapped
-	# @return [JDBCHelper::TableWrapper]
-	def table table_name
+  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 have no effect at all.
+  # @param [Fixnum] fsz
+  # @return [NilClass]
+  def set_fetch_size(fsz)
+    check_closed
+
+    @fetch_size = fsz
+    @spool.each { | stmt | stmt.set_fetch_size @fetch_size }
+  end
+  alias fetch_size= set_fetch_size
+
+  # Returns the fetch size of the connection. If not set, nil is returned.
+  # @return [Fixnum]
+  attr_reader :fetch_size
+
+  # Closes the connection
+  # @return [NilClass]
+  def close
+    return if closed?
+    @spool.close
+    @conn.close
+    @conn = @spool = nil
+  end
+
+  # Returns if this connection is closed or not
+  # @return [Boolean]
+  def closed?
+    @conn.nil?
+  end
+
+  # Returns a table wrapper for the given table name
+  # @since 0.2.0
+  # @param [String/Symbol] table_name Name of the table to be wrapped
+  # @return [JDBCHelper::TableWrapper]
+  def table table_name
     @table_wrappers[table_name] ||= JDBCHelper::TableWrapper.new self, table_name
-	end
-
-	# Returns a sequence wrapper for the given name
-	# @since 0.4.2
-	# @param [String/Symbol] sequence_name Name of the sequence to be wrapped
-	# @return [JDBCHelper::SequenceWrapper]
-	def sequence sequence_name
-		JDBCHelper::SequenceWrapper.new self, sequence_name
-	end
-
-	# Returns a function wrapper for the given function name
-	# @since 0.2.2
-	# @param [String/Symbol] func_name Name of the function to be wrapped
-	# @return [JDBCHelper::FunctionWrapper]
-	def function func_name
-		JDBCHelper::FunctionWrapper.new self, func_name
-	end
-
-	# Returns a procedure wrapper for the given procedure name
-	# @since 0.3.0
-	# @param [String/Symbol] proc_name Name of the procedure to be wrapped
-	# @return [JDBCHelper::ProcedureWrapper]
-	def procedure proc_name
-		JDBCHelper::ProcedureWrapper.new self, proc_name
-	end
-
-	# Statistics
-	class Stat
-		attr_accessor :type, :elapsed, :success_count, :fail_count
-
-		def initialize(t, e, s, f)
-			self.type = t
-			self.elapsed = e
-			self.success_count = s
-			self.fail_count = f
-		end
-	end
+  end
+
+  # Returns a sequence wrapper for the given name
+  # @since 0.4.2
+  # @param [String/Symbol] sequence_name Name of the sequence to be wrapped
+  # @return [JDBCHelper::SequenceWrapper]
+  def sequence sequence_name
+    JDBCHelper::SequenceWrapper.new self, sequence_name
+  end
+
+  # Returns a function wrapper for the given function name
+  # @since 0.2.2
+  # @param [String/Symbol] func_name Name of the function to be wrapped
+  # @return [JDBCHelper::FunctionWrapper]
+  def function func_name
+    JDBCHelper::FunctionWrapper.new self, func_name
+  end
+
+  # Returns a procedure wrapper for the given procedure name
+  # @since 0.3.0
+  # @param [String/Symbol] proc_name Name of the procedure to be wrapped
+  # @return [JDBCHelper::ProcedureWrapper]
+  def procedure proc_name
+    JDBCHelper::ProcedureWrapper.new self, proc_name
+  end
+
+  # Statistics
+  class Stat
+    attr_accessor :type, :elapsed, :success_count, :fail_count
+
+    def initialize(t, e, s, f)
+      self.type = t
+      self.elapsed = e
+      self.success_count = s
+      self.fail_count = f
+    end
+  end
 
 private
-	# Transaction object passed to the code block given to transaction method
-	class Transaction
-		# Commits the transaction
-		# @raise [JDBCHelper::Transaction::Commit]
-		def commit
-			@conn.commit
-			raise Commit
-		end
-		# Rolls back this transaction
-		# @raise [JDBCHelper::Transaction::Rollback]
-		def rollback
-			@conn.rollback
-			raise Rollback
-		end
-	private	
-		def initialize(conn) # :nodoc:
-			@conn = conn
-		end
-		class Commit < Exception # :nodoc:
-		end
-		class Rollback < Exception # :nodoc:
-		end
-	end
-
-	def create_statement # :nodoc:
-		stmt = @conn.create_statement
-		stmt.set_fetch_size @fetch_size if @fetch_size
-		stmt
-	end
-
-	def process_and_close_rset(rset) # :nodoc:
-		enum = ResultSetEnumerator.send :new, rset
-		rows = []
-
-		begin
-			enum.each do | row |
-				if block_given?
-					yield row
-				else
-					rows << row
-				end
-			end
-			block_given? ? nil : rows
-		ensure
-			enum.close
-		end
-	end
+  # Transaction object passed to the code block given to transaction method
+  class Transaction
+    # Commits the transaction
+    # @raise [JDBCHelper::Transaction::Commit]
+    def commit
+      @conn.commit
+      raise Commit
+    end
+    # Rolls back this transaction
+    # @raise [JDBCHelper::Transaction::Rollback]
+    def rollback
+      @conn.rollback
+      raise Rollback
+    end
+  private  
+    def initialize(conn) # :nodoc:
+      @conn = conn
+    end
+    class Commit < Exception # :nodoc:
+    end
+    class Rollback < Exception # :nodoc:
+    end
+  end
+
+  def create_statement # :nodoc:
+    stmt = @conn.create_statement
+    stmt.set_fetch_size @fetch_size if @fetch_size
+    stmt
+  end
+
+  def process_and_close_rset(rset) # :nodoc:
+    enum = ResultSetEnumerator.send :new, rset
+    rows = []
+
+    begin
+      enum.each do | row |
+        if block_given?
+          yield row
+        else
+          rows << row
+        end
+      end
+      block_given? ? nil : rows
+    ensure
+      enum.close
+    end
+  end
 
   def close_pstmt pstmt
     @pstmts.delete pstmt
   end
 
-	def update_stat(type, elapsed, success_count, fail_count) # :nodoc:
-		@prev_stat.type = type
-		@prev_stat.elapsed = elapsed
-		@prev_stat.success_count = success_count
-		@prev_stat.fail_count = fail_count
-
-		accum = @stats[type]
-		accum.elapsed += elapsed
-		accum.success_count += success_count
-		accum.fail_count += fail_count
-	end
-
-	def measure_exec(type)
-		begin
-			st = Time.now
-			ret = yield
-			elapsed = Time.now - st
-			update_stat(type, elapsed, 1, 0)
-		rescue Exception
-			update_stat(type, 0, 0, 1)
-			raise
-		end
-		ret
-	end
-	
-	def check_closed
-		raise RuntimeError.new('Connection already closed') if closed?
-	end
+  def update_stat(type, elapsed, success_count, fail_count) # :nodoc:
+    @prev_stat.type = type
+    @prev_stat.elapsed = elapsed
+    @prev_stat.success_count = success_count
+    @prev_stat.fail_count = fail_count
+
+    accum = @stats[type]
+    accum.elapsed += elapsed
+    accum.success_count += success_count
+    accum.fail_count += fail_count
+  end
+
+  def measure_exec(type)
+    begin
+      st = Time.now
+      ret = yield
+      elapsed = Time.now - st
+      update_stat(type, elapsed, 1, 0)
+    rescue Exception
+      update_stat(type, 0, 0, 1)
+      raise
+    end
+    ret
+  end
+  
+  def check_closed
+    raise RuntimeError.new('Connection already closed') if closed?
+  end
 end#Connection
 end#JDBCHelper