rdbi 0.9.0 → 0.9.1

data/README.rdoc

@@ -20,6 +20,24 @@ path down the rabbit hole:
 * If you're interested in how schemas and types are dealt with, see
   RDBI::Schema, RDBI::Column, and RDBI::Type.
 
+== Need a Driver?
+
+=== Databases:
+
+==== Maintained by the RDBI project:
+
+* rdbi-driver-mysql: http://github.com/RDBI/rdbi-driver-mysql
+* rdbi-driver-postgresql: http://github.com/RDBI/rdbi-driver-postgresql
+* rdbi-driver-sqlite3: http://github.com/RDBI/rdbi-driver-sqlite3
+
+==== Maintained by third parties:
+
+* rdbi-driver-odbc: https://github.com/semmons99/rdbi-driver-odbc by Shane Emmons
+
+=== Results:
+
+* rdbi-result-driver-json: http://github.com/RDBI/rdbi-result-driver-json
+
 == Give me a code sample already!
 
   # connect to an in-memory sqlite3 database:
@@ -51,7 +69,6 @@ compelling (or off-putting. We're pragmatists.):
 * RDBI is, at the time of this writing, fewer than 1000 lines of code.
 * RDBI is light and fast. Eventually we will show you benchmarks.
 * RDBI can be tested without a database, or even a database driver.
-* RDBI is almost 100% thread-safe.
 * RDBI can transform your results through a driver system. Want a CSV? Use the
   CSV driver, don't bother transforming it yourself. Transform to JSON or YAML
   with another gem. Drivers can be independently installed, used and swapped.

data/Rakefile

@@ -106,4 +106,42 @@ task :docview => [:rerdoc] do
   sh "open rdoc/index.html"
 end
 
+namespace :perf do
+  namespace :profile do
+    task :prep => [:install]
+
+    task :prepared_insert => [:prep] do
+      sh "ruby -I lib perf/profile.rb prepared_insert"
+    end
+
+    task :insert => [:prep] do
+      sh "ruby -I lib perf/profile.rb insert"
+    end
+    
+    task :raw_select => [:prep] do
+      sh "ruby -I lib perf/profile.rb raw_select"
+    end
+    
+    task :res_select => [:prep] do
+      sh "ruby -I lib perf/profile.rb res_select"
+    end
+    
+    task :single_fetch => [:prep] do
+      sh "ruby -I lib perf/profile.rb single_fetch"
+    end
+    
+    task :unprepared_raw_select => [:prep] do
+      sh "ruby -I lib perf/profile.rb unprepared_raw_select"
+    end
+    
+    task :unprepared_res_select => [:prep] do
+      sh "ruby -I lib perf/profile.rb unprepared_res_select"
+    end
+    
+    task :unprepared_single_fetch => [:prep] do
+      sh "ruby -I lib perf/profile.rb unprepared_single_fetch"
+    end
+  end
+end
+
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.1

data/lib/rdbi.rb

@@ -1,20 +1,11 @@
 require 'epoxy'
-require 'methlab'
-require 'thread'
 
 module RDBI
   class << self
-    extend MethLab
-
-    # Every database handle allocated throughout the lifetime of the
-    # program. This functionality is subject to change and may be pruned
-    # during disconnection.
-    attr_reader :all_connections
-
     #
     # The last database handle allocated. This may come from pooled connections or regular ones.
     #
-    attr_threaded_accessor :last_dbh
+    attr_accessor :last_dbh
   end
 
   #
@@ -38,23 +29,20 @@ module RDBI
     driver = klass.new(*args)
     dbh = self.last_dbh = driver.new_handle
 
-    @all_connections ||= []
-    @all_connections.push(dbh)
-
     yield dbh if block_given?
     return dbh
   end
 
   #
   # connect_cached() works similarly to connect, but yields a database handle
-  # copied from a RDBI::Pool. The 'default' pool is the ... default, but this
-  # may be manipulated by providing :pool_name to the connection arguments.
+  # copied from an RDBI::Pool. The 'default' pool is the ... default, but this
+  # may be manipulated by setting :pool_name in the connection arguments.
   #
   # If a pool does not exist already, it will be created and a database
-  # handle instanced from your connection arguments.
+  # handle instantiated using your connection arguments.
   #
   # If a pool *already* exists, your connection arguments will be ignored and
-  # it will instance from the Pool's connection arguments.
+  # it will instantiate from the Pool's connection arguments.
   def self.connect_cached(klass, *args)
     args = args[0]
     pool_name = args[:pool_name] || :default
@@ -74,7 +62,7 @@ module RDBI
   end
 
   #
-  # Retrieves a RDBI::Pool. See RDBI::Pool.[].
+  # Retrieves an RDBI::Pool. See RDBI::Pool.[].
   def self.pool(pool_name=:default)
     RDBI::Pool[pool_name]
   end
@@ -85,18 +73,6 @@ module RDBI
     connect(klass, *args).ping
   end
 
-  #
-  # Reconnects all known connections. See RDBI.all_connections.
-  def self.reconnect_all
-    @all_connections.each(&:reconnect)
-  end
-
-  #
-  # Disconnects all known connections. See RDBI.all_connections.
-  def self.disconnect_all
-    @all_connections.each(&:disconnect)
-  end
-
   #
   # Base Error class for RDBI. Rescue this to catch all RDBI-specific errors.
   #
@@ -169,14 +145,30 @@ module RDBI::Util
     case row_count
     when :first, :last
       ary = ary[0]
-      return nil if ary.empty?
+      return nil if ary and ary.empty?
       return ary
     else
       return ary
     end
   end
+
+  def self.index_binds(args, index_map)
+    # FIXME exception if mixed hash/indexed binds
+    if args[0].kind_of?(Hash)
+      binds = []
+      args[0].keys.each do |key| 
+        if index = index_map.index(key)
+          binds.insert(index, args[0][key])
+        end
+      end
+      return binds
+    else
+      return args
+    end
+  end
 end
 
+require 'rdbi/types'
 require 'rdbi/pool'
 require 'rdbi/driver'
 require 'rdbi/database'
@@ -184,6 +176,5 @@ require 'rdbi/statement'
 require 'rdbi/schema'
 require 'rdbi/result'
 require 'rdbi/cursor'
-require 'rdbi/types'
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/lib/rdbi/cursor.rb

@@ -17,12 +17,17 @@ class RDBI::Cursor
   #
   class NotImplementedError < Exception; end
 
-  extend MethLab
+  #
+  # Exception which indicates that this result is not rewindable.
+  #
+  class NotRewindableError < Exception; end
+
   include Enumerable
 
   # underlying handle.
   
   attr_reader :handle
+  attr_accessor :rewindable_result
 
   # Default constructor. Feel free to override this.
   #

data/lib/rdbi/database.rb

@@ -1,85 +1,70 @@
 #
-# RDBI::Database is the base class for database handles. This is the primary
-# method in which most users will access their database system.
+# RDBI::Database is the base class for database handles.  Most users will
+# access their database system through this class.
 #
 # To execute statements, look at +prepare+ and +execute+.
 #
 # To retrieve schema information, look at +schema+ and +table_schema+.
 #
-# To deal with transactions, +transaction+, +commit+, and +rollback+.
+# To deal with transactions, refer to +transaction+, +commit+, and +rollback+.
 class RDBI::Database
-  extend MethLab
-
   # the driver class that is responsible for creating this database handle.
   attr_accessor :driver
 
   # the name of the database we're connected to, if any.
   attr_accessor :database_name
 
+  # see RDBI::Statement#rewindable_result
+  attr_accessor :rewindable_result
+
   # the arguments used to create the connection.
   attr_reader :connect_args
 
-  ##
-  # :attr_reader: last_statement
-  #
   # the last statement handle allocated. affected by +prepare+ and +execute+.
-  attr_threaded_accessor :last_statement
-
-  ##
-  # :attr: last_query
+  attr_accessor :last_statement
+ 
   # the last query sent, as a string.
-  attr_threaded_accessor :last_query
+  attr_accessor :last_query
 
-  ##
-  # :attr: open_statements
   # all the open statement handles.
-  attr_threaded_accessor :open_statements
+  attr_accessor :open_statements
 
-  ##
-  # :attr: in_transaction
-  # are we currently in a transaction?
-  
-  ##
-  # :attr: in_transaction?
   # are we currently in a transaction?
-  inline(:in_transaction, :in_transaction?) { @in_transaction > 0 }
+  def in_transaction
+    @in_transaction > 0
+  end
 
-  # the mutex for this database handle.
-  attr_reader :mutex
+  alias in_transaction? in_transaction
 
-  ##
-  # :attr: connected
-  # are we connected to the database?
-  
-  ##
-  # :attr_accessor: connected?
   # are we connected to the database?
-  inline(:connected, :connected?) { @connected }
 
-  ##
-  # :method: ping
+  attr_reader :connected
+  alias connected? connected
+
   # ping the database. yield an integer result on success.
-  inline(:ping) { raise NoMethodError, "this method is not implemented in this driver" }
+  def ping
+    raise NoMethodError, "this method is not implemented in this driver"
+  end
 
-  ##
-  # :method: table_schema
-  # query the schema for a specific table. Returns a RDBI::Schema object.
-  inline(:table_schema) { |*args| raise NoMethodError, "this method is not implemented in this driver" }
+  # query the schema for a specific table. Returns an RDBI::Schema object.
+  def table_schema(table_name)
+    raise NoMethodError, "this method is not implemented in this driver"
+  end
 
-  ##
-  # :method: schema
   # query the schema for the entire database. Returns an array of RDBI::Schema objects.
-  inline(:schema) { |*args| raise NoMethodError, "this method is not implemented in this driver" }
+  def schema
+    raise NoMethodError, "this method is not implemented in this driver"
+  end
 
-  ##
-  # :method: rollback
   # ends the outstanding transaction and rolls the affected rows back.
-  inline(:rollback) { @in_transaction -= 1 unless @in_transaction == 0 }
- 
-  ##
-  # :method: commit
+  def rollback
+    @in_transaction -= 1 unless @in_transaction == 0
+  end
+
   # ends the outstanding transaction and commits the result.
-  inline(:commit)   { @in_transaction -= 1 unless @in_transaction == 0 }
+  def commit
+    @in_transaction -= 1 unless @in_transaction == 0 
+  end
 
   #
   # Create a new database handle. This is typically done by a driver and
@@ -88,11 +73,11 @@ class RDBI::Database
   # args is the connection arguments the user initially supplied to
   # RDBI.connect.
   def initialize(*args)
-    @connect_args   = RDBI::Util.key_hash_as_symbols(args[0])
-    @connected      = true
-    @mutex          = Mutex.new
-    @in_transaction = 0
-    self.open_statements = []
+    @connect_args         = RDBI::Util.key_hash_as_symbols(args[0])
+    @connected            = true
+    @in_transaction       = 0
+    @rewindable_result    = false
+    self.open_statements  = { }
   end
 
   # reconnect to the database. Any outstanding connection will be terminated.
@@ -106,12 +91,9 @@ class RDBI::Database
   # statement handles left open.
   #
   def disconnect
-    unless self.open_statements.empty?
-      warn "[RDBI] Open statements during disconnection -- automatically finishing. You should fix this."
-      self.open_statements.each(&:finish)
-    end
-    self.open_statements = []
     @connected = false
+    self.open_statements.values.each { |x| x.finish if x }
+    self.open_statements = { }
   end
 
   #
@@ -157,7 +139,7 @@ class RDBI::Database
 
   #
   # Prepares a statement for execution. Takes a query as its only argument,
-  # returns a RDBI::Statement.
+  # returns an RDBI::Statement.
   #
   # ex:
   #   sth = dbh.prepare("select * from foo where item = ?")
@@ -172,12 +154,11 @@ class RDBI::Database
   #
   def prepare(query)
     sth = nil
-    mutex.synchronize do
-      self.last_query = query
-      sth = new_statement(query)
-      yield sth if block_given?
-      sth.finish if block_given?
-    end
+
+    self.last_query = query
+    sth = new_statement(query)
+    yield sth if block_given?
+    sth.finish if block_given?
 
     return self.last_statement = sth
   end
@@ -203,23 +184,24 @@ class RDBI::Database
   def execute(query, *binds)
     res = nil
 
-    mutex.synchronize do
-      self.last_query = query
-      self.last_statement = sth = new_statement(query)
-      res = sth.execute(*binds)
-
-      if block_given?
-        yield res
-      else
-        res.coerce_to_array
-      end
+    self.last_query = query
+    self.last_statement = sth = new_statement(query)
+    res = sth.execute(*binds)
 
-      sth.finish
+    if block_given?
+      yield res
     end
 
     return res
   end
 
+  def execute_modification(query, *binds)
+    self.last_statement = sth = new_statement(query)
+    rows = sth.execute_modification(*binds)
+    sth.finish
+    return rows
+  end
+
   #
   # Process the query as your driver would normally, and return the result.
   # Depending on the driver implementation and potentially connection
@@ -241,14 +223,12 @@ class RDBI::Database
   # quoter during bind processing.
   #
   def preprocess_query(query, *binds)
-    mutex.synchronize do
-      self.last_query = query
-    end
-   
+    self.last_query = query
+
     ep = Epoxy.new(query)
 
     hashes = binds.select { |x| x.kind_of?(Hash) }
-    binds.collect! { |x| x.kind_of?(Hash) ? nil : x } 
+    binds.collect! { |x| x.kind_of?(Hash) ? nil : x }
     total_hash = hashes.inject({}) { |x, y| x.merge(y) }
 
     if @preprocess_quoter.respond_to?(:call)

data/lib/rdbi/pool.rb

@@ -109,6 +109,20 @@ class RDBI::Pool
     end
   end
 
+  #
+  # Asserts that all the pooled handles are connected. Returns true or false
+  # depending on the result of that assertion.
+  #
+  def up
+    alive = false
+
+    mutex.synchronize do
+      alive = @handles.select { |x| x.ping.nil? }.empty?
+    end
+
+    return alive
+  end
+
   #
   # Unconditionally reconnect all database handles.
   def reconnect
@@ -216,9 +230,6 @@ class RDBI::Pool
   # Add any ol' database handle. This is not for global consumption.
   #
   def add(dbh)
-    dbh = *MethLab.validate_array_params([RDBI::Database], [dbh])
-    raise dbh if dbh.kind_of?(Exception)
-
     dbh = dbh[0] if dbh.kind_of?(Array)
 
     mutex.synchronize do