jdbc-helper 0.4.10 → 0.5.0

data/lib/jdbc-helper.rb

@@ -16,6 +16,7 @@ module JavaSql # :nodoc:
 end
 
 require 'jdbc-helper/sql'
+require 'jdbc-helper/sql_prepared'
 require 'jdbc-helper/constants'
 require 'jdbc-helper/connection'
 require 'jdbc-helper/connector'

data/lib/jdbc-helper/connection.rb

@@ -144,7 +144,8 @@ class Connection
 	# @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 |
@@ -179,6 +180,8 @@ class Connection
 		@stats = Hash.new { | h, k | h[k] = Stat.new(k, 0, 0, 0) }
 		@prev_stat = Stat.new(nil, 0, 0, 0)
 
+    @pstmts = []
+
 		if block_given?
 			begin
 				yield self
@@ -188,15 +191,30 @@ class Connection
 		end
 	end
 
+  # Creates another connection with the same parameters as this Connection.
+  # @return [JDBCHelper::Connection]
+  def clone
+    nc = JDBCHelper::Connection.new @args
+    nc.fetch_size = @fetch_size if @fetch_size
+    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
 
-		PreparedStatement.send(:new, self, qstr,
+		pstmt = PreparedStatement.send(:new, self, qstr,
 				measure_exec(:prepare) { @conn.prepare_statement(qstr) })
+    @pstmts << pstmt
+    pstmt
 	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)
@@ -311,27 +329,36 @@ class Connection
 		@bstmt.add_batch qstr
 	end
 
-	# Executes batched statements. No effect when no statment is added
+	# Executes batched statements including prepared statements. No effect when no statment is added
 	# @return [NilClass]
 	def execute_batch
 		check_closed
 
-		return unless @bstmt
-		ret = measure_exec(:execute_batch) { @bstmt.execute_batch }
-		@spool.give @bstmt
-		@bstmt = nil
-		ret
+    if @bstmt
+      measure_exec(:execute_batch) { @bstmt.execute_batch }
+      @spool.give @bstmt
+      @bstmt = nil
+    end
+
+    @pstmts.each do |stmt|
+      measure_exec(:execute_batch) { stmt.execute_batch }
+    end
 	end
 
-	# Clears the batched statements
+	# Clears the batched statements including prepared statements.
 	# @return [NilClass]
 	def clear_batch
 		check_closed
 
-		return unless @bstmt
-		@bstmt.clear_batch
-		@spool.give @bstmt
-		@bstmt = nil
+    if @bstmt
+      @bstmt.clear_batch
+      @spool.give @bstmt
+      @bstmt = nil
+    end
+
+    @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.
@@ -458,6 +485,10 @@ private
 		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

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

@@ -19,6 +19,13 @@ class PreparedStatement < ParameterizedStatement
 		@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

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

@@ -24,7 +24,7 @@ class StatementPool
 
 	def take
 		if @free.empty?
-			raise Exception.new("Nesting too deep") if
+			raise Exception.new("Statement nesting level is too deep (likely a bug)") if
 					@occupied.length >= @max_size
 			@occupied << nstmt = @conn.send(:create_statement)
 			nstmt

data/lib/jdbc-helper/sql.rb

@@ -6,9 +6,12 @@ module JDBCHelper
 # Generate SQL snippet, prevents the string from being quoted.
 # @param [String] SQL snippet
 # @return [JDBCHelper::SQL]
-def self.SQL str
+def self.sql str
 	JDBCHelper::SQL.new str
 end
+class << self
+	alias_method :SQL, :sql
+end
 
 # Class representing an SQL snippet. Also has many SQL generator class methods.
 class SQL
@@ -44,6 +47,9 @@ class SQL
 		where_clause.empty? ? where_clause : check(where_clause)
 	end
 
+  def self.where_prepared *conds
+  end
+
 	# Generates SQL order by cluase with the given conditions.
 	def self.order *criteria
 		str = criteria.map(&:to_s).reject(&:empty?).join(', ')
