dbd-odbc 0.2.2

data/test/dbd/general/test_types.rb

@@ -0,0 +1,253 @@
+@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
+    def skip_bit
+        # FIXME this test fails because DBI's type system blows goats.
+       @sth = nil
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into bit_test (mybit) values (?)")
+            @sth.bind_param(1, 0, DBI::SQL_TINYINT)
+            @sth.execute
+#             if dbtype == "postgresql"
+#                 @sth.execute("0")
+#             else
+#                 @sth.execute(0)
+#             end
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from bit_test")
+            @sth.execute
+            row = @sth.fetch
+            @sth.finish
+
+            assert_equal [0], row
+        end
+    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
+    # debugging time if something breaks.
+    def test_bind_coltype
+        # ensure type conv didn't get turned off somewhere.
+        assert(DBI.convert_types)
+        assert(@dbh.convert_types)
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select name, age from names order by age")
+            assert(@sth.convert_types) # again
+            @sth.execute
+            @sth.bind_coltype(2, DBI::Type::Varchar)
+            assert_equal(
+                [
+                    ["Joe", "19"], 
+                    ["Bob", "21"],
+                    ["Jim", "30"], 
+                ], @sth.fetch_all
+            )
+            @sth.finish
+        end
+
+        # just to be sure..
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select name, age from names order by age")
+            @sth.execute
+            @sth.bind_coltype(2, DBI::Type::Float)
+            @sth.fetch_all.collect { |x| assert_kind_of(Float, x[1]) }
+            @sth.finish
+        end
+
+        # now, let's check some failure cases
+        @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) }
+        # can't index < 1
+        assert_raise(DBI::InterfaceError) { @sth.bind_coltype(0, DBI::Type::Float) }
+    end
+
+    def test_noconv
+        # XXX this test will fail the whole test suite miserably if it fails at any point.
+        assert(DBI.convert_types)
+
+        DBI.convert_types = false
+        @sth.finish rescue nil
+        @dbh.disconnect
+        set_base_dbh
+
+        assert(!@dbh.convert_types)
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names order by age")
+            assert(!@sth.convert_types)
+            @sth.execute
+            assert_equal(
+                [
+                    ["Joe", "19"], 
+                    ["Bob", "21"],
+                    ["Jim", "30"], 
+                ], @sth.fetch_all
+            )
+            @sth.finish
+        end
+
+        DBI.convert_types = true
+        @sth.finish rescue nil
+        @dbh.disconnect
+        set_base_dbh
+
+        assert(DBI.convert_types)
+        assert(@dbh.convert_types)
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names order by age")
+            assert(@sth.convert_types)
+            @sth.execute
+            assert_equal(
+                [
+                    ["Joe", 19], 
+                    ["Bob", 21],
+                    ["Jim", 30], 
+                ], @sth.fetch_all
+            )
+            @sth.finish
+        end
+
+        @dbh.convert_types = false
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names order by age")
+            assert(!@sth.convert_types)
+            @sth.execute
+            assert_equal(
+                [
+                    ["Joe", "19"], 
+                    ["Bob", "21"],
+                    ["Jim", "30"], 
+                ], @sth.fetch_all
+            )
+            @sth.finish
+        end
+
+        @dbh.convert_types = true
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names order by age")
+            assert(@sth.convert_types)
+            @sth.convert_types = false
+            @sth.execute
+            assert_equal(
+                [
+                    ["Joe", "19"], 
+                    ["Bob", "21"],
+                    ["Jim", "30"], 
+                ], @sth.fetch_all
+            )
+            @sth.finish
+        end
+    rescue Exception => e
+        DBI.convert_types = true
+        @sth.finish
+        @dbh.disconnect
+        set_base_dbh
+        raise e
+    end
+
+    def test_null
+        assert_nothing_raised do
+            @sth = @dbh.prepare('insert into names (name, age) values (?, ?)')
+            @sth.execute("'NULL'", 201)
+            @sth.execute(nil, 202)
+            @sth.execute("NULL", 203)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare('select * from names where age > 200 order by age')
+            @sth.execute
+            assert_equal(["'NULL'", 201], @sth.fetch)
+            assert_equal([nil, 202], @sth.fetch)
+            assert_equal(["NULL", 203], @sth.fetch)
+            @sth.finish
+        end
+    end
+
+    def test_time
+        @sth = nil
+        t = nil
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into time_test (mytime) values (?)")
+            t = Time.now
+            @sth.execute(t)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from time_test")
+            @sth.execute
+            row = @sth.fetch
+            assert_kind_of DateTime, row[0]
+            assert_equal t.hour, row[0].hour
+            assert_equal t.min, row[0].min
+            assert_equal t.sec, row[0].sec
+            @sth.finish
+        end
+    end
+
+    def test_timestamp
+        @sth = nil
+         # We omit fractional second testing here -- timestamp precision
+         # is a very slippery, dependent on driver and driver version.
+        t = DBI::Timestamp.new(2008, 3, 8, 10, 39, 1)
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into timestamp_test (mytimestamp) values (?)")
+            @sth.execute(t)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from timestamp_test")
+            @sth.execute
+            row = @sth.fetch
+            assert_kind_of DateTime, row[0]
+            assert_equal t.year, row[0].year
+            assert_equal t.month, row[0].month
+            assert_equal t.day, row[0].day
+            assert_equal t.hour, row[0].hour
+            assert_equal t.min, row[0].min
+            assert_equal t.sec, row[0].sec
+             # omit fractional tests
+            @sth.finish
+        end
+    end
+
+    def test_boolean_return
+        @sth = nil
+
+        unless dbtype == "odbc" # ODBC has no boolean type
+            assert_nothing_raised do
+                @sth = @dbh.prepare("insert into boolean_test (num, mybool) values (?, ?)")
+                @sth.execute(1, true)
+                @sth.execute(2, false)
+                @sth.finish
+            end
+
+            assert_nothing_raised do
+                @sth = @dbh.prepare("select * from boolean_test order by num")
+                @sth.execute
+
+                pairs = @sth.fetch_all
+
+                assert_equal(
+                    [
+                                 [1, true],
+                                 [2, false],
+                    ], pairs
+                )
+
+                @sth.finish
+            end
+        end
+    end
+end

