jdbc-helper 0.5.1 → 0.6.0

data/lib/jdbc-helper/wrapper/function_wrapper.rb

@@ -7,19 +7,19 @@ module JDBCHelper
 # @example Usage
 #  conn.function(:coalesce).call(nil, nil, 'king')
 class FunctionWrapper < ObjectWrapper
-	# Returns the name of the function
-	# @return [String]
-	alias to_s name
+  # Returns the name of the function
+  # @return [String]
+  alias to_s name
 
-	# Returns the result of the function call with the given parameters
-	def call(*args)
-		pstmt = @connection.prepare("select #{name}(#{args.map{'?'}.join ','}) from dual")
-		begin
-			pstmt.query(*args)[0][0]
-		ensure
-			pstmt.close
-		end
-	end
+  # Returns the result of the function call with the given parameters
+  def call(*args)
+    pstmt = @connection.prepare("select #{name}(#{args.map{'?'}.join ','}) from dual")
+    begin
+      pstmt.query(*args)[0][0]
+    ensure
+      pstmt.close
+    end
+  end
 end#FunctionWrapper
 end#JDBCHelper
 

data/lib/jdbc-helper/wrapper/object_wrapper.rb

@@ -6,26 +6,26 @@ module JDBCHelper
 # @abstract
 # @since 0.2.0
 class ObjectWrapper
-	# Underlying JDBCHelper::Connection object
-	# @return [JDBCHelper::Connection]
-	attr_reader :connection
+  # Underlying JDBCHelper::Connection object
+  # @return [JDBCHelper::Connection]
+  attr_reader :connection
 
-	# Object name (or expression)
-	# @return [String]
-	attr_reader :name
+  # Object name (or expression)
+  # @return [String]
+  attr_reader :name
 
-	# Base constructor.
-	# @param [JDBCHelper::Connection] conn JDBCHelper::Connection object
-	# @param [String/Symbol] name Name of the object to be wrapped
-	def initialize(conn, name)
-		raise Exception.new(
-			"JDBCHelper::ObjectWrapper is an abstract class") if 
-					self.instance_of? ObjectWrapper
+  # Base constructor.
+  # @param [JDBCHelper::Connection] conn JDBCHelper::Connection object
+  # @param [String/Symbol] name Name of the object to be wrapped
+  def initialize(conn, name)
+    raise NotImplementedError.new(
+      "JDBCHelper::ObjectWrapper is an abstract class") if 
+          self.instance_of? ObjectWrapper
 
-		@connection = conn
-		@name = name.to_s
-		JDBCHelper::SQL.check @name, true
-	end
+    @connection = conn
+    @name = name.to_s
+    JDBCHelper::SQL.check @name, true
+  end
 end#ObjectWrapper
 end#JDBCHelper
 

data/lib/jdbc-helper/wrapper/procedure_wrapper.rb

@@ -7,131 +7,128 @@ module JDBCHelper
 # @example Usage
 #  conn.procedure(:my_procedure).call(1, ["a", String], Fixnum)
 class ProcedureWrapper < ObjectWrapper
-	# Returns the name of the procedure
-	# @return [String]
-	alias to_s name
-
-	# Executes the procedure and returns the values of INOUT & OUT parameters in Hash
-	# @return [Hash]
-	def call(*args)
-		params = build_params args
-		cstmt = @connection.prepare_call "{call #{name}(#{Array.new(@cols.length){'?'}.join ', '})}"
-		begin
-			process_result( args, cstmt.call(*params) )
-		ensure
-			cstmt.close
-		end
-	end
-
-	# Reloads procedure metadata. Metadata is cached for performance.
-	# However, if you have modified the procedure, you need to reload the
-	# metadata with this method.
-	# @return [JDBCHelper::ProcedureWrapper]
-	def refresh
-		@cols = @defaults = nil
-		self
-	end
+  # Returns the name of the procedure
+  # @return [String]
+  alias to_s name
+
+  # Executes the procedure and returns the values of INOUT & OUT parameters in Hash
+  # @return [Hash]
+  def call(*args)
+    params = build_params args
+    cstmt = @connection.prepare_call "{call #{name}(#{Array.new(@cols.length){'?'}.join ', '})}"
+    begin
+      process_result( args, cstmt.call(*params) )
+    ensure
+      cstmt.close
+    end
+  end
+
+  # Reloads procedure metadata. Metadata is cached for performance.
+  # However, if you have modified the procedure, you need to reload the
+  # metadata with this method.
+  # @return [JDBCHelper::ProcedureWrapper]
+  def refresh
+    @cols = @defaults = nil
+    self
+  end
 
 private
