amalgalite 0.5.1-x86-mswin32-60 → 0.6.0-x86-mswin32-60

data/lib/amalgalite/version.rb

@@ -8,8 +8,8 @@ module Amalgalite
   module Version
 
     MAJOR   = 0
-    MINOR   = 5
-    BUILD   = 1
+    MINOR   = 6
+    BUILD   = 0
 
     #
     # return the Version as an array of MAJOR, MINOR, BUILD

data/spec/aggregate_spec.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/database'
+
+class AggregateTest1 < ::Amalgalite::Aggregate
+  def initialize
+    @name = 'atest1'
+    @arity = -1
+    @count = 0
+  end
+  def step( *args )
+    @count += 1
+  end
+  def finalize
+    return @count
+  end
+end
+
+
+describe "Aggregate SQL Functions" do
+
+  before(:each) do
+    @schema = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+
+  after(:each) do
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  end
+
+
+  it "must have a finalize method implemented" do
+    ag = ::Amalgalite::Aggregate.new
+    lambda { ag.finalize }.should raise_error( NotImplementedError, /Aggregate#finalize must be implemented/ )
+  end
+
+  it "can define a custom SQL aggregate as a class with N params" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should == r.first['c']
+    r.first['a'].should == 242
+  end
+
+  it "can remove a custom SQL aggregate by class" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should == 1
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should == r.first['c']
+    r.first['a'].should == 242
+    @iso_db.remove_aggregate( "atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should == 0
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove a custom SQL aggregate by arity" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should == 1
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should == r.first['c']
+    r.first['a'].should == 242
+    @iso_db.remove_aggregate( "atest1", -1)
+    @iso_db.aggregates.size.should == 0
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove all custom SQL aggregates with the same name" do
+    class AT2 < AggregateTest1
+      def arity() 1; end
+    end
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.define_aggregate("atest1", AT2)
+    @iso_db.aggregates.size.should == 2
+    r = @iso_db.execute("SELECT atest1(id,name) as a, atest1(id), count(*) as c FROM country")
+    r.first['a'].should == r.first['c']
+    r.first['a'].should == 242
+    @iso_db.remove_aggregate( "atest1" )
+    @iso_db.aggregates.size.should == 0
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+
+
+  it "does not allow mixing of arbitrary and mandatory arguments to an SQL function" do
+    class AggregateTest2 < AggregateTest1
+      def name() "atest2"; end
+      def arity() -2; end
+    end
+    lambda { @iso_db.define_aggregate("atest2", AggregateTest2 ) }.should raise_error( ::Amalgalite::Database::AggregateError, 
+                                                    /Use only mandatory or arbitrary parameters in an SQL Aggregate, not both/ )
+  end
+
+  it "does not allow outrageous arity" do
+    class AggregateTest3 < AggregateTest1
+      def name() "atest3"; end
+      def arity() 101; end
+    end
+    lambda { @iso_db.define_aggregate("atest3", AggregateTest3 ) }.should raise_error( ::Amalgalite::SQLite3::Error, /SQLITE_ERROR .* bad parameters/ )
+  end
+
+  it "does not allow registering a function which does not match the defined name " do
+    class AggregateTest4 < AggregateTest1
+      def name() "name_mismatch"; end
+    end
+    lambda { @iso_db.define_aggregate("atest4", AggregateTest4 ) }.should raise_error( ::Amalgalite::Database::AggregateError,
+                                           /Aggregate implementation name 'name_mismatch' does not match defined name 'atest4'/)
+  end
+
+  it "handles an error being thrown during the step function" do
+    class AggregateTest5 < AggregateTest1
+      def initialize
+        @name = "atest5"
+        @arity = -1
+        @count = 0
+      end
+
+      def step( *args )
+        @count += 1
+        if @count > 50 then
+          raise "Stepwise error!" if @count > 50
+        end
+      end
+
+    end
+
+    @iso_db.define_aggregate( "atest5", AggregateTest5 )
+    lambda { @iso_db.execute( "SELECT atest5(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Stepwise error!/ )
+  end
+
+  it "handles an error being thrown during the finalize function" do
+    class AggregateTest6 < AggregateTest1
+      def initialize
+        @name = "atest6"
+        @count = 0
+        @arity = -1
+      end
+      def finalize
+        raise "Finalize error!"
+      end
+    end
+    @iso_db.define_aggregate( "atest6", AggregateTest6 )
+    lambda { @iso_db.execute( "SELECT atest6(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Finalize error!/ )
+  end
+
+  it "handles an error being thrown during initialization in the C extension" do
+    class AggregateTest7 < AggregateTest1
+      @@instance_count = 0
+      def initialize
+        @name = "atest7"
+        @count = 0
+        @arity = -1
+        if @@instance_count > 0 then
+          raise "Initialization error!"
+        else
+          @@instance_count += 1
+        end
+      end
+    end
+    @iso_db.define_aggregate( "atest7", AggregateTest7 )
+    lambda { @iso_db.execute( "SELECT atest7(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Initialization error!/ )
+  end
+end
+

data/spec/busy_handler.rb

@@ -0,0 +1,164 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/database'
+
+class BusyHandlerTest < Amalgalite::BusyHandler
+  attr_accessor :call_count
+  def initialize( max = 5 )
+    @max = max
+    @call_count = 0
+  end
+
+  def call( c )
+    @call_count += 1
+    if call_count >= @max then
+      return false
+    end
+    return true
+  end
+end
+
+describe "Busy Handlers" do
+  before(:each) do
+    @db_name = SpecInfo.make_iso_db
+    @read_db = Amalgalite::Database.new( @db_name )
+    @write_db = Amalgalite::Database.new( @db_name )
+  end
+
+  after(:each) do
+    @write_db.close
+    @read_db.close
+    File.unlink @db_name if File.exist?( @db_name )
+  end
+
+  it "raises NotImplemented if #call is not overwritten" do
+    bh = ::Amalgalite::BusyHandler.new
+    lambda { bh.call( 42 ) }.should raise_error( ::NotImplementedError, /The busy handler call\(N\) method must be implemented/ )
+  end
+
+  it "can be registered as block" do
+    call_count = 0
+    @write_db.busy_handler do |x|
+      call_count = x
+      if call_count >= 20 then
+        false
+      else
+        true
+      end
+    end
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    call_count.should == 20
+  end
+
+  it "can be registered as lambda" do
+    call_count = 0
+    callable = lambda do |x|
+      call_count = x
+      if call_count >= 40 then
+        false
+      else
+        true
+      end
+    end
+
+    @write_db.busy_handler( callable )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    call_count.should == 40
+  end
+
+  it "can be registered as a class" do
+    h = BusyHandlerTest.new( 10 )
+    @write_db.busy_handler( h )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    h.call_count.should == 10
+  end
+
+  it "has a default timeout class available " do
+    to = ::Amalgalite::BusyTimeout.new( 5, 10 ) 
+    @write_db.busy_handler( to )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    before = Time.now
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    after = Time.now
+    to.call_count.should > 5
+    (after - before).should > 0.05
+  end
+
+  it "cannot register a block with the wrong arity" do
+    lambda do 
+      @write_db.define_busy_handler { |x,y| puts "What!" }
+    end.should raise_error( ::Amalgalite::Database::BusyHandlerError, /A busy handler expects 1 and only 1 argument/ )
+  end
+
+  it "can remove a busy handler" do
+    bht = BusyHandlerTest.new
+
+    @write_db.busy_handler( bht )
+
+    # put a read lock on the database
+    @read_db.transaction( "DEFERRED" )
+
+    # put a read lock on the database, but want to go to an exclusive
+    @write_db.transaction( "IMMEDIATE" )
+
+    # do a read operation
+    @read_db.execute("SELECT count(*) FROM subcountry")
+
+    # attempt to do a write operation and commit it
+    @write_db.execute("DELETE FROM subcountry")
+    @write_db.remove_busy_handler
+    lambda { @write_db.execute("COMMIT"); }.should raise_error( ::Amalgalite::SQLite3::Error, /database is locked/ )
+    bht.call_count.should == 0
+  end
+
+end

data/spec/database_spec.rb

@@ -5,6 +5,7 @@ $: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
 require 'amalgalite'
 require 'amalgalite/taps/io'
 require 'amalgalite/taps/console'
+require 'amalgalite/database'
 
 describe Amalgalite::Database do
   before(:each) do
@@ -110,8 +111,6 @@ describe Amalgalite::Database do
     db.close
   end
 
- 
-
   it "can immediately execute an sql statement " do
     db = Amalgalite::Database.new( SpecInfo.test_db )
     db.execute( "CREATE TABLE t1( x, y, z )" ).should be_empty
@@ -234,5 +233,100 @@ describe Amalgalite::Database do
       @iso_db.execute("SELECT count(1) as cnt FROM country").first['cnt'].should == 242
     end
   end
-end
 
+  describe "#define_function" do
+   it "does not allow mixing of arbitrary and mandatory arguments to an SQL function" do
+      class FunctionTest2 < ::Amalgalite::Function
+        def initialize
+          super( 'ftest2', -2 )
+        end
+        def call( a, *args ); end
+      end
+      lambda { @iso_db.define_function("ftest2", FunctionTest2.new ) }.should raise_error( ::Amalgalite::Database::FunctionError )
+    end
+
+    it "does not allow outrageous arity" do
+      class FunctionTest3 < ::Amalgalite::Function
+        def initialize
+          super( 'ftest3', 101 )
+        end
+        def call( *args) ; end
+      end
+      lambda { @iso_db.define_function("ftest3", FunctionTest3.new ) }.should raise_error( ::Amalgalite::SQLite3::Error )
+    end
+
+ end
+
+  describe "#remove_function" do
+    it "unregisters a single function by name and arity" do
+      @iso_db.define_function( "rtest" ) do
+        "rtest called"
+      end
+      @iso_db.functions.size.should == 1 
+
+      r = @iso_db.execute( "select rtest() AS r" )
+      r.first['r'].should == "rtest called"
+      @iso_db.remove_function("rtest", -1)
+      lambda { @iso_db.execute( "select rtest() as r" )}.should raise_error( ::Amalgalite::SQLite3::Error, /no such function: rtest/ )
+      @iso_db.functions.size.should == 0
+    end
+
+    it "unregisters a function by instances" do
+      class FunctionTest5 < ::Amalgalite::Function
+        def initialize
+          super( 'ftest5', 0)
+        end
+        def call( *args) "ftest5 called"; end
+      end
+      @iso_db.define_function("ftest5", FunctionTest5.new )
+      @iso_db.functions.size.should == 1
+      r = @iso_db.execute( "select ftest5() AS r" )
+      r.first['r'].should == "ftest5 called"
+      @iso_db.remove_function("ftest5", FunctionTest5.new )
+      lambda { @iso_db.execute( "select ftest5() as r" )}.should raise_error( ::Amalgalite::SQLite3::Error, /no such function: ftest5/ )
+      @iso_db.functions.size.should == 0
+    end
+
+    it "unregisters all functions with the same name" do
+      @iso_db.function( "rtest" ) do |x|
+        "rtest #{x} called"
+      end
+
+      @iso_db.function( "rtest" ) do ||
+        "rtest/0 called"
+      end
+
+      @iso_db.functions.size.should == 2
+      r = @iso_db.execute( "select rtest(1) AS r")
+      r.first['r'].should == "rtest 1 called"
+      r = @iso_db.execute( "select rtest() AS r")
+      r.first['r'].should == "rtest/0 called"
+      @iso_db.remove_function( 'rtest' )
+      lambda {  @iso_db.execute( "select rtest(1) AS r") }.should raise_error( ::Amalgalite::SQLite3::Error )
+      lambda {  @iso_db.execute( "select rtest() AS r")  }.should raise_error( ::Amalgalite::SQLite3::Error )
+      @iso_db.functions.size.should == 0
+    end
+  end
+
+  it "can interrupt another thread that is also running in this database" do
+    had_error = nil 
+    executions = 0
+    other = Thread.new( @iso_db ) do |db|
+      loop do
+        begin
+          db.execute("select count(id) from country")
+          executions += 1
+        rescue => e
+          had_error = e
+          break
+        end
+      end
+    end
+    sleep 0.01
+    @iso_db.interrupt!
+    other.join
+    executions.should > 10
+    had_error.should be_an_instance_of( ::Amalgalite::SQLite3::Error )
+    had_error.message.should =~ / interrupted/
+  end
+end