sqlite3 1.3.8-x64-mingw32

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,37 @@
+begin
+  require 'hoe'
+rescue LoadError
+  # try with rubygems?
+  require 'rubygems'
+  require 'hoe'
+end
+
+Hoe.plugin :debugging, :doofus, :git, :minitest, :bundler
+
+HOE = Hoe.spec 'sqlite3' do
+  developer           'Jamis Buck', 'jamis@37signals.com'
+  developer           'Luis Lavena', 'luislavena@gmail.com'
+  developer           'Aaron Patterson', 'aaron@tenderlovemaking.com'
+
+  license             "MIT"
+
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.rdoc', 'ext/**/*.c']
+
+  require_ruby_version ">= 1.8.7"
+  require_rubygems_version ">= 1.3.5"
+
+  spec_extras[:extensions] = ["ext/sqlite3/extconf.rb"]
+
+  extra_dev_deps << ['rake-compiler', "~> 0.9.1"]
+  extra_dev_deps << ["mini_portile", "~> 0.5.1"]
+  extra_dev_deps << ["minitest", "~> 5.0"]
+  extra_dev_deps << ["hoe-bundler", "~> 1.0"]
+
+  clean_globs.push('**/test.db')
+end
+
+Hoe.add_include_dirs '.'
+
+# vim: syntax=ruby

data/tasks/native.rake

@@ -0,0 +1,45 @@
+# use rake-compiler for building the extension
+require 'rake/extensiontask'
+require 'rake/extensioncompiler'
+
+# NOTE: version used by cross compilation of Windows native extension
+# It do not affect compilation under other operating systems
+# The version indicated is the minimum DLL suggested for correct functionality
+BINARY_VERSION = "3.7.17"
+URL_VERSION    = "3071700"
+URL_PATH       = "/2013"
+
+# build sqlite3_native C extension
+RUBY_EXTENSION = Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
+  # where to locate the extension
+  ext.ext_dir = 'ext/sqlite3'
+
+  # where native extension will be copied (matches makefile)
+  ext.lib_dir = "lib/sqlite3"
+
+  # clean binary folders always
+  CLEAN.include("#{ext.lib_dir}/?.?")
+
+  # automatically add build options to avoid need of manual input
+  if RUBY_PLATFORM =~ /mswin|mingw/ then
+    # define target for extension (supporting fat binaries)
+    RUBY_VERSION =~ /(\d+\.\d+)/
+    ext.lib_dir = "lib/sqlite3/#{$1}"
+    ext.config_options << "--enable-local"
+  else
+
+    # detect cross-compiler available
+    begin
+      Rake::ExtensionCompiler.mingw_host
+      ext.cross_compile = true
+      ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32', 'x64-mingw32']
+    rescue RuntimeError
+      # noop
+    end
+  end
+end
+
+# ensure things are compiled prior testing
+task :test => [:compile]
+
+# vim: syntax=ruby

data/tasks/vendor_sqlite3.rake

