ydbi 0.5.0

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

data/test/dbd/postgresql/test_ping.rb

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

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

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

data/test/dbd/postgresql/testdbipg.rb

@@ -0,0 +1,307 @@
+require 'dbd/Pg'
+
+module DBI
+  class ForcedError < ::DBI::Error
+  end
+end
+
+######################################################################
+# Test the PostgreSql DBD driver.  This test exercises options
+# difficult to test through the standard DBI interface.
+#
+class TestDbdPostgres < DBDConfig.testbase(:postgresql)
+
+    # FIXME this is a feature that should be there, but currently isn't.
+#   def test_connect
+#     dbd = get_dbd
+#     assert_not_nil dbd.connection
+#     assert_equal 'localhost', dbd.connection.host
+#     assert_equal 'erikh', dbd.connection.user
+#     assert_equal 'rubytest', dbd.connection.db
+#     assert_equal 5432, dbd.connection.port
+#   ensure
+#      dbd.disconnect if dbd
+#   end
+
+    # this monkeypatch is used for the following test... NEVER integrate this into DBI proper.
+    class DBI::StatementHandle < DBI::Handle
+        def stmt_name
+            @handle.instance_variable_get(:@stmt_name)
+        end
+    end
+
+    def test_database_name
+        assert_nothing_raised do
+            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
+        end
+    end
+
+    def test_enum_type
+        assert_nothing_raised do
+            assert(@dbh.convert_types)
+            @sth = @dbh.prepare("insert into enum_type_test values (?)")
+            @sth.execute("one")
+            @sth.finish
+
+            @sth = @dbh.prepare("select foo from enum_type_test")
+            @sth.execute
+            assert_equal(@sth.fetch, ['one'])
+            @sth.finish
+        end
+    end
+
+    def test_statement_finish_deallocates_sth
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from names")
+            @sth.execute
+            sth_internal_name = @sth.stmt_name
+            assert(sth_internal_name)
+            assert(!sth_internal_name.empty?)
+            @sth.finish
+
+            # at this point, the statement name should no longer exist
+            #
+            # XXX this is a potentially horrible way of doing it since it'll
+            # create another prepared statement, but *at this time*, I don't
+            # see any drawbacks and the alternative is considerably uglier.
+
+            @sth = @dbh.prepare("select count(*) from pg_prepared_statements where name = ?")
+            @sth.execute(sth_internal_name)
+            assert_equal([0], @sth.fetch)
+            @sth.finish
+        end
+    end
+
+    def test_binding
+        assert(@dbh["pg_native_binding"])
+
+        assert_raises(DBI::ProgrammingError) do
+            @sth = @dbh.prepare("select * from names where age IS NOT ?")
+            @sth.execute("NULL")
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @dbh["pg_native_binding"] = false
+            @sth = @dbh.prepare("select * from names where age IS NOT ? order by age")
+            @sth.execute("NULL")
+            assert_equal(
+                [
+                    ["Joe", 19],
+                    ["Bob", 21],
+                    ["Jim", 30],
+                ],
+                @sth.fetch_all
+            )
+
+            @sth.finish
+
+            @sth = @dbh.prepare("select * from names where age = ?")
+            @sth.execute(19)
+            assert_equal(
+                [
+                    ["Joe", 19]
+                ],
+                @sth.fetch_all
+            )
+
+            @sth.finish
+        end
+    end
+
+    def test_function_multiple_return_values
+        @sth = @dbh.prepare("SELECT age, select_subproperty(age, NULL), select_subproperty(age, 1) FROM names WHERE age = 19")
+        @sth.execute
+        assert_equal([[19, nil, 19]], @sth.fetch_all)
+        @sth.finish
+    end
+
+    def test_columns
+        assert_equal(
+            [
+                {
+                        :name =>"age",
+                        :default =>nil,
+                        :primary =>nil,
+                        :scale =>nil,
+                        :sql_type =>4,
+                        :nullable =>true,
+                        :indexed =>false,
+                        :precision =>4,
+                        :type_name =>"integer",
+                        :unique =>nil,
+                        :array_of_type =>nil
+                },
+                {
+                        :name =>"name",
+                        :default =>nil,
+                        :primary =>nil,
+                        :scale =>nil,
+                        :sql_type =>12,
+                        :nullable =>true,
+                        :indexed =>false,
+                        :precision =>255,
+                        :type_name =>"character varying",
+                        :unique =>nil,
+                        :array_of_type =>nil
+                }
+        ], @dbh.columns("names").sort_by { |x| x["name"] })
+
+        assert_equal(2, @dbh.columns("names").size) # make sure this works before the search path change
+
+        assert_equal(0, @dbh.columns("tbl").size) # tbl doesn't exist in public
+
+        @dbh.do('SET search_path TO schema1,schema2,"$user",public')
+
+        assert_equal(1, @dbh.columns('tbl').size);
+        assert_equal(
+            [
+                {
+                    :name =>"foo",
+                    :default =>nil,
+                    :primary =>nil,
+                    :scale =>nil,
+                    :sql_type =>4,
+                    :nullable =>true,
+                    :indexed =>false,
+                    :precision =>4,
+                    :type_name =>"integer",
+                    :unique =>nil,
+                    :array_of_type =>nil
+
+                }
+            ],
+            @dbh.columns('tbl')
+        )
+
+    end
+
+  def test_statement_name_uniqueness
+    5000.times do
+      begin
+        @dbh.prepare('SELECT 1').execute()
+        raise DBI::ForcedError
+        sth.finish # never reached
+      rescue DBI::ProgrammingError => e
+        # ERROR:  prepared statement "ruby-dbi:Pg:-604926268" already exists
+        # This should never happen
+        raise e
+      rescue DBI::ForcedError
+        # no-op
+      end
+    end
+  end
+
+  def test_connect_errors
+    dbd = nil
+    ex = assert_raises(DBI::OperationalError) {
+      dbd = DBI::DBD::Pg::Database.new('rubytest:1234', 'jim', nil, {})
+    }
+    ex = assert_raises(DBI::OperationalError) {
+      dbd = DBI::DBD::Pg::Database.new('bad_db_name', 'jim', nil, {})
+    }
+
+    # this corresponds to the test_parse_url_expected_errors test in tc_dbi.rb
+    assert_raises(DBI::InterfaceError) do
+        DBI.connect("dbi:Pg").disconnect
+    end
+
+  ensure
+    dbd.disconnect if dbd
+  end
+
+  def skip_test_type_map
+    dbd = get_dbd
+    def dbd.type_map
+      @type_map
+    end
+    assert dbd.type_map
+    assert_equal 21, dbd.convert("21", 23)
+    assert_equal "21", dbd.convert("21", 1043)
+    assert_equal 21.5, dbd.convert("21.5", 701)
+  end
+
+  def test_simple_command
+    dbd = get_dbd
+    res = dbd.do("INSERT INTO names (name, age) VALUES('Dan', 16)")
+    assert_equal 1, res
+
+    @sth = get_dbi.prepare("SELECT name FROM names WHERE age=16")
+    @sth.execute
+    assert @sth.fetchable?
+    # XXX FIXME This is a bug in the DBD. #rows should equal 1 for select statements.
+    assert_equal 0, @sth.rows
+  ensure
+    dbd.do("DELETE FROM names WHERE age < 20")
+    dbd.disconnect if dbd
+  end
+
+  def test_bad_command
+    dbd = get_dbd
+    assert_raises(DBI::ProgrammingError) {
+      dbd.do("INSERT INTO bad_table (name, age) VALUES('Dave', 12)")
+    }
+  ensure
+    dbd.disconnect if dbd
+  end
+
+  def test_query_single
+    dbd = get_dbi
+    res = dbd.prepare("SELECT name, age FROM names WHERE age=21;")
+    assert res
+    res.execute
+    fields = res.column_info
+    assert_equal 2, fields.length
+    assert_equal 'name', fields[0]['name']
+    assert_equal 'varchar', fields[0]['type_name']
+    assert_equal 'age', fields[1]['name']
+    assert_equal 'int4', fields[1]['type_name']
+
+    row = res.fetch
+
+    assert_equal 'Bob', row[0]
+    assert_equal 21, row[1]
+
+    row = res.fetch
+    assert_nil row
+
+    res.finish
+  ensure
+    dbd.disconnect if dbd
+  end
+
+  def test_query_multi
+    dbd = get_dbd
+    res = dbd.prepare("SELECT name, age FROM names WHERE age > 20;")
+
+    expected_list = ['Jim', 'Bob', 'Charlie']
+    res.execute
+    while row=res.fetch
+      expected = expected_list.shift
+      assert_equal expected, row[0]
+    end
+
+    res.finish
+  ensure
+    dbd.disconnect if dbd
+  end
+
+  def test_tables_call
+      # per bug #1082, views do not show up in tables listing.
+      assert get_dbi.tables.include?("view_names")
+  end
+
+  def get_dbi
+      config = DBDConfig.get_config
+      DBI.connect("dbi:Pg:#{config['postgresql']['dbname']}", config['postgresql']['username'], config['postgresql']['password'])
+  end
+
+  def get_dbd
+      config = DBDConfig.get_config['postgresql']
+      result = DBI::DBD::Pg::Database.new(config['dbname'], config['username'], config['password'], {})
+      result['AutoCommit'] = true
+      result
+  end
+end
+
+# --------------------------------------------------------------------