-	def metadata_lookup
-		return if @cols
-
-		procedure, package, schema = name.split('.').reverse
-		procedure_u, package_u, schema_u = name.upcase.split('.').reverse
-
-		# Alas, metadata lookup can be case-sensitive. e.g. Oracle
-		dbmd = @connection.java_obj.get_meta_data
-		lookups = 
-			if schema
-				[ 
-					lambda { dbmd.getProcedureColumns(package, schema, procedure, nil) },
-					lambda { dbmd.getProcedureColumns(package_u, schema_u, procedure_u, nil) } 
-				]
-			else
-				# schema or catalog? we don't know.
-				# - too inefficient for parameter-less procedures
-				[ lambda { dbmd.getProcedureColumns(nil, package, procedure, nil) },
-				  lambda { dbmd.getProcedureColumns(nil, package_u, procedure_u, nil) },
-				  lambda { dbmd.getProcedureColumns(package, nil, procedure, nil) },
-				  lambda { dbmd.getProcedureColumns(package_u, nil, procedure_u, nil) },
-				]
-			end
-
-		cols = []
-		@defaults = {}
-		lookups.each do |ld|
-			rset = ld.call
-			default_support = rset.get_meta_data.get_column_count >= 14
-			while rset.next
-				next if rset.getString("COLUMN_TYPE") == Java::JavaSql::DatabaseMetaData.procedureColumnReturn
-
-				cols << rset.getString("COLUMN_NAME").upcase
-				# TODO/NOT TESTED
-				# - MySQL doesn't support default values for procedure parameters
-				# - Oracle supports default values, however it does not provide
-				#   standard interface to query default values. COLUMN_DEF always returns null.
-				#   http://download.oracle.com/docs/cd/E11882_01/appdev.112/e13995/oracle/jdbc/OracleDatabaseMetaData.html#getProcedureColumns_java_lang_String__java_lang_String__java_lang_String__java_lang_String_
-				if default_support && (default = rset.getString("COLUMN_DEF"))
-					@defaults[cols.length - 1] << default
-				end
-			end
-			unless cols.empty?
-				@cols = cols
-				break
-			end
-		end
-		@cols ||= []
-	end
-
-	def build_params args
-		metadata_lookup
-
-		params = []
-		# Array
-		unless args.first.kind_of?(Hash)
-			if args.length < @cols.length
-				# Fill the Array with default values
-				@cols.length.times do |idx|
-					if @defaults[idx]
-						params << @defaults[idx]
-					else
-						params << args[idx]
-					end
-				end
-			else
-				params = args
-			end
-
-		# Hash
-		else
-			raise ArgumentError.new("More than one Hash given") if args.length > 1
-
-			# Set to default,
-			@defaults.each do |idx, v|
-				params[idx] = v
-			end
-
-			# then override
-			args.first.each do |k, v|
-				idx = @cols.index k.to_s.upcase
-				params[idx] = v
-			end
-		end
-
-		return params
-	end
-
-	def process_result args, result
-		input = args.first
-		return result unless input.kind_of? Hash
-
-		final = {}
-		result.each do |idx, ret|
-			key = input.keys.find { |key| key.to_s.upcase == @cols[idx - 1] }
-			final[key] = ret
-		end
-		final
-	end
+  def metadata_lookup
+    return if @cols
+
+    procedure, package, schema = name.split('.').reverse
+    procedure_u, package_u, schema_u = name.upcase.split('.').reverse
+
+    # Alas, metadata lookup can be case-sensitive. e.g. Oracle
+    dbmd = @connection.java_obj.get_meta_data
+    lookups = 
+      if schema
+        [ lambda { dbmd.getProcedureColumns(package, schema, procedure, nil) },
+          lambda { dbmd.getProcedureColumns(package_u, schema_u, procedure_u, nil) } ]
+      else
+        # schema or catalog? we don't know.
+        # - too inefficient for parameter-less procedures
+        [ lambda { dbmd.getProcedureColumns(nil, package, procedure, nil) },
+          lambda { dbmd.getProcedureColumns(nil, package_u, procedure_u, nil) },
+          lambda { dbmd.getProcedureColumns(package, nil, procedure, nil) },
+          lambda { dbmd.getProcedureColumns(package_u, nil, procedure_u, nil) } ]
+      end
+
+    cols = []
+    @defaults = {}
+    lookups.each do |ld|
+      rset = ld.call
+      default_support = rset.get_meta_data.get_column_count >= 14
+      while rset.next
+        next if rset.getString("COLUMN_TYPE") == java.sql.DatabaseMetaData.procedureColumnReturn
+
+        cols << rset.getString("COLUMN_NAME").upcase
+        # TODO/NOT TESTED
+        # - MySQL doesn't support default values for procedure parameters
+        # - Oracle supports default values, however it does not provide
+        #   standard interface to query default values. COLUMN_DEF always returns null.
+        #   http://download.oracle.com/docs/cd/E11882_01/appdev.112/e13995/oracle/jdbc/OracleDatabaseMetaData.html#getProcedureColumns_java_lang_String__java_lang_String__java_lang_String__java_lang_String_
+        if default_support && (default = rset.getString("COLUMN_DEF"))
+          @defaults[cols.length - 1] << default
+        end
+      end
+      unless cols.empty?
+        @cols = cols
+        break
+      end
+    end
+    @cols ||= []
+  end
+
+  def build_params args
+    metadata_lookup
+
+    params = []
+    # Array
+    unless args.first.kind_of?(Hash)
+      if args.length < @cols.length
+        # Fill the Array with default values
+        @cols.length.times do |idx|
+          if @defaults[idx]
+            params << @defaults[idx]
+          else
+            params << args[idx]
+          end
+        end
+      else
+        params = args
+      end
+
+    # Hash
+    else
+      raise ArgumentError.new("More than one Hash given") if args.length > 1
+
+      # Set to default,
+      @defaults.each do |idx, v|
+        params[idx] = v
+      end
+
+      # then override
+      args.first.each do |k, v|
+        idx = @cols.index k.to_s.upcase
+        params[idx] = v
+      end
+    end
+
+    return params
+  end
+
+  def process_result args, result
+    input = args.first
+    return result unless input.kind_of? Hash
+
+    final = {}
+    result.each do |idx, ret|
+      key = input.keys.find { |key| key.to_s.upcase == @cols[idx - 1] }
+      final[key] = ret
+    end
+    final
+  end
 end#ProcedureWrapper
 end#JDBCHelper
 

