jdbc-helper 0.3.2 → 0.4.0

data/README.rdoc

@@ -115,17 +115,46 @@ Add JDBC driver of the DBMS you're willing to use to your CLASSPATH
 === Using table wrappers (since 0.2.0)
   # 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.select(:c => 3) do |row|
-    puts row.a
+  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
-  table.update(:a => 1, :b => 2, :where => { :c => 3 })
-  table.insert(:a => 10, :b => 20, :c => 30)
+
+  # 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)
+
+  # 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!
   table.drop_table!
 

data/lib/jdbc-helper/connection.rb

@@ -11,6 +11,7 @@ require 'jdbc-helper/connection/row'
 
 require 'jdbc-helper/wrapper/object_wrapper'
 require 'jdbc-helper/wrapper/table_wrapper'
+require 'jdbc-helper/wrapper/table_wrapper'
 require 'jdbc-helper/wrapper/function_wrapper'
 require 'jdbc-helper/wrapper/procedure_wrapper'
 

data/lib/jdbc-helper/sql.rb

@@ -2,16 +2,24 @@
 # Junegunn Choi (junegunn.c@gmail.com)
 
 module JDBCHelper
-module SQL
-	# Prevents a string from being quoted
-	def self.expr str
-		Expr.new str
-	end
-	
+
+# Generate SQL snippet, prevents the string from being quoted.
+# @param [String] SQL snippet
+# @return [JDBCHelper::SQL]
+def self.SQL str
+	JDBCHelper::SQL.new str
+end
+
+# Class representing an SQL snippet. Also has many SQL generator class methods.
+class SQL
 	# Returns NotNilClass singleton object
+	# @return [JDBCHelper::SQL::NotNilClass]
 	def self.not_nil
 		NotNilClass.singleton
 	end
+	class << self
+		alias not_null not_nil
+	end
 
 	# Formats the given data so that it can be injected into SQL
 	def self.value data
@@ -20,7 +28,7 @@ module SQL
 			'null'
 		when Fixnum, Bignum, Float
 			data
-		when JDBCHelper::SQL::Expr
+		when JDBCHelper::SQL
 			data.to_s
 		when String
 			"'#{esc data}'"
@@ -37,7 +45,7 @@ module SQL
 	end
 
 	# Generates SQL order by cluase with the given conditions.
-	def self.order_by *criteria
+	def self.order *criteria
 		str = criteria.map(&:to_s).reject(&:empty?).join(', ')
 		str.empty? ? str : check('order by ' + str)
 	end
@@ -62,18 +70,19 @@ module SQL
 
 	# 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_clause = where_internal(data_hash.delete :where)
+	def self.update table, data_hash, where
+		where_clause = where_internal where
 		updates = data_hash.map { |k, v| "#{k} = #{value v}" }.join(', ')
 		check "update #{table} set #{updates} #{where_clause}".strip
 	end
 
-	# Generates select * SQL with the given conditions
-	def self.select table, conds = nil, orders = nil
+	# Generates select SQL with the given conditions
+	def self.select table, opts = {}
+		opts = opts.reject { |k, v| v.nil? }
 		check [
-			"select * from #{table}", 
-			where_internal(conds),
-			order_by(orders)
+			"select #{opts.fetch(:select, ['*']).join(', ')} from #{table}", 
+			where_internal(opts.fetch(:where, {})),
+			order(opts.fetch(:order, []).join(', '))
 		].reject(&:empty?).join(' ')
 	end
 
@@ -106,6 +115,10 @@ module SQL
 		return expr
 	end
 
+	def to_s
+		@expr
+	end
+
 private
 	def self.esc str
 		str.gsub("'", "''")
@@ -127,7 +140,7 @@ private
 							"is null"
 						when NotNilClass
 							"is not null"
-						when Fixnum, Bignum, Float, JDBCHelper::SQL::Expr
+						when Fixnum, Bignum, Float, JDBCHelper::SQL
 							"= #{v}"
 						when Range
 							">= #{v.first} and #{k} <#{'=' unless v.exclude_end?} #{v.last}"
@@ -157,16 +170,10 @@ private
 		check "#{cmd} into #{table} (#{cols.join ', '}) values (#{cols.map{|c|value data_hash[c]}.join ', '})"
 	end
 
