dbi 0.4.1 → 0.4.2

data/build/Rakefile.dbi.rb

@@ -13,14 +13,17 @@ end
 task :package         => (map_task("package") + map_task("gem"))
 task :clobber_package => map_task("clobber_package")
 
+desc 'Run interface tests (no database connectivity required)'
 task :test_dbi do
     ruby("test/ts_dbi.rb")
 end
 
+desc 'Run database-specific tests'
 task :test_dbd do
     ruby("test/ts_dbd.rb")
 end
 
+desc 'Run full test suite'
 task :test => [:test_dbi, :test_dbd]
 
 build_dbi_tasks

data/lib/dbi.rb

@@ -90,7 +90,7 @@ Deprecate.set_action(
 
 #++
 module DBI
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
 
     module DBD # :nodoc:
         API_VERSION = "0.3"
@@ -107,6 +107,12 @@ module DBI
     @@trace_output   = DEFAULT_TRACE_OUTPUT
     @@caseless_driver_name_map = nil
     @@convert_types  = true
+    @@last_connection = nil
+
+    # Return the last connection attempted.
+    def self.last_connection
+        @@last_connection
+    end
 
     # Return the current status of type conversion at this level. This status
     # will be propogated to any new DatabaseHandles created.
@@ -139,7 +145,7 @@ module DBI
             dr, db_args = _get_full_driver(driver_url)
             dh = dr[0] # driver-handle
             dh.convert_types = @@convert_types
-            dh.connect(db_args, user, auth, params, &p)
+            @@last_connection = dh.connect(db_args, user, auth, params, &p)
         end
 
         # Load a DBD and returns the DriverHandle object
@@ -255,7 +261,7 @@ module DBI
                         begin
                             require @@caseless_driver_name_map[dc] if @@caseless_driver_name_map[dc]
                         rescue LoadError => e2
-                            raise e.class, "Could not find driver #{driver_name} or #{driver_name.downcase} (error: #{e1.message})"
+                            raise e1.class, "Could not find driver #{driver_name} or #{driver_name.downcase} (error: #{e1.message})"
                         end
                     end
 

data/lib/dbi/handles/database.rb

@@ -9,6 +9,7 @@ module DBI
     # database is not connected.
     class DatabaseHandle < Handle
 
+        attr_accessor :last_statement
         attr_accessor :raise_error
 
         # This is the driver name as supplied by the DBD's driver_name method.
@@ -49,6 +50,7 @@ module DBI
         #
         def prepare(stmt)
             sanity_check(stmt)
+            @last_statement = stmt
             sth = StatementHandle.new(@handle.prepare(stmt), false, true, @convert_types)
             # FIXME trace sth.trace(@trace_mode, @trace_output)
             sth.dbh = self
@@ -71,6 +73,7 @@ module DBI
         def execute(stmt, *bindvars)
             sanity_check(stmt)
 
+            @last_statement = stmt
             if @convert_types
                 bindvars = DBI::Utils::ConvParam.conv_param(driver_name, *bindvars)
             end
@@ -99,6 +102,7 @@ module DBI
         def do(stmt, *bindvars)
             sanity_check(stmt)
 
+            @last_statement = stmt
             @handle.do(stmt, *DBI::Utils::ConvParam.conv_param(driver_name, *bindvars))
         end
 
@@ -131,6 +135,14 @@ module DBI
             return rows
         end
 
+        #
+        # Return the name of the database we are connected to.
+        #
+        def database_name
+            sanity_check
+            @handle.database_name
+        end
+
         #
         # Return the tables available to this DatabaseHandle as an array of strings.
         #

data/lib/dbi/row.rb

@@ -226,8 +226,18 @@ module DBI
             def clone
                 Marshal.load(Marshal.dump(self))
             end
-            
-            alias dup clone
+
+            def dup
+                row = self.class.allocate
+                row.instance_variable_set :@column_types,  @column_types
+                row.instance_variable_set :@convert_types, @convert_types
+                row.instance_variable_set :@column_map,    @column_map
+                row.instance_variable_set :@column_names,  @column_names
+                # this is the only one we actually dup...
+                row.instance_variable_set :@arr,           arr = @arr.dup
+                row.instance_variable_set :@_dc_obj,       arr
+                row
+            end
         end
 
         private

data/lib/dbi/types.rb

@@ -102,19 +102,77 @@ module DBI
         # Represents a SQL TIMESTAMP and returns DateTime. Falls back to Null.
         #
         class Timestamp < Null
+            def self.create(year, month, day, hour, min, sec, usec=0, of=0)
+                # DateTime will remove leap and leap-leap seconds
+                sec = 59 if sec > 59
+                # store this before we modify it
+                civil = year, month, day
+                time  = hour, min, sec, usec
+                if month <= 2
+                    month += 12
+                    year  -= 1
+                end
+                y   = year + 4800
+                m   = month - 3
+                jd  = day + (153 * m + 2) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 32045
+                #fr  = hour / 24.0 + min / 1440.0 + sec / 86400.0
+                # ridiculously, this line does the same thing but twice as fast... :/
+                fr  = ::Time.gm(1970, 1, 1, hour, min, sec, usec).to_f / 86400
+                date = ::DateTime.new!(jd + fr - 0.5, of, ::DateTime::ITALY)
+                prefill_cache date, civil, time
+                date
+            end
+
+            if RUBY_VERSION =~ /^1\.8\./
+                def self.prefill_cache date, civil, time
+                		time[3] /= 86400000000.0
+                    date.instance_variable_set :"@__#{:civil.to_i}__", [civil]
+                    date.instance_variable_set :"@__#{:time.to_i}__",  [time]
+                end
+            else
+                def self.prefill_cache date, civil, time
+                		time[3] /= 1000000.0
+                    date.instance_variable_get(:@__ca__)[:civil.object_id] = civil
+                    date.instance_variable_get(:@__ca__)[:time.object_id] = time
+                end
+            end
+
+            def self.parse_string str
+                # special casing the common formats here gives roughly an
+                # 8-fold speed boost over using Date._parse
+                case str
+                when /^(\d{4})-(\d{2})-(\d{2})(?: (\d{2}):(\d{2}):(\d{2})(\.\d+)?)?(?: ([+-]?\d{2}):?(\d{2}))?$/
+                    parts = $~[1..-4].map { |s| s.to_i }
+                    parts << $7.to_f * 1000000.0
+                    parts << ($8 ? ($8.to_f * 60 + $9.to_i) / 1440 : 0)
+                else
+                    parts = ::Date._parse(str).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset)
+                    # some defaults
+                    today = nil
+                    8.times do |i|
+                        next if parts[i]
+                        today ||= ::Time.now.to_a.values_at(5, 4, 3) + [0, 0, 0, 0, 0]
+                        parts[i] = today[i]
+                    end
+                    parts[6] *= 1000000.0
+                    parts[7] /= 86400.0
+                end
+                parts
+            end
+
             def self.parse(obj)