data/test/dbd/odbc/base.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'fileutils'
+
+DBDConfig.set_testbase(:odbc, Class.new(Test::Unit::TestCase) do
+        
+        def dbtype
+            "odbc"
+        end
+
+        def test_base
+            assert_equal(@dbh.driver_name, "odbc")
+            assert_kind_of(DBI::DBD::ODBC::Database, @dbh.instance_variable_get(:@handle))
+        end
+        
+        def set_base_dbh
+            config = DBDConfig.get_config['odbc']
+            @dbh = DBI.connect("dbi:ODBC:#{config['dbname']}", config['username'], config['password'])
+        end
+
+        def setup
+            set_base_dbh
+            DBDConfig.inject_sql(@dbh, dbtype, "dbd/odbc/up.sql")
+        end
+
+        def teardown
+            @sth.finish if @sth && !@sth.finished?
+            DBDConfig.inject_sql(@dbh, dbtype, "dbd/odbc/down.sql")
+            @dbh.disconnect
+        end
+    end
+)

data/test/dbd/odbc/down.sql

@@ -0,0 +1,17 @@
+drop view view_names;
+---
+drop table names;
+---
+drop table blob_test;
+---
+drop table boolean_test;
+---
+drop table time_test;
+---
+drop table timestamp_test;
+---
+drop table bit_test;
+---
+drop table field_types_test;
+---
+drop table precision_test;

data/test/dbd/odbc/test_ping.rb

@@ -0,0 +1,10 @@
+class TestODBCPing < DBDConfig.testbase(:odbc)
+    def test_ping
+        config = DBDConfig.get_config['odbc']
+        dbh = DBI.connect("dbi:Pg:#{config['dbname']}", config['username'], config['password'])
+        assert dbh
+        assert dbh.ping
+        dbh.disconnect
+        assert_raise(DBI::InterfaceError) { dbh.ping }
+    end
+end

data/test/dbd/odbc/test_statement.rb

@@ -0,0 +1,42 @@
+class TestODBCStatement < DBDConfig.testbase(:odbc)
+    def test_column_info
+        sth = nil
+        
+        assert_nothing_raised do 
+            sth = @dbh.prepare("select * from names")
+            sth.execute
+        end
+
+        assert_kind_of Array, sth.column_info 
+        assert_kind_of DBI::ColumnInfo, sth.column_info[0]
+        assert_kind_of DBI::ColumnInfo, sth.column_info[1]
+        assert_equal [
+            {
+                :table=>"names", 
+                :precision=>255, 
+                :searchable=>true, 
+                :name=>"name", 
+                :unsigned=>true, 
+                :length=>255, 
+                :sql_type=>12, 
+                :scale=>0, 
+                :nullable=>true, 
+                :type_name=>"VARCHAR"
+            },
+            {
+                :table=>"names", 
+                :precision=>10, 
+                :searchable=>true, 
+                :name=>"age", 
+                :unsigned=>false, 
+                :length=>4, 
+                :sql_type=>4, 
+                :scale=>0, 
+                :nullable=>true, 
+                :type_name=>"INTEGER"
+            }
+        ], sth.column_info
+
+        sth.finish
+    end
+end

data/test/dbd/odbc/test_transactions.rb

@@ -0,0 +1,58 @@
+class TestODBCTransaction < DBDConfig.testbase(:odbc)
+    def test_rollback
+        dbh = get_dbh
+        dbh["AutoCommit"] = false
+        @sth = dbh.prepare('insert into names (name, age) values (?, ?)')
+        @sth.execute("Foo", 51)
+        dbh.rollback
+        assert_equal 1, @sth.rows
+        @sth.finish
+
+
+        @sth = dbh.prepare('select name, age from names where name=?')
+        @sth.execute("Foo")
+        assert !@sth.fetch
+        @sth.finish
+        dbh.disconnect 
+    end
+
+    def test_commit
+        dbh = get_dbh
+        dbh["AutoCommit"] = false
+        @sth = dbh.prepare('insert into names (name, age) values (?, ?)')
+        @sth.execute("Foo", 51)
+        dbh.commit
+        assert_equal 1, @sth.rows
+        @sth.finish
+        
+        @sth = dbh.prepare('select name, age from names where name=?')
+        @sth.execute("Foo")
+        row = @sth.fetch
+        assert row
+        assert_equal "Foo", row[0]
+        assert_equal 51, row[1]
+        @sth.finish
+        dbh.disconnect 
+    end
+
+    def test_select_transaction
+        # per bug #10466
+        dbh = get_dbh
+        dbh["AutoCommit"] = false
+        @sth = dbh.prepare('select * from test_insert(?, ?)');
+        @sth.execute("Foo", 51)
+        dbh.rollback
+        @sth.finish
+
+        @sth = dbh.prepare('select name, age from names where name=?')
+        @sth.execute("Foo")
+        assert !@sth.fetch
+        @sth.finish
+        dbh.disconnect 
+    end
+
+    def get_dbh
+        config = DBDConfig.get_config['odbc']
+        DBI.connect("dbi:ODBC:#{config['dbname']}", config['username'], config['password'])
+    end
+end

data/test/dbd/odbc/up.sql

@@ -0,0 +1,31 @@
+create table names (
+    name varchar(255),
+    age integer
+);
+---
+insert into names (name, age) values ('Joe', 19);
+---
+insert into names (name, age) values ('Jim', 30);
+---
+insert into names (name, age) values ('Bob', 21);
+---
+create table precision_test (text_field varchar(20) primary key not null, integer_field decimal(2,1));
+---
+CREATE TABLE blob_test (name VARCHAR(30), data OID);
+---
+create view view_names as select * from names;
+---
+create or replace function test_insert (varchar(255), integer) 
+    returns integer 
+    language sql 
+    as 'insert into names (name, age) values ($1, $2); select age from names where name = $1';
+---
+create table boolean_test (num integer, mybool boolean);
+---
+create table time_test (mytime time);
+---
+create table timestamp_test (mytimestamp timestamp);
+---
+create table bit_test (mybit bit);
+---
+create table field_types_test (foo integer not null primary key default 1);