-	class Expr
-		def initialize str
-			@expr = str
-		end
-		
-		def to_s
-			@expr
-		end
+	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/wrapper/object_wrapper.rb

@@ -5,7 +5,6 @@ module JDBCHelper
 # Abstract base class for wrappers for various database objects.
 # @abstract
 # @since 0.2.0
-# @todo Procedure wrapper with input & output params
 class ObjectWrapper
 	# Underlying JDBCHelper::Connection object
 	# @return [JDBCHelper::Connection]

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

@@ -7,48 +7,64 @@ module JDBCHelper
 # @example Usage
 #  # For more complex examples, refer to test/test_object_wrapper.rb
 #
-#  conn.table('test.data').count
-#  conn.table('test.data').empty?
-#  conn.table('test.data').select(:c => 3) do |row|
-#    puts row.a
+#  # 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
-#  conn.table('test.data').update(:a => 1, :b => 2, :where => { :c => 3 })
-#  conn.table('test.data').insert(:a => 10, :b => 20, :c => 30)
-#  conn.table('test.data').insert_ignore(:a => 10, :b => 20, :c => 30)
-#  conn.table('test.data').insert_replace(:a => 10, :b => 20, :c => 30)
-#  conn.table('test.data').delete(:c => 3)
-#  conn.table('test.data').truncate_table!
-#  conn.table('test.data').drop_table!
+#
+#  # 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)
+#
+#  # Delete with conditions
+#  table.delete(:c => 3)
+#  # Or equivalently,
+#  table.where(:c => 3).delete
+#
+#  # Truncate or drop table (Cannot be undone)
+#  table.truncate_table!
+#  table.drop_table!
 class TableWrapper < ObjectWrapper
 	# Returns the name of the table
 	# @return [String]
 	alias to_s name
 
 	# Retrieves the count of the table
+	# @param [Hash/String] Filter conditions
 	# @return [Fixnum] Count of the records.
-	def count(where = nil)
-		@connection.query(JDBCHelper::SQL.count name, where)[0][0].to_i
+	def count where = nil
+		@connection.query(JDBCHelper::SQL.count name, where || @query_where)[0][0].to_i
 	end
 
 	# Sees if the table is empty
+	# @param [Hash/String] Filter conditions
 	# @return [boolean]
-	def empty?
-		count == 0
-	end
-
-	# Select * with optional conditions
-	# @param [Hash/String] where Select filters
-	# @return [Array] Array is returned if block is not given
-	# @yield [JDBCHelper::Connection::Row]
-	def select where = nil, &block
-		@connection.query(JDBCHelper::SQL.select(name, where), &block)
+	def empty? where = nil
+		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
-		@connection.update(JDBCHelper::SQL.insert name, data_hash)
+		@connection.send @update_method, JDBCHelper::SQL.insert(name, data_hash)
 	end
 
 	# Inserts a record into the table with the given hash.
@@ -57,7 +73,7 @@ class TableWrapper < ObjectWrapper
 	# @param [Hash] data_hash Column values in Hash
 	# @return [Fixnum] Number of affected records
 	def insert_ignore data_hash
-		@connection.update(JDBCHelper::SQL.insert_ignore name, data_hash)
+		@connection.send @update_method, JDBCHelper::SQL.insert_ignore(name, data_hash)
 	end
 
 	# Replaces a record in the table with the new one with the same unique key.
@@ -65,7 +81,7 @@ class TableWrapper < ObjectWrapper
 	# @param [Hash] data_hash Column values in Hash
 	# @return [Fixnum] Number of affected records
 	def replace data_hash
-		@connection.update(JDBCHelper::SQL.replace name, data_hash)
+		@connection.send @update_method, JDBCHelper::SQL.replace(name, data_hash)
 	end
 
 	# Executes update with the given hash.
@@ -74,14 +90,15 @@ class TableWrapper < ObjectWrapper
 	#   :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
-		@connection.update(JDBCHelper::SQL.update name, data_hash_with_where)
+		where = data_hash_with_where.delete(:where) || @query_where
+		@connection.send @update_method, JDBCHelper::SQL.update(name, data_hash_with_where, where)
 	end
 
 	# Deletes records matching given condtion
 	# @param [Hash] where Delete filters
 	# @return [Fixnum] Number of affected records
 	def delete where = nil
-		@connection.update(JDBCHelper::SQL.delete name, where)
+		@connection.send @update_method, JDBCHelper::SQL.delete(name, where || @query_where)
 	end
 
 	# Empties the table.