data/lib/jdbc-helper/wrapper/sequence_wrapper.rb

@@ -11,49 +11,49 @@ module JDBCHelper
 #  conn.sequence(:my_seq).reset!(1)
 #  conn.sequence(:my_seq).drop!
 class SequenceWrapper < ObjectWrapper
-	# Returns the name of the sequence
-	# @return [String]
-	alias to_s name
-
-	# Increments the sequence and returns the value
-	# @return [Fixnum]
-	def nextval
-		@connection.query("select #{name}.nextval from dual")[0][0].to_i
-	end
-
-	# Returns the incremented value of the sequence
-	# @return [Fixnum]
-	def currval
-		@connection.query("select #{name}.currval from dual")[0][0].to_i
-	end
-
-	# Recreates the sequence. Cannot be undone.
-	# @param [Fixnum] value Initial value
-	# @param [Fixnum] increment_by Increment size for a single nextval call
-	# @return [JDBCHelper::SequenceWrapper] Self.
-	def reset! value = 1, increment_by = 1
-		drop! rescue nil
-		create! value, increment_by
-		self
-	end
-
-	# Drops the sequence. Cannot be undone.
-	# @return [JDBCHelper::SequenceWrapper] Self.
-	def drop!
-		@connection.update("drop sequence #{name}")
-		self
-	end
-
-	# Creates the sequence. Cannot be undone.
-	# @param [Fixnum] value Initial value
-	# @param [Fixnum] increment_by Increment size for a single nextval call
-	# @return [JDBCHelper::SequenceWrapper] Self.
-	def create! value = 1, increment_by = 1
-		create = JDBCHelper::SQL.check(
-				"create sequence #{name} start with #{value} increment by #{increment_by}")
-		@connection.update(create)
-		self
-	end
+  # Returns the name of the sequence
+  # @return [String]
+  alias to_s name
+
+  # Increments the sequence and returns the value
+  # @return [Fixnum]
+  def nextval
+    @connection.query("select #{name}.nextval from dual")[0][0].to_i
+  end
+
+  # Returns the incremented value of the sequence
+  # @return [Fixnum]
+  def currval
+    @connection.query("select #{name}.currval from dual")[0][0].to_i
+  end
+
+  # Recreates the sequence. Cannot be undone.
+  # @param [Fixnum] value Initial value
+  # @param [Fixnum] increment_by Increment size for a single nextval call
+  # @return [JDBCHelper::SequenceWrapper] Self.
+  def reset! value = 1, increment_by = 1
+    drop! rescue nil
+    create! value, increment_by
+    self
+  end
+
+  # Drops the sequence. Cannot be undone.
+  # @return [JDBCHelper::SequenceWrapper] Self.
+  def drop!
+    @connection.update("drop sequence #{name}")
+    self
+  end
+
+  # Creates the sequence. Cannot be undone.
+  # @param [Fixnum] value Initial value
+  # @param [Fixnum] increment_by Increment size for a single nextval call
+  # @return [JDBCHelper::SequenceWrapper] Self.
+  def create! value = 1, increment_by = 1
+    create = JDBCHelper::SQL.check(
+        "create sequence #{name} start with #{value} increment by #{increment_by}")
+    @connection.update(create)
+    self
+  end
 end#SequenceWrapper
 end#JDBCHelper
 

