sqlite3-ruby 1.2.5 → 1.3.0.beta.1

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

@@ -1,219 +0,0 @@
-# support multiple ruby version (fat binaries under windows)
-begin
-  require 'sqlite3_api'
-rescue LoadError
-  if RUBY_PLATFORM =~ /mingw|mswin/ then
-    RUBY_VERSION =~ /(\d+.\d+)/
-    require "#{$1}/sqlite3_api"
-  end
-end
-
-module SQLite3 ; module Driver ; module Native
-
-  class Driver
-
-    def initialize
-      @callback_data = Hash.new
-      @authorizer = Hash.new
-      @busy_handler = Hash.new
-      @trace = Hash.new
-    end
-
-    def complete?( sql, utf16=false )
-      API.send( utf16 ? :sqlite3_complete16 : :sqlite3_complete, sql ) != 0
-    end
-
-    def busy_handler( db, data=nil, &block )
-      if block
-        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
-
-      result
-    end
-
-    def set_authorizer( db, data=nil, &block )
-      if block
-        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
-
-      result
-    end
-
-    def trace( db, data=nil, &block )
-      if block
-        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
-
-      result
-    end
-
-    def open( filename, utf16=false )
-      API.send( utf16 ? :sqlite3_open16 : :sqlite3_open, filename )
-    end
-
-    def errmsg( db, utf16=false )
-      API.send( utf16 ? :sqlite3_errmsg16 : :sqlite3_errmsg, db )
-    end
-
-    def prepare( db, sql, utf16=false )
-      API.send( ( utf16 ? :sqlite3_prepare16 : :sqlite3_prepare ),
-        db, sql )
-    end
-
-    def bind_text( stmt, index, value, utf16=false )
-      API.send( ( utf16 ? :sqlite3_bind_text16 : :sqlite3_bind_text ),
-        stmt, index, value.to_s )
-    end
-
-    def column_name( stmt, index, utf16=false )
-      API.send( ( utf16 ? :sqlite3_column_name16 : :sqlite3_column_name ),
-        stmt, index )
-    end
-
-    def column_decltype( stmt, index, utf16=false )
-      API.send(
-        ( utf16 ? :sqlite3_column_decltype16 : :sqlite3_column_decltype ),
-        stmt, index )
-    end
-
-    def column_text( stmt, index, utf16=false )
-      API.send( ( utf16 ? :sqlite3_column_text16 : :sqlite3_column_text ),
-        stmt, index )
-    end
-
-    def create_function( db, name, args, text, cookie, func, step, final )
-      if func || ( step && final )
-        cb = API::CallbackData.new
-        cb.proc = cb.proc2 = nil
-        cb.data = cookie
-      end
-
-      if func
-        cb.proc = func
-
-        func = API::Sqlite3_ruby_function_step
-        step = final = nil
-      elsif step && final
-        cb.proc = step
-        cb.proc2 = final
-
-        func = nil
-        step = API::Sqlite3_ruby_function_step
-        final = API::Sqlite3_ruby_function_final
-      end
-
-      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 )
-      method = case utf16
-        when nil, false then :sqlite3_value_text
-        when :le then :sqlite3_value_text16le
-        when :be then :sqlite3_value_text16be
-        else :sqlite3_value_text16
-      end
-
-      API.send( method, value )
-    end
-
-    def result_text( context, result, utf16=false )
-      method = case utf16
-        when nil, false then :sqlite3_result_text
-        when :le then :sqlite3_result_text16le
-        when :be then :sqlite3_result_text16be
-        else :sqlite3_result_text16
-      end
-
-      API.send( method, context, result.to_s )
-    end
-
-    def result_error( context, value, utf16=false )
-      API.send( ( utf16 ? :sqlite3_result_error16 : :sqlite3_result_error ),
-        context, value )
-    end
-
-    def self.api_delegate( name )
-      eval "def #{name} (*args) API.sqlite3_#{name}( *args ) ; end"
-    end
-
-    api_delegate :libversion
-    api_delegate :close
-    api_delegate :last_insert_rowid
-    api_delegate :changes
-    api_delegate :total_changes
-    api_delegate :interrupt
-    api_delegate :busy_timeout
-    api_delegate :errcode
-    api_delegate :bind_blob
-    api_delegate :bind_double
-    api_delegate :bind_int
-    api_delegate :bind_int64
-    api_delegate :bind_null
-    api_delegate :bind_parameter_count
-    api_delegate :bind_parameter_name
-    api_delegate :bind_parameter_index
-    api_delegate :column_count
-    api_delegate :step
-    api_delegate :data_count
-    api_delegate :column_blob
-    api_delegate :column_bytes
-    api_delegate :column_bytes16
-    api_delegate :column_double
-    api_delegate :column_int
-    api_delegate :column_int64
-    api_delegate :column_type
-    api_delegate :finalize
-    api_delegate :reset
-    api_delegate :aggregate_count
-    api_delegate :value_blob
-    api_delegate :value_bytes
-    api_delegate :value_bytes16
-    api_delegate :value_double
-    api_delegate :value_int
-    api_delegate :value_int64
-    api_delegate :value_type
-    api_delegate :result_blob
-    api_delegate :result_double
-    api_delegate :result_int
-    api_delegate :result_int64
-    api_delegate :result_null
-    api_delegate :result_value
-    api_delegate :aggregate_context
-
-  end
-
-end ; end ; end

data/tasks/benchmark.rake