@@ -120,7 +126,15 @@ class SQL
 		@expr
 	end
 
-private
+  def == other
+    self.to_s == other.to_s
+  end
+	
+  def eql? other
+    self.class == other.class && self.to_s == other.to_s
+  end
+	
+protected
 	def self.esc str
 		str.gsub("'", "''")
 	end
@@ -177,7 +191,7 @@ private
 	def initialize str
 		@expr = JDBCHelper::SQL.check str
 	end
-	
+
 	# Class to represent "(IS) NOT NULL" expression in SQL
 	class NotNilClass
 		# Returns the singleton object of NotNilClass

data/lib/jdbc-helper/sql_prepared.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# SQL generator class methods for prepared operations.
+# WARNING: Does not perform SQL.check to minimize performance overhead
+class SQLPrepared < JDBCHelper::SQL
+  # Generates SQL where cluase with the given conditions.
+  # Parameter can be either Hash of String.
+  def self.where *conds
+    where_internal conds
+  end
+
+  # SQL Helpers
+  # ===========
+  # Generates insert SQL with hash
+  def self.insert table, data_hash
+    insert_internal 'insert', table, data_hash
+  end
+
+  # Generates insert ignore SQL (Non-standard syntax)
+  def self.insert_ignore table, data_hash
+    insert_internal 'insert ignore', table, data_hash
+  end
+
+  # Generates replace SQL (Non-standard syntax)
+  def self.replace table, data_hash
+    insert_internal 'replace', table, data_hash
+  end
+
+  # Generates update SQL with hash.
+  # :where element of the given hash is taken out to generate where clause.
+  def self.update table, data_hash, where
+    where_clause, where_binds = where_internal where
+
+    col_binds = []
+    sql = ("update #{table} set " + data_hash.map { |k, v|
+      case v
+      when JDBCHelper::SQL
+        "#{k} = #{v}"
+      else
+        col_binds << v
+        "#{k} = ?"
+      end
+    }.join(', ') + " #{where_clause}").strip
+
+    return sql, col_binds + where_binds
+  end
+
+  # Generates select SQL with the given conditions
+  def self.select table, opts = {}
+    opts = opts.reject { |k, v| v.nil? }
+    w_c, w_b = where_internal(opts.fetch(:where, {}))
+    sql = [
+      "select #{opts.fetch(:select, ['*']).join(', ')} from #{table}", 
+      w_c.to_s,
+      order(opts.fetch(:order, []).join(', '))
+    ].reject(&:empty?).join(' ')
+
+    return sql, w_b
+  end
+
+  # Generates count SQL with the given conditions
+  def self.count table, conds = nil
+    w_c, w_b = where_internal(conds)
+    sql = "select count(*) from #{table} #{w_c}".strip
+
+    return sql, w_b
+  end
+
+  # Generates delete SQL with the given conditions
+  def self.delete table, conds = nil
+    w_c, w_b = where_internal(conds)
+    sql =  "delete from #{table} #{w_c}".strip
+    return sql, w_b
+  end
+
+  private
+  def self.where_internal conds
+    conds = [conds] unless conds.is_a? Array
+
+    binds = []
+    clauses = []
+    conds.compact.each do |cond| 
+      c, b = where_unit cond 
+      next if c.empty?
+
+      binds += b
+      clauses << c
+    end
+    where_clause = clauses.join(' and ')
+    if where_clause.empty?
+      return nil, []
+    else
+      where_clause = 'where ' + where_clause
+      return where_clause, binds
+    end
+  end
+
+  def self.where_unit conds
+    binds = []
+
+    clause = case conds
+             when String
+               conds = conds.strip
+               conds.empty? ? '' : "(#{conds})"
+             when Hash
+               conds.map { |k, v|
+                 "#{k} " +
+                   case v
+                   when NilClass
+                     "is null"
+                   when NotNilClass
+                     "is not null"
+                   when JDBCHelper::SQL
+                     "= #{v}"
+                   when Fixnum, Bignum, Float
+                     binds << v
+                     "= ?"
+                   when Range
+                     binds << v.begin << v.end
+                     ">= ? and #{k} <#{'=' unless v.exclude_end?} ?"
+                   when Array
+                     "in (" + 
+                       v.map { |e|
+                       case e
+                       when String
+                         "'#{esc e}'"
+                       else
+                         e.to_s
+                       end }.join(', ') + ")"
+                   else
+                     binds << v
+                     "= ?"
+                   end
+               }.join(' and ')
+             else
+               raise NotImplementedError.new("Parameter to where must be either Hash or String")
+             end
+    return clause, binds
+  end
+
+  def self.insert_internal cmd, table, data_hash
+    binds = []
+    values = data_hash.values.map { |v|
+      case v
+      when JDBCHelper::SQL
+        v
+      else
+        binds << v
+        '?'
+      end
+    }
+    sql = "#{cmd} into #{table} (#{data_hash.keys.join ', '}) values (#{values.join(', ')})"
+    return sql, binds
+  end
+end#SQL
+end#JDBCHelper
+

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

