sqlite3-ruby 1.1.0 → 1.2.0

data/ext/sqlite3_api/win32/build.bat

@@ -0,0 +1,7 @@
+REM This is not guaranteed to work, ever. It's just a little helper
+REM script that I threw together to help me build the win32 version of
+REM the library. If someone with more win32-fu than I wants to make
+REM something more robust, please feel free! I'd love to include it.
+REM -- Jamis Buck
+
+cl /LD /Ie:\WinSDK\Include /Ic:\ruby\lib\ruby\1.8\i386-mswin32 /Ic:\ruby\sqlite3\src /Ic:\ruby\src\ruby-1.8.4_2006-04-14 sqlite3_api_wrap.c /link /LIBPATH:c:\ruby\sqlite3 /LIBPATH:e:\WinSDK\Lib /LIBPATH:c:\ruby\lib sqlite3.lib msvcrt-ruby18.lib

data/lib/sqlite3/database.rb

@@ -109,12 +109,13 @@ module SQLite3
       @statement_factory = options[:statement_factory] || Statement
 
       result, @handle = @driver.open( file_name, utf16 )
-      Error.check( result, nil, "could not open database" )
+      Error.check( result, self, "could not open database" )
 
       @closed = false
       @results_as_hash = options.fetch(:results_as_hash,false)
       @type_translation = options.fetch(:type_translation,false)
       @translator = nil
+      @transaction_active = false
     end
 
     # Return +true+ if the string is a valid (ie, parsable) SQL statement, and
@@ -436,7 +437,7 @@ module SQLite3
     # begin
       if block
         proxy = AggregateDefinitionProxy.new
-        proxy.instance_eval &block
+        proxy.instance_eval(&block)
         step ||= proxy.step_callback
         finalize ||= proxy.finalize_callback
       end
@@ -591,7 +592,7 @@ module SQLite3
         abort = false
         begin
           yield self
-        rescue Exception
+        rescue ::Object
           abort = true
           raise
         ensure

data/lib/sqlite3/driver/dl/driver.rb

@@ -32,6 +32,10 @@
 
 require 'sqlite3/driver/dl/api'
 
+warn "The DL driver for sqlite3-ruby is deprecated and will be removed"
+warn "in a future release. Please update your installation to use the"
+warn "Native driver."
+
 module Kernel
   # Allows arbitrary objects to be passed as a pointer to functions.
   # (Probably not very GC safe, but by encapsulating it like this we

data/lib/sqlite3/driver/native/driver.rb

@@ -38,6 +38,9 @@ module SQLite3 ; module Driver ; module Native
 
     def initialize
       @callback_data = Hash.new
+      @authorizer = Hash.new
+      @busy_handler = Hash.new
+      @trace = Hash.new
     end
 
     def complete?( sql, utf16=false )
@@ -49,10 +52,18 @@ module SQLite3 ; module Driver ; module Native
         cb = API::CallbackData.new
         cb.proc = block
         cb.data = data
+        result = API.sqlite3_busy_handler( db, API::Sqlite3_ruby_busy_handler, cb )
+        # Reference the Callback object so that 
+        # it is not deleted by the GC
+        @busy_handler[db] = cb
+      else
+        # Unreference the callback *after* having removed it
+        # from sqlite
+        result = API.sqlite3_busy_handler( db, nil, nil )
+        @busy_handler.delete(db)
       end
 
-      API.sqlite3_busy_handler( db,
-        block ? API::Sqlite3_ruby_busy_handler : nil, cb )
+      result
     end
 
     def set_authorizer( db, data=nil, &block )
@@ -60,10 +71,14 @@ module SQLite3 ; module Driver ; module Native
         cb = API::CallbackData.new
         cb.proc = block
         cb.data = data
+        result = API.sqlite3_set_authorizer( db, API::Sqlite3_ruby_authorizer, cb )
+        @authorizer[db] = cb # see comments in busy_handler
+      else
+        result = API.sqlite3_set_authorizer( db, nil, nil )
+        @authorizer.delete(db) # see comments in busy_handler
       end
 
