rhubarb 0.2.4 → 0.2.5

data/CHANGES

@@ -1,3 +1,9 @@
+version 0.2.5
+
+*  Prepared statements are now optional to eliminate a strange bug
+   that appears in some environments.  If you experience unusual table
+   locking errors, try running without prepared statements.
+
 version 0.2.4
 
 *  More aggressive use of prepared statements, which should result 

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.2.5

data/lib/rhubarb/classmixins.rb

@@ -49,28 +49,24 @@ module Rhubarb
     alias find_by_id find
 
     def find_by(arg_hash)
+      results = []
       arg_hash = arg_hash.dup
       valid_cols = self.colnames.intersection arg_hash.keys
       select_criteria = valid_cols.map {|col| "#{col.to_s} = #{col.inspect}"}.join(" AND ")
       arg_hash.each {|k,v| arg_hash[k] = v.row_id if v.respond_to? :row_id}
-      find_by_text = "select * from #{table_name} where #{select_criteria} order by row_id"
-      find_by_stmt = (db.stmts[find_by_text] ||= db.prepare(find_by_text))
-      find_by_stmt.execute!(arg_hash).map {|tup| self.new(tup) }
+      db.do_query("select * from #{table_name} where #{select_criteria} order by row_id", arg_hash) {|tup| results << self.new(tup) }
+      results
     end
 
     # Does what it says on the tin.  Since this will allocate an object for each row, it isn't recomended for huge tables.
     def find_all
       results = []
-      find_all_text = "SELECT * from #{table_name}"
-      find_all_stmt = (db.stmts[find_all_text] ||= db.prepare(find_all_text))
-      find_all_stmt.execute! {|tup| results << self.new(tup)}
+      db.do_query("SELECT * from #{table_name}") {|tup| results << self.new(tup)}
       results
     end
 
     def delete_all
-      da_text = "DELETE from #{table_name}"
-      da_stmt = (db.stmts[da_text] ||= db.prepare(da_text))
-      da_stmt.execute!
+      db.do_query("DELETE from #{table_name}")
     end
 
     def delete_where(arg_hash)
@@ -78,9 +74,7 @@ module Rhubarb
       valid_cols = self.colnames.intersection arg_hash.keys
       select_criteria = valid_cols.map {|col| "#{col.to_s} = #{col.inspect}"}.join(" AND ")
       arg_hash.each {|k,v| arg_hash[k] = v.row_id if v.respond_to? :row_id}
-      dw_text = "DELETE FROM #{table_name} WHERE #{select_criteria}"
-      dw_stmt = (db.stmts[dw_text] ||= db.prepare(dw_text))
-      dw_stmt.execute!(arg_hash)
+      db.do_query("DELETE FROM #{table_name} WHERE #{select_criteria}", arg_hash)
     end
 
     # Declares a query method named +name+ and adds it to this class.  The query method returns a list of objects corresponding to the rows returned by executing "+SELECT * FROM+ _table_ +WHERE+ _query_" on the database.
@@ -91,15 +85,16 @@ module Rhubarb
     # Declares a custom query method named +name+, and adds it to this class.  The custom query method returns a list of objects corresponding to the rows returned by executing +query+ on the database.  +query+ should select all fields (with +SELECT *+).  If +query+ includes the string +\_\_TABLE\_\_+, it will be expanded to the table name.  Typically, you will want to use +declare\_query+ instead; this method is most useful for self-joins.
     def declare_custom_query(name, query)
       klass = (class << self; self end)
+      processed_query = query.gsub("__TABLE__", "#{self.table_name}")
+      
       klass.class_eval do
         define_method name.to_s do |*args|
           # handle reference parameters
           args = args.map {|arg| Util::rhubarb_fk_identity(arg)}
-          cq_text = query.gsub("__TABLE__", "#{self.table_name}")
-          cq_stmt = (db.stmts[cq_text] ||= db.prepare(cq_text))
           