-                obj = super
-                return obj unless obj
-                case obj.class
+                case obj
                 when ::DateTime
                     return obj
                 when ::Date
-                    return ::DateTime.parse(obj.to_s)
+                    return create(obj.year, obj.month, obj.day, 0, 0, 0)
                 when ::Time
-                    return ::DateTime.parse(obj.to_s)
+                    return create(obj.year, obj.month, obj.day, obj.hour, obj.min, obj.sec, obj.usec, obj.utc_offset / 86400.0)
                 else
-                    return ::DateTime.parse(obj.to_s)   if obj.respond_to? :to_s
-                    return ::DateTime.parse(obj.to_str) if obj.respond_to? :to_str
+                    obj = super
+                    return obj unless obj
+                    return create(*parse_string(obj.to_s))   if obj.respond_to? :to_s
+                    return create(*parse_string(obj.to_str)) if obj.respond_to? :to_str
                     return obj
                 end
             end

data/test/dbi/tc_dbi.rb

@@ -13,127 +13,144 @@ require 'dbi'
 require 'test/unit'
 
 class TC_DBI < Test::Unit::TestCase
-   def setup
-      @db_error  = DBI::DatabaseError.new("test", 1, "montana")
-      @db_binary = DBI::Binary.new("test")
-      @url_basic = 'dbi:foo:bar'
-      @url_inter = 'dbi:foo:bar:host'
-      @url_advan = 'dbi:foo:database=db;host=xx;port=99'
-   end
-
-   def test_dbi_version
-      assert_equal("0.4.1", DBI::VERSION)
-   end
-
-   def test_dbd_module
-      assert_equal("0.3", DBI::DBD::API_VERSION)
-   end
-
-   def test_fetch_scroll_constants
-      assert_equal(1, DBI::SQL_FETCH_NEXT)
-      assert_equal(2, DBI::SQL_FETCH_PRIOR)
-      assert_equal(3, DBI::SQL_FETCH_FIRST)
-      assert_equal(4, DBI::SQL_FETCH_LAST)
-      assert_equal(5, DBI::SQL_FETCH_ABSOLUTE)
-      assert_equal(6, DBI::SQL_FETCH_RELATIVE)
-   end
-
-   def test_sql_type_constants
-      assert_equal(1, DBI::SQL_CHAR)
-      assert_equal(2, DBI::SQL_NUMERIC)
-      assert_equal(3, DBI::SQL_DECIMAL)
-      assert_equal(4, DBI::SQL_INTEGER)
-      assert_equal(5, DBI::SQL_SMALLINT)
-      assert_equal(6, DBI::SQL_FLOAT)
-      assert_equal(7, DBI::SQL_REAL)
-      assert_equal(8, DBI::SQL_DOUBLE)
-      assert_equal(9, DBI::SQL_DATE)
-      assert_equal(10, DBI::SQL_TIME)
-      assert_equal(11, DBI::SQL_TIMESTAMP)
-      assert_equal(12, DBI::SQL_VARCHAR)
-      assert_equal(100, DBI::SQL_OTHER)
-      assert_equal(-1, DBI::SQL_LONGVARCHAR)
-      assert_equal(-2, DBI::SQL_BINARY)
-      assert_equal(-3, DBI::SQL_VARBINARY)
-      assert_equal(-4, DBI::SQL_LONGVARBINARY)
-      assert_equal(-5, DBI::SQL_BIGINT)
-      assert_equal(-6, DBI::SQL_TINYINT)
-      assert_equal(-7, DBI::SQL_BIT)
-      assert_equal(-10, DBI::SQL_BLOB)
-      assert_equal(-11, DBI::SQL_CLOB)
-   end
-
-   def test_sql_type_names
-      assert_equal('BIT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIT])
-      assert_equal('TINYINT', DBI::SQL_TYPE_NAMES[DBI::SQL_TINYINT])
-      assert_equal('SMALLINT', DBI::SQL_TYPE_NAMES[DBI::SQL_SMALLINT])
-      assert_equal('INTEGER', DBI::SQL_TYPE_NAMES[DBI::SQL_INTEGER])
-      assert_equal('BIGINT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIGINT])
-      assert_equal('FLOAT', DBI::SQL_TYPE_NAMES[DBI::SQL_FLOAT])
-      assert_equal('REAL', DBI::SQL_TYPE_NAMES[DBI::SQL_REAL])
-      assert_equal('DOUBLE', DBI::SQL_TYPE_NAMES[DBI::SQL_DOUBLE])
-      assert_equal('NUMERIC', DBI::SQL_TYPE_NAMES[DBI::SQL_NUMERIC])
-      assert_equal('DECIMAL', DBI::SQL_TYPE_NAMES[DBI::SQL_DECIMAL])
-      assert_equal('CHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_CHAR])
-      assert_equal('VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_VARCHAR])
-      assert_equal('LONG VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARCHAR])
-      assert_equal('DATE', DBI::SQL_TYPE_NAMES[DBI::SQL_DATE])
-      assert_equal('TIME', DBI::SQL_TYPE_NAMES[DBI::SQL_TIME])
-      assert_equal('TIMESTAMP', DBI::SQL_TYPE_NAMES[DBI::SQL_TIMESTAMP])
-      assert_equal('BINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_BINARY])
-      assert_equal('VARBINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_VARBINARY])
-      assert_equal('LONG VARBINARY',
-         DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARBINARY])
-      assert_equal('BLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_BLOB])
-      assert_equal('CLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_CLOB])
-      assert_equal(nil, DBI::SQL_TYPE_NAMES[DBI::SQL_OTHER])
-   end
-
-   def test_dbi_exception_classes
-      assert(DBI::Error)
-      assert(DBI::Warning)
-      assert(DBI::InterfaceError)
-      assert(DBI::NotImplementedError)
-      assert(DBI::DatabaseError)
-      assert(DBI::DataError)
-      assert(DBI::OperationalError)
-      assert(DBI::IntegrityError)
-      assert(DBI::InternalError)
-      assert(DBI::ProgrammingError)
-      assert(DBI::NotSupportedError)
-   end
+    def setup
+        @db_error  = DBI::DatabaseError.new("test", 1, "montana")
+        @db_binary = DBI::Binary.new("test")
+        @url_basic = 'dbi:foo:bar'
+        @url_inter = 'dbi:foo:bar:host'
+        @url_advan = 'dbi:foo:database=db;host=xx;port=99'
+    end
+
+    def test_dbi_version
+        assert_equal("0.4.2", DBI::VERSION)
+    end
+
+    def test_dbd_module
+        assert_equal("0.3", DBI::DBD::API_VERSION)
+    end
+
+    def test_fetch_scroll_constants
+        assert_equal(1, DBI::SQL_FETCH_NEXT)
+        assert_equal(2, DBI::SQL_FETCH_PRIOR)
+        assert_equal(3, DBI::SQL_FETCH_FIRST)
+        assert_equal(4, DBI::SQL_FETCH_LAST)
+        assert_equal(5, DBI::SQL_FETCH_ABSOLUTE)
+        assert_equal(6, DBI::SQL_FETCH_RELATIVE)
+    end
+
+    def test_sql_type_constants
+        assert_equal(1, DBI::SQL_CHAR)
+        assert_equal(2, DBI::SQL_NUMERIC)
+        assert_equal(3, DBI::SQL_DECIMAL)
+        assert_equal(4, DBI::SQL_INTEGER)
+        assert_equal(5, DBI::SQL_SMALLINT)
+        assert_equal(6, DBI::SQL_FLOAT)
+        assert_equal(7, DBI::SQL_REAL)
+        assert_equal(8, DBI::SQL_DOUBLE)
+        assert_equal(9, DBI::SQL_DATE)
+        assert_equal(10, DBI::SQL_TIME)
+        assert_equal(11, DBI::SQL_TIMESTAMP)
+        assert_equal(12, DBI::SQL_VARCHAR)
+        assert_equal(100, DBI::SQL_OTHER)
+        assert_equal(-1, DBI::SQL_LONGVARCHAR)
+        assert_equal(-2, DBI::SQL_BINARY)
+        assert_equal(-3, DBI::SQL_VARBINARY)
+        assert_equal(-4, DBI::SQL_LONGVARBINARY)
+        assert_equal(-5, DBI::SQL_BIGINT)
+        assert_equal(-6, DBI::SQL_TINYINT)
+        assert_equal(-7, DBI::SQL_BIT)
+        assert_equal(-10, DBI::SQL_BLOB)
+        assert_equal(-11, DBI::SQL_CLOB)
+    end
+
+    def test_sql_type_names
+        assert_equal('BIT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIT])
+        assert_equal('TINYINT', DBI::SQL_TYPE_NAMES[DBI::SQL_TINYINT])
+        assert_equal('SMALLINT', DBI::SQL_TYPE_NAMES[DBI::SQL_SMALLINT])
+        assert_equal('INTEGER', DBI::SQL_TYPE_NAMES[DBI::SQL_INTEGER])
+        assert_equal('BIGINT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIGINT])
+        assert_equal('FLOAT', DBI::SQL_TYPE_NAMES[DBI::SQL_FLOAT])
+        assert_equal('REAL', DBI::SQL_TYPE_NAMES[DBI::SQL_REAL])
+        assert_equal('DOUBLE', DBI::SQL_TYPE_NAMES[DBI::SQL_DOUBLE])
+        assert_equal('NUMERIC', DBI::SQL_TYPE_NAMES[DBI::SQL_NUMERIC])
+        assert_equal('DECIMAL', DBI::SQL_TYPE_NAMES[DBI::SQL_DECIMAL])
+        assert_equal('CHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_CHAR])
+        assert_equal('VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_VARCHAR])
+        assert_equal('LONG VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARCHAR])
+        assert_equal('DATE', DBI::SQL_TYPE_NAMES[DBI::SQL_DATE])
+        assert_equal('TIME', DBI::SQL_TYPE_NAMES[DBI::SQL_TIME])
+        assert_equal('TIMESTAMP', DBI::SQL_TYPE_NAMES[DBI::SQL_TIMESTAMP])
+        assert_equal('BINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_BINARY])
+        assert_equal('VARBINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_VARBINARY])
+        assert_equal('LONG VARBINARY',
+                     DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARBINARY])
+        assert_equal('BLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_BLOB])
+        assert_equal('CLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_CLOB])
+        assert_equal(nil, DBI::SQL_TYPE_NAMES[DBI::SQL_OTHER])
+    end
+
+    def test_dbi_exception_classes
+        assert(DBI::Error)
+        assert(DBI::Warning)
+        assert(DBI::InterfaceError)
+        assert(DBI::NotImplementedError)
+        assert(DBI::DatabaseError)
+        assert(DBI::DataError)
+        assert(DBI::OperationalError)
+        assert(DBI::IntegrityError)
+        assert(DBI::InternalError)
+        assert(DBI::ProgrammingError)
+        assert(DBI::NotSupportedError)
+    end
 
    # This error class gets extra testing since it defines some custom
    # accessors.
    def test_dbi_database_error
-      assert_respond_to(@db_error, :errstr)
-      assert_respond_to(@db_error, :err)
-      assert_respond_to(@db_error, :state)
-      assert_equal("test", @db_error.errstr)
-      assert_equal(1, @db_error.err)
-      assert_equal("montana", @db_error.state)
+       assert_respond_to(@db_error, :errstr)
+       assert_respond_to(@db_error, :err)
+       assert_respond_to(@db_error, :state)
+       assert_equal("test", @db_error.errstr)
+       assert_equal(1, @db_error.err)
+       assert_equal("montana", @db_error.state)
    end
 
    def test_binary_datatype
-      assert_respond_to(@db_binary, :data)
-      assert_respond_to(@db_binary, :to_s)
-      assert_equal("test", @db_binary.data)
-      assert_equal("test", @db_binary.to_s)
+       assert_respond_to(@db_binary, :data)
+       assert_respond_to(@db_binary, :to_s)
+       assert_equal("test", @db_binary.data)
+       assert_equal("test", @db_binary.to_s)
    end
 
    def test_misc_constants
-      assert_equal(2, DBI::DEFAULT_TRACE_MODE)
-      assert_equal(STDERR, DBI::DEFAULT_TRACE_OUTPUT)
+       assert_equal(2, DBI::DEFAULT_TRACE_MODE)
+       assert_equal(STDERR, DBI::DEFAULT_TRACE_OUTPUT)
    end
 
-   def test_connect
-      assert_respond_to(DBI, :connect)
+   def test_last_connection
+       assert_respond_to(DBI, :last_connection)
    end
 
-   def test_available_drivers
-      assert_respond_to(DBI, :available_drivers)
+   def test_convert_types
+       assert_respond_to(DBI, :convert_types)
+       assert_respond_to(DBI, :convert_types=)
+   end
+
+   def test_connect
+       assert_respond_to(DBI, :connect)
    end
    
+   def test_available_drivers
+       assert_respond_to(DBI, :available_drivers)
+       assert_equal(
+       [
+            "dbi:Mysql:",
+            "dbi:ODBC:",
+            "dbi:Pg:",
+            "dbi:SQLite3:",
+            "dbi:SQLite:"
+       ], DBI.available_drivers.sort)
+   end
+
    # PRIVATE METHODS
    def test_parse_url
       assert_nothing_raised{ DBI.send(:parse_url, "dbi:foo:bar") }
@@ -160,17 +177,6 @@ class TC_DBI < Test::Unit::TestCase
       end
    end
 
-   def test_available_drivers
-       assert_equal(
-       [
-            "dbi:Mysql:",
-            "dbi:ODBC:",
-            "dbi:Pg:",
-            "dbi:SQLite3:",
-            "dbi:SQLite:"
-       ], DBI.available_drivers.sort)
-   end
-
    def teardown
       @db_error  = nil
       @db_binary = nil

data/test/dbi/tc_types.rb

@@ -109,10 +109,10 @@ class TC_DBI_Type < Test::Unit::TestCase
         assert_equal(dt.to_s, klass.parse(dt).to_s)
         
         t = Time.now
-        assert_equal(DateTime.parse(t.to_s), klass.parse(t))
+        assert_equal(DateTime.parse(t.to_s).to_s, klass.parse(t).to_s)
 
         d = Date.today
-        assert_equal(DateTime.parse(d.to_s), klass.parse(d))
+        assert_equal(DateTime.parse(d.to_s).to_s, klass.parse(d).to_s)
 
         md = "10-11"
 

metadata

@@ -1,100 +1,107 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: dbi
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
-date: 2008-11-28 00:00:00 -08:00
-summary: A vendor independent interface for accessing databases, similar to Perl's DBI
-require_paths: 
-- lib
-email: ruby-dbi-users@rubyforge.org
-homepage: http://www.rubyforge.org/projects/ruby-dbi
-rubyforge_project: ruby-dbi
-description: A vendor independent interface for accessing databases, similar to Perl's 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: 0.4.2
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Erik Hollensbe
 - Christopher Maujean
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: deprecated
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: A vendor independent interface for accessing databases, similar to Perl's DBI
+email: ruby-dbi-users@rubyforge.org
+executables: 
+- dbi
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- ChangeLog
 files: 
-- examples/test1.pl
 - examples/test1.rb
+- examples/test1.pl
 - examples/xmltest.rb
 - bin/dbi
 - build/Rakefile.dbi.rb
 - lib/dbi.rb
-- lib/dbi/row.rb
-- lib/dbi/columninfo.rb
-- lib/dbi/sql/preparedstatement.rb
-- lib/dbi/typeutil.rb
-- lib/dbi/utils/time.rb
-- lib/dbi/utils/xmlformatter.rb
 - lib/dbi/utils/timestamp.rb
+- lib/dbi/utils/xmlformatter.rb
 - lib/dbi/utils/date.rb
+- lib/dbi/utils/time.rb
 - lib/dbi/utils/tableformatter.rb
-- lib/dbi/binary.rb
+- lib/dbi/handles/database.rb
+- lib/dbi/handles/driver.rb
+- lib/dbi/handles/statement.rb
+- lib/dbi/handles.rb
+- lib/dbi/trace.rb
+- lib/dbi/exceptions.rb
+- lib/dbi/sql/preparedstatement.rb
+- lib/dbi/base_classes.rb
 - lib/dbi/base_classes/database.rb
 - lib/dbi/base_classes/driver.rb
 - lib/dbi/base_classes/statement.rb
+- lib/dbi/typeutil.rb
 - lib/dbi/sql_type_constants.rb
-- lib/dbi/handles.rb
-- lib/dbi/exceptions.rb
+- lib/dbi/row.rb
 - lib/dbi/types.rb
-- lib/dbi/trace.rb
-- lib/dbi/base_classes.rb
+- lib/dbi/binary.rb
 - lib/dbi/utils.rb
+- lib/dbi/columninfo.rb
 - lib/dbi/sql.rb
-- lib/dbi/handles/database.rb
-- lib/dbi/handles/driver.rb
-- lib/dbi/handles/statement.rb
 - test/ts_dbi.rb
+- test/dbi/tc_date.rb
 - test/dbi/tc_time.rb
-- test/dbi/tc_row.rb
-- test/dbi/tc_dbi.rb
-- test/dbi/tc_statementhandle.rb
 - test/dbi/tc_sqlbind.rb
-- test/dbi/tc_columninfo.rb
-- test/dbi/trace.rb
+- test/dbi/tc_dbi.rb
+- test/dbi/tc_row.rb
 - test/dbi/tc_timestamp.rb
+- test/dbi/tc_statementhandle.rb
 - test/dbi/tc_types.rb
-- test/dbi/tc_date.rb
+- test/dbi/tc_columninfo.rb
 - README
 - LICENSE
 - ChangeLog
-test_files: 
-- test/ts_dbi.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/ruby-dbi
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- README
-- LICENSE
-- ChangeLog
-executables: 
-- dbi
-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: deprecated
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.0.0
-    version: 
+rubyforge_project: ruby-dbi
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A vendor independent interface for accessing databases, similar to Perl's DBI
+test_files: 
+- test/ts_dbi.rb

data/test/dbi/trace.rb

@@ -1,26 +0,0 @@
-$;.unshift('lib')
-require "dbi/trace"
-require 'stringio'
-require "test/unit"
-
-$stringio = StringIO.new
-
-class TC_DBI_Trace < Test::Unit::TestCase
-    def setup
-        $stringio = StringIO.new
-    end
-end
-
-class DBI::DBD::Dummy
-    class Database < DBI::BaseDatabase
-        DBI::BaseDatabase.instance_methods.each do |x|
-            next if x.to_sym == :initialize
-            define_method(x.to_sym) do |*args|
-                $stringio << "[test] call:#{x} args:#{args.inspect}"
-            end
-        end
-
-        def initialize
-        end
-    end
-end