@@ -50,7 +50,9 @@ class TableWrapper < ObjectWrapper
 	# @param [List of Hash/String] where Filter conditions
 	# @return [Fixnum] Count of the records.
 	def count *where
-		@connection.query(JDBCHelper::SQL.count(name, @query_where + where))[0][0].to_i
+		sql, binds = JDBCHelper::SQLPrepared.count(name, @query_where + where)
+    pstmt = prepare :count, sql
+    pstmt.query(*binds)[0][0].to_i
 	end
 
 	# Sees if the table is empty
@@ -64,7 +66,9 @@ class TableWrapper < ObjectWrapper
 	# @param [Hash] data_hash Column values in Hash
 	# @return [Fixnum] Number of affected records
 	def insert data_hash = {}
-		@connection.send @update_method, JDBCHelper::SQL.insert(name, @query_default.merge(data_hash))
+    sql, binds = JDBCHelper::SQLPrepared.insert(name, @query_default.merge(data_hash))
+    pstmt = prepare :insert, sql
+    pstmt.send @update_method, *binds
 	end
 
 	# Inserts a record into the table with the given hash.
@@ -73,7 +77,9 @@ class TableWrapper < ObjectWrapper
 	# @param [Hash] data_hash Column values in Hash
 	# @return [Fixnum] Number of affected records
 	def insert_ignore data_hash = {}
-		@connection.send @update_method, JDBCHelper::SQL.insert_ignore(name, @query_default.merge(data_hash))
+    sql, binds = JDBCHelper::SQLPrepared.insert_ignore(name, @query_default.merge(data_hash))
+    pstmt = prepare :insert, sql
+    pstmt.send @update_method, *binds
 	end
 
 	# Replaces a record in the table with the new one with the same unique key.
@@ -81,7 +87,9 @@ class TableWrapper < ObjectWrapper
 	# @param [Hash] data_hash Column values in Hash
 	# @return [Fixnum] Number of affected records
 	def replace data_hash = {}
-		@connection.send @update_method, JDBCHelper::SQL.replace(name, @query_default.merge(data_hash))
+    sql, binds = JDBCHelper::SQLPrepared.replace(name, @query_default.merge(data_hash))
+    pstmt = prepare :insert, sql
+    pstmt.send @update_method, *binds
 	end
 
 	# Executes update with the given hash.
@@ -92,15 +100,20 @@ class TableWrapper < ObjectWrapper
 	def update data_hash_with_where = {}
 		where_ext = data_hash_with_where.delete(:where)
 		where_ext = [where_ext] unless where_ext.is_a? Array
-		@connection.send @update_method, 
-			JDBCHelper::SQL.update(name, @query_default.merge(data_hash_with_where), @query_where + where_ext.compact)
+    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
 
 	# Deletes records matching given condtion
 	# @param [List of Hash/String] where Delete filters
 	# @return [Fixnum] Number of affected records
 	def delete *where