-          res = cq_stmt.execute!(args)
-          res.map {|row| self.new(row) }        
+          results = []
+          db.do_query(processed_query, args) {|tup| results << self.new(tup)}
+          results
         end
       end
     end
@@ -136,15 +131,14 @@ module Rhubarb
       klass = (class << self; self end)
       klass.class_eval do 
         define_method find_method_name do |arg|
-          fq_stmt = (self.db.stmts[find_query] ||= db.prepare(find_query))
-          res = fq_stmt.execute!(arg)
-          res.map {|row| self.new(row)}
+          results = []
+          db.do_query(find_query, arg) {|row| results << self.new(row)}
+          results
         end
 
         define_method find_first_method_name do |arg|
-          fq_stmt = (self.db.stmts[find_query] ||= db.prepare(find_query))
           result = nil
-          fq_stmt.execute!(arg) {|row| result = self.new(row) ; break }
+          db.do_query(find_query, arg) {|row| result = self.new(row) ; break }
           result
         end
       end
@@ -235,8 +229,8 @@ module Rhubarb
       end
 
       create_text = "insert into #{table_name} (#{colspec}) values (#{valspec})"
-      create_stmt = (self.db.stmts[create_text] ||= db.prepare(create_text))
-      create_stmt.execute!(new_row)
+      db.do_query(create_text, new_row)
+      
       res = find(db.last_insert_row_id)
       
       res
@@ -297,8 +291,9 @@ module Rhubarb
 
     def find_tuple(tid)
       ft_text = "select * from #{table_name} where row_id = ?"
-      ft_stmt = (self.db.stmts[ft_text] ||= db.prepare(ft_text))
-      return ft_stmt.execute!(tid)[0]
+      result = nil
+      db.do_query(ft_text, tid) {|tup| result = tup; break}
+      result
     end
     
     include FindFreshest

data/lib/rhubarb/persistence.rb

@@ -10,10 +10,29 @@
 # 
 #     http://www.apache.org/licenses/LICENSE-2.0
 
-module Rhubarb
+module Rhubarb  
+  
   module Persistence
+    module UsePreparedStatements
+      def do_query(stmt, *args, &blk)
+        the_stmt = (self.stmts[stmt] ||= self.prepare(stmt))
+        the_stmt.execute!(args, &blk)
+      end
+    end
+    
+    module EschewPreparedStatements
+      def do_query(stmt, *args, &blk)
+        execute(stmt, args, &blk)
+      end
+    end
+    
     class DbCollection < Hash
       alias orig_set []=
+      attr_accessor :use_prepared_stmts
+      
+      def initialize
+        self.use_prepared_stmts = true
+      end
       
       def []=(key,db)
         setup_db(db) if db
@@ -31,12 +50,23 @@ module Rhubarb
             @rhubarb_stmts
           end
         end
+        
+        if @use_prepared_stmts
+          class << db
+            include UsePreparedStatements
+          end
+        else
+          class << db
+            include EschewPreparedStatements
+          end
+        end
       end
     end
     
     @dbs = DbCollection.new
     
-    def self.open(filename, which=:default)
+    def self.open(filename, which=:default, usePrepared=true)
+      dbs.use_prepared_stmts = usePrepared
       dbs[which] = SQLite3::Database.new(filename)
     end
   

data/lib/rhubarb/persisting.rb

@@ -62,9 +62,7 @@ module Rhubarb
     # Deletes the row corresponding to this object from the database; 
     # invalidates =self= and any other objects backed by this row
     def delete
-      delete_text = "delete from #{self.class.table_name} where row_id = ?"
-      delete_stmt = (self.db.stmts[delete_text] ||= self.db.prepare(delete_text))
-      delete_stmt.execute!(@row_id)
+      db.do_query("delete from #{self.class.table_name} where row_id = ?", @row_id)
       mark_dirty
       @tuple = nil
       @row_id = nil
