sqlite3 1.7.3 → 2.0.0

data/test/test_integration_aggregate.rb

@@ -1,336 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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[@result.columns[0]], 1
-    assert_equal hash[@result.columns[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