-		@connection.send @update_method, JDBCHelper::SQL.delete(name, @query_where + where)
+		sql, binds = JDBCHelper::SQLPrepared.delete(name, @query_where + where)
+    pstmt = prepare :delete, sql
+    pstmt.send @update_method, *binds
 	end
 
 	# Empties the table.
@@ -181,19 +194,26 @@ class TableWrapper < ObjectWrapper
 	# @return [JDBCHelper::Connection::ResultSetEnumerator]
 	# @since 0.4.0
 	def each &block
-		@connection.enumerate sql, &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
 
 	# 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::Connection::ResultSetEnumerator]
+	# @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
@@ -223,8 +243,37 @@ class TableWrapper < ObjectWrapper
 		@update_method = :update
 		@query_default = {}
 		@query_where = []
+    @pstmts = {
+      :select => {},
+      :insert => {},
+      :delete => {},
+      :count => {},
+      :update => {}
+    }
 	end
+  
+  # Closes the prepared statements
+  # @since 0.5.0
+  def close
+    @pstmts.each do |typ, hash|
+      hash.each do |sql, pstmt|
+        pstmt.close if pstmt
+      end
+      @pstmts[typ] = {}
+    end
+  end
+
+  # @return [Hash] Prepared statements for this wrapper
+  # @since 0.5.0
+  def prepared_statements
+    @pstmts
+  end
+
 private
+  def prepare type, sql
+    @pstmts[type][sql] ||= @connection.prepare(JDBCHelper::SQL.check(sql))
+  end
+
 	def ret obj, &block
 		if block_given?
 			obj.each &block

data/test/helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'bundler'
+require 'pry'
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e

data/test/test_connection.rb

@@ -68,7 +68,7 @@ class TestConnection < Test::Unit::TestCase
 
 	# ---------------------------------------------------------------
 
-	def test_connect_and_close
+	def test_connect_clone_and_close
 		config.each do | db, conn_info_org |
 			4.times do | i |
 				conn_info = conn_info_org.reject { |k,v| k == 'database' }
@@ -89,6 +89,9 @@ class TestConnection < Test::Unit::TestCase
 				assert_equal(conn.driver, conn_info[:driver] || conn_info['driver'])
 				assert_equal(conn.url, conn_info[:url] || conn_info['url'])
 
+        conn.fetch_size = 100
+        assert_equal 100, conn.fetch_size
+
 				conn.close
 				assert_equal(conn.closed?, true)
 				[ :query, :update, :add_batch, :prepare ].each do | met |
@@ -98,10 +101,23 @@ class TestConnection < Test::Unit::TestCase
 					assert_raise(RuntimeError) { conn.send met }
 				end
 
+        new_conn = conn.clone
+        assert new_conn.java_obj != conn.java_obj
+				assert new_conn.closed? == false
+        assert_equal 100, new_conn.fetch_size
+        new_conn.close
+
 				# initialize with execution block
 				conn = JDBCHelper::Connection.new(conn_info) do | c |
+          c2 = c.clone
+          assert c2.java_obj != c.java_obj
+
 					c.query('select 1 from dual')
+					c2.query('select 1 from dual')
 					assert_equal c.closed?, false
+
+          c2.close
+					assert c2.closed?
 				end
 				assert conn.closed?
 			end
@@ -155,6 +171,8 @@ class TestConnection < Test::Unit::TestCase
 			iq = lambda do | i |
 				"insert into #{TEST_TABLE} values (#{i}, 'A')"
 			end
+      ins1 = conn.prepare "insert into #{TEST_TABLE} values (? + #{count}, 'B')"
+      ins2 = conn.prepare "insert into #{TEST_TABLE} values (? + #{count * 2}, 'C')"
 
 			# update
 			assert_equal 1, conn.update(iq.call 0)
