sqlite3 1.5.0.rc1-x86_64-darwin

data/test/test_integration_aggregate.rb

@@ -0,0 +1,336 @@
+require 'helper'
+
+class TC_Integration_Aggregate < SQLite3::TestCase
+  def setup
+    @db = SQLite3::Database.new(":memory:")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text, c integer )"
+      @db.execute "insert into foo ( b, c ) values ( 'foo', 10 )"
+      @db.execute "insert into foo ( b, c ) values ( 'bar', 11 )"
+      @db.execute "insert into foo ( b, c ) values ( 'bar', 12 )"
+    end
+  end
+
+  def teardown
+    @db.close
+  end
+
+  def test_create_aggregate_without_block
+    step = proc do |ctx,a|
+      ctx[:sum] ||= 0
+      ctx[:sum] += a.to_i
+    end
+
+    final = proc { |ctx| ctx.result = ctx[:sum] }
+
+    @db.create_aggregate( "accumulate", 1, step, final )
+
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
+
+    # calling #get_first_value twice don't add up to the latest result
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
+  end
+
+  def test_create_aggregate_with_block
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    value = @db.get_first_value( "select accumulate(a) from foo" )
+    assert_equal 6, value
+  end
+
+  def test_create_aggregate_with_group_by
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    values = @db.execute( "select b, accumulate(c) from foo group by b order by b" )
+    assert_equal "bar", values[0][0]
+    assert_equal 23, values[0][1]
+    assert_equal "foo", values[1][0]
+    assert_equal 10, values[1][1]
+  end
+
+  def test_create_aggregate_with_the_same_function_twice_in_a_query
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    values = @db.get_first_row( "select accumulate(a), accumulate(c) from foo" )
+    assert_equal 6, values[0]
+    assert_equal 33, values[1]
+  end
+
+  def test_create_aggregate_with_two_different_functions
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    @db.create_aggregate( "multiply", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 1
+        ctx[:sum] *= a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    GC.start
+    
+    values = @db.get_first_row( "select accumulate(a), multiply(c) from foo" )
+    assert_equal 6, values[0]
+    assert_equal 1320, values[1]
+
+    value = @db.get_first_value( "select accumulate(c) from foo")
+    assert_equal 33, value
+
+    value = @db.get_first_value( "select multiply(a) from foo")
+    assert_equal 6, value
+  end
+
+  def test_create_aggregate_overwrite_function
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    value = @db.get_first_value( "select accumulate(c) from foo")
+    assert_equal 33, value
+
+    GC.start
+
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 1
+        ctx[:sum] *= a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    value = @db.get_first_value( "select accumulate(c) from foo")
+    assert_equal 1320, value
+  end
+
+  def test_create_aggregate_overwrite_function_with_different_arity
+    @db.create_aggregate( "accumulate", -1 ) do
+      step do |ctx,*args|
+        ctx[:sum] ||= 0
+        args.each { |a| ctx[:sum] += a.to_i }
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    @db.create_aggregate( "accumulate", 2 ) do
+      step do |ctx,a,b|
+        ctx[:sum] ||= 1
+        ctx[:sum] *= (a.to_i + b.to_i)
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] }
+    end
+
+    GC.start
+
+    values = @db.get_first_row( "select accumulate(c), accumulate(a,c) from foo")
+    assert_equal 33, values[0]
+    assert_equal 2145, values[1]
+  end
+
+  def test_create_aggregate_with_invalid_arity
+    assert_raise ArgumentError do
+      @db.create_aggregate( "accumulate", 1000 ) do
+        step {|ctx,*args| }
+        finalize { |ctx| }
+      end
+    end
+  end
+
+  class CustomException < Exception
+  end
+
+  def test_create_aggregate_with_exception_in_step
+    @db.create_aggregate( "raiseexception", 1 ) do
+      step do |ctx,a|
+        raise CustomException.new( "bogus aggregate handler" )
+      end
+
+      finalize { |ctx| ctx.result = 42 }
+    end
+
+    assert_raise CustomException do
+      @db.get_first_value( "select raiseexception(a) from foo")
+    end
+  end
+
+  def test_create_aggregate_with_exception_in_finalize
+    @db.create_aggregate( "raiseexception", 1 ) do
+      step do |ctx,a|
+        raise CustomException.new( "bogus aggregate handler" )
+      end
+
+      finalize do |ctx|
+        raise CustomException.new( "bogus aggregate handler" )
+      end
+    end
+
+    assert_raise CustomException do
+      @db.get_first_value( "select raiseexception(a) from foo")
+    end
+  end
+
+  def test_create_aggregate_with_no_data
+    @db.create_aggregate( "accumulate", 1 ) do
+      step do |ctx,a|
+        ctx[:sum] ||= 0
+        ctx[:sum] += a.to_i
+      end
+
+      finalize { |ctx| ctx.result = ctx[:sum] || 0 }
+    end
+
+    value = @db.get_first_value(
+      "select accumulate(a) from foo where a = 100" )
+    assert_equal 0, value
+  end
+
+  class AggregateHandler
+    class << self
+      def arity; 1; end
+      def text_rep; SQLite3::Constants::TextRep::ANY; end
+      def name; "multiply"; end
+    end
+    def step(ctx, a)
+      ctx[:buffer] ||= 1
+      ctx[:buffer] *= a.to_i
+    end
+    def finalize(ctx); ctx.result = ctx[:buffer]; end
+  end
+
+  def test_aggregate_initialized_twice
+    initialized = 0
+    handler = Class.new(AggregateHandler) do
+      define_method(:initialize) do
+        initialized += 1
+        super()
+      end
+    end
+
+    @db.create_aggregate_handler handler
+    @db.get_first_value( "select multiply(a) from foo" )
+    @db.get_first_value( "select multiply(a) from foo" )
+    assert_equal 2, initialized
+  end
+
+  def test_create_aggregate_handler_call_with_wrong_arity
+    @db.create_aggregate_handler AggregateHandler
+
+    assert_raise(SQLite3::SQLException) do
+     @db.get_first_value( "select multiply(a,c) from foo" )
+   end
+  end
+
+  class RaiseExceptionStepAggregateHandler
+    class << self
+      def arity; 1; end
+      def text_rep; SQLite3::Constants::TextRep::ANY; end
+      def name; "raiseexception"; end
+    end
+    def step(ctx, a)
+      raise CustomException.new( "bogus aggregate handler" )
+    end
+    def finalize(ctx); ctx.result = nil; end
+  end
+
+  def test_create_aggregate_handler_with_exception_step
+    @db.create_aggregate_handler RaiseExceptionStepAggregateHandler
+    assert_raise CustomException do
+      @db.get_first_value( "select raiseexception(a) from foo")
+    end
+  end
+
+  class RaiseExceptionNewAggregateHandler
+    class << self
+      def name; "raiseexception"; end
+    end
+    def initialize
+      raise CustomException.new( "bogus aggregate handler" )
+    end
+    def step(ctx, a); end
+    def finalize(ctx); ctx.result = nil; end
+  end
+
+  def test_create_aggregate_handler_with_exception_new
+    @db.create_aggregate_handler RaiseExceptionNewAggregateHandler
+    assert_raise CustomException do
+      @db.get_first_value( "select raiseexception(a) from foo")
+    end
+  end
+
+  def test_create_aggregate_handler
+    @db.create_aggregate_handler AggregateHandler
+    value = @db.get_first_value( "select multiply(a) from foo" )
+    assert_equal 6, value
+  end
+
+  class AccumulateAggregator
+    def step(*args)
+      @sum ||= 0
+      args.each { |a| @sum += a.to_i }
+    end
+
+    def finalize
+      @sum
+    end
+  end
+
+  class AccumulateAggregator2
+    def step(a, b)
+      @sum ||= 1
+      @sum *= (a.to_i + b.to_i)
+    end
+
+    def finalize
+      @sum
+    end
+  end
+
+  def test_define_aggregator_with_two_different_arities
+    @db.define_aggregator( "accumulate", AccumulateAggregator.new )
+    @db.define_aggregator( "accumulate", AccumulateAggregator2.new )
+
+    GC.start
+
+    values = @db.get_first_row( "select accumulate(c), accumulate(a,c) from foo")
+    assert_equal 33, values[0]
+    assert_equal 2145, values[1]
+  end
+end

