Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

pgcatalog

package

Go to main page

Versions in this module

v1

v1.2.0

Dec 9, 2018

v1.1.1

Dec 2, 2018

v1.1.0

Oct 23, 2018

v1.0.0

Aug 26, 2018

Changes in this version

+ var XOLog = func(string, ...interface{})

+ func ASCII(db XODB, v0 string) (int, error)

+ func ASCIIToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func ASCIIToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Abbrev(db XODB, v0 pgtypes.Cidr, v1 string) (string, error)

+ func Abs(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func Abstime(db XODB, v0 time.Time, v1 time.Time) (pgtypes.Abstime, error)

+ func Abstimeeq(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimege(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimegt(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimein(db XODB, v0 pgtypes.Cstring) (pgtypes.Abstime, error)

+ func Abstimele(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimelt(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimene(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (bool, error)

+ func Abstimeout(db XODB, v0 pgtypes.Abstime) (pgtypes.Cstring, error)

+ func Abstimerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Abstime, error)

+ func Abstimesend(db XODB, v0 pgtypes.Abstime) ([]byte, error)

+ func Aclcontains(db XODB, v0 []pgtypes.Aclitem, v1 pgtypes.Aclitem) (bool, error)

+ func Acldefault(db XODB, v0 uint8, v1 pgtypes.Oid) ([]pgtypes.Aclitem, error)

+ func Aclexplode(db XODB, v0 []pgtypes.Aclitem) ([]pgtypes.Record, error)

+ func Aclinsert(db XODB, v0 []pgtypes.Aclitem, v1 pgtypes.Aclitem) ([]pgtypes.Aclitem, error)

+ func Aclitemeq(db XODB, v0 pgtypes.Aclitem, v1 pgtypes.Aclitem) (bool, error)

+ func Aclitemin(db XODB, v0 pgtypes.Cstring) (pgtypes.Aclitem, error)

+ func Aclitemout(db XODB, v0 pgtypes.Aclitem) (pgtypes.Cstring, error)

+ func Aclremove(db XODB, v0 []pgtypes.Aclitem, v1 pgtypes.Aclitem) ([]pgtypes.Aclitem, error)

+ func Acos(db XODB, v0 float64) (float64, error)

+ func Age(db XODB, v0 pgtypes.Xid, v1 time.Time, v2 time.Time, v3 time.Time, ...) (*time.Duration, error)

+ func AnyIn(db XODB, v0 pgtypes.Cstring) ([]byte, error)

+ func AnyOut(db XODB, v0 []byte) (pgtypes.Cstring, error)

+ func AnyarrayIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Anyarray, error)

+ func AnyarrayOut(db XODB, v0 pgtypes.Anyarray) (pgtypes.Cstring, error)

+ func AnyarrayRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Anyarray, error)

+ func AnyarraySend(db XODB, v0 pgtypes.Anyarray) ([]byte, error)

+ func AnyelementIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Anyelement, error)

+ func AnyelementOut(db XODB, v0 pgtypes.Anyelement) (pgtypes.Cstring, error)

+ func AnyenumIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Anyenum, error)

+ func AnyenumOut(db XODB, v0 pgtypes.Anyenum) (pgtypes.Cstring, error)

+ func AnynonarrayIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Anynonarray, error)

+ func AnynonarrayOut(db XODB, v0 pgtypes.Anynonarray) (pgtypes.Cstring, error)

+ func AnyrangeIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (pgtypes.Anyrange, error)

+ func AnyrangeOut(db XODB, v0 pgtypes.Anyrange) (pgtypes.Cstring, error)

+ func Anytextcat(db XODB, v0 pgtypes.Anynonarray, v1 string) (string, error)

+ func Area(db XODB, v0 pgtypes.Path, v1 pgtypes.Box, v2 pgtypes.Circle) (float64, error)

+ func Areajoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Areasel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func ArrayAgg(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anynonarray) (pgtypes.Anyarray, error)

+ func ArrayAggArrayFinalfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyarray) (pgtypes.Anyarray, error)

+ func ArrayAggArrayTransfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyarray) (pgtypes.Internal, error)

+ func ArrayAggFinalfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anynonarray) (pgtypes.Anyarray, error)

+ func ArrayAggTransfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anynonarray) (pgtypes.Internal, error)

+ func ArrayAppend(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyelement) (pgtypes.Anyarray, error)

