jdbc-helper 0.1.3 → 0.2.0

data/lib/jdbc-helper/object_wrapper.rb

@@ -0,0 +1,126 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+# Abstract base class for wrappers for various database objects.
+# @abstract
+# @since 0.2.0
+# @todo Need to add more subclasses (such as for functions and procedures)
+class ObjectWrapper
+	# Underlying JDBCHelper::Connection object
+	# @return [JDBCHelper::Connection]
+	attr_reader :connection
+
+	# Object name (or expression)
+	# @return [String]
+	attr_reader :name
+
+	# Base constructor.
+	# @param [JDBCHelper::Connection] conn JDBCHelper::Connection object
+	# @param [String] 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
+
+		@connection = conn
+		@name = name.to_s
+		JDBCHelper::SQL.check @name
+	end
+end#ObjectWrapper
+
+# A wrapper object representing a database table. Allows you to perform table operations easily.
+# @since 0.2.0
+# @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
+#  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!
+class TableWrapper < ObjectWrapper
+	# Retrieves the count of the table
+	# @return [Fixnum] Count of the records.
+	def count(where = nil)
+		@connection.query(JDBCHelper::SQL.count name, where)[0][0]
+	end
+
+	# Sees if the table is empty
+	# @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)
+	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)
+	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
+		@connection.update(JDBCHelper::SQL.insert_ignore name, data_hash)
+	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
+		@connection.update(JDBCHelper::SQL.replace name, data_hash)
+	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
+		@connection.update(JDBCHelper::SQL.update name, data_hash_with_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)
+	end
+
+	# Empties the table.
+	# @note This operation cannot be undone
+	# @return [Fixnum] executeUpdate return value
+	def truncate_table!
+		@connection.update(JDBCHelper::SQL.check "truncate table #{name}")
+	end
+	
+	# Drops the table.
+	# @note This operation cannot be undone
+	# @return [Fixnum] executeUpdate return value
+	def drop_table!
+		@connection.update(JDBCHelper::SQL.check "drop table #{name}")
+	end
+end#TableWrapper
+
+end#JDBCHelper
+

