dbd-sqlite3 1.2.3 → 1.2.4

data/lib/dbd/SQLite3.rb

@@ -1,18 +1,18 @@
 #--
 # DBD::SQLite3
-# 
+#
 # copyright (c) 2005 Jun Mukai <mukai@jmuk.org>
 # Compatibility patches by Erik Hollensbe <erik@hollensbe.org>
-# 
+#
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without 
-# modification, are permitted provided that the following conditions 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
 # are met:
-# 1. Redistributions of source code must retain the above copyright 
+# 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright 
-#    notice, this list of conditions and the following disclaimer in the 
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
 # 3. The name of the author may not be used to endorse or promote products
 #    derived from this software without specific prior written permission.
@@ -50,7 +50,7 @@ module DBI
         # Only things that extend DBI's results are documented.
         #
         module SQLite3
-            VERSION = "1.2.3"
+            VERSION = "1.2.4"
             DESCRIPTION = "SQLite 3.x DBD for DBI"
 
             #
@@ -70,9 +70,9 @@ module DBI
             # It will raise DBI::DatabaseError should it find any.
             #
             def self.parse_type(type_name)
-                # FIXME plucked from SQLite driver, this needs to be in DBI proper 
+                # FIXME plucked from SQLite driver, this needs to be in DBI proper
                 return ['varchar'] unless type_name
-                type_name.match(/^([^\(]+)(\((\d+)(,(\d+))?\))?$/)
+                type_name.match(/^([^\(\s]+)\s*(\(\s*(\d+)\s*(,\s*(\d+))?\s*\))?$/)
             end
 
             #

data/test/DBD_TESTS

@@ -2,6 +2,8 @@
 Using DBD tests
 ================================================================================
 
+Before you do anything, read the TESTING file.
+
 Create a YAML file named .ruby-dbi.test-config.yaml in your home directory.
 
 This file is a hash of keys that determine what you want to test and how you

data/test/dbd/general/test_database.rb

@@ -1,4 +1,15 @@
 @class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+
+    def test_empty_query
+        ["", " ", "\t"].each do |str|
+            [:do, :prepare, :execute, :select_one, :select_all].each do |call|
+                assert_raises(DBI::InterfaceError) do
+                    @dbh.send(call, str)
+                end
+            end
+        end
+    end
+
     def test_ping
         assert @dbh.ping
         # XXX if it isn't obvious, this should be tested better. Not sure what
@@ -11,7 +22,7 @@
 
             assert(cols)
             assert_kind_of(Array, cols)
-            assert_equal(2, cols.length)
+            assert_equal(4, cols.length)
 
             # the first column should always be "text_field" and have the following
             # properties:
@@ -30,19 +41,42 @@
             end
 
             assert_equal(
-                DBI::Type::Varchar, 
-                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"])
+                DBI::Type::Varchar.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"]).object_id
             )
 
             # the second column should always be "integer_field" and have the following
             # properties:
             assert_equal("integer_field", cols[1]["name"])
             assert(cols[1]["nullable"])
-            assert_equal(1, cols[1]["scale"])
-            assert_equal(2, cols[1]["precision"])
+            assert_equal(1, cols[2]["scale"])
+            assert_equal(2, cols[2]["precision"])
+
+            assert_equal(
+                DBI::Type::Integer.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"]).object_id
+            )
+
+            # the second column should always be "integer_field" and have the following
+            # properties:
+            assert_equal("decimal_field", cols[2]["name"])
+            assert(cols[2]["nullable"])
+            assert_equal(1, cols[2]["scale"])
+            assert_equal(2, cols[2]["precision"])
             assert_equal(
-                DBI::Type::Decimal, 
-                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"])
+                DBI::Type::Decimal.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[2]["type_name"]).object_id
+            )
+
+            # the second column should always be "numeric_field" and have the following
+            # properties:
+            assert_equal("numeric_field", cols[3]["name"])
+            assert(cols[3]["nullable"])
+            assert_equal(6, cols[3]["scale"])
+            assert_equal(30, cols[3]["precision"])
+            assert_equal(
+                DBI::Type::Decimal.object_id,
+                DBI::TypeUtil.type_name_to_module(cols[3]["type_name"]).object_id
             )
 
             # finally, we ensure that every column in the array is a ColumnInfo
@@ -123,11 +157,13 @@
                 "views"
             ]
         end
-        
-        case dbtype 
+
+        case dbtype
         when "postgresql"
             tables.reject! { |x| x =~ /^pg_/ }