data/lib/jdbc-helper/wrapper/table_wrapper.rb

@@ -42,207 +42,207 @@ module JDBCHelper
 #  table.truncate_table!
 #  table.drop_table!
 class TableWrapper < ObjectWrapper
-	# Returns the name of the table
-	# @return [String]
-	alias to_s name
+  # Returns the name of the table
+  # @return [String]
+  alias to_s name
 
-	# Retrieves the count of the table
-	# @param [List of Hash/String] where Filter conditions
-	# @return [Fixnum] Count of the records.
-	def count *where
-		sql, binds = JDBCHelper::SQLPrepared.count(name, @query_where + where)
+  # Retrieves the count of the table
+  # @param [List of Hash/String] where Filter conditions
+  # @return [Fixnum] Count of the records.
+  def count *where
+    sql, binds = JDBCHelper::SQLPrepared.count(name, @query_where + where)
     pstmt = prepare :count, sql
     pstmt.query(*binds)[0][0].to_i
-	end
+  end
 
-	# Sees if the table is empty
-	# @param [Hash/String] Filter conditions
-	# @return [boolean]
-	def empty? *where
-		count(*where) == 0
-	end
+  # Sees if the table is empty
+  # @param [Hash/String] Filter conditions
+  # @return [boolean]
+  def empty? *where
+    count(*where) == 0
+  end
 
-	# Inserts a record into the table with the given hash
-	# @param [Hash] data_hash Column values in Hash
-	# @return [Fixnum] Number of affected records
-	def insert data_hash = {}
+  # Inserts a record into the table with the given hash
+  # @param [Hash] data_hash Column values in Hash
+  # @return [Fixnum] Number of affected records
+  def insert data_hash = {}
     sql, binds = JDBCHelper::SQLPrepared.insert(name, @query_default.merge(data_hash))
     pstmt = prepare :insert, sql
     pstmt.send @update_method, *binds
-	end
+  end
 
