GOMODULES
/
pgx
mirror of https://github.com/jackc/pgx.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use interace{} returning SelectValue(s) 

Instead of SelectInt32, SelectAllString, etc.

fixes #19
pgx-vs-pq
Jack Christensen 2013-06-29 12:07:31 -05:00
parent d1fda1b21c
commit 520da3a102
10 changed files with 257 additions and 716 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
connection.go
View File

@ -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)

100
connection_select_column.go
View File

@ -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
}

148
connection_select_column_test.go
View File

@ -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")
}
}

74
connection_select_column_test.go.erb
View File

@ -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 %>

69
connection_select_value.go
View File

@ -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
}

90
connection_select_value_test.go
View File

@ -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)
}
}
}

109
connection_test.go
View File

@ -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")
}
}

124
data_row_reader.go
View File

@ -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 {
panic("Unexpected null")
if size > -1 {
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)
}

177
data_row_reader_test.go
View File

@ -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" {
t.Error("Wrong value returned")
if v != nil {
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")
}
}

63
data_row_reader_test.go.erb
View File

@ -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 %>