-            assert_equal %w(array_test bit_test blob_test boolean_test bytea_test db_specific_types_test field_types_test names precision_test time_test timestamp_test view_names), tables
+            assert_equal %w(array_test bit_test blob_test boolean_test bytea_test db_specific_types_test enum_type_test field_types_test names precision_test time_test timestamp_test view_names), tables
+        when 'sqlite3'
+            assert_equal %w(bit_test blob_test boolean_test db_specific_types_test field_types_test names names_defined_with_spaces precision_test time_test timestamp_test view_names), tables
         else
             assert_equal %w(bit_test blob_test boolean_test db_specific_types_test field_types_test names precision_test time_test timestamp_test view_names), tables
         end
@@ -142,13 +178,13 @@
         assert !@dbh["AutoCommit"]
 
         # test committing an outstanding transaction
-        
+
         @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
         @sth.execute("Billy", 22)
         @sth.finish
 
         assert @dbh["AutoCommit"] = true # should commit at this point
-        
+
         @sth = @dbh.prepare("select * from names where name = ?")
         @sth.execute("Billy")
         assert_equal [ "Billy", 22 ], @sth.fetch

data/test/dbd/general/test_statement.rb

@@ -1,4 +1,50 @@
 @class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+   
+    def prep_status_statement
+        @sth.finish if (@sth and !@sth.finished?)
+        @sth = @dbh.prepare("select * from names order by age")
+        @sth.raise_error = true
+    end
+
+    def test_status
+        names_rc = 3
+
+        [:fetch, :fetch_hash, :each, :fetch_all].each do |call|
+            assert_raise(DBI::InterfaceError, DBI::NotSupportedError) do
+                prep_status_statement
+                @sth.send(call)
+            end
+        end
+        
+        # for these next three, it doesn't really matter what the args are, it should fail
+        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
+            prep_status_statement
+            @sth.fetch_many(1) 
+        end
+
+        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
+            prep_status_statement
+            @sth.fetch_scroll(0, 0)
+        end
+
+        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
+            prep_status_statement
+            @sth.each { |x| }
+        end
+
+        assert_raises(DBI::InterfaceError) do
+            prep_status_statement
+            @sth.execute
+            2.times { @sth.fetch_all }
+        end
+
+        assert_raises(DBI::InterfaceError) do
+            prep_status_statement
+            @sth.execute
+            # XXX fetch_many won't know it can't fetch anything until the third time around.
+            3.times { @sth.fetch_many(names_rc) }
+        end
+    end
 
     def test_execute
         assert_nothing_raised do
@@ -44,7 +90,7 @@
 
             assert(cols)
             assert_kind_of(Array, cols)
-            assert_equal(2, cols.length)
+            assert_equal(4, cols.length)
             
             # the first column should always be "text_field" and have the following
             # properties:
@@ -61,18 +107,49 @@
             end
                 
             assert_equal(
-                DBI::Type::Varchar, 
-                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"])
+                DBI::Type::Varchar.object_id, 
+                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"]).object_id
             )
 
             # the second column should always be "integer_field" and have the following
             # properties:
             assert_equal("integer_field", cols[1]["name"])
-            assert_equal(1, cols[1]["scale"])
-            assert_equal(2, cols[1]["precision"])
+            # if these aren't set on the field, they should not exist
+            # FIXME mysql does not follow this rule, neither does ODBC
+            if dbtype == "mysql" 
+                assert_equal(0, cols[1]["scale"])
+                assert_equal(11, cols[1]["precision"])
+            elsif dbtype == "odbc"
+                assert_equal(0, cols[1]["scale"])
+                assert_equal(10, cols[1]["precision"])
+            else
+                assert(!cols[1]["scale"])
+                assert(!cols[1]["precision"])
+            end
+
+            assert_equal(
+                DBI::Type::Integer.object_id, 
+                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"]).object_id
+            )
+
+            # the second column should always be "integer_field" and have the following
+            # properties:
+            assert_equal("decimal_field", cols[2]["name"])
+            assert_equal(1, cols[2]["scale"])
+            assert_equal(2, cols[2]["precision"])
+            assert_equal(
+                DBI::Type::Decimal.object_id, 
+                DBI::TypeUtil.type_name_to_module(cols[2]["type_name"]).object_id
+            )
+
+            # the second column should always be "numeric_field" and have the following
+            # properties:
+            assert_equal("numeric_field", cols[3]["name"])
+            assert_equal(6, cols[3]["scale"])
+            assert_equal(30, cols[3]["precision"])
             assert_equal(
-                DBI::Type::Decimal, 
-                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"])
+                DBI::Type::Decimal.object_id, 
+                DBI::TypeUtil.type_name_to_module(cols[3]["type_name"]).object_id
             )
 
             cols.each { |col| assert_kind_of(DBI::ColumnInfo, col) }

