rdbi 0.9.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54de058484d15e39b1555c43dd208f2ae7d061ba
+  data.tar.gz: 96fd6fa385652f31d50f12cf04f2ee1b7ad4e03e
+SHA512:
+  metadata.gz: 25751397efafcd45de071d2ed98f5669c4bf59b8070e9d64393ddc84fdd67d0e97aecbe6bc53811839dfc82f224e5dfcadefedacdc926287a10319d8b5ab06f6
+  data.tar.gz: eecff757dba45e463dab45b88fb553625350937c6f4847af0280651f5b128ab4e7b50b842258f22318c2c6e575bf4d4f373c2d7667694f27cde43f3ffe201b22

data/History.txt

@@ -0,0 +1,13 @@
+=== 2013-03-16 / 1.1.0
+* Bump version
+* [deprecation] Statement#prep_finalizer considered harmful
+  Internal API:  driver authors, do not use.  RDBI::Util offers upon_finalize!
+  but this may not be needed as RDBI's own finalizations now will finish()
+  driver sth and result set data objects.
+* [bugfix] issue#33 (memory leak) addressed with new finalization and weakened
+  sth objects held by Result objects.
+* [bugfix] Result no longer finish()es Statement (issue#34)
+
+=== Prehistory / 2011-01-30
+
+* First use of Hoe.

data/Manifest.txt

@@ -0,0 +1,28 @@
+.gemtest
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+docs/external-api.pdf
+docs/external-api.texi
+lib/rdbi.rb
+lib/rdbi/cursor.rb
+lib/rdbi/database.rb
+lib/rdbi/driver.rb
+lib/rdbi/pool.rb
+lib/rdbi/result.rb
+lib/rdbi/schema.rb
+lib/rdbi/statement.rb
+lib/rdbi/types.rb
+perf/bench.rb
+perf/profile.rb
+rdbi.gemspec
+test/helper.rb
+test/test_database.rb
+test/test_pool.rb
+test/test_rdbi.rb
+test/test_result.rb
+test/test_statement.rb
+test/test_types.rb
+test/test_util.rb

data/{README.rdoc → README.txt}

@@ -44,22 +44,22 @@ path down the rabbit hole:
   dbh = RDBI.connect(:SQLite3, :database => ":memory:")
 
   # execute this CREATE TABLE statement:
-  dbh.execute("create table foo (bar integer, baz varchar)")
+  dbh.execute("create table tbl (string varchar(32), number integer)")
 
   # prepare an insert statement for execution with two placeholders:
-  dbh.prepare("insert into foo (bar, baz) values (?, ?)") do |sth|
+  dbh.prepare("insert into tbl (string, number) values (?, ?)") do |sth|
 
-    # and execute it with bound variables:
-    sth.execute(1, "foo")
-    sth.execute(2, "bar")
-    sth.execute(3, "quux")
+    # and execute it three times with bound variables:
+    sth.execute("foo", -37)
+    sth.execute("bar", 127)
+    sth.execute("quux", 1024)
   end
 
   # get a result handle from a select statement:
-  result = dbh.execute("select * from foo")
+  result = dbh.execute("select * from tbl")
 
   # and fetch the first row
-  result.fetch(:first) # [1, "foo"]
+  result.fetch(:first) # ["foo", -37]
 
 == What +is+ RDBI all about, anyway?
 
@@ -154,7 +154,7 @@ Aaaaaand here are some things RDBI won't do:
 == Show me even more awesome!
 
   # retrieve cached handles 5 times -- handles will be yielded twice if there
-  # is a smaller Pool size: 
+  # is a smaller Pool size:
   5.times do
     RDBI.connect_cached(:SQLite3, :database => ":memory:")
   end

data/Rakefile

@@ -1,147 +1,53 @@
-require 'rubygems'
-require 'rake'
-
-version = (File.exist?('VERSION') ? File.read('VERSION') : "").chomp
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "rdbi"
-    gem.summary = %Q{RDBI provides sane query-level database access with low magic.}
-    gem.description = %Q{RDBI is a rearchitecture of the Ruby/DBI project by its maintainer and others. It intends to fully supplant Ruby/DBI in the future for similar database access needs.}
-    gem.email = "erik@hollensbe.org"
-    gem.homepage = "http://github.com/RDBI/rdbi"
-    gem.authors = ["Erik Hollensbe"]
-
-    gem.add_development_dependency 'rdbi-driver-mock'
-    gem.add_development_dependency 'test-unit'
-    gem.add_development_dependency 'rdoc'
-    ## for now, install hanna from here: http://github.com/erikh/hanna
-    #gem.add_development_dependency 'hanna'
-    gem.add_development_dependency 'fastercsv'
+# -*- ruby -*-
 
-    gem.add_dependency 'methlab', '>= 0.0.9'
-    gem.add_dependency 'epoxy', '>= 0.3.1'
-    gem.add_dependency 'typelib'
-
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-begin
-  gem 'test-unit'
-  require 'rake/testtask'
-  Rake::TestTask.new(:test) do |test|
-    test.libs << 'lib' << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :test do
-    abort "test-unit gem is not available. In order to run test-unit, you must: sudo gem install test-unit"
-  end
-end
+require 'rubygems'
+require 'hoe'
 
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :git
+Hoe.plugin :rcov
+Hoe.plugin :roodi
+Hoe.plugin :reek
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
+spec = Hoe.spec 'rdbi' do
+  developer 'Erik Hollensbe', 'erik@hollensbe.org'
 
-task :test => :check_dependencies
+  self.rubyforge_name = nil
 
-begin
-  require 'roodi'
-  require 'roodi_task'
-  RoodiTask.new do |t|
-    t.verbose = false
-  end
-rescue LoadError
-  task :roodi do
-    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
-  end
-end
+  self.description = <<-EOF
+  RDBI is a database interface built out of small parts. A micro framework for
+  databases, RDBI works with and extends libraries like 'typelib' and 'epoxy'
+  to provide type conversion and binding facilities. Via a driver/adapter
+  system it provides database access. RDBI itself provides pooling and other
+  enhanced database features.
+  EOF
 
-task :default => :test
+  self.summary = 'RDBI is a database interface built out of small parts.'
+  self.urls = %w[http://github.com/rdbi/rdbi]
 
-begin
-  require 'hanna'
-  require 'rdoc/task'
-  RDoc::Task.new do |rdoc|
-    version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  require_ruby_version ">= 1.8.7"
 
-    rdoc.options.push '-f', 'hanna'
-    rdoc.main = 'README.rdoc'
-    rdoc.rdoc_dir = 'rdoc'
-    rdoc.title = "RDBI #{version} Documentation"
-    rdoc.rdoc_files.include('README*')
-    rdoc.rdoc_files.include('lib/**/*.rb')
-  end
-rescue LoadError => e
-  rdoc_missing = lambda do
-    abort "What, were you born in a barn? Install rdoc and hanna at http://github.com/raggi/hanna ."
-  end
-  task :rdoc, &rdoc_missing
-  task :clobber_rdoc, &rdoc_missing
-end
+  extra_dev_deps << ['rdbi-driver-mock']
+  extra_dev_deps << ['test-unit']
+  extra_dev_deps << ['rdoc']
+  extra_dev_deps << ['hanna-nouveau']
+  extra_dev_deps << ['fastercsv']
+  extra_dev_deps << ['hoe-roodi']
+  extra_dev_deps << ['hoe-reek']
+  extra_dev_deps << ['minitest']
 
-task :to_blog => [:clobber_rdoc, :rdoc] do
-  sh "rm -fr $git/blog/content/docs/rdbi && mv doc $git/blog/content/docs/rdbi"
-end
+  extra_deps << ['epoxy', '>= 0.3.1']
+  extra_deps << ['typelib']
 
-task :install => [:test, :build]
+  # waiting on a patch from hoe for this
+  #self.extra_rdoc_args = lambda do |rd|
+    #rd.generator = "hanna"
+  #end
 
-task :docview => [:rerdoc] do
-  sh "open rdoc/index.html"
+  desc "install a gem without sudo"
 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
+task :install => [:gem] do
+  sh "gem install pkg/#{spec.name}-#{spec.version}.gem"
 end
-
-# vim: syntax=ruby ts=2 et sw=2 sts=2
+# vim: syntax=ruby

data/lib/rdbi.rb

@@ -1,6 +1,9 @@
 require 'epoxy'
 
 module RDBI
+
+  VERSION = '1.1.0'
+
   class << self
     #
     # The last database handle allocated. This may come from pooled connections or regular ones.
@@ -21,7 +24,8 @@ module RDBI
   #
   # connect() returns an instance of RDBI::Database. In the instance a block
   # is provided, it will be called upon connection success, with the
-  # RDBI::Database object provided in as the first argument.
+  # RDBI::Database object provided in as the first argument, and the
+  # connection will be automatically disconnected at the end of the block.
   def self.connect(klass, *args)
 
     klass = RDBI::Util.class_from_class_or_symbol(klass, self::Driver)
@@ -29,8 +33,13 @@ module RDBI
     driver = klass.new(*args)
     dbh = self.last_dbh = driver.new_handle
 
-    yield dbh if block_given?
-    return dbh
+    return dbh unless block_given?
+
+    begin
+        yield dbh
+    ensure
+        dbh.disconnect rescue nil
+    end
   end
 
   #
@@ -43,14 +52,17 @@ module RDBI
   #
   # If a pool *already* exists, your connection arguments will be ignored and
   # it will instantiate from the Pool's connection arguments.
+  #
+  # If a block is provided, the connection is *not* disconnected at the end
+  # of the block.
   def self.connect_cached(klass, *args)
     args = args[0]
     pool_name = args[:pool_name] || :default
 
     dbh = nil
 
-    if RDBI::Pool[pool_name]
-      dbh = RDBI::Pool[pool_name].get_dbh
+    if pool = RDBI::Pool[pool_name]
+      dbh = pool.get_dbh
     else
       dbh = RDBI::Pool.new(pool_name, [klass, args]).get_dbh
     end
@@ -134,39 +146,39 @@ module RDBI::Util
     Marshal.load(Marshal.dump(obj))
   end
 
-  #
-  # Takes an array and appropriate boxes/deboxes it based on what was
-  # requested.
-  #
-  #--
-  # FIXME this is a really poorly performing way of doing this.
-  #++
-  def self.format_results(row_count, ary)
-    case row_count
-    when :first, :last
-      ary = ary[0]
-      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)
+    
+    if args.empty? or !args.find { |x| x.kind_of?(Hash) }
+      return args
+    end
+
+    if args.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
+      hash = args
     else
-      return args
+      hashes, binds = args.partition { |x| x.kind_of?(Hash) }
+      hash = hashes.inject({ }, :merge)
+    end
+
+    hash.each do |key, value| 
+      # XXX yes, we want to *assign* here.
+      if index = index_map.index(key)
+        binds.insert(index, value)
+      end
     end
+    return binds
   end
-end
+
+  def self.upon_finalize!(what, o, meth, *args)
+    ObjectSpace.define_finalizer(what, make_fini_proc(o, meth, *args))
+  end
+
+  def self.make_fini_proc(obj, meth, *args)
+    proc { |object_id| obj.__send__(meth.to_sym, *args) rescue nil }
+  end
+
+end # -- module RDBI::Util
 
 require 'rdbi/types'
 require 'rdbi/pool'

data/lib/rdbi/database.rb

@@ -22,7 +22,7 @@ class RDBI::Database
 
   # the last statement handle allocated. affected by +prepare+ and +execute+.
   attr_accessor :last_statement
- 
+
   # the last query sent, as a string.
   attr_accessor :last_query
 
@@ -77,6 +77,7 @@ class RDBI::Database
     @connected            = true
     @in_transaction       = 0
     @rewindable_result    = false
+    @preprocess_quoter    = nil
     self.open_statements  = { }
   end
 
@@ -92,6 +93,7 @@ class RDBI::Database
   #
   def disconnect
     @connected = false
+    # FIXME - this is not serving a useful purpose nor public API
     self.open_statements.values.each { |x| x.finish if x }
     self.open_statements = { }
   end
@@ -153,53 +155,85 @@ class RDBI::Database
   #   end
   #
   def prepare(query)
-    sth = nil
+    sth = new_statement(query)
 
     self.last_query = query
-    sth = new_statement(query)
-    yield sth if block_given?
-    sth.finish if block_given?
+    self.open_statements[sth.object_id] = self.last_statement = ::WeakRef.new(sth)
+
+    return sth unless block_given?
 
-    return self.last_statement = sth
+    begin
+      yield sth
+    ensure
+      sth.finish rescue nil
+    end
   end
 
   #
-  # Prepares and executes a statement. Takes a string query and an optional
+  # Prepares and executes a statement.  Takes a string query and an optional
   # number of variable type binds.
   #
   # ex:
   #   res = dbh.execute("select * from foo where item = ?", "an item")
   #   ary = res.to_a
   #
-  # You can also use a block form which will finish the statement and yield the
-  # result handle:
+  # If invoked with a block, the result handle will be yielded and the handle
+  # and statement will be finished at the end of the block.  Use this form
+  # when the result handle is not needed outside the block:
+  #
   #   dbh.execute("select * from foo where item = ?", "an item") do |res|
   #     res.as(:Struct).fetch(:all).each do |struct|
   #       p struct.item
   #     end
   #   end
   #
-  # Which will be considerably more performant under some database drivers.
+  # Block invocation may be considerably more efficient under some database
+  # drivers.
+  #
+  # For DDL and other statements which return no rows, see
+  # #execute_modification.
   #
   def execute(query, *binds)
     res = nil
 
-    self.last_query = query
-    self.last_statement = sth = new_statement(query)
-    res = sth.execute(*binds)
+    sth = prepare(query)
+    begin
+      res = sth.execute(*binds)
+    rescue Exception => e
+      sth.finish rescue nil
+      raise e
+    end
 
-    if block_given?
-      yield res
+    unless block_given?
+      RDBI::Util.upon_finalize!(res, sth, :finish)
+      return res
     end
 
-    return res
+    begin
+      yield res
+    ensure
+      res.finish rescue nil
+      sth.finish rescue nil
+    end
   end
 
+  #
+  # Prepare, execute and finish a statement, returning the number of rows
+  # affected (number of rows INSERTed, DELETEd, etc.).
+  #
+  # Effectively equivalent to
+  #
+  #   dbh.execute(sql_stmt) do |res|
+  #     res.affected_count
+  #   end
+  #
+  # but likely more efficient.  See also RDBI::Statement#execute_modification
+  #
   def execute_modification(query, *binds)
-    self.last_statement = sth = new_statement(query)
-    rows = sth.execute_modification(*binds)
-    sth.finish
-    return rows
+    sth = prepare(query)
+    sth.execute_modification(*binds)
+  ensure
+    sth.finish rescue nil
   end
 
   #
@@ -237,6 +271,13 @@ class RDBI::Database
       ep.quote(total_hash) { |x| %Q{'#{(total_hash[x] || binds[x]).to_s.gsub(/'/, "''")}'} }
     end
   end
+
+  #
+  # Quote a single item using a consistent quoting method.
+  #
+  def quote(item)
+    "\'#{item.to_s}\'"
+  end
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2