Add daterange, tsrange, and tstzrange

daterange.go

@@ -0,0 +1,268 @@
+package pgtype
+
+import (
+	"bytes"
+	"database/sql/driver"
+	"fmt"
+	"io"
+
+	"github.com/jackc/pgx/pgio"
+)
+
+type Daterange struct {
+	Lower     Date
+	Upper     Date
+	LowerType BoundType
+	UpperType BoundType
+	Status    Status
+}
+
+func (dst *Daterange) Set(src interface{}) error {
+	return fmt.Errorf("cannot convert %v to Daterange", src)
+}
+
+func (dst *Daterange) Get() interface{} {
+	switch dst.Status {
+	case Present:
+		return dst
+	case Null:
+		return nil
+	default:
+		return dst.Status
+	}
+}
+
+func (src *Daterange) AssignTo(dst interface{}) error {
+	return fmt.Errorf("cannot assign %v to %T", src, dst)
+}
+
+func (dst *Daterange) DecodeText(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Daterange{Status: Null}
+		return nil
+	}
+
+	utr, err := ParseUntypedTextRange(string(src))
+	if err != nil {
+		return err
+	}
+
+	*dst = Daterange{Status: Present}
+
+	dst.LowerType = utr.LowerType
+	dst.UpperType = utr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeText(ci, []byte(utr.Lower)); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeText(ci, []byte(utr.Upper)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (dst *Daterange) DecodeBinary(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Daterange{Status: Null}
+		return nil
+	}
+
+	ubr, err := ParseUntypedBinaryRange(src)
+	if err != nil {
+		return err
+	}
+
+	*dst = Daterange{Status: Present}
+
+	dst.LowerType = ubr.LowerType
+	dst.UpperType = ubr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeBinary(ci, ubr.Lower); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeBinary(ci, ubr.Upper); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (src Daterange) EncodeText(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	switch src.LowerType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, '('); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, '['); err != nil {
+			return false, err
+		}
+	case Empty:
+		_, err := io.WriteString(w, "empty")
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown lower bound type %v", src.LowerType)
+	}
+
+	if src.LowerType != Unbounded {
+		if null, err := src.Lower.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+	}
+
+	if err := pgio.WriteByte(w, ','); err != nil {
+		return false, err
+	}
+
+	if src.UpperType != Unbounded {
+		if null, err := src.Upper.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+	}
+
+	switch src.UpperType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, ')'); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, ']'); err != nil {
+			return false, err
+		}
+	default:
+		return false, fmt.Errorf("unknown upper bound type %v", src.UpperType)
+	}
+
+	return false, nil
+}
+
+func (src Daterange) EncodeBinary(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	var rangeType byte
+	switch src.LowerType {
+	case Inclusive:
+		rangeType |= lowerInclusiveMask
+	case Unbounded:
+		rangeType |= lowerUnboundedMask
+	case Exclusive:
+	case Empty:
+		err := pgio.WriteByte(w, emptyMask)
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown LowerType: %v", src.LowerType)
+	}
+
+	switch src.UpperType {
+	case Inclusive:
+		rangeType |= upperInclusiveMask
+	case Unbounded:
+		rangeType |= upperUnboundedMask
+	case Exclusive:
+	default:
+		return false, fmt.Errorf("unknown UpperType: %v", src.UpperType)
+	}
+
+	if err := pgio.WriteByte(w, rangeType); err != nil {
+		return false, err
+	}
+
+	valBuf := &bytes.Buffer{}
+
+	if src.LowerType != Unbounded {
+		null, err := src.Lower.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	if src.UpperType != Unbounded {
+		null, err := src.Upper.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return false, nil
+}
+
+// Scan implements the database/sql Scanner interface.
+func (dst *Daterange) Scan(src interface{}) error {
+	if src == nil {
+		*dst = Daterange{Status: Null}
+		return nil
+	}
+
+	switch src := src.(type) {
+	case string:
+		return dst.DecodeText(nil, []byte(src))
+	case []byte:
+		return dst.DecodeText(nil, src)
+	}
+
+	return fmt.Errorf("cannot scan %T", src)
+}
+
+// Value implements the database/sql/driver Valuer interface.
+func (src Daterange) Value() (driver.Value, error) {
+	return encodeValueText(src)
+}

daterange_test.go

@@ -0,0 +1,66 @@
+package pgtype_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/pgtype"
+)
+
+func TestDaterangeTranscode(t *testing.T) {
+	testSuccessfulTranscodeEqFunc(t, "daterange", []interface{}{
+		pgtype.Daterange{LowerType: pgtype.Empty, UpperType: pgtype.Empty, Status: pgtype.Present},
+		pgtype.Daterange{
+			Lower:     pgtype.Date{Time: time.Date(1990, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Date{Time: time.Date(2028, 1, 1, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Daterange{
+			Lower:     pgtype.Date{Time: time.Date(1800, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Date{Time: time.Date(2200, 1, 1, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Daterange{Status: pgtype.Null},
+	}, func(aa, bb interface{}) bool {
+		a := aa.(pgtype.Daterange)
+		b := bb.(pgtype.Daterange)
+
+		return a.Status == b.Status &&
+			a.Lower.Time.Equal(b.Lower.Time) &&
+			a.Lower.Status == b.Lower.Status &&
+			a.Lower.InfinityModifier == b.Lower.InfinityModifier &&
+			a.Upper.Time.Equal(b.Upper.Time) &&
+			a.Upper.Status == b.Upper.Status &&
+			a.Upper.InfinityModifier == b.Upper.InfinityModifier
+	})
+}
+
+func TestDaterangeNormalize(t *testing.T) {
+	testSuccessfulNormalizeEqFunc(t, []normalizeTest{
+		{
+			sql: "select daterange('2010-01-01', '2010-01-11', '(]')",
+			value: pgtype.Daterange{
+				Lower:     pgtype.Date{Time: time.Date(2010, 1, 2, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+				Upper:     pgtype.Date{Time: time.Date(2010, 1, 12, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+				LowerType: pgtype.Inclusive,
+				UpperType: pgtype.Exclusive,
+				Status:    pgtype.Present,
+			},
+		},
+	}, func(aa, bb interface{}) bool {
+		a := aa.(pgtype.Daterange)
+		b := bb.(pgtype.Daterange)
+
+		return a.Status == b.Status &&
+			a.Lower.Time.Equal(b.Lower.Time) &&
+			a.Lower.Status == b.Lower.Status &&
+			a.Lower.InfinityModifier == b.Lower.InfinityModifier &&
+			a.Upper.Time.Equal(b.Upper.Time) &&
+			a.Upper.Status == b.Upper.Status &&
+			a.Upper.InfinityModifier == b.Upper.InfinityModifier
+	})
+}

pgtype.go

@@ -227,6 +227,7 @@ func init() {
 		"cid":          &Cid{},
 		"cidr":         &Cidr{},
 		"date":         &Date{},
+		"daterange":    &Daterange{},
 		"float4":       &Float4{},
 		"float8":       &Float8{},
 		"hstore":       &Hstore{},
@@ -235,6 +236,7 @@ func init() {
 		"int4":         &Int4{},
 		"int4range":    &Int4range{},
 		"int8":         &Int8{},
+		"int8range":    &Int8range{},
 		"json":         &Json{},
 		"jsonb":        &Jsonb{},
 		"name":         &Name{},
@@ -244,6 +246,8 @@ func init() {
 		"tid":          &Tid{},
 		"timestamp":    &Timestamp{},
 		"timestamptz":  &Timestamptz{},
+		"tsrange":      &Tsrange{},
+		"tstzrange":    &Tstzrange{},
 		"unknown":      &Unknown{},
 		"varchar":      &Varchar{},
 		"xid":          &Xid{},

tsrange.go

@@ -0,0 +1,268 @@
+package pgtype
+
+import (
+	"bytes"
+	"database/sql/driver"
+	"fmt"
+	"io"
+
+	"github.com/jackc/pgx/pgio"
+)
+
+type Tsrange struct {
+	Lower     Timestamp
+	Upper     Timestamp
+	LowerType BoundType
+	UpperType BoundType
+	Status    Status
+}
+
+func (dst *Tsrange) Set(src interface{}) error {
+	return fmt.Errorf("cannot convert %v to Tsrange", src)
+}
+
+func (dst *Tsrange) Get() interface{} {
+	switch dst.Status {
+	case Present:
+		return dst
+	case Null:
+		return nil
+	default:
+		return dst.Status
+	}
+}
+
+func (src *Tsrange) AssignTo(dst interface{}) error {
+	return fmt.Errorf("cannot assign %v to %T", src, dst)
+}
+
+func (dst *Tsrange) DecodeText(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Tsrange{Status: Null}
+		return nil
+	}
+
+	utr, err := ParseUntypedTextRange(string(src))
+	if err != nil {
+		return err
+	}
+
+	*dst = Tsrange{Status: Present}
+
+	dst.LowerType = utr.LowerType
+	dst.UpperType = utr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeText(ci, []byte(utr.Lower)); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeText(ci, []byte(utr.Upper)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (dst *Tsrange) DecodeBinary(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Tsrange{Status: Null}
+		return nil
+	}
+
+	ubr, err := ParseUntypedBinaryRange(src)
+	if err != nil {
+		return err
+	}
+
+	*dst = Tsrange{Status: Present}
+
+	dst.LowerType = ubr.LowerType
+	dst.UpperType = ubr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeBinary(ci, ubr.Lower); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeBinary(ci, ubr.Upper); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (src Tsrange) EncodeText(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	switch src.LowerType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, '('); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, '['); err != nil {
+			return false, err
+		}
+	case Empty:
+		_, err := io.WriteString(w, "empty")
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown lower bound type %v", src.LowerType)
+	}
+
+	if src.LowerType != Unbounded {
+		if null, err := src.Lower.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+	}
+
+	if err := pgio.WriteByte(w, ','); err != nil {
+		return false, err
+	}
+
+	if src.UpperType != Unbounded {
+		if null, err := src.Upper.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+	}
+
+	switch src.UpperType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, ')'); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, ']'); err != nil {
+			return false, err
+		}
+	default:
+		return false, fmt.Errorf("unknown upper bound type %v", src.UpperType)
+	}
+
+	return false, nil
+}
+
+func (src Tsrange) EncodeBinary(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	var rangeType byte
+	switch src.LowerType {
+	case Inclusive:
+		rangeType |= lowerInclusiveMask
+	case Unbounded:
+		rangeType |= lowerUnboundedMask
+	case Exclusive:
+	case Empty:
+		err := pgio.WriteByte(w, emptyMask)
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown LowerType: %v", src.LowerType)
+	}
+
+	switch src.UpperType {
+	case Inclusive:
+		rangeType |= upperInclusiveMask
+	case Unbounded:
+		rangeType |= upperUnboundedMask
+	case Exclusive:
+	default:
+		return false, fmt.Errorf("unknown UpperType: %v", src.UpperType)
+	}
+
+	if err := pgio.WriteByte(w, rangeType); err != nil {
+		return false, err
+	}
+
+	valBuf := &bytes.Buffer{}
+
+	if src.LowerType != Unbounded {
+		null, err := src.Lower.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	if src.UpperType != Unbounded {
+		null, err := src.Upper.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return false, nil
+}
+
+// Scan implements the database/sql Scanner interface.
+func (dst *Tsrange) Scan(src interface{}) error {
+	if src == nil {
+		*dst = Tsrange{Status: Null}
+		return nil
+	}
+
+	switch src := src.(type) {
+	case string:
+		return dst.DecodeText(nil, []byte(src))
+	case []byte:
+		return dst.DecodeText(nil, src)
+	}
+
+	return fmt.Errorf("cannot scan %T", src)
+}
+
+// Value implements the database/sql/driver Valuer interface.
+func (src Tsrange) Value() (driver.Value, error) {
+	return encodeValueText(src)
+}

tsrange_test.go

@@ -0,0 +1,40 @@
+package pgtype_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/pgtype"
+)
+
+func TestTsrangeTranscode(t *testing.T) {
+	testSuccessfulTranscodeEqFunc(t, "tsrange", []interface{}{
+		pgtype.Tsrange{LowerType: pgtype.Empty, UpperType: pgtype.Empty, Status: pgtype.Present},
+		pgtype.Tsrange{
+			Lower:     pgtype.Timestamp{Time: time.Date(1990, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Timestamp{Time: time.Date(2028, 1, 1, 0, 23, 12, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Tsrange{
+			Lower:     pgtype.Timestamp{Time: time.Date(1800, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Timestamp{Time: time.Date(2200, 1, 1, 0, 23, 12, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Tsrange{Status: pgtype.Null},
+	}, func(aa, bb interface{}) bool {
+		a := aa.(pgtype.Tsrange)
+		b := bb.(pgtype.Tsrange)
+
+		return a.Status == b.Status &&
+			a.Lower.Time.Equal(b.Lower.Time) &&
+			a.Lower.Status == b.Lower.Status &&
+			a.Lower.InfinityModifier == b.Lower.InfinityModifier &&
+			a.Upper.Time.Equal(b.Upper.Time) &&
+			a.Upper.Status == b.Upper.Status &&
+			a.Upper.InfinityModifier == b.Upper.InfinityModifier
+	})
+}

tstzrange.go

@@ -0,0 +1,268 @@
+package pgtype
+
+import (
+	"bytes"
+	"database/sql/driver"
+	"fmt"
+	"io"
+
+	"github.com/jackc/pgx/pgio"
+)
+
+type Tstzrange struct {
+	Lower     Timestamptz
+	Upper     Timestamptz
+	LowerType BoundType
+	UpperType BoundType
+	Status    Status
+}
+
+func (dst *Tstzrange) Set(src interface{}) error {
+	return fmt.Errorf("cannot convert %v to Tstzrange", src)
+}
+
+func (dst *Tstzrange) Get() interface{} {
+	switch dst.Status {
+	case Present:
+		return dst
+	case Null:
+		return nil
+	default:
+		return dst.Status
+	}
+}
+
+func (src *Tstzrange) AssignTo(dst interface{}) error {
+	return fmt.Errorf("cannot assign %v to %T", src, dst)
+}
+
+func (dst *Tstzrange) DecodeText(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Tstzrange{Status: Null}
+		return nil
+	}
+
+	utr, err := ParseUntypedTextRange(string(src))
+	if err != nil {
+		return err
+	}
+
+	*dst = Tstzrange{Status: Present}
+
+	dst.LowerType = utr.LowerType
+	dst.UpperType = utr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeText(ci, []byte(utr.Lower)); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeText(ci, []byte(utr.Upper)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (dst *Tstzrange) DecodeBinary(ci *ConnInfo, src []byte) error {
+	if src == nil {
+		*dst = Tstzrange{Status: Null}
+		return nil
+	}
+
+	ubr, err := ParseUntypedBinaryRange(src)
+	if err != nil {
+		return err
+	}
+
+	*dst = Tstzrange{Status: Present}
+
+	dst.LowerType = ubr.LowerType
+	dst.UpperType = ubr.UpperType
+
+	if dst.LowerType == Empty {
+		return nil
+	}
+
+	if dst.LowerType == Inclusive || dst.LowerType == Exclusive {
+		if err := dst.Lower.DecodeBinary(ci, ubr.Lower); err != nil {
+			return err
+		}
+	}
+
+	if dst.UpperType == Inclusive || dst.UpperType == Exclusive {
+		if err := dst.Upper.DecodeBinary(ci, ubr.Upper); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (src Tstzrange) EncodeText(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	switch src.LowerType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, '('); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, '['); err != nil {
+			return false, err
+		}
+	case Empty:
+		_, err := io.WriteString(w, "empty")
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown lower bound type %v", src.LowerType)
+	}
+
+	if src.LowerType != Unbounded {
+		if null, err := src.Lower.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+	}
+
+	if err := pgio.WriteByte(w, ','); err != nil {
+		return false, err
+	}
+
+	if src.UpperType != Unbounded {
+		if null, err := src.Upper.EncodeText(ci, w); err != nil {
+			return false, err
+		} else if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+	}
+
+	switch src.UpperType {
+	case Exclusive, Unbounded:
+		if err := pgio.WriteByte(w, ')'); err != nil {
+			return false, err
+		}
+	case Inclusive:
+		if err := pgio.WriteByte(w, ']'); err != nil {
+			return false, err
+		}
+	default:
+		return false, fmt.Errorf("unknown upper bound type %v", src.UpperType)
+	}
+
+	return false, nil
+}
+
+func (src Tstzrange) EncodeBinary(ci *ConnInfo, w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	var rangeType byte
+	switch src.LowerType {
+	case Inclusive:
+		rangeType |= lowerInclusiveMask
+	case Unbounded:
+		rangeType |= lowerUnboundedMask
+	case Exclusive:
+	case Empty:
+		err := pgio.WriteByte(w, emptyMask)
+		return false, err
+	default:
+		return false, fmt.Errorf("unknown LowerType: %v", src.LowerType)
+	}
+
+	switch src.UpperType {
+	case Inclusive:
+		rangeType |= upperInclusiveMask
+	case Unbounded:
+		rangeType |= upperUnboundedMask
+	case Exclusive:
+	default:
+		return false, fmt.Errorf("unknown UpperType: %v", src.UpperType)
+	}
+
+	if err := pgio.WriteByte(w, rangeType); err != nil {
+		return false, err
+	}
+
+	valBuf := &bytes.Buffer{}
+
+	if src.LowerType != Unbounded {
+		null, err := src.Lower.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Lower cannot be null unless LowerType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	if src.UpperType != Unbounded {
+		null, err := src.Upper.EncodeBinary(ci, valBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			return false, fmt.Errorf("Upper cannot be null unless UpperType is Unbounded")
+		}
+
+		_, err = pgio.WriteInt32(w, int32(valBuf.Len()))
+		if err != nil {
+			return false, err
+		}
+		_, err = valBuf.WriteTo(w)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return false, nil
+}
+
+// Scan implements the database/sql Scanner interface.
+func (dst *Tstzrange) Scan(src interface{}) error {
+	if src == nil {
+		*dst = Tstzrange{Status: Null}
+		return nil
+	}
+
+	switch src := src.(type) {
+	case string:
+		return dst.DecodeText(nil, []byte(src))
+	case []byte:
+		return dst.DecodeText(nil, src)
+	}
+
+	return fmt.Errorf("cannot scan %T", src)
+}
+
+// Value implements the database/sql/driver Valuer interface.
+func (src Tstzrange) Value() (driver.Value, error) {
+	return encodeValueText(src)
+}

tstzrange_test.go

@@ -0,0 +1,40 @@
+package pgtype_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/pgtype"
+)
+
+func TestTstzrangeTranscode(t *testing.T) {
+	testSuccessfulTranscodeEqFunc(t, "tstzrange", []interface{}{
+		pgtype.Tstzrange{LowerType: pgtype.Empty, UpperType: pgtype.Empty, Status: pgtype.Present},
+		pgtype.Tstzrange{
+			Lower:     pgtype.Timestamptz{Time: time.Date(1990, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Timestamptz{Time: time.Date(2028, 1, 1, 0, 23, 12, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Tstzrange{
+			Lower:     pgtype.Timestamptz{Time: time.Date(1800, 12, 31, 0, 0, 0, 0, time.UTC), Status: pgtype.Present},
+			Upper:     pgtype.Timestamptz{Time: time.Date(2200, 1, 1, 0, 23, 12, 0, time.UTC), Status: pgtype.Present},
+			LowerType: pgtype.Inclusive,
+			UpperType: pgtype.Exclusive,
+			Status:    pgtype.Present,
+		},
+		pgtype.Tstzrange{Status: pgtype.Null},
+	}, func(aa, bb interface{}) bool {
+		a := aa.(pgtype.Tstzrange)
+		b := bb.(pgtype.Tstzrange)
+
+		return a.Status == b.Status &&
+			a.Lower.Time.Equal(b.Lower.Time) &&
+			a.Lower.Status == b.Lower.Status &&
+			a.Lower.InfinityModifier == b.Lower.InfinityModifier &&
+			a.Upper.Time.Equal(b.Upper.Time) &&
+			a.Upper.Status == b.Upper.Status &&
+			a.Upper.InfinityModifier == b.Upper.InfinityModifier
+	})
+}

typed_range_gen.sh

@@ -1,3 +1,6 @@
 erb range_type=Int4range element_type=Int4 typed_range.go.erb > int4range.go
 erb range_type=Int8range element_type=Int8 typed_range.go.erb > int8range.go
+erb range_type=Tsrange element_type=Timestamp typed_range.go.erb > tsrange.go
+erb range_type=Tstzrange element_type=Timestamptz typed_range.go.erb > tstzrange.go
+erb range_type=Daterange element_type=Date typed_range.go.erb > daterange.go
 goimports -w *range.go