ydbd-pg 0.5.1

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

data/test/dbd/postgresql/test_async.rb

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

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

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