data/test/dbd/general/test_types.rb

@@ -25,6 +25,34 @@
         end
     end
 
+    def test_numeric_types
+        assert(@dbh.convert_types)
+
+        @sth = @dbh.prepare("insert into precision_test (text_field, integer_field, decimal_field, numeric_field) values (?, ?, ?, ?)")
+        assert(@sth.convert_types)
+        1.step(5) do |x|
+            @sth.execute("poop#{x}", x, x + 0.123, x + 0.234)
+        end
+
+        @sth.finish
+
+        @sth = @dbh.prepare("select integer_field, decimal_field, numeric_field from precision_test")
+        @sth.execute
+        col_info = @sth.column_info
+        1.step(5) do |x|
+            row = @sth.fetch
+
+            assert_kind_of(Integer, row[0])
+            assert_kind_of(BigDecimal, row[1])
+            assert_kind_of(BigDecimal, row[2])
+
+            # FIXME BigDecimal requires a string and some databases will pad
+            # decimal/numeric with constrained precision. We should account for
+            # this, but I'm not quite sure how yet.
+        end
+        @sth.finish
+    end
+
     # FIXME
     # Ideally, this test should be split across the DBI tests and DBD, but for
     # now testing against the DBDs really doesn't cost us anything other than
@@ -62,9 +90,9 @@
         @sth = @dbh.prepare("select name, age from names order by age")
 
         # can't bind_coltype before execute
-        assert_raise(DBI::InterfaceError) { @sth.bind_coltype(1, DBI::Type::Float) }
+        assert_raises(DBI::InterfaceError) { @sth.bind_coltype(1, DBI::Type::Float) }
         # can't index < 1
-        assert_raise(DBI::InterfaceError) { @sth.bind_coltype(0, DBI::Type::Float) }
+        assert_raises(DBI::InterfaceError) { @sth.bind_coltype(0, DBI::Type::Float) }
     end
 
     def test_noconv

data/test/dbd/sqlite3/base.rb

@@ -1,4 +1,3 @@
-require 'test/unit'
 require 'fileutils'
 
 DBDConfig.set_testbase(:sqlite3, Class.new(Test::Unit::TestCase) do

data/test/dbd/sqlite3/test_database.rb

@@ -21,6 +21,51 @@ class TestDatabase < DBDConfig.testbase(:sqlite3)
                 :sql_type  => 4,
                 :type_name => "integer"
             }