-      API.sqlite3_set_authorizer( db,
-        block ? API::Sqlite3_ruby_authorizer : nil, cb )
+      result
     end
 
     def trace( db, data=nil, &block )
@@ -71,10 +86,14 @@ module SQLite3 ; module Driver ; module Native
         cb = API::CallbackData.new
         cb.proc = block
         cb.data = data
+        result = API.sqlite3_trace( db, API::Sqlite3_ruby_trace, cb )
+        @trace[db] = cb # see comments in busy_handler
+      else
+        result = API.sqlite3_trace( db, nil, nil )
+        @trace.delete(db) # see comments in busy_handler
       end
 
-      API.sqlite3_trace( db,
-        block ? API::Sqlite3_ruby_trace : nil, cb )
+      result
     end
 
     def open( filename, utf16=false )
@@ -116,9 +135,6 @@ module SQLite3 ; module Driver ; module Native
         cb = API::CallbackData.new
         cb.proc = cb.proc2 = nil
         cb.data = cookie
-        @callback_data[ name ] = cb
-      else
-        @callback_data.delete( name )
       end
 
       if func
@@ -135,7 +151,16 @@ module SQLite3 ; module Driver ; module Native
         final = API::Sqlite3_ruby_function_final
       end
 
-      API.sqlite3_create_function( db, name, args, text, cb, func, step, final )
+      result = API.sqlite3_create_function( db, name, args, text, cb, func, step, final )
+
+      # see comments in busy_handler
+      if cb
+        @callback_data[ name ] = cb
+      else
+        @callback_data.delete( name )
+      end
+
+      return result
     end
 
     def value_text( value, utf16=false )

data/lib/sqlite3/errors.rb

@@ -91,7 +91,7 @@ module SQLite3
     def check( result, db=nil, msg=nil )
       unless result == Constants::ErrorCode::OK
         msg = ( msg ? msg + ": " : "" ) + db.errmsg if db
-        raise ( EXCEPTIONS[result] || SQLite3::Exception ), msg
+        raise(( EXCEPTIONS[result] || SQLite3::Exception ), msg)
       end
     end
     module_function :check

data/lib/sqlite3/resultset.rb

@@ -81,6 +81,7 @@ module SQLite3
     # can be rewound and reiterated.
     def reset( *bind_params )
       @stmt.must_be_open!
+      @stmt.reset!(false)
       @driver.reset( @stmt.handle )
       @stmt.bind_params( *bind_params )
       @eof = false

data/lib/sqlite3/statement.rb

@@ -66,6 +66,7 @@ module SQLite3
       @db = db
       @driver = @db.driver
       @closed = false
+      @results = @columns = nil
       result, @handle, @remainder = @driver.prepare( @db.handle, sql )
       Error.check( result, @db )
     end
@@ -115,8 +116,11 @@ module SQLite3
     # See also #bind_params.
     def bind_param( param, value )
       must_be_open!
+      reset! if active?
       if Fixnum === param
         case value
+          when Bignum then
+            @driver.bind_int64( @handle, param, value )
           when Integer then
             @driver.bind_int( @handle, param, value )
           when Numeric then
@@ -129,8 +133,9 @@ module SQLite3
             @driver.bind_text( @handle, param, value )
         end
       else
-        index = @driver.bind_parameter_index(
-          @handle, param.to_s )
+        param = param.to_s
+        param = ":#{param}" unless param[0] == ?:
+        index = @driver.bind_parameter_index( @handle, param )
         raise Exception, "no such bind parameter '#{param}'" if index == 0
         bind_param index, value
       end
@@ -152,9 +157,9 @@ module SQLite3
     # See also #bind_params, #execute!.
     def execute( *bind_vars )
       must_be_open!
-      @driver.reset( @handle ) if @results
+      reset! if active?
 
-      bind_params *bind_vars unless bind_vars.empty?
+      bind_params(*bind_vars) unless bind_vars.empty?
       @results = ResultSet.new( @db, self )
 
       if block_given?