+ func ArrayCat(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (pgtypes.Anyarray, error)

+ func ArrayDims(db XODB, v0 pgtypes.Anyarray) (string, error)

+ func ArrayEq(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayFill(db XODB, v0 pgtypes.Anyelement, v1 []int, v2 pgtypes.Anyelement, v3 []int, ...) (pgtypes.Anyarray, error)

+ func ArrayGe(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayGt(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (pgtypes.Anyarray, error)

+ func ArrayLarger(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (pgtypes.Anyarray, error)

+ func ArrayLe(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayLength(db XODB, v0 pgtypes.Anyarray, v1 int) (int, error)

+ func ArrayLower(db XODB, v0 pgtypes.Anyarray, v1 int) (int, error)

+ func ArrayLt(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayNdims(db XODB, v0 pgtypes.Anyarray) (int, error)

+ func ArrayNe(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func ArrayOut(db XODB, v0 pgtypes.Anyarray) (pgtypes.Cstring, error)

+ func ArrayPosition(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyelement, v2 pgtypes.Anyarray, ...) (int, error)

+ func ArrayPositions(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyelement) ([]int, error)

+ func ArrayPrepend(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Anyarray) (pgtypes.Anyarray, error)

+ func ArrayRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (pgtypes.Anyarray, error)

+ func ArrayRemove(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyelement) (pgtypes.Anyarray, error)

+ func ArrayReplace(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyelement, v2 pgtypes.Anyelement) (pgtypes.Anyarray, error)

+ func ArraySend(db XODB, v0 pgtypes.Anyarray) ([]byte, error)

+ func ArraySmaller(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (pgtypes.Anyarray, error)

+ func ArrayToJSON(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray, v2 bool) (pgtypes.JSON, error)

+ func ArrayToString(db XODB, v0 pgtypes.Anyarray, v1 string, v2 pgtypes.Anyarray, v3 string, ...) (string, error)

+ func ArrayTypanalyze(db XODB, v0 pgtypes.Internal) (bool, error)

+ func ArrayUpper(db XODB, v0 pgtypes.Anyarray, v1 int) (int, error)

+ func Arraycontained(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func Arraycontains(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func Arraycontjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Arraycontsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Arrayoverlap(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (bool, error)

+ func Asin(db XODB, v0 float64) (float64, error)

+ func Atan(db XODB, v0 float64) (float64, error)

+ func Atan2(db XODB, v0 float64, v1 float64) (float64, error)

+ func Avg(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 *time.Duration, ...) (*time.Duration, error)

+ func Bernoulli(db XODB, v0 pgtypes.Internal) (pgtypes.TsmHandler, error)

+ func Big5ToEucTw(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Big5ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Big5ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func BinaryUpgradeCreateEmptyExtension(db XODB, v0 string, v1 string, v2 bool, v3 string, v4 []pgtypes.Oid, ...) error

+ func BinaryUpgradeSetNextArrayPgTypeOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextHeapPgClassOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextIndexPgClassOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextPgAuthidOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextPgEnumOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextPgTypeOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextToastPgClassOid(db XODB, v0 pgtypes.Oid) error

+ func BinaryUpgradeSetNextToastPgTypeOid(db XODB, v0 pgtypes.Oid) error

+ func Bit(db XODB, v0 int64, v1 int, v2 int, v3 int, v4 uint8, v5 int, v6 bool) (uint8, error)

+ func BitAnd(db XODB, v0 int64, v1 int16, v2 int, v3 uint8) (uint8, error)

+ func BitIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (uint8, error)

+ func BitLength(db XODB, v0 []byte, v1 string, v2 uint8) (int, error)

+ func BitOr(db XODB, v0 int64, v1 int16, v2 int, v3 uint8) (uint8, error)

+ func BitOut(db XODB, v0 uint8) (pgtypes.Cstring, error)

+ func BitRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (uint8, error)

+ func BitSend(db XODB, v0 uint8) ([]byte, error)

+ func Bitand(db XODB, v0 uint8, v1 uint8) (uint8, error)

+ func Bitcat(db XODB, v0 []byte, v1 []byte) ([]byte, error)

+ func Bitcmp(db XODB, v0 uint8, v1 uint8) (int, error)

+ func Biteq(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitge(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitgt(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitle(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitlt(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitne(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Bitnot(db XODB, v0 uint8) (uint8, error)

+ func Bitor(db XODB, v0 uint8, v1 uint8) (uint8, error)

+ func Bitshiftleft(db XODB, v0 uint8, v1 int) (uint8, error)

+ func Bitshiftright(db XODB, v0 uint8, v1 int) (uint8, error)

+ func Bittypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Bittypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Bitxor(db XODB, v0 uint8, v1 uint8) (uint8, error)

+ func Bool(db XODB, v0 int) (bool, error)

+ func BoolAccum(db XODB, v0 pgtypes.Internal, v1 bool) (pgtypes.Internal, error)

+ func BoolAccumInv(db XODB, v0 pgtypes.Internal, v1 bool) (pgtypes.Internal, error)

+ func BoolAlltrue(db XODB, v0 pgtypes.Internal) (bool, error)

+ func BoolAnd(db XODB, v0 bool) (bool, error)

+ func BoolAnytrue(db XODB, v0 pgtypes.Internal) (bool, error)

+ func BoolOr(db XODB, v0 bool) (bool, error)

+ func BoolandStatefunc(db XODB, v0 bool, v1 bool) (bool, error)

+ func Booleq(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boolge(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boolgt(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boolin(db XODB, v0 pgtypes.Cstring) (bool, error)

+ func Boolle(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boollt(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boolne(db XODB, v0 bool, v1 bool) (bool, error)

+ func BoolorStatefunc(db XODB, v0 bool, v1 bool) (bool, error)

+ func Boolout(db XODB, v0 bool) (pgtypes.Cstring, error)

+ func Boolrecv(db XODB, v0 pgtypes.Internal) (bool, error)

+ func Boolsend(db XODB, v0 bool) ([]byte, error)

+ func BoundBox(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (pgtypes.Box, error)

+ func Box(db XODB, v0 pgtypes.Point, v1 pgtypes.Polygon, v2 pgtypes.Circle, ...) (pgtypes.Box, error)

+ func BoxAbove(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxAboveEq(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxAdd(db XODB, v0 pgtypes.Box, v1 pgtypes.Point) (pgtypes.Box, error)

+ func BoxBelow(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxBelowEq(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxCenter(db XODB, v0 pgtypes.Box) (pgtypes.Point, error)

+ func BoxContain(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxContainPt(db XODB, v0 pgtypes.Box, v1 pgtypes.Point) (bool, error)

+ func BoxContained(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxDistance(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (float64, error)

+ func BoxDiv(db XODB, v0 pgtypes.Box, v1 pgtypes.Point) (pgtypes.Box, error)

+ func BoxEq(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxGe(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxGt(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Box, error)

+ func BoxIntersect(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (pgtypes.Box, error)

+ func BoxLe(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxLeft(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxLt(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxMul(db XODB, v0 pgtypes.Box, v1 pgtypes.Point) (pgtypes.Box, error)

+ func BoxOut(db XODB, v0 pgtypes.Box) (pgtypes.Cstring, error)

+ func BoxOverabove(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxOverbelow(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxOverlap(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxOverleft(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxOverright(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Box, error)

+ func BoxRight(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxSame(db XODB, v0 pgtypes.Box, v1 pgtypes.Box) (bool, error)

+ func BoxSend(db XODB, v0 pgtypes.Box) ([]byte, error)

+ func BoxSub(db XODB, v0 pgtypes.Box, v1 pgtypes.Point) (pgtypes.Box, error)

+ func Bpchar(db XODB, v0 uint8, v1 pgtypes.Name, v2 string, v3 int, v4 bool) (string, error)

+ func BpcharLarger(db XODB, v0 string, v1 string) (string, error)

+ func BpcharPatternGe(db XODB, v0 string, v1 string) (bool, error)

+ func BpcharPatternGt(db XODB, v0 string, v1 string) (bool, error)

+ func BpcharPatternLe(db XODB, v0 string, v1 string) (bool, error)

+ func BpcharPatternLt(db XODB, v0 string, v1 string) (bool, error)

+ func BpcharSmaller(db XODB, v0 string, v1 string) (string, error)

+ func Bpcharcmp(db XODB, v0 string, v1 string) (int, error)

+ func Bpchareq(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharge(db XODB, v0 string, v1 string) (bool, error)

+ func Bpchargt(db XODB, v0 string, v1 string) (bool, error)

+ func Bpchariclike(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharicnlike(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharicregexeq(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharicregexne(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharin(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (string, error)

+ func Bpcharle(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharlike(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharlt(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharne(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharnlike(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharout(db XODB, v0 string) (pgtypes.Cstring, error)

+ func Bpcharrecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (string, error)

+ func Bpcharregexeq(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharregexne(db XODB, v0 string, v1 string) (bool, error)

+ func Bpcharsend(db XODB, v0 string) ([]byte, error)

+ func Bpchartypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Bpchartypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func BrinInclusionAddValue(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func BrinInclusionConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (bool, error)

+ func BrinInclusionOpcinfo(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func BrinInclusionUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (bool, error)

+ func BrinMinmaxAddValue(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func BrinMinmaxConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (bool, error)

+ func BrinMinmaxOpcinfo(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func BrinMinmaxUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (bool, error)

+ func BrinSummarizeNewValues(db XODB, v0 pgtypes.Regclass) (int, error)

+ func Brinbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Brinbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Brinbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Brinbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Brincostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Brinendscan(db XODB, v0 pgtypes.Internal) error

+ func Bringetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Brininsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Brinmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Brinoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Brinrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Brinrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Brinvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func Broadcast(db XODB, v0 string) (string, error)

+ func Btabstimecmp(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (int, error)

+ func Btarraycmp(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Anyarray) (int, error)

+ func Btbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Btboolcmp(db XODB, v0 bool, v1 bool) (int, error)

+ func BtbpcharPatternCmp(db XODB, v0 string, v1 string) (int, error)

+ func Btbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Btbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Btbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Btcanreturn(db XODB, v0 pgtypes.Internal, v1 int) (bool, error)

+ func Btcharcmp(db XODB, v0 uint8, v1 uint8) (int, error)

+ func Btcostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Btendscan(db XODB, v0 pgtypes.Internal) error

+ func Btfloat48cmp(db XODB, v0 float32, v1 float64) (int, error)

+ func Btfloat4cmp(db XODB, v0 float32, v1 float32) (int, error)

+ func Btfloat4sortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btfloat84cmp(db XODB, v0 float64, v1 float32) (int, error)

+ func Btfloat8cmp(db XODB, v0 float64, v1 float64) (int, error)

+ func Btfloat8sortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btgetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Btgettuple(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func Btinsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Btint24cmp(db XODB, v0 int16, v1 int) (int, error)

+ func Btint28cmp(db XODB, v0 int16, v1 int64) (int, error)

+ func Btint2cmp(db XODB, v0 int16, v1 int16) (int, error)

+ func Btint2sortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btint42cmp(db XODB, v0 int, v1 int16) (int, error)

+ func Btint48cmp(db XODB, v0 int, v1 int64) (int, error)

+ func Btint4cmp(db XODB, v0 int, v1 int) (int, error)

+ func Btint4sortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btint82cmp(db XODB, v0 int64, v1 int16) (int, error)

+ func Btint84cmp(db XODB, v0 int64, v1 int) (int, error)

+ func Btint8cmp(db XODB, v0 int64, v1 int64) (int, error)

+ func Btint8sortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Btnamecmp(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (int, error)

+ func Btnamesortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btoidcmp(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (int, error)

+ func Btoidsortsupport(db XODB, v0 pgtypes.Internal) error

+ func Btoidvectorcmp(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (int, error)

+ func Btoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Btrecordcmp(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (int, error)

+ func Btrecordimagecmp(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (int, error)

+ func Btreltimecmp(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (int, error)

+ func Btrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Btrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Btrim(db XODB, v0 string, v1 []byte, v2 []byte, v3 string, v4 string) ([]byte, error)

+ func BttextPatternCmp(db XODB, v0 string, v1 string) (int, error)

+ func Bttextcmp(db XODB, v0 string, v1 string) (int, error)

+ func Bttextsortsupport(db XODB, v0 pgtypes.Internal) error

+ func Bttidcmp(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (int, error)

+ func Bttintervalcmp(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (int, error)

+ func Btvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func ByteaStringAggFinalfn(db XODB, v0 pgtypes.Internal) ([]byte, error)

+ func ByteaStringAggTransfn(db XODB, v0 pgtypes.Internal, v1 []byte, v2 []byte) (pgtypes.Internal, error)

+ func Byteacat(db XODB, v0 []byte, v1 []byte) ([]byte, error)

+ func Byteacmp(db XODB, v0 []byte, v1 []byte) (int, error)

+ func Byteaeq(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteage(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteagt(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteain(db XODB, v0 pgtypes.Cstring) ([]byte, error)

+ func Byteale(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Bytealike(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Bytealt(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteane(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteanlike(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Byteaout(db XODB, v0 []byte) (pgtypes.Cstring, error)

+ func Bytearecv(db XODB, v0 pgtypes.Internal) ([]byte, error)

+ func Byteasend(db XODB, v0 []byte) ([]byte, error)

+ func Cardinality(db XODB, v0 pgtypes.Anyarray) (int, error)

+ func CashCmp(db XODB, v0 string, v1 string) (int, error)

+ func CashDivCash(db XODB, v0 string, v1 string) (float64, error)

+ func CashDivFlt4(db XODB, v0 string, v1 float32) (string, error)

+ func CashDivFlt8(db XODB, v0 string, v1 float64) (string, error)

+ func CashDivInt2(db XODB, v0 string, v1 int16) (string, error)

+ func CashDivInt4(db XODB, v0 string, v1 int) (string, error)

+ func CashEq(db XODB, v0 string, v1 string) (bool, error)

+ func CashGe(db XODB, v0 string, v1 string) (bool, error)

+ func CashGt(db XODB, v0 string, v1 string) (bool, error)

+ func CashIn(db XODB, v0 pgtypes.Cstring) (string, error)

+ func CashLe(db XODB, v0 string, v1 string) (bool, error)

+ func CashLt(db XODB, v0 string, v1 string) (bool, error)

+ func CashMi(db XODB, v0 string, v1 string) (string, error)

+ func CashMulFlt4(db XODB, v0 string, v1 float32) (string, error)

+ func CashMulFlt8(db XODB, v0 string, v1 float64) (string, error)

+ func CashMulInt2(db XODB, v0 string, v1 int16) (string, error)

+ func CashMulInt4(db XODB, v0 string, v1 int) (string, error)

+ func CashNe(db XODB, v0 string, v1 string) (bool, error)

+ func CashOut(db XODB, v0 string) (pgtypes.Cstring, error)

+ func CashPl(db XODB, v0 string, v1 string) (string, error)

+ func CashRecv(db XODB, v0 pgtypes.Internal) (string, error)

+ func CashSend(db XODB, v0 string) ([]byte, error)

+ func CashWords(db XODB, v0 string) (string, error)

+ func Cashlarger(db XODB, v0 string, v1 string) (string, error)

+ func Cashsmaller(db XODB, v0 string, v1 string) (string, error)

+ func Cbrt(db XODB, v0 float64) (float64, error)

+ func Ceil(db XODB, v0 float64, v1 float64) (float64, error)

+ func Ceiling(db XODB, v0 float64, v1 float64) (float64, error)

+ func Center(db XODB, v0 pgtypes.Box, v1 pgtypes.Circle) (pgtypes.Point, error)

+ func Char(db XODB, v0 int, v1 string) (uint8, error)

+ func CharLength(db XODB, v0 string, v1 string) (int, error)

+ func CharacterLength(db XODB, v0 string, v1 string) (int, error)

+ func Chareq(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Charge(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Chargt(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Charin(db XODB, v0 pgtypes.Cstring) (uint8, error)

+ func Charle(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Charlt(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Charne(db XODB, v0 uint8, v1 uint8) (bool, error)

+ func Charout(db XODB, v0 uint8) (pgtypes.Cstring, error)

+ func Charrecv(db XODB, v0 pgtypes.Internal) (uint8, error)

+ func Charsend(db XODB, v0 uint8) ([]byte, error)

+ func Chr(db XODB, v0 int) (string, error)

+ func Cideq(db XODB, v0 pgtypes.Cid, v1 pgtypes.Cid) (bool, error)

+ func Cidin(db XODB, v0 pgtypes.Cstring) (pgtypes.Cid, error)

+ func Cidout(db XODB, v0 pgtypes.Cid) (pgtypes.Cstring, error)

+ func Cidr(db XODB, v0 string) (pgtypes.Cidr, error)

+ func CidrIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Cidr, error)

+ func CidrOut(db XODB, v0 pgtypes.Cidr) (pgtypes.Cstring, error)

+ func CidrRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Cidr, error)

+ func CidrSend(db XODB, v0 pgtypes.Cidr) ([]byte, error)

+ func Cidrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Cid, error)

+ func Cidsend(db XODB, v0 pgtypes.Cid) ([]byte, error)

+ func Circle(db XODB, v0 pgtypes.Box, v1 pgtypes.Polygon, v2 pgtypes.Point, v3 float64) (pgtypes.Circle, error)

+ func CircleAbove(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleAddPt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (pgtypes.Circle, error)

+ func CircleBelow(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleCenter(db XODB, v0 pgtypes.Circle) (pgtypes.Point, error)

+ func CircleContain(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleContainPt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (bool, error)

+ func CircleContained(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleDistance(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (float64, error)

+ func CircleDivPt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (pgtypes.Circle, error)

+ func CircleEq(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleGe(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleGt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Circle, error)

+ func CircleLe(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleLeft(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleLt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleMulPt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (pgtypes.Circle, error)

+ func CircleNe(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleOut(db XODB, v0 pgtypes.Circle) (pgtypes.Cstring, error)

+ func CircleOverabove(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleOverbelow(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleOverlap(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleOverleft(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleOverright(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Circle, error)

+ func CircleRight(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleSame(db XODB, v0 pgtypes.Circle, v1 pgtypes.Circle) (bool, error)

+ func CircleSend(db XODB, v0 pgtypes.Circle) ([]byte, error)

+ func CircleSubPt(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (pgtypes.Circle, error)

+ func ClockTimestamp(db XODB) (time.Time, error)

+ func CloseLb(db XODB, v0 pgtypes.Line, v1 pgtypes.Box) (pgtypes.Point, error)

+ func CloseLs(db XODB, v0 pgtypes.Line, v1 pgtypes.Lseg) (pgtypes.Point, error)

+ func CloseLseg(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (pgtypes.Point, error)

+ func ClosePb(db XODB, v0 pgtypes.Point, v1 pgtypes.Box) (pgtypes.Point, error)

+ func ClosePl(db XODB, v0 pgtypes.Point, v1 pgtypes.Line) (pgtypes.Point, error)

+ func ClosePs(db XODB, v0 pgtypes.Point, v1 pgtypes.Lseg) (pgtypes.Point, error)

+ func CloseSb(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Box) (pgtypes.Point, error)

+ func CloseSl(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line) (pgtypes.Point, error)

+ func ColDescription(db XODB, v0 pgtypes.Oid, v1 int) (string, error)

+ func Concat(db XODB, v0 []byte) (string, error)

+ func ConcatWs(db XODB, v0 string, v1 []byte) (string, error)

+ func Contjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Contsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Convert(db XODB, v0 []byte, v1 pgtypes.Name, v2 pgtypes.Name) ([]byte, error)

+ func ConvertFrom(db XODB, v0 []byte, v1 pgtypes.Name) (string, error)

+ func ConvertTo(db XODB, v0 string, v1 pgtypes.Name) ([]byte, error)

+ func Corr(db XODB, v0 float64, v1 float64) (float64, error)

+ func Cos(db XODB, v0 float64) (float64, error)

+ func Cot(db XODB, v0 float64) (float64, error)

+ func Count(db XODB, v0 []byte) (int64, error)

+ func CovarPop(db XODB, v0 float64, v1 float64) (float64, error)

+ func CovarSamp(db XODB, v0 float64, v1 float64) (float64, error)

+ func CstringIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Cstring, error)

+ func CstringOut(db XODB, v0 pgtypes.Cstring) (pgtypes.Cstring, error)

+ func CstringRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Cstring, error)

+ func CstringSend(db XODB, v0 pgtypes.Cstring) ([]byte, error)

+ func CumeDist(db XODB, v0 []byte) (float64, error)

+ func CumeDistFinal(db XODB, v0 pgtypes.Internal, v1 []byte) (float64, error)

+ func CurrentDatabase(db XODB) (pgtypes.Name, error)

+ func CurrentQuery(db XODB) (string, error)

+ func CurrentSchema(db XODB) (pgtypes.Name, error)

+ func CurrentSchemas(db XODB, v0 bool) ([]pgtypes.Name, error)

+ func CurrentSetting(db XODB, v0 string) (string, error)

+ func CurrentUser(db XODB) (pgtypes.Name, error)

+ func Currtid(db XODB, v0 pgtypes.Oid, v1 pgtypes.Tid) (pgtypes.Tid, error)

+ func Currtid2(db XODB, v0 string, v1 pgtypes.Tid) (pgtypes.Tid, error)

+ func Currval(db XODB, v0 pgtypes.Regclass) (int64, error)

+ func CursorToXML(db XODB, v0 pgtypes.Refcursor, v1 int, v2 bool, v3 bool, v4 string) (pgtypes.XML, error)

+ func CursorToXmlschema(db XODB, v0 pgtypes.Refcursor, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func DatabaseToXML(db XODB, v0 bool, v1 bool, v2 string) (pgtypes.XML, error)

+ func DatabaseToXMLAndXmlschema(db XODB, v0 bool, v1 bool, v2 string) (pgtypes.XML, error)

+ func DatabaseToXmlschema(db XODB, v0 bool, v1 bool, v2 string) (pgtypes.XML, error)

+ func Date(db XODB, v0 pgtypes.Abstime, v1 time.Time, v2 time.Time) (time.Time, error)

+ func DateCmp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func DateCmpTimestamp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func DateCmpTimestamptz(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func DateEq(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateEqTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateEqTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGtTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateGtTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateIn(db XODB, v0 pgtypes.Cstring) (time.Time, error)

+ func DateLarger(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func DateLe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateLeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateLeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateLt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateLtTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateLtTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateMi(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func DateMiInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func DateMii(db XODB, v0 time.Time, v1 int) (time.Time, error)

+ func DateNe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateNeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateNeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func DateOut(db XODB, v0 time.Time) (pgtypes.Cstring, error)

+ func DatePart(db XODB, v0 string, v1 pgtypes.Abstime, v2 string, v3 pgtypes.Reltime, ...) (float64, error)

+ func DatePlInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func DatePli(db XODB, v0 time.Time, v1 int) (time.Time, error)

+ func DateRecv(db XODB, v0 pgtypes.Internal) (time.Time, error)

+ func DateSend(db XODB, v0 time.Time) ([]byte, error)

+ func DateSmaller(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func DateSortsupport(db XODB, v0 pgtypes.Internal) error

+ func DateTrunc(db XODB, v0 string, v1 time.Time, v2 string, v3 time.Time, v4 string, ...) (time.Time, error)

+ func Daterange(db XODB, v0 time.Time, v1 time.Time, v2 time.Time, v3 time.Time, v4 string) (pgtypes.Daterange, error)

+ func DaterangeCanonical(db XODB, v0 pgtypes.Daterange) (pgtypes.Daterange, error)

+ func DaterangeSubdiff(db XODB, v0 time.Time, v1 time.Time) (float64, error)

+ func DatetimePl(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func DatetimetzPl(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func Dcbrt(db XODB, v0 float64) (float64, error)

+ func Decode(db XODB, v0 string, v1 string) ([]byte, error)

+ func Degrees(db XODB, v0 float64) (float64, error)

+ func DenseRank(db XODB, v0 []byte) (int64, error)

+ func DenseRankFinal(db XODB, v0 pgtypes.Internal, v1 []byte) (int64, error)

+ func Dexp(db XODB, v0 float64) (float64, error)

+ func Diagonal(db XODB, v0 pgtypes.Box) (pgtypes.Lseg, error)

+ func Diameter(db XODB, v0 pgtypes.Circle) (float64, error)

+ func DispellInit(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func DispellLexize(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func DistCpoint(db XODB, v0 pgtypes.Circle, v1 pgtypes.Point) (float64, error)

+ func DistCpoly(db XODB, v0 pgtypes.Circle, v1 pgtypes.Polygon) (float64, error)

+ func DistLb(db XODB, v0 pgtypes.Line, v1 pgtypes.Box) (float64, error)

+ func DistPb(db XODB, v0 pgtypes.Point, v1 pgtypes.Box) (float64, error)

+ func DistPc(db XODB, v0 pgtypes.Point, v1 pgtypes.Circle) (float64, error)

+ func DistPl(db XODB, v0 pgtypes.Point, v1 pgtypes.Line) (float64, error)

+ func DistPolyp(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Point) (float64, error)

+ func DistPpath(db XODB, v0 pgtypes.Point, v1 pgtypes.Path) (float64, error)

+ func DistPpoly(db XODB, v0 pgtypes.Point, v1 pgtypes.Polygon) (float64, error)

+ func DistPs(db XODB, v0 pgtypes.Point, v1 pgtypes.Lseg) (float64, error)

+ func DistSb(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Box) (float64, error)

+ func DistSl(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line) (float64, error)

+ func Div(db XODB, v0 float64, v1 float64) (float64, error)

+ func Dlog1(db XODB, v0 float64) (float64, error)

+ func Dlog10(db XODB, v0 float64) (float64, error)

+ func DomainIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) ([]byte, error)

+ func DomainRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) ([]byte, error)

+ func Dpow(db XODB, v0 float64, v1 float64) (float64, error)

+ func Dround(db XODB, v0 float64) (float64, error)

+ func DsimpleInit(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func DsimpleLexize(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func DsnowballInit(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func DsnowballLexize(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Dsqrt(db XODB, v0 float64) (float64, error)

+ func DsynonymInit(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func DsynonymLexize(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Dtrunc(db XODB, v0 float64) (float64, error)

+ func ElemContainedByRange(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Anyrange) (bool, error)

+ func Encode(db XODB, v0 []byte, v1 string) (string, error)

+ func EnumCmp(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (int, error)

+ func EnumEq(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumFirst(db XODB, v0 pgtypes.Anyenum) (pgtypes.Anyenum, error)

+ func EnumGe(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumGt(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid) (pgtypes.Anyenum, error)

+ func EnumLarger(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (pgtypes.Anyenum, error)

+ func EnumLast(db XODB, v0 pgtypes.Anyenum) (pgtypes.Anyenum, error)

+ func EnumLe(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumLt(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumNe(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (bool, error)

+ func EnumOut(db XODB, v0 pgtypes.Anyenum) (pgtypes.Cstring, error)

+ func EnumRange(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum, v2 pgtypes.Anyenum) (pgtypes.Anyarray, error)

+ func EnumRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid) (pgtypes.Anyenum, error)

+ func EnumSend(db XODB, v0 pgtypes.Anyenum) ([]byte, error)

+ func EnumSmaller(db XODB, v0 pgtypes.Anyenum, v1 pgtypes.Anyenum) (pgtypes.Anyenum, error)

+ func Eqjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Eqsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func EucCnToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucCnToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucJis2004ToShiftJis2004(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucJis2004ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucJpToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucJpToSjis(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucJpToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucKrToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucKrToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucTwToBig5(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucTwToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EucTwToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func EventTriggerIn(db XODB, v0 pgtypes.Cstring) (pgtypes.EventTrigger, error)

+ func EventTriggerOut(db XODB, v0 pgtypes.EventTrigger) (pgtypes.Cstring, error)

+ func Every(db XODB, v0 bool) (bool, error)

+ func Exp(db XODB, v0 float64, v1 float64) (float64, error)

+ func Factorial(db XODB, v0 int64) (float64, error)

+ func Family(db XODB, v0 string) (int, error)

+ func FdwHandlerIn(db XODB, v0 pgtypes.Cstring) (pgtypes.FdwHandler, error)

+ func FdwHandlerOut(db XODB, v0 pgtypes.FdwHandler) (pgtypes.Cstring, error)

+ func FirstValue(db XODB, v0 pgtypes.Anyelement) (pgtypes.Anyelement, error)

+ func Float4(db XODB, v0 int64, v1 int16, v2 int, v3 float64, v4 float64) (float32, error)

+ func Float48div(db XODB, v0 float32, v1 float64) (float64, error)

+ func Float48eq(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48ge(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48gt(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48le(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48lt(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48mi(db XODB, v0 float32, v1 float64) (float64, error)

+ func Float48mul(db XODB, v0 float32, v1 float64) (float64, error)

+ func Float48ne(db XODB, v0 float32, v1 float64) (bool, error)

+ func Float48pl(db XODB, v0 float32, v1 float64) (float64, error)

+ func Float4Accum(db XODB, v0 []float64, v1 float32) ([]float64, error)

+ func Float4abs(db XODB, v0 float32) (float32, error)

+ func Float4div(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4eq(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4ge(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4gt(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4in(db XODB, v0 pgtypes.Cstring) (float32, error)

+ func Float4larger(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4le(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4lt(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4mi(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4mul(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4ne(db XODB, v0 float32, v1 float32) (bool, error)

+ func Float4out(db XODB, v0 float32) (pgtypes.Cstring, error)

+ func Float4pl(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4recv(db XODB, v0 pgtypes.Internal) (float32, error)

+ func Float4send(db XODB, v0 float32) ([]byte, error)

+ func Float4smaller(db XODB, v0 float32, v1 float32) (float32, error)

+ func Float4um(db XODB, v0 float32) (float32, error)

+ func Float4up(db XODB, v0 float32) (float32, error)

+ func Float8(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64) (float64, error)

+ func Float84div(db XODB, v0 float64, v1 float32) (float64, error)

+ func Float84eq(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84ge(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84gt(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84le(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84lt(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84mi(db XODB, v0 float64, v1 float32) (float64, error)

+ func Float84mul(db XODB, v0 float64, v1 float32) (float64, error)

+ func Float84ne(db XODB, v0 float64, v1 float32) (bool, error)

+ func Float84pl(db XODB, v0 float64, v1 float32) (float64, error)

+ func Float8Accum(db XODB, v0 []float64, v1 float64) ([]float64, error)

+ func Float8Avg(db XODB, v0 []float64) (float64, error)

+ func Float8Corr(db XODB, v0 []float64) (float64, error)

+ func Float8CovarPop(db XODB, v0 []float64) (float64, error)

+ func Float8CovarSamp(db XODB, v0 []float64) (float64, error)

+ func Float8RegrAccum(db XODB, v0 []float64, v1 float64, v2 float64) ([]float64, error)

+ func Float8RegrAvgx(db XODB, v0 []float64) (float64, error)

+ func Float8RegrAvgy(db XODB, v0 []float64) (float64, error)

+ func Float8RegrIntercept(db XODB, v0 []float64) (float64, error)

+ func Float8RegrR2(db XODB, v0 []float64) (float64, error)

+ func Float8RegrSlope(db XODB, v0 []float64) (float64, error)

+ func Float8RegrSxx(db XODB, v0 []float64) (float64, error)

+ func Float8RegrSxy(db XODB, v0 []float64) (float64, error)

+ func Float8RegrSyy(db XODB, v0 []float64) (float64, error)

+ func Float8StddevPop(db XODB, v0 []float64) (float64, error)

+ func Float8StddevSamp(db XODB, v0 []float64) (float64, error)

+ func Float8VarPop(db XODB, v0 []float64) (float64, error)

+ func Float8VarSamp(db XODB, v0 []float64) (float64, error)

+ func Float8abs(db XODB, v0 float64) (float64, error)

+ func Float8div(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8eq(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8ge(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8gt(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8in(db XODB, v0 pgtypes.Cstring) (float64, error)

+ func Float8larger(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8le(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8lt(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8mi(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8mul(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8ne(db XODB, v0 float64, v1 float64) (bool, error)

+ func Float8out(db XODB, v0 float64) (pgtypes.Cstring, error)

+ func Float8pl(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8recv(db XODB, v0 pgtypes.Internal) (float64, error)

+ func Float8send(db XODB, v0 float64) ([]byte, error)

+ func Float8smaller(db XODB, v0 float64, v1 float64) (float64, error)

+ func Float8um(db XODB, v0 float64) (float64, error)

+ func Float8up(db XODB, v0 float64) (float64, error)

+ func Floor(db XODB, v0 float64, v1 float64) (float64, error)

+ func Flt4MulCash(db XODB, v0 float32, v1 string) (string, error)

+ func Flt8MulCash(db XODB, v0 float64, v1 string) (string, error)

+ func FmgrCValidator(db XODB, v0 pgtypes.Oid) error

+ func FmgrInternalValidator(db XODB, v0 pgtypes.Oid) error

+ func FmgrSQLValidator(db XODB, v0 pgtypes.Oid) error

+ func Format(db XODB, v0 string, v1 string, v2 []byte) (string, error)

+ func FormatType(db XODB, v0 pgtypes.Oid, v1 int) (string, error)

+ func Gb18030ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func GbkToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func GenerateSeries(db XODB, v0 int64, v1 int64, v2 int, v3 int, v4 float64, v5 float64, v6 int64, ...) ([]time.Time, error)

+ func GenerateSubscripts(db XODB, v0 pgtypes.Anyarray, v1 int, v2 pgtypes.Anyarray, v3 int, v4 bool) ([]int, error)

+ func GetBit(db XODB, v0 []byte, v1 int, v2 uint8, v3 int) (int, error)

+ func GetByte(db XODB, v0 []byte, v1 int) (int, error)

+ func GetCurrentTsConfig(db XODB) (pgtypes.Regconfig, error)

+ func Getdatabaseencoding(db XODB) (pgtypes.Name, error)

+ func Getpgusername(db XODB) (pgtypes.Name, error)

+ func GinCmpPrefix(db XODB, v0 string, v1 string, v2 int16, v3 pgtypes.Internal) (int, error)

+ func GinCmpTslexeme(db XODB, v0 string, v1 string) (int, error)

+ func GinCompareJsonb(db XODB, v0 string, v1 string) (int, error)

+ func GinConsistentJsonb(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (bool, error)

+ func GinConsistentJsonbPath(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (bool, error)

+ func GinExtractJsonb(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GinExtractJsonbPath(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GinExtractJsonbQuery(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Internal, v2 int16, ...) (pgtypes.Internal, error)

+ func GinExtractJsonbQueryPath(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Internal, v2 int16, ...) (pgtypes.Internal, error)

+ func GinExtractTsquery(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Internal, v2 int16, ...) (pgtypes.Internal, error)

+ func GinExtractTsvector(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Internal, v2 pgtypes.Tsvector, ...) (pgtypes.Internal, error)

+ func GinTriconsistentJsonb(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (uint8, error)

+ func GinTriconsistentJsonbPath(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (uint8, error)

+ func GinTsqueryConsistent(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Tsquery, v3 int, ...) (bool, error)

+ func GinTsqueryTriconsistent(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Tsquery, v3 int, ...) (uint8, error)

+ func Ginarrayconsistent(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (bool, error)

+ func Ginarrayextract(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Internal, v2 pgtypes.Anyarray, ...) (pgtypes.Internal, error)

+ func Ginarraytriconsistent(db XODB, v0 pgtypes.Internal, v1 int16, v2 pgtypes.Anyarray, v3 int, ...) (uint8, error)

+ func Ginbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Ginbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Ginbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Ginbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Gincostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Ginendscan(db XODB, v0 pgtypes.Internal) error

+ func Gingetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Gininsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Ginmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Ginoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Ginqueryarrayextract(db XODB, v0 pgtypes.Anyarray, v1 pgtypes.Internal, v2 int16, ...) (pgtypes.Internal, error)

+ func Ginrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Ginrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Ginvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBboxDistance(db XODB, v0 pgtypes.Internal, v1 pgtypes.Point, v2 int, v3 pgtypes.Oid) (float64, error)

+ func GistBoxCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Box, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func GistBoxDecompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxFetch(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxPenalty(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxSame(db XODB, v0 pgtypes.Box, v1 pgtypes.Box, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistBoxUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Box, error)

+ func GistCircleCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistCircleConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Circle, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func GistPointCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistPointConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Point, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func GistPointDistance(db XODB, v0 pgtypes.Internal, v1 pgtypes.Point, v2 int, v3 pgtypes.Oid) (float64, error)

+ func GistPointFetch(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistPolyCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GistPolyConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Polygon, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func Gistbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Gistbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Gistbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Gistbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Gistcanreturn(db XODB, v0 pgtypes.Internal, v1 int) (bool, error)

+ func Gistcostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Gistendscan(db XODB, v0 pgtypes.Internal) error

+ func Gistgetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Gistgettuple(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func Gistinsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Gistmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Gistoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Gistrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Gistrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Gistvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsqueryCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsqueryConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func GtsqueryDecompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsqueryPenalty(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsqueryPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsquerySame(db XODB, v0 int64, v1 int64, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsqueryUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Gtsvector, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func GtsvectorDecompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorPenalty(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorSame(db XODB, v0 pgtypes.Gtsvector, v1 pgtypes.Gtsvector, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func GtsvectorUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func Gtsvectorin(db XODB, v0 pgtypes.Cstring) (pgtypes.Gtsvector, error)

+ func Gtsvectorout(db XODB, v0 pgtypes.Gtsvector) (pgtypes.Cstring, error)

+ func HasAnyColumnPrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasColumnPrivilege(db XODB, v0 string, v1 int16, v2 string, v3 string, v4 string, v5 string, ...) (bool, error)

+ func HasDatabasePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasForeignDataWrapperPrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasFunctionPrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasLanguagePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasSchemaPrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasSequencePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasServerPrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasTablePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasTablespacePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HasTypePrivilege(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string, v4 pgtypes.Name, ...) (bool, error)

+ func HashAclitem(db XODB, v0 pgtypes.Aclitem) (int, error)

+ func HashArray(db XODB, v0 pgtypes.Anyarray) (int, error)

+ func HashNumeric(db XODB, v0 float64) (int, error)

+ func HashRange(db XODB, v0 pgtypes.Anyrange) (int, error)

+ func Hashbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Hashbpchar(db XODB, v0 string) (int, error)

+ func Hashbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Hashbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Hashbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Hashchar(db XODB, v0 uint8) (int, error)

+ func Hashcostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Hashendscan(db XODB, v0 pgtypes.Internal) error

+ func Hashenum(db XODB, v0 pgtypes.Anyenum) (int, error)

+ func Hashfloat4(db XODB, v0 float32) (int, error)

+ func Hashfloat8(db XODB, v0 float64) (int, error)

+ func Hashgetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Hashgettuple(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func Hashinet(db XODB, v0 string) (int, error)

+ func Hashinsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Hashint2(db XODB, v0 int16) (int, error)

+ func Hashint2vector(db XODB, v0 pgtypes.Int2vector) (int, error)

+ func Hashint4(db XODB, v0 int) (int, error)

+ func Hashint8(db XODB, v0 int64) (int, error)

+ func Hashmacaddr(db XODB, v0 pgtypes.Macaddr) (int, error)

+ func Hashmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Hashname(db XODB, v0 pgtypes.Name) (int, error)

+ func Hashoid(db XODB, v0 pgtypes.Oid) (int, error)

+ func Hashoidvector(db XODB, v0 pgtypes.Oidvector) (int, error)

+ func Hashoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Hashrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Hashrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Hashtext(db XODB, v0 string) (int, error)

+ func Hashvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func Hashvarlena(db XODB, v0 pgtypes.Internal) (int, error)

+ func Height(db XODB, v0 pgtypes.Box) (float64, error)

+ func Host(db XODB, v0 string) (string, error)

+ func Hostmask(db XODB, v0 string) (string, error)

+ func Iclikejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Iclikesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Icnlikejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Icnlikesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Icregexeqjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Icregexeqsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Icregexnejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Icregexnesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func InetClientAddr(db XODB) (string, error)

+ func InetClientPort(db XODB) (int, error)

+ func InetGistCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistConsistent(db XODB, v0 pgtypes.Internal, v1 string, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func InetGistDecompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistFetch(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistPenalty(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistSame(db XODB, v0 string, v1 string, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetGistUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func InetIn(db XODB, v0 pgtypes.Cstring) (string, error)

+ func InetMerge(db XODB, v0 string, v1 string) (pgtypes.Cidr, error)

+ func InetOut(db XODB, v0 string) (pgtypes.Cstring, error)

+ func InetRecv(db XODB, v0 pgtypes.Internal) (string, error)

+ func InetSameFamily(db XODB, v0 string, v1 string) (bool, error)

+ func InetSend(db XODB, v0 string) ([]byte, error)

+ func InetServerAddr(db XODB) (string, error)

+ func InetServerPort(db XODB) (int, error)

+ func Inetand(db XODB, v0 string, v1 string) (string, error)

+ func Inetmi(db XODB, v0 string, v1 string) (int64, error)

+ func InetmiInt8(db XODB, v0 string, v1 int64) (string, error)

+ func Inetnot(db XODB, v0 string) (string, error)

+ func Inetor(db XODB, v0 string, v1 string) (string, error)

+ func Inetpl(db XODB, v0 string, v1 int64) (string, error)

+ func Initcap(db XODB, v0 string) (string, error)

+ func Int2(db XODB, v0 int64, v1 int, v2 float32, v3 float64, v4 float64) (int16, error)

+ func Int24div(db XODB, v0 int16, v1 int) (int, error)

+ func Int24eq(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24ge(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24gt(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24le(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24lt(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24mi(db XODB, v0 int16, v1 int) (int, error)

+ func Int24mul(db XODB, v0 int16, v1 int) (int, error)

+ func Int24ne(db XODB, v0 int16, v1 int) (bool, error)

+ func Int24pl(db XODB, v0 int16, v1 int) (int, error)

+ func Int28div(db XODB, v0 int16, v1 int64) (int64, error)

+ func Int28eq(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28ge(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28gt(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28le(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28lt(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28mi(db XODB, v0 int16, v1 int64) (int64, error)

+ func Int28mul(db XODB, v0 int16, v1 int64) (int64, error)

+ func Int28ne(db XODB, v0 int16, v1 int64) (bool, error)

+ func Int28pl(db XODB, v0 int16, v1 int64) (int64, error)

+ func Int2Accum(db XODB, v0 pgtypes.Internal, v1 int16) (pgtypes.Internal, error)

+ func Int2AccumInv(db XODB, v0 pgtypes.Internal, v1 int16) (pgtypes.Internal, error)

+ func Int2AvgAccum(db XODB, v0 []int64, v1 int16) ([]int64, error)

+ func Int2AvgAccumInv(db XODB, v0 []int64, v1 int16) ([]int64, error)

+ func Int2MulCash(db XODB, v0 int16, v1 string) (string, error)

+ func Int2Sum(db XODB, v0 int64, v1 int16) (int64, error)

+ func Int2abs(db XODB, v0 int16) (int16, error)

+ func Int2and(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2div(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2eq(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2ge(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2gt(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2in(db XODB, v0 pgtypes.Cstring) (int16, error)

+ func Int2int4Sum(db XODB, v0 []int64) (int64, error)

+ func Int2larger(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2le(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2lt(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2mi(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2mod(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2mul(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2ne(db XODB, v0 int16, v1 int16) (bool, error)

+ func Int2not(db XODB, v0 int16) (int16, error)

+ func Int2or(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2out(db XODB, v0 int16) (pgtypes.Cstring, error)

+ func Int2pl(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2recv(db XODB, v0 pgtypes.Internal) (int16, error)

+ func Int2send(db XODB, v0 int16) ([]byte, error)

+ func Int2shl(db XODB, v0 int16, v1 int) (int16, error)

+ func Int2shr(db XODB, v0 int16, v1 int) (int16, error)

+ func Int2smaller(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int2um(db XODB, v0 int16) (int16, error)

+ func Int2up(db XODB, v0 int16) (int16, error)

+ func Int2vectoreq(db XODB, v0 pgtypes.Int2vector, v1 pgtypes.Int2vector) (bool, error)

+ func Int2vectorin(db XODB, v0 pgtypes.Cstring) (pgtypes.Int2vector, error)

+ func Int2vectorout(db XODB, v0 pgtypes.Int2vector) (pgtypes.Cstring, error)

+ func Int2vectorrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Int2vector, error)

+ func Int2vectorsend(db XODB, v0 pgtypes.Int2vector) ([]byte, error)

+ func Int2xor(db XODB, v0 int16, v1 int16) (int16, error)

+ func Int4(db XODB, v0 bool, v1 uint8, v2 int64, v3 int16, v4 float32, v5 float64, ...) (int, error)

+ func Int42div(db XODB, v0 int, v1 int16) (int, error)

+ func Int42eq(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42ge(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42gt(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42le(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42lt(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42mi(db XODB, v0 int, v1 int16) (int, error)

+ func Int42mul(db XODB, v0 int, v1 int16) (int, error)

+ func Int42ne(db XODB, v0 int, v1 int16) (bool, error)

+ func Int42pl(db XODB, v0 int, v1 int16) (int, error)

+ func Int48div(db XODB, v0 int, v1 int64) (int64, error)

+ func Int48eq(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48ge(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48gt(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48le(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48lt(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48mi(db XODB, v0 int, v1 int64) (int64, error)

+ func Int48mul(db XODB, v0 int, v1 int64) (int64, error)

+ func Int48ne(db XODB, v0 int, v1 int64) (bool, error)

+ func Int48pl(db XODB, v0 int, v1 int64) (int64, error)

+ func Int4Accum(db XODB, v0 pgtypes.Internal, v1 int) (pgtypes.Internal, error)

+ func Int4AccumInv(db XODB, v0 pgtypes.Internal, v1 int) (pgtypes.Internal, error)

+ func Int4AvgAccum(db XODB, v0 []int64, v1 int) ([]int64, error)

+ func Int4AvgAccumInv(db XODB, v0 []int64, v1 int) ([]int64, error)

+ func Int4MulCash(db XODB, v0 int, v1 string) (string, error)

+ func Int4Sum(db XODB, v0 int64, v1 int) (int64, error)

+ func Int4abs(db XODB, v0 int) (int, error)

+ func Int4and(db XODB, v0 int, v1 int) (int, error)

+ func Int4div(db XODB, v0 int, v1 int) (int, error)

+ func Int4eq(db XODB, v0 int, v1 int) (bool, error)

+ func Int4ge(db XODB, v0 int, v1 int) (bool, error)

+ func Int4gt(db XODB, v0 int, v1 int) (bool, error)

+ func Int4in(db XODB, v0 pgtypes.Cstring) (int, error)

+ func Int4inc(db XODB, v0 int) (int, error)

+ func Int4larger(db XODB, v0 int, v1 int) (int, error)

+ func Int4le(db XODB, v0 int, v1 int) (bool, error)

+ func Int4lt(db XODB, v0 int, v1 int) (bool, error)

+ func Int4mi(db XODB, v0 int, v1 int) (int, error)

+ func Int4mod(db XODB, v0 int, v1 int) (int, error)

+ func Int4mul(db XODB, v0 int, v1 int) (int, error)

+ func Int4ne(db XODB, v0 int, v1 int) (bool, error)

+ func Int4not(db XODB, v0 int) (int, error)

+ func Int4or(db XODB, v0 int, v1 int) (int, error)

+ func Int4out(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Int4pl(db XODB, v0 int, v1 int) (int, error)

+ func Int4range(db XODB, v0 int, v1 int, v2 int, v3 int, v4 string) (pgtypes.Int4range, error)

+ func Int4rangeCanonical(db XODB, v0 pgtypes.Int4range) (pgtypes.Int4range, error)

+ func Int4rangeSubdiff(db XODB, v0 int, v1 int) (float64, error)

+ func Int4recv(db XODB, v0 pgtypes.Internal) (int, error)

+ func Int4send(db XODB, v0 int) ([]byte, error)

+ func Int4shl(db XODB, v0 int, v1 int) (int, error)

+ func Int4shr(db XODB, v0 int, v1 int) (int, error)

+ func Int4smaller(db XODB, v0 int, v1 int) (int, error)

+ func Int4um(db XODB, v0 int) (int, error)

+ func Int4up(db XODB, v0 int) (int, error)

+ func Int4xor(db XODB, v0 int, v1 int) (int, error)

+ func Int8(db XODB, v0 int16, v1 int, v2 pgtypes.Oid, v3 float32, v4 float64, v5 uint8, ...) (int64, error)

+ func Int82div(db XODB, v0 int64, v1 int16) (int64, error)

+ func Int82eq(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82ge(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82gt(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82le(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82lt(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82mi(db XODB, v0 int64, v1 int16) (int64, error)

+ func Int82mul(db XODB, v0 int64, v1 int16) (int64, error)

+ func Int82ne(db XODB, v0 int64, v1 int16) (bool, error)

+ func Int82pl(db XODB, v0 int64, v1 int16) (int64, error)

+ func Int84div(db XODB, v0 int64, v1 int) (int64, error)

+ func Int84eq(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84ge(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84gt(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84le(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84lt(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84mi(db XODB, v0 int64, v1 int) (int64, error)

+ func Int84mul(db XODB, v0 int64, v1 int) (int64, error)

+ func Int84ne(db XODB, v0 int64, v1 int) (bool, error)

+ func Int84pl(db XODB, v0 int64, v1 int) (int64, error)

+ func Int8Accum(db XODB, v0 pgtypes.Internal, v1 int64) (pgtypes.Internal, error)

+ func Int8AccumInv(db XODB, v0 pgtypes.Internal, v1 int64) (pgtypes.Internal, error)

+ func Int8Avg(db XODB, v0 []int64) (float64, error)

+ func Int8AvgAccum(db XODB, v0 pgtypes.Internal, v1 int64) (pgtypes.Internal, error)

+ func Int8AvgAccumInv(db XODB, v0 pgtypes.Internal, v1 int64) (pgtypes.Internal, error)

+ func Int8Sum(db XODB, v0 float64, v1 int64) (float64, error)

+ func Int8abs(db XODB, v0 int64) (int64, error)

+ func Int8and(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8dec(db XODB, v0 int64) (int64, error)

+ func Int8decAny(db XODB, v0 int64, v1 []byte) (int64, error)

+ func Int8div(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8eq(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8ge(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8gt(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8in(db XODB, v0 pgtypes.Cstring) (int64, error)

+ func Int8inc(db XODB, v0 int64) (int64, error)

+ func Int8incAny(db XODB, v0 int64, v1 []byte) (int64, error)

+ func Int8incFloat8Float8(db XODB, v0 int64, v1 float64, v2 float64) (int64, error)

+ func Int8larger(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8le(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8lt(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8mi(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8mod(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8mul(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8ne(db XODB, v0 int64, v1 int64) (bool, error)

+ func Int8not(db XODB, v0 int64) (int64, error)

+ func Int8or(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8out(db XODB, v0 int64) (pgtypes.Cstring, error)

+ func Int8pl(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8plInet(db XODB, v0 int64, v1 string) (string, error)

+ func Int8range(db XODB, v0 int64, v1 int64, v2 int64, v3 int64, v4 string) (pgtypes.Int8range, error)

+ func Int8rangeCanonical(db XODB, v0 pgtypes.Int8range) (pgtypes.Int8range, error)

+ func Int8rangeSubdiff(db XODB, v0 int64, v1 int64) (float64, error)

+ func Int8recv(db XODB, v0 pgtypes.Internal) (int64, error)

+ func Int8send(db XODB, v0 int64) ([]byte, error)

+ func Int8shl(db XODB, v0 int64, v1 int) (int64, error)

+ func Int8shr(db XODB, v0 int64, v1 int) (int64, error)

+ func Int8smaller(db XODB, v0 int64, v1 int64) (int64, error)

+ func Int8um(db XODB, v0 int64) (int64, error)

+ func Int8up(db XODB, v0 int64) (int64, error)

+ func Int8xor(db XODB, v0 int64, v1 int64) (int64, error)

+ func IntegerPlDate(db XODB, v0 int, v1 time.Time) (time.Time, error)

+ func InterLb(db XODB, v0 pgtypes.Line, v1 pgtypes.Box) (bool, error)

+ func InterSb(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Box) (bool, error)

+ func InterSl(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line) (bool, error)

+ func InternalIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Internal, error)

+ func InternalOut(db XODB, v0 pgtypes.Internal) (pgtypes.Cstring, error)

+ func Interval(db XODB, v0 pgtypes.Reltime, v1 time.Time, v2 *time.Duration, v3 int) (*time.Duration, error)

+ func IntervalAccum(db XODB, v0 []*time.Duration, v1 *time.Duration) ([]*time.Duration, error)

+ func IntervalAccumInv(db XODB, v0 []*time.Duration, v1 *time.Duration) ([]*time.Duration, error)

+ func IntervalAvg(db XODB, v0 []*time.Duration) (*time.Duration, error)

+ func IntervalCmp(db XODB, v0 *time.Duration, v1 *time.Duration) (int, error)

+ func IntervalDiv(db XODB, v0 *time.Duration, v1 float64) (*time.Duration, error)

+ func IntervalEq(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalGe(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalGt(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalHash(db XODB, v0 *time.Duration) (int, error)

+ func IntervalIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (*time.Duration, error)

+ func IntervalLarger(db XODB, v0 *time.Duration, v1 *time.Duration) (*time.Duration, error)

+ func IntervalLe(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalLt(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalMi(db XODB, v0 *time.Duration, v1 *time.Duration) (*time.Duration, error)

+ func IntervalMul(db XODB, v0 *time.Duration, v1 float64) (*time.Duration, error)

+ func IntervalNe(db XODB, v0 *time.Duration, v1 *time.Duration) (bool, error)

+ func IntervalOut(db XODB, v0 *time.Duration) (pgtypes.Cstring, error)

+ func IntervalPl(db XODB, v0 *time.Duration, v1 *time.Duration) (*time.Duration, error)

+ func IntervalPlDate(db XODB, v0 *time.Duration, v1 time.Time) (time.Time, error)

+ func IntervalPlTime(db XODB, v0 *time.Duration, v1 time.Time) (time.Time, error)

+ func IntervalPlTimestamp(db XODB, v0 *time.Duration, v1 time.Time) (time.Time, error)

+ func IntervalPlTimestamptz(db XODB, v0 *time.Duration, v1 time.Time) (time.Time, error)

+ func IntervalPlTimetz(db XODB, v0 *time.Duration, v1 time.Time) (time.Time, error)

+ func IntervalRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (*time.Duration, error)

+ func IntervalSend(db XODB, v0 *time.Duration) ([]byte, error)

+ func IntervalSmaller(db XODB, v0 *time.Duration, v1 *time.Duration) (*time.Duration, error)

+ func IntervalTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func IntervalUm(db XODB, v0 *time.Duration) (*time.Duration, error)

+ func Intervaltypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Intervaltypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Intinterval(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Tinterval) (bool, error)

+ func Isclosed(db XODB, v0 pgtypes.Path) (bool, error)

+ func Isempty(db XODB, v0 pgtypes.Anyrange) (bool, error)

+ func Isfinite(db XODB, v0 pgtypes.Abstime, v1 time.Time, v2 time.Time, v3 time.Time, ...) (bool, error)

+ func Ishorizontal(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line, v2 pgtypes.Point, v3 pgtypes.Point) (bool, error)

+ func Iso88591ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Iso8859ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func IsoToKoi8r(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func IsoToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func IsoToWin1251(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func IsoToWin866(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Isopen(db XODB, v0 pgtypes.Path) (bool, error)

+ func Isparallel(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg, v2 pgtypes.Line, v3 pgtypes.Line) (bool, error)

+ func Isperp(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg, v2 pgtypes.Line, v3 pgtypes.Line) (bool, error)

+ func Isvertical(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line, v2 pgtypes.Point, v3 pgtypes.Point) (bool, error)

+ func JSONAgg(db XODB, v0 pgtypes.Anyelement) (pgtypes.JSON, error)

+ func JSONAggFinalfn(db XODB, v0 pgtypes.Internal) (pgtypes.JSON, error)

+ func JSONAggTransfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyelement) (pgtypes.Internal, error)

+ func JSONArrayElement(db XODB, v0 pgtypes.JSON, v1 int) (pgtypes.JSON, error)

+ func JSONArrayElementText(db XODB, v0 pgtypes.JSON, v1 int) (string, error)

+ func JSONArrayElements(db XODB, v0 pgtypes.JSON) ([]pgtypes.JSON, error)

+ func JSONArrayElementsText(db XODB, v0 pgtypes.JSON) ([]string, error)

+ func JSONArrayLength(db XODB, v0 pgtypes.JSON) (int, error)

+ func JSONBuildArray(db XODB, v0 []byte) (pgtypes.JSON, error)

+ func JSONBuildObject(db XODB, v0 []byte) (pgtypes.JSON, error)

+ func JSONEach(db XODB, v0 pgtypes.JSON) ([]pgtypes.Record, error)

+ func JSONEachText(db XODB, v0 pgtypes.JSON) ([]pgtypes.Record, error)

+ func JSONExtractPath(db XODB, v0 pgtypes.JSON, v1 StringSlice) (pgtypes.JSON, error)

+ func JSONExtractPathText(db XODB, v0 pgtypes.JSON, v1 StringSlice) (string, error)

+ func JSONIn(db XODB, v0 pgtypes.Cstring) (pgtypes.JSON, error)

+ func JSONObject(db XODB, v0 StringSlice, v1 StringSlice, v2 StringSlice) (pgtypes.JSON, error)

+ func JSONObjectAgg(db XODB, v0 []byte, v1 []byte) (pgtypes.JSON, error)

+ func JSONObjectAggFinalfn(db XODB, v0 pgtypes.Internal) (pgtypes.JSON, error)

+ func JSONObjectAggTransfn(db XODB, v0 pgtypes.Internal, v1 []byte, v2 []byte) (pgtypes.Internal, error)

+ func JSONObjectField(db XODB, v0 pgtypes.JSON, v1 string) (pgtypes.JSON, error)

+ func JSONObjectFieldText(db XODB, v0 pgtypes.JSON, v1 string) (string, error)

+ func JSONObjectKeys(db XODB, v0 pgtypes.JSON) ([]string, error)

+ func JSONOut(db XODB, v0 pgtypes.JSON) (pgtypes.Cstring, error)

+ func JSONPopulateRecord(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.JSON, v2 bool) (pgtypes.Anyelement, error)

+ func JSONPopulateRecordset(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.JSON, v2 bool) ([]pgtypes.Anyelement, error)

+ func JSONRecv(db XODB, v0 pgtypes.Internal) (pgtypes.JSON, error)

+ func JSONSend(db XODB, v0 pgtypes.JSON) ([]byte, error)

+ func JSONStripNulls(db XODB, v0 pgtypes.JSON) (pgtypes.JSON, error)

+ func JSONToRecord(db XODB, v0 pgtypes.JSON) (pgtypes.Record, error)

+ func JSONToRecordset(db XODB, v0 pgtypes.JSON) ([]pgtypes.Record, error)

+ func JSONTypeof(db XODB, v0 pgtypes.JSON) (string, error)

+ func JohabToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func JsonbAgg(db XODB, v0 pgtypes.Anyelement) (pgtypes.Jsonb, error)

+ func JsonbAggFinalfn(db XODB, v0 pgtypes.Internal) (pgtypes.Jsonb, error)

+ func JsonbAggTransfn(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyelement) (pgtypes.Internal, error)

+ func JsonbArrayElement(db XODB, v0 pgtypes.Jsonb, v1 int) (pgtypes.Jsonb, error)

+ func JsonbArrayElementText(db XODB, v0 pgtypes.Jsonb, v1 int) (string, error)

+ func JsonbArrayElements(db XODB, v0 pgtypes.Jsonb) ([]pgtypes.Jsonb, error)

+ func JsonbArrayElementsText(db XODB, v0 pgtypes.Jsonb) ([]string, error)

+ func JsonbArrayLength(db XODB, v0 pgtypes.Jsonb) (int, error)

+ func JsonbBuildArray(db XODB, v0 []byte) (pgtypes.Jsonb, error)

+ func JsonbBuildObject(db XODB, v0 []byte) (pgtypes.Jsonb, error)

+ func JsonbCmp(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (int, error)

+ func JsonbConcat(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (pgtypes.Jsonb, error)

+ func JsonbContained(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbContains(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbDelete(db XODB, v0 pgtypes.Jsonb, v1 int, v2 pgtypes.Jsonb, v3 string) (pgtypes.Jsonb, error)

+ func JsonbDeletePath(db XODB, v0 pgtypes.Jsonb, v1 StringSlice) (pgtypes.Jsonb, error)

+ func JsonbEach(db XODB, v0 pgtypes.Jsonb) ([]pgtypes.Record, error)

+ func JsonbEachText(db XODB, v0 pgtypes.Jsonb) ([]pgtypes.Record, error)

+ func JsonbEq(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbExists(db XODB, v0 pgtypes.Jsonb, v1 string) (bool, error)

+ func JsonbExistsAll(db XODB, v0 pgtypes.Jsonb, v1 StringSlice) (bool, error)

+ func JsonbExistsAny(db XODB, v0 pgtypes.Jsonb, v1 StringSlice) (bool, error)

+ func JsonbExtractPath(db XODB, v0 pgtypes.Jsonb, v1 StringSlice) (pgtypes.Jsonb, error)

+ func JsonbExtractPathText(db XODB, v0 pgtypes.Jsonb, v1 StringSlice) (string, error)

+ func JsonbGe(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbGt(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbHash(db XODB, v0 pgtypes.Jsonb) (int, error)

+ func JsonbIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Jsonb, error)

+ func JsonbLe(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbLt(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbNe(db XODB, v0 pgtypes.Jsonb, v1 pgtypes.Jsonb) (bool, error)

+ func JsonbObject(db XODB, v0 StringSlice, v1 StringSlice, v2 StringSlice) (pgtypes.Jsonb, error)

+ func JsonbObjectAgg(db XODB, v0 []byte, v1 []byte) (pgtypes.Jsonb, error)

+ func JsonbObjectAggFinalfn(db XODB, v0 pgtypes.Internal) (pgtypes.Jsonb, error)

+ func JsonbObjectAggTransfn(db XODB, v0 pgtypes.Internal, v1 []byte, v2 []byte) (pgtypes.Internal, error)

+ func JsonbObjectField(db XODB, v0 pgtypes.Jsonb, v1 string) (pgtypes.Jsonb, error)

+ func JsonbObjectFieldText(db XODB, v0 pgtypes.Jsonb, v1 string) (string, error)

+ func JsonbObjectKeys(db XODB, v0 pgtypes.Jsonb) ([]string, error)

+ func JsonbOut(db XODB, v0 pgtypes.Jsonb) (pgtypes.Cstring, error)

+ func JsonbPopulateRecord(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Jsonb) (pgtypes.Anyelement, error)

+ func JsonbPopulateRecordset(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Jsonb) ([]pgtypes.Anyelement, error)

+ func JsonbPretty(db XODB, v0 pgtypes.Jsonb) (string, error)

+ func JsonbRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Jsonb, error)

+ func JsonbSend(db XODB, v0 pgtypes.Jsonb) ([]byte, error)

+ func JsonbSet(db XODB, v0 pgtypes.Jsonb, v1 StringSlice, v2 pgtypes.Jsonb, v3 bool) (pgtypes.Jsonb, error)

+ func JsonbStripNulls(db XODB, v0 pgtypes.Jsonb) (pgtypes.Jsonb, error)

+ func JsonbToRecord(db XODB, v0 pgtypes.Jsonb) (pgtypes.Record, error)

+ func JsonbToRecordset(db XODB, v0 pgtypes.Jsonb) ([]pgtypes.Record, error)

+ func JsonbTypeof(db XODB, v0 pgtypes.Jsonb) (string, error)

+ func JustifyDays(db XODB, v0 *time.Duration) (*time.Duration, error)

+ func JustifyHours(db XODB, v0 *time.Duration) (*time.Duration, error)

+ func JustifyInterval(db XODB, v0 *time.Duration) (*time.Duration, error)

+ func Koi8rToIso(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Koi8rToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Koi8rToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Koi8rToWin1251(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Koi8rToWin866(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Koi8uToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Lag(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Anyelement, v2 int, ...) (pgtypes.Anyelement, error)

+ func LanguageHandlerIn(db XODB, v0 pgtypes.Cstring) (pgtypes.LanguageHandler, error)

+ func LanguageHandlerOut(db XODB, v0 pgtypes.LanguageHandler) (pgtypes.Cstring, error)

+ func LastValue(db XODB, v0 pgtypes.Anyelement) (pgtypes.Anyelement, error)

+ func Lastval(db XODB) (int64, error)

+ func Latin1ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Latin2ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Latin2ToWin1250(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Latin3ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Latin4ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Lead(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Anyelement, v2 int, ...) (pgtypes.Anyelement, error)

+ func Left(db XODB, v0 string, v1 int) (string, error)

+ func Length(db XODB, v0 []byte, v1 string, v2 pgtypes.Lseg, v3 pgtypes.Path, v4 string, ...) (int, error)

+ func Like(db XODB, v0 []byte, v1 []byte, v2 pgtypes.Name, v3 string, v4 string, ...) (bool, error)

+ func LikeEscape(db XODB, v0 []byte, v1 []byte, v2 string, v3 string) ([]byte, error)

+ func Likejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Likesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Line(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (pgtypes.Line, error)

+ func LineDistance(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (float64, error)

+ func LineEq(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (bool, error)

+ func LineHorizontal(db XODB, v0 pgtypes.Line) (bool, error)

+ func LineIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Line, error)

+ func LineInterpt(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (pgtypes.Point, error)

+ func LineIntersect(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (bool, error)

+ func LineOut(db XODB, v0 pgtypes.Line) (pgtypes.Cstring, error)

+ func LineParallel(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (bool, error)

+ func LinePerp(db XODB, v0 pgtypes.Line, v1 pgtypes.Line) (bool, error)

+ func LineRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Line, error)

+ func LineSend(db XODB, v0 pgtypes.Line) ([]byte, error)

+ func LineVertical(db XODB, v0 pgtypes.Line) (bool, error)

+ func Ln(db XODB, v0 float64, v1 float64) (float64, error)

+ func LoClose(db XODB, v0 int) (int, error)

+ func LoCreat(db XODB, v0 int) (pgtypes.Oid, error)

+ func LoCreate(db XODB, v0 pgtypes.Oid) (pgtypes.Oid, error)

+ func LoExport(db XODB, v0 pgtypes.Oid, v1 string) (int, error)

+ func LoFromBytea(db XODB, v0 pgtypes.Oid, v1 []byte) (pgtypes.Oid, error)

+ func LoGet(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 int64, v3 int) ([]byte, error)

+ func LoImport(db XODB, v0 string, v1 string, v2 pgtypes.Oid) (pgtypes.Oid, error)

+ func LoLseek(db XODB, v0 int, v1 int, v2 int) (int, error)

+ func LoLseek64(db XODB, v0 int, v1 int64, v2 int) (int64, error)

+ func LoOpen(db XODB, v0 pgtypes.Oid, v1 int) (int, error)

+ func LoPut(db XODB, v0 pgtypes.Oid, v1 int64, v2 []byte) error

+ func LoTell(db XODB, v0 int) (int, error)

+ func LoTell64(db XODB, v0 int) (int64, error)

+ func LoTruncate(db XODB, v0 int, v1 int) (int, error)

+ func LoTruncate64(db XODB, v0 int, v1 int64) (int, error)

+ func LoUnlink(db XODB, v0 pgtypes.Oid) (int, error)

+ func Log(db XODB, v0 float64, v1 float64, v2 float64, v3 float64) (float64, error)

+ func Loread(db XODB, v0 int, v1 int) ([]byte, error)

+ func Lower(db XODB, v0 string, v1 pgtypes.Anyrange) (pgtypes.Anyelement, error)

+ func LowerInc(db XODB, v0 pgtypes.Anyrange) (bool, error)

+ func LowerInf(db XODB, v0 pgtypes.Anyrange) (bool, error)

+ func Lowrite(db XODB, v0 int, v1 []byte) (int, error)

+ func Lpad(db XODB, v0 string, v1 int, v2 string, v3 int, v4 string) (string, error)

+ func Lseg(db XODB, v0 pgtypes.Box, v1 pgtypes.Point, v2 pgtypes.Point) (pgtypes.Lseg, error)

+ func LsegCenter(db XODB, v0 pgtypes.Lseg) (pgtypes.Point, error)

+ func LsegDistance(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (float64, error)

+ func LsegEq(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegGe(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegGt(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegHorizontal(db XODB, v0 pgtypes.Lseg) (bool, error)

+ func LsegIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Lseg, error)

+ func LsegInterpt(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (pgtypes.Point, error)

+ func LsegIntersect(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegLe(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegLength(db XODB, v0 pgtypes.Lseg) (float64, error)

+ func LsegLt(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegNe(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegOut(db XODB, v0 pgtypes.Lseg) (pgtypes.Cstring, error)

+ func LsegParallel(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegPerp(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Lseg) (bool, error)

+ func LsegRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Lseg, error)

+ func LsegSend(db XODB, v0 pgtypes.Lseg) ([]byte, error)

+ func LsegVertical(db XODB, v0 pgtypes.Lseg) (bool, error)

+ func Ltrim(db XODB, v0 string, v1 string, v2 string) (string, error)

+ func MacaddrAnd(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (pgtypes.Macaddr, error)

+ func MacaddrCmp(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (int, error)

+ func MacaddrEq(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrGe(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrGt(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Macaddr, error)

+ func MacaddrLe(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrLt(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrNe(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (bool, error)

+ func MacaddrNot(db XODB, v0 pgtypes.Macaddr) (pgtypes.Macaddr, error)

+ func MacaddrOr(db XODB, v0 pgtypes.Macaddr, v1 pgtypes.Macaddr) (pgtypes.Macaddr, error)

+ func MacaddrOut(db XODB, v0 pgtypes.Macaddr) (pgtypes.Cstring, error)

+ func MacaddrRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Macaddr, error)

+ func MacaddrSend(db XODB, v0 pgtypes.Macaddr) ([]byte, error)

+ func MakeDate(db XODB, v0 int, v1 int, v2 int) (time.Time, error)

+ func MakeInterval(db XODB, v0 int, v1 int, v2 int, v3 int, v4 int, v5 int, v6 float64) (*time.Duration, error)

+ func MakeTime(db XODB, v0 int, v1 int, v2 float64) (time.Time, error)

+ func MakeTimestamp(db XODB, v0 int, v1 int, v2 int, v3 int, v4 int, v5 float64) (time.Time, error)

+ func MakeTimestamptz(db XODB, v0 int, v1 int, v2 int, v3 int, v4 int, v5 float64, v6 int, v7 int, ...) (time.Time, error)

+ func Makeaclitem(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 string, v3 bool) (pgtypes.Aclitem, error)

+ func Masklen(db XODB, v0 string) (int, error)

+ func Max(db XODB, v0 int64, v1 int16, v2 int, v3 string, v4 pgtypes.Oid, v5 pgtypes.Tid, ...) (pgtypes.Anyenum, error)

+ func Md5(db XODB, v0 []byte, v1 string) (string, error)

+ func MicToASCII(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToBig5(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToEucCn(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToEucJp(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToEucKr(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToEucTw(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToIso(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToKoi8r(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToLatin1(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToLatin2(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToLatin3(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToLatin4(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToSjis(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToWin1250(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToWin1251(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func MicToWin866(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Min(db XODB, v0 int64, v1 int16, v2 int, v3 string, v4 pgtypes.Oid, v5 pgtypes.Tid, ...) (pgtypes.Anyenum, error)

+ func Mktinterval(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (pgtypes.Tinterval, error)

+ func Mod(db XODB, v0 int64, v1 int64, v2 int16, v3 int16, v4 int, v5 int, v6 float64, ...) (float64, error)

+ func Mode(db XODB, v0 pgtypes.Anyelement) (pgtypes.Anyelement, error)

+ func ModeFinal(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyelement) (pgtypes.Anyelement, error)

+ func Money(db XODB, v0 int64, v1 int, v2 float64) (string, error)

+ func MulDInterval(db XODB, v0 float64, v1 *time.Duration) (*time.Duration, error)

+ func MxidAge(db XODB, v0 pgtypes.Xid) (int, error)

+ func Name(db XODB, v0 string, v1 string, v2 string) (pgtypes.Name, error)

+ func Nameeq(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Namege(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Namegt(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Nameiclike(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Nameicnlike(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Nameicregexeq(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Nameicregexne(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Namein(db XODB, v0 pgtypes.Cstring) (pgtypes.Name, error)

+ func Namele(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Namelike(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Namelt(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Namene(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (bool, error)

+ func Namenlike(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Nameout(db XODB, v0 pgtypes.Name) (pgtypes.Cstring, error)

+ func Namerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Name, error)

+ func Nameregexeq(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Nameregexne(db XODB, v0 pgtypes.Name, v1 string) (bool, error)

+ func Namesend(db XODB, v0 pgtypes.Name) ([]byte, error)

+ func Neqjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Neqsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Netmask(db XODB, v0 string) (string, error)

+ func Network(db XODB, v0 string) (pgtypes.Cidr, error)

+ func NetworkCmp(db XODB, v0 string, v1 string) (int, error)

+ func NetworkEq(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkGe(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkGt(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkLarger(db XODB, v0 string, v1 string) (string, error)

+ func NetworkLe(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkLt(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkNe(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkOverlap(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkSmaller(db XODB, v0 string, v1 string) (string, error)

+ func NetworkSub(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkSubeq(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkSup(db XODB, v0 string, v1 string) (bool, error)

+ func NetworkSupeq(db XODB, v0 string, v1 string) (bool, error)

+ func Networkjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Networksel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Nextval(db XODB, v0 pgtypes.Regclass) (int64, error)

+ func Nlikejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Nlikesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Notlike(db XODB, v0 []byte, v1 []byte, v2 pgtypes.Name, v3 string, v4 string, ...) (bool, error)

+ func Now(db XODB) (time.Time, error)

+ func Npoints(db XODB, v0 pgtypes.Path, v1 pgtypes.Polygon) (int, error)

+ func NthValue(db XODB, v0 pgtypes.Anyelement, v1 int) (pgtypes.Anyelement, error)

+ func Ntile(db XODB, v0 int) (int, error)

+ func Numeric(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 string, ...) (float64, error)

+ func NumericAbs(db XODB, v0 float64) (float64, error)

+ func NumericAccum(db XODB, v0 pgtypes.Internal, v1 float64) (pgtypes.Internal, error)

+ func NumericAccumInv(db XODB, v0 pgtypes.Internal, v1 float64) (pgtypes.Internal, error)

+ func NumericAdd(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericAvg(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericAvgAccum(db XODB, v0 pgtypes.Internal, v1 float64) (pgtypes.Internal, error)

+ func NumericCmp(db XODB, v0 float64, v1 float64) (int, error)

+ func NumericDiv(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericDivTrunc(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericEq(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericExp(db XODB, v0 float64) (float64, error)

+ func NumericFac(db XODB, v0 int64) (float64, error)

+ func NumericGe(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericGt(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (float64, error)

+ func NumericInc(db XODB, v0 float64) (float64, error)

+ func NumericLarger(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericLe(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericLn(db XODB, v0 float64) (float64, error)

+ func NumericLog(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericLt(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericMod(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericMul(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericNe(db XODB, v0 float64, v1 float64) (bool, error)

+ func NumericOut(db XODB, v0 float64) (pgtypes.Cstring, error)

+ func NumericPolyAvg(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPolyStddevPop(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPolyStddevSamp(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPolySum(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPolyVarPop(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPolyVarSamp(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericPower(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (float64, error)

+ func NumericSend(db XODB, v0 float64) ([]byte, error)

+ func NumericSmaller(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericSortsupport(db XODB, v0 pgtypes.Internal) error

+ func NumericSqrt(db XODB, v0 float64) (float64, error)

+ func NumericStddevPop(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericStddevSamp(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericSub(db XODB, v0 float64, v1 float64) (float64, error)

+ func NumericSum(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func NumericUminus(db XODB, v0 float64) (float64, error)

+ func NumericUplus(db XODB, v0 float64) (float64, error)

+ func NumericVarPop(db XODB, v0 pgtypes.Internal) (float64, error)

+ func NumericVarSamp(db XODB, v0 pgtypes.Internal) (float64, error)

+ func Numerictypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Numerictypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Numnode(db XODB, v0 pgtypes.Tsquery) (int, error)

+ func Numrange(db XODB, v0 float64, v1 float64, v2 float64, v3 float64, v4 string) (pgtypes.Numrange, error)

+ func NumrangeSubdiff(db XODB, v0 float64, v1 float64) (float64, error)

+ func ObjDescription(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 pgtypes.Name) (string, error)

+ func OctetLength(db XODB, v0 []byte, v1 string, v2 string, v3 uint8) (int, error)

+ func Oid(db XODB, v0 int64) (pgtypes.Oid, error)

+ func Oideq(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidge(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidgt(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidin(db XODB, v0 pgtypes.Cstring) (pgtypes.Oid, error)

+ func Oidlarger(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (pgtypes.Oid, error)

+ func Oidle(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidlt(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidne(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (bool, error)

+ func Oidout(db XODB, v0 pgtypes.Oid) (pgtypes.Cstring, error)

+ func Oidrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Oid, error)

+ func Oidsend(db XODB, v0 pgtypes.Oid) ([]byte, error)

+ func Oidsmaller(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (pgtypes.Oid, error)

+ func Oidvectoreq(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorge(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorgt(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorin(db XODB, v0 pgtypes.Cstring) (pgtypes.Oidvector, error)

+ func Oidvectorle(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorlt(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorne(db XODB, v0 pgtypes.Oidvector, v1 pgtypes.Oidvector) (bool, error)

+ func Oidvectorout(db XODB, v0 pgtypes.Oidvector) (pgtypes.Cstring, error)

+ func Oidvectorrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Oidvector, error)

+ func Oidvectorsend(db XODB, v0 pgtypes.Oidvector) ([]byte, error)

+ func Oidvectortypes(db XODB, v0 pgtypes.Oidvector) (string, error)

+ func OnPb(db XODB, v0 pgtypes.Point, v1 pgtypes.Box) (bool, error)

+ func OnPl(db XODB, v0 pgtypes.Point, v1 pgtypes.Line) (bool, error)

+ func OnPpath(db XODB, v0 pgtypes.Point, v1 pgtypes.Path) (bool, error)

+ func OnPs(db XODB, v0 pgtypes.Point, v1 pgtypes.Lseg) (bool, error)

+ func OnSb(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Box) (bool, error)

+ func OnSl(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Line) (bool, error)

+ func OpaqueIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Opaque, error)

+ func OpaqueOut(db XODB, v0 pgtypes.Opaque) (pgtypes.Cstring, error)

+ func OrderedSetTransition(db XODB, v0 pgtypes.Internal, v1 []byte) (pgtypes.Internal, error)

+ func OrderedSetTransitionMulti(db XODB, v0 pgtypes.Internal, v1 []byte) (pgtypes.Internal, error)

+ func Overlaps(db XODB, v0 time.Time, v1 time.Time, v2 time.Time, v3 time.Time, v4 time.Time, ...) (bool, error)

+ func Overlay(db XODB, v0 []byte, v1 []byte, v2 int, v3 string, v4 string, v5 int, v6 uint8, ...) (uint8, error)

+ func Path(db XODB, v0 pgtypes.Polygon) (pgtypes.Path, error)

+ func PathAdd(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (pgtypes.Path, error)

+ func PathAddPt(db XODB, v0 pgtypes.Path, v1 pgtypes.Point) (pgtypes.Path, error)

+ func PathCenter(db XODB, v0 pgtypes.Path) (pgtypes.Point, error)

+ func PathContainPt(db XODB, v0 pgtypes.Path, v1 pgtypes.Point) (bool, error)

+ func PathDistance(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (float64, error)

+ func PathDivPt(db XODB, v0 pgtypes.Path, v1 pgtypes.Point) (pgtypes.Path, error)

+ func PathIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Path, error)

+ func PathInter(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathLength(db XODB, v0 pgtypes.Path) (float64, error)

+ func PathMulPt(db XODB, v0 pgtypes.Path, v1 pgtypes.Point) (pgtypes.Path, error)

+ func PathNEq(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathNGe(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathNGt(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathNLe(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathNLt(db XODB, v0 pgtypes.Path, v1 pgtypes.Path) (bool, error)

+ func PathNpoints(db XODB, v0 pgtypes.Path) (int, error)

+ func PathOut(db XODB, v0 pgtypes.Path) (pgtypes.Cstring, error)

+ func PathRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Path, error)

+ func PathSend(db XODB, v0 pgtypes.Path) ([]byte, error)

+ func PathSubPt(db XODB, v0 pgtypes.Path, v1 pgtypes.Point) (pgtypes.Path, error)

+ func Pclose(db XODB, v0 pgtypes.Path) (pgtypes.Path, error)

+ func PercentRank(db XODB, v0 []byte) (float64, error)

+ func PercentRankFinal(db XODB, v0 pgtypes.Internal, v1 []byte) (float64, error)

+ func PercentileCont(db XODB, v0 float64, v1 float64, v2 float64, v3 *time.Duration, v4 []float64, ...) ([]*time.Duration, error)

+ func PercentileContFloat8Final(db XODB, v0 pgtypes.Internal, v1 float64) (float64, error)

+ func PercentileContFloat8MultiFinal(db XODB, v0 pgtypes.Internal, v1 []float64) ([]float64, error)

+ func PercentileContIntervalFinal(db XODB, v0 pgtypes.Internal, v1 float64) (*time.Duration, error)

+ func PercentileContIntervalMultiFinal(db XODB, v0 pgtypes.Internal, v1 []float64) ([]*time.Duration, error)

+ func PercentileDisc(db XODB, v0 float64, v1 pgtypes.Anyelement, v2 []float64, ...) (pgtypes.Anyarray, error)

+ func PercentileDiscFinal(db XODB, v0 pgtypes.Internal, v1 float64, v2 pgtypes.Anyelement) (pgtypes.Anyelement, error)

+ func PercentileDiscMultiFinal(db XODB, v0 pgtypes.Internal, v1 []float64, v2 pgtypes.Anyelement) (pgtypes.Anyarray, error)

+ func PgAdvisoryLock(db XODB, v0 int64, v1 int, v2 int) error

+ func PgAdvisoryLockShared(db XODB, v0 int64, v1 int, v2 int) error

+ func PgAdvisoryUnlock(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgAdvisoryUnlockAll(db XODB) error

+ func PgAdvisoryUnlockShared(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgAdvisoryXactLock(db XODB, v0 int64, v1 int, v2 int) error

+ func PgAdvisoryXactLockShared(db XODB, v0 int64, v1 int, v2 int) error

+ func PgAvailableExtensionVersions(db XODB) ([]pgtypes.Record, error)

+ func PgAvailableExtensions(db XODB) ([]pgtypes.Record, error)

+ func PgBackendPid(db XODB) (int, error)

+ func PgBackupStartTime(db XODB) (time.Time, error)

+ func PgCancelBackend(db XODB, v0 int) (bool, error)

+ func PgCharToEncoding(db XODB, v0 pgtypes.Name) (int, error)

+ func PgClientEncoding(db XODB) (pgtypes.Name, error)

+ func PgCollationFor(db XODB, v0 []byte) (string, error)

+ func PgCollationIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgColumnIsUpdatable(db XODB, v0 pgtypes.Regclass, v1 int16, v2 bool) (bool, error)

+ func PgColumnSize(db XODB, v0 []byte) (int, error)

+ func PgConfLoadTime(db XODB) (time.Time, error)

+ func PgConversionIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgCreateLogicalReplicationSlot(db XODB, v0 pgtypes.Name, v1 pgtypes.Name) (pgtypes.Record, error)

+ func PgCreatePhysicalReplicationSlot(db XODB, v0 pgtypes.Name) (pgtypes.Record, error)

+ func PgCreateRestorePoint(db XODB, v0 string) (pgtypes.PgLsn, error)

+ func PgCurrentXlogInsertLocation(db XODB) (pgtypes.PgLsn, error)

+ func PgCurrentXlogLocation(db XODB) (pgtypes.PgLsn, error)

+ func PgCursor(db XODB) ([]pgtypes.Record, error)

+ func PgDatabaseSize(db XODB, v0 pgtypes.Name, v1 pgtypes.Oid) (int64, error)

+ func PgDdlCommandIn(db XODB, v0 pgtypes.Cstring) (pgtypes.PgDdlCommand, error)

+ func PgDdlCommandOut(db XODB, v0 pgtypes.PgDdlCommand) (pgtypes.Cstring, error)

+ func PgDdlCommandRecv(db XODB, v0 pgtypes.Internal) (pgtypes.PgDdlCommand, error)

+ func PgDdlCommandSend(db XODB, v0 pgtypes.PgDdlCommand) ([]byte, error)

+ func PgDescribeObject(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 int) (string, error)

+ func PgDropReplicationSlot(db XODB, v0 pgtypes.Name) error

+ func PgEncodingMaxLength(db XODB, v0 int) (int, error)

+ func PgEncodingToChar(db XODB, v0 int) (pgtypes.Name, error)

+ func PgEventTriggerDdlCommands(db XODB) ([]pgtypes.Record, error)

+ func PgEventTriggerDroppedObjects(db XODB) ([]pgtypes.Record, error)

+ func PgEventTriggerTableRewriteOid(db XODB) (pgtypes.Oid, error)

+ func PgEventTriggerTableRewriteReason(db XODB) (int, error)

+ func PgExportSnapshot(db XODB) (string, error)

+ func PgExtensionConfigDump(db XODB, v0 pgtypes.Regclass, v1 string) error

+ func PgExtensionUpdatePaths(db XODB, v0 pgtypes.Name) ([]pgtypes.Record, error)

+ func PgFilenodeRelation(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid) (pgtypes.Regclass, error)

+ func PgFunctionIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgGetConstraintdef(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 bool) (string, error)

+ func PgGetExpr(db XODB, v0 pgtypes.PgNodeTree, v1 pgtypes.Oid, v2 pgtypes.PgNodeTree, ...) (string, error)

+ func PgGetFunctionArgDefault(db XODB, v0 pgtypes.Oid, v1 int) (string, error)

+ func PgGetFunctionArguments(db XODB, v0 pgtypes.Oid) (string, error)

+ func PgGetFunctionIdentityArguments(db XODB, v0 pgtypes.Oid) (string, error)

+ func PgGetFunctionResult(db XODB, v0 pgtypes.Oid) (string, error)

+ func PgGetFunctiondef(db XODB, v0 pgtypes.Oid) (string, error)

+ func PgGetIndexdef(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 int, v3 bool) (string, error)

+ func PgGetKeywords(db XODB) ([]pgtypes.Record, error)

+ func PgGetMultixactMembers(db XODB, v0 pgtypes.Xid) ([]pgtypes.Record, error)

+ func PgGetObjectAddress(db XODB, v0 string, v1 StringSlice, v2 StringSlice) (pgtypes.Record, error)

+ func PgGetReplicationSlots(db XODB) ([]pgtypes.Record, error)

+ func PgGetRuledef(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 bool) (string, error)

+ func PgGetSerialSequence(db XODB, v0 string, v1 string) (string, error)

+ func PgGetTriggerdef(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 bool) (string, error)

+ func PgGetUserbyid(db XODB, v0 pgtypes.Oid) (pgtypes.Name, error)

+ func PgGetViewdef(db XODB, v0 string, v1 pgtypes.Oid, v2 string, v3 bool, v4 pgtypes.Oid, ...) (string, error)

+ func PgHasRole(db XODB, v0 pgtypes.Name, v1 string, v2 pgtypes.Oid, v3 string, ...) (bool, error)

+ func PgIdentifyObject(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 int) (pgtypes.Record, error)

+ func PgIdentifyObjectAsAddress(db XODB, v0 pgtypes.Oid, v1 pgtypes.Oid, v2 int) (pgtypes.Record, error)

+ func PgIndexesSize(db XODB, v0 pgtypes.Regclass) (int64, error)

+ func PgIsInBackup(db XODB) (bool, error)

+ func PgIsInRecovery(db XODB) (bool, error)

+ func PgIsOtherTempSchema(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgIsXlogReplayPaused(db XODB) (bool, error)

+ func PgLastCommittedXact(db XODB) (pgtypes.Record, error)

+ func PgLastXactReplayTimestamp(db XODB) (time.Time, error)

+ func PgLastXlogReceiveLocation(db XODB) (pgtypes.PgLsn, error)

+ func PgLastXlogReplayLocation(db XODB) (pgtypes.PgLsn, error)

+ func PgListeningChannels(db XODB) ([]string, error)

+ func PgLockStatus(db XODB) ([]pgtypes.Record, error)

+ func PgLogicalSlotGetBinaryChanges(db XODB, v0 pgtypes.Name, v1 pgtypes.PgLsn, v2 int, v3 StringSlice) ([]pgtypes.Record, error)

+ func PgLogicalSlotGetChanges(db XODB, v0 pgtypes.Name, v1 pgtypes.PgLsn, v2 int, v3 StringSlice) ([]pgtypes.Record, error)

+ func PgLogicalSlotPeekBinaryChanges(db XODB, v0 pgtypes.Name, v1 pgtypes.PgLsn, v2 int, v3 StringSlice) ([]pgtypes.Record, error)

+ func PgLogicalSlotPeekChanges(db XODB, v0 pgtypes.Name, v1 pgtypes.PgLsn, v2 int, v3 StringSlice) ([]pgtypes.Record, error)

+ func PgLsDir(db XODB, v0 string, v1 string, v2 bool, v3 bool) ([]string, error)

+ func PgLsnCmp(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (int, error)

+ func PgLsnEq(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnGe(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnGt(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnHash(db XODB, v0 pgtypes.PgLsn) (int, error)

+ func PgLsnIn(db XODB, v0 pgtypes.Cstring) (pgtypes.PgLsn, error)

+ func PgLsnLe(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnLt(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnMi(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (float64, error)

+ func PgLsnNe(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (bool, error)

+ func PgLsnOut(db XODB, v0 pgtypes.PgLsn) (pgtypes.Cstring, error)

+ func PgLsnRecv(db XODB, v0 pgtypes.Internal) (pgtypes.PgLsn, error)

+ func PgLsnSend(db XODB, v0 pgtypes.PgLsn) ([]byte, error)

+ func PgMyTempSchema(db XODB) (pgtypes.Oid, error)

+ func PgNodeTreeIn(db XODB, v0 pgtypes.Cstring) (pgtypes.PgNodeTree, error)

+ func PgNodeTreeOut(db XODB, v0 pgtypes.PgNodeTree) (pgtypes.Cstring, error)

+ func PgNodeTreeRecv(db XODB, v0 pgtypes.Internal) (pgtypes.PgNodeTree, error)

+ func PgNodeTreeSend(db XODB, v0 pgtypes.PgNodeTree) ([]byte, error)

+ func PgNotify(db XODB, v0 string, v1 string) error

+ func PgOpclassIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgOperatorIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgOpfamilyIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgOptionsToTable(db XODB, v0 StringSlice) ([]pgtypes.Record, error)

+ func PgPostmasterStartTime(db XODB) (time.Time, error)

+ func PgPreparedStatement(db XODB) ([]pgtypes.Record, error)

+ func PgPreparedXact(db XODB) ([]pgtypes.Record, error)

+ func PgReadBinaryFile(db XODB, v0 string, v1 string, v2 int64, v3 int64, v4 string, v5 int64, ...) ([]byte, error)

+ func PgReadFile(db XODB, v0 string, v1 string, v2 int64, v3 int64, v4 string, v5 int64, ...) (string, error)

+ func PgRelationFilenode(db XODB, v0 pgtypes.Regclass) (pgtypes.Oid, error)

+ func PgRelationFilepath(db XODB, v0 pgtypes.Regclass) (string, error)

+ func PgRelationIsUpdatable(db XODB, v0 pgtypes.Regclass, v1 bool) (int, error)

+ func PgRelationSize(db XODB, v0 pgtypes.Regclass, v1 pgtypes.Regclass, v2 string) (int64, error)

+ func PgReloadConf(db XODB) (bool, error)

+ func PgReplicationOriginAdvance(db XODB, v0 string, v1 pgtypes.PgLsn) error

+ func PgReplicationOriginCreate(db XODB, v0 string) (pgtypes.Oid, error)

+ func PgReplicationOriginDrop(db XODB, v0 string) error

+ func PgReplicationOriginOid(db XODB, v0 string) (pgtypes.Oid, error)

+ func PgReplicationOriginProgress(db XODB, v0 string, v1 bool) (pgtypes.PgLsn, error)

+ func PgReplicationOriginSessionIsSetup(db XODB) (bool, error)

+ func PgReplicationOriginSessionProgress(db XODB, v0 bool) (pgtypes.PgLsn, error)

+ func PgReplicationOriginSessionReset(db XODB) error

+ func PgReplicationOriginSessionSetup(db XODB, v0 string) error

+ func PgReplicationOriginXactReset(db XODB, v0 pgtypes.PgLsn, v1 time.Time) error

+ func PgReplicationOriginXactSetup(db XODB, v0 pgtypes.PgLsn, v1 time.Time) error

+ func PgRotateLogfile(db XODB) (bool, error)

+ func PgSequenceParameters(db XODB, v0 pgtypes.Oid) (pgtypes.Record, error)

+ func PgShowAllFileSettings(db XODB) ([]pgtypes.Record, error)

+ func PgShowAllSettings(db XODB) ([]pgtypes.Record, error)

+ func PgShowReplicationOriginStatus(db XODB) ([]pgtypes.Record, error)

+ func PgSizePretty(db XODB, v0 int64, v1 float64) (string, error)

+ func PgSleep(db XODB, v0 float64) error

+ func PgSleepFor(db XODB, v0 *time.Duration) error

+ func PgSleepUntil(db XODB, v0 time.Time) error

+ func PgStartBackup(db XODB, v0 string, v1 bool) (pgtypes.PgLsn, error)

+ func PgStatClearSnapshot(db XODB) error

+ func PgStatFile(db XODB, v0 string, v1 string, v2 bool) (pgtypes.Record, error)

+ func PgStatGetActivity(db XODB, v0 int) ([]pgtypes.Record, error)

+ func PgStatGetAnalyzeCount(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetArchiver(db XODB) (pgtypes.Record, error)

+ func PgStatGetAutoanalyzeCount(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetAutovacuumCount(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetBackendActivity(db XODB, v0 int) (string, error)

+ func PgStatGetBackendActivityStart(db XODB, v0 int) (time.Time, error)

+ func PgStatGetBackendClientAddr(db XODB, v0 int) (string, error)

+ func PgStatGetBackendClientPort(db XODB, v0 int) (int, error)

+ func PgStatGetBackendDbid(db XODB, v0 int) (pgtypes.Oid, error)

+ func PgStatGetBackendIdset(db XODB) ([]int, error)

+ func PgStatGetBackendPid(db XODB, v0 int) (int, error)

+ func PgStatGetBackendStart(db XODB, v0 int) (time.Time, error)

+ func PgStatGetBackendUserid(db XODB, v0 int) (pgtypes.Oid, error)

+ func PgStatGetBackendWaiting(db XODB, v0 int) (bool, error)

+ func PgStatGetBackendXactStart(db XODB, v0 int) (time.Time, error)

+ func PgStatGetBgwriterBufWrittenCheckpoints(db XODB) (int64, error)

+ func PgStatGetBgwriterBufWrittenClean(db XODB) (int64, error)

+ func PgStatGetBgwriterMaxwrittenClean(db XODB) (int64, error)

+ func PgStatGetBgwriterRequestedCheckpoints(db XODB) (int64, error)

+ func PgStatGetBgwriterStatResetTime(db XODB) (time.Time, error)

+ func PgStatGetBgwriterTimedCheckpoints(db XODB) (int64, error)

+ func PgStatGetBlocksFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetBlocksHit(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetBufAlloc(db XODB) (int64, error)

+ func PgStatGetBufFsyncBackend(db XODB) (int64, error)

+ func PgStatGetBufWrittenBackend(db XODB) (int64, error)

+ func PgStatGetCheckpointSyncTime(db XODB) (float64, error)

+ func PgStatGetCheckpointWriteTime(db XODB) (float64, error)

+ func PgStatGetDbBlkReadTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetDbBlkWriteTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetDbBlocksFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbBlocksHit(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictAll(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictBufferpin(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictLock(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictSnapshot(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictStartupDeadlock(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbConflictTablespace(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbDeadlocks(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbNumbackends(db XODB, v0 pgtypes.Oid) (int, error)

+ func PgStatGetDbStatResetTime(db XODB, v0 pgtypes.Oid) (time.Time, error)

+ func PgStatGetDbTempBytes(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTempFiles(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTuplesDeleted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTuplesFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTuplesInserted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTuplesReturned(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbTuplesUpdated(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbXactCommit(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDbXactRollback(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetDeadTuples(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetFunctionCalls(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetFunctionSelfTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetFunctionTotalTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetLastAnalyzeTime(db XODB, v0 pgtypes.Oid) (time.Time, error)

+ func PgStatGetLastAutoanalyzeTime(db XODB, v0 pgtypes.Oid) (time.Time, error)

+ func PgStatGetLastAutovacuumTime(db XODB, v0 pgtypes.Oid) (time.Time, error)

+ func PgStatGetLastVacuumTime(db XODB, v0 pgtypes.Oid) (time.Time, error)

+ func PgStatGetLiveTuples(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetModSinceAnalyze(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetNumscans(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetSnapshotTimestamp(db XODB) (time.Time, error)

+ func PgStatGetTuplesDeleted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetTuplesFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetTuplesHotUpdated(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetTuplesInserted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetTuplesReturned(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetTuplesUpdated(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetVacuumCount(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetWalSenders(db XODB) ([]pgtypes.Record, error)

+ func PgStatGetXactBlocksFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactBlocksHit(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactFunctionCalls(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactFunctionSelfTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetXactFunctionTotalTime(db XODB, v0 pgtypes.Oid) (float64, error)

+ func PgStatGetXactNumscans(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesDeleted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesFetched(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesHotUpdated(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesInserted(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesReturned(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatGetXactTuplesUpdated(db XODB, v0 pgtypes.Oid) (int64, error)

+ func PgStatReset(db XODB) error

+ func PgStatResetShared(db XODB, v0 string) error

+ func PgStatResetSingleFunctionCounters(db XODB, v0 pgtypes.Oid) error

+ func PgStatResetSingleTableCounters(db XODB, v0 pgtypes.Oid) error

+ func PgStopBackup(db XODB) (pgtypes.PgLsn, error)

+ func PgSwitchXlog(db XODB) (pgtypes.PgLsn, error)

+ func PgTableIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTableSize(db XODB, v0 pgtypes.Regclass) (int64, error)

+ func PgTablespaceDatabases(db XODB, v0 pgtypes.Oid) ([]pgtypes.Oid, error)

+ func PgTablespaceLocation(db XODB, v0 pgtypes.Oid) (string, error)

+ func PgTablespaceSize(db XODB, v0 pgtypes.Name, v1 pgtypes.Oid) (int64, error)

+ func PgTerminateBackend(db XODB, v0 int) (bool, error)

+ func PgTimezoneAbbrevs(db XODB) ([]pgtypes.Record, error)

+ func PgTimezoneNames(db XODB) ([]pgtypes.Record, error)

+ func PgTotalRelationSize(db XODB, v0 pgtypes.Regclass) (int64, error)

+ func PgTriggerDepth(db XODB) (int, error)

+ func PgTryAdvisoryLock(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgTryAdvisoryLockShared(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgTryAdvisoryXactLock(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgTryAdvisoryXactLockShared(db XODB, v0 int64, v1 int, v2 int) (bool, error)

+ func PgTsConfigIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTsDictIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTsParserIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTsTemplateIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTypeIsVisible(db XODB, v0 pgtypes.Oid) (bool, error)

+ func PgTypeof(db XODB, v0 []byte) (pgtypes.Regtype, error)

+ func PgXactCommitTimestamp(db XODB, v0 pgtypes.Xid) (time.Time, error)

+ func PgXlogLocationDiff(db XODB, v0 pgtypes.PgLsn, v1 pgtypes.PgLsn) (float64, error)

+ func PgXlogReplayPause(db XODB) error

+ func PgXlogReplayResume(db XODB) error

+ func PgXlogfileName(db XODB, v0 pgtypes.PgLsn) (string, error)

+ func PgXlogfileNameOffset(db XODB, v0 pgtypes.PgLsn) (pgtypes.Record, error)

+ func Pi(db XODB) (float64, error)

+ func PlaintoTsquery(db XODB, v0 string, v1 pgtypes.Regconfig, v2 string) (pgtypes.Tsquery, error)

+ func PlpgsqlCallHandler(db XODB) (pgtypes.LanguageHandler, error)

+ func PlpgsqlInlineHandler(db XODB, v0 pgtypes.Internal) error

+ func PlpgsqlValidator(db XODB, v0 pgtypes.Oid) error

+ func Point(db XODB, v0 pgtypes.Lseg, v1 pgtypes.Path, v2 pgtypes.Box, v3 pgtypes.Polygon, ...) (pgtypes.Point, error)

+ func PointAbove(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointAdd(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (pgtypes.Point, error)

+ func PointBelow(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointDistance(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (float64, error)

+ func PointDiv(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (pgtypes.Point, error)

+ func PointEq(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointHoriz(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Point, error)

+ func PointLeft(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointMul(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (pgtypes.Point, error)

+ func PointNe(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointOut(db XODB, v0 pgtypes.Point) (pgtypes.Cstring, error)

+ func PointRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Point, error)

+ func PointRight(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PointSend(db XODB, v0 pgtypes.Point) ([]byte, error)

+ func PointSub(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (pgtypes.Point, error)

+ func PointVert(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (bool, error)

+ func PolyAbove(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyBelow(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyCenter(db XODB, v0 pgtypes.Polygon) (pgtypes.Point, error)

+ func PolyContain(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyContainPt(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Point) (bool, error)

+ func PolyContained(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyDistance(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (float64, error)

+ func PolyIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Polygon, error)

+ func PolyLeft(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyNpoints(db XODB, v0 pgtypes.Polygon) (int, error)

+ func PolyOut(db XODB, v0 pgtypes.Polygon) (pgtypes.Cstring, error)

+ func PolyOverabove(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyOverbelow(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyOverlap(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyOverleft(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyOverright(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolyRecv(db XODB, v0 pgtypes.Internal) (pgtypes.Polygon, error)

+ func PolyRight(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolySame(db XODB, v0 pgtypes.Polygon, v1 pgtypes.Polygon) (bool, error)

+ func PolySend(db XODB, v0 pgtypes.Polygon) ([]byte, error)

+ func Polygon(db XODB, v0 pgtypes.Path, v1 pgtypes.Box, v2 pgtypes.Circle, v3 int, ...) (pgtypes.Polygon, error)

+ func Popen(db XODB, v0 pgtypes.Path) (pgtypes.Path, error)

+ func Position(db XODB, v0 []byte, v1 []byte, v2 string, v3 string, v4 uint8, v5 uint8) (int, error)

+ func Positionjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Positionsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func PostgresqlFdwValidator(db XODB, v0 StringSlice, v1 pgtypes.Oid) (bool, error)

+ func Pow(db XODB, v0 float64, v1 float64, v2 float64, v3 float64) (float64, error)

+ func Power(db XODB, v0 float64, v1 float64, v2 float64, v3 float64) (float64, error)

+ func PrsdEnd(db XODB, v0 pgtypes.Internal) error

+ func PrsdHeadline(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Tsquery) (pgtypes.Internal, error)

+ func PrsdLextype(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func PrsdNexttoken(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func PrsdStart(db XODB, v0 pgtypes.Internal, v1 int) (pgtypes.Internal, error)

+ func PtContainedCircle(db XODB, v0 pgtypes.Point, v1 pgtypes.Circle) (bool, error)

+ func PtContainedPoly(db XODB, v0 pgtypes.Point, v1 pgtypes.Polygon) (bool, error)

+ func QueryToXML(db XODB, v0 string, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func QueryToXMLAndXmlschema(db XODB, v0 string, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func QueryToXmlschema(db XODB, v0 string, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func Querytree(db XODB, v0 pgtypes.Tsquery) (string, error)

+ func QuoteIdent(db XODB, v0 string) (string, error)

+ func QuoteLiteral(db XODB, v0 string, v1 pgtypes.Anyelement) (string, error)

+ func QuoteNullable(db XODB, v0 string, v1 pgtypes.Anyelement) (string, error)

+ func Radians(db XODB, v0 float64) (float64, error)

+ func Radius(db XODB, v0 pgtypes.Circle) (float64, error)

+ func Random(db XODB) (float64, error)

+ func RangeAdjacent(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeAfter(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeBefore(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeCmp(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (int, error)

+ func RangeContainedBy(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeContains(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeContainsElem(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyelement) (bool, error)

+ func RangeEq(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeGe(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeGistCompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Anyrange, v2 int, v3 pgtypes.Oid, ...) (bool, error)

+ func RangeGistDecompress(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistFetch(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistPenalty(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistSame(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGistUnion(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func RangeGt(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (pgtypes.Anyrange, error)

+ func RangeIntersect(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (pgtypes.Anyrange, error)

+ func RangeLe(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeLt(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeMerge(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (pgtypes.Anyrange, error)

+ func RangeMinus(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (pgtypes.Anyrange, error)

+ func RangeNe(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeOut(db XODB, v0 pgtypes.Anyrange) (pgtypes.Cstring, error)

+ func RangeOverlaps(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeOverleft(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeOverright(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (bool, error)

+ func RangeRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (pgtypes.Anyrange, error)

+ func RangeSend(db XODB, v0 pgtypes.Anyrange) ([]byte, error)

+ func RangeTypanalyze(db XODB, v0 pgtypes.Internal) (bool, error)

+ func RangeUnion(db XODB, v0 pgtypes.Anyrange, v1 pgtypes.Anyrange) (pgtypes.Anyrange, error)

+ func Rangesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Rank(db XODB, v0 []byte) (int64, error)

+ func RankFinal(db XODB, v0 pgtypes.Internal, v1 []byte) (int64, error)

+ func RecordEq(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordGe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordGt(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageEq(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageGe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageGt(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageLe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageLt(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordImageNe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (pgtypes.Record, error)

+ func RecordLe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordLt(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordNe(db XODB, v0 pgtypes.Record, v1 pgtypes.Record) (bool, error)

+ func RecordOut(db XODB, v0 pgtypes.Record) (pgtypes.Cstring, error)

+ func RecordRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (pgtypes.Record, error)

+ func RecordSend(db XODB, v0 pgtypes.Record) ([]byte, error)

+ func Regclass(db XODB, v0 string) (pgtypes.Regclass, error)

+ func Regclassin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regclass, error)

+ func Regclassout(db XODB, v0 pgtypes.Regclass) (pgtypes.Cstring, error)

+ func Regclassrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regclass, error)

+ func Regclasssend(db XODB, v0 pgtypes.Regclass) ([]byte, error)

+ func Regconfigin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regconfig, error)

+ func Regconfigout(db XODB, v0 pgtypes.Regconfig) (pgtypes.Cstring, error)

+ func Regconfigrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regconfig, error)

+ func Regconfigsend(db XODB, v0 pgtypes.Regconfig) ([]byte, error)

+ func Regdictionaryin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regdictionary, error)

+ func Regdictionaryout(db XODB, v0 pgtypes.Regdictionary) (pgtypes.Cstring, error)

+ func Regdictionaryrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regdictionary, error)

+ func Regdictionarysend(db XODB, v0 pgtypes.Regdictionary) ([]byte, error)

+ func Regexeqjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Regexeqsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Regexnejoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Regexnesel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func RegexpReplace(db XODB, v0 string, v1 string, v2 string, v3 string, v4 string, v5 string, ...) (string, error)

+ func RegexpSplitToTable(db XODB, v0 string, v1 string, v2 string, v3 string, v4 string) ([]string, error)

+ func Regnamespacein(db XODB, v0 pgtypes.Cstring) (pgtypes.Regnamespace, error)

+ func Regnamespaceout(db XODB, v0 pgtypes.Regnamespace) (pgtypes.Cstring, error)

+ func Regnamespacerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regnamespace, error)

+ func Regnamespacesend(db XODB, v0 pgtypes.Regnamespace) ([]byte, error)

+ func Regoperatorin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regoperator, error)

+ func Regoperatorout(db XODB, v0 pgtypes.Regoperator) (pgtypes.Cstring, error)

+ func Regoperatorrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regoperator, error)

+ func Regoperatorsend(db XODB, v0 pgtypes.Regoperator) ([]byte, error)

+ func Regoperin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regoper, error)

+ func Regoperout(db XODB, v0 pgtypes.Regoper) (pgtypes.Cstring, error)

+ func Regoperrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regoper, error)

+ func Regopersend(db XODB, v0 pgtypes.Regoper) ([]byte, error)

+ func Regprocedurein(db XODB, v0 pgtypes.Cstring) (pgtypes.Regprocedure, error)

+ func Regprocedureout(db XODB, v0 pgtypes.Regprocedure) (pgtypes.Cstring, error)

+ func Regprocedurerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regprocedure, error)

+ func Regproceduresend(db XODB, v0 pgtypes.Regprocedure) ([]byte, error)

+ func Regprocin(db XODB, v0 pgtypes.Cstring) (pgtypes.Regproc, error)

+ func Regprocout(db XODB, v0 pgtypes.Regproc) (pgtypes.Cstring, error)

+ func Regprocrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regproc, error)

+ func Regprocsend(db XODB, v0 pgtypes.Regproc) ([]byte, error)

+ func RegrAvgx(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrAvgy(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrCount(db XODB, v0 float64, v1 float64) (int64, error)

+ func RegrIntercept(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrR2(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrSlope(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrSxx(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrSxy(db XODB, v0 float64, v1 float64) (float64, error)

+ func RegrSyy(db XODB, v0 float64, v1 float64) (float64, error)

+ func Regrolein(db XODB, v0 pgtypes.Cstring) (pgtypes.Regrole, error)

+ func Regroleout(db XODB, v0 pgtypes.Regrole) (pgtypes.Cstring, error)

+ func Regrolerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regrole, error)

+ func Regrolesend(db XODB, v0 pgtypes.Regrole) ([]byte, error)

+ func Regtypein(db XODB, v0 pgtypes.Cstring) (pgtypes.Regtype, error)

+ func Regtypeout(db XODB, v0 pgtypes.Regtype) (pgtypes.Cstring, error)

+ func Regtyperecv(db XODB, v0 pgtypes.Internal) (pgtypes.Regtype, error)

+ func Regtypesend(db XODB, v0 pgtypes.Regtype) ([]byte, error)

+ func Reltime(db XODB, v0 *time.Duration) (pgtypes.Reltime, error)

+ func Reltimeeq(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimege(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimegt(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimein(db XODB, v0 pgtypes.Cstring) (pgtypes.Reltime, error)

+ func Reltimele(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimelt(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimene(db XODB, v0 pgtypes.Reltime, v1 pgtypes.Reltime) (bool, error)

+ func Reltimeout(db XODB, v0 pgtypes.Reltime) (pgtypes.Cstring, error)

+ func Reltimerecv(db XODB, v0 pgtypes.Internal) (pgtypes.Reltime, error)

+ func Reltimesend(db XODB, v0 pgtypes.Reltime) ([]byte, error)

+ func Repeat(db XODB, v0 string, v1 int) (string, error)

+ func Replace(db XODB, v0 string, v1 string, v2 string) (string, error)

+ func Reverse(db XODB, v0 string) (string, error)

+ func Right(db XODB, v0 string, v1 int) (string, error)

+ func Round(db XODB, v0 float64, v1 float64, v2 float64, v3 int) (float64, error)

+ func RowNumber(db XODB) (int64, error)

+ func RowSecurityActive(db XODB, v0 string, v1 pgtypes.Oid) (bool, error)

+ func RowToJSON(db XODB, v0 pgtypes.Record, v1 pgtypes.Record, v2 bool) (pgtypes.JSON, error)

+ func Rpad(db XODB, v0 string, v1 int, v2 string, v3 int, v4 string) (string, error)

+ func Rtrim(db XODB, v0 string, v1 string, v2 string) (string, error)

+ func Scalargtjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Scalargtsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func Scalarltjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Scalarltsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func SchemaToXML(db XODB, v0 pgtypes.Name, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func SchemaToXMLAndXmlschema(db XODB, v0 pgtypes.Name, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func SchemaToXmlschema(db XODB, v0 pgtypes.Name, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func SessionUser(db XODB) (pgtypes.Name, error)

+ func SetBit(db XODB, v0 []byte, v1 int, v2 int, v3 uint8, v4 int, v5 int) (uint8, error)

+ func SetByte(db XODB, v0 []byte, v1 int, v2 int) ([]byte, error)

+ func SetConfig(db XODB, v0 string, v1 string, v2 bool) (string, error)

+ func SetMasklen(db XODB, v0 pgtypes.Cidr, v1 int, v2 string, v3 int) (pgtypes.Cidr, error)

+ func Setseed(db XODB, v0 float64) error

+ func Setval(db XODB, v0 pgtypes.Regclass, v1 int64, v2 pgtypes.Regclass, v3 int64, v4 bool) (int64, error)

+ func Setweight(db XODB, v0 pgtypes.Tsvector, v1 uint8) (pgtypes.Tsvector, error)

+ func ShellIn(db XODB, v0 pgtypes.Cstring) (pgtypes.Opaque, error)

+ func ShellOut(db XODB, v0 pgtypes.Opaque) (pgtypes.Cstring, error)

+ func ShiftJis2004ToEucJis2004(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func ShiftJis2004ToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func ShobjDescription(db XODB, v0 pgtypes.Oid, v1 pgtypes.Name) (string, error)

+ func Sign(db XODB, v0 float64, v1 float64) (float64, error)

+ func SimilarEscape(db XODB, v0 string, v1 string) (string, error)

+ func Sin(db XODB, v0 float64) (float64, error)

+ func SjisToEucJp(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func SjisToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func SjisToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Slope(db XODB, v0 pgtypes.Point, v1 pgtypes.Point) (float64, error)

+ func Smgreq(db XODB, v0 pgtypes.Smgr, v1 pgtypes.Smgr) (bool, error)

+ func Smgrin(db XODB, v0 pgtypes.Cstring) (pgtypes.Smgr, error)

+ func Smgrne(db XODB, v0 pgtypes.Smgr, v1 pgtypes.Smgr) (bool, error)

+ func Smgrout(db XODB, v0 pgtypes.Smgr) (pgtypes.Cstring, error)

+ func SpgKdChoose(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgKdConfig(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgKdInnerConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgKdPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgQuadChoose(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgQuadConfig(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgQuadInnerConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgQuadLeafConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func SpgQuadPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgRangeQuadChoose(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgRangeQuadConfig(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgRangeQuadInnerConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgRangeQuadLeafConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func SpgRangeQuadPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgTextChoose(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgTextConfig(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgTextInnerConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func SpgTextLeafConsistent(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func SpgTextPicksplit(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) error

+ func Spgbeginscan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Spgbuild(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal) (pgtypes.Internal, error)

+ func Spgbuildempty(db XODB, v0 pgtypes.Internal) error

+ func Spgbulkdelete(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Spgcanreturn(db XODB, v0 pgtypes.Internal, v1 int) (bool, error)

+ func Spgcostestimate(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Spgendscan(db XODB, v0 pgtypes.Internal) error

+ func Spggetbitmap(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (int64, error)

+ func Spggettuple(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (bool, error)

+ func Spginsert(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (bool, error)

+ func Spgmarkpos(db XODB, v0 pgtypes.Internal) error

+ func Spgoptions(db XODB, v0 StringSlice, v1 bool) ([]byte, error)

+ func Spgrescan(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) error

+ func Spgrestrpos(db XODB, v0 pgtypes.Internal) error

+ func Spgvacuumcleanup(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal) (pgtypes.Internal, error)

+ func SplitPart(db XODB, v0 string, v1 string, v2 int) (string, error)

+ func Sqrt(db XODB, v0 float64, v1 float64) (float64, error)

+ func StatementTimestamp(db XODB) (time.Time, error)

+ func Stddev(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func StddevPop(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func StddevSamp(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func StringAgg(db XODB, v0 []byte, v1 []byte, v2 string, v3 string) ([]byte, error)

+ func StringAggFinalfn(db XODB, v0 pgtypes.Internal) (string, error)

+ func StringAggTransfn(db XODB, v0 pgtypes.Internal, v1 string, v2 string) (pgtypes.Internal, error)

+ func Strip(db XODB, v0 pgtypes.Tsvector) (pgtypes.Tsvector, error)

+ func Strpos(db XODB, v0 string, v1 string) (int, error)

+ func Substr(db XODB, v0 []byte, v1 int, v2 string, v3 int, v4 []byte, v5 int, v6 int, ...) ([]byte, error)

+ func Substring(db XODB, v0 []byte, v1 int, v2 string, v3 int, v4 string, v5 string, v6 uint8, ...) (string, error)

+ func Sum(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 string, ...) (float64, error)

+ func System(db XODB, v0 pgtypes.Internal) (pgtypes.TsmHandler, error)

+ func TableToXML(db XODB, v0 pgtypes.Regclass, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func TableToXMLAndXmlschema(db XODB, v0 pgtypes.Regclass, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func TableToXmlschema(db XODB, v0 pgtypes.Regclass, v1 bool, v2 bool, v3 string) (pgtypes.XML, error)

+ func Tan(db XODB, v0 float64) (float64, error)

+ func Text(db XODB, v0 bool, v1 uint8, v2 pgtypes.Name, v3 pgtypes.XML, v4 string, ...) (string, error)

+ func TextGe(db XODB, v0 string, v1 string) (bool, error)

+ func TextGt(db XODB, v0 string, v1 string) (bool, error)

+ func TextLarger(db XODB, v0 string, v1 string) (string, error)

+ func TextLe(db XODB, v0 string, v1 string) (bool, error)

+ func TextLt(db XODB, v0 string, v1 string) (bool, error)

+ func TextPatternGe(db XODB, v0 string, v1 string) (bool, error)

+ func TextPatternGt(db XODB, v0 string, v1 string) (bool, error)

+ func TextPatternLe(db XODB, v0 string, v1 string) (bool, error)

+ func TextPatternLt(db XODB, v0 string, v1 string) (bool, error)

+ func TextSmaller(db XODB, v0 string, v1 string) (string, error)

+ func Textanycat(db XODB, v0 string, v1 pgtypes.Anynonarray) (string, error)

+ func Textcat(db XODB, v0 string, v1 string) (string, error)

+ func Texteq(db XODB, v0 string, v1 string) (bool, error)

+ func Texticlike(db XODB, v0 string, v1 string) (bool, error)

+ func Texticnlike(db XODB, v0 string, v1 string) (bool, error)

+ func Texticregexeq(db XODB, v0 string, v1 string) (bool, error)

+ func Texticregexne(db XODB, v0 string, v1 string) (bool, error)

+ func Textin(db XODB, v0 pgtypes.Cstring) (string, error)

+ func Textlen(db XODB, v0 string) (int, error)

+ func Textlike(db XODB, v0 string, v1 string) (bool, error)

+ func Textne(db XODB, v0 string, v1 string) (bool, error)

+ func Textnlike(db XODB, v0 string, v1 string) (bool, error)

+ func Textout(db XODB, v0 string) (pgtypes.Cstring, error)

+ func Textrecv(db XODB, v0 pgtypes.Internal) (string, error)

+ func Textregexeq(db XODB, v0 string, v1 string) (bool, error)

+ func Textregexne(db XODB, v0 string, v1 string) (bool, error)

+ func Textsend(db XODB, v0 string) ([]byte, error)

+ func ThesaurusInit(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func ThesaurusLexize(db XODB, v0 pgtypes.Internal, v1 pgtypes.Internal, v2 pgtypes.Internal, ...) (pgtypes.Internal, error)

+ func Tideq(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidge(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidgt(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidin(db XODB, v0 pgtypes.Cstring) (pgtypes.Tid, error)

+ func Tidlarger(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (pgtypes.Tid, error)

+ func Tidle(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidlt(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidne(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (bool, error)

+ func Tidout(db XODB, v0 pgtypes.Tid) (pgtypes.Cstring, error)

+ func Tidrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Tid, error)

+ func Tidsend(db XODB, v0 pgtypes.Tid) ([]byte, error)

+ func Tidsmaller(db XODB, v0 pgtypes.Tid, v1 pgtypes.Tid) (pgtypes.Tid, error)

+ func Time(db XODB, v0 pgtypes.Abstime, v1 time.Time, v2 time.Time, v3 *time.Duration, ...) (time.Time, error)

+ func TimeCmp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimeEq(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeGe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeGt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeHash(db XODB, v0 time.Time) (int, error)

+ func TimeIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimeLarger(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimeLe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeLt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeMiInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimeMiTime(db XODB, v0 time.Time, v1 time.Time) (*time.Duration, error)

+ func TimeNe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimeOut(db XODB, v0 time.Time) (pgtypes.Cstring, error)

+ func TimePlInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimeRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimeSend(db XODB, v0 time.Time) ([]byte, error)

+ func TimeSmaller(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimeTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func TimedatePl(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func Timemi(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Reltime) (pgtypes.Abstime, error)

+ func Timenow(db XODB) (pgtypes.Abstime, error)

+ func Timeofday(db XODB) (string, error)

+ func Timepl(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Reltime) (pgtypes.Abstime, error)

+ func Timestamp(db XODB, v0 pgtypes.Abstime, v1 time.Time, v2 time.Time, v3 time.Time, ...) (time.Time, error)

+ func TimestampCmp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestampCmpDate(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestampCmpTimestamptz(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestampEq(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampEqDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampEqTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGtDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampGtTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampHash(db XODB, v0 time.Time) (int, error)

+ func TimestampIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimestampIzoneTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func TimestampLarger(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimestampLe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampLeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampLeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampLt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampLtDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampLtTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampMi(db XODB, v0 time.Time, v1 time.Time) (*time.Duration, error)

+ func TimestampMiInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimestampNe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampNeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampNeTimestamptz(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestampOut(db XODB, v0 time.Time) (pgtypes.Cstring, error)

+ func TimestampPlInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimestampRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimestampSend(db XODB, v0 time.Time) ([]byte, error)

+ func TimestampSmaller(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimestampSortsupport(db XODB, v0 pgtypes.Internal) error

+ func TimestampTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func TimestampZoneTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func Timestamptypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Timestamptypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Timestamptz(db XODB, v0 pgtypes.Abstime, v1 time.Time, v2 time.Time, v3 time.Time, ...) (time.Time, error)

+ func TimestamptzCmp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestamptzCmpDate(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestamptzCmpTimestamp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimestamptzEq(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzEqDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzEqTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGtDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzGtTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimestamptzLarger(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimestamptzLe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzLeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzLeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzLt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzLtDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzLtTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzMi(db XODB, v0 time.Time, v1 time.Time) (*time.Duration, error)

+ func TimestamptzMiInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimestamptzNe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzNeDate(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzNeTimestamp(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimestamptzOut(db XODB, v0 time.Time) (pgtypes.Cstring, error)

+ func TimestamptzPlInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimestamptzRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimestamptzSend(db XODB, v0 time.Time) ([]byte, error)

+ func TimestamptzSmaller(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func Timestamptztypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Timestamptztypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Timetypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Timetypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Timetz(db XODB, v0 time.Time, v1 time.Time, v2 time.Time, v3 int) (time.Time, error)

+ func TimetzCmp(db XODB, v0 time.Time, v1 time.Time) (int, error)

+ func TimetzEq(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzGe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzGt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzHash(db XODB, v0 time.Time) (int, error)

+ func TimetzIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimetzLarger(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimetzLe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzLt(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzMiInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimetzNe(db XODB, v0 time.Time, v1 time.Time) (bool, error)

+ func TimetzOut(db XODB, v0 time.Time) (pgtypes.Cstring, error)

+ func TimetzPlInterval(db XODB, v0 time.Time, v1 *time.Duration) (time.Time, error)

+ func TimetzRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (time.Time, error)

+ func TimetzSend(db XODB, v0 time.Time) ([]byte, error)

+ func TimetzSmaller(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func TimetzdatePl(db XODB, v0 time.Time, v1 time.Time) (time.Time, error)

+ func Timetztypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Timetztypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Timezone(db XODB, v0 string, v1 time.Time, v2 string, v3 time.Time, v4 string, ...) (time.Time, error)

+ func Tinterval(db XODB, v0 pgtypes.Abstime, v1 pgtypes.Abstime) (pgtypes.Tinterval, error)

+ func Tintervalct(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalend(db XODB, v0 pgtypes.Tinterval) (pgtypes.Abstime, error)

+ func Tintervaleq(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalge(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalgt(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalin(db XODB, v0 pgtypes.Cstring) (pgtypes.Tinterval, error)

+ func Tintervalle(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalleneq(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallenge(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallengt(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallenle(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallenlt(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallenne(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Reltime) (bool, error)

+ func Tintervallt(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalne(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalout(db XODB, v0 pgtypes.Tinterval) (pgtypes.Cstring, error)

+ func Tintervalov(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Tinterval, error)

+ func Tintervalrel(db XODB, v0 pgtypes.Tinterval) (pgtypes.Reltime, error)

+ func Tintervalsame(db XODB, v0 pgtypes.Tinterval, v1 pgtypes.Tinterval) (bool, error)

+ func Tintervalsend(db XODB, v0 pgtypes.Tinterval) ([]byte, error)

+ func Tintervalstart(db XODB, v0 pgtypes.Tinterval) (pgtypes.Abstime, error)

+ func ToASCII(db XODB, v0 string, v1 string, v2 pgtypes.Name, v3 string, v4 int) (string, error)

+ func ToChar(db XODB, v0 int64, v1 string, v2 int, v3 string, v4 float32, v5 string, ...) (string, error)

+ func ToDate(db XODB, v0 string, v1 string) (time.Time, error)

+ func ToHex(db XODB, v0 int64, v1 int) (string, error)

+ func ToJSON(db XODB, v0 pgtypes.Anyelement) (pgtypes.JSON, error)

+ func ToJsonb(db XODB, v0 pgtypes.Anyelement) (pgtypes.Jsonb, error)

+ func ToNumber(db XODB, v0 string, v1 string) (float64, error)

+ func ToRegclass(db XODB, v0 pgtypes.Cstring) (pgtypes.Regclass, error)

+ func ToRegnamespace(db XODB, v0 pgtypes.Cstring) (pgtypes.Regnamespace, error)

+ func ToRegoper(db XODB, v0 pgtypes.Cstring) (pgtypes.Regoper, error)

+ func ToRegoperator(db XODB, v0 pgtypes.Cstring) (pgtypes.Regoperator, error)

+ func ToRegproc(db XODB, v0 pgtypes.Cstring) (pgtypes.Regproc, error)

+ func ToRegprocedure(db XODB, v0 pgtypes.Cstring) (pgtypes.Regprocedure, error)

+ func ToRegrole(db XODB, v0 pgtypes.Cstring) (pgtypes.Regrole, error)

+ func ToRegtype(db XODB, v0 pgtypes.Cstring) (pgtypes.Regtype, error)

+ func ToTimestamp(db XODB, v0 float64, v1 string, v2 string) (time.Time, error)

+ func ToTsquery(db XODB, v0 string, v1 pgtypes.Regconfig, v2 string) (pgtypes.Tsquery, error)

+ func ToTsvector(db XODB, v0 string, v1 pgtypes.Regconfig, v2 string) (pgtypes.Tsvector, error)

+ func TransactionTimestamp(db XODB) (time.Time, error)

+ func Translate(db XODB, v0 string, v1 string, v2 string) (string, error)

+ func TriggerOut(db XODB, v0 pgtypes.Trigger) (pgtypes.Cstring, error)

+ func Trunc(db XODB, v0 float64, v1 pgtypes.Macaddr, v2 float64, v3 float64, v4 int) (float64, error)

+ func TsDebug(db XODB, v0 string, v1 pgtypes.Regconfig, v2 string) ([]pgtypes.Record, error)

+ func TsHeadline(db XODB, v0 string, v1 pgtypes.Tsquery, v2 string, v3 pgtypes.Tsquery, ...) (string, error)

+ func TsMatchQv(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsvector) (bool, error)

+ func TsMatchTq(db XODB, v0 string, v1 pgtypes.Tsquery) (bool, error)

+ func TsMatchTt(db XODB, v0 string, v1 string) (bool, error)

+ func TsMatchVq(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsquery) (bool, error)

+ func TsParse(db XODB, v0 string, v1 string, v2 pgtypes.Oid, v3 string) ([]pgtypes.Record, error)

+ func TsRank(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsquery, v2 []float32, ...) (float32, error)

+ func TsRankCd(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsquery, v2 []float32, ...) (float32, error)

+ func TsRewrite(db XODB, v0 pgtypes.Tsquery, v1 string, v2 pgtypes.Tsquery, v3 pgtypes.Tsquery, ...) (pgtypes.Tsquery, error)

+ func TsStat(db XODB, v0 string, v1 string, v2 string) ([]pgtypes.Record, error)

+ func TsTokenType(db XODB, v0 string, v1 pgtypes.Oid) ([]pgtypes.Record, error)

+ func TsTypanalyze(db XODB, v0 pgtypes.Internal) (bool, error)

+ func TsmHandlerIn(db XODB, v0 pgtypes.Cstring) (pgtypes.TsmHandler, error)

+ func TsmHandlerOut(db XODB, v0 pgtypes.TsmHandler) (pgtypes.Cstring, error)

+ func Tsmatchjoinsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int16, ...) (float64, error)

+ func Tsmatchsel(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 pgtypes.Internal, v3 int) (float64, error)

+ func TsqMcontained(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqMcontains(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryAnd(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (pgtypes.Tsquery, error)

+ func TsqueryCmp(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (int, error)

+ func TsqueryEq(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryGe(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryGt(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryLe(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryLt(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryNe(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (bool, error)

+ func TsqueryNot(db XODB, v0 pgtypes.Tsquery) (pgtypes.Tsquery, error)

+ func TsqueryOr(db XODB, v0 pgtypes.Tsquery, v1 pgtypes.Tsquery) (pgtypes.Tsquery, error)

+ func Tsqueryin(db XODB, v0 pgtypes.Cstring) (pgtypes.Tsquery, error)

+ func Tsqueryout(db XODB, v0 pgtypes.Tsquery) (pgtypes.Cstring, error)

+ func Tsqueryrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Tsquery, error)

+ func Tsquerysend(db XODB, v0 pgtypes.Tsquery) ([]byte, error)

+ func Tsrange(db XODB, v0 time.Time, v1 time.Time, v2 time.Time, v3 time.Time, v4 string) (pgtypes.Tsrange, error)

+ func TsrangeSubdiff(db XODB, v0 time.Time, v1 time.Time) (float64, error)

+ func Tstzrange(db XODB, v0 time.Time, v1 time.Time, v2 time.Time, v3 time.Time, v4 string) (pgtypes.Tstzrange, error)

+ func TstzrangeSubdiff(db XODB, v0 time.Time, v1 time.Time) (float64, error)

+ func TsvectorCmp(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (int, error)

+ func TsvectorConcat(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (pgtypes.Tsvector, error)

+ func TsvectorEq(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func TsvectorGe(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func TsvectorGt(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func TsvectorLe(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func TsvectorLt(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func TsvectorNe(db XODB, v0 pgtypes.Tsvector, v1 pgtypes.Tsvector) (bool, error)

+ func Tsvectorin(db XODB, v0 pgtypes.Cstring) (pgtypes.Tsvector, error)

+ func Tsvectorout(db XODB, v0 pgtypes.Tsvector) (pgtypes.Cstring, error)

+ func Tsvectorrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Tsvector, error)

+ func Tsvectorsend(db XODB, v0 pgtypes.Tsvector) ([]byte, error)

+ func TxidCurrent(db XODB) (int64, error)

+ func TxidCurrentSnapshot(db XODB) (pgtypes.TxidSnapshot, error)

+ func TxidSnapshotIn(db XODB, v0 pgtypes.Cstring) (pgtypes.TxidSnapshot, error)

+ func TxidSnapshotOut(db XODB, v0 pgtypes.TxidSnapshot) (pgtypes.Cstring, error)

+ func TxidSnapshotRecv(db XODB, v0 pgtypes.Internal) (pgtypes.TxidSnapshot, error)

+ func TxidSnapshotSend(db XODB, v0 pgtypes.TxidSnapshot) ([]byte, error)

+ func TxidSnapshotXip(db XODB, v0 pgtypes.TxidSnapshot) ([]int64, error)

+ func TxidSnapshotXmax(db XODB, v0 pgtypes.TxidSnapshot) (int64, error)

+ func TxidSnapshotXmin(db XODB, v0 pgtypes.TxidSnapshot) (int64, error)

+ func TxidVisibleInSnapshot(db XODB, v0 int64, v1 pgtypes.TxidSnapshot) (bool, error)

+ func UTF8ToASCII(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToBig5(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToEucCn(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToEucJis2004(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToEucJp(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToEucKr(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToEucTw(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToGb18030(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToGbk(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToIso8859(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToIso88591(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToJohab(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToKoi8r(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToKoi8u(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToShiftJis2004(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToSjis(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToUhc(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UTF8ToWin(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func UUIDCmp(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (int, error)

+ func UUIDEq(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDGe(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDGt(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDHash(db XODB, v0 pgtypes.UUID) (int, error)

+ func UUIDIn(db XODB, v0 pgtypes.Cstring) (pgtypes.UUID, error)

+ func UUIDLe(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDLt(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDNe(db XODB, v0 pgtypes.UUID, v1 pgtypes.UUID) (bool, error)

+ func UUIDOut(db XODB, v0 pgtypes.UUID) (pgtypes.Cstring, error)

+ func UUIDRecv(db XODB, v0 pgtypes.Internal) (pgtypes.UUID, error)

+ func UUIDSend(db XODB, v0 pgtypes.UUID) ([]byte, error)

+ func UhcToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Unknownin(db XODB, v0 pgtypes.Cstring) (pgtypes.Unknown, error)

+ func Unknownout(db XODB, v0 pgtypes.Unknown) (pgtypes.Cstring, error)

+ func Unknownrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Unknown, error)

+ func Unknownsend(db XODB, v0 pgtypes.Unknown) ([]byte, error)

+ func Unnest(db XODB, v0 pgtypes.Anyarray) ([]pgtypes.Anyelement, error)

+ func Upper(db XODB, v0 string, v1 pgtypes.Anyrange) (pgtypes.Anyelement, error)

+ func UpperInc(db XODB, v0 pgtypes.Anyrange) (bool, error)

+ func UpperInf(db XODB, v0 pgtypes.Anyrange) (bool, error)

+ func VarPop(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func VarSamp(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func Varbit(db XODB, v0 []byte, v1 int, v2 bool) ([]byte, error)

+ func VarbitIn(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) ([]byte, error)

+ func VarbitOut(db XODB, v0 []byte) (pgtypes.Cstring, error)

+ func VarbitRecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) ([]byte, error)

+ func VarbitSend(db XODB, v0 []byte) ([]byte, error)

+ func VarbitTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func Varbitcmp(db XODB, v0 []byte, v1 []byte) (int, error)

+ func Varbiteq(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbitge(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbitgt(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbitle(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbitlt(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbitne(db XODB, v0 []byte, v1 []byte) (bool, error)

+ func Varbittypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Varbittypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Varchar(db XODB, v0 pgtypes.Name, v1 string, v2 int, v3 bool) (string, error)

+ func VarcharTransform(db XODB, v0 pgtypes.Internal) (pgtypes.Internal, error)

+ func Varcharin(db XODB, v0 pgtypes.Cstring, v1 pgtypes.Oid, v2 int) (string, error)

+ func Varcharout(db XODB, v0 string) (pgtypes.Cstring, error)

+ func Varcharrecv(db XODB, v0 pgtypes.Internal, v1 pgtypes.Oid, v2 int) (string, error)

+ func Varcharsend(db XODB, v0 string) ([]byte, error)

+ func Varchartypmodin(db XODB, v0 []pgtypes.Cstring) (int, error)

+ func Varchartypmodout(db XODB, v0 int) (pgtypes.Cstring, error)

+ func Variance(db XODB, v0 int64, v1 int16, v2 int, v3 float32, v4 float64, v5 float64) (float64, error)

+ func Version(db XODB) (string, error)

+ func VoidIn(db XODB, v0 pgtypes.Cstring) error

+ func VoidOut(db XODB, v0 pgtypes.Void) (pgtypes.Cstring, error)

+ func VoidRecv(db XODB, v0 pgtypes.Internal) error

+ func VoidSend(db XODB, v0 pgtypes.Void) ([]byte, error)

+ func Width(db XODB, v0 pgtypes.Box) (float64, error)

+ func WidthBucket(db XODB, v0 pgtypes.Anyelement, v1 pgtypes.Anyarray, v2 float64, v3 float64, ...) (int, error)

+ func Win1250ToLatin2(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win1250ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win1251ToIso(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win1251ToKoi8r(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win1251ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win1251ToWin866(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win866ToIso(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win866ToKoi8r(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win866ToMic(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func Win866ToWin1251(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func WinToUTF8(db XODB, v0 int, v1 int, v2 pgtypes.Cstring, v3 pgtypes.Internal, v4 int) error

+ func XML(db XODB, v0 string) (pgtypes.XML, error)

+ func XMLIn(db XODB, v0 pgtypes.Cstring) (pgtypes.XML, error)

+ func XMLIsWellFormed(db XODB, v0 string) (bool, error)

+ func XMLIsWellFormedContent(db XODB, v0 string) (bool, error)

+ func XMLIsWellFormedDocument(db XODB, v0 string) (bool, error)

+ func XMLOut(db XODB, v0 pgtypes.XML) (pgtypes.Cstring, error)

+ func XMLRecv(db XODB, v0 pgtypes.Internal) (pgtypes.XML, error)

+ func XMLSend(db XODB, v0 pgtypes.XML) ([]byte, error)

+ func Xideq(db XODB, v0 pgtypes.Xid, v1 pgtypes.Xid) (bool, error)

+ func Xideqint4(db XODB, v0 pgtypes.Xid, v1 int) (bool, error)

+ func Xidin(db XODB, v0 pgtypes.Cstring) (pgtypes.Xid, error)

+ func Xidout(db XODB, v0 pgtypes.Xid) (pgtypes.Cstring, error)

+ func Xidrecv(db XODB, v0 pgtypes.Internal) (pgtypes.Xid, error)

+ func Xidsend(db XODB, v0 pgtypes.Xid) ([]byte, error)

+ func Xmlagg(db XODB, v0 pgtypes.XML) (pgtypes.XML, error)

+ func Xmlcomment(db XODB, v0 string) (pgtypes.XML, error)

+ func Xmlconcat2(db XODB, v0 pgtypes.XML, v1 pgtypes.XML) (pgtypes.XML, error)

+ func Xmlexists(db XODB, v0 string, v1 pgtypes.XML) (bool, error)

+ func Xmlvalidate(db XODB, v0 pgtypes.XML, v1 string) (bool, error)

+ func Xpath(db XODB, v0 string, v1 pgtypes.XML, v2 string, v3 pgtypes.XML, v4 StringSlice) ([]pgtypes.XML, error)

+ func XpathExists(db XODB, v0 string, v1 pgtypes.XML, v2 string, v3 pgtypes.XML, v4 StringSlice) (bool, error)

+ type PgAggregate struct

+ Aggfinalextra bool

+ Aggfinalfn pgtypes.Regproc

+ Aggfnoid pgtypes.Regproc

+ Agginitval sql.NullString

+ Aggkind uint8

+ Aggmfinalextra bool

+ Aggmfinalfn pgtypes.Regproc

+ Aggminitval sql.NullString

+ Aggminvtransfn pgtypes.Regproc

+ Aggmtransfn pgtypes.Regproc

+ Aggmtransspace int

+ Aggmtranstype pgtypes.Oid

+ Aggnumdirectargs int16

+ Aggsortop pgtypes.Oid

+ Aggtransfn pgtypes.Regproc

+ Aggtransspace int

+ Aggtranstype pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAggregateByAggfnoid(db XODB, aggfnoid pgtypes.Regproc) (*PgAggregate, error)

+ type PgAm struct

+ Ambeginscan pgtypes.Regproc

+ Ambuild pgtypes.Regproc

+ Ambuildempty pgtypes.Regproc

+ Ambulkdelete pgtypes.Regproc

+ Amcanbackward bool

+ Amcanmulticol bool

+ Amcanorder bool

+ Amcanorderbyop bool

+ Amcanreturn pgtypes.Regproc

+ Amcanunique bool

+ Amclusterable bool

+ Amcostestimate pgtypes.Regproc

+ Amendscan pgtypes.Regproc

+ Amgetbitmap pgtypes.Regproc

+ Amgettuple pgtypes.Regproc

+ Aminsert pgtypes.Regproc

+ Amkeytype pgtypes.Oid

+ Ammarkpos pgtypes.Regproc

+ Amname pgtypes.Name

+ Amoptionalkey bool

+ Amoptions pgtypes.Regproc

+ Ampredlocks bool

+ Amrescan pgtypes.Regproc

+ Amrestrpos pgtypes.Regproc

+ Amsearcharray bool

+ Amsearchnulls bool

+ Amstorage bool

+ Amstrategies int16

+ Amsupport int16

+ Amvacuumcleanup pgtypes.Regproc

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAmByAmname(db XODB, amname pgtypes.Name) (*PgAm, error)

+ func PgAmByOid(db XODB, oid pgtypes.Oid) (*PgAm, error)

+ type PgAmop struct

+ Amopfamily pgtypes.Oid

+ Amoplefttype pgtypes.Oid

+ Amopmethod pgtypes.Oid

+ Amopopr pgtypes.Oid

+ Amoppurpose uint8

+ Amoprighttype pgtypes.Oid

+ Amopsortfamily pgtypes.Oid

+ Amopstrategy int16

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(db XODB, amopfamily pgtypes.Oid, amoplefttype pgtypes.Oid, ...) (*PgAmop, error)

+ func PgAmopByAmopoprAmoppurposeAmopfamily(db XODB, amopopr pgtypes.Oid, amoppurpose uint8, amopfamily pgtypes.Oid) (*PgAmop, error)

+ func PgAmopByOid(db XODB, oid pgtypes.Oid) (*PgAmop, error)

+ type PgAmproc struct

+ Amproc pgtypes.Regproc

+ Amprocfamily pgtypes.Oid

+ Amproclefttype pgtypes.Oid

+ Amprocnum int16

+ Amprocrighttype pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(db XODB, amprocfamily pgtypes.Oid, amproclefttype pgtypes.Oid, ...) (*PgAmproc, error)

+ func PgAmprocByOid(db XODB, oid pgtypes.Oid) (*PgAmproc, error)

+ type PgAttrdef struct

+ Adbin pgtypes.PgNodeTree

+ Adnum int16

+ Adrelid pgtypes.Oid

+ Adsrc sql.NullString

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAttrdefByAdrelidAdnum(db XODB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error)

+ func PgAttrdefByOid(db XODB, oid pgtypes.Oid) (*PgAttrdef, error)

+ type PgAttribute struct

+ Attacl []pgtypes.Aclitem

+ Attalign uint8

+ Attbyval bool

+ Attcacheoff int

+ Attcollation pgtypes.Oid

+ Attfdwoptions []sql.NullString

+ Atthasdef bool

+ Attinhcount int

+ Attisdropped bool

+ Attislocal bool

+ Attlen int16

+ Attname pgtypes.Name

+ Attndims int

+ Attnotnull bool

+ Attnum int16

+ Attoptions []sql.NullString

+ Attrelid pgtypes.Oid

+ Attstattarget int

+ Attstorage uint8

+ Atttypid pgtypes.Oid

+ Atttypmod int

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAttributeByAttrelidAttname(db XODB, attrelid pgtypes.Oid, attname pgtypes.Name) (*PgAttribute, error)

+ func PgAttributeByAttrelidAttnum(db XODB, attrelid pgtypes.Oid, attnum int16) (*PgAttribute, error)

+ type PgAuthMember struct

+ AdminOption bool

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Grantor pgtypes.Oid

+ Member pgtypes.Oid

+ Roleid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAuthMemberByMemberRoleid(db XODB, member pgtypes.Oid, roleid pgtypes.Oid) (*PgAuthMember, error)

+ func PgAuthMemberByRoleidMember(db XODB, roleid pgtypes.Oid, member pgtypes.Oid) (*PgAuthMember, error)

+ type PgAuthid struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Rolbypassrls bool

+ Rolcanlogin bool

+ Rolconnlimit int

+ Rolcreatedb bool

+ Rolcreaterole bool

+ Rolinherit bool

+ Rolname pgtypes.Name

+ Rolpassword sql.NullString

+ Rolreplication bool

+ Rolsuper bool

+ Rolvaliduntil pq.NullTime

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgAuthidByOid(db XODB, oid pgtypes.Oid) (*PgAuthid, error)

+ func PgAuthidByRolname(db XODB, rolname pgtypes.Name) (*PgAuthid, error)

+ type PgCast struct

+ Castcontext uint8

+ Castfunc pgtypes.Oid

+ Castmethod uint8

+ Castsource pgtypes.Oid

+ Casttarget pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgCastByCastsourceCasttarget(db XODB, castsource pgtypes.Oid, casttarget pgtypes.Oid) (*PgCast, error)

+ func PgCastByOid(db XODB, oid pgtypes.Oid) (*PgCast, error)

+ type PgClass struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Relacl []pgtypes.Aclitem

+ Relallvisible int

+ Relam pgtypes.Oid

+ Relchecks int16

+ Relfilenode pgtypes.Oid

+ Relforcerowsecurity bool

+ Relfrozenxid pgtypes.Xid

+ Relhasindex bool

+ Relhasoids bool

+ Relhaspkey bool

+ Relhasrules bool

+ Relhassubclass bool

+ Relhastriggers bool

+ Relispopulated bool

+ Relisshared bool

+ Relkind uint8

+ Relminmxid pgtypes.Xid

+ Relname pgtypes.Name

+ Relnamespace pgtypes.Oid

+ Relnatts int16

+ Reloftype pgtypes.Oid

+ Reloptions []sql.NullString

+ Relowner pgtypes.Oid

+ Relpages int

+ Relpersistence uint8

+ Relreplident uint8

+ Relrowsecurity bool

+ Reltablespace pgtypes.Oid

+ Reltoastrelid pgtypes.Oid

+ Reltuples float32

+ Reltype pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgClassByOid(db XODB, oid pgtypes.Oid) (*PgClass, error)

+ func PgClassByRelnameRelnamespace(db XODB, relname pgtypes.Name, relnamespace pgtypes.Oid) (*PgClass, error)

+ func PgClassesByReltablespaceRelfilenode(db XODB, reltablespace pgtypes.Oid, relfilenode pgtypes.Oid) ([]*PgClass, error)

+ type PgCollation struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Collcollate pgtypes.Name

+ Collctype pgtypes.Name

+ Collencoding int

+ Collname pgtypes.Name

+ Collnamespace pgtypes.Oid

+ Collowner pgtypes.Oid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgCollationByCollnameCollencodingCollnamespace(db XODB, collname pgtypes.Name, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error)

+ func PgCollationByOid(db XODB, oid pgtypes.Oid) (*PgCollation, error)

+ type PgConstraint struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Conbin pgtypes.PgNodeTree

+ Condeferrable bool

+ Condeferred bool

+ Conexclop []pgtypes.Oid

+ Confdeltype uint8

+ Conffeqop []pgtypes.Oid

+ Confkey []sql.NullInt64

+ Confmatchtype uint8

+ Confrelid pgtypes.Oid

+ Confupdtype uint8

+ Conindid pgtypes.Oid

+ Coninhcount int

+ Conislocal bool

+ Conkey []sql.NullInt64

+ Conname pgtypes.Name

+ Connamespace pgtypes.Oid

+ Connoinherit bool

+ Conpfeqop []pgtypes.Oid

+ Conppeqop []pgtypes.Oid

+ Conrelid pgtypes.Oid

+ Consrc sql.NullString

+ Contype uint8

+ Contypid pgtypes.Oid

+ Convalidated bool

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgConstraintByOid(db XODB, oid pgtypes.Oid) (*PgConstraint, error)

+ func PgConstraintsByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) ([]*PgConstraint, error)

+ func PgConstraintsByConrelid(db XODB, conrelid pgtypes.Oid) ([]*PgConstraint, error)

+ func PgConstraintsByContypid(db XODB, contypid pgtypes.Oid) ([]*PgConstraint, error)

+ type PgConversion struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Condefault bool

+ Conforencoding int

+ Conname pgtypes.Name

+ Connamespace pgtypes.Oid

+ Conowner pgtypes.Oid

+ Conproc pgtypes.Regproc

+ Contoencoding int

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgConversionByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) (*PgConversion, error)

+ func PgConversionByConnamespaceConforencodingContoencodingOid(db XODB, connamespace pgtypes.Oid, conforencoding int, contoencoding int, ...) (*PgConversion, error)

+ func PgConversionByOid(db XODB, oid pgtypes.Oid) (*PgConversion, error)

+ type PgDatabase struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Datacl []pgtypes.Aclitem

+ Datallowconn bool

+ Datcollate pgtypes.Name

+ Datconnlimit int

+ Datctype pgtypes.Name

+ Datdba pgtypes.Oid

+ Datfrozenxid pgtypes.Xid

+ Datistemplate bool

+ Datlastsysoid pgtypes.Oid

+ Datminmxid pgtypes.Xid

+ Datname pgtypes.Name

+ Dattablespace pgtypes.Oid

+ Encoding int

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgDatabaseByDatname(db XODB, datname pgtypes.Name) (*PgDatabase, error)

+ func PgDatabaseByOid(db XODB, oid pgtypes.Oid) (*PgDatabase, error)

+ type PgDbRoleSetting struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Setconfig []sql.NullString

+ Setdatabase pgtypes.Oid

+ Setrole pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgDbRoleSettingBySetdatabaseSetrole(db XODB, setdatabase pgtypes.Oid, setrole pgtypes.Oid) (*PgDbRoleSetting, error)

+ type PgDefaultACL struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Defaclacl []pgtypes.Aclitem

+ Defaclnamespace pgtypes.Oid

+ Defaclobjtype uint8

+ Defaclrole pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(db XODB, defaclrole pgtypes.Oid, defaclnamespace pgtypes.Oid, ...) (*PgDefaultACL, error)

+ func PgDefaultACLByOid(db XODB, oid pgtypes.Oid) (*PgDefaultACL, error)

+ type PgDepend struct

+ Classid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Deptype uint8

+ Objid pgtypes.Oid

+ Objsubid int

+ Refclassid pgtypes.Oid

+ Refobjid pgtypes.Oid

+ Refobjsubid int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error)

+ func PgDependsByRefclassidRefobjidRefobjsubid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid, refobjsubid int) ([]*PgDepend, error)

+ type PgDescription struct

+ Classoid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Description string

+ Objoid pgtypes.Oid

+ Objsubid int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error)

+ type PgEnum struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Enumlabel pgtypes.Name

+ Enumsortorder float32

+ Enumtypid pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error)

+ func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error)

+ func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error)

+ type PgEventTrigger struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Evtenabled uint8

+ Evtevent pgtypes.Name

+ Evtfoid pgtypes.Oid

+ Evtname pgtypes.Name

+ Evtowner pgtypes.Oid

+ Evttags []sql.NullString

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error)

+ func PgEventTriggerByOid(db XODB, oid pgtypes.Oid) (*PgEventTrigger, error)

+ type PgExtension struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Extcondition []sql.NullString

+ Extconfig []pgtypes.Oid

+ Extname pgtypes.Name

+ Extnamespace pgtypes.Oid

+ Extowner pgtypes.Oid

+ Extrelocatable bool

+ Extversion string

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error)

+ func PgExtensionByOid(db XODB, oid pgtypes.Oid) (*PgExtension, error)

+ type PgForeignDataWrapper struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Fdwacl []pgtypes.Aclitem

+ Fdwhandler pgtypes.Oid

+ Fdwname pgtypes.Name

+ Fdwoptions []sql.NullString

+ Fdwowner pgtypes.Oid

+ Fdwvalidator pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgForeignDataWrapperByFdwname(db XODB, fdwname pgtypes.Name) (*PgForeignDataWrapper, error)

+ func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error)

+ type PgForeignServer struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Srvacl []pgtypes.Aclitem

+ Srvfdw pgtypes.Oid

+ Srvname pgtypes.Name

+ Srvoptions []sql.NullString

+ Srvowner pgtypes.Oid

+ Srvtype sql.NullString

+ Srvversion sql.NullString

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgForeignServerByOid(db XODB, oid pgtypes.Oid) (*PgForeignServer, error)

+ func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error)

+ type PgForeignTable struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Ftoptions []sql.NullString

+ Ftrelid pgtypes.Oid

+ Ftserver pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error)

+ type PgIndex struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Indcheckxmin bool

+ Indclass pgtypes.Oidvector

+ Indcollation pgtypes.Oidvector

+ Indexprs pgtypes.PgNodeTree

+ Indexrelid pgtypes.Oid

+ Indimmediate bool

+ Indisclustered bool

+ Indisexclusion bool

+ Indislive bool

+ Indisprimary bool

+ Indisready bool

+ Indisreplident bool

+ Indisunique bool

+ Indisvalid bool

+ Indkey pgtypes.Int2vector

+ Indnatts int16

+ Indoption pgtypes.Int2vector

+ Indpred pgtypes.PgNodeTree

+ Indrelid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error)

+ func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error)

+ type PgInherit struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Inhparent pgtypes.Oid

+ Inhrelid pgtypes.Oid

+ Inhseqno int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error)

+ func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error)

+ type PgLanguage struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Lanacl []pgtypes.Aclitem

+ Laninline pgtypes.Oid

+ Lanispl bool

+ Lanname pgtypes.Name

+ Lanowner pgtypes.Oid

+ Lanplcallfoid pgtypes.Oid

+ Lanpltrusted bool

+ Lanvalidator pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error)

+ func PgLanguageByOid(db XODB, oid pgtypes.Oid) (*PgLanguage, error)

+ type PgLargeobject struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Data []byte

+ Loid pgtypes.Oid

+ Pageno int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error)

+ type PgLargeobjectMetadatum struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Lomacl []pgtypes.Aclitem

+ Lomowner pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error)

+ type PgNamespace struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Nspacl []pgtypes.Aclitem

+ Nspname pgtypes.Name

+ Nspowner pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error)

+ func PgNamespaceByOid(db XODB, oid pgtypes.Oid) (*PgNamespace, error)

+ type PgOpclass struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Opcdefault bool

+ Opcfamily pgtypes.Oid

+ Opcintype pgtypes.Oid

+ Opckeytype pgtypes.Oid

+ Opcmethod pgtypes.Oid

+ Opcname pgtypes.Name

+ Opcnamespace pgtypes.Oid

+ Opcowner pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error)

+ func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error)

+ type PgOperator struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Oprcanhash bool

+ Oprcanmerge bool

+ Oprcode pgtypes.Regproc

+ Oprcom pgtypes.Oid

+ Oprjoin pgtypes.Regproc

+ Oprkind uint8

+ Oprleft pgtypes.Oid

+ Oprname pgtypes.Name

+ Oprnamespace pgtypes.Oid

+ Oprnegate pgtypes.Oid

+ Oprowner pgtypes.Oid

+ Oprrest pgtypes.Regproc

+ Oprresult pgtypes.Oid

+ Oprright pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error)

+ func PgOperatorByOprnameOprleftOprrightOprnamespace(db XODB, oprname pgtypes.Name, oprleft pgtypes.Oid, oprright pgtypes.Oid, ...) (*PgOperator, error)

+ type PgOpfamily struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Opfmethod pgtypes.Oid

+ Opfname pgtypes.Name

+ Opfnamespace pgtypes.Oid

+ Opfowner pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgOpfamilyByOid(db XODB, oid pgtypes.Oid) (*PgOpfamily, error)

+ func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error)

+ type PgPltemplate struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Tableoid pgtypes.Oid

+ Tmplacl []pgtypes.Aclitem

+ Tmpldbacreate bool

+ Tmplhandler string

+ Tmplinline sql.NullString

+ Tmpllibrary string

+ Tmplname pgtypes.Name

+ Tmpltrusted bool

+ Tmplvalidator sql.NullString

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgPltemplateByTmplname(db XODB, tmplname pgtypes.Name) (*PgPltemplate, error)

+ type PgPolicy struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Polcmd uint8

+ Polname pgtypes.Name

+ Polqual pgtypes.PgNodeTree

+ Polrelid pgtypes.Oid

+ Polroles []pgtypes.Oid

+ Polwithcheck pgtypes.PgNodeTree

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgPolicyByOid(db XODB, oid pgtypes.Oid) (*PgPolicy, error)

+ func PgPolicyByPolrelidPolname(db XODB, polrelid pgtypes.Oid, polname pgtypes.Name) (*PgPolicy, error)

+ type PgProc struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Proacl []pgtypes.Aclitem

+ Proallargtypes []pgtypes.Oid

+ Proargdefaults pgtypes.PgNodeTree

+ Proargmodes []uint8

+ Proargnames []sql.NullString

+ Proargtypes pgtypes.Oidvector

+ Probin sql.NullString

+ Proconfig []sql.NullString

+ Procost float32

+ Proisagg bool

+ Proisstrict bool

+ Proiswindow bool

+ Prolang pgtypes.Oid

+ Proleakproof bool

+ Proname pgtypes.Name

+ Pronamespace pgtypes.Oid

+ Pronargdefaults int16

+ Pronargs int16

+ Proowner pgtypes.Oid

+ Proretset bool

+ Prorettype pgtypes.Oid

+ Prorows float32

+ Prosecdef bool

+ Prosrc string

+ Protransform pgtypes.Regproc

+ Protrftypes []pgtypes.Oid

+ Provariadic pgtypes.Oid

+ Provolatile uint8

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgProcByOid(db XODB, oid pgtypes.Oid) (*PgProc, error)

+ func PgProcByPronameProargtypesPronamespace(db XODB, proname pgtypes.Name, proargtypes pgtypes.Oidvector, ...) (*PgProc, error)

+ type PgRange struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Rngcanonical pgtypes.Regproc

+ Rngcollation pgtypes.Oid

+ Rngsubdiff pgtypes.Regproc

+ Rngsubopc pgtypes.Oid

+ Rngsubtype pgtypes.Oid

+ Rngtypid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgRangeByRngtypid(db XODB, rngtypid pgtypes.Oid) (*PgRange, error)

+ type PgReplicationOrigin struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Roident pgtypes.Oid

+ Roname string

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgReplicationOriginByRoident(db XODB, roident pgtypes.Oid) (*PgReplicationOrigin, error)

+ func PgReplicationOriginByRoname(db XODB, roname string) (*PgReplicationOrigin, error)

+ type PgRewrite struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ EvAction pgtypes.PgNodeTree

+ EvClass pgtypes.Oid

+ EvEnabled uint8

+ EvQual pgtypes.PgNodeTree

+ EvType uint8

+ IsInstead bool

+ Oid pgtypes.Oid

+ Rulename pgtypes.Name

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgRewriteByEvClassRulename(db XODB, evClass pgtypes.Oid, rulename pgtypes.Name) (*PgRewrite, error)

+ func PgRewriteByOid(db XODB, oid pgtypes.Oid) (*PgRewrite, error)

+ type PgSeclabel struct

+ Classoid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Label string

+ Objoid pgtypes.Oid

+ Objsubid int

+ Provider string

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgSeclabelByObjoidClassoidObjsubidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int, ...) (*PgSeclabel, error)

+ type PgShdepend struct

+ Classid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Dbid pgtypes.Oid

+ Deptype uint8

+ Objid pgtypes.Oid

+ Objsubid int

+ Refclassid pgtypes.Oid

+ Refobjid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgShdependsByDbidClassidObjidObjsubid(db XODB, dbid pgtypes.Oid, classid pgtypes.Oid, objid pgtypes.Oid, ...) ([]*PgShdepend, error)

+ func PgShdependsByRefclassidRefobjid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid) ([]*PgShdepend, error)

+ type PgShdescription struct

+ Classoid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Description string

+ Objoid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgShdescriptionByObjoidClassoid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid) (*PgShdescription, error)

+ type PgShseclabel struct

+ Classoid pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Label string

+ Objoid pgtypes.Oid

+ Provider string

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgShseclabelByObjoidClassoidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error)

+ type PgStatistic struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Staattnum int16

+ Stadistinct float32

+ Stainherit bool

+ Stakind1 int16

+ Stakind2 int16

+ Stakind3 int16

+ Stakind4 int16

+ Stakind5 int16

+ Stanullfrac float32

+ Stanumbers1 []sql.NullFloat64

+ Stanumbers2 []sql.NullFloat64

+ Stanumbers3 []sql.NullFloat64

+ Stanumbers4 []sql.NullFloat64

+ Stanumbers5 []sql.NullFloat64

+ Staop1 pgtypes.Oid

+ Staop2 pgtypes.Oid

+ Staop3 pgtypes.Oid

+ Staop4 pgtypes.Oid

+ Staop5 pgtypes.Oid

+ Starelid pgtypes.Oid

+ Stavalues1 pgtypes.Anyarray

+ Stavalues2 pgtypes.Anyarray

+ Stavalues3 pgtypes.Anyarray

+ Stavalues4 pgtypes.Anyarray

+ Stavalues5 pgtypes.Anyarray

+ Stawidth int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgStatisticByStarelidStaattnumStainherit(db XODB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error)

+ type PgTablespace struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Spcacl []pgtypes.Aclitem

+ Spcname pgtypes.Name

+ Spcoptions []sql.NullString

+ Spcowner pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTablespaceByOid(db XODB, oid pgtypes.Oid) (*PgTablespace, error)

+ func PgTablespaceBySpcname(db XODB, spcname pgtypes.Name) (*PgTablespace, error)

+ type PgTransform struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Trffromsql pgtypes.Regproc

+ Trflang pgtypes.Oid

+ Trftosql pgtypes.Regproc

+ Trftype pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTransformByOid(db XODB, oid pgtypes.Oid) (*PgTransform, error)

+ func PgTransformByTrftypeTrflang(db XODB, trftype pgtypes.Oid, trflang pgtypes.Oid) (*PgTransform, error)

+ type PgTrigger struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Tgargs []byte

+ Tgattr pgtypes.Int2vector

+ Tgconstraint pgtypes.Oid

+ Tgconstrindid pgtypes.Oid

+ Tgconstrrelid pgtypes.Oid

+ Tgdeferrable bool

+ Tgenabled uint8

+ Tgfoid pgtypes.Oid

+ Tginitdeferred bool

+ Tgisinternal bool

+ Tgname pgtypes.Name

+ Tgnargs int16

+ Tgqual pgtypes.PgNodeTree

+ Tgrelid pgtypes.Oid

+ Tgtype int16

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTriggerByOid(db XODB, oid pgtypes.Oid) (*PgTrigger, error)

+ func PgTriggerByTgrelidTgname(db XODB, tgrelid pgtypes.Oid, tgname pgtypes.Name) (*PgTrigger, error)

+ func PgTriggersByTgconstraint(db XODB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error)

+ type PgTsConfig struct

+ Cfgname pgtypes.Name

+ Cfgnamespace pgtypes.Oid

+ Cfgowner pgtypes.Oid

+ Cfgparser pgtypes.Oid

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTsConfigByCfgnameCfgnamespace(db XODB, cfgname pgtypes.Name, cfgnamespace pgtypes.Oid) (*PgTsConfig, error)

+ func PgTsConfigByOid(db XODB, oid pgtypes.Oid) (*PgTsConfig, error)

+ type PgTsConfigMap struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Mapcfg pgtypes.Oid

+ Mapdict pgtypes.Oid

+ Mapseqno int

+ Maptokentype int

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTsConfigMapByMapcfgMaptokentypeMapseqno(db XODB, mapcfg pgtypes.Oid, maptokentype int, mapseqno int) (*PgTsConfigMap, error)

+ type PgTsDict struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Dictinitoption sql.NullString

+ Dictname pgtypes.Name

+ Dictnamespace pgtypes.Oid

+ Dictowner pgtypes.Oid

+ Dicttemplate pgtypes.Oid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTsDictByDictnameDictnamespace(db XODB, dictname pgtypes.Name, dictnamespace pgtypes.Oid) (*PgTsDict, error)

+ func PgTsDictByOid(db XODB, oid pgtypes.Oid) (*PgTsDict, error)

+ type PgTsParser struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Prsend pgtypes.Regproc

+ Prsheadline pgtypes.Regproc

+ Prslextype pgtypes.Regproc

+ Prsname pgtypes.Name

+ Prsnamespace pgtypes.Oid

+ Prsstart pgtypes.Regproc

+ Prstoken pgtypes.Regproc

+ Tableoid pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTsParserByOid(db XODB, oid pgtypes.Oid) (*PgTsParser, error)

+ func PgTsParserByPrsnamePrsnamespace(db XODB, prsname pgtypes.Name, prsnamespace pgtypes.Oid) (*PgTsParser, error)

+ type PgTsTemplate struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Tmplinit pgtypes.Regproc

+ Tmpllexize pgtypes.Regproc

+ Tmplname pgtypes.Name

+ Tmplnamespace pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTsTemplateByOid(db XODB, oid pgtypes.Oid) (*PgTsTemplate, error)

+ func PgTsTemplateByTmplnameTmplnamespace(db XODB, tmplname pgtypes.Name, tmplnamespace pgtypes.Oid) (*PgTsTemplate, error)

+ type PgType struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Typacl []pgtypes.Aclitem

+ Typalign uint8

+ Typanalyze pgtypes.Regproc

+ Typarray pgtypes.Oid

+ Typbasetype pgtypes.Oid

+ Typbyval bool

+ Typcategory uint8

+ Typcollation pgtypes.Oid

+ Typdefault sql.NullString

+ Typdefaultbin pgtypes.PgNodeTree

+ Typdelim uint8

+ Typelem pgtypes.Oid

+ Typinput pgtypes.Regproc

+ Typisdefined bool

+ Typispreferred bool

+ Typlen int16

+ Typmodin pgtypes.Regproc

+ Typmodout pgtypes.Regproc

+ Typname pgtypes.Name

+ Typnamespace pgtypes.Oid

+ Typndims int

+ Typnotnull bool

+ Typoutput pgtypes.Regproc

+ Typowner pgtypes.Oid

+ Typreceive pgtypes.Regproc

+ Typrelid pgtypes.Oid

+ Typsend pgtypes.Regproc

+ Typstorage uint8

+ Typtype uint8

+ Typtypmod int

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgTypeByOid(db XODB, oid pgtypes.Oid) (*PgType, error)

+ func PgTypeByTypnameTypnamespace(db XODB, typname pgtypes.Name, typnamespace pgtypes.Oid) (*PgType, error)

+ type PgUserMapping struct

+ Cmax pgtypes.Cid

+ Cmin pgtypes.Cid

+ Ctid pgtypes.Tid

+ Oid pgtypes.Oid

+ Tableoid pgtypes.Oid

+ Umoptions []sql.NullString

+ Umserver pgtypes.Oid

+ Umuser pgtypes.Oid

+ Xmax pgtypes.Xid

+ Xmin pgtypes.Xid

+ func PgUserMappingByOid(db XODB, oid pgtypes.Oid) (*PgUserMapping, error)

+ func PgUserMappingByUmuserUmserver(db XODB, umuser pgtypes.Oid, umserver pgtypes.Oid) (*PgUserMapping, error)

+ type ScannerValuer interface

+ type Slice []ScannerValuer

+ type StringSlice []string

+ func RegexpMatches(db XODB, v0 string, v1 string, v2 string, v3 string, v4 string) ([]StringSlice, error)

+ func RegexpSplitToArray(db XODB, v0 string, v1 string, v2 string, v3 string, v4 string) (StringSlice, error)

+ func StringToArray(db XODB, v0 string, v1 string, v2 string, v3 string, v4 string) (StringSlice, error)

+ func TsLexize(db XODB, v0 pgtypes.Regdictionary, v1 string) (StringSlice, error)

+ func (ss *StringSlice) Scan(src interface{}) error

+ func (ss StringSlice) Value() (driver.Value, error)

+ type XODB interface

+ Exec func(string, ...interface{}) (sql.Result, error)

+ Query func(string, ...interface{}) (*sql.Rows, error)

+ QueryRow func(string, ...interface{}) *sql.Row