@@ -1,9 +0,0 @@
-desc "Run benchmarks vs. sqlite-ruby"
-task :benchmark do
-  ruby "test/bm.rb"
-end
-
-desc "Run benchmarks dl vs. native"
-task :benchmark2 do
-  ruby "test/native-vs-dl.rb"
-end

data/tasks/gem.rake

@@ -1,32 +0,0 @@
-require 'rubygems/package_task'
-require 'hoe'
-
-HOE = Hoe.spec 'sqlite3-ruby' do
-  self.rubyforge_name = 'sqlite-ruby'
-  self.author         = ['Jamis Buck']
-  self.email          = %w[jamis@37signals.com]
-  self.readme_file    = 'README.txt'
-  self.need_tar       = false
-  self.need_zip       = false
-
-  spec_extras[:required_ruby_version] = Gem::Requirement.new('> 1.8.5')
-
-  spec_extras[:extensions] = ["ext/sqlite3_api/extconf.rb"]
-
-  extra_dev_deps << 'mocha'
-  extra_dev_deps << ['rake-compiler', "~> 0.5.0"]
-
-  spec_extras['rdoc_options'] = proc do |rdoc_options|
-    rdoc_options << "--main=README.txt"
-  end
-
-  clean_globs.push('**/test.db')
-end
-
-file "#{HOE.spec.name}.gemspec" => ['Rakefile', 'tasks/gem.rake', 'lib/sqlite3/version.rb'] do |t|
-  puts "Generating #{t.name}"
-  File.open(t.name, 'w') { |f| f.puts HOE.spec.to_yaml }
-end
-
-desc "Generate or update the standalone gemspec file for the project"
-task :gemspec => ["#{HOE.spec.name}.gemspec"]

data/test/bm.rb

@@ -1,140 +0,0 @@
-require 'benchmark'
-
-N = 1000
-
-$VERBOSE=nil
-
-puts "file require"
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    N.times do
-      $".delete_if { |i| i =~ /sqlite/ }
-      require 'sqlite'
-    end
-  end
-  x.report('sqlite3') do
-    N.times do
-      $".delete_if { |i| i =~ /sqlite3/ }
-      require 'sqlite3'
-    end
-  end
-end
-
-puts
-puts "database creation..."
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    N.times do
-      File.delete "test.db" rescue nil
-      SQLite::Database.open( "test.db" ).close
-    end
-  end
-  x.report('sqlite3') do
-    N.times do
-      File.delete "test.db" rescue nil
-      SQLite3::Database.open( "test.db" ).close
-    end
-  end
-end
-File.delete "test.db" rescue nil
-
-SQLite::Database.open( "test.db" ).close
-SQLite3::Database.open( "test3.db" ).close
-
-puts
-puts "database open..."
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    N.times do
-      SQLite::Database.open( "test.db" ).close
-    end
-  end
-  x.report('sqlite3') do
-    N.times do
-      SQLite3::Database.open( "test3.db" ).close
-    end
-  end
-end
-File.delete "test.db" rescue nil
-File.delete "test3.db" rescue nil
-
-db = SQLite::Database.open( "test.db" )
-db3 = SQLite3::Database.open( "test3.db" )
-
-db.execute "create table foo (a,b)"
-db3.execute "create table foo (a,b)"
-
-puts
-puts "insertions"
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    db.transaction do
-      N.times do |i|
-        db.execute "insert into foo values (#{i}, #{i+1})"
-      end
-    end
-  end
-  x.report('sqlite3') do
-    db3.transaction do
-      N.times do |i|
-        db3.execute "insert into foo values (#{i}, #{i+1})"
-      end
-    end
-  end
-end
-
-puts
-puts "insertions using prepared statement"
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    db.transaction do
-      stmt = db.prepare "insert into foo values (?,?)"
-      N.times { |i| stmt.execute i, i+1 }
-    end
-  end
-  x.report('sqlite3') do
-    db3.transaction do
-      db3.prepare( "insert into foo values (?,?)" ) do |stmt|
-        N.times { |i| stmt.execute i, i+1 }
-      end
-    end
-  end
-end
-
-db.close
-db3.close
-File.delete "test.db" rescue nil
-File.delete "test3.db" rescue nil
-
-db = SQLite::Database.open( "test.db" )
-db3 = SQLite3::Database.open( "test3.db" )
-
-db.execute "create table foo (a,b)"
-db.execute "insert into foo values (1,2)"
-db.execute "insert into foo values (3,4)"
-db.execute "insert into foo values (5,6)"
-
-db3.execute "create table foo (a,b)"
-db3.execute "insert into foo values (1,2)"
-db3.execute "insert into foo values (3,4)"
-db3.execute "insert into foo values (5,6)"
-
-puts
-puts "queries"
-Benchmark.bm( 7 ) do |x|
-  x.report('sqlite') do
-    N.times do
-      db.execute "select * from foo"
-    end
-  end
-  x.report('sqlite3') do
-    N.times do
-      db3.execute "select * from foo"
-    end
-  end
-end
-
-db.close
-db3.close
-File.delete "test.db" rescue nil
-File.delete "test3.db" rescue nil

data/test/driver/dl/tc_driver.rb

@@ -1,292 +0,0 @@
-if (ENV["SQLITE3_DRIVERS"] || "Native").split(/,/).include?("DL")
-  $:.unshift "../../../lib"
-
-  require 'sqlite3/constants'
-  require 'sqlite3/driver/dl/driver'
-  require 'test/unit'
-
-  class TC_DL_Driver < Test::Unit::TestCase
-
-    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 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_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_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_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_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_complete
-      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 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 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_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_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_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_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
-
-  end
-end