@@ -97,6 +114,101 @@ class TableWrapper < ObjectWrapper
 	def drop_table!
 		@connection.update(JDBCHelper::SQL.check "drop table #{name}")
 	end
+
+	# 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.
+	# @return [*String/*Symbol] 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 [Hash/String] Filter conditions
+	# @return [JDBCHelper::TableWrapper]
+	# @since 0.4.0
+	def where conditions, &block
+		obj = self.dup
+		obj.instance_variable_set :@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] 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
+
+	# 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
+		@connection.enumerate sql, &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]
+	# @since 0.4.0
+	def batch
+		if batch?
+			self
+		else
+			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 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
+	end
+private
+	def ret obj, &block
+		if block_given?
+			obj.each &block
+		else
+			obj
+		end
+	end
 end#TableWrapper
 end#JDBCHelper
 

data/test/database.yml

@@ -5,9 +5,9 @@ mysql:
     user: root
     password:
 
-oracle:
-    driver: oracle.jdbc.driver.OracleDriver
-    url: jdbc:oracle:thin:@localhost/test
-    user: testuser
-    password: testpassword
+#oracle:
+    #driver: oracle.jdbc.driver.OracleDriver
+    #url: jdbc:oracle:thin:@localhost/test
+    #user: testuser
+    #password: testpassword
 

data/test/test_object_wrapper.rb

@@ -70,15 +70,15 @@ class TestObjectWrapper < Test::Unit::TestCase
 		end
 	end
 
-	def insert table
+	def insert table, cnt = 100
 		params = {
 			:alpha => 100, 
-			:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+			:beta => JDBCHelper::SQL('0.1 + 0.2'), 
 			:gamma => 'hello world' }
 
-		(1..100).each do |pk|
+		(1..cnt).each do |pk|
 			icnt = table.insert(params.merge(:id => pk))
-			assert_equal icnt, 1
+			assert_equal 1, icnt unless table.batch?
 		end
 	end
 
@@ -133,10 +133,22 @@ class TestObjectWrapper < Test::Unit::TestCase
 			# Insert
 			insert table
 
+			# Empty?
+			assert_equal false, table.empty?
+			assert_equal true, table.empty?(:alpha => 999)
+			assert_equal true, table.where(:alpha => 999).empty?
+
 			# Count
 			assert_equal 100, table.count
 			assert_equal 100, table.count(:alpha => 100)
 			assert_equal 0, table.count(:beta => nil)
+
+			assert_equal 100, table.where(:alpha => 100).count
+			assert_equal 0, table.where(:beta => nil).count
+			assert_equal 0, table.where(:alpha => 100).count(:beta => nil)
+
+			assert_equal true, table.empty?(:beta => nil)
+			assert_equal true, table.where(:beta => nil).empty?
 		end
 	end
 
@@ -149,7 +161,7 @@ class TestObjectWrapper < Test::Unit::TestCase
 			params = {
 				:id => 1,
 				:alpha => 100, 
-				:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+				:beta => JDBCHelper::SQL('0.1 + 0.2'), 
 				:gamma => 'hello world' }
 
 			100.times do
@@ -168,7 +180,7 @@ class TestObjectWrapper < Test::Unit::TestCase
 			table = conn.table(@table_name)
 			params = {
 				:id => 1,
-				:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+				:beta => JDBCHelper::SQL('0.1 + 0.2'), 
 				:gamma => 'hello world' }
 
 			100.times do |i|
@@ -187,21 +199,60 @@ class TestObjectWrapper < Test::Unit::TestCase
 			insert table
 			assert_equal 100, table.count
 
+			def check_row row
+				assert_equal 100, row.alpha
+				assert_equal 'hello world', row.gamma
+			end
+
 			cnt = 0
 			table.select do |row|
 				cnt += 1
-				assert_equal 100, row.alpha
-				assert_equal 'hello world', row.gamma
+				check_row row
 			end
 			assert_equal 100, cnt
 
 			cnt = 0
-			table.select(:id => 11..20) do |row|
+			table.each do |row|
 				cnt += 1
