Class: JDBCHelper::Connection

Inherits:
Object
  • Object
show all
Defined in:
lib/jdbc-helper/connection.rb,
lib/jdbc-helper/connection/row.rb,
lib/jdbc-helper/connection/type_map.rb,
lib/jdbc-helper/connection/result_set.rb,
lib/jdbc-helper/connection/statement_pool.rb,
lib/jdbc-helper/connection/callable_statement.rb,
lib/jdbc-helper/connection/prepared_statement.rb,
lib/jdbc-helper/connection/parameterized_statement.rb

Overview

p_upd.close

Defined Under Namespace

Classes: CallableStatement, ParameterizedStatement, PreparedStatement, ResultSet, Row, StatementPool, Transaction

Constant Summary collapse

RUBY_SQL_TYPE_MAP = 
{
  Fixnum => java.sql.Types::INTEGER,
  Bignum => java.sql.Types::BIGINT,
  String => java.sql.Types::VARCHAR,
  Float  => java.sql.Types::DOUBLE,
  Time   => java.sql.Types::TIMESTAMP
}
GETTER_MAP = 
{
  java.sql.Types::TINYINT                   => :getInt,
  java.sql.Types::SMALLINT                  => :getInt,
  java.sql.Types::INTEGER                   => :getInt,
  java.sql.Types::BIGINT                    => :getLong,

  java.sql.Types::CHAR                      => :getString,
  java.sql.Types::VARCHAR                   => :getString,
  java.sql.Types::LONGVARCHAR               => :getString,
  (java.sql.Types::NCHAR        rescue nil) => :getString,
  (java.sql.Types::NVARCHAR     rescue nil) => :getString,
  (java.sql.Types::LONGNVARCHAR rescue nil) => :getString,

  # !! MySQL function returns VARBINARY type
  java.sql.Types::BINARY             => :getBinaryStream,
  java.sql.Types::VARBINARY          => :getBinaryStream,
  java.sql.Types::LONGVARBINARY      => :getBinaryStream,

  java.sql.Types::REAL               => :getDouble,
  java.sql.Types::FLOAT              => :getFloat,
  java.sql.Types::DOUBLE             => :getDouble,

  java.sql.Types::DATE               => :getDate,
  java.sql.Types::TIME               => :getTime,
  java.sql.Types::TIMESTAMP          => :getTimestamp,

  java.sql.Types::BLOB               => :getBlob,
  java.sql.Types::CLOB               => :getString,
  (java.sql.Types::NCLOB rescue nil) => :getString,

  java.sql.Types::BOOLEAN            => :getBoolean
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(args = {}) ⇒ Connection

Creates a database connection.

  • ‘args` hash must include :driver (or “driver”) and :url (or “url”)

  • and takes optional :user and :password tuples (or “user”, “password”)

  • You can also specify :timeout (or “timeout”) to override the default connection timeout (60 seconds)

Must be closed explicitly if not used. If a block is given, the connection is automatically closed after executing the block.

Parameters:

  • args (Hash) (defaults to: {})

Raises:

  • (ArgumentError) 


138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/jdbc-helper/connection.rb', line 138

def initialize(args = {})
  # Subsequent deletes should not affect the input
  @args = args
  args = InsensitiveHash[ @args ]

  raise ArgumentError.new("driver not given") unless args.has_key? :driver
  raise ArgumentError.new("url not given") unless args.has_key? :url

  @driver = args.delete :driver
  @url = args.delete :url

  timeout = args.has_key?(:timeout) ? args.delete(:timeout) : Constants::DEFAULT_LOGIN_TIMEOUT
  if timeout
    if timeout.is_a?(Fixnum) == false || timeout <= 0
      raise ArgumentError.new("Timeout must be a positive integer")
    end
    Java::java.sql.DriverManager.setLoginTimeout timeout
  end

  props = Java::java.util.Properties.new
  args.each do |k, v|
    props.setProperty(k.to_s, v.to_s) unless v.nil?
  end

  @conn = case @driver
          when String
            # NameError will be thrown for invalid drivers
            Java::JavaClass.for_name @driver
            Java::java.sql.DriverManager.get_connection(@url, props)
          when Class
            @driver.new.connect(@url, props)
          else
            if @driver.respond_to?(:connect)
              @driver.connect(@url, props)
            else
              raise ArgumentError.new('Invalid type for :driver')
            end
          end
  @spool = StatementPool.send :new, self
  @bstmt = nil
  @fetch_size = nil

  @pstmts = []

  @table_wrappers = {}

  if block_given?
    begin
      yield self
    ensure
      close rescue nil
    end
  end
end

Instance Attribute Details

#driver ⇒ String|Class|#connect (readonly)

JDBC driver of the connection

Returns:

  • (String|Class|#connect) 


120
121
122
 
# File 'lib/jdbc-helper/connection.rb', line 120

def driver
  @driver
end

#fetch_size ⇒ Fixnum

Returns the fetch size of the connection. If not set, nil is returned.

Returns:

  • (Fixnum) 


385
386
387
 
# File 'lib/jdbc-helper/connection.rb', line 385

def fetch_size
  @fetch_size
end

#url ⇒ String (readonly)

JDBC URL of the connection

Returns:

  • (String) 


116
117
118
 
# File 'lib/jdbc-helper/connection.rb', line 116

def url
  @url
end

Instance Method Details

#add_batch(qstr) ⇒ NilClass

Adds a statement to be executed in batch Adds to the batch

Parameters:

  • qstr (String)

Returns:

  • (NilClass) 


328
329
330
331
332
333
 
# File 'lib/jdbc-helper/connection.rb', line 328

def add_batch(qstr)
  check_closed

  @bstmt ||= @spool.take
  @bstmt.add_batch qstr
end

#clear_batch ⇒ NilClass

Clears the batched statements including prepared statements.

Returns:

  • (NilClass) 


357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/jdbc-helper/connection.rb', line 357

def clear_batch
  check_closed

  if @bstmt
    @bstmt.clear_batch
    @spool.give @bstmt
    @bstmt = nil
  end

  @pstmts.each do |stmt|
    stmt.clear_batch
  end
end

#clone ⇒ JDBCHelper::Connection

Creates another connection with the same parameters as this Connection.

Returns:



195
196
197
198
199
 
# File 'lib/jdbc-helper/connection.rb', line 195

def clone
  nc = JDBCHelper::Connection.new @args
  nc.fetch_size = @fetch_size if @fetch_size
  nc
end

#close ⇒ NilClass

Closes the connection

Returns:

  • (NilClass) 


389
390
391
392
393
394
 
# File 'lib/jdbc-helper/connection.rb', line 389

def close
  return if closed?
  @spool.close
  @conn.close
  @conn = @spool = nil
end

#closed? ⇒ Boolean

Returns if this connection is closed or not

Returns:

  • (Boolean) 


398
399
400
 
# File 'lib/jdbc-helper/connection.rb', line 398

def closed?
  @conn.nil?
end

#execute(qstr) ⇒ Fixnum|ResultSet

Executes an SQL and returns the count of the update rows or a ResultSet object depending on the type of the given statement. If a ResultSet is returned, it must be enumerated or closed.

Parameters:

  • qstr (String) —

    SQL string

Returns:



259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/jdbc-helper/connection.rb', line 259

def execute(qstr)
  check_closed

  stmt = @spool.take
  begin
    if stmt.execute(qstr)
      ResultSet.send(:new, stmt.getResultSet) { @spool.give stmt }
    else
      rset = stmt.getUpdateCount
      @spool.give stmt
      rset
    end
  rescue Exception => e
    @spool.give stmt
    raise
  end
end

#execute_batch ⇒ Fixnum

Executes batched statements including prepared statements. No effect when no statement is added

Returns:

  • (Fixnum) —

    Sum of all update counts



337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
 
# File 'lib/jdbc-helper/connection.rb', line 337

def execute_batch
  check_closed

  cnt = 0

  if @bstmt
    cnt += @bstmt.execute_batch.inject(:+) || 0
    @spool.give @bstmt
    @bstmt = nil
  end

  @pstmts.each do |pstmt|
    cnt += pstmt.execute_batch
  end

  cnt
end

#function(func_name) ⇒ JDBCHelper::FunctionWrapper

Returns a function wrapper for the given function name

Parameters:

  • func_name (String/Symbol) —

    Name of the function to be wrapped

Returns:

Since:

  • 0.2.2



425
426
427
 
# File 'lib/jdbc-helper/connection.rb', line 425

def function func_name
  JDBCHelper::FunctionWrapper.new self, func_name
end

#inspect ⇒ String

Returns:

  • (String) 


438
439
440
441
442
 
# File 'lib/jdbc-helper/connection.rb', line 438

def inspect
  InsensitiveHash[@args].merge({ :closed? => closed? }).tap { |c|
    c.delete(:password)
  }.inspect
end

#jdbc_conn ⇒ Object Also known as: java_obj, java

Returns the underlying JDBC Connection object. Only use this when you really need to access it directly.



124
125
126
 
# File 'lib/jdbc-helper/connection.rb', line 124

def jdbc_conn
  @conn
end

#prepare(qstr) ⇒ Object

Creates a prepared statement, which is also an encapsulation of Java PreparedStatement object

Parameters:

  • qstr (String) —

    SQL string



203
204
205
206
207
208
209
210
211
 
# File 'lib/jdbc-helper/connection.rb', line 203

def prepare(qstr)
  check_closed

  pstmt = PreparedStatement.send(:new, self, qstr, @conn.prepare_statement(qstr))
  pstmt.set_fetch_size @fetch_size if @fetch_size

  @pstmts << pstmt
  pstmt
end

#prepare_call(qstr) ⇒ Object

Creates a callable statement.

Parameters:

  • qstr (String) —

    SQL string



220
221
222
223
224
 
# File 'lib/jdbc-helper/connection.rb', line 220

def prepare_call(qstr)
  check_closed

  CallableStatement.send(:new, self, qstr, @conn.prepare_call(qstr))
end

#prepared_statements ⇒ Array

Returns Prepared statements currently opened for this connection.

Returns:

  • (Array) —

    Prepared statements currently opened for this connection



214
215
216
 
# File 'lib/jdbc-helper/connection.rb', line 214

def prepared_statements
  @pstmts
end

#procedure(proc_name) ⇒ JDBCHelper::ProcedureWrapper

Returns a procedure wrapper for the given procedure name

Parameters:

  • proc_name (String/Symbol) —

    Name of the procedure to be wrapped

Returns:

Since:

  • 0.3.0



433
434
435
 
# File 'lib/jdbc-helper/connection.rb', line 433

def procedure proc_name
  JDBCHelper::ProcedureWrapper.new self, proc_name
end

#query(qstr) {|JDBCHelper::Connection::Row| ... } ⇒ Array Also known as: enumerate

Executes a select query. When a code block is given, each row of the result is passed to the block one by one. If not given, ResultSet is returned, which can be used to enumerate through the result set. ResultSet is closed automatically when all the rows in the result set is consumed.

Examples:

Nested querying

conn.query("SELECT a FROM T") do | trow |
  conn.query("SELECT * FROM U_#{trow.a}").each_slice(10) do | urows |
    # ...
  end
end

Parameters:

  • qstr (String) —

    SQL string

Yields:

Returns:

  • (Array) 


302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/jdbc-helper/connection.rb', line 302

def query(qstr, &blk)
  check_closed

  stmt = @spool.take
  begin
    rset = stmt.execute_query(qstr)
  rescue Exception => e
    @spool.give stmt
    raise
  end

  enum = ResultSet.send(:new, rset) { @spool.give stmt }
  if block_given?
    enum.each do |row|
      yield row
    end
  else
    enum
  end
end

#sequence(sequence_name) ⇒ JDBCHelper::SequenceWrapper

Returns a sequence wrapper for the given name

Parameters:

  • sequence_name (String/Symbol) —

    Name of the sequence to be wrapped

Returns:

Since:

  • 0.4.2



417
418
419
 
# File 'lib/jdbc-helper/connection.rb', line 417

def sequence sequence_name
  JDBCHelper::SequenceWrapper.new self, sequence_name
end

#set_fetch_size(fsz) ⇒ NilClass Also known as: fetch_size=

Gives the JDBC driver a hint of the number of rows to fetch from the database by a single interaction. This is only a hint. It may have no effect at all.

Parameters:

  • fsz (Fixnum)

Returns:

  • (NilClass) 


375
376
377
378
379
380
 
# File 'lib/jdbc-helper/connection.rb', line 375

def set_fetch_size(fsz)
  check_closed

  @fetch_size = fsz
  @spool.each { | stmt | stmt.set_fetch_size @fetch_size }
end

#table(table_name) ⇒ JDBCHelper::TableWrapper Also known as: []

Returns a table wrapper for the given table name

Parameters:

  • table_name (String/Symbol) —

    Name of the table to be wrapped

Returns:

Since:

  • 0.2.0



406
407
408
409
410
 
# File 'lib/jdbc-helper/connection.rb', line 406

def table table_name
  table = JDBCHelper::TableWrapper.new(self, table_name)
  table = table.fetch_size(@fetch_size) if @fetch_size
  @table_wrappers[table_name] ||= table
end

#transaction {|JDBCHelper::Connection::Transaction| ... } ⇒ Boolean

Executes the given code block as a transaction. Returns true if the transaction is committed. A transaction object is passed to the block, which only has commit and rollback methods. The execution breaks out of the code block when either of the methods is called.

Yields:

Returns:

  • (Boolean) —

    True if committed

Raises:

  • (ArgumentError) 


231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/jdbc-helper/connection.rb', line 231

def transaction
  check_closed

  raise ArgumentError.new("Transaction block not given") unless block_given?
  tx = Transaction.send :new, @conn
  ac = @conn.get_auto_commit
  status = :unknown
  begin
    @conn.set_auto_commit false
    yield tx
    @conn.commit
    status = :committed
  rescue Transaction::Commit
    status = :committed
  rescue Transaction::Rollback
    status = :rolledback
  ensure
    @conn.rollback if status == :unknown && @conn.get_auto_commit == false
    @conn.set_auto_commit ac
  end
  status == :committed
end

#update(qstr) ⇒ Fixnum

Executes an update and returns the count of the updated rows.

Parameters:

  • qstr (String) —

    SQL string

Returns:

  • (Fixnum) —

    Count of affected records



280
281
282
283
284
285
286
 
# File 'lib/jdbc-helper/connection.rb', line 280

def update(qstr)
  check_closed

  @spool.with do | stmt |
    ret = stmt.execute_update(qstr)
  end
end