ydbi 0.5.0 → 0.5.1

data/test/dbd/odbc/up.sql

@@ -1,33 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

data/test/dbd/postgresql/test_async.rb

@@ -1,121 +0,0 @@
-class TestPostgresAsync < DBDConfig.testbase(:postgresql)
-    def get_dbh
-        config = DBDConfig.get_config['postgresql']
-        DBI.connect("dbi:Pg:#{config['dbname']}", config['username'], config['password'])
-    end
-
-    def get_db_info
-        config = DBDConfig.get_config['postgresql']
-        dsn  = "dbi:Pg:database=#{config['dbname']}"
-        user = config['username']
-        pass = config['password']
-
-        return [dsn, user, pass]
-    end
-
-    def test_async_default
-        dsn, user, pass = get_db_info
-
-        DBI.connect(dsn, user, pass) do |dbh|
-            assert_equal false, dbh['pg_async']
-            assert_equal false, dbh['NonBlocking']
-            dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                assert_equal false, sth['pg_async']
-                assert_equal false, sth['NonBlocking']
-            end
-        end
-    end
-
-    def test_async_dsn_enable
-        dsn, user, pass = get_db_info
-
-        for enable in ['true', 'TRUE', 'tRuE']
-            DBI.connect(dsn + ";pg_async=#{enable}", user, pass) do |dbh|
-                assert_equal true, dbh['pg_async']
-                assert_equal true, dbh['NonBlocking']
-                dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                    assert_equal true, sth['pg_async']
-                    assert_equal true, sth['NonBlocking']
-                end
-            end
-        end
-    end
-
-    def test_async_attr_enable
-        dsn, user, pass = get_db_info
-
-        for enable in ['true', 'TRUE', 'tRuE']
-            DBI.connect(dsn, user, pass, { 'pg_async' => enable } ) do |dbh|
-                assert_equal true, dbh['pg_async']
-                assert_equal true, dbh['NonBlocking']
-                dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                    assert_equal true, sth['pg_async']
-                    assert_equal true, sth['NonBlocking']
-                end
-            end
-        end
-    end
-
-    def test_async_dsn_disable
-        dsn, user, pass = get_db_info
-
-        for disable in ['false', 'FALSE', 'fAlSe']
-            DBI.connect(dsn + ";pg_async=#{disable}", user, pass) do |dbh|
-                assert_equal false, dbh['pg_async']
-                assert_equal false, dbh['NonBlocking']
-                dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                    assert_equal false, sth['pg_async']
-                    assert_equal false, sth['NonBlocking']
-                end
-            end
-        end
-    end
-
-    def test_async_attr_disable
-        dsn, user, pass = get_db_info
-
-        for disable in ['false', 'FALSE', 'fAlSe']
-            DBI.connect(dsn, user, pass, { 'pg_async' => disable }) do |dbh|
-                assert_equal false, dbh['pg_async']
-                assert_equal false, dbh['NonBlocking']
-                dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                    assert_equal false, sth['pg_async']
-                    assert_equal false, sth['NonBlocking']
-                end
-            end
-        end
-    end
-
-    def test_manual_enable
-        dsn, user, pass = get_db_info
-
-        DBI.connect(dsn, user, pass) do |dbh|
-            dbh['pg_async'] = true
-            assert_equal true, dbh['pg_async']
-            assert_equal true, dbh['NonBlocking']
-            dbh.prepare('SELECT 1') do |sth|      # Statement inherits
-                assert_equal true, sth['pg_async']
-                assert_equal true, sth['NonBlocking']
-            end
-        end
-    end
-
-    def test_async_commands
-        dsn, user, pass = get_db_info
-
-        DBI.connect(dsn + ";pg_async=true", user, pass) do |dbh|
-            assert_equal true, dbh['pg_async']
-            assert_equal true, dbh['NonBlocking']
-            ret = dbh.select_all('SELECT 1')
-            assert_equal [[1]], ret
-
-            ret = dbh.select_all(%q{SELECT 1 WHERE 'foo' = ?}, 'bar')
-            assert_equal [], ret
-
-            dbh.prepare(%q{SELECT 1 WHERE 'foo' = ?}) do |sth|
-                sth.execute('bar')
-                assert_equal [], sth.fetch_all
-            end
-        end
-    end
-end

data/test/dbd/postgresql/test_blob.rb

@@ -1,36 +0,0 @@
-class TestPostgresBlob < DBDConfig.testbase(:postgresql)
-    DATA = "this is my new binary object"
-
-    def test_insert
-        assert @dbh
-        assert @dbh.ping
-
-        # test with DBI::Binary
-        assert_equal 1, @dbh.do("INSERT INTO blob_test (name, data) VALUES (?,?)", "test", DBI::Binary.new(DATA))
-
-        # test with blob_create directly
-        blob = @dbh.func(:blob_create, PGconn::INV_WRITE)
-        assert blob
-        assert @dbh.func(:blob_write, blob, DATA)
-        assert_equal 1, @dbh.do("INSERT INTO blob_test (name, data) VALUES (?,?)", "test (2)", blob)
-
-        # test with blob_import directly
-        File.open('/tmp/pg_dbi_import_test', 'w') { |f| f << DATA }
-        blob = @dbh.func(:blob_import, '/tmp/pg_dbi_import_test')
-        assert blob
-        assert_equal 1, @dbh.do("INSERT INTO blob_test (name, data) VALUES (?,?)", "test (2)", blob)
-
-        index = 0
-        @dbh.select_all("SELECT name, data FROM blob_test") do |name, data|
-            index += 1
-            assert_equal DATA, @dbh.func(:blob_read, data, DATA.length)
-            @dbh.func(:blob_export, data, '/tmp/pg_dbi_read_test')
-            assert_equal DATA, File.read('/tmp/pg_dbi_read_test')
-        end
-
-        assert_equal 3, index
-
-        File.unlink("/tmp/pg_dbi_read_test")
-        File.unlink("/tmp/pg_dbi_import_test")
-    end
-end