@@ -121,9 +119,7 @@ module Rhubarb
     def update(attr_name, value)
       mark_dirty
 
-      update_text = "update #{self.class.table_name} set #{attr_name} = ?, updated = ? where row_id = ?"
-      update_stmt = (self.db.stmts[update_text] ||= self.db.prepare(update_text))
-      update_stmt.execute!(value, Util::timestamp, @row_id)
+      db.do_query("update #{self.class.table_name} set #{attr_name} = ?, updated = ? where row_id = ?", value, Util::timestamp, @row_id)
     end
 
     # Resolve any fields that reference other tables, replacing row ids with referred objects

data/ruby-rhubarb.spec.in

@@ -48,11 +48,17 @@ rm -rf %{buildroot}
 %{ruby_sitelib}/rhubarb/persistence.rb
 
 %changelog
+* Wed Apr 14 2010 willb <willb@redhat> - 0.2.5-1.0
+- Updated to version 0.2.5
+
+* Wed Apr 7 2010 willb <willb@redhat> - 0.2.4-1.0
+- Updated to version 0.2.4
+
 * Thu Feb 25 2010 willb <willb@redhat> - 0.2.3-1.0
-* updated to version 0.2.3 from source
+- updated to version 0.2.3 from source
 
 * Thu Feb 25 2010 willb <willb@redhat> - 0.2.2-2.0
-* removed rubygems include 
+- removed rubygems include 
 
 * Fri Feb  5 2010  <rrat@redhat> - 0.2.0-0.3
 - Explicitly list files

data/test/test_rhubarb.rb

@@ -12,6 +12,7 @@
 #     http://www.apache.org/licenses/LICENSE-2.0
 
 require 'helper'
+require 'fileutils'
 
 class TestClass 
   include Rhubarb::Persisting  
@@ -92,9 +93,21 @@ class BlobTestTable
   declare_column :info, :blob
 end
 
-class BackendBasicTests < Test::Unit::TestCase
+class PreparedStmtBackendTests < Test::Unit::TestCase  
+  def dbfile
+    ENV['RHUBARB_TEST_DB'] || ":memory:"
+  end
+  
+  def use_prepared
+    true
+  end
+
   def setup
-    Rhubarb::Persistence::open(":memory:")
+    unless dbfile == ":memory:"
+      FileUtils::safe_unlink(dbfile)
+    end
+
+    Rhubarb::Persistence::open(dbfile, :default, use_prepared)
     klasses = []
     klasses << TestClass
     klasses << TestClass2
@@ -216,6 +229,13 @@ class BackendBasicTests < Test::Unit::TestCase
     end
   end
 
+  def test_delete_all
+    freshness_query_fixture
+    assert(FreshTestTable.find_all.size > 0)
+    FreshTestTable.delete_all
+    assert_equal([], FreshTestTable.find_all)
+  end
+
   def test_class_methods
     ["foo", "bar"].each do |prefix|
       ["find_by_#{prefix}", "find_first_by_#{prefix}"].each do |m|
@@ -711,3 +731,9 @@ class BackendBasicTests < Test::Unit::TestCase
   end
 
 end
+
+class NoPreparedStmtBackendTests < PreparedStmtBackendTests  
+  def use_prepared
+    false
+  end
+end

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rhubarb
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 4
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - William Benton
@@ -14,37 +9,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -05:00
+date: 2010-04-20 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 2
-        - 9
         version: 1.2.9
-  type: :development
-  version_requirements: *id001
+    version: 
 - !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 2
-        - 2
         version: 1.2.2
-  type: :runtime
-  version_requirements: *id002
+    version: 
 description: Rhubarb is a simple object-graph persistence library implemented as a mixin.  It also works with the SPQR library for straightforward object publishing over QMF.
 email: willb@redhat.com
 executables: []
@@ -88,20 +75,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: "Rhubarb:  object graph persistence, easy as pie"