@@ -165,17 +183,24 @@ class TestConnection < Test::Unit::TestCase
 
 			count.times do | p |
 				conn.add_batch iq.call(p)
+        ins1.add_batch p
+        ins2.add_batch p
 			end
 			conn.execute_batch
-			assert_equal count, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
+			assert_equal count * 3, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
 
 			# add_batch clear_batch
 			reset_test_table conn
 
 			count.times do | p |
 				conn.add_batch iq.call(p)
+        ins1.add_batch p
+        ins2.add_batch p
 			end
 			conn.clear_batch
+      # Already cleared, no effect
+      ins1.execute_batch
+      ins2.execute_batch
 			assert_equal 0, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
 		end
 	end
@@ -184,6 +209,7 @@ class TestConnection < Test::Unit::TestCase
 		each_connection do | conn |
 			sel = conn.prepare get_one_two
 			assert sel.closed? == false
+      assert_equal conn.prepared_statements.first, sel
 
 			# Fetch size
 			assert_nil conn.fetch_size
@@ -232,6 +258,7 @@ class TestConnection < Test::Unit::TestCase
 			reset_test_table conn
 			ins = conn.prepare "insert into #{TEST_TABLE} values (?, ?)"
 			assert_equal 2, ins.parameter_count
+      assert_equal conn.prepared_statements.first, ins
 
 			count = 100
 
@@ -240,31 +267,49 @@ class TestConnection < Test::Unit::TestCase
 			assert_equal 1, ins.update(0, 'A')
 			assert_equal 1, conn.prev_stat.success_count
 			ins.close
+      assert_equal 0, conn.prepared_statements.length
 
 			# add_batch execute_batch
-			reset_test_table conn
-			ins = conn.prepare "insert into #{TEST_TABLE} values (?, ?)"
-
-			count.times do | p |
-				ins.add_batch(p + 1, 'A')
-			end
-			ins.execute_batch
-			assert_equal count, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
-			ins.close
+      2.times do |iter|
+        reset_test_table conn
+        ins = conn.prepare "insert into #{TEST_TABLE} values (?, ?)"
+        assert_equal conn.prepared_statements.first, ins
+
+        count.times do | p |
+          ins.add_batch(p + 1, 'A')
+        end
+        if iter == 0
+          ins.execute_batch
+        else
+          conn.execute_batch
+        end
+        assert_equal count, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
+        ins.close
+        assert_equal 0, conn.prepared_statements.length
+      end
 
 			# add_batch clear_batch
 			reset_test_table conn
 			ins = conn.prepare "insert into #{TEST_TABLE} values (?, ?)"
-
-			count.times do | p |
-				ins.add_batch(p + 1, 'A')
-			end
-			ins.clear_batch
-			assert_equal 0, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
+      assert_equal conn.prepared_statements.first, ins
+
+      # clear_batch
+      2.times do |iter|
+        count.times do | p |
+          ins.add_batch(p + 1, 'A')
+        end
+        if iter == 0
+          ins.clear_batch
+        else
+          conn.clear_batch
+        end
+        assert_equal 0, conn.query("select count(*) from #{TEST_TABLE}")[0][0]
+      end
 
 			# close closed?
 			assert ins.closed? == false
 			ins.close
+      assert_equal 0, conn.prepared_statements.length
 			assert ins.closed?
 			[ :query, :update, :add_batch, :execute_batch, :clear_batch ].each do | met |
 				assert_raise(RuntimeError) { ins.send met }

data/test/test_object_wrapper.rb

@@ -363,21 +363,24 @@ class TestObjectWrapper < Test::Unit::TestCase
 			# Batch updates
 			table.batch.delete
 			assert_equal 100, table.count
+      conn.execute_batch
+			assert_equal 0, table.count
 
 			insert table.batch, 50
