On Wed, Jun 18, 2008 at 1:10 PM, Larry M. [email protected]
wrote:
I actually created a ruby gem specifically for this purpose. It lives quite
happily up on rubyforge.
http://jdbc-wrapper.rubyforge.org/
Ruby’s blocks make it quite easy to break out of the try/catch/finally pain
you usually have to do with JDBC in Java.
Ruby’s blocks are quite nice for JDBC. I am doing something similar.
I had tried using a jdbc/dbi driver, but had some problems with it (I
don’t remember what they were at the moment). I didn’t actually wrap
JDBC like your package does, I chose to decorate java classes with
ruby like functionality.
module JdbcHelper
[‘javax.sql.DataSource’, ‘java.sql.Connection’,
‘java.sql.Statement’].each do |j_class|
JavaUtilities.extend_proxy(j_class) do
def with_closeable_resource(resource)
begin
yield(resource)
ensure
resource.close
end
end
end
end
JavaUtilities.extend_proxy(‘javax.sql.DataSource’) do
def with_connection(&block)
with_closeable_resource(self.get_connection, &block)
end
def transaction
with_connection { |c| c.transaction { yield(c) } }
end
def execute_update(sql, *params, &block)
self.transaction { |connection| connection.execute_update(sql,
*params, &block) }
end
def each_array(sql, *params, &block)
self.transaction { |connection| connection.each_array(sql,
*params, &block) }
end
def each_hash(sql, *params, &block)
self.transaction { |connection| connection.each_hash(sql,
*params, &block) }
end
end
JavaUtilities.extend_proxy(‘java.sql.Connection’) do
def mysql?
!self.meta_data.database_product_name.downcase.index("mysql").nil?
end
def postgres?
!self.meta_data.database_product_name.downcase.index("postgres").nil?
end
def with_statement(&block)
with_closeable_resource(self.create_statement, &block)
end
def with_prepared_statement(sql, &block)
with_closeable_resource(self.prepare_statement(sql), &block)
end
def with_callable_statement(sql, &block)
with_closeable_resource(self.prepare_call(sql), &block)
end
def transaction
ac = self.auto_commit
begin
self.auto_commit = false if ac
success = false
begin
rc = yield
success = true
return rc
ensure
if success
self.commit
else
self.rollback
end
end
ensure
self.auto_commit = ac if ac
end
end
def execute_update(sql, *params)
rc = -1
if params.empty?
with_statement { |st| rc = st.execute_update(sql) }
else
with_prepared_statement(sql) do |st|
st.set_parameters(*params)
rc = st.execute_update
end
end
rc
end
def each_array(sql, *params, &block)
if params.empty?
with_statement do |st|
st.enable_streaming_results
st.each_array(sql, &block)
end
else
with_prepared_statement(sql) do |st|
st.set_parameters(*params)
st.enable_streaming_results
st.each_array(&block)
end
end
end
def each_hash(sql, *params, &block)
if params.empty?
with_statement do |st|
st.enable_streaming_results
st.each_hash(sql, &block)
end
else
with_prepared_statement(sql) do |st|
st.set_parameters(*params)
st.enable_streaming_results
st.each_hash(&block)
end
end
end
end
JavaUtilities.extend_proxy(‘java.sql.Statement’) do
def execute_with_result_set(sql = nil, &block)
rs = nil
if sql.nil?
rs = self.execute_query
else
rs = self.execute_query(sql)
end
with_closeable_resource(rs, &block)
end
def enable_streaming_results
# Tries to use streaming result sets
if self.connection.postgres?
self.fetch_size = 100
elsif self.connection.mysql?
self.fetch_size = java.lang.Integer::MIN_VALUE
end
end
def each_array(sql = nil, &block)
execute_with_result_set(sql) { |rs| rs.each_array(&block) }
end
def each_hash(sql = nil, &block)
execute_with_result_set(sql) { |rs| rs.each_hash(&block) }
end
end
JavaUtilities.extend_proxy(‘java.sql.PreparedStatement’) do
def set_parameters(*params)
i = 1
params.each do |param|
if param.nil?
self.set_null(i, java.sql.Types::NULL)
elsif param.kind_of? java.lang.Object
self.set_object(i, param)
elsif param.kind_of? Float
self.set_double(i, param)
elsif param.kind_of? Fixnum
self.set_long(i, param)
elsif param.kind_of? Bignum
self.set_big_integer(i, param)
elsif param.kind_of? TrueClass or param.kind_of? FalseClass
self.set_boolean(i, param)
elsif param.kind_of? Time
self.set_timestamp(i, java.sql.Timestamp.new((param.to_f *
1000).to_i))
elsif param.kind_of? DateTime
self.set_timestamp(i,
java.sql.Timestamp.new((Time.parse(param.to_s).to_f * 1000).to_i))
elsif param.kind_of? Date
self.set_date(i, java.sql.Date.value_of(param))
else
self.set_string(i, param.to_s)
end
i+= 1
end
end
end
JavaUtilities.extend_proxy(‘java.sql.ResultSet’) do
def each_array(&block)
md = self.meta_data
ncols = md.column_count
columns = (1..ncols).collect { |i| md.column_name(i) }
while self.next
row = (1..ncols).collect { |i| self.get_object(i) }
if block.arity == 2
block.call(row, columns)
else
block.call(row)
end
end
end
def each_hash
md = self.meta_data
ncols = md.column_count
columns = (1..ncols).collect { |i| md.column_name(i) }
while self.next
row = {}
(1..ncols).each { |i| row[columns[i-1]] = self.get_object(i) }
yield(row)
end
end
end
end
I want to access JDBC from JRuby. How do I do this? Has anyone got a
believed to be free of any virus or other defect that might affect any
http://xircles.codehaus.org/manage_email
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