-	# Inserts a record into the table with the given hash.
-	# Skip insertion when duplicate record is found.
-	# @note This is not SQL standard. Only works if the database supports insert ignore syntax.
-	# @param [Hash] data_hash Column values in Hash
-	# @return [Fixnum] Number of affected records
-	def insert_ignore data_hash = {}
+  # Inserts a record into the table with the given hash.
+  # Skip insertion when duplicate record is found.
+  # @note This is not SQL standard. Only works if the database supports insert ignore syntax.
+  # @param [Hash] data_hash Column values in Hash
+  # @return [Fixnum] Number of affected records
+  def insert_ignore data_hash = {}
     sql, binds = JDBCHelper::SQLPrepared.insert_ignore(name, @query_default.merge(data_hash))
     pstmt = prepare :insert, sql
     pstmt.send @update_method, *binds
-	end
+  end
 
-	# Replaces a record in the table with the new one with the same unique key.
-	# @note This is not SQL standard. Only works if the database supports replace syntax.
-	# @param [Hash] data_hash Column values in Hash
-	# @return [Fixnum] Number of affected records
-	def replace data_hash = {}
+  # Replaces a record in the table with the new one with the same unique key.
+  # @note This is not SQL standard. Only works if the database supports replace syntax.
+  # @param [Hash] data_hash Column values in Hash
+  # @return [Fixnum] Number of affected records
+  def replace data_hash = {}
     sql, binds = JDBCHelper::SQLPrepared.replace(name, @query_default.merge(data_hash))
     pstmt = prepare :insert, sql
     pstmt.send @update_method, *binds
-	end
+  end
 
-	# Executes update with the given hash.
-	# :where element of the hash is taken out to generate where clause of the update SQL.
-	# @param [Hash] data_hash_with_where Column values in Hash.
-	#   :where element of the given hash can (usually should) point to another Hash representing update filters.
-	# @return [Fixnum] Number of affected records
-	def update data_hash_with_where = {}
-		where_ext = data_hash_with_where.delete(:where)
-		where_ext = [where_ext] unless where_ext.is_a? Array
+  # Executes update with the given hash.
+  # :where element of the hash is taken out to generate where clause of the update SQL.
+  # @param [Hash] data_hash_with_where Column values in Hash.
+  #   :where element of the given hash can (usually should) point to another Hash representing update filters.
+  # @return [Fixnum] Number of affected records
+  def update data_hash_with_where = {}
+    where_ext = data_hash_with_where.delete(:where)
+    where_ext = [where_ext] unless where_ext.is_a? Array
     sql, binds = JDBCHelper::SQLPrepared.update(name, 
                     @query_default.merge(data_hash_with_where),
                     @query_where + where_ext.compact)
     pstmt = prepare :update, sql
     pstmt.send @update_method, *binds
-	end
+  end
 
-	# Deletes records matching given condtion
-	# @param [List of Hash/String] where Delete filters
-	# @return [Fixnum] Number of affected records
-	def delete *where
-		sql, binds = JDBCHelper::SQLPrepared.delete(name, @query_where + where)
+  # Deletes records matching given condtion
+  # @param [List of Hash/String] where Delete filters
+  # @return [Fixnum] Number of affected records
+  def delete *where
+    sql, binds = JDBCHelper::SQLPrepared.delete(name, @query_where + where)
     pstmt = prepare :delete, sql
     pstmt.send @update_method, *binds
-	end
+  end
 
-	# Empties the table.
-	# @note This operation cannot be undone
-	# @return [JDBCHelper::TableWrapper] Self.
-	def truncate!
-		@connection.update(JDBCHelper::SQL.check "truncate table #{name}")
-		self
-	end
-	alias truncate_table! truncate!
-	
-	# Drops the table.
-	# @note This operation cannot be undone
-	# @return [JDBCHelper::TableWrapper] Self.
-	def drop!
-		@connection.update(JDBCHelper::SQL.check "drop table #{name}")
-		self
-	end
-	alias drop_table! drop!
+  # Empties the table.
+  # @note This operation cannot be undone
+  # @return [JDBCHelper::TableWrapper] Self.
+  def truncate!
+    @connection.update(JDBCHelper::SQL.check "truncate table #{name}")
+    self
+  end
+  alias truncate_table! truncate!
+  
+  # Drops the table.
+  # @note This operation cannot be undone
+  # @return [JDBCHelper::TableWrapper] Self.
+  def drop!
+    @connection.update(JDBCHelper::SQL.check "drop table #{name}")
+    self
+  end
+  alias drop_table! drop!
 
