sqlite3-ruby 1.2.5-x86-mswin32

data/tasks/benchmark.rake

@@ -0,0 +1,9 @@
+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/faq.rake

@@ -0,0 +1,9 @@
+# Generate FAQ
+desc "Generate the FAQ document"
+task :faq => ['faq/faq.html']
+
+file 'faq/faq.html' => ['faq/faq.rb', 'faq/faq.yml'] do
+  cd 'faq' do
+    ruby "faq.rb > faq.html"
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,32 @@
+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/tasks/native.rake

@@ -0,0 +1,35 @@
+# use rake-compiler for building the extension
+require 'rake/extensiontask'
+
+# build sqlite3_api C extension
+Rake::ExtensionTask.new('sqlite3_api', HOE.spec) do |ext|
+  # reference to the sqlite3 library
+  sqlite3_lib = File.expand_path(File.join(File.dirname(__FILE__), '..', 'vendor', 'sqlite3'))
+
+  # define target for extension (supporting fat binaries)
+  if RUBY_PLATFORM =~ /mingw/ then
+    ruby_ver = RUBY_VERSION.match(/(\d+\.\d+)/)[1]
+    ext.lib_dir = "lib/#{ruby_ver}"
+  end
+
+  # automatically add build options to avoid need of manual input
+  if RUBY_PLATFORM =~ /mswin|mingw/ then
+    ext.config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
+  else
+    ext.cross_compile = true
+    ext.cross_platform = ['i386-mswin32', 'i386-mingw32']
+    ext.cross_config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
+  end
+end
+
+# C wrapper depends on swig file to be generated
+file 'ext/sqlite3_api/sqlite3_api_wrap.c' => ['ext/sqlite3_api/sqlite3_api.i'] do |t|
+  begin
+    sh "swig -ruby -o #{t.name} #{t.prerequisites.first}"
+  rescue
+    fail "could not build wrapper via swig (perhaps swig is not installed?)"
+  end
+end
+
+# ensure things are compiled prior testing
+task :test => [:compile]

data/tasks/vendor_sqlite3.rake

@@ -0,0 +1,104 @@
+require 'rake/clean'
+require 'rake/extensioncompiler'
+
+# download sqlite3 library and headers
+
+# only on Windows or cross platform compilation
+def dlltool(dllname, deffile, libfile)
+  # define if we are using GCC or not
+  if Rake::ExtensionCompiler.mingw_gcc_executable then
+    dir = File.dirname(Rake::ExtensionCompiler.mingw_gcc_executable)
+    tool = case RUBY_PLATFORM
+      when /mingw/
+        File.join(dir, 'dlltool.exe')
+      when /linux|darwin/
+        File.join(dir, "#{Rake::ExtensionCompiler.mingw_host}-dlltool")
+    end
+    return "#{tool} --dllname #{dllname} --def #{deffile} --output-lib #{libfile}"
+  else
+    if RUBY_PLATFORM =~ /mswin/ then
+      tool = 'lib.exe'
+    else
+      fail "Unsupported platform for cross-compilation (please, contribute some patches)."
+    end
+    return "#{tool} /DEF:#{deffile} /OUT:#{libfile}"
+  end
+end
+
+version = '3_6_16'
+
+# required folder structure for --with-sqlite3-dir (include + lib)
+directory "vendor/sqlite3/lib"
+directory "vendor/sqlite3/include"
+
+# download amalgamation version (for include files)
+file "vendor/sqlite-amalgamation-#{version}.zip" => ['vendor'] do |t|
+  url = "http://www.sqlite.org/#{File.basename(t.name)}"
+  when_writing "downloading #{t.name}" do
+    cd File.dirname(t.name) do
+      system "wget -c #{url} || curl -C - -O #{url}"
+    end
+  end
+end
+
+# download dll binaries
+file "vendor/sqlitedll-#{version}.zip" => ['vendor'] do |t|
+  url = "http://www.sqlite.org/#{File.basename(t.name)}"
+  when_writing "downloading #{t.name}" do
+    cd File.dirname(t.name) do
+      system "wget -c #{url} || curl -C - -O #{url}"
+    end
+  end
+end
+
+# extract header files into include folder
+file "vendor/sqlite3/include/sqlite3.h" => ['vendor/sqlite3/include', "vendor/sqlite-amalgamation-#{version}.zip"] do |t|
+  full_file = File.expand_path(t.prerequisites.last)
+  when_writing "creating #{t.name}" do
+    cd File.dirname(t.name) do
+      sh "unzip #{full_file}"
+      # update file timestamp to avoid Rake perform this extraction again.
+      touch File.basename(t.name)
+    end
+  end
+end
+
+# extract dll files into lib folder
+file "vendor/sqlite3/lib/sqlite3.dll" => ['vendor/sqlite3/lib', "vendor/sqlitedll-#{version}.zip"] do |t|
+  full_file = File.expand_path(t.prerequisites.last)
+  when_writing "creating #{t.name}" do
+    cd File.dirname(t.name) do
+      sh "unzip #{full_file}"
+      # update file timestamp to avoid Rake perform this extraction again.
+      touch File.basename(t.name)
+    end
+  end
+end
+
+# generate import library from definition and dll file
+file "vendor/sqlite3/lib/sqlite3.lib" => ["vendor/sqlite3/lib/sqlite3.dll"] do |t|
+  libfile = t.name
+  dllname = libfile.ext('dll')
+  deffile = libfile.ext('def')
+
+  when_writing "creating #{t.name}" do
+    sh dlltool(dllname, deffile, libfile)
+  end
+end
+
+# clean and clobber actions
+# All the uncompressed files must be removed at clean
+ CLEAN.include('vendor/sqlite3')
+
+# clobber vendored packages
+CLOBBER.include('vendor')
+
+# vendor:sqlite3
+task 'vendor:sqlite3' => ["vendor/sqlite3/lib/sqlite3.lib", "vendor/sqlite3/include/sqlite3.h"]
+
+# hook into cross compilation vendored sqlite3 dependency
+if RUBY_PLATFORM =~ /mingw|mswin/ then
+  Rake::Task['compile'].prerequisites.unshift 'vendor:sqlite3'
+else
+  Rake::Task['cross'].prerequisites.unshift 'vendor:sqlite3'
+end

data/test/bm.rb

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

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