@@ -0,0 +1,87 @@
+require "rake/clean"
+require "rake/extensioncompiler"
+require "mini_portile"
+
+CLOBBER.include("ports")
+
+directory "ports"
+
+def define_sqlite_task(platform, host)
+  recipe = MiniPortile.new "sqlite3", BINARY_VERSION
+  recipe.files << "http://sqlite.org#{URL_PATH}/sqlite-autoconf-#{URL_VERSION}.tar.gz"
+  recipe.host = host
+
+  desc "Compile sqlite3 for #{platform} (#{host})"
+  task "ports:sqlite3:#{platform}" => ["ports"] do |t|
+    checkpoint = "ports/.#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
+
+    unless File.exist?(checkpoint)
+      cflags = "-O2 -DSQLITE_ENABLE_COLUMN_METADATA"
+      cflags << " -fPIC" if recipe.host.include?("x86_64")
+      recipe.configure_options << "CFLAGS='#{cflags}'"
+      recipe.cook
+      touch checkpoint
+    end
+  end
+
+  recipe
+end
+
+# native sqlite3 compilation
+define_sqlite_task RUBY_PLATFORM, RbConfig::CONFIG["host"]
+
+# trick to test local compilation of sqlite3
+if ENV["USE_MINI_PORTILE"] == "true"
+  # fake recipe so we can build a directory to it
+  recipe = MiniPortile.new "sqlite3", BINARY_VERSION
+  recipe.host = RbConfig::CONFIG["host"]
+
+  RUBY_EXTENSION.config_options << "--with-opt-dir=#{recipe.path}"
+
+  # compile sqlite3 first
+  Rake::Task["compile"].prerequisites.unshift "ports:sqlite3:#{RUBY_PLATFORM}"
+end
+
+# force compilation of sqlite3 when working natively under MinGW
+if RUBY_PLATFORM =~ /mingw/
+  Rake::Task['compile'].prerequisites.unshift "ports:sqlite3:#{RUBY_PLATFORM}"
+end
+
+# iterate over all cross-compilation platforms and define the proper
+# sqlite3 recipe for it.
+if RUBY_EXTENSION.cross_compile
+  config_path = File.expand_path("~/.rake-compiler/config.yml")
+  if File.exist?(config_path)
+    # obtains platforms from rake-compiler's config.yml
+    config_file = YAML.load_file(config_path)
+
+    Array(RUBY_EXTENSION.cross_platform).each do |platform|
+      # obtain platform from rbconfig file
+      config_key = config_file.keys.sort.find { |key|
+        key.start_with?("rbconfig-#{platform}-")
+      }
+      rbfile = config_file[config_key]
+
+      # skip if rbconfig cannot be read
+      next unless File.exist?(rbfile)
+
+      host = IO.read(rbfile).match(/CONFIG\["CC"\] = "(.*)"/)[1].sub(/\-gcc/, '')
+      recipe = define_sqlite_task(platform, host)
+
+      RUBY_EXTENSION.cross_config_options << {
+        platform => "--with-opt-dir=#{recipe.path}"
+      }
+
+      # pre-compile sqlite3 port when cross-compiling
+      task :cross => "ports:sqlite3:#{platform}"
+    end
+  else
+    warn "rake-compiler configuration doesn't exist, but is required for ports"
+  end
+end
+
+task :cross do
+  ["CC", "CXX", "LDFLAGS", "CPPFLAGS", "RUBYOPT"].each do |var|
+    ENV.delete(var)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'sqlite3'
+require 'minitest/autorun'
+
+unless RUBY_VERSION >= "1.9"
+  require 'iconv'
+end
+
+module SQLite3
+  class TestCase < Minitest::Test
+    alias :assert_not_equal :refute_equal
+    alias :assert_not_nil   :refute_nil
+    alias :assert_raise     :assert_raises
+
+    def assert_nothing_raised
+      yield
+    end
+  end
+end

data/test/test_backup.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+module SQLite3
+  class TestBackup < SQLite3::TestCase
+    def setup
+      @sdb = SQLite3::Database.new(':memory:')
+      @ddb = SQLite3::Database.new(':memory:')
+      @sdb.execute('CREATE TABLE foo (idx, val);');
+      @data = ('A'..'Z').map{|x|x * 40}
+      @data.each_with_index do |v, i|
+        @sdb.execute('INSERT INTO foo (idx, val) VALUES (?, ?);', [i, v])
+      end
+    end
+
+    def test_backup_step
+      b = SQLite3::Backup.new(@ddb, 'main', @sdb, 'main')
+      while b.step(1) == SQLite3::Constants::ErrorCode::OK
+        assert_not_equal(0, b.remaining)
+      end
+      assert_equal(0, b.remaining)
+      b.finish
+      assert_equal(@data.length, @ddb.execute('SELECT * FROM foo;').length)
+    end
+
+    def test_backup_all
+      b = SQLite3::Backup.new(@ddb, 'main', @sdb, 'main')
+      assert_equal(SQLite3::Constants::ErrorCode::DONE, b.step(-1))
+      assert_equal(0, b.remaining)
+      b.finish
+      assert_equal(@data.length, @ddb.execute('SELECT * FROM foo;').length)
+    end
+  end if defined?(SQLite3::Backup)
+end