-			assert_equal 100, table.count
+			assert_equal 0, table.count
+      conn.execute_batch
+			assert_equal 50, table.count
 
 			table.batch.update(:alpha => JDBCHelper::SQL('alpha * 2'))
 			assert_equal 100, table.select(:alpha).to_a.first.alpha.to_i
 
 			# Independent update inbetween
 			table.delete(:id => 1..10)
-			assert_equal 90, table.count
+			assert_equal 40, table.count
 
 			# Finally
 			conn.execute_batch
 
-			assert_equal 50, table.count
 			assert_equal 200, table.select(:alpha).to_a.first.alpha.to_i
 		end
 	end
@@ -429,5 +432,49 @@ class TestObjectWrapper < Test::Unit::TestCase
 			seq.drop!
 		end
 	end
+
+  def test_prepared_statements
+		each_connection do |conn|
+			create_table conn
+
+      # No duplicate preparations
+      t = conn.table(@table_name)
+      t.count(:id => 1)
+      t.count('1 = 0')
+      bt = t.batch
+
+      assert_equal 2, t.prepared_statements[:count].length
+      assert_equal 2, bt.prepared_statements[:count].length
+
+      t.count(:id => 2)
+      t.count('2 = 0')
+      bt.count('3 = 0')
+      assert_equal 4, t.prepared_statements[:count].length
+      assert_equal 4, bt.prepared_statements[:count].length
+
+      t.count(:id => 3)
+      t.batch.count('4 = 0')
+      assert_equal 5, t.prepared_statements[:count].length
+      assert_equal 5, bt.prepared_statements[:count].length
+      assert_equal 5, t.batch.prepared_statements[:count].length
+      assert_equal 5, bt.batch.prepared_statements[:count].length
+
+      t.close
+      assert_equal 0, t.prepared_statements[:count].length
+      assert_equal 0, bt.prepared_statements[:count].length
+      assert_equal 0, t.batch.prepared_statements[:count].length
+      assert_equal 0, bt.batch.prepared_statements[:count].length
+
+      t.batch.batch.batch.count(:id => 1)
+      assert_equal 1, t.prepared_statements[:count].length
+      assert_equal 1, bt.prepared_statements[:count].length
+      assert_equal 1, bt.batch.prepared_statements[:count].length
+      assert_equal 1, t.batch.where('1 = 2').select(:a, :b).prepared_statements[:count].length
+
+      # Should be OK
+      bt.close
+      t.batch.close
+    end
+  end
 end
 

data/test/test_performance.rb

@@ -7,7 +7,7 @@ class TestPerformance < Test::Unit::TestCase
 	def setup
 		@table = 'tmp_jdbc_helper'
 		@range = 'aaa'..'aaz'
-		@count = 100#00 # Increase this for performance measurement
+		@count = 10000 # Increase this for performance measurement
 	end
 
 	def teardown
@@ -26,6 +26,17 @@ class TestPerformance < Test::Unit::TestCase
 				end
 			}.real}"
 
+			puts "Normal inserts (batch & chuck-transactional): #{Benchmark.measure {
+				(0...@count).each_slice(50) do |slice|
+					conn.transaction do
+						slice.each do |i|
+              conn.add_batch "insert into #{@table} values (#{@range.map{rand @count}.join ','})"
+						end
+						conn.execute_batch
+					end
+				end
+			}.real}"
+
 			puts "Prepared inserts: #{Benchmark.measure {
 				pins = conn.prepare "insert into #{@table} values (#{@range.map{'?'}.join ','})"
 				@count.times do |i|
@@ -56,17 +67,18 @@ class TestPerformance < Test::Unit::TestCase
 
 			puts "Inserts with hash (batch & chunk-transactional): #{Benchmark.measure {
 				table = conn.table(@table)
+        btable = table.batch
 				(0...@count).each_slice(50) do |slice|
 					conn.transaction do
 						slice.each do |i|
-							table.batch.insert @range.inject({}) { |hash, key| hash[key] = rand; hash }
+							btable.insert @range.inject({}) { |hash, key| hash[key] = rand; hash }
 						end
 						conn.execute_batch
 					end
 				end
 			}.real}"
 