-				assert_equal 100, row.alpha
-				assert_equal 'hello world', row.gamma
+				check_row row
+			end
+			assert_equal 100, cnt
+
+			cnt = 0
+			table.each_slice(10) do |rows|
+				cnt += rows.length
+			end
+			assert_equal 100, cnt
+
+			cnt = 0
+			table.select('alpha omega') do |row|
+				cnt += 1
+				assert_equal 100, row.omega
+				assert_equal ['omega'], row.labels.map(&:downcase)
+			end
+			assert_equal 100, cnt
+
+			cnt = 0
+			prev_id = 100
+			table.where(:id => 11..20).order('id desc') do |row|
+				cnt += 1
+				check_row row
+
+				assert row.id.to_i < prev_id
+				prev_id = row.id.to_i
 			end
 			assert_equal 10, cnt
+
+			assert_equal "select a, b, c cc from tmp_jdbc_helper " +
+					"where id >= 11 and id <= 20 order by id desc, name asc",
+					table.where(:id => 11..20).
+						select(:a, :b, 'c cc').
+						order('id desc', 'name asc').sql
+
+			assert_raise(ArgumentError) { table.order }
+			assert_raise(ArgumentError) { table.order.where }
+			assert_raise(ArgumentError) { table.where.order }
+			assert_raise(ArgumentError) { table.select.order }
 		end
 	end
 
@@ -220,9 +271,10 @@ class TestObjectWrapper < Test::Unit::TestCase
 			assert_equal 1, table.delete(:id => 21)
 			assert_equal 4, table.delete(:id => [22, 23, 24, 25])
 			assert_equal 5, table.delete("id <= 30")
+			assert_equal 10, table.where("id <= 40").delete
 
 			# Could be dangerous (XXX)
-			assert_equal 70, table.delete
+			assert_equal 60, table.delete
 
 			# Count
 			assert_equal 0, table.count
@@ -236,8 +288,42 @@ class TestObjectWrapper < Test::Unit::TestCase
 			insert table
 
 			assert_equal 10, table.update(:beta => 0, :where => { :id => (1..10) })
-			assert_equal 10, table.count(:beta => 0)
+			assert_equal 10, table.where(:id => (11..20)).update(:beta => 0)
+			assert_equal 20, table.count(:beta => 0)
+			assert_equal 100, table.update(:beta => 1)
+		end
+	end
+
+	def test_batch
+		each_connection do |conn|
+			# Initialize test table
+			create_table conn
+			table = conn.table(@table_name)
+			insert table
+
+			# Duplicated calls are idempotent
+			btable = table.batch
+			assert_equal btable, btable.batch
+
+			# Batch updates
+			table.batch.delete
+			assert_equal 100, table.count
+
+			insert table.batch, 50
+			assert_equal 100, 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
+
+			# Finally
+			conn.execute_batch
 
+			assert_equal 50, table.count
+			assert_equal 200, table.select(:alpha).to_a.first.alpha.to_i
 		end
 	end
 

data/test/test_sql.rb

@@ -1,6 +1,7 @@
 require 'helper'
 include JDBCHelper
 
+# WARNING: tests assumes ordered hash
 class TestSQL < Test::Unit::TestCase
 	def setup
 	end
@@ -14,22 +15,22 @@ class TestSQL < Test::Unit::TestCase
 		assert_equal 9999999999999999999, SQL.value(9999999999999999999)
 		assert_equal "'sysdate'",         SQL.value('sysdate')
 		assert_equal "'A''s'",            SQL.value("A's")
-		assert_equal "sysdate",           SQL.value(SQL.expr('sysdate'))
+		assert_equal "sysdate",           SQL.value(JDBCHelper::SQL('sysdate'))
 
 	end
 
-	def test_order_by
-		assert_equal "", SQL.order_by()
-		assert_equal "", SQL.order_by(nil)
-		assert_equal "", SQL.order_by(nil, nil)
-		assert_equal "order by a", SQL.order_by(:a)
-		assert_equal "order by a", SQL.order_by('a')
-		assert_equal "order by a desc", SQL.order_by('a desc')
-		assert_equal "order by a asc", SQL.order_by('a asc')
-		assert_equal "order by a, b asc, c desc", SQL.order_by(:a, 'b asc', 'c desc')
-
-		assert_raise(ArgumentError) { SQL.order_by(" -- ") }
-		assert_raise(ArgumentError) { SQL.order_by(:a, :b, "c 'd") }
+	def test_order
+		assert_equal "", SQL.order()
+		assert_equal "", SQL.order(nil)
+		assert_equal "", SQL.order(nil, nil)
+		assert_equal "order by a", SQL.order(:a)
+		assert_equal "order by a", SQL.order('a')
+		assert_equal "order by a desc", SQL.order('a desc')
+		assert_equal "order by a asc", SQL.order('a asc')
+		assert_equal "order by a, b asc, c desc", SQL.order(:a, 'b asc', 'c desc')
+
+		assert_raise(ArgumentError) { SQL.order(" -- ") }
+		assert_raise(ArgumentError) { SQL.order(:a, :b, "c 'd") }
 	end
 
 	def test_where