data/test/test_collation.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+require 'helper'
+
+module SQLite3
+  class TestCollation < SQLite3::TestCase
+    class Comparator
+      attr_reader :calls
+      def initialize
+        @calls = []
+      end
+
+      def compare left, right
+        @calls << [left, right]
+        left <=> right
+      end
+    end
+
+    def setup
+      @db = SQLite3::Database.new(':memory:')
+      @create = "create table ex(id int, data string)"
+      @db.execute(@create);
+      [ [1, 'hello'], [2, 'world'] ].each do |vals|
+        @db.execute('insert into ex (id, data) VALUES (?, ?)', vals)
+      end
+    end
+
+    def test_custom_collation
+      comparator = Comparator.new
+
+      @db.collation 'foo', comparator
+
+      assert_equal comparator, @db.collations['foo']
+      @db.execute('select data from ex order by 1 collate foo')
+      assert_equal 1, comparator.calls.length
+    end
+
+    def test_remove_collation
+      comparator = Comparator.new
+
+      @db.collation 'foo', comparator
+      @db.collation 'foo', nil
+
+      assert_nil @db.collations['foo']
+      assert_raises(SQLite3::SQLException) do
+        @db.execute('select data from ex order by 1 collate foo')
+      end
+    end
+
+    if RUBY_VERSION >= '1.9.1'
+      def test_encoding
+        comparator = Comparator.new
+        @db.collation 'foo', comparator
+        @db.execute('select data from ex order by 1 collate foo')
+
+        a, b = *comparator.calls.first
+
+        assert_equal Encoding.find('UTF-8'), a.encoding
+        assert_equal Encoding.find('UTF-8'), b.encoding
+      end
+
+      def test_encoding_default_internal
+        warn_before = $-w
+        $-w = false
+        before_enc = Encoding.default_internal
+
+        Encoding.default_internal = 'EUC-JP'
+        comparator = Comparator.new
+        @db.collation 'foo', comparator
+        @db.execute('select data from ex order by 1 collate foo')
+
+        a, b = *comparator.calls.first
+
+        assert_equal Encoding.find('EUC-JP'), a.encoding
+        assert_equal Encoding.find('EUC-JP'), b.encoding
+      ensure
+        Encoding.default_internal = before_enc
+        $-w = warn_before
+      end
+    end
+  end
+end

data/test/test_database.rb

