diff --git a/examples/url_shortener/main.go b/examples/url_shortener/main.go
index 121959223..0887a0198 100644
--- a/examples/url_shortener/main.go
+++ b/examples/url_shortener/main.go
@@ -2,7 +2,7 @@ package main
 
 import (
 	"context"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"os"
@@ -29,7 +29,7 @@ func getUrlHandler(w http.ResponseWriter, req *http.Request) {
 func putUrlHandler(w http.ResponseWriter, req *http.Request) {
 	id := req.URL.Path
 	var url string
-	if body, err := ioutil.ReadAll(req.Body); err == nil {
+	if body, err := io.ReadAll(req.Body); err == nil {
 		url = string(body)
 	} else {
 		http.Error(w, "Internal server error", http.StatusInternalServerError)
diff --git a/pgtype/array.go b/pgtype/array.go
index 7dfee389e..737619568 100644
--- a/pgtype/array.go
+++ b/pgtype/array.go
@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
-	"reflect"
 	"strconv"
 	"strings"
 	"unicode"
@@ -375,27 +374,6 @@ func quoteArrayElementIfNeeded(src string) string {
 	return src
 }
 
-func findDimensionsFromValue(value reflect.Value, dimensions []ArrayDimension, elementsLength int) ([]ArrayDimension, int, bool) {
-	switch value.Kind() {
-	case reflect.Array:
-		fallthrough
-	case reflect.Slice:
-		length := value.Len()
-		if 0 == elementsLength {
-			elementsLength = length
-		} else {
-			elementsLength *= length
-		}
-		dimensions = append(dimensions, ArrayDimension{Length: int32(length), LowerBound: 1})
-		for i := 0; i < length; i++ {
-			if d, l, ok := findDimensionsFromValue(value.Index(i), dimensions, elementsLength); ok {
-				return d, l, true
-			}
-		}
-	}
-	return dimensions, elementsLength, true
-}
-
 // Array represents a PostgreSQL array for T. It implements the ArrayGetter and ArraySetter interfaces. It preserves
 // PostgreSQL dimensions and custom lower bounds. Use FlatArray if these are not needed.
 type Array[T any] struct {
diff --git a/pgtype/convert.go b/pgtype/convert.go
index 7fddeaa8a..8a9cee9c3 100644
--- a/pgtype/convert.go
+++ b/pgtype/convert.go
@@ -1,380 +1,9 @@
 package pgtype
 
 import (
-	"database/sql"
-	"fmt"
-	"math"
 	"reflect"
-	"time"
 )
 
-const (
-	maxUint = ^uint(0)
-	maxInt  = int(maxUint >> 1)
-	minInt  = -maxInt - 1
-)
-
-// underlyingNumberType gets the underlying type that can be converted to Int2, Int4, Int8, Float4, or Float8
-func underlyingNumberType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	case reflect.Int:
-		convVal := int(refVal.Int())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Int8:
-		convVal := int8(refVal.Int())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Int16:
-		convVal := int16(refVal.Int())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Int32:
-		convVal := int32(refVal.Int())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Int64:
-		convVal := int64(refVal.Int())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Uint:
-		convVal := uint(refVal.Uint())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Uint8:
-		convVal := uint8(refVal.Uint())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Uint16:
-		convVal := uint16(refVal.Uint())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Uint32:
-		convVal := uint32(refVal.Uint())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Uint64:
-		convVal := uint64(refVal.Uint())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Float32:
-		convVal := float32(refVal.Float())
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Float64:
-		convVal := refVal.Float()
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.String:
-		convVal := refVal.String()
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	case reflect.Bool:
-		convVal := refVal.Bool()
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	}
-
-	return nil, false
-}
-
-// underlyingBoolType gets the underlying type that can be converted to Bool
-func underlyingBoolType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	case reflect.Bool:
-		convVal := refVal.Bool()
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	}
-
-	return nil, false
-}
-
-// underlyingBytesType gets the underlying type that can be converted to []byte
-func underlyingBytesType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	case reflect.Slice:
-		if refVal.Type().Elem().Kind() == reflect.Uint8 {
-			convVal := refVal.Bytes()
-			return convVal, reflect.TypeOf(convVal) != refVal.Type()
-		}
-	}
-
-	return nil, false
-}
-
-// underlyingStringType gets the underlying type that can be converted to String
-func underlyingStringType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	case reflect.String:
-		convVal := refVal.String()
-		return convVal, reflect.TypeOf(convVal) != refVal.Type()
-	}
-
-	return nil, false
-}
-
-// underlyingPtrType dereferences a pointer
-func underlyingPtrType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	}
-
-	return nil, false
-}
-
-// underlyingTimeType gets the underlying type that can be converted to time.Time
-func underlyingTimeType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	}
-
-	timeType := reflect.TypeOf(time.Time{})
-	if refVal.Type().ConvertibleTo(timeType) {
-		return refVal.Convert(timeType).Interface(), true
-	}
-
-	return nil, false
-}
-
-// underlyingUUIDType gets the underlying type that can be converted to [16]byte
-func underlyingUUIDType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return time.Time{}, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	}
-
-	uuidType := reflect.TypeOf([16]byte{})
-	if refVal.Type().ConvertibleTo(uuidType) {
-		return refVal.Convert(uuidType).Interface(), true
-	}
-
-	return nil, false
-}
-
-// underlyingSliceType gets the underlying slice type
-func underlyingSliceType(val any) (any, bool) {
-	refVal := reflect.ValueOf(val)
-
-	switch refVal.Kind() {
-	case reflect.Ptr:
-		if refVal.IsNil() {
-			return nil, false
-		}
-		convVal := refVal.Elem().Interface()
-		return convVal, true
-	case reflect.Slice:
-		baseSliceType := reflect.SliceOf(refVal.Type().Elem())
-		if refVal.Type().ConvertibleTo(baseSliceType) {
-			convVal := refVal.Convert(baseSliceType)
-			return convVal.Interface(), reflect.TypeOf(convVal.Interface()) != refVal.Type()
-		}
-	}
-
-	return nil, false
-}
-
-func int64AssignTo(srcVal int64, srcValid bool, dst any) error {
-	if srcValid {
-		switch v := dst.(type) {
-		case *int:
-			if srcVal < int64(minInt) {
-				return fmt.Errorf("%d is less than minimum value for int", srcVal)
-			} else if srcVal > int64(maxInt) {
-				return fmt.Errorf("%d is greater than maximum value for int", srcVal)
-			}
-			*v = int(srcVal)
-		case *int8:
-			if srcVal < math.MinInt8 {
-				return fmt.Errorf("%d is less than minimum value for int8", srcVal)
-			} else if srcVal > math.MaxInt8 {
-				return fmt.Errorf("%d is greater than maximum value for int8", srcVal)
-			}
-			*v = int8(srcVal)
-		case *int16:
-			if srcVal < math.MinInt16 {
-				return fmt.Errorf("%d is less than minimum value for int16", srcVal)
-			} else if srcVal > math.MaxInt16 {
-				return fmt.Errorf("%d is greater than maximum value for int16", srcVal)
-			}
-			*v = int16(srcVal)
-		case *int32:
-			if srcVal < math.MinInt32 {
-				return fmt.Errorf("%d is less than minimum value for int32", srcVal)
-			} else if srcVal > math.MaxInt32 {
-				return fmt.Errorf("%d is greater than maximum value for int32", srcVal)
-			}
-			*v = int32(srcVal)
-		case *int64:
-			if srcVal < math.MinInt64 {
-				return fmt.Errorf("%d is less than minimum value for int64", srcVal)
-			} else if srcVal > math.MaxInt64 {
-				return fmt.Errorf("%d is greater than maximum value for int64", srcVal)
-			}
-			*v = int64(srcVal)
-		case *uint:
-			if srcVal < 0 {
-				return fmt.Errorf("%d is less than zero for uint", srcVal)
-			} else if uint64(srcVal) > uint64(maxUint) {
-				return fmt.Errorf("%d is greater than maximum value for uint", srcVal)
-			}
-			*v = uint(srcVal)
-		case *uint8:
-			if srcVal < 0 {
-				return fmt.Errorf("%d is less than zero for uint8", srcVal)
-			} else if srcVal > math.MaxUint8 {
-				return fmt.Errorf("%d is greater than maximum value for uint8", srcVal)
-			}
-			*v = uint8(srcVal)
-		case *uint16:
-			if srcVal < 0 {
-				return fmt.Errorf("%d is less than zero for uint16", srcVal)
-			} else if srcVal > math.MaxUint16 {
-				return fmt.Errorf("%d is greater than maximum value for uint16", srcVal)
-			}
-			*v = uint16(srcVal)
-		case *uint32:
-			if srcVal < 0 {
-				return fmt.Errorf("%d is less than zero for uint32", srcVal)
-			} else if srcVal > math.MaxUint32 {
-				return fmt.Errorf("%d is greater than maximum value for uint32", srcVal)
-			}
-			*v = uint32(srcVal)
-		case *uint64:
-			if srcVal < 0 {
-				return fmt.Errorf("%d is less than zero for uint64", srcVal)
-			}
-			*v = uint64(srcVal)
-		case sql.Scanner:
-			return v.Scan(srcVal)
-		default:
-			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
-				el := v.Elem()
-				switch el.Kind() {
-				// if dst is a pointer to pointer, strip the pointer and try again
-				case reflect.Ptr:
-					if el.IsNil() {
-						// allocate destination
-						el.Set(reflect.New(el.Type().Elem()))
-					}
-					return int64AssignTo(srcVal, srcValid, el.Interface())
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-					if el.OverflowInt(int64(srcVal)) {
-						return fmt.Errorf("cannot put %d into %T", srcVal, dst)
-					}
-					el.SetInt(int64(srcVal))
-					return nil
-				case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-					if srcVal < 0 {
-						return fmt.Errorf("%d is less than zero for %T", srcVal, dst)
-					}
-					if el.OverflowUint(uint64(srcVal)) {
-						return fmt.Errorf("cannot put %d into %T", srcVal, dst)
-					}
-					el.SetUint(uint64(srcVal))
-					return nil
-				}
-			}
-			return fmt.Errorf("cannot assign %v into %T", srcVal, dst)
-		}
-		return nil
-	}
-
-	// if dst is a pointer to pointer and srcStatus is not Valid, nil it out
-	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
-		el := v.Elem()
-		if el.Kind() == reflect.Ptr {
-			el.Set(reflect.Zero(el.Type()))
-			return nil
-		}
-	}
-
-	return fmt.Errorf("cannot assign %v %v into %T", srcVal, srcValid, dst)
-}
-
-func float64AssignTo(srcVal float64, srcValid bool, dst any) error {
-	if srcValid {
-		switch v := dst.(type) {
-		case *float32:
-			*v = float32(srcVal)
-		case *float64:
-			*v = srcVal
-		default:
-			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
-				el := v.Elem()
-				switch el.Kind() {
-				// if dst is a type alias of a float32 or 64, set dst val
-				case reflect.Float32, reflect.Float64:
-					el.SetFloat(srcVal)
-					return nil
-				// if dst is a pointer to pointer, strip the pointer and try again
-				case reflect.Ptr:
-					if el.IsNil() {
-						// allocate destination
-						el.Set(reflect.New(el.Type().Elem()))
-					}
-					return float64AssignTo(srcVal, srcValid, el.Interface())
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-					i64 := int64(srcVal)
-					if float64(i64) == srcVal {
-						return int64AssignTo(i64, srcValid, dst)
-					}
-				}
-			}
-			return fmt.Errorf("cannot assign %v into %T", srcVal, dst)
-		}
-		return nil
-	}
-
-	// if dst is a pointer to pointer and srcStatus is not Valid, nil it out
-	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
-		el := v.Elem()
-		if el.Kind() == reflect.Ptr {
-			el.Set(reflect.Zero(el.Type()))
-			return nil
-		}
-	}
-
-	return fmt.Errorf("cannot assign %v %v into %T", srcVal, srcValid, dst)
-}
-
 func NullAssignTo(dst any) error {
 	dstPtr := reflect.ValueOf(dst)
 
diff --git a/pgtype/numeric.go b/pgtype/numeric.go
index 4e0ccc9a1..62e457873 100644
--- a/pgtype/numeric.go
+++ b/pgtype/numeric.go
@@ -33,23 +33,6 @@ var big10 *big.Int = big.NewInt(10)
 var big100 *big.Int = big.NewInt(100)
 var big1000 *big.Int = big.NewInt(1000)
 
-var bigMaxInt8 *big.Int = big.NewInt(math.MaxInt8)
-var bigMinInt8 *big.Int = big.NewInt(math.MinInt8)
-var bigMaxInt16 *big.Int = big.NewInt(math.MaxInt16)
-var bigMinInt16 *big.Int = big.NewInt(math.MinInt16)
-var bigMaxInt32 *big.Int = big.NewInt(math.MaxInt32)
-var bigMinInt32 *big.Int = big.NewInt(math.MinInt32)
-var bigMaxInt64 *big.Int = big.NewInt(math.MaxInt64)
-var bigMinInt64 *big.Int = big.NewInt(math.MinInt64)
-var bigMaxInt *big.Int = big.NewInt(int64(maxInt))
-var bigMinInt *big.Int = big.NewInt(int64(minInt))
-
-var bigMaxUint8 *big.Int = big.NewInt(math.MaxUint8)
-var bigMaxUint16 *big.Int = big.NewInt(math.MaxUint16)
-var bigMaxUint32 *big.Int = big.NewInt(math.MaxUint32)
-var bigMaxUint64 *big.Int = (&big.Int{}).SetUint64(uint64(math.MaxUint64))
-var bigMaxUint *big.Int = (&big.Int{}).SetUint64(uint64(maxUint))
-
 var bigNBase *big.Int = big.NewInt(nbase)
 var bigNBaseX2 *big.Int = big.NewInt(nbase * nbase)
 var bigNBaseX3 *big.Int = big.NewInt(nbase * nbase * nbase)
diff --git a/pgtype/pgtype.go b/pgtype/pgtype.go
index b9cd7b410..8b636763a 100644
--- a/pgtype/pgtype.go
+++ b/pgtype/pgtype.go
@@ -1140,25 +1140,6 @@ func (m *Map) Scan(oid uint32, formatCode int16, src []byte, dst any) error {
 	return plan.Scan(src, dst)
 }
 
-func scanUnknownType(oid uint32, formatCode int16, buf []byte, dest any) error {
-	switch dest := dest.(type) {
-	case *string:
-		if formatCode == BinaryFormatCode {
-			return fmt.Errorf("unknown oid %d in binary format cannot be scanned into %T", oid, dest)
-		}
-		*dest = string(buf)
-		return nil
-	case *[]byte:
-		*dest = buf
-		return nil
-	default:
-		if nextDst, retry := GetAssignToDstType(dest); retry {
-			return scanUnknownType(oid, formatCode, buf, nextDst)
-		}
-		return fmt.Errorf("unknown oid %d cannot be scanned into %T", oid, dest)
-	}
-}
-
 var ErrScanTargetTypeChanged = errors.New("scan target type changed")
 
 func codecScan(codec Codec, m *Map, oid uint32, format int16, src []byte, dst any) error {
diff --git a/pgtype/pgtype_test.go b/pgtype/pgtype_test.go
index 5affc0c71..24d9e25bf 100644
--- a/pgtype/pgtype_test.go
+++ b/pgtype/pgtype_test.go
@@ -47,15 +47,6 @@ type _byteSlice []byte
 // is not known (e.g. when using the simple protocol).
 const unregisteredOID = uint32(1)
 
-func mustParseCIDR(t testing.TB, s string) *net.IPNet {
-	_, ipnet, err := net.ParseCIDR(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return ipnet
-}
-
 func mustParseInet(t testing.TB, s string) *net.IPNet {
 	ip, ipnet, err := net.ParseCIDR(s)
 	if err == nil {