-        ], @dbh.columns("names")  
+        ], @dbh.columns("names")
+
+        assert_equal [
+            {
+                :name      => "name",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 100,
+                :precision => 255,
+                :type_name => "varchar"
+            },
+            {
+                :name      => "age",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 4,
+                :type_name => "integer"
+            }
+        ], @dbh.columns("names_defined_with_spaces")
+    end
+    
+    def test_parse_type
+      # Some tests to ensure various whitespace and case styles don't confuse parse_type.
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR(4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'varchar(4096)' )
+      assert_equal 'varchar', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR ( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR (4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
     end
 end

data/test/dbd/sqlite3/test_driver.rb

@@ -18,17 +18,17 @@ class TestDriver < DBDConfig.testbase(:sqlite3)
         assert_kind_of DBI::DatabaseHandle, dbh
 
         # first argument should be a string
-        assert_raise(DBI::InterfaceError) do
+        assert_raises(DBI::InterfaceError) do
             DBI::DBD::SQLite3::Driver.new.connect(nil, nil, nil, { })
         end
 
         # that string should have some frackin' length
-        assert_raise(DBI::InterfaceError) do
+        assert_raises(DBI::InterfaceError) do
             DBI::DBD::SQLite3::Driver.new.connect("", nil, nil, { })
         end
 
         # last argument should be a hash
-        assert_raise(DBI::InterfaceError) do
+        assert_raises(DBI::InterfaceError) do
             DBI::DBD::SQLite3::Driver.new.connect(config['dbname'], nil, nil, nil)
         end
 

data/test/dbd/sqlite3/test_statement.rb

@@ -20,7 +20,7 @@ class TestStatement < DBDConfig.testbase(:sqlite3)
     def test_bind_param
         sth = DBI::DBD::SQLite3::Statement.new("select * from names", @dbh.instance_variable_get("@handle").instance_variable_get("@db"))
 
-        assert_raise(DBI::InterfaceError) do
+        assert_raises(DBI::InterfaceError) do
             sth.bind_param(:foo, "monkeys")
         end
 
@@ -59,6 +59,7 @@ class TestStatement < DBDConfig.testbase(:sqlite3)
         assert_nothing_raised do
             @sth = @dbh.prepare("insert into db_specific_types_test (dbl) values (?)")
             @sth.execute(11111111.111111)
+            @sth.execute(22)
             @sth.finish
         end
 
@@ -66,7 +67,10 @@ class TestStatement < DBDConfig.testbase(:sqlite3)
             @sth = @dbh.prepare("select * from db_specific_types_test")
             @sth.execute
             assert_equal([11111111.111111], @sth.fetch)
+            assert_equal([22], @sth.fetch)
             @sth.finish
+
+            assert_equal([[11111111.111111], [22]], @dbh.select_all("select * from db_specific_types_test"))
         end
     end
 end

data/test/dbd/sqlite3/up.sql

@@ -6,7 +6,7 @@ insert into names (name, age) values ("Joe", 19);
 ---
 insert into names (name, age) values ("Jim", 30);
 ---
-create table precision_test (text_field varchar(20) primary key not null, integer_field decimal(2,1));
+create table precision_test (text_field varchar(20) primary key not null, integer_field integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
 ---
 create view view_names as select * from names;
 ---
@@ -23,3 +23,11 @@ create table bit_test (mybit bit);
 create table field_types_test (foo integer not null primary key default 1);
 ---
 create table db_specific_types_test (dbl double);
+---
+create table names_defined_with_spaces ( name varchar( 255 ), age integer );
+---
+insert into names_defined_with_spaces (name, age) values ("Bob", 21);
+---
+insert into names_defined_with_spaces (name, age) values ("Joe", 19);
+---
+insert into names_defined_with_spaces (name, age) values ("Jim", 30);

data/test/ts_dbd.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+gem 'test-unit'
 # figure out what tests to run
 require 'yaml'
 require 'test/unit/testsuite'
@@ -17,6 +19,16 @@ module Test::Unit::Assertions
     end
 end
 
+class Class
+    def name=(klass_name)
+        @name = klass_name
+    end
+
+    def name
+        return @name || super
+    end
+end
+
 module DBDConfig
     @testbase = { }
     @current_dbtype = nil
@@ -68,6 +80,7 @@ module DBDConfig
 
     def self.set_testbase(klass_name, klass)
         @testbase[klass_name] = klass
+        klass.name = klass_name.to_s
     end
 
     def self.suite
@@ -110,7 +123,7 @@ if __FILE__ == $0
             Dir["dbd/#{dbtype}/test*.rb"].each { |file| require file }
             # run the general tests
             DBDConfig.current_dbtype = dbtype.to_sym
-            Dir["dbd/general/test*.rb"].each { |file| load file; DBDConfig.suite << @class }
+            Dir["dbd/general/test*.rb"].each { |file| load file; @class.name = file; DBDConfig.suite << @class }
         end
     elsif !config["dbtypes"]
         warn "Please see test/DBD_TESTS for information on configuring DBD tests."

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: dbd-sqlite3
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
-date: 2008-09-27 00:00:00 -07:00
-summary: SQLite 3.x DBD for DBI
-require_paths: 
-- lib
-email: ruby-dbi-users@rubyforge.org
-homepage: http://www.rubyforge.org/projects/ruby-dbi
-rubyforge_project: ruby-dbi
-description: SQLite 3.x DBD for DBI
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.0
-  version: 
+  version: 1.2.4
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Erik Hollensbe
 - Christopher Maujean
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dbi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: SQLite 3.x DBD for DBI
+email: ruby-dbi-users@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- ChangeLog
 files: 
-- test/dbd/general/test_database.rb
-- test/dbd/general/test_statement.rb
 - test/dbd/general/test_types.rb
+- test/dbd/general/test_statement.rb
+- test/dbd/general/test_database.rb
 - test/dbd/sqlite3/base.rb
-- test/dbd/sqlite3/test_database.rb
 - test/dbd/sqlite3/test_statement.rb
 - test/dbd/sqlite3/test_driver.rb
 - test/dbd/sqlite3/up.sql
+- test/dbd/sqlite3/test_database.rb
 - lib/dbd/SQLite3.rb
 - lib/dbd/sqlite3/database.rb
 - lib/dbd/sqlite3/statement.rb
@@ -45,36 +59,31 @@ files:
 - README
 - LICENSE
 - ChangeLog
-test_files: 
-- test/ts_dbd.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/ruby-dbi
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- README
-- LICENSE
-- ChangeLog
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: dbi
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.4.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: sqlite3-ruby
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
-    version: 
+rubyforge_project: ruby-dbi
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: SQLite 3.x DBD for DBI
+test_files: 
+- test/ts_dbd.rb