@@ -191,6 +196,19 @@ module SQLite3
       rows
     end
 
+    # Resets the statement. This is typically done internally, though it might
+    # occassionally be necessary to manually reset the statement.
+    def reset!(clear_result=true)
+      @driver.reset(@handle)
+      @results = nil if clear_result
+    end
+
+    # Returns true if the statement is currently active, meaning it has an
+    # open result set.
+    def active?
+      not @results.nil?
+    end
+
     # Return an array of the column names for this statement. Note that this
     # may execute the statement in order to obtain the metadata; this makes it
     # a (potentially) expensive operation.

data/lib/sqlite3/translator.rb

@@ -81,6 +81,7 @@ module SQLite3
     # A convenience method for working with type names. This returns the "base"
     # type name, without any parenthetical data.
     def type_name( type )
+      return "" if type.nil?
       type = $1 if type =~ /^(.*?)\(/
       type.upcase
     end

data/lib/sqlite3/version.rb

@@ -35,7 +35,7 @@ module SQLite3
   module Version
 
     MAJOR = 1
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [ MAJOR, MINOR, TINY ].join( "." )

data/test/driver/dl/tc_driver.rb

@@ -30,293 +30,295 @@
 # =============================================================================
 #++
 
-$:.unshift "../../../lib"
+if (ENV["SQLITE3_DRIVERS"] || "Native").split(/,/).include?("DL")
+  $:.unshift "../../../lib"
 
-require 'sqlite3/constants'
-require 'sqlite3/driver/dl/driver'
-require 'test/unit'
+  require 'sqlite3/constants'
+  require 'sqlite3/driver/dl/driver'
+  require 'test/unit'
 
-class TC_DL_Driver < Test::Unit::TestCase
+  class TC_DL_Driver < Test::Unit::TestCase
 
-  def utf16ify( str )
-    chars = str.split(//)
-    chars.zip(["\0"] * chars.length).flatten.join
-  end
+    def utf16ify( str )
+      chars = str.split(//)
+      chars.zip(["\0"] * chars.length).flatten.join
+    end
 
-  def setup
-    @driver = SQLite3::Driver::DL::Driver.new
-    @dbname = "test.db"
-    @db = nil
-  end
+    def setup
+      @driver = SQLite3::Driver::DL::Driver.new
+      @dbname = "test.db"
+      @db = nil
+    end
 
-  def teardown
-    @driver.close( @db ) rescue nil
-    File.delete @dbname rescue nil
-  end
+    def teardown
+      @driver.close( @db ) rescue nil
+      File.delete @dbname rescue nil
+    end
 
-  def test_open
-    result, @db = @driver.open( @dbname )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert File.exist?( @dbname )
-  end
+    def test_open
+      result, @db = @driver.open( @dbname )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert File.exist?( @dbname )
+    end
 
-  def test_open_utf16
-    name = utf16ify( @dbname )
-    result, @db = @driver.open( name, true )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert File.exist?( @dbname )
-  end
+    def test_open_utf16
+      name = utf16ify( @dbname )
+      result, @db = @driver.open( name, true )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert File.exist?( @dbname )
+    end
 
-  def test_errmsg
-    result, @db = @driver.open( @dbname )
-    msg = @driver.errmsg( @db )
-    assert_equal msg, "not an error"
-  end
+    def test_errmsg
+      result, @db = @driver.open( @dbname )
+      msg = @driver.errmsg( @db )
+      assert_equal msg, "not an error"
+    end
 
-  def test_errmsg16
-    result, @db = @driver.open( @dbname )
-    msg = @driver.errmsg( @db, true )
-    assert_equal msg, utf16ify( "not an error" )
-  end
+    def test_errmsg16
+      result, @db = @driver.open( @dbname )
+      msg = @driver.errmsg( @db, true )
+      assert_equal msg, utf16ify( "not an error" )
+    end
 
-  def test_prepare
-    result, @db = @driver.open( @dbname )
-    sql = "create table foo ( a, b )"
-    result, handle, remainder = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert_equal "", remainder
-    @driver.finalize( handle )
-  end
+    def test_prepare
+      result, @db = @driver.open( @dbname )
+      sql = "create table foo ( a, b )"
+      result, handle, remainder = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert_equal "", remainder
+      @driver.finalize( handle )
+    end
 
-  def test_prepare_error
-    result, @db = @driver.open( @dbname )
-    sql = "create tble foo ( a, b )"
-    result, handle, remainder = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::ERROR, result
-  end
+    def test_prepare_error
+      result, @db = @driver.open( @dbname )
+      sql = "create tble foo ( a, b )"
+      result, handle, remainder = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::ERROR, result
+    end
 
-  def test_prepare_remainder
-    result, @db = @driver.open( @dbname )
-    sql = "create table foo ( a, b ); select * from foo"
-    result, handle, remainder = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert_equal " select * from foo", remainder
-    @driver.finalize( handle )
-  end
+    def test_prepare_remainder
+      result, @db = @driver.open( @dbname )
+      sql = "create table foo ( a, b ); select * from foo"
+      result, handle, remainder = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert_equal " select * from foo", remainder
+      @driver.finalize( handle )
+    end
 
-  def test_prepare16
-    result, @db = @driver.open( @dbname )
-    sql = utf16ify( "create table foo ( a, b )" )
-    result, handle, remainder = @driver.prepare( @db, sql, true )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert_equal "", remainder
-    @driver.finalize( handle )
-  end
+    def test_prepare16
+      result, @db = @driver.open( @dbname )
+      sql = utf16ify( "create table foo ( a, b )" )
+      result, handle, remainder = @driver.prepare( @db, sql, true )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert_equal "", remainder
+      @driver.finalize( handle )
+    end
 
-  def test_prepare16_remainder
-    result, @db = @driver.open( @dbname )
-    sql = utf16ify( "create table foo ( a, b ); select * from foo" )
-    result, handle, remainder = @driver.prepare( @db, sql, true )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert_equal utf16ify( " select * from foo" ), remainder
-    @driver.finalize( handle )
-  end
+    def test_prepare16_remainder
+      result, @db = @driver.open( @dbname )
+      sql = utf16ify( "create table foo ( a, b ); select * from foo" )
+      result, handle, remainder = @driver.prepare( @db, sql, true )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert_equal utf16ify( " select * from foo" ), remainder
+      @driver.finalize( handle )
+    end
 
-  def test_complete
-    assert @driver.complete?( "select * from foo;" )
-  end
+    def test_complete
+      assert @driver.complete?( "select * from foo;" )
+    end
 
-  def test_complete_fail
-    assert !@driver.complete?( "select * from foo" )
-  end
+    def test_complete_fail
+      assert !@driver.complete?( "select * from foo" )
+    end
 
-  def test_complete16
-    assert @driver.complete?( utf16ify("select * from foo;"), true )
-  end
+    def test_complete16
+      assert @driver.complete?( utf16ify("select * from foo;"), true )
+    end
 
-  def create_foo
-    result, @db = @driver.open( @dbname )
-    sql = "create table foo ( a, b )"
-    result, handle, = @driver.prepare( @db, sql )
-    @driver.step( handle )
-    @driver.finalize( handle )
-  end
+    def create_foo
+      result, @db = @driver.open( @dbname )
+      sql = "create table foo ( a, b )"
+      result, handle, = @driver.prepare( @db, sql )
+      @driver.step( handle )
+      @driver.finalize( handle )
+    end
 
-  def populate_foo
-    create_foo
-    sql = "insert into foo values ( 100, 200 )"
-    result, handle, = @driver.prepare( @db, sql )
-    @driver.step( handle )
-    @driver.finalize( handle )
-  end
+    def populate_foo
+      create_foo
+      sql = "insert into foo values ( 100, 200 )"
+      result, handle, = @driver.prepare( @db, sql )
+      @driver.step( handle )
+      @driver.finalize( handle )
+    end
 
-  def test_step
-    populate_foo
-    sql = "select * from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    @driver.finalize( handle )
-  end
+    def test_step
+      populate_foo
+      sql = "select * from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      @driver.finalize( handle )
+    end
 
-  def test_step_fail
-    populate_foo
-    sql = "select * from"
-    result, handle, = @driver.prepare( @db, sql )
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::MISUSE, result
-    @driver.finalize( handle )
-  end
+    def test_step_fail
+      populate_foo
+      sql = "select * from"
+      result, handle, = @driver.prepare( @db, sql )
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::MISUSE, result
+      @driver.finalize( handle )
+    end
 
-  def test_bind_blob
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_blob( handle, 1, "a\0b\1c\2d\0e" )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal "a\0b\1c\2d\0e", @driver.column_blob( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_blob
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_blob( handle, 1, "a\0b\1c\2d\0e" )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal "a\0b\1c\2d\0e", @driver.column_blob( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_double
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_double( handle, 1, 3.14 )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal 3.14, @driver.column_double( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_double
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_double( handle, 1, 3.14 )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal 3.14, @driver.column_double( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_int
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_int( handle, 1, 14 )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal 14, @driver.column_int( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_int
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_int( handle, 1, 14 )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal 14, @driver.column_int( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_null
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_null( handle, 1 )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal SQLite3::Constants::ColumnType::NULL,
-      @driver.column_type( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_null
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_null( handle, 1 )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal SQLite3::Constants::ColumnType::NULL,
+        @driver.column_type( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_text
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_text( handle, 1, "hello, world" )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal "hello, world", @driver.column_text( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_text
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_text( handle, 1, "hello, world" )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal "hello, world", @driver.column_text( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_text16
-    create_foo
-    sql = "insert into foo (b) values (?)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_text( handle, 1, utf16ify("hello, world"), true )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::DONE, result
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    sql = "select b from foo"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.step( handle )
-    assert_equal SQLite3::Constants::ErrorCode::ROW, result
-    assert_equal "hello, world", @driver.column_text( handle, 0 )
-    result = @driver.finalize( handle )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-  end
+    def test_bind_text16
+      create_foo
+      sql = "insert into foo (b) values (?)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_text( handle, 1, utf16ify("hello, world"), true )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::DONE, result
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      sql = "select b from foo"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.step( handle )
+      assert_equal SQLite3::Constants::ErrorCode::ROW, result
+      assert_equal "hello, world", @driver.column_text( handle, 0 )
+      result = @driver.finalize( handle )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+    end
 
-  def test_bind_parameter_index
-    create_foo
-    sql = "insert into foo (b) values (:hello)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    result = @driver.bind_parameter_index( handle, ":hello" )
-    assert_equal 1, result
-    result = @driver.bind_parameter_index( handle, ":foo" )
-    assert_equal 0, result
-    @driver.finalize( handle )
-  end
+    def test_bind_parameter_index
+      create_foo
+      sql = "insert into foo (b) values (:hello)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      result = @driver.bind_parameter_index( handle, ":hello" )
+      assert_equal 1, result
+      result = @driver.bind_parameter_index( handle, ":foo" )
+      assert_equal 0, result
+      @driver.finalize( handle )
+    end
 
-  def test_bind_parameter_name
-    create_foo
-    sql = "insert into foo (a,b) values (?,:foo)"
-    result, handle, = @driver.prepare( @db, sql )
-    assert_equal SQLite3::Constants::ErrorCode::OK, result
-    assert_nil nil, @driver.bind_parameter_name(handle,1)
-    assert_equal ":foo", @driver.bind_parameter_name(handle,2)
-    @driver.finalize( handle )
-  end
+    def test_bind_parameter_name
+      create_foo
+      sql = "insert into foo (a,b) values (?,:foo)"
+      result, handle, = @driver.prepare( @db, sql )
+      assert_equal SQLite3::Constants::ErrorCode::OK, result
+      assert_nil nil, @driver.bind_parameter_name(handle,1)
+      assert_equal ":foo", @driver.bind_parameter_name(handle,2)
+      @driver.finalize( handle )
+    end
 
-end
+  end
+end