-	# Select SQL wrapper
-	include Enumerable
+  # Select SQL wrapper
+  include Enumerable
 
-	# Returns a new TableWrapper object which can be used to execute a select
-	# statement for the table selecting only the specified fields.
-	# If a block is given, executes the select statement and yields each row to the block.
-	# @param [*String/*Symbol] fields List of fields to select
-	# @return [JDBCHelper::TableWrapper]
-	# @since 0.4.0
-	def select *fields, &block
-		obj = self.dup
-		obj.instance_variable_set :@query_select, fields unless fields.empty?
-		ret obj, &block
-	end
+  # Returns a new TableWrapper object which can be used to execute a select
+  # statement for the table selecting only the specified fields.
+  # If a block is given, executes the select statement and yields each row to the block.
+  # @param [*String/*Symbol] fields List of fields to select
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.4.0
+  def select *fields, &block
+    obj = self.dup
+    obj.instance_variable_set :@query_select, fields unless fields.empty?
+    ret obj, &block
+  end
 
-	# Returns a new TableWrapper object which can be used to execute a select
-	# statement for the table with the specified filter conditions.
-	# If a block is given, executes the select statement and yields each row to the block.
-	# @param [List of Hash/String] conditions Filter conditions
-	# @return [JDBCHelper::TableWrapper]
-	# @since 0.4.0
-	def where *conditions, &block
-		raise ArgumentError.new("Wrong number of arguments") if conditions.empty?
+  # Returns a new TableWrapper object which can be used to execute a select
+  # statement for the table with the specified filter conditions.
+  # If a block is given, executes the select statement and yields each row to the block.
+  # @param [List of Hash/String] conditions Filter conditions
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.4.0
+  def where *conditions, &block
+    raise ArgumentError.new("Wrong number of arguments") if conditions.empty?
 
-		obj = self.dup
-		obj.instance_variable_set :@query_where, @query_where + conditions
-		ret obj, &block
-	end
+    obj = self.dup
+    obj.instance_variable_set :@query_where, @query_where + conditions
+    ret obj, &block
+  end
 
-	# Returns a new TableWrapper object which can be used to execute a select
-	# statement for the table with the given sorting criteria.
-	# If a block is given, executes the select statement and yields each row to the block.
-	# @param [*String/*Symbol] criteria Sorting criteria
-	# @return [JDBCHelper::TableWrapper]
-	# @since 0.4.0
-	def order *criteria, &block
-		raise ArgumentError.new("Wrong number of arguments") if criteria.empty?
-		obj = self.dup
-		obj.instance_variable_set :@query_order, criteria
-		ret obj, &block
-	end
+  # Returns a new TableWrapper object which can be used to execute a select
+  # statement for the table with the given sorting criteria.
+  # If a block is given, executes the select statement and yields each row to the block.
+  # @param [*String/*Symbol] criteria Sorting criteria
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.4.0
+  def order *criteria, &block
+    raise ArgumentError.new("Wrong number of arguments") if criteria.empty?
+    obj = self.dup
+    obj.instance_variable_set :@query_order, criteria
+    ret obj, &block
+  end
 
-	# Returns a new TableWrapper object with default values, which will be applied to
-	# the subsequent inserts and updates.
-	# @param [Hash] data_hash Default values
-	# @return [JDBCHelper::TableWrapper]
-	# @since 0.4.5
-	def default data_hash
-		raise ArgumentError.new("Hash required") unless data_hash.kind_of? Hash
+  # Returns a new TableWrapper object with default values, which will be applied to
+  # the subsequent inserts and updates.
+  # @param [Hash] data_hash Default values
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.4.5
+  def default data_hash
+    raise ArgumentError.new("Hash required") unless data_hash.kind_of? Hash
 
-		obj = self.dup
-		obj.instance_variable_set :@query_default, @query_default.merge(data_hash)
-		obj
-	end
+    obj = self.dup
+    obj.instance_variable_set :@query_default, @query_default.merge(data_hash)
+    obj
+  end
 