-			assert_equal @count * 5, conn.table(@table).count
+			assert_equal @count * 6, conn.table(@table).count
 
 			conn.query("select * from #{@table}") do |row|
 				# ...

data/test/test_sql.rb

@@ -16,7 +16,6 @@ class TestSQL < Test::Unit::TestCase
 		assert_equal "'sysdate'",         SQL.value('sysdate')
 		assert_equal "'A''s'",            SQL.value("A's")
 		assert_equal "sysdate",           SQL.value(JDBCHelper::SQL('sysdate'))
-
 	end
 
 	def test_order
@@ -71,6 +70,29 @@ class TestSQL < Test::Unit::TestCase
 		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(' aab`bb``  ')) }
 	end
 
+  def test_where_prepared
+		assert_equal ["where a = ?", [1]],                  SQLPrepared.where(:a => 1)
+		assert_equal ["where a = ?", [1.2]],               SQLPrepared.where(:a => 1.2)
+		assert_equal ["where a = ?", [9999999999999999999]], SQLPrepared.where(:a => 9999999999999999999)
+		assert_equal ["where a >= ? and a <= ?", [1,2]],      SQLPrepared.where(:a => 1..2)
+		assert_equal ["where a >= ? and a < ?", [1,2]],       SQLPrepared.where(:a => 1...2)
+		assert_equal ["where a = ?", ["A's"]],            SQLPrepared.where(:a => "A's")
+		assert_equal ["where a is null", []],             SQLPrepared.where(:a => nil)
+		assert_equal ["where a is not null", []],          SQLPrepared.where(:a => SQL.not_nil)
+		assert_equal ["where a is not null", []],         SQLPrepared.where(:a => SQL.not_null)
+		assert_equal ["where a = sysdate", []],           SQLPrepared.where(:a => JDBCHelper::SQL('sysdate'))
+		assert_equal ["where sysdate = sysdate", []],     SQLPrepared.where(JDBCHelper::SQL('sysdate') => JDBCHelper::SQL('sysdate'))
+		assert_equal ["where a in ('aa', 'bb', 'cc')", []], SQLPrepared.where(:a => %w[aa bb cc])
+		assert_equal ["where a = ? and b = ?", [1, "A's"]],   SQLPrepared.where(:a => 1, :b => "A's")
+		assert_equal ["where (a = 1 or b = 1)", []],        SQLPrepared.where("a = 1 or b = 1")
+		assert_equal ["where (a = 1 or b = 1) and c = ?", [2]], SQLPrepared.where("a = 1 or b = 1", :c => 2)
+		assert_equal ["where c = ? and (a = 1 or b = 1)", [2]], SQLPrepared.where({:c => 2}, "a = 1 or b = 1")
+		assert_equal ["where c = ? and (a = 1 or b = 1) and (e = 2) and f = ?", [2, 3]],
+				SQLPrepared.where({:c => 2}, "a = 1 or b = 1", nil, "", "e = 2", nil, {:f => 3}, {})
+		assert_equal [nil, []], SQLPrepared.where(nil)
+		assert_equal [nil, []], SQLPrepared.where(" ")
+  end
+
 	def test_select
 		assert_equal "select * from a.b", SQL.select('a.b')
 		assert_equal "select aa, bb from a.b where a is not null",
@@ -86,11 +108,17 @@ class TestSQL < Test::Unit::TestCase
 	def test_count
 		assert_equal "select count(*) from a.b", SQL.count('a.b')
 		assert_equal "select count(*) from a.b where a is not null", SQL.count('a.b', :a => SQL.not_nil)
+
+		assert_equal ["select count(*) from a.b", []], SQLPrepared.count('a.b')
+		assert_equal ["select count(*) from a.b where a = ?", [1]], SQLPrepared.count('a.b', :a => 1)
 	end
 
 	def test_delete
 		assert_equal "delete from a.b", SQL.delete('a.b')
 		assert_equal "delete from a.b where a is not null", SQL.delete('a.b', :a => SQL.not_nil)
