ValueTranscoder EncodeTo now receives io.Writer

conn.go

@@ -793,7 +793,7 @@ func (c *Conn) sendPreparedQuery(ps *preparedStatement, arguments ...interface{}
 			if transcoder == nil {
 				transcoder = defaultTranscoder
 			}
-			err = transcoder.EncodeTo(w, arguments[i])
+			err = transcoder.EncodeTo(w.buf, arguments[i])
 			if err != nil {
 				return err
 			}

example_value_transcoder_test.go

@@ -1,8 +1,10 @@
 package pgx_test
 
 import (
+	"encoding/binary"
 	"fmt"
 	"github.com/JackC/pgx"
+	"io"
 	"regexp"
 	"strconv"
 )
@@ -55,15 +57,19 @@ func decodePointFromText(mr *pgx.MessageReader, size int32) interface{} {
 	return p
 }
 
-func encodePoint(w *pgx.MessageWriter, value interface{}) error {
+func encodePoint(w io.Writer, value interface{}) error {
 	p, ok := value.(Point)
 	if !ok {
 		return fmt.Errorf("Expected Point, received %T", value)
 	}
 
 	s := fmt.Sprintf("point(%v,%v)", p.x, p.y)
-	w.Write(int32(len(s)))
-	w.WriteString(s)
 
-	return nil
+	err := binary.Write(w, binary.BigEndian, int32(len(s)))
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(w, s)
+	return err
 }

value_transcoder.go

@@ -2,8 +2,10 @@ package pgx
 
 import (
 	"bytes"
+	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+	"io"
 	"regexp"
 	"strconv"
 	"time"
@@ -18,7 +20,7 @@ type ValueTranscoder struct {
 	// DecodeBinary decodes values returned from the server in binary format
 	DecodeBinary func(*MessageReader, int32) interface{}
 	// EncodeTo encodes values to send to the server
-	EncodeTo func(*MessageWriter, interface{}) error
+	EncodeTo func(io.Writer, interface{}) error
 	// EncodeFormat is the format values are encoded for transmission.
 	// 0 = text
 	// 1 = binary
@@ -159,20 +161,23 @@ func decodeBoolFromBinary(mr *MessageReader, size int32) interface{} {
 	return b != 0
 }
 
-func encodeBool(w *MessageWriter, value interface{}) error {
+func encodeBool(w io.Writer, value interface{}) error {
 	v, ok := value.(bool)
 	if !ok {
 		return fmt.Errorf("Expected bool, received %T", value)
 	}
 
-	w.Write(int32(1))
+	err := binary.Write(w, binary.BigEndian, int32(1))
-	if v {
+	if err != nil {
-		w.WriteByte(1)
+		return err
-	} else {
-		w.WriteByte(0)
 	}
 
-	return nil
+	var n byte
+	if v {
+		n = 1
+	}
+
+	return binary.Write(w, binary.BigEndian, n)
 }
 
 func decodeInt8FromText(mr *MessageReader, size int32) interface{} {
@@ -191,16 +196,18 @@ func decodeInt8FromBinary(mr *MessageReader, size int32) interface{} {
 	return mr.ReadInt64()
 }
 
-func encodeInt8(w *MessageWriter, value interface{}) error {
+func encodeInt8(w io.Writer, value interface{}) error {
 	v, ok := value.(int64)
 	if !ok {
 		return fmt.Errorf("Expected int64, received %T", value)
 	}
 
-	w.Write(int32(8))
+	err := binary.Write(w, binary.BigEndian, int32(8))
-	w.Write(v)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	return binary.Write(w, binary.BigEndian, v)
 }
 
 func decodeInt2FromText(mr *MessageReader, size int32) interface{} {
@@ -219,16 +226,18 @@ func decodeInt2FromBinary(mr *MessageReader, size int32) interface{} {
 	return mr.ReadInt16()
 }
 
-func encodeInt2(w *MessageWriter, value interface{}) error {
+func encodeInt2(w io.Writer, value interface{}) error {
 	v, ok := value.(int16)
 	if !ok {
 		return fmt.Errorf("Expected int16, received %T", value)
 	}
 
-	w.Write(int32(2))
+	err := binary.Write(w, binary.BigEndian, int32(2))
-	w.Write(v)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	return binary.Write(w, binary.BigEndian, v)
 }
 
 func decodeInt4FromText(mr *MessageReader, size int32) interface{} {
@@ -247,16 +256,18 @@ func decodeInt4FromBinary(mr *MessageReader, size int32) interface{} {
 	return mr.ReadInt32()
 }
 
-func encodeInt4(w *MessageWriter, value interface{}) error {
+func encodeInt4(w io.Writer, value interface{}) error {
 	v, ok := value.(int32)
 	if !ok {
 		return fmt.Errorf("Expected int32, received %T", value)
 	}
 
-	w.Write(int32(4))
+	err := binary.Write(w, binary.BigEndian, int32(4))
-	w.Write(v)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	return binary.Write(w, binary.BigEndian, v)
 }
 
 func decodeFloat4FromText(mr *MessageReader, size int32) interface{} {
@@ -278,16 +289,18 @@ func decodeFloat4FromBinary(mr *MessageReader, size int32) interface{} {
 	return *(*float32)(p)
 }
 
-func encodeFloat4(w *MessageWriter, value interface{}) error {
+func encodeFloat4(w io.Writer, value interface{}) error {
 	v, ok := value.(float32)
 	if !ok {
 		return fmt.Errorf("Expected float32, received %T", value)
 	}
 
-	w.Write(int32(4))
+	err := binary.Write(w, binary.BigEndian, int32(4))
-	w.Write(v)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	return binary.Write(w, binary.BigEndian, v)
 }
 
 func decodeFloat8FromText(mr *MessageReader, size int32) interface{} {
@@ -309,32 +322,37 @@ func decodeFloat8FromBinary(mr *MessageReader, size int32) interface{} {
 	return *(*float64)(p)
 }
 
-func encodeFloat8(w *MessageWriter, value interface{}) error {
+func encodeFloat8(w io.Writer, value interface{}) error {
 	v, ok := value.(float64)
 	if !ok {
 		return fmt.Errorf("Expected float64, received %T", value)
 	}
 
-	w.Write(int32(8))
+	err := binary.Write(w, binary.BigEndian, int32(8))
-	w.Write(v)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	return binary.Write(w, binary.BigEndian, v)
 }
 
 func decodeTextFromText(mr *MessageReader, size int32) interface{} {
 	return mr.ReadString(size)
 }
 
-func encodeText(w *MessageWriter, value interface{}) error {
+func encodeText(w io.Writer, value interface{}) error {
 	s, ok := value.(string)
 	if !ok {
 		return fmt.Errorf("Expected string, received %T", value)
 	}
 
-	w.Write(int32(len(s)))
+	err := binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }
 
 func decodeByteaFromText(mr *MessageReader, size int32) interface{} {
@@ -346,16 +364,19 @@ func decodeByteaFromText(mr *MessageReader, size int32) interface{} {
 	return b
 }
 
-func encodeBytea(w *MessageWriter, value interface{}) error {
+func encodeBytea(w io.Writer, value interface{}) error {
 	b, ok := value.([]byte)
 	if !ok {
 		return fmt.Errorf("Expected []byte, received %T", value)
 	}
 
-	w.Write(int32(len(b)))
+	err := binary.Write(w, binary.BigEndian, int32(len(b)))
-	w.Write(b)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = w.Write(b)
+	return err
 }
 
 func decodeDateFromText(mr *MessageReader, size int32) interface{} {
@@ -367,17 +388,20 @@ func decodeDateFromText(mr *MessageReader, size int32) interface{} {
 	return t
 }
 
-func encodeDate(w *MessageWriter, value interface{}) error {
+func encodeDate(w io.Writer, value interface{}) error {
 	t, ok := value.(time.Time)
 	if !ok {
 		return fmt.Errorf("Expected time.Time, received %T", value)
 	}
 
 	s := t.Format("2006-01-02")
-	w.Write(int32(len(s)))
+	err := binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }
 
 func decodeTimestampTzFromText(mr *MessageReader, size int32) interface{} {
@@ -403,17 +427,20 @@ func decodeTimestampTzFromBinary(mr *MessageReader, size int32) interface{} {
 
 }
 
-func encodeTimestampTz(w *MessageWriter, value interface{}) error {
+func encodeTimestampTz(w io.Writer, value interface{}) error {
 	t, ok := value.(time.Time)
 	if !ok {
-		return fmt.Errorf("Expected float32, received %T", value)
+		return fmt.Errorf("Expected time.Time, received %T", value)
 	}
 
 	s := t.Format("2006-01-02 15:04:05.999999 -0700")
-	w.Write(int32(len(s)))
+	err := binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }
 
 func decodeInt2ArrayFromText(mr *MessageReader, size int32) interface{} {
@@ -447,7 +474,7 @@ func int16SliceToArrayString(nums []int16) (string, error) {
 	return w.buf.String(), w.Err
 }
 
-func encodeInt2Array(w *MessageWriter, value interface{}) error {
+func encodeInt2Array(w io.Writer, value interface{}) error {
 	v, ok := value.([]int16)
 	if !ok {
 		return fmt.Errorf("Expected []int16, received %T", value)
@@ -458,10 +485,13 @@ func encodeInt2Array(w *MessageWriter, value interface{}) error {
 		return fmt.Errorf("Failed to encode []int16: %v", err)
 	}
 
-	w.Write(int32(len(s)))
+	err = binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }
 
 func decodeInt4ArrayFromText(mr *MessageReader, size int32) interface{} {
@@ -495,7 +525,7 @@ func int32SliceToArrayString(nums []int32) (string, error) {
 	return w.buf.String(), w.Err
 }
 
-func encodeInt4Array(w *MessageWriter, value interface{}) error {
+func encodeInt4Array(w io.Writer, value interface{}) error {
 	v, ok := value.([]int32)
 	if !ok {
 		return fmt.Errorf("Expected []int32, received %T", value)
@@ -506,10 +536,13 @@ func encodeInt4Array(w *MessageWriter, value interface{}) error {
 		return fmt.Errorf("Failed to encode []int32: %v", err)
 	}
 
-	w.Write(int32(len(s)))
+	err = binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }
 
 func decodeInt8ArrayFromText(mr *MessageReader, size int32) interface{} {
@@ -543,7 +576,7 @@ func int64SliceToArrayString(nums []int64) (string, error) {
 	return w.buf.String(), w.Err
 }
 
-func encodeInt8Array(w *MessageWriter, value interface{}) error {
+func encodeInt8Array(w io.Writer, value interface{}) error {
 	v, ok := value.([]int64)
 	if !ok {
 		return fmt.Errorf("Expected []int64, received %T", value)
@@ -554,8 +587,11 @@ func encodeInt8Array(w *MessageWriter, value interface{}) error {
 		return fmt.Errorf("Failed to encode []int64: %v", err)
 	}
 
-	w.Write(int32(len(s)))
+	err = binary.Write(w, binary.BigEndian, int32(len(s)))
-	w.WriteString(s)
+	if err != nil {
+		return err
+	}
 
-	return nil
+	_, err = io.WriteString(w, s)
+	return err
 }