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

Extract Connection.SelectAll* to own file

pgx-vs-pq
Jack Christensen 2013-04-20 11:34:52 -05:00
parent e27511a4c5
commit 58ae1855cb
4 changed files with 244 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
conn.go
View File

@ -8,7 +8,6 @@ import (
"fmt"
"io"
"net"
"strconv"
)
type Connection struct {
@ -142,100 +141,6 @@ func (c *Connection) SelectRows(sql string) (rows []map[string]string, err error
return
}
func (c *Connection) SelectAllString(sql string) (strings []string, err error) {
strings = make([]string, 0, 8)
onDataRow := func(r *messageReader, _ []fieldDescription) error {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, fields []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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
}
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)

139
conn_test.go
View File

@ -1,7 +1,6 @@
package pgx
import (
"strings"
"testing"
)
@ -157,141 +156,3 @@ func TestSelectRows(t *testing.T) {
t.Error("Null value shouldn't have been present in map")
}
}
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 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 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 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 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")
}
}

100
connection_select_column.go Normal file
View File

@ -0,0 +1,100 @@
package pgx
import (
"errors"
"strconv"
)
func (c *Connection) SelectAllString(sql string) (strings []string, err error) {
strings = make([]string, 0, 8)
onDataRow := func(r *messageReader, _ []fieldDescription) error {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, fields []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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 *messageReader, _ []fieldDescription) (parseError error) {
s, null := c.rxDataRowFirstValue(r)
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
}

144
connection_select_column_test.go Normal file
View File

@ -0,0 +1,144 @@
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 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 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 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 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")
}
}