+
+		assert_equal ["delete from a.b", []], SQLPrepared.delete('a.b')
+		assert_equal ["delete from a.b where a = ?", [1]], SQLPrepared.delete('a.b', :a => 1)
 	end
 
 	def test_update
@@ -99,11 +127,33 @@ class TestSQL < Test::Unit::TestCase
 
 		assert_equal "update a.b set a = 1, b = 'A''s', c = now() where a is not null", 
 			SQL.update('a.b', {:a => 1, :b => "A's", :c => JDBCHelper::SQL('now()')}, { :a => SQL.not_nil })
+
+		assert_equal ["update a.b set a = ?, b = ?, c = now()", [1, "A's"]],
+			SQLPrepared.update('a.b', {:a => 1, :b => "A's", :c => JDBCHelper::SQL('now()')}, {})
+
+		assert_equal ["update a.b set a = ?, b = ?, c = now() where a = ?", [1, "A's", 2]],
+			SQLPrepared.update('a.b', {:a => 1, :b => "A's", :c => JDBCHelper::SQL('now()')}, { :a => 2 })
 	end
 
 	def test_insert
 		assert_equal "insert into a.b (a, b, c) values (1, 'A''s', null)",
 			SQL.insert('a.b', :a => 1, :b => "A's", :c => nil)
+
+		assert_equal ["insert into a.b (a, b, c) values (?, ?, ?)", [1, "A's", nil]],
+			SQLPrepared.insert('a.b', :a => 1, :b => "A's", :c => nil)
 	end
+
+  def test_sql_equality
+    assert_equal "a = b", JDBCHelper.SQL('a = b').to_s
+    assert_equal JDBCHelper.SQL('a = b'), JDBCHelper.SQL('a = b')
+
+    # type conversion across ==, but not across eql (TODO TBD)
+    assert JDBCHelper.SQL('a = b') == (JDBCHelper.SQL('a = b'))
+    assert JDBCHelper.SQL('a = b') == 'a = b'
+    assert       JDBCHelper.SQL('a = b').eql?(JDBCHelper.SQL('a = b'))
+    assert_false JDBCHelper.SQL('a = b').eql?('a = b')
+
+    assert JDBCHelper.SQL('a = b') != JDBCHelper.SQL('a = c')
+  end
 end
 

metadata

@@ -2,7 +2,7 @@
 name: jdbc-helper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.10
+  version: 0.5.0
 platform: ruby
 authors: 
   - Junegunn Choi
@@ -10,7 +10,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-09 00:00:00 Z
+date: 2011-08-29 00:00:00 +09:00
+default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: bundler
@@ -56,6 +57,17 @@ dependencies:
     requirement: *id004
     prerelease: false
     type: :development
+  - !ruby/object:Gem::Dependency 
+    name: pry
+    version_requirements: &id005 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id005
+    prerelease: false
+    type: :development
 description: A JDBC helper for JRuby/Database developers.
 email: junegunn.c@gmail.com
 executables: []
@@ -80,6 +92,7 @@ files:
   - lib/jdbc-helper/connector/oracle_connector.rb
   - lib/jdbc-helper/constants.rb
   - lib/jdbc-helper/sql.rb
+  - lib/jdbc-helper/sql_prepared.rb
   - lib/jdbc-helper/wrapper/function_wrapper.rb
   - lib/jdbc-helper/wrapper/object_wrapper.rb
   - lib/jdbc-helper/wrapper/procedure_wrapper.rb
@@ -95,6 +108,7 @@ files:
   - test/test_object_wrapper.rb
   - test/test_performance.rb
   - test/test_sql.rb
+has_rdoc: true
 homepage: http://github.com/junegunn/jdbc-helper
 licenses: 
   - MIT
@@ -121,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: A JDBC helper for JRuby/Database developers.