data/lib/jdbc-helper/sql.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+# Junegunn Choi (junegunn.c@gmail.com)
+
+module JDBCHelper
+module SQL
+	# Prevents a string from being quoted
+	def self.expr str
+		Expr.new str
+	end
+	
+	# Returns NotNilClass singleton object
+	def self.not_nil
+		NotNilClass.singleton
+	end
+
+	# Formats the given data so that it can be injected into SQL
+	def self.value data
+		case data
+		when NilClass
+			'null'
+		when Fixnum, Bignum, Float
+			data
+		when JDBCHelper::SQL::Expr
+			data.to_s
+		when String
+			"'#{esc data}'"
+		else
+			raise NotImplementedError.new("Unsupported datatype: #{data.class}")
+		end
+	end
+
+	# Generates SQL where cluase with the given conditions.
+	# Parameter can be either Hash of String.
+	def self.where conds
+		check(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_clause = make_where(data_hash.delete :where)
+		updates = data_hash.map { |k, v| "#{k} = #{value v}" }.join(', ')
+		check "update #{table} set #{updates}#{where_clause}"
+	end
+
+	# Generates select * SQL with the given conditions
+	def self.select table, conds = nil
+		check "select * from #{table}#{make_where conds}"
+	end
+
+	# Generates count SQL with the given conditions
+	def self.count table, conds = nil
+		check "select count(*) from #{table}#{make_where conds}"
+	end
+
+	# Generates delete SQL with the given conditions
+	def self.delete table, conds = nil
+		check "delete from #{table}#{make_where conds}"
+	end
+
+	# FIXME: Naive protection for SQL Injection
+	def self.check expr
+		return nil if expr.nil?
+
+		test = expr.gsub(/'[^']*'/, '').gsub(/`[^`]*`/, '').gsub(/"[^"]*"/, '')
+		raise ArgumentError.new("Expression cannot contain semi-colons: #{test}") if test.include?(';')
+		raise ArgumentError.new("Expression cannot contain comments: #{test}") if test.match(%r{--|/\*|\*/})
+		raise ArgumentError.new("Unclosed quotation mark: #{test}") if test.match(/['"`]/)
+
+		return expr
+	end
+
+private
+	def self.esc str
+		str.gsub("'", "''")
+	end
+
+	def self.make_where conds
+		str = where_internal conds
+		str = ' where ' + str if str
+		str
+	end
+
+	# No check
+	def self.where_internal conds
+		return nil if conds.nil?
+
+		case conds
+		when String
+			return nil if conds.strip.empty?
+			conds
+		when Hash
+			return nil if conds.empty?
+			conds.map { |k, v|
+				"#{k} " +
+					case v
+					when NilClass
+						"is null"
+					when NotNilClass
+						"is not null"
+					when Fixnum, Bignum, Float, JDBCHelper::SQL::Expr
+						"= #{v}"
+					when Range
+						">= #{v.first} and #{k} <#{'=' unless v.exclude_end?} #{v.last}"
+					when Array
+						"in (" + 
+						v.map { |e|
+							case e
+							when String
+								"'#{esc e}'"
+							else
+								e
+							end }.join(', ') + ")"
+					when String
+						"= '#{esc v}'"
+					else
+						raise NotImplementedError.new("Unsupported class: #{v.class}")
+					end
+			}.join(' and ')
+		else
+			raise NotImplementedError.new("Parameter to where must be either Hash or String")
+		end
+	end
+
+	def self.insert_internal cmd, table, data_hash
+		cols = data_hash.keys
+		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
+	end
+
+	# Class to represent "(IS) NOT NULL" expression in SQL
+	class NotNilClass
+		# Returns the singleton object of NotNilClass
+		# @return [NotNilClass]
+		def self.singleton
+			@@singleton ||= NotNilClass.new
+		end
+	end
+end#SQL
+end#JDBCHelper
+

data/lib/jdbc-helper.rb

@@ -15,6 +15,8 @@ module JavaSql # :nodoc:
 	include_package 'java.sql'
 end
 
+require 'jdbc-helper/sql'
+require 'jdbc-helper/object_wrapper'
 require 'jdbc-helper/constants'
 require 'jdbc-helper/connection'
 require 'jdbc-helper/connector'

data/test/database.yml

@@ -4,10 +4,12 @@ mysql:
     url: jdbc:mysql://localhost/test
     user: mysql
     password:
+    database: test
 
 # oracle:
 #     driver: com.mysql.jdbc.Driver
-#     url: jdbc:mysql://localhost/test
-#     user: mysql
+#     url: jdbc:oracle:thin:@localhost/test
+#     user: test
 #     password:
+#     database: test
 

data/test/helper.rb

@@ -15,3 +15,25 @@ require 'jdbc-helper'
 
 class Test::Unit::TestCase
 end
+
+module JDBCHelperTestHelper
+	require 'yaml'
+	def config
+		@db_config ||= YAML.load File.read(File.dirname(__FILE__) + '/database.yml')
+	end
+
+	def each_connection(&block)
+		config.each do | db, conn_info |
+			conn = JDBCHelper::Connection.new(conn_info)
+			begin
+				if block.arity == 1
+					yield conn
+				else
+					yield conn, conn_info
+				end
+			ensure
+				conn.close
+			end
+		end
+	end
+end

data/test/{test_jdbc-helper.rb → test_connection.rb}

@@ -1,28 +1,16 @@
 require 'helper'
 
-class TestJdbcHelper < Test::Unit::TestCase
+class TestConnection < Test::Unit::TestCase
+	include JDBCHelperTestHelper
+
 	def setup
-		require 'yaml'
-		@config = YAML.load File.read(File.dirname(__FILE__) + '/database.yml')
 	end
 
 	def teardown
-
 	end
 
 	TEST_TABLE = 'tmp_jdbc_helper_test'
 
-	def each_connection
-		@config.each do | db, conn_info |
-			conn = JDBCHelper::Connection.new(conn_info)
-			begin
-				yield conn
-			ensure
-				conn.close
-			end
-		end
-	end
-
 	def get_one_two
 		"
 		select 1 one, 'two' two from dual
@@ -42,7 +30,7 @@ class TestJdbcHelper < Test::Unit::TestCase
 		assert_equal 'two', rec[1]
 		assert_equal 'two', rec['two']
 
-		assert_raise(NameError) { rec.three }
+		assert_raise(NoMethodError) { rec.three }
 		assert_raise(NameError) { rec['three'] }
 		assert_raise(RangeError) { rec[3] }
 	end
@@ -69,7 +57,7 @@ class TestJdbcHelper < Test::Unit::TestCase
 	# ---------------------------------------------------------------
 
 	def test_connect_and_close
-		@config.each do | db, conn_info |
+		config.each do | db, conn_info |
 			4.times do | i |
 				# With or without timeout parameter
 				conn_info['timeout'] = 60 if i % 2 == 1
@@ -276,28 +264,6 @@ class TestJdbcHelper < Test::Unit::TestCase
 		end
 	end
 
-	def test_connectors
-		@config.each do | db, conn_info |
-			if db == 'mysql'
-				host = conn_info['url'].match(%r{//(.*?)/})[1]
-				db = conn_info['url'].match(%r{/([^/?]*?)(\?.*)?$})[1]
-				conn = JDBCHelper::MySQLConnector.connect(host, conn_info['user'], conn_info['password'], db)
-
-				assert conn.closed? == false
-				conn.close
-				assert conn.closed?
-			elsif db == 'oracle'
-				host = conn_info['url'].match(%r{//(.*?)/})[1]
-				svc = conn_info['url'].match(%r{/([^/?]*?)(\?.*)?$})[1]
-				conn = JDBCHelper::OracleConnector.connect(host, conn_info['user'], conn_info['password'], svc)
-
-				assert conn.closed? == false
-				conn.close
-				assert conn.closed?
-			end
-		end
-	end
-
 	def test_setter_timestamp
 		each_connection do | conn |
 			# Java timestamp

data/test/test_connectors.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+class TestConnectors < Test::Unit::TestCase
+	include JDBCHelperTestHelper
+
+	def setup
+	end
+
+	def teardown
+	end
+
+	def test_connectors
+		config.each do | db, conn_info |
+			if db == 'mysql'
+				host = conn_info['url'].match(%r{//(.*?)/})[1]
+				db = conn_info['url'].match(%r{/([^/?]*?)(\?.*)?$})[1]
+				conn = JDBCHelper::MySQLConnector.connect(host, conn_info['user'], conn_info['password'], db)
+
+				assert conn.closed? == false
+				conn.close
+				assert conn.closed?
+			elsif db == 'oracle'
+				host = conn_info['url'].match(%r{//(.*?)/})[1]
+				svc = conn_info['url'].match(%r{/([^/?]*?)(\?.*)?$})[1]
+				conn = JDBCHelper::OracleConnector.connect(host, conn_info['user'], conn_info['password'], svc)
+
+				assert conn.closed? == false
+				conn.close
+				assert conn.closed?
+			end
+		end
+	end
+end
+

data/test/test_object_wrapper.rb

@@ -0,0 +1,221 @@
+require 'helper'
+
+class TestObjectWrapper < Test::Unit::TestCase
+	include JDBCHelperTestHelper
+
+	def setup
+		@table_name = "tmp_jdbc_helper"
+	end
+
+	def teardown
+		each_connection do |conn|
+			drop_table conn
+		end
+	end
+
+	def create_table conn
+		drop_table conn
+		conn.update "
+			create table #{@table_name} (
+				id    int primary key,
+				alpha int,
+				beta  float,
+				gamma varchar(100)
+			)
+		"
+	end
+
+	def drop_table conn
+		begin
+			conn.update "drop table #{@table_name}"
+			return true
+		rescue Exception
+			return false
+		end
+	end
+
+	def test_wrapper
+		each_connection do |conn|
+			# With symbol
+			assert_kind_of     JDBCHelper::ObjectWrapper, conn.table(:some_table)
+			assert_instance_of JDBCHelper::TableWrapper, conn.table(:some_table)
+			assert_equal       'some_table', conn.table(:some_table).name
+
+			# With string
+			assert_kind_of     JDBCHelper::ObjectWrapper, conn.table('db.table')
+			assert_instance_of JDBCHelper::TableWrapper, conn.table('db.table')
+			assert_equal       'db.table', conn.table('db.table').name
+
+			# Invalid table name
+			assert_raise(ArgumentError) { conn.table('table;') }
+			assert_raise(ArgumentError) { conn.table('table -- ') }
+			assert_raise(ArgumentError) { conn.table("tab'le") }
+			assert_raise(ArgumentError) { conn.table('tab"le') }
+			assert_raise(ArgumentError) { conn.table("tab`le") }
+
+			# Abstract class
+			assert_raise(Exception) { JDBCHelper::ObjectWrapper.new(conn, 'table') }
+		end
+	end
+
+	def insert table
+		params = {
+			:alpha => 100, 
+			:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+			:gamma => 'hello world' }
+
+		(1..100).each do |pk|
+			icnt = table.insert(params.merge(:id => pk))
+			assert_equal icnt, 1
+		end
+	end
+
+	def test_empty
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+
+			assert table.empty?
+		end
+	end
+
+	def test_insert_count
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+
+			# Count
+			assert_equal 0, table.count
+			assert table.empty?
+
+			# Insert
+			insert table
+
+			# Count
+			assert_equal 100, table.count
+			assert_equal 100, table.count(:alpha => 100)
+			assert_equal 0, table.count(:beta => nil)
+		end
+	end
+
+	# This will fail if the database doesn't support insert ignore syntax
+	def test_insert_ignore
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			params = {
+				:id => 1,
+				:alpha => 100, 
+				:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+				:gamma => 'hello world' }
+
+			100.times do
+				table.insert_ignore(params)
+			end
+
+			assert_equal 1, table.count
+		end
+	end
+
+	# This will fail if the database doesn't support replace syntax
+	def test_replace
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			params = {
+				:id => 1,
+				:beta => JDBCHelper::SQL.expr('0.1 + 0.2'), 
+				:gamma => 'hello world' }
+
+			100.times do |i|
+				table.replace(params.merge(:alpha => i))
+			end
+
+			assert_equal 1, table.count
+			assert_equal 99, table.select.first.alpha
+		end
+	end
+
+	def test_select
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			insert table
+			assert_equal 100, table.count
+
+			cnt = 0
+			table.select do |row|
+				cnt += 1
+				assert_equal 100, row.alpha
+				assert_equal 'hello world', row.gamma
+			end
+			assert_equal 100, cnt
+
+			cnt = 0
+			table.select(:id => 11..20) do |row|
+				cnt += 1
+				assert_equal 100, row.alpha
+				assert_equal 'hello world', row.gamma
+			end
+			assert_equal 10, cnt
+		end
+	end
+
+	def test_delete
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			insert table
+
+			# Count
+			assert_equal 100, table.count
+
+			# Delete
+			assert_equal 10, table.delete(:id => (1...11))
+			assert_equal 10, table.delete(:id => (11..20))
+			assert_equal 1, table.delete(:id => 21)
+			assert_equal 4, table.delete(:id => [22, 23, 24, 25])
+			assert_equal 5, table.delete("id <= 30")
+
+			# Could be dangerous (XXX)
+			assert_equal 70, table.delete
+
+			# Count
+			assert_equal 0, table.count
+		end
+	end
+
+	def test_update
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			insert table
+
+			assert_equal 10, table.update(:beta => 0, :where => { :id => (1..10) })
+			assert_equal 10, table.count(:beta => 0)
+
+		end
+	end
+
+	def test_truncate_table
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			insert table
+
+			table.truncate_table!
+			assert table.empty?
+		end
+	end
+
+	def test_drop_table
+		each_connection do |conn|
+			create_table conn
+			table = conn.table(@table_name)
+			table.drop_table!
+
+			assert_equal false, drop_table(conn)
+		end
+	end
+end
+