femto-sqlite3 1.3.7

data/test/test_result_set.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+module SQLite3
+  class TestResultSet < SQLite3::TestCase
+    def test_each_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rs.each_hash do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+
+    def test_next_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rows = []
+      while row = rs.next_hash
+        rows << row
+      end
+      rows.each do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+  end
+end

data/test/test_sqlite3.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+module SQLite3
+  class TestSQLite3 < SQLite3::TestCase
+    def test_libversion
+      assert_not_nil SQLite3.libversion
+    end
+  end
+end

data/test/test_statement.rb

@@ -0,0 +1,249 @@
+require 'helper'
+
+module SQLite3
+  class TestStatement < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
+    end
+
+    def test_double_close_does_not_segv
+      @db.execute 'CREATE TABLE "things" ("number" float NOT NULL)'
+
+      stmt = @db.prepare 'INSERT INTO things (number) VALUES (?)'
+      assert_raises(SQLite3::ConstraintException) { stmt.execute(nil) }
+
+      stmt.close
+
+      assert_raises(SQLite3::Exception) { stmt.close }
+    end
+
+    def test_raises_type_error
+      assert_raises(TypeError) do
+        SQLite3::Statement.new( @db, nil )
+      end
+    end
+
+    ###
+    # This method may not exist depending on how sqlite3 was compiled
+    def test_database_name
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      stmt = @db.prepare('select text from foo')
+      if stmt.respond_to?(:database_name)
+        assert_equal 'main', stmt.database_name(0)
+      end
+    end
+
+    def test_prepare_blob
+      @db.execute('create table foo(text BLOB)')
+      stmt = @db.prepare('insert into foo(text) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new('hello'))
+      stmt.step
+      stmt.close
+    end
+
+    def test_select_blob
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      assert_equal 'hello', @db.execute('select * from foo').first.first
+    end
+
+    def test_new
+      assert @stmt
+    end
+
+    def test_new_closed_handle
+      @db = SQLite3::Database.new(':memory:')
+      @db.close
+      assert_raises(ArgumentError) do
+        SQLite3::Statement.new(@db, 'select "foo"')
+      end
+    end
+
+    def test_new_with_remainder
+      stmt = SQLite3::Statement.new(@db, "select 'foo';bar")
+      assert_equal 'bar', stmt.remainder
+    end
+
+    def test_empty_remainder
+      assert_equal '', @stmt.remainder
+    end
+
+    def test_close
+      @stmt.close
+      assert @stmt.closed?
+    end
+
+    def test_double_close
+      @stmt.close
+      assert_raises(SQLite3::Exception) do
+        @stmt.close
+      end
+    end
+
+    def test_bind_param_string
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, "hello")
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_bind_param_int
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 10)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [10], result
+    end
+
+    def test_bind_nil
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, nil)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [nil], result
+    end
+
+    def test_bind_blobs
+    end
+
+    def test_bind_64
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2 ** 31)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2 ** 31], result
+    end
+
+    def test_bind_double
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2.2)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2.2], result
+    end
+
+    def test_named_bind
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(':foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_no_colon
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param('foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_symbol
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(:foo, 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_not_found
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      assert_raises(SQLite3::Exception) do
+        stmt.bind_param('bar', 'hello')
+      end
+    end
+
+    def test_each
+      r = nil
+      @stmt.each do |row|
+        r = row
+      end
+      assert_equal(['foo'], r)
+    end
+
+    def test_reset!
+      r = []
+      @stmt.each { |row| r << row }
+      @stmt.reset!
+      @stmt.each { |row| r << row }
+      assert_equal [['foo'], ['foo']], r
+    end
+
+    def test_step
+      r = @stmt.step
+      assert_equal ['foo'], r
+    end
+
+    def test_tainted
+      r = @stmt.step
+      assert r.first.tainted?
+    end
+
+    def test_step_twice
+      assert_not_nil @stmt.step
+      assert !@stmt.done?
+      assert_nil @stmt.step
+      assert @stmt.done?
+
+      @stmt.reset!
+      assert !@stmt.done?
+    end
+
+    def test_step_never_moves_past_done
+      10.times { @stmt.step }
+      @stmt.done?
+    end
+
+    def test_column_count
+      assert_equal 1, @stmt.column_count
+    end
+
+    def test_column_name
+      assert_equal "'foo'", @stmt.column_name(0)
+      assert_equal nil, @stmt.column_name(10)
+    end
+
+    def test_bind_parameter_count
+      stmt = SQLite3::Statement.new(@db, "select ?, ?, ?")
+      assert_equal 3, stmt.bind_parameter_count
+    end
+
+    def test_execute_with_varargs
+      stmt = @db.prepare('select ?, ?')
+      assert_equal [[nil, nil]], stmt.execute(nil, nil).to_a
+    end
+
+    def test_execute_with_hash
+      stmt = @db.prepare('select :n, :h')
+      assert_equal [[10, nil]], stmt.execute('n' => 10, 'h' => nil).to_a
+    end
+
+    def test_with_error
+      @db.execute('CREATE TABLE "employees" ("name" varchar(20) NOT NULL CONSTRAINT "index_employees_on_name" UNIQUE)')
+      stmt = @db.prepare("INSERT INTO Employees(name) VALUES(?)")
+      stmt.execute('employee-1')
+      stmt.execute('employee-1') rescue SQLite3::ConstraintException
+      stmt.reset!
+      assert_nothing_raised(SQLite3::ConstraintException) {
+        stmt.execute('employee-2')
+      }
+    end
+
+    def test_clear_bindings
+      stmt = @db.prepare('select ?, ?')
+      stmt.bind_param 1, "foo"
+      stmt.bind_param 2, "bar"
+
+      # We can't fetch bound parameters back out of sqlite3, so just call
+      # the clear_bindings! method and assert that nil is returned
+      stmt.clear_bindings!
+
+      while x = stmt.step
+        assert_equal [nil, nil], x
+      end
+    end
+  end
+end

data/test/test_statement_execute.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module SQLite3
+  class TestStatementExecute < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @db.execute_batch(
+        "CREATE TABLE items (id integer PRIMARY KEY, number integer)")
+    end
+
+    def test_execute_insert
+      ps = @db.prepare("INSERT INTO items (number) VALUES (:n)")
+      ps.execute('n'=>10)
+      assert_equal 1, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+
+    def test_execute_update
+      @db.execute("INSERT INTO items (number) VALUES (?)", [10])
+
+      ps = @db.prepare("UPDATE items SET number = :new WHERE number = :old")
+      ps.execute('old'=>10, 'new'=>20)
+      assert_equal 20, @db.get_first_value("SELECT number FROM items")
+      ps.close
+    end
+
+    def test_execute_delete
+      @db.execute("INSERT INTO items (number) VALUES (?)", [20])
+      ps = @db.prepare("DELETE FROM items WHERE number = :n")
+      ps.execute('n' => 20)
+      assert_equal 0, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+  end
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: femto-sqlite3
+version: !ruby/object:Gem::Version
+  version: 1.3.7
+  prerelease: 
+platform: ruby
+authors:
+- Jamis Buck
+- Luis Lavena
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: mini_portile
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: ! 'This module allows Ruby programs to interface with the SQLite3
+
+  database engine (http://www.sqlite.org).  You must have the
+
+  SQLite engine installed in order to build this module.
+
+
+  Note that this module is only compatible with SQLite 3.6.16 or newer.'
+email:
+- jamis@37signals.com
+- luislavena@gmail.com
+- aaron@tenderlovemaking.com
+executables: []
+extensions:
+- ext/sqlite3/extconf.rb
+extra_rdoc_files:
+- API_CHANGES.rdoc
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+- ext/sqlite3/sqlite3.c
+- ext/sqlite3/backup.c
+- ext/sqlite3/exception.c
+- ext/sqlite3/statement.c
+- ext/sqlite3/database.c
+files:
+- API_CHANGES.rdoc
+- CHANGELOG.rdoc
+- ChangeLog.cvs
+- LICENSE
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- ext/sqlite3/backup.c
+- ext/sqlite3/backup.h
+- ext/sqlite3/database.c
+- ext/sqlite3/database.h
+- ext/sqlite3/exception.c
+- ext/sqlite3/exception.h
+- ext/sqlite3/extconf.rb
+- ext/sqlite3/sqlite3.c
+- ext/sqlite3/sqlite3_ruby.h
+- ext/sqlite3/statement.c
+- ext/sqlite3/statement.h
+- faq/faq.rb
+- faq/faq.yml
+- lib/sqlite3.rb
+- lib/sqlite3/constants.rb
+- lib/sqlite3/database.rb
+- lib/sqlite3/errors.rb
+- lib/sqlite3/pragmas.rb
+- lib/sqlite3/resultset.rb
+- lib/sqlite3/statement.rb
+- lib/sqlite3/translator.rb
+- lib/sqlite3/value.rb
+- lib/sqlite3/version.rb
+- setup.rb
+- tasks/faq.rake
+- tasks/gem.rake
+- tasks/native.rake
+- tasks/vendor_sqlite3.rake
+- test/helper.rb
+- test/test_backup.rb
+- test/test_collation.rb
+- test/test_database.rb
+- test/test_database_readonly.rb
+- test/test_deprecated.rb
+- test/test_encoding.rb
+- test/test_integration.rb
+- test/test_integration_open_close.rb
+- test/test_integration_pending.rb
+- test/test_integration_resultset.rb
+- test/test_integration_statement.rb
+- test/test_sqlite3.rb
+- test/test_statement.rb
+- test/test_statement_execute.rb
+- test/test_result_set.rb
+- .gemtest
+homepage: http://github.com/luislavena/sqlite3-ruby
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: femto-sqlite3
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: This module allows Ruby programs to interface with the SQLite3 database engine
+  (http://www.sqlite.org)
+test_files:
+- test/test_deprecated.rb
+- test/test_integration.rb
+- test/test_integration_statement.rb
+- test/test_collation.rb
+- test/test_database.rb
+- test/test_statement.rb
+- test/test_integration_open_close.rb
+- test/test_result_set.rb
+- test/test_statement_execute.rb
+- test/test_database_readonly.rb
+- test/test_sqlite3.rb
+- test/test_integration_resultset.rb
+- test/test_encoding.rb
+- test/test_backup.rb
+- test/test_integration_pending.rb