Use interace{} returning SelectValue(s)

Instead of SelectInt32, SelectAllString, etc.

fixes #19

connection.go

@@ -158,6 +158,25 @@ func (c *Connection) SelectRow(sql string) (row map[string]string, err error) {
 	return
 }
 
+func (c *Connection) SelectValue(sql string) (v interface{}, err error) {
+	onDataRow := func(r *DataRowReader) error {
+		v = r.ReadValue()
+		return nil
+	}
+	err = c.SelectFunc(sql, onDataRow)
+	return
+}
+
+func (c *Connection) SelectValues(sql string) (values []interface{}, err error) {
+	values = make([]interface{}, 0, 8)
+	onDataRow := func(r *DataRowReader) error {
+		values = append(values, r.ReadValue())
+		return nil
+	}
+	err = c.SelectFunc(sql, onDataRow)
+	return
+}
+
 func (c *Connection) sendSimpleQuery(sql string) (err error) {
 	bufSize := 5 + len(sql) + 1 // message identifier (1), message size (4), null string terminator (1)
 	buf := c.getBuf(bufSize)

connection_select_column.go

@@ -1,100 +0,0 @@
-package pgx
-
-import (
-	"errors"
-	"strconv"
-)
-
-func (c *Connection) SelectAllString(sql string) (strings []string, err error) {
-	strings = make([]string, 0, 8)
-	onDataRow := func(r *DataRowReader) error {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		strings = append(strings, s)
-		return nil
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}
-
-func (c *Connection) SelectAllInt64(sql string) (ints []int64, err error) {
-	ints = make([]int64, 0, 8)
-	onDataRow := func(r *DataRowReader) (parseError error) {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		var i int64
-		i, parseError = strconv.ParseInt(s, 10, 64)
-		ints = append(ints, i)
-		return
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}
-
-func (c *Connection) SelectAllInt32(sql string) (ints []int32, err error) {
-	ints = make([]int32, 0, 8)
-	onDataRow := func(r *DataRowReader) (parseError error) {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		var i int64
-		i, parseError = strconv.ParseInt(s, 10, 32)
-		ints = append(ints, int32(i))
-		return
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}
-
-func (c *Connection) SelectAllInt16(sql string) (ints []int16, err error) {
-	ints = make([]int16, 0, 8)
-	onDataRow := func(r *DataRowReader) (parseError error) {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		var i int64
-		i, parseError = strconv.ParseInt(s, 10, 16)
-		ints = append(ints, int16(i))
-		return
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}
-
-func (c *Connection) SelectAllFloat64(sql string) (floats []float64, err error) {
-	floats = make([]float64, 0, 8)
-	onDataRow := func(r *DataRowReader) (parseError error) {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		var f float64
-		f, parseError = strconv.ParseFloat(s, 64)
-		floats = append(floats, f)
-		return
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}
-
-func (c *Connection) SelectAllFloat32(sql string) (floats []float32, err error) {
-	floats = make([]float32, 0, 8)
-	onDataRow := func(r *DataRowReader) (parseError error) {
-		s, null := c.rxDataRowFirstValue(r.mr)
-		if null {
-			return errors.New("Unexpected NULL")
-		}
-		var f float64
-		f, parseError = strconv.ParseFloat(s, 32)
-		floats = append(floats, float32(f))
-		return
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}

connection_select_column_test.go

@@ -1,148 +0,0 @@
-package pgx
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestSelectAllString(t *testing.T) {
-	conn := getSharedConnection()
-
-	s, err := conn.SelectAllString("select * from (values ('Matthew'), ('Mark'), ('Luke'), ('John')) t")
-	if err != nil {
-		t.Fatal("Unable to select all strings: " + err.Error())
-	}
-
-	if s[0] != "Matthew" || s[1] != "Mark" || s[2] != "Luke" || s[3] != "John" {
-		t.Error("Received incorrect strings")
-	}
-
-	_, err = conn.SelectAllString("select * from (values ('Matthew'), (null)) t")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-
-func TestSelectAllInt64(t *testing.T) {
-	conn := getSharedConnection()
-
-	i, err := conn.SelectAllInt64("select * from (values (1), (2)) t")
-	if err != nil {
-		t.Fatal("Unable to select all int64: " + err.Error())
-	}
-
-	if i[0] != 1 || i[1] != 2 {
-		t.Error("Received incorrect int64s")
-	}
-
-	i, err = conn.SelectAllInt64("select power(2,65)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number greater than max int64")
-	}
-
-	i, err = conn.SelectAllInt64("select -power(2,65)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number less than min int64")
-	}
-
-	_, err = conn.SelectAllInt64("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-func TestSelectAllInt32(t *testing.T) {
-	conn := getSharedConnection()
-
-	i, err := conn.SelectAllInt32("select * from (values (1), (2)) t")
-	if err != nil {
-		t.Fatal("Unable to select all int32: " + err.Error())
-	}
-
-	if i[0] != 1 || i[1] != 2 {
-		t.Error("Received incorrect int32s")
-	}
-
-	i, err = conn.SelectAllInt32("select power(2,33)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number greater than max int32")
-	}
-
-	i, err = conn.SelectAllInt32("select -power(2,33)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number less than min int32")
-	}
-
-	_, err = conn.SelectAllInt32("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-func TestSelectAllInt16(t *testing.T) {
-	conn := getSharedConnection()
-
-	i, err := conn.SelectAllInt16("select * from (values (1), (2)) t")
-	if err != nil {
-		t.Fatal("Unable to select all int16: " + err.Error())
-	}
-
-	if i[0] != 1 || i[1] != 2 {
-		t.Error("Received incorrect int16s")
-	}
-
-	i, err = conn.SelectAllInt16("select power(2,17)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number greater than max int16")
-	}
-
-	i, err = conn.SelectAllInt16("select -power(2,17)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number less than min int16")
-	}
-
-	_, err = conn.SelectAllInt16("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-
-
-func TestSelectAllFloat64(t *testing.T) {
-	conn := getSharedConnection()
-
-	f, err := conn.SelectAllFloat64("select * from (values (1.23), (4.56)) t")
-	if err != nil {
-		t.Fatal("Unable to select all float64: " + err.Error())
-	}
-
-	if f[0] != 1.23 || f[1] != 4.56 {
-		t.Error("Received incorrect float64")
-	}
-
-	_, err = conn.SelectAllFloat64("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-func TestSelectAllFloat32(t *testing.T) {
-	conn := getSharedConnection()
-
-	f, err := conn.SelectAllFloat32("select * from (values (1.23), (4.56)) t")
-	if err != nil {
-		t.Fatal("Unable to select all float32: " + err.Error())
-	}
-
-	if f[0] != 1.23 || f[1] != 4.56 {
-		t.Error("Received incorrect float32")
-	}
-
-	_, err = conn.SelectAllFloat32("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-

connection_select_column_test.go.erb

@@ -1,74 +0,0 @@
-package pgx
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestSelectAllString(t *testing.T) {
-	conn := getSharedConnection()
-
-	s, err := conn.SelectAllString("select * from (values ('Matthew'), ('Mark'), ('Luke'), ('John')) t")
-	if err != nil {
-		t.Fatal("Unable to select all strings: " + err.Error())
-	}
-
-	if s[0] != "Matthew" || s[1] != "Mark" || s[2] != "Luke" || s[3] != "John" {
-		t.Error("Received incorrect strings")
-	}
-
-	_, err = conn.SelectAllString("select * from (values ('Matthew'), (null)) t")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-
-<% [64, 32, 16].each do |size| %>
-func TestSelectAllInt<%= size %>(t *testing.T) {
-	conn := getSharedConnection()
-
-	i, err := conn.SelectAllInt<%= size %>("select * from (values (1), (2)) t")
-	if err != nil {
-		t.Fatal("Unable to select all int<%= size %>: " + err.Error())
-	}
-
-	if i[0] != 1 || i[1] != 2 {
-		t.Error("Received incorrect int<%= size %>s")
-	}
-
-	i, err = conn.SelectAllInt<%= size %>("select power(2,<%= size + 1 %>)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number greater than max int<%= size %>")
-	}
-
-	i, err = conn.SelectAllInt<%= size %>("select -power(2,<%= size + 1 %>)::numeric")
-	if err == nil || !strings.Contains(err.Error(), "value out of range") {
-		t.Error("Expected value out of range error when selecting number less than min int<%= size %>")
-	}
-
-	_, err = conn.SelectAllInt<%= size %>("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-<% end %>
-
-<% [64, 32].each do |size| %>
-func TestSelectAllFloat<%= size %>(t *testing.T) {
-	conn := getSharedConnection()
-
-	f, err := conn.SelectAllFloat<%= size %>("select * from (values (1.23), (4.56)) t")
-	if err != nil {
-		t.Fatal("Unable to select all float<%= size %>: " + err.Error())
-	}
-
-	if f[0] != 1.23 || f[1] != 4.56 {
-		t.Error("Received incorrect float<%= size %>")
-	}
-
-	_, err = conn.SelectAllFloat<%= size %>("select null")
-	if err == nil || !strings.Contains(err.Error(), "NULL") {
-		t.Error("Should have received error on null")
-	}
-}
-<% end %>

connection_select_value.go

@@ -1,69 +0,0 @@
-package pgx
-
-import (
-	"fmt"
-	"strconv"
-)
-
-func (c *Connection) SelectValue(sql string) (v interface{}, err error) {
-	onDataRow := func(r *DataRowReader) error {
-		size := r.mr.ReadInt32()
-		if size > -1 {
-			switch r.fields[0].DataType {
-			case oid(16): // bool
-				s := r.mr.ReadByteString(size)
-				switch s {
-				case "t":
-					v = true
-				case "f":
-					v = false
-				default:
-					fmt.Errorf("Received invalid bool: %v", s)
-				}
-			case oid(20): // int8
-				s := r.mr.ReadByteString(size)
-				v, err = strconv.ParseInt(s, 10, 64)
-				if err != nil {
-					fmt.Errorf("Received invalid int8: %v", s)
-				}
-			case oid(21): // int2
-				s := r.mr.ReadByteString(size)
-				var n int64
-				n, err = strconv.ParseInt(s, 10, 16)
-				if err != nil {
-					fmt.Errorf("Received invalid int2: %v", s)
-				}
-				v = int16(n)
-			case oid(23): // int4
-				s := r.mr.ReadByteString(size)
-				var n int64
-				n, err = strconv.ParseInt(s, 10, 32)
-				if err != nil {
-					fmt.Errorf("Received invalid int4: %v", s)
-				}
-				v = int32(n)
-			case oid(700): // float4
-				s := r.mr.ReadByteString(size)
-				var n float64
-				n, err = strconv.ParseFloat(s, 32)
-				if err != nil {
-					fmt.Errorf("Received invalid float4: %v", s)
-				}
-				v = float32(n)
-			case oid(701): //float8
-				s := r.mr.ReadByteString(size)
-				v, err = strconv.ParseFloat(s, 64)
-				if err != nil {
-					fmt.Errorf("Received invalid float8: %v", s)
-				}
-			default:
-				v = r.mr.ReadByteString(size)
-			}
-		} else {
-			v = nil
-		}
-		return nil
-	}
-	err = c.SelectFunc(sql, onDataRow)
-	return
-}

connection_select_value_test.go

@@ -1,90 +0,0 @@
-package pgx
-
-import (
-	"testing"
-)
-
-func TestSelectValue(t *testing.T) {
-	conn := getSharedConnection()
-	var v interface{}
-	var err error
-
-	v, err = conn.SelectValue("select null")
-	if err != nil {
-		t.Errorf("Unable to select null: %v", err)
-	} else {
-		if v != nil {
-			t.Errorf("Expected: nil, recieved: %v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select 'foo'")
-	if err != nil {
-		t.Errorf("Unable to select string: %v", err)
-	} else {
-		s, ok := v.(string)
-		if !(ok && s == "foo") {
-			t.Errorf("Expected: foo, recieved: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select true")
-	if err != nil {
-		t.Errorf("Unable to select bool: %#v", err)
-	} else {
-		s, ok := v.(bool)
-		if !(ok && s == true) {
-			t.Errorf("Expected true, received: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select false")
-	if err != nil {
-		t.Errorf("Unable to select bool: %v", err)
-	} else {
-		s, ok := v.(bool)
-		if !(ok && s == false) {
-			t.Errorf("Expected false, received: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select 1::int2")
-	if err != nil {
-		t.Errorf("Unable to select int2: %v", err)
-	} else {
-		s, ok := v.(int16)
-		if !(ok && s == 1) {
-			t.Errorf("Expected 1, received: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select 1::int4")
-	if err != nil {
-		t.Errorf("Unable to select int4: %v", err)
-	} else {
-		s, ok := v.(int32)
-		if !(ok && s == 1) {
-			t.Errorf("Expected 1, received: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select 1::int8")
-	if err != nil {
-		t.Errorf("Unable to select int8: %#v", err)
-	} else {
-		s, ok := v.(int64)
-		if !(ok && s == 1) {
-			t.Errorf("Expected 1, received: %#v", v)
-		}
-	}
-
-	v, err = conn.SelectValue("select 1.23::float4")
-	if err != nil {
-		t.Errorf("Unable to select float4: %#v", err)
-	} else {
-		s, ok := v.(float32)
-		if !(ok && s == float32(1.23)) {
-			t.Errorf("Expected 1.23, received: %#v", v)
-		}
-	}
-}

connection_test.go

@@ -132,7 +132,7 @@ func TestSelectFunc(t *testing.T) {
 	var sum, rowCount int32
 	onDataRow := func(r *DataRowReader) error {
 		rowCount++
-		sum += r.ReadInt32()
+		sum += r.ReadValue().(int32)
 		return nil
 	}
 
@@ -201,3 +201,110 @@ func TestSelectRow(t *testing.T) {
 		t.Fatal("Query failed")
 	}
 }
+
+func TestConnectionSelectValue(t *testing.T) {
+	conn := getSharedConnection()
+	var v interface{}
+	var err error
+
+	v, err = conn.SelectValue("select null")
+	if err != nil {
+		t.Errorf("Unable to select null: %v", err)
+	} else {
+		if v != nil {
+			t.Errorf("Expected: nil, recieved: %v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select 'foo'")
+	if err != nil {
+		t.Errorf("Unable to select string: %v", err)
+	} else {
+		s, ok := v.(string)
+		if !(ok && s == "foo") {
+			t.Errorf("Expected: foo, recieved: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select true")
+	if err != nil {
+		t.Errorf("Unable to select bool: %#v", err)
+	} else {
+		s, ok := v.(bool)
+		if !(ok && s == true) {
+			t.Errorf("Expected true, received: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select false")
+	if err != nil {
+		t.Errorf("Unable to select bool: %v", err)
+	} else {
+		s, ok := v.(bool)
+		if !(ok && s == false) {
+			t.Errorf("Expected false, received: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select 1::int2")
+	if err != nil {
+		t.Errorf("Unable to select int2: %v", err)
+	} else {
+		s, ok := v.(int16)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select 1::int4")
+	if err != nil {
+		t.Errorf("Unable to select int4: %v", err)
+	} else {
+		s, ok := v.(int32)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select 1::int8")
+	if err != nil {
+		t.Errorf("Unable to select int8: %#v", err)
+	} else {
+		s, ok := v.(int64)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	v, err = conn.SelectValue("select 1.23::float4")
+	if err != nil {
+		t.Errorf("Unable to select float4: %#v", err)
+	} else {
+		s, ok := v.(float32)
+		if !(ok && s == float32(1.23)) {
+			t.Errorf("Expected 1.23, received: %#v", v)
+		}
+	}
+}
+
+func TestSelectValues(t *testing.T) {
+	conn := getSharedConnection()
+	var values []interface{}
+	var err error
+
+	values, err = conn.SelectValues("select * from (values ('Matthew'), ('Mark'), ('Luke'), ('John')) t")
+	if err != nil {
+		t.Fatalf("Unable to select all strings: %v", err)
+	}
+	if values[0].(string) != "Matthew" || values[1].(string) != "Mark" || values[2].(string) != "Luke" || values[3].(string) != "John" {
+		t.Error("Received incorrect strings")
+	}
+
+	values, err = conn.SelectValues("select * from (values ('Matthew'), (null)) t")
+	if err != nil {
+		t.Fatalf("Unable to select values including a null: %v", err)
+	}
+	if values[0].(string) != "Matthew" || values[1] != nil {
+		t.Error("Received incorrect strings")
+	}
+}

data_row_reader.go

@@ -1,6 +1,7 @@
 package pgx
 
 import (
+	"fmt"
 	"strconv"
 )
 
@@ -22,76 +23,59 @@ func newDataRowReader(mr *MessageReader, fields []FieldDescription) (r *DataRowR
 	return
 }
 
-func (r *DataRowReader) ReadString() string {
+func (r *DataRowReader) ReadValue() interface{} {
 	size := r.mr.ReadInt32()
-	if size == -1 {
+	if size > -1 {
-		panic("Unexpected null")
+		switch r.fields[0].DataType {
+		case oid(16): // bool
+			s := r.mr.ReadByteString(size)
+			switch s {
+			case "t":
+				return true
+			case "f":
+				return false
+			default:
+				panic(fmt.Sprintf("Received invalid bool: %v", s))
+			}
+		case oid(20): // int8
+			s := r.mr.ReadByteString(size)
+			n, err := strconv.ParseInt(s, 10, 64)
+			if err != nil {
+				panic(fmt.Sprintf("Received invalid int8: %v", s))
+			}
+			return n
+		case oid(21): // int2
+			s := r.mr.ReadByteString(size)
+			n, err := strconv.ParseInt(s, 10, 16)
+			if err != nil {
+				panic(fmt.Sprintf("Received invalid int2: %v", s))
+			}
+			return int16(n)
+		case oid(23): // int4
+			s := r.mr.ReadByteString(size)
+			n, err := strconv.ParseInt(s, 10, 32)
+			if err != nil {
+				panic(fmt.Sprintf("Received invalid int4: %v", s))
+			}
+			return int32(n)
+		case oid(700): // float4
+			s := r.mr.ReadByteString(size)
+			n, err := strconv.ParseFloat(s, 32)
+			if err != nil {
+				panic(fmt.Sprintf("Received invalid float4: %v", s))
+			}
+			return float32(n)
+		case oid(701): //float8
+			s := r.mr.ReadByteString(size)
+			v, err := strconv.ParseFloat(s, 64)
+			if err != nil {
+				panic(fmt.Sprintf("Received invalid float8: %v", s))
+			}
+			return v
+		default:
+			return r.mr.ReadByteString(size)
+		}
+	} else {
+		return nil
 	}
-
-	return r.mr.ReadByteString(size)
-}
-
-func (r *DataRowReader) ReadInt64() int64 {
-	size := r.mr.ReadInt32()
-	if size == -1 {
-		panic("Unexpected null")
-	}
-
-	i64, err := strconv.ParseInt(r.mr.ReadByteString(size), 10, 64)
-	if err != nil {
-		panic("Number too large")
-	}
-	return i64
-}
-
-func (r *DataRowReader) ReadInt32() int32 {
-	size := r.mr.ReadInt32()
-	if size == -1 {
-		panic("Unexpected null")
-	}
-
-	i64, err := strconv.ParseInt(r.mr.ReadByteString(size), 10, 32)
-	if err != nil {
-		panic("Number too large")
-	}
-	return int32(i64)
-}
-
-func (r *DataRowReader) ReadInt16() int16 {
-	size := r.mr.ReadInt32()
-	if size == -1 {
-		panic("Unexpected null")
-	}
-
-	i64, err := strconv.ParseInt(r.mr.ReadByteString(size), 10, 16)
-	if err != nil {
-		panic("Number too large")
-	}
-	return int16(i64)
-}
-
-func (r *DataRowReader) ReadFloat64() float64 {
-	size := r.mr.ReadInt32()
-	if size == -1 {
-		panic("Unexpected null")
-	}
-
-	f64, err := strconv.ParseFloat(r.mr.ReadByteString(size), 64)
-	if err != nil {
-		panic("Number too large")
-	}
-	return f64
-}
-
-func (r *DataRowReader) ReadFloat32() float32 {
-	size := r.mr.ReadInt32()
-	if size == -1 {
-		panic("Unexpected null")
-	}
-
-	f64, err := strconv.ParseFloat(r.mr.ReadByteString(size), 32)
-	if err != nil {
-		panic("Number too large")
-	}
-	return float32(f64)
 }

data_row_reader_test.go

@@ -4,114 +4,89 @@ import (
 	"testing"
 )
 
-func TestDataRowReaderReadString(t *testing.T) {
+func TestDataRowReaderReadValue(t *testing.T) {
 	conn := getSharedConnection()
+	var v interface{}
+	var err error
 
-	var s string
 	onDataRow := func(r *DataRowReader) error {
-		s = r.ReadString()
+		v = r.ReadValue()
 		return nil
 	}
 
-	err := conn.SelectFunc("select 'Jack'", onDataRow)
+	err = conn.SelectFunc("select null", onDataRow)
 	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
+		t.Fatalf("Select failed: %v", err)
 	}
-	if s != "Jack" {
+	if v != nil {
-		t.Error("Wrong value returned")
+		t.Errorf("Wrong value returned: %v", v)
+	}
+
+	err = conn.SelectFunc("select 'Jack'", onDataRow)
+	if err != nil {
+		t.Fatalf("Select failed: %v", err)
+	}
+	if typedValue, _ := v.(string); typedValue != "Jack" {
+		t.Errorf("Wrong value returned: %v", typedValue)
+	}
+
+	err = conn.SelectFunc("select true", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select bool: %#v", err)
+	} else {
+		s, ok := v.(bool)
+		if !(ok && s == true) {
+			t.Errorf("Expected true, received: %#v", v)
+		}
+	}
+
+	err = conn.SelectFunc("select false", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select bool: %v", err)
+	} else {
+		s, ok := v.(bool)
+		if !(ok && s == false) {
+			t.Errorf("Expected false, received: %#v", v)
+		}
+	}
+
+	err = conn.SelectFunc("select 1::int2", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select int2: %v", err)
+	} else {
+		s, ok := v.(int16)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	err = conn.SelectFunc("select 1::int4", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select int4: %v", err)
+	} else {
+		s, ok := v.(int32)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	err = conn.SelectFunc("select 1::int8", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select int8: %#v", err)
+	} else {
+		s, ok := v.(int64)
+		if !(ok && s == 1) {
+			t.Errorf("Expected 1, received: %#v", v)
+		}
+	}
+
+	err = conn.SelectFunc("select 1.23::float4", onDataRow)
+	if err != nil {
+		t.Errorf("Unable to select float4: %#v", err)
+	} else {
+		s, ok := v.(float32)
+		if !(ok && s == float32(1.23)) {
+			t.Errorf("Expected 1.23, received: %#v", v)
+		}
 	}
 }
-
-
-func TestDataRowReaderReadInt64(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n int64
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadInt64()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1 {
-		t.Error("Wrong value returned")
-	}
-}
-
-func TestDataRowReaderReadInt32(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n int32
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadInt32()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1 {
-		t.Error("Wrong value returned")
-	}
-}
-
-func TestDataRowReaderReadInt16(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n int16
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadInt16()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1 {
-		t.Error("Wrong value returned")
-	}
-}
-
-
-
-func TestDataRowReaderReadFloat64(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n float64
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadFloat64()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1.5", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1.5 {
-		t.Error("Wrong value returned")
-	}
-}
-
-func TestDataRowReaderReadFloat32(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n float32
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadFloat32()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1.5", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1.5 {
-		t.Error("Wrong value returned")
-	}
-}
-

data_row_reader_test.go.erb

@@ -1,63 +0,0 @@
-package pgx
-
-import (
-	"testing"
-)
-
-func TestDataRowReaderReadString(t *testing.T) {
-	conn := getSharedConnection()
-
-	var s string
-	onDataRow := func(r *DataRowReader) error {
-		s = r.ReadString()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 'Jack'", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if s != "Jack" {
-		t.Error("Wrong value returned")
-	}
-}
-
-<% [64, 32, 16].each do |size| %>
-func TestDataRowReaderReadInt<%= size %>(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n int<%= size %>
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadInt<%= size %>()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1 {
-		t.Error("Wrong value returned")
-	}
-}
-<% end %>
-
-<% [64, 32].each do |size| %>
-func TestDataRowReaderReadFloat<%= size %>(t *testing.T) {
-	conn := getSharedConnection()
-
-	var n float<%= size %>
-	onDataRow := func(r *DataRowReader) error {
-		n = r.ReadFloat<%= size %>()
-		return nil
-	}
-
-	err := conn.SelectFunc("select 1.5", onDataRow)
-	if err != nil {
-		t.Fatal("Select failed: " + err.Error())
-	}
-	if n != 1.5 {
-		t.Error("Wrong value returned")
-	}
-}
-<% end %>