data/test/test_integration_open_close.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TC_OpenClose < SQLite3::TestCase
+  def test_create_close
+    begin
+      db = SQLite3::Database.new( "test-create.db" )
+      assert File.exist?( "test-create.db" )
+      assert_nothing_raised { db.close }
+    ensure
+      File.delete( "test-create.db" ) rescue nil
+    end
+  end
+
+  def test_open_close
+    begin
+      File.open( "test-open.db", "w" ) { |f| }
+      assert File.exist?( "test-open.db" )
+      db = SQLite3::Database.new( "test-open.db" )
+      assert_nothing_raised { db.close }
+    ensure
+      File.delete( "test-open.db" ) rescue nil
+    end
+  end
+
+  def test_bad_open
+    assert_raise( SQLite3::CantOpenException ) do
+      SQLite3::Database.new( "." )
+    end
+  end
+end

data/test/test_integration_pending.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+require 'thread'
+require 'benchmark'
+
+class TC_Integration_Pending < SQLite3::TestCase
+  def setup
+    @db = SQLite3::Database.new("test.db")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+  end
+
+  def teardown
+    @db.close
+    File.delete( "test.db" )
+  end
+
+  def test_busy_handler_outwait
+    skip("not working in 1.9") if RUBY_VERSION >= '1.9'
+
+    busy = Mutex.new
+    busy.lock
+    handler_call_count = 0
+
+    t = Thread.new(busy) do |locker|
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          locker.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+
+    @db.busy_handler do |data,count|
+      handler_call_count += 1
+      busy.unlock
+      true
+    end
+
+    assert_nothing_raised do
+      @db.execute "insert into foo (b) values ( 'from 2' )"
+    end
+
+    t.join
+
+    assert_equal 1, handler_call_count
+  end
+
+  def test_busy_handler_impatient
+    busy = Mutex.new
+    busy.lock
+    handler_call_count = 0
+
+    t = Thread.new do
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          busy.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+    sleep 1
+
+    @db.busy_handler do
+      handler_call_count += 1
+      false
+    end
+
+    assert_raise( SQLite3::BusyException ) do
+      @db.execute "insert into foo (b) values ( 'from 2' )"
+    end
+
+    busy.unlock
+    t.join
+
+    assert_equal 1, handler_call_count
+  end
+
+  def test_busy_timeout
+    @db.busy_timeout 1000
+    busy = Mutex.new
+    busy.lock
+
+    t = Thread.new do
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          busy.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+
+    sleep 1
+    time = Benchmark.measure do
+      assert_raise( SQLite3::BusyException ) do
+        @db.execute "insert into foo (b) values ( 'from 2' )"
+      end
+    end
+
+    busy.unlock
+    t.join
+
+    assert time.real*1000 >= 1000
+  end
+end

