dbd-pg 0.3.3

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_raise(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,254 @@
+require 'dbd/Pg'
+
+######################################################################
+# 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
+
+    def test_binding
+        assert(@dbh["pg_native_binding"])
+
+        assert_raise(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_tables
+        assert_equal(
+        [
+            "array_test",
+            "bit_test",
+            "blob_test",
+            "boolean_test",
+            "bytea_test",
+            "field_types_test",
+            "names",
+            "precision_test",
+            "time_test",
+            "timestamp_test",
+            "view_names"
+        ], @dbh.tables.reject { |x| x =~ /^pg_/ }.sort)
+    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_connect_errors
+    dbd = nil
+    ex = assert_raise(DBI::OperationalError) {
+      dbd = DBI::DBD::Pg::Database.new('rubytest:1234', 'jim', nil, {})
+    }
+    ex = assert_raise(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_raise(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_raise(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
+
+# --------------------------------------------------------------------

data/test/dbd/postgresql/up.sql

@@ -0,0 +1,54 @@
+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);
+---
+create table array_test (foo integer[], bar integer[3], baz integer[3][3], quux varchar[2]);
+---
+create table bytea_test (foo bytea);
+---
+create schema schema1;
+---
+create schema schema2;
+---
+create table schema1.tbl (foo integer);
+---
+create table schema2.tbl (bar integer);
+---
+create or replace function 
+    select_subproperty(value names.age%TYPE, sub names.age%TYPE, out retval names.age%TYPE) 
+    as $$ 
+        select 
+            case 
+            when $2 is not null 
+                then $1 
+            else null 
+        end 
+    $$ language sql;