@@ -0,0 +1,350 @@
+require 'helper'
+
+module SQLite3
+  class TestDatabase < SQLite3::TestCase
+    attr_reader :db
+
+    def setup
+      @db = SQLite3::Database.new(':memory:')
+    end
+
+    def test_segv
+      assert_raises(TypeError) { SQLite3::Database.new 1 }
+    end
+
+    def test_bignum
+      num = 4907021672125087844
+      db.execute 'CREATE TABLE "employees" ("token" integer(8), "name" varchar(20) NOT NULL)'
+      db.execute "INSERT INTO employees(name, token) VALUES('employee-1', ?)", [num]
+      rows = db.execute 'select token from employees'
+      assert_equal num, rows.first.first
+    end
+
+    def test_blob
+      @db.execute("CREATE TABLE blobs ( id INTEGER, hash BLOB(10) )")
+      blob = Blob.new("foo\0bar")
+      @db.execute("INSERT INTO blobs VALUES (0, ?)", [blob])
+      assert_equal [[0, blob, blob.length, blob.length*2]], @db.execute("SELECT id, hash, length(hash), length(hex(hash)) FROM blobs")
+    end
+
+    def test_get_first_row
+      assert_equal [1], @db.get_first_row('SELECT 1')
+    end
+
+    def test_get_first_row_with_type_translation_and_hash_results
+      @db.results_as_hash = true
+      assert_equal({0=>1, "1"=>1}, @db.get_first_row('SELECT 1'))
+    end
+
+    def test_execute_with_type_translation_and_hash
+      @db.results_as_hash = true
+      rows = []
+      @db.execute('SELECT 1') { |row| rows << row }
+
+      assert_equal({0=>1, "1"=>1}, rows.first)
+    end
+
+    def test_encoding
+      assert @db.encoding, 'database has encoding'
+    end
+
+    def test_changes
+      @db.execute("CREATE TABLE items (id integer PRIMARY KEY AUTOINCREMENT, number integer)")
+      assert_equal 0, @db.changes
+      @db.execute("INSERT INTO items (number) VALUES (10)")
+      assert_equal 1, @db.changes
+      @db.execute_batch(
+        "UPDATE items SET number = (number + :nn) WHERE (number = :n)",
+        {"nn" => 20, "n" => 10})
+      assert_equal 1, @db.changes
+      assert_equal [[30]], @db.execute("select number from items")
+    end
+
+    def test_new
+      db = SQLite3::Database.new(':memory:')
+      assert db
+    end
+
+    def test_new_yields_self
+      thing = nil
+      SQLite3::Database.new(':memory:') do |db|
+        thing = db
+      end
+      assert_instance_of(SQLite3::Database, thing)
+    end
+
+    def test_new_with_options
+      # determine if Ruby is running on Big Endian platform
+      utf16 = ([1].pack("I") == [1].pack("N")) ? "UTF-16BE" : "UTF-16LE"
+
+      if RUBY_VERSION >= "1.9"
+        db = SQLite3::Database.new(':memory:'.encode(utf16), :utf16 => true)
+      else
+        db = SQLite3::Database.new(Iconv.conv(utf16, 'UTF-8', ':memory:'),
+                                   :utf16 => true)
+      end
+      assert db
+    end
+
+    def test_close
+      db = SQLite3::Database.new(':memory:')
+      db.close
+      assert db.closed?
+    end
+
+    def test_block_closes_self
+      thing = nil
+      SQLite3::Database.new(':memory:') do |db|
+        thing = db
+        assert !thing.closed?
+      end
+      assert thing.closed?
+    end
+
+    def test_prepare
+      db = SQLite3::Database.new(':memory:')
+      stmt = db.prepare('select "hello world"')
+      assert_instance_of(SQLite3::Statement, stmt)
+    end
+
+    def test_total_changes
+      db = SQLite3::Database.new(':memory:')
+      db.execute("create table foo ( a integer primary key, b text )")
+      db.execute("insert into foo (b) values ('hello')")
+      assert_equal 1, db.total_changes
+    end
+
+    def test_execute_returns_list_of_hash
+      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
+      db.execute("create table foo ( a integer primary key, b text )")
+      db.execute("insert into foo (b) values ('hello')")
+      rows = db.execute("select * from foo")
+      assert_equal [{0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}], rows
+    end
+
+    def test_execute_yields_hash
+      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
+      db.execute("create table foo ( a integer primary key, b text )")
+      db.execute("insert into foo (b) values ('hello')")
+      db.execute("select * from foo") do |row|
+        assert_equal({0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}, row)
+      end
+    end
+
+    def test_table_info
+      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
+      db.execute("create table foo ( a integer primary key, b text )")
+      info = [{
+        "name"       => "a",
+        "pk"         => 1,
+        "notnull"    => 0,
+        "type"       => "integer",
+        "dflt_value" => nil,
+        "cid"        => 0
+      },
+      {
+        "name"       => "b",
+        "pk"         => 0,
+        "notnull"    => 0,
+        "type"       => "text",
+        "dflt_value" => nil,
+        "cid"        => 1
+      }]
+      assert_equal info, db.table_info('foo')
+    end
+
+    def test_total_changes_closed
+      db = SQLite3::Database.new(':memory:')
+      db.close
+      assert_raise(SQLite3::Exception) do
+        db.total_changes
+      end
+    end
+
+    def test_trace_requires_opendb
+      @db.close
+      assert_raise(SQLite3::Exception) do
+        @db.trace { |x| }
+      end
+    end
+
+    def test_trace_with_block
+      result = nil
+      @db.trace { |sql| result = sql }
+      @db.execute "select 'foo'"
+      assert_equal "select 'foo'", result
+    end
+
+    def test_trace_with_object
+      obj = Class.new {
+        attr_accessor :result
+        def call sql; @result = sql end
+      }.new
+
+      @db.trace(obj)
+      @db.execute "select 'foo'"
+      assert_equal "select 'foo'", obj.result
+    end
+
+    def test_trace_takes_nil
+      @db.trace(nil)
+      @db.execute "select 'foo'"
+    end
+
+    def test_last_insert_row_id_closed
+      @db.close
+      assert_raise(SQLite3::Exception) do
+        @db.last_insert_row_id
+      end
+    end
+
+    def test_define_function
+      called_with = nil
+      @db.define_function("hello") do |value|
+        called_with = value
+      end
+      @db.execute("select hello(10)")
+      assert_equal 10, called_with
+    end
+
+    def test_call_func_arg_type
+      called_with = nil
+      @db.define_function("hello") do |b, c, d|
+        called_with = [b, c, d]
+        nil
+      end
+      @db.execute("select hello(2.2, 'foo', NULL)")
+      assert_equal [2.2, 'foo', nil], called_with
+    end
+
+    def test_define_varargs
+      called_with = nil
+      @db.define_function("hello") do |*args|
+        called_with = args
+        nil
+      end
+      @db.execute("select hello(2.2, 'foo', NULL)")
+      assert_equal [2.2, 'foo', nil], called_with
+    end
+
+    def test_call_func_blob
+      called_with = nil
+      @db.define_function("hello") do |a, b|
+        called_with = [a, b, a.length]
+        nil
+      end
+      blob = Blob.new("a\0fine\0kettle\0of\0fish")
+      @db.execute("select hello(?, length(?))", [blob, blob])
+      assert_equal [blob, blob.length, 21], called_with
+    end
+
+    def test_function_return
+      @db.define_function("hello") { |a| 10 }
+      assert_equal [10], @db.execute("select hello('world')").first
+    end
+
+    def test_function_return_types
+      [10, 2.2, nil, "foo"].each do |thing|
+        @db.define_function("hello") { |a| thing }
+        assert_equal [thing], @db.execute("select hello('world')").first
+      end
+    end
+
+    def test_define_function_closed
+      @db.close
+      assert_raise(SQLite3::Exception) do
+        @db.define_function('foo') {  }
+      end
+    end
+
+    def test_inerrupt_closed
+      @db.close
+      assert_raise(SQLite3::Exception) do
+        @db.interrupt
+      end
+    end
+
+    def test_define_aggregate
+      @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' )"
+
+      acc = Class.new {
+        attr_reader :sum
+        alias :finalize :sum
+        def initialize
+          @sum = 0
+        end
+
+        def step a
+          @sum += a
+        end
+      }.new
+
+      @db.define_aggregator("accumulate", acc)
+      value = @db.get_first_value( "select accumulate(a) from foo" )
+      assert_equal 6, value
+    end
+
+    def test_authorizer_ok
+      @db.authorizer = Class.new {
+        def call action, a, b, c, d; true end
+      }.new
+      @db.prepare("select 'fooooo'")
+
+      @db.authorizer = Class.new {
+        def call action, a, b, c, d; 0 end
+      }.new
+      @db.prepare("select 'fooooo'")
+    end
+
+    def test_authorizer_ignore
+      @db.authorizer = Class.new {
+        def call action, a, b, c, d; nil end
+      }.new
+      stmt = @db.prepare("select 'fooooo'")
+      assert_equal nil, stmt.step
+    end
+
+    def test_authorizer_fail
+      @db.authorizer = Class.new {
+        def call action, a, b, c, d; false end
+      }.new
+      assert_raises(SQLite3::AuthorizationException) do
+        @db.prepare("select 'fooooo'")
+      end
+    end
+
+    def test_remove_auth
+      @db.authorizer = Class.new {
+        def call action, a, b, c, d; false end
+      }.new
+      assert_raises(SQLite3::AuthorizationException) do
+        @db.prepare("select 'fooooo'")
+      end
+
+      @db.authorizer = nil
+      @db.prepare("select 'fooooo'")
+    end
+
+    def test_close_with_open_statements
+      @db.prepare("select 'foo'")
+      assert_raises(SQLite3::BusyException) do
+        @db.close
+      end
+    end
+
+    def test_execute_with_empty_bind_params
+      assert_equal [['foo']], @db.execute("select 'foo'", [])
+    end
+
+    def test_query_with_named_bind_params
+      assert_equal [['foo']], @db.query("select :n", {'n' => 'foo'}).to_a
+    end
+
+    def test_execute_with_named_bind_params
+      assert_equal [['foo']], @db.execute("select :n", {'n' => 'foo'})
+    end
+  end
+end