diff --git a/cid.go b/cid.go
index b7718f88..0ed54f44 100644
--- a/cid.go
+++ b/cid.go
@@ -4,7 +4,7 @@ import (
 	"database/sql/driver"
 )
 
-// Cid is PostgreSQL's Command Identifier type.
+// CID is PostgreSQL's Command Identifier type.
 //
 // When one does
 //
@@ -15,47 +15,47 @@ import (
 // It is currently implemented as an unsigned four byte integer.
 // Its definition can be found in src/include/c.h as CommandId
 // in the PostgreSQL sources.
-type Cid pguint32
+type CID pguint32
 
-// Set converts from src to dst. Note that as Cid is not a general
+// Set converts from src to dst. Note that as CID is not a general
 // number type Set does not do automatic type conversion as other number
 // types do.
-func (dst *Cid) Set(src interface{}) error {
+func (dst *CID) Set(src interface{}) error {
 	return (*pguint32)(dst).Set(src)
 }
 
-func (dst *Cid) Get() interface{} {
+func (dst *CID) Get() interface{} {
 	return (*pguint32)(dst).Get()
 }
 
-// AssignTo assigns from src to dst. Note that as Cid is not a general number
+// AssignTo assigns from src to dst. Note that as CID is not a general number
 // type AssignTo does not do automatic type conversion as other number types do.
-func (src *Cid) AssignTo(dst interface{}) error {
+func (src *CID) AssignTo(dst interface{}) error {
 	return (*pguint32)(src).AssignTo(dst)
 }
 
-func (dst *Cid) DecodeText(ci *ConnInfo, src []byte) error {
+func (dst *CID) DecodeText(ci *ConnInfo, src []byte) error {
 	return (*pguint32)(dst).DecodeText(ci, src)
 }
 
-func (dst *Cid) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (dst *CID) DecodeBinary(ci *ConnInfo, src []byte) error {
 	return (*pguint32)(dst).DecodeBinary(ci, src)
 }
 
-func (src *Cid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*pguint32)(src).EncodeText(ci, buf)
 }
 
-func (src *Cid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*pguint32)(src).EncodeBinary(ci, buf)
 }
 
 // Scan implements the database/sql Scanner interface.
-func (dst *Cid) Scan(src interface{}) error {
+func (dst *CID) Scan(src interface{}) error {
 	return (*pguint32)(dst).Scan(src)
 }
 
 // Value implements the database/sql/driver Valuer interface.
-func (src *Cid) Value() (driver.Value, error) {
+func (src *CID) Value() (driver.Value, error) {
 	return (*pguint32)(src).Value()
 }
diff --git a/cid_test.go b/cid_test.go
index c3bf3132..0dfc56d4 100644
--- a/cid_test.go
+++ b/cid_test.go
@@ -8,11 +8,11 @@ import (
 	"github.com/jackc/pgx/pgtype/testutil"
 )
 
-func TestCidTranscode(t *testing.T) {
+func TestCIDTranscode(t *testing.T) {
 	pgTypeName := "cid"
 	values := []interface{}{
-		&pgtype.Cid{Uint: 42, Status: pgtype.Present},
-		&pgtype.Cid{Status: pgtype.Null},
+		&pgtype.CID{Uint: 42, Status: pgtype.Present},
+		&pgtype.CID{Status: pgtype.Null},
 	}
 	eqFunc := func(a, b interface{}) bool {
 		return reflect.DeepEqual(a, b)
@@ -28,16 +28,16 @@ func TestCidTranscode(t *testing.T) {
 	}
 }
 
-func TestCidSet(t *testing.T) {
+func TestCIDSet(t *testing.T) {
 	successfulTests := []struct {
 		source interface{}
-		result pgtype.Cid
+		result pgtype.CID
 	}{
-		{source: uint32(1), result: pgtype.Cid{Uint: 1, Status: pgtype.Present}},
+		{source: uint32(1), result: pgtype.CID{Uint: 1, Status: pgtype.Present}},
 	}
 
 	for i, tt := range successfulTests {
-		var r pgtype.Cid
+		var r pgtype.CID
 		err := r.Set(tt.source)
 		if err != nil {
 			t.Errorf("%d: %v", i, err)
@@ -49,17 +49,17 @@ func TestCidSet(t *testing.T) {
 	}
 }
 
-func TestCidAssignTo(t *testing.T) {
+func TestCIDAssignTo(t *testing.T) {
 	var ui32 uint32
 	var pui32 *uint32
 
 	simpleTests := []struct {
-		src      pgtype.Cid
+		src      pgtype.CID
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Cid{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
-		{src: pgtype.Cid{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
+		{src: pgtype.CID{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
+		{src: pgtype.CID{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
 	}
 
 	for i, tt := range simpleTests {
@@ -74,11 +74,11 @@ func TestCidAssignTo(t *testing.T) {
 	}
 
 	pointerAllocTests := []struct {
-		src      pgtype.Cid
+		src      pgtype.CID
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Cid{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
+		{src: pgtype.CID{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
 	}
 
 	for i, tt := range pointerAllocTests {
@@ -93,10 +93,10 @@ func TestCidAssignTo(t *testing.T) {
 	}
 
 	errorTests := []struct {
-		src pgtype.Cid
+		src pgtype.CID
 		dst interface{}
 	}{
-		{src: pgtype.Cid{Status: pgtype.Null}, dst: &ui32},
+		{src: pgtype.CID{Status: pgtype.Null}, dst: &ui32},
 	}
 
 	for i, tt := range errorTests {
diff --git a/cidr.go b/cidr.go
index 2b45d2d0..519b9cae 100644
--- a/cidr.go
+++ b/cidr.go
@@ -1,31 +1,31 @@
 package pgtype
 
-type Cidr Inet
+type CIDR Inet
 
-func (dst *Cidr) Set(src interface{}) error {
+func (dst *CIDR) Set(src interface{}) error {
 	return (*Inet)(dst).Set(src)
 }
 
-func (dst *Cidr) Get() interface{} {
+func (dst *CIDR) Get() interface{} {
 	return (*Inet)(dst).Get()
 }
 
-func (src *Cidr) AssignTo(dst interface{}) error {
+func (src *CIDR) AssignTo(dst interface{}) error {
 	return (*Inet)(src).AssignTo(dst)
 }
 
-func (dst *Cidr) DecodeText(ci *ConnInfo, src []byte) error {
+func (dst *CIDR) DecodeText(ci *ConnInfo, src []byte) error {
 	return (*Inet)(dst).DecodeText(ci, src)
 }
 
-func (dst *Cidr) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (dst *CIDR) DecodeBinary(ci *ConnInfo, src []byte) error {
 	return (*Inet)(dst).DecodeBinary(ci, src)
 }
 
-func (src *Cidr) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CIDR) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*Inet)(src).EncodeText(ci, buf)
 }
 
-func (src *Cidr) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CIDR) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*Inet)(src).EncodeBinary(ci, buf)
 }
diff --git a/cidr_array.go b/cidr_array.go
index b8a70d63..9b7b50fa 100644
--- a/cidr_array.go
+++ b/cidr_array.go
@@ -9,28 +9,28 @@ import (
 	"github.com/jackc/pgx/pgio"
 )
 
-type CidrArray struct {
-	Elements   []Cidr
+type CIDRArray struct {
+	Elements   []CIDR
 	Dimensions []ArrayDimension
 	Status     Status
 }
 
-func (dst *CidrArray) Set(src interface{}) error {
+func (dst *CIDRArray) Set(src interface{}) error {
 	switch value := src.(type) {
 
 	case []*net.IPNet:
 		if value == nil {
-			*dst = CidrArray{Status: Null}
+			*dst = CIDRArray{Status: Null}
 		} else if len(value) == 0 {
-			*dst = CidrArray{Status: Present}
+			*dst = CIDRArray{Status: Present}
 		} else {
-			elements := make([]Cidr, len(value))
+			elements := make([]CIDR, len(value))
 			for i := range value {
 				if err := elements[i].Set(value[i]); err != nil {
 					return err
 				}
 			}
-			*dst = CidrArray{
+			*dst = CIDRArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
 				Status:     Present,
@@ -39,17 +39,17 @@ func (dst *CidrArray) Set(src interface{}) error {
 
 	case []net.IP:
 		if value == nil {
-			*dst = CidrArray{Status: Null}
+			*dst = CIDRArray{Status: Null}
 		} else if len(value) == 0 {
-			*dst = CidrArray{Status: Present}
+			*dst = CIDRArray{Status: Present}
 		} else {
-			elements := make([]Cidr, len(value))
+			elements := make([]CIDR, len(value))
 			for i := range value {
 				if err := elements[i].Set(value[i]); err != nil {
 					return err
 				}
 			}
-			*dst = CidrArray{
+			*dst = CIDRArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
 				Status:     Present,
@@ -60,13 +60,13 @@ func (dst *CidrArray) Set(src interface{}) error {
 		if originalSrc, ok := underlyingSliceType(src); ok {
 			return dst.Set(originalSrc)
 		}
-		return fmt.Errorf("cannot convert %v to Cidr", value)
+		return fmt.Errorf("cannot convert %v to CIDR", value)
 	}
 
 	return nil
 }
 
-func (dst *CidrArray) Get() interface{} {
+func (dst *CIDRArray) Get() interface{} {
 	switch dst.Status {
 	case Present:
 		return dst
@@ -77,7 +77,7 @@ func (dst *CidrArray) Get() interface{} {
 	}
 }
 
-func (src *CidrArray) AssignTo(dst interface{}) error {
+func (src *CIDRArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
 		switch v := dst.(type) {
@@ -112,9 +112,9 @@ func (src *CidrArray) AssignTo(dst interface{}) error {
 	return fmt.Errorf("cannot decode %v into %T", src, dst)
 }
 
-func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
+func (dst *CIDRArray) DecodeText(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = CidrArray{Status: Null}
+		*dst = CIDRArray{Status: Null}
 		return nil
 	}
 
@@ -123,13 +123,13 @@ func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
 		return err
 	}
 
-	var elements []Cidr
+	var elements []CIDR
 
 	if len(uta.Elements) > 0 {
-		elements = make([]Cidr, len(uta.Elements))
+		elements = make([]CIDR, len(uta.Elements))
 
 		for i, s := range uta.Elements {
-			var elem Cidr
+			var elem CIDR
 			var elemSrc []byte
 			if s != "NULL" {
 				elemSrc = []byte(s)
@@ -143,14 +143,14 @@ func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = CidrArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
+	*dst = CIDRArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
 
 	return nil
 }
 
-func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (dst *CIDRArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = CidrArray{Status: Null}
+		*dst = CIDRArray{Status: Null}
 		return nil
 	}
 
@@ -161,7 +161,7 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 	}
 
 	if len(arrayHeader.Dimensions) == 0 {
-		*dst = CidrArray{Dimensions: arrayHeader.Dimensions, Status: Present}
+		*dst = CIDRArray{Dimensions: arrayHeader.Dimensions, Status: Present}
 		return nil
 	}
 
@@ -170,7 +170,7 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 		elementCount *= d.Length
 	}
 
-	elements := make([]Cidr, elementCount)
+	elements := make([]CIDR, elementCount)
 
 	for i := range elements {
 		elemLen := int(int32(binary.BigEndian.Uint32(src[rp:])))
@@ -186,11 +186,11 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = CidrArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
+	*dst = CIDRArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
 	return nil
 }
 
-func (src *CidrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CIDRArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	switch src.Status {
 	case Null:
 		return nil, nil
@@ -247,7 +247,7 @@ func (src *CidrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return buf, nil
 }
 
-func (src *CidrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *CIDRArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	switch src.Status {
 	case Null:
 		return nil, nil
@@ -292,7 +292,7 @@ func (src *CidrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 }
 
 // Scan implements the database/sql Scanner interface.
-func (dst *CidrArray) Scan(src interface{}) error {
+func (dst *CIDRArray) Scan(src interface{}) error {
 	if src == nil {
 		return dst.DecodeText(nil, nil)
 	}
@@ -310,7 +310,7 @@ func (dst *CidrArray) Scan(src interface{}) error {
 }
 
 // Value implements the database/sql/driver Valuer interface.
-func (src *CidrArray) Value() (driver.Value, error) {
+func (src *CIDRArray) Value() (driver.Value, error) {
 	buf, err := src.EncodeText(nil, nil)
 	if err != nil {
 		return nil, err
diff --git a/cidr_array_test.go b/cidr_array_test.go
index 1ebe5195..70d3f65b 100644
--- a/cidr_array_test.go
+++ b/cidr_array_test.go
@@ -9,40 +9,40 @@ import (
 	"github.com/jackc/pgx/pgtype/testutil"
 )
 
-func TestCidrArrayTranscode(t *testing.T) {
+func TestCIDRArrayTranscode(t *testing.T) {
 	testutil.TestSuccessfulTranscode(t, "cidr[]", []interface{}{
-		&pgtype.CidrArray{
+		&pgtype.CIDRArray{
 			Elements:   nil,
 			Dimensions: nil,
 			Status:     pgtype.Present,
 		},
-		&pgtype.CidrArray{
-			Elements: []pgtype.Cidr{
-				pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-				pgtype.Cidr{Status: pgtype.Null},
+		&pgtype.CIDRArray{
+			Elements: []pgtype.CIDR{
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.CIDR{Status: pgtype.Null},
 			},
 			Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}},
 			Status:     pgtype.Present,
 		},
-		&pgtype.CidrArray{Status: pgtype.Null},
-		&pgtype.CidrArray{
-			Elements: []pgtype.Cidr{
-				pgtype.Cidr{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
-				pgtype.Cidr{Status: pgtype.Null},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
+		&pgtype.CIDRArray{Status: pgtype.Null},
+		&pgtype.CIDRArray{
+			Elements: []pgtype.CIDR{
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
+				pgtype.CIDR{Status: pgtype.Null},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
 			},
 			Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}},
 			Status:     pgtype.Present,
 		},
-		&pgtype.CidrArray{
-			Elements: []pgtype.Cidr{
-				pgtype.Cidr{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
-				pgtype.Cidr{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
+		&pgtype.CIDRArray{
+			Elements: []pgtype.CIDR{
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
+				pgtype.CIDR{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
 			},
 			Dimensions: []pgtype.ArrayDimension{
 				{Length: 2, LowerBound: 4},
@@ -53,37 +53,37 @@ func TestCidrArrayTranscode(t *testing.T) {
 	})
 }
 
-func TestCidrArraySet(t *testing.T) {
+func TestCIDRArraySet(t *testing.T) {
 	successfulTests := []struct {
 		source interface{}
-		result pgtype.CidrArray
+		result pgtype.CIDRArray
 	}{
 		{
-			source: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
-			result: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+			source: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
+			result: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present},
 		},
 		{
 			source: (([]*net.IPNet)(nil)),
-			result: pgtype.CidrArray{Status: pgtype.Null},
+			result: pgtype.CIDRArray{Status: pgtype.Null},
 		},
 		{
-			source: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
-			result: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+			source: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
+			result: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present},
 		},
 		{
 			source: (([]net.IP)(nil)),
-			result: pgtype.CidrArray{Status: pgtype.Null},
+			result: pgtype.CIDRArray{Status: pgtype.Null},
 		},
 	}
 
 	for i, tt := range successfulTests {
-		var r pgtype.CidrArray
+		var r pgtype.CIDRArray
 		err := r.Set(tt.source)
 		if err != nil {
 			t.Errorf("%d: %v", i, err)
@@ -95,27 +95,27 @@ func TestCidrArraySet(t *testing.T) {
 	}
 }
 
-func TestCidrArrayAssignTo(t *testing.T) {
+func TestCIDRArrayAssignTo(t *testing.T) {
 	var ipnetSlice []*net.IPNet
 	var ipSlice []net.IP
 
 	simpleTests := []struct {
-		src      pgtype.CidrArray
+		src      pgtype.CIDRArray
 		dst      interface{}
 		expected interface{}
 	}{
 		{
-			src: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+			src: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
 			dst:      &ipnetSlice,
-			expected: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
+			expected: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
 		},
 		{
-			src: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{Status: pgtype.Null}},
+			src: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{Status: pgtype.Null}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
@@ -123,17 +123,17 @@ func TestCidrArrayAssignTo(t *testing.T) {
 			expected: []*net.IPNet{nil},
 		},
 		{
-			src: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+			src: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
 			dst:      &ipSlice,
-			expected: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
+			expected: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
 		},
 		{
-			src: pgtype.CidrArray{
-				Elements:   []pgtype.Cidr{{Status: pgtype.Null}},
+			src: pgtype.CIDRArray{
+				Elements:   []pgtype.CIDR{{Status: pgtype.Null}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
@@ -141,12 +141,12 @@ func TestCidrArrayAssignTo(t *testing.T) {
 			expected: []net.IP{nil},
 		},
 		{
-			src:      pgtype.CidrArray{Status: pgtype.Null},
+			src:      pgtype.CIDRArray{Status: pgtype.Null},
 			dst:      &ipnetSlice,
 			expected: (([]*net.IPNet)(nil)),
 		},
 		{
-			src:      pgtype.CidrArray{Status: pgtype.Null},
+			src:      pgtype.CIDRArray{Status: pgtype.Null},
 			dst:      &ipSlice,
 			expected: (([]net.IP)(nil)),
 		},
diff --git a/inet_array_test.go b/inet_array_test.go
index c0465922..3e2b6a3c 100644
--- a/inet_array_test.go
+++ b/inet_array_test.go
@@ -18,7 +18,7 @@ func TestInetArrayTranscode(t *testing.T) {
 		},
 		&pgtype.InetArray{
 			Elements: []pgtype.Inet{
-				pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
 				pgtype.Inet{Status: pgtype.Null},
 			},
 			Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}},
@@ -27,22 +27,22 @@ func TestInetArrayTranscode(t *testing.T) {
 		&pgtype.InetArray{Status: pgtype.Null},
 		&pgtype.InetArray{
 			Elements: []pgtype.Inet{
-				pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
 				pgtype.Inet{Status: pgtype.Null},
-				pgtype.Inet{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
 			},
 			Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}},
 			Status:     pgtype.Present,
 		},
 		&pgtype.InetArray{
 			Elements: []pgtype.Inet{
-				pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
-				pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
+				pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
 			},
 			Dimensions: []pgtype.ArrayDimension{
 				{Length: 2, LowerBound: 4},
@@ -59,9 +59,9 @@ func TestInetArraySet(t *testing.T) {
 		result pgtype.InetArray
 	}{
 		{
-			source: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
+			source: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
 			result: pgtype.InetArray{
-				Elements:   []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+				Elements:   []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present},
 		},
@@ -70,9 +70,9 @@ func TestInetArraySet(t *testing.T) {
 			result: pgtype.InetArray{Status: pgtype.Null},
 		},
 		{
-			source: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
+			source: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
 			result: pgtype.InetArray{
-				Elements:   []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+				Elements:   []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present},
 		},
@@ -106,12 +106,12 @@ func TestInetArrayAssignTo(t *testing.T) {
 	}{
 		{
 			src: pgtype.InetArray{
-				Elements:   []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+				Elements:   []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
 			dst:      &ipnetSlice,
-			expected: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
+			expected: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
 		},
 		{
 			src: pgtype.InetArray{
@@ -124,12 +124,12 @@ func TestInetArrayAssignTo(t *testing.T) {
 		},
 		{
 			src: pgtype.InetArray{
-				Elements:   []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+				Elements:   []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
 				Status:     pgtype.Present,
 			},
 			dst:      &ipSlice,
-			expected: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
+			expected: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
 		},
 		{
 			src: pgtype.InetArray{
diff --git a/inet_test.go b/inet_test.go
index b883df8e..32d66999 100644
--- a/inet_test.go
+++ b/inet_test.go
@@ -12,16 +12,16 @@ import (
 func TestInetTranscode(t *testing.T) {
 	for _, pgTypeName := range []string{"inet", "cidr"} {
 		testutil.TestSuccessfulTranscode(t, pgTypeName, []interface{}{
-			&pgtype.Inet{IPNet: mustParseCidr(t, "0.0.0.0/32"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "192.168.1.0/24"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "255.255.255.255/32"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "::/128"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "::/0"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "::1/128"), Status: pgtype.Present},
-			&pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "0.0.0.0/32"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.1.0/24"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "255.255.255.255/32"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "::/128"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "::/0"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "::1/128"), Status: pgtype.Present},
+			&pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
 			&pgtype.Inet{Status: pgtype.Null},
 		})
 	}
@@ -32,9 +32,9 @@ func TestInetSet(t *testing.T) {
 		source interface{}
 		result pgtype.Inet
 	}{
-		{source: mustParseCidr(t, "127.0.0.1/32"), result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
-		{source: mustParseCidr(t, "127.0.0.1/32").IP, result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
-		{source: "127.0.0.1/32", result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
+		{source: mustParseCIDR(t, "127.0.0.1/32"), result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
+		{source: mustParseCIDR(t, "127.0.0.1/32").IP, result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
+		{source: "127.0.0.1/32", result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
 	}
 
 	for i, tt := range successfulTests {
@@ -61,8 +61,8 @@ func TestInetAssignTo(t *testing.T) {
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ipnet, expected: *mustParseCidr(t, "127.0.0.1/32")},
-		{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ip, expected: mustParseCidr(t, "127.0.0.1/32").IP},
+		{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ipnet, expected: *mustParseCIDR(t, "127.0.0.1/32")},
+		{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ip, expected: mustParseCIDR(t, "127.0.0.1/32").IP},
 		{src: pgtype.Inet{Status: pgtype.Null}, dst: &pipnet, expected: ((*net.IPNet)(nil))},
 		{src: pgtype.Inet{Status: pgtype.Null}, dst: &pip, expected: ((*net.IP)(nil))},
 	}
@@ -83,8 +83,8 @@ func TestInetAssignTo(t *testing.T) {
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pipnet, expected: *mustParseCidr(t, "127.0.0.1/32")},
-		{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pip, expected: mustParseCidr(t, "127.0.0.1/32").IP},
+		{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pipnet, expected: *mustParseCIDR(t, "127.0.0.1/32")},
+		{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pip, expected: mustParseCIDR(t, "127.0.0.1/32").IP},
 	}
 
 	for i, tt := range pointerAllocTests {
@@ -102,7 +102,7 @@ func TestInetAssignTo(t *testing.T) {
 		src pgtype.Inet
 		dst interface{}
 	}{
-		{src: pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.0/16"), Status: pgtype.Present}, dst: &ip},
+		{src: pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.0/16"), Status: pgtype.Present}, dst: &ip},
 		{src: pgtype.Inet{Status: pgtype.Null}, dst: &ipnet},
 	}
 
diff --git a/pgtype.go b/pgtype.go
index 4fdcf3c2..4302a5fe 100644
--- a/pgtype.go
+++ b/pgtype.go
@@ -16,12 +16,12 @@ const (
 	Int4OID             = 23
 	TextOID             = 25
 	OIDOID              = 26
-	TidOID              = 27
-	XidOID              = 28
-	CidOID              = 29
+	TIDOID              = 27
+	XIDOID              = 28
+	CIDOID              = 29
 	JSONOID             = 114
-	CidrOID             = 650
-	CidrArrayOID        = 651
+	CIDROID             = 650
+	CIDRArrayOID        = 651
 	Float4OID           = 700
 	Float8OID           = 701
 	UnknownOID          = 705
@@ -209,7 +209,7 @@ func init() {
 		"_aclitem":     &ACLItemArray{},
 		"_bool":        &BoolArray{},
 		"_bytea":       &ByteaArray{},
-		"_cidr":        &CidrArray{},
+		"_cidr":        &CIDRArray{},
 		"_date":        &DateArray{},
 		"_float4":      &Float4Array{},
 		"_float8":      &Float8Array{},
@@ -227,8 +227,8 @@ func init() {
 		"box":          &Box{},
 		"bytea":        &Bytea{},
 		"char":         &QChar{},
-		"cid":          &Cid{},
-		"cidr":         &Cidr{},
+		"cid":          &CID{},
+		"cidr":         &CIDR{},
 		"circle":       &Circle{},
 		"date":         &Date{},
 		"daterange":    &Daterange{},
@@ -256,7 +256,7 @@ func init() {
 		"polygon":      &Polygon{},
 		"record":       &Record{},
 		"text":         &Text{},
-		"tid":          &Tid{},
+		"tid":          &TID{},
 		"timestamp":    &Timestamp{},
 		"timestamptz":  &Timestamptz{},
 		"tsrange":      &Tsrange{},
@@ -265,6 +265,6 @@ func init() {
 		"uuid":         &UUID{},
 		"varbit":       &Varbit{},
 		"varchar":      &Varchar{},
-		"xid":          &Xid{},
+		"xid":          &XID{},
 	}
 }
diff --git a/pgtype_test.go b/pgtype_test.go
index 716e063d..f7e743b2 100644
--- a/pgtype_test.go
+++ b/pgtype_test.go
@@ -20,7 +20,7 @@ type _float32Slice []float32
 type _float64Slice []float64
 type _byteSlice []byte
 
-func mustParseCidr(t testing.TB, s string) *net.IPNet {
+func mustParseCIDR(t testing.TB, s string) *net.IPNet {
 	_, ipnet, err := net.ParseCIDR(s)
 	if err != nil {
 		t.Fatal(err)
diff --git a/pguint32.go b/pguint32.go
index c15ee6d7..15b0f38d 100644
--- a/pguint32.go
+++ b/pguint32.go
@@ -11,7 +11,7 @@ import (
 )
 
 // pguint32 is the core type that is used to implement PostgreSQL types such as
-// Cid and Xid.
+// CID and XID.
 type pguint32 struct {
 	Uint   uint32
 	Status Status
diff --git a/tid.go b/tid.go
index 2f4412cb..d44ea3a6 100644
--- a/tid.go
+++ b/tid.go
@@ -10,7 +10,7 @@ import (
 	"github.com/jackc/pgx/pgio"
 )
 
-// Tid is PostgreSQL's Tuple Identifier type.
+// TID is PostgreSQL's Tuple Identifier type.
 //
 // When one does
 //
@@ -21,17 +21,17 @@ import (
 // It is currently implemented as a pair unsigned two byte integers.
 // Its conversion functions can be found in src/backend/utils/adt/tid.c
 // in the PostgreSQL sources.
-type Tid struct {
+type TID struct {
 	BlockNumber  uint32
 	OffsetNumber uint16
 	Status       Status
 }
 
-func (dst *Tid) Set(src interface{}) error {
-	return fmt.Errorf("cannot convert %v to Tid", src)
+func (dst *TID) Set(src interface{}) error {
+	return fmt.Errorf("cannot convert %v to TID", src)
 }
 
-func (dst *Tid) Get() interface{} {
+func (dst *TID) Get() interface{} {
 	switch dst.Status {
 	case Present:
 		return dst
@@ -42,13 +42,13 @@ func (dst *Tid) Get() interface{} {
 	}
 }
 
-func (src *Tid) AssignTo(dst interface{}) error {
+func (src *TID) AssignTo(dst interface{}) error {
 	return fmt.Errorf("cannot assign %v to %T", src, dst)
 }
 
-func (dst *Tid) DecodeText(ci *ConnInfo, src []byte) error {
+func (dst *TID) DecodeText(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = Tid{Status: Null}
+		*dst = TID{Status: Null}
 		return nil
 	}
 
@@ -71,13 +71,13 @@ func (dst *Tid) DecodeText(ci *ConnInfo, src []byte) error {
 		return err
 	}
 
-	*dst = Tid{BlockNumber: uint32(blockNumber), OffsetNumber: uint16(offsetNumber), Status: Present}
+	*dst = TID{BlockNumber: uint32(blockNumber), OffsetNumber: uint16(offsetNumber), Status: Present}
 	return nil
 }
 
-func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (dst *TID) DecodeBinary(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = Tid{Status: Null}
+		*dst = TID{Status: Null}
 		return nil
 	}
 
@@ -85,7 +85,7 @@ func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
 		return fmt.Errorf("invalid length for tid: %v", len(src))
 	}
 
-	*dst = Tid{
+	*dst = TID{
 		BlockNumber:  binary.BigEndian.Uint32(src),
 		OffsetNumber: binary.BigEndian.Uint16(src[4:]),
 		Status:       Present,
@@ -93,7 +93,7 @@ func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
 	return nil
 }
 
-func (src *Tid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *TID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	switch src.Status {
 	case Null:
 		return nil, nil
@@ -105,7 +105,7 @@ func (src *Tid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return buf, nil
 }
 
-func (src *Tid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *TID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	switch src.Status {
 	case Null:
 		return nil, nil
@@ -119,9 +119,9 @@ func (src *Tid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 }
 
 // Scan implements the database/sql Scanner interface.
-func (dst *Tid) Scan(src interface{}) error {
+func (dst *TID) Scan(src interface{}) error {
 	if src == nil {
-		*dst = Tid{Status: Null}
+		*dst = TID{Status: Null}
 		return nil
 	}
 
@@ -138,6 +138,6 @@ func (dst *Tid) Scan(src interface{}) error {
 }
 
 // Value implements the database/sql/driver Valuer interface.
-func (src *Tid) Value() (driver.Value, error) {
+func (src *TID) Value() (driver.Value, error) {
 	return EncodeValueText(src)
 }
diff --git a/tid_test.go b/tid_test.go
index a5430d11..9185cb31 100644
--- a/tid_test.go
+++ b/tid_test.go
@@ -7,10 +7,10 @@ import (
 	"github.com/jackc/pgx/pgtype/testutil"
 )
 
-func TestTidTranscode(t *testing.T) {
+func TestTIDTranscode(t *testing.T) {
 	testutil.TestSuccessfulTranscode(t, "tid", []interface{}{
-		&pgtype.Tid{BlockNumber: 42, OffsetNumber: 43, Status: pgtype.Present},
-		&pgtype.Tid{BlockNumber: 4294967295, OffsetNumber: 65535, Status: pgtype.Present},
-		&pgtype.Tid{Status: pgtype.Null},
+		&pgtype.TID{BlockNumber: 42, OffsetNumber: 43, Status: pgtype.Present},
+		&pgtype.TID{BlockNumber: 4294967295, OffsetNumber: 65535, Status: pgtype.Present},
+		&pgtype.TID{Status: pgtype.Null},
 	})
 }
diff --git a/typed_array_gen.sh b/typed_array_gen.sh
index d7abcbcf..1aa6c354 100644
--- a/typed_array_gen.sh
+++ b/typed_array_gen.sh
@@ -8,7 +8,7 @@ erb pgtype_array_type=TimestampArray pgtype_element_type=Timestamp go_array_type
 erb pgtype_array_type=Float4Array pgtype_element_type=Float4 go_array_types=[]float32 element_type_name=float4 text_null=NULL binary_format=true typed_array.go.erb > float4_array.go
 erb pgtype_array_type=Float8Array pgtype_element_type=Float8 go_array_types=[]float64 element_type_name=float8 text_null=NULL binary_format=true typed_array.go.erb > float8_array.go
 erb pgtype_array_type=InetArray pgtype_element_type=Inet go_array_types=[]*net.IPNet,[]net.IP element_type_name=inet text_null=NULL binary_format=true typed_array.go.erb > inet_array.go
-erb pgtype_array_type=CidrArray pgtype_element_type=Cidr go_array_types=[]*net.IPNet,[]net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go
+erb pgtype_array_type=CIDRArray pgtype_element_type=CIDR go_array_types=[]*net.IPNet,[]net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go
 erb pgtype_array_type=TextArray pgtype_element_type=Text go_array_types=[]string element_type_name=text text_null='"NULL"' binary_format=true typed_array.go.erb > text_array.go
 erb pgtype_array_type=VarcharArray pgtype_element_type=Varchar go_array_types=[]string element_type_name=varchar text_null='"NULL"' binary_format=true typed_array.go.erb > varchar_array.go
 erb pgtype_array_type=ByteaArray pgtype_element_type=Bytea go_array_types=[][]byte element_type_name=bytea text_null=NULL binary_format=true typed_array.go.erb > bytea_array.go
diff --git a/xid.go b/xid.go
index 84acd1b0..f66f5367 100644
--- a/xid.go
+++ b/xid.go
@@ -4,7 +4,7 @@ import (
 	"database/sql/driver"
 )
 
-// Xid is PostgreSQL's Transaction ID type.
+// XID is PostgreSQL's Transaction ID type.
 //
 // In later versions of PostgreSQL, it is the type used for the backend_xid
 // and backend_xmin columns of the pg_stat_activity system view.
@@ -18,47 +18,47 @@ import (
 // It is currently implemented as an unsigned four byte integer.
 // Its definition can be found in src/include/postgres_ext.h as TransactionId
 // in the PostgreSQL sources.
-type Xid pguint32
+type XID pguint32
 
-// Set converts from src to dst. Note that as Xid is not a general
+// Set converts from src to dst. Note that as XID is not a general
 // number type Set does not do automatic type conversion as other number
 // types do.
-func (dst *Xid) Set(src interface{}) error {
+func (dst *XID) Set(src interface{}) error {
 	return (*pguint32)(dst).Set(src)
 }
 
-func (dst *Xid) Get() interface{} {
+func (dst *XID) Get() interface{} {
 	return (*pguint32)(dst).Get()
 }
 
-// AssignTo assigns from src to dst. Note that as Xid is not a general number
+// AssignTo assigns from src to dst. Note that as XID is not a general number
 // type AssignTo does not do automatic type conversion as other number types do.
-func (src *Xid) AssignTo(dst interface{}) error {
+func (src *XID) AssignTo(dst interface{}) error {
 	return (*pguint32)(src).AssignTo(dst)
 }
 
-func (dst *Xid) DecodeText(ci *ConnInfo, src []byte) error {
+func (dst *XID) DecodeText(ci *ConnInfo, src []byte) error {
 	return (*pguint32)(dst).DecodeText(ci, src)
 }
 
-func (dst *Xid) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (dst *XID) DecodeBinary(ci *ConnInfo, src []byte) error {
 	return (*pguint32)(dst).DecodeBinary(ci, src)
 }
 
-func (src *Xid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *XID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*pguint32)(src).EncodeText(ci, buf)
 }
 
-func (src *Xid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
+func (src *XID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	return (*pguint32)(src).EncodeBinary(ci, buf)
 }
 
 // Scan implements the database/sql Scanner interface.
-func (dst *Xid) Scan(src interface{}) error {
+func (dst *XID) Scan(src interface{}) error {
 	return (*pguint32)(dst).Scan(src)
 }
 
 // Value implements the database/sql/driver Valuer interface.
-func (src *Xid) Value() (driver.Value, error) {
+func (src *XID) Value() (driver.Value, error) {
 	return (*pguint32)(src).Value()
 }
diff --git a/xid_test.go b/xid_test.go
index c4a1bec3..d0f3f0ab 100644
--- a/xid_test.go
+++ b/xid_test.go
@@ -8,11 +8,11 @@ import (
 	"github.com/jackc/pgx/pgtype/testutil"
 )
 
-func TestXidTranscode(t *testing.T) {
+func TestXIDTranscode(t *testing.T) {
 	pgTypeName := "xid"
 	values := []interface{}{
-		&pgtype.Xid{Uint: 42, Status: pgtype.Present},
-		&pgtype.Xid{Status: pgtype.Null},
+		&pgtype.XID{Uint: 42, Status: pgtype.Present},
+		&pgtype.XID{Status: pgtype.Null},
 	}
 	eqFunc := func(a, b interface{}) bool {
 		return reflect.DeepEqual(a, b)
@@ -28,16 +28,16 @@ func TestXidTranscode(t *testing.T) {
 	}
 }
 
-func TestXidSet(t *testing.T) {
+func TestXIDSet(t *testing.T) {
 	successfulTests := []struct {
 		source interface{}
-		result pgtype.Xid
+		result pgtype.XID
 	}{
-		{source: uint32(1), result: pgtype.Xid{Uint: 1, Status: pgtype.Present}},
+		{source: uint32(1), result: pgtype.XID{Uint: 1, Status: pgtype.Present}},
 	}
 
 	for i, tt := range successfulTests {
-		var r pgtype.Xid
+		var r pgtype.XID
 		err := r.Set(tt.source)
 		if err != nil {
 			t.Errorf("%d: %v", i, err)
@@ -49,17 +49,17 @@ func TestXidSet(t *testing.T) {
 	}
 }
 
-func TestXidAssignTo(t *testing.T) {
+func TestXIDAssignTo(t *testing.T) {
 	var ui32 uint32
 	var pui32 *uint32
 
 	simpleTests := []struct {
-		src      pgtype.Xid
+		src      pgtype.XID
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Xid{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
-		{src: pgtype.Xid{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
+		{src: pgtype.XID{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
+		{src: pgtype.XID{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
 	}
 
 	for i, tt := range simpleTests {
@@ -74,11 +74,11 @@ func TestXidAssignTo(t *testing.T) {
 	}
 
 	pointerAllocTests := []struct {
-		src      pgtype.Xid
+		src      pgtype.XID
 		dst      interface{}
 		expected interface{}
 	}{
-		{src: pgtype.Xid{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
+		{src: pgtype.XID{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
 	}
 
 	for i, tt := range pointerAllocTests {
@@ -93,10 +93,10 @@ func TestXidAssignTo(t *testing.T) {
 	}
 
 	errorTests := []struct {
-		src pgtype.Xid
+		src pgtype.XID
 		dst interface{}
 	}{
-		{src: pgtype.Xid{Status: pgtype.Null}, dst: &ui32},
+		{src: pgtype.XID{Status: pgtype.Null}, dst: &ui32},
 	}
 
 	for i, tt := range errorTests {