data/test/test_integration_resultset.rb

@@ -0,0 +1,142 @@
+require 'helper'
+
+class TC_ResultSet < SQLite3::TestCase
+  def setup
+    @db = SQLite3::Database.new(":memory:")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+    @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" )
+    @result = @stmt.execute
+  end
+
+  def teardown
+    @stmt.close
+    @db.close
+  end
+
+  def test_reset_unused
+    assert_nothing_raised { @result.reset }
+    assert @result.to_a.empty?
+  end
+
+  def test_reset_used
+    @result.to_a
+    assert_nothing_raised { @result.reset }
+    assert @result.to_a.empty?
+  end
+
+  def test_reset_with_bind
+    @result.to_a
+    assert_nothing_raised { @result.reset( 1, 2 ) }
+    assert_equal 2, @result.to_a.length
+  end
+
+  def test_eof_inner
+    @result.reset( 1 )
+    assert !@result.eof?
+  end
+
+  def test_eof_edge
+    @result.reset( 1 )
+    @result.next # to first row
+    @result.next # to end of result set
+    assert @result.eof?
+  end
+
+  def test_next_eof
+    @result.reset( 1 )
+    assert_not_nil @result.next
+    assert_nil @result.next
+  end
+
+  def test_next_no_type_translation_no_hash
+    @result.reset( 1 )
+    assert_equal [ 1, "foo" ], @result.next
+  end
+
+  def test_next_type_translation
+    @result.reset( 1 )
+    assert_equal [ 1, "foo" ], @result.next
+  end
+
+  def test_next_type_translation_with_untyped_column
+    @db.query( "select count(*) from foo" ) do |result|
+      assert_equal [3], result.next
+    end
+  end
+
+  def test_type_translation_with_null_column
+    time = '1974-07-25 14:39:00'
+
+    @db.execute "create table bar ( a integer, b time, c string )"
+    @db.execute "insert into bar (a, b, c) values (NULL, '#{time}', 'hello')"
+    @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')"
+    @db.execute "insert into bar (a, b, c) values (2, '#{time}', NULL)"
+    @db.query( "select * from bar" ) do |result|
+      assert_equal [nil, time, 'hello'], result.next
+      assert_equal [1, nil, 'hello'], result.next
+      assert_equal [2, time, nil], result.next
+    end
+  end
+
+  def test_real_translation
+    @db.execute('create table foo_real(a real)')
+    @db.execute('insert into foo_real values (42)' )
+    @db.query('select a, sum(a), typeof(a), typeof(sum(a)) from foo_real') do |result|
+      result = result.next
+      assert result[0].is_a?(Float)
+      assert result[1].is_a?(Float)
+      assert result[2].is_a?(String)
+      assert result[3].is_a?(String)
+    end
+  end
+
+  def test_next_results_as_hash
+    @db.results_as_hash = true
+    @result.reset( 1 )
+    hash = @result.next
+    assert_equal( { "a" => 1, "b" => "foo" },
+      hash )
+    assert_equal hash[0], 1
+    assert_equal hash[1], "foo"
+  end
+
+  def test_each
+    called = 0
+    @result.reset( 1, 2 )
+    @result.each { |row| called += 1 }
+    assert_equal 2, called
+  end
+
+  def test_enumerable
+    @result.reset( 1, 2 )
+    assert_equal 2, @result.to_a.length
+  end
+
+  def test_types
+    assert_equal [ "integer", "text" ], @result.types
+  end
+
+  def test_columns
+    assert_equal [ "a", "b" ], @result.columns
+  end
+
+  def test_close
+    stmt = @db.prepare( "select * from foo" )
+    result = stmt.execute
+    assert !result.closed?
+    result.close
+    assert result.closed?
+    assert stmt.closed?
+    assert_raise( SQLite3::Exception ) { result.reset }
+    assert_raise( SQLite3::Exception ) { result.next }
+    assert_raise( SQLite3::Exception ) { result.each }
+    assert_raise( SQLite3::Exception ) { result.close }
+    assert_raise( SQLite3::Exception ) { result.types }
+    assert_raise( SQLite3::Exception ) { result.columns }
+  end
+end