@@ -41,8 +42,9 @@ class TestSQL < Test::Unit::TestCase
 		assert_equal "where a = 'A''s'",              SQL.where(:a => "A's")
 		assert_equal "where a is null",               SQL.where(:a => nil)
 		assert_equal "where a is not null",           SQL.where(:a => SQL.not_nil)
-		assert_equal "where a = sysdate",             SQL.where(:a => SQL.expr('sysdate'))
-		assert_equal "where sysdate = sysdate",       SQL.where(SQL.expr('sysdate') => SQL.expr('sysdate'))
+		assert_equal "where a is not null",           SQL.where(:a => SQL.not_null)
+		assert_equal "where a = sysdate",             SQL.where(:a => JDBCHelper::SQL('sysdate'))
+		assert_equal "where sysdate = sysdate",       SQL.where(JDBCHelper::SQL('sysdate') => JDBCHelper::SQL('sysdate'))
 		assert_equal "where a in ('aa', 'bb', 'cc')", SQL.where(:a => %w[aa bb cc])
 		assert_equal "where a = 1 and b = 'A''s'",    SQL.where(:a => 1, :b => "A's")
 		assert_equal "where a = 1 or b = 1",          SQL.where("a = 1 or b = 1")
@@ -53,16 +55,23 @@ class TestSQL < Test::Unit::TestCase
 		assert_raise(NotImplementedError) { SQL.where(:a => Time.now) }
 
 		# Invalid SQL detection
-		assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'a--b' -- cde")) }
-		assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'aabbb''dd")) }
-		assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(" 'aabbb''dd' /* aaa */")) }
-		assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(' aabbb"""  ')) }
-		assert_raise(ArgumentError) { SQL.where(:a => SQL.expr(' aab`bb``  ')) }
+		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(" 'a--b' -- cde")) }
+		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(" 'aabbb''dd")) }
+		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(" 'aabbb''dd' /* aaa */")) }
+		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(' aabbb"""  ')) }
+		assert_raise(ArgumentError) { SQL.where(:a => JDBCHelper::SQL(' aab`bb``  ')) }
 	end
 
 	def test_select
 		assert_equal "select * from a.b", SQL.select('a.b')
-		assert_equal "select * from a.b where a is not null", SQL.select('a.b', :a => SQL.not_nil)
+		assert_equal "select aa, bb from a.b where a is not null",
+				SQL.select('a.b', :select => %w[aa bb], :where => {:a => SQL.not_nil})
+		assert_equal "select aa, bb from a.b where a is not null and b >= 1 and b <= 10 order by cc, dd", 
+				SQL.select('a.b', 
+						   :select => %w[aa bb], 
+						   :where => {:a => SQL.not_null, :b => (1..10)},
+						   :order => %w[cc dd]
+						  )
 	end
 
 	def test_count
@@ -77,10 +86,10 @@ class TestSQL < Test::Unit::TestCase
 
 	def test_update
 		assert_equal "update a.b set a = 1, b = 'A''s', c = now()", 
-			SQL.update('a.b', :a => 1, :b => "A's", :c => SQL.expr('now()'))
+			SQL.update('a.b', {:a => 1, :b => "A's", :c => JDBCHelper::SQL('now()')}, {})
 
 		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 => SQL.expr('now()'), :where => { :a => SQL.not_nil })
+			SQL.update('a.b', {:a => 1, :b => "A's", :c => JDBCHelper::SQL('now()')}, { :a => SQL.not_nil })
 	end
 
 	def test_insert

metadata

@@ -2,7 +2,7 @@
 name: jdbc-helper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
   - Junegunn Choi
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-25 00:00:00 +09:00
+date: 2011-05-31 00:00:00 +09:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency