ydbi 0.5.0

data/test/dbd/mysql/up.sql

@@ -0,0 +1,28 @@
+create table names (
+    name varchar(255),
+    age integer
+) Engine=InnoDB;
+---
+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 integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+CREATE TABLE blob_test (name VARCHAR(30), data BLOB) Engine=InnoDB;
+---
+create view view_names as select * from names;
+---
+create table boolean_test (num integer, mybool boolean) Engine=InnoDB;
+---
+create table time_test (mytime time) Engine=InnoDB;
+---
+create table timestamp_test (mytimestamp timestamp) Engine=InnoDB;
+---
+create table bit_test (mybit bit) Engine=InnoDB;
+---
+create table field_types_test (foo integer not null primary key default 1);
+---
+create table db_specific_types_test (ts timestamp, dt date);

data/test/dbd/odbc/base.rb

@@ -0,0 +1,30 @@
+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,19 @@
+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 db_specific_types_test;
+---
+drop table precision_test;

data/test/dbd/odbc/test_new_methods.rb

@@ -0,0 +1,12 @@
+class TestODBCPing < DBDConfig.testbase(:odbc)
+    def test_database_name
+        #
+        # NOTE this test will fail if the database is not named "rubytest". I
+        # don't think there's a good way to get around this, so I've set it to
+        # what I typically use in my odbc.ini. - erikh
+        #
+        assert_nothing_raised do
+            assert_equal "rubytest", @dbh.database_name
+        end
+    end
+end

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:ODBC:#{config['dbname']}", config['username'], config['password'])
+        assert dbh
+        assert dbh.ping
+        dbh.disconnect
+        assert_raises(DBI::InterfaceError) { dbh.ping }
+    end
+end

data/test/dbd/odbc/test_statement.rb

@@ -0,0 +1,44 @@
+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]
+        # XXX odbc seems to have a problem with this every other edition of unixodbc or so.
+        #     yes, I know this test is important.
+#         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,33 @@
+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 integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+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);
+---
+create table db_specific_types_test (foo integer);

data/test/dbd/postgresql/base.rb

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

data/test/dbd/postgresql/down.sql

@@ -0,0 +1,31 @@
+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 db_specific_types_test;
+---
+drop table array_test;
+---
+drop table bytea_test;
+---
+drop table precision_test;
+---
+drop table enum_type_test;
+---
+drop type enum_test;
+---
+drop schema schema1 cascade;
+---
+drop schema schema2 cascade;

data/test/dbd/postgresql/test_arrays.rb

@@ -0,0 +1,179 @@
+class TestPostgresArray < DBDConfig.testbase(:postgresql)
+    def test_array_type
+        assert_nothing_raised do
+            cols = @dbh.columns("array_test")
+            assert_equal(
+                [
+                    {
+                        :name =>"foo", 
+                        :default =>nil, 
+                        :primary =>nil, 
+                        :scale =>nil, 
+                        :sql_type =>DBI::SQL_INTEGER, 
+                        :nullable =>true, 
+                        :indexed =>false, 
+                        :precision =>-1, 
+                        :type_name =>"integer", 
+                        :unique =>nil,
+                        :array_of_type  => true
+                    }, 
+                    {
+                        :name =>"bar", 
+                        :default =>nil, 
+                        :primary =>nil, 
+                        :scale =>nil, 
+                        :sql_type =>DBI::SQL_INTEGER, 
+                        :nullable =>true, 
+                        :indexed =>false, 
+                        :precision =>-1, 
+                        :type_name =>"integer", 
+                        :unique =>nil,
+                        :array_of_type  => true
+                    },
+                    {
+                        :name =>"baz", 
+                        :default =>nil, 
+                        :primary =>nil, 
+                        :scale =>nil, 
+                        :sql_type =>DBI::SQL_INTEGER, 
+                        :nullable =>true, 
+                        :indexed =>false, 
+                        :precision =>-1, 
+                        :type_name =>"integer", 
+                        :unique =>nil,
+                        :array_of_type  => true
+                    },
+                    {
+                        :array_of_type=>true,
+                        :unique=>nil,
+                        :precision=>-1,
+                        :name=>"quux",
+                        :default=>nil,
+                        :indexed=>false,
+                        :scale=>nil,
+                        :primary=>nil,
+                        :sql_type=>12,
+                        :nullable=>true,
+                        :type_name=>"character varying"
+                    }
+                ], cols.collect { |x| x.reject { |key, value| key == :dbi_type } }
+            )
+
+            assert_equal(([DBI::DBD::Pg::Type::Array] * 4), cols.collect { |x| x["dbi_type"].class })
+            assert_equal((([DBI::Type::Integer] * 3) + [DBI::Type::Varchar]), cols.collect { |x| x["dbi_type"].base_type })
+        end
+    end
+
+    def test_array_parser
+        # string representation
+        assert_nothing_raised do
+            sth = @dbh.prepare('insert into array_test (foo) values (?)')
+            sth.execute('{1,2,3}')
+            sth.finish
+        end
+
+        assert_nothing_raised do
+            sth = @dbh.prepare('insert into array_test (foo) values (?)')
+            sth.execute([1,2,3])
+            sth.finish
+        end
+
+        assert_nothing_raised do
+            sth = @dbh.prepare('insert into array_test (quux) values (?)')
+            sth.execute(["Hello\\ World", "Again\\"])
+            sth.finish
+        end
+
+        assert_nothing_raised do
+            sth = @dbh.prepare('select foo from array_test where foo is not null')
+            sth.execute
+            assert_equal(
+                [
+                    [[1,2,3]],
+                    [[1,2,3]],
+                ], sth.fetch_all
+            )
+            sth.finish
+
+            sth = @dbh.prepare('select quux from array_test where quux is not null')
+            sth.execute
+
+            assert_equal(
+                [
+                    [["Hello\\ World", "Again\\"]]
+                ], sth.fetch_all
+            )
+
+            sth.finish
+        end
+    end
+
+    def test_array_boundaries
+        # bar has a max extents of 3
+        sth = @dbh.prepare('insert into array_test (bar) values (?)')
+
+        assert_nothing_raised do
+            sth.execute('{1,2,3}')
+        end
+
+        # XXX postgresql does not enforce extents on single-dimension arrays 
+        assert_nothing_raised do
+            sth.execute('{1,2,3,4}')
+        end
+
+        sth.finish
+        sth = @dbh.prepare('insert into array_test(baz) values (?)')
+
+        assert_nothing_raised do
+            sth.execute('{{1,2,3}, {1,2,3}}')
+        end
+
+        assert_nothing_raised do
+            # XXX for the record, I have no fucking idea why this works, what
+            # it's technically represented as and what backwards array
+            # implementation would allow it to work.
+            #
+            # I'm hoping it'll break on some future version of postgresql so I
+            # can fix it.
+            sth.execute('{1,2,3}')
+        end
+
+        assert_raises(DBI::ProgrammingError) do
+            sth.execute('{{1,2,3,4}, {1,2,3}}')
+        end
+
+        assert_raises(DBI::ProgrammingError) do
+            sth.execute('{{1,2,3}, {1,2,3,4}}')
+        end
+
+        sth.finish
+    end
+
+    def test_array_type_parser
+        pc = DBI::DBD::Pg::Type::Array
+
+        assert_nothing_raised do
+            po = pc.new(DBI::Type::Integer)
+            assert_equal([1,2,3], po.parse("{1,2,3}"))
+            assert_equal([[1,2,3],[4,5,6]], po.parse("{{1,2,3},{4,5,6}}"))
+        end
+
+        assert_nothing_raised do
+            po = pc.new(DBI::Type::Varchar)
+            assert_equal(["one", "two", "three"], po.parse("{\"one\",\"two\",\"three\"}"))
+            assert_equal([["one"], ["two\\"]], po.parse("{{\"one\"},{\"two\\\\\"}}"))
+            assert_equal([["one", "two\\"], ["three\\", "four"]], po.parse("{{\"one\",\"two\\\\\"},{\"three\\\\\",\"four\"}}"))
+        end
+    end
+
+    def test_array_generator
+        pg = DBI::DBD::Pg
+
+        assert_nothing_raised do
+            assert_equal("{1,2,3}", pg.generate_array([1,2,3]))
+            assert_equal("{{1,2,3},{1,2,3}}", pg.generate_array([[1,2,3],[1,2,3]]))
+            assert_equal("{\"one\",\"two\"}", pg.generate_array(["one", "two"]))
+            assert_equal("{\"hello\\\\ world\",\"again\"}", pg.generate_array(["hello\\ world", "again"]))
+        end
+    end
+end