data/test/dbd/postgresql/test_bytea.rb

@@ -1,87 +0,0 @@
-require 'dbd/Pg'
-
-begin
-    require 'rubygems'
-    gem 'pg'
-rescue Exception => e
-end
-
-require 'pg'
-
-LEN = 50
-
-class TestPostgresByteA < DBDConfig.testbase(:postgresql)
-    # FIXME the 'pg' module is broken and doesn't encode/decode properly.
-    # this test should prove that the 'pg' module works so we can back out our
-    # hacks.
-    def skip_underlying_driver 
-        str = generate_random_string
-
-        encoded = PGconn.escape_bytea(str.dup)
-        decoded = PGconn.unescape_bytea(encoded)
-
-        assert_equal str, decoded
-    end
-
-    def test_encode_decode
-        bytea = DBI::DBD::Pg::Type::ByteA
-        
-        # some specific cases that were failing intermittenly
-        # poor \\ handling
-        str = "\236\000\257\202G<\371\035TPEO\211\005*AH'H\3136\360\004\245\261\037\340u\003s\\772X\231\002\200\n\327\202\217\353\177r\317o\341\237\341"
-        encoded = bytea.escape_bytea(str)
-        decoded = bytea.parse(encoded)
-
-        assert_equal str, decoded 
-
-        # the split hack not working
-        str = "\343\336e\260\337\373\314\026\323#\237i\035\0302\024\346X\274\016\324\371\206\036\230\374\206#rA\n\214\272\316\330\025\374\000\2663\244M\255x\360\002\266q\336\231"
-
-        encoded = bytea.escape_bytea(str)
-        decoded = bytea.parse(encoded)
-
-        assert_equal str, decoded 
-
-        # delimiter at the end
-        str = "\343\336e\260\337\373\314\026\323#\237i\035\0302\024\346X\274\016\324\371\206\036\230\374\206#rA\n\214\272\316\330\025\374\000\2663\244M\255x\360\002\266q\336\231\\\\\\\\"
-
-        encoded = bytea.escape_bytea(str)
-        decoded = bytea.parse(encoded)
-
-        assert_equal str, decoded 
-
-        # a huge test to weed out all the stragglers
-        5_000.times do 
-            str = generate_random_string
-
-            encoded = bytea.escape_bytea(str)
-            decoded = bytea.parse(encoded)
-
-            assert_equal str, decoded
-        end
-    end
-    
-    def test_insert_retrieve
-        assert_nothing_raised do
-            str = generate_random_string
-            sth = @dbh.prepare('insert into bytea_test (foo) values (?)')
-            sth.execute(DBI::DBD::Pg::Type::ByteA.new(str))
-            sth.finish
-
-            sth = @dbh.prepare('select * from bytea_test')
-            sth.execute
-            assert_equal([str], sth.fetch)
-            sth.finish
-        end
-    end
-
-    def generate_random_string
-        # random string test
-        str = " " * LEN
-        for i in 0...LEN
-            str[i] = (rand * 256).to_i.chr
-        end
-
-        return str
-    end
-end

data/test/dbd/postgresql/test_ping.rb

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

data/test/dbd/postgresql/test_timestamp.rb

@@ -1,77 +0,0 @@
-class TestPostgresTimestamp < DBDConfig.testbase(:postgresql)
-	def get_tstamp
-        DateTime.parse("2008-03-08 10:39:01.012300")
-    end
-
-    # XXX DateTime is not allowed to modify the sec_fraction component, so this test is moot.
-    # perhaps we need to fix DateTime.
-    def skip_test_timestamp_altered_fraction
-        ts = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into timestamp_test (mytimestamp) values (?)")
-            ts = DateTime.parse(Time.now.to_s)
-            ts.sec_fraction = 22200000
-            @sth.execute(ts)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from timestamp_test")
-            @sth.execute
-            row = @sth.fetch
-            @sth.finish
-            assert_equal ts.sec_fraction, row[0].sec_fraction
-        end
-    end
-
-    def test_current_timestamp
-        assert @dbh
-         # syntax db-specific (e.g., "from dual", "...timestamp()", etc.)
-        ts = @dbh.select_one("SELECT CURRENT_TIMESTAMP")[0]
-        assert_kind_of DateTime, ts
-        assert_not_nil ts.sec_fraction
-    end
-
-    # Just like the 'general' test, but checking for fractional seconds
-    def test_timestamp_fractional
-        assert @dbh
-        @sth = nil
-        t = get_tstamp
-        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
-            assert_not_nil row[0].sec_fraction
-            assert_equal t.sec_fraction, row[0].sec_fraction
-            @sth.finish
-        end
-    end
-
-    # Is our DBI::Timestamp equivalent to its canonical string literal
-    # form cast appropriately?
-    def test_timestamp_from_cast
-        assert @dbh
-        sql_ts = "SELECT CAST('2008-03-08 10:39:01.012300' AS TIMESTAMP)"
-
-        row = @dbh.select_one(sql_ts)
-        assert_not_nil row
-        assert_equal 1, row.size
-
-        assert_kind_of DateTime, row[0]
-        assert_equal row[0], get_tstamp
-    end
-end

data/test/dbd/postgresql/test_transactions.rb

@@ -1,58 +0,0 @@
-class TestPostgresTransaction < DBDConfig.testbase(:postgresql)
-    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
-        DBI.connect("dbi:Pg:#{config['postgresql']['dbname']}", config['postgresql']['username'], config['postgresql']['password'])
-    end
-end