-	# Executes a select SQL for the table and returns an Enumerable object,
-	# or yields each row if block is given.
-	# @return [JDBCHelper::Connection::ResultSetEnumerator]
-	# @since 0.4.0
-	def each &block
-		sql, binds = JDBCHelper::SQLPrepared.select(
-				name, 
-				:select => @query_select, 
-				:where => @query_where,
-				:order => @query_order)
+  # Executes a select SQL for the table and returns an Enumerable object,
+  # or yields each row if block is given.
+  # @return [JDBCHelper::Connection::ResultSetEnumerator]
+  # @since 0.4.0
+  def each &block
+    sql, binds = JDBCHelper::SQLPrepared.select(
+        name, 
+        :select => @query_select, 
+        :where => @query_where,
+        :order => @query_order)
     pstmt = prepare :select, sql
     pstmt.enumerate *binds, &block
-	end
+  end
 
-	# Returns a new TableWrapper object whose subsequent inserts, updates,
-	# and deletes are added to batch for JDBC batch-execution. The actual execution
-	# is deferred until JDBCHelper::Connection#execute_batch method is called.
-	# Self is returned when batch is called more than once.
-	# @return [JDBCHelper::TableWrapper]
-	# @since 0.4.0
-	def batch
-		if batch?
-			self
-		else
+  # Returns a new TableWrapper object whose subsequent inserts, updates,
+  # and deletes are added to batch for JDBC batch-execution. The actual execution
+  # is deferred until JDBCHelper::Connection#execute_batch method is called.
+  # Self is returned when batch is called more than once.
+  # @return [JDBCHelper::TableWrapper]
+  # @since 0.4.0
+  def batch
+    if batch?
+      self
+    else
       # dup makes @pstmts to be shared
-			obj = self.dup
-			obj.instance_variable_set :@update_method, :add_batch
-			obj
-		end
-	end
+      obj = self.dup
+      obj.instance_variable_set :@update_method, :add_batch
+      obj
+    end
+  end
 
-	# Returns if the subsequent updates for this wrapper will be batched
-	# @return [Boolean]
-	# @since 0.4.0
-	def batch?
-		@update_method == :add_batch
-	end
+  # Returns if the subsequent updates for this wrapper will be batched
+  # @return [Boolean]
+  # @since 0.4.0
+  def batch?
+    @update_method == :add_batch
+  end
 
-	# Returns the select SQL for this wrapper object
-	# @return [String] Select SQL
-	# @since 0.4.0
-	def sql
-		JDBCHelper::SQL.select(
-				name, 
-				:select => @query_select, 
-				:where => @query_where,
-				:order => @query_order)
-	end
+  # Returns the select SQL for this wrapper object
+  # @return [String] Select SQL
+  # @since 0.4.0
+  def sql
+    JDBCHelper::SQL.select(
+        name, 
+        :select => @query_select, 
+        :where => @query_where,
+        :order => @query_order)
+  end
 
-	def initialize connection, table_name
-		super connection, table_name
-		@update_method = :update
-		@query_default = {}
-		@query_where = []
+  def initialize connection, table_name
+    super connection, table_name
+    @update_method = :update
+    @query_default = {}
+    @query_where = []
     @pstmts = {
       :select => {},
       :insert => {},
@@ -250,7 +250,7 @@ class TableWrapper < ObjectWrapper
       :count => {},
       :update => {}
     }
-	end
+  end
   
   # Closes the prepared statements
   # @since 0.5.0
@@ -271,16 +271,19 @@ class TableWrapper < ObjectWrapper
 
 private
   def prepare type, sql
-    @pstmts[type][sql] ||= @connection.prepare(JDBCHelper::SQL.check(sql))
+    sql   = JDBCHelper::SQL.check(sql)
+    pstmt = @pstmts[type][sql] ||= @connection.prepare(sql)
+    pstmt = @pstmts[type][sql]   = @connection.prepare(sql) if pstmt.closed?
+    pstmt
   end
 
-	def ret obj, &block
-		if block_given?
-			obj.each &block
-		else
-			obj
-		end
-	end
+  def ret obj, &block
+    if block_given?
+      obj.each &block
+    else
+      obj
+    end
+  end
 end#TableWrapper
 end#JDBCHelper