/_examples/pgcatalog/pgcatalog/pgcatalog.xo.go

// Package pgcatalog contains generated code for schema 'pg_catalog'.
package pgcatalog

// Code generated by xo. DO NOT EDIT.

import (
	"context"
	"database/sql"
	"database/sql/driver"
	"encoding/csv"
	"fmt"
	"io"
	"regexp"
	"strings"
	"time"

	"github.com/xo/xo/_examples/pgcatalog/pgtypes"

	"github.com/google/uuid"
)

var (
	// logf is used by generated code to log SQL queries.
	logf = func(string, ...interface{}) {}
	// errf is used by generated code to log SQL errors.
	errf = func(string, ...interface{}) {}
)

// logerror logs the error and returns it.
func logerror(err error) error {
	errf("ERROR: %v", err)
	return err
}

// Logf logs a message using the package logger.
func Logf(s string, v ...interface{}) {
	logf(s, v...)
}

// SetLogger sets the package logger. Valid logger types:
//
//     io.Writer
//     func(string, ...interface{}) (int, error) // fmt.Printf
//     func(string, ...interface{}) // log.Printf
//
func SetLogger(logger interface{}) {
	logf = convLogger(logger)
}

// Errorf logs an error message using the package error logger.
func Errorf(s string, v ...interface{}) {
	errf(s, v...)
}

// SetErrorLogger sets the package error logger. Valid logger types:
//
//     io.Writer
//     func(string, ...interface{}) (int, error) // fmt.Printf
//     func(string, ...interface{}) // log.Printf
//
func SetErrorLogger(logger interface{}) {
	errf = convLogger(logger)
}

// convLogger converts logger to the standard logger interface.
func convLogger(logger interface{}) func(string, ...interface{}) {
	switch z := logger.(type) {
	case io.Writer:
		return func(s string, v ...interface{}) {
			fmt.Fprintf(z, s, v...)
		}
	case func(string, ...interface{}) (int, error): // fmt.Printf
		return func(s string, v ...interface{}) {
			_, _ = z(s, v...)
		}
	case func(string, ...interface{}): // log.Printf
		return z
	}
	panic(fmt.Sprintf("unsupported logger type %T", logger))
}

// DB is the common interface for database operations that can be used with
// types from schema 'pg_catalog'.
//
// This works with both database/sql.DB and database/sql.Tx.
type DB interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

// Error is an error.
type Error string

// Error satisfies the error interface.
func (err Error) Error() string {
	return string(err)
}

// Error values.
const (
	// ErrAlreadyExists is the already exists error.
	ErrAlreadyExists Error = "already exists"
	// ErrDoesNotExist is the does not exist error.
	ErrDoesNotExist Error = "does not exist"
	// ErrMarkedForDeletion is the marked for deletion error.
	ErrMarkedForDeletion Error = "marked for deletion"
)

// ErrInsertFailed is the insert failed error.
type ErrInsertFailed struct {
	Err error
}

// Error satisfies the error interface.
func (err *ErrInsertFailed) Error() string {
	return fmt.Sprintf("insert failed: %v", err.Err)
}

// Unwrap satisfies the unwrap interface.
func (err *ErrInsertFailed) Unwrap() error {
	return err.Err
}

// ErrUpdateFailed is the update failed error.
type ErrUpdateFailed struct {
	Err error
}

// Error satisfies the error interface.
func (err *ErrUpdateFailed) Error() string {
	return fmt.Sprintf("update failed: %v", err.Err)
}

// Unwrap satisfies the unwrap interface.
func (err *ErrUpdateFailed) Unwrap() error {
	return err.Err
}

// ErrUpsertFailed is the upsert failed error.
type ErrUpsertFailed struct {
	Err error
}

// Error satisfies the error interface.
func (err *ErrUpsertFailed) Error() string {
	return fmt.Sprintf("upsert failed: %v", err.Err)
}

// Unwrap satisfies the unwrap interface.
func (err *ErrUpsertFailed) Unwrap() error {
	return err.Err
}

// ErrDecodeFailed is the decode failed error.
type ErrDecodeFailed struct {
	Err error
}

// Error satisfies the error interface.
func (err *ErrDecodeFailed) Error() string {
	return fmt.Sprintf("unable to decode: %v", err.Err)
}

// Unwrap satisfies the unwrap interface.
func (err *ErrDecodeFailed) Unwrap() error {
	return err.Err
}

// ErrInvalidStringSlice is the invalid StringSlice error.
const ErrInvalidStringSlice Error = "invalid StringSlice"

// StringSlice is a slice of strings.
type StringSlice []string

// Scan satisfies the sql.Scanner interface for StringSlice.
func (ss *StringSlice) Scan(v interface{}) error {
	buf, ok := v.([]byte)
	if !ok {
		return logerror(ErrInvalidStringSlice)
	}
	// change quote escapes for csv parser
	str := strings.Replace(quoteEscRE.ReplaceAllString(string(buf), `$1""`), `\\`, `\`, -1)
	str = str[1 : len(str)-1]
	// bail if only one
	if len(str) == 0 {
		return nil
	}
	// parse with csv reader
	r := csv.NewReader(strings.NewReader(str))
	line, err := r.Read()
	if err != nil {
		return logerror(&ErrDecodeFailed{err})
	}
	*ss = StringSlice(line)
	return nil
}

// quoteEscRE matches escaped characters in a string.
var quoteEscRE = regexp.MustCompile(`([^\\]([\\]{2})*)\\"`)

// Value satisfies the sql/driver.Valuer interface.
func (ss StringSlice) Value() (driver.Value, error) {
	v := make([]string, len(ss))
	for i, s := range ss {
		v[i] = `"` + strings.Replace(strings.Replace(s, `\`, `\\\`, -1), `"`, `\"`, -1) + `"`
	}
	return "{" + strings.Join(v, ",") + "}", nil
}

// PgAggregate represents a row from 'pg_catalog.pg_aggregate'.
type PgAggregate struct {
	Tableoid         pgtypes.Oid     `json:"tableoid"`         // tableoid
	Cmax             pgtypes.Cid     `json:"cmax"`             // cmax
	Xmax             pgtypes.Xid     `json:"xmax"`             // xmax
	Cmin             pgtypes.Cid     `json:"cmin"`             // cmin
	Xmin             pgtypes.Xid     `json:"xmin"`             // xmin
	Ctid             pgtypes.Tid     `json:"ctid"`             // ctid
	Aggfnoid         pgtypes.Regproc `json:"aggfnoid"`         // aggfnoid
	Aggkind          pgtypes.Char    `json:"aggkind"`          // aggkind
	Aggnumdirectargs int16           `json:"aggnumdirectargs"` // aggnumdirectargs
	Aggtransfn       pgtypes.Regproc `json:"aggtransfn"`       // aggtransfn
	Aggfinalfn       pgtypes.Regproc `json:"aggfinalfn"`       // aggfinalfn
	Aggcombinefn     pgtypes.Regproc `json:"aggcombinefn"`     // aggcombinefn
	Aggserialfn      pgtypes.Regproc `json:"aggserialfn"`      // aggserialfn
	Aggdeserialfn    pgtypes.Regproc `json:"aggdeserialfn"`    // aggdeserialfn
	Aggmtransfn      pgtypes.Regproc `json:"aggmtransfn"`      // aggmtransfn
	Aggminvtransfn   pgtypes.Regproc `json:"aggminvtransfn"`   // aggminvtransfn
	Aggmfinalfn      pgtypes.Regproc `json:"aggmfinalfn"`      // aggmfinalfn
	Aggfinalextra    bool            `json:"aggfinalextra"`    // aggfinalextra
	Aggmfinalextra   bool            `json:"aggmfinalextra"`   // aggmfinalextra
	Aggfinalmodify   pgtypes.Char    `json:"aggfinalmodify"`   // aggfinalmodify
	Aggmfinalmodify  pgtypes.Char    `json:"aggmfinalmodify"`  // aggmfinalmodify
	Aggsortop        pgtypes.Oid     `json:"aggsortop"`        // aggsortop
	Aggtranstype     pgtypes.Oid     `json:"aggtranstype"`     // aggtranstype
	Aggtransspace    int             `json:"aggtransspace"`    // aggtransspace
	Aggmtranstype    pgtypes.Oid     `json:"aggmtranstype"`    // aggmtranstype
	Aggmtransspace   int             `json:"aggmtransspace"`   // aggmtransspace
	Agginitval       sql.NullString  `json:"agginitval"`       // agginitval
	Aggminitval      sql.NullString  `json:"aggminitval"`      // aggminitval
}

// PgAm represents a row from 'pg_catalog.pg_am'.
type PgAm struct {
	Tableoid  pgtypes.Oid     `json:"tableoid"`  // tableoid
	Cmax      pgtypes.Cid     `json:"cmax"`      // cmax
	Xmax      pgtypes.Xid     `json:"xmax"`      // xmax
	Cmin      pgtypes.Cid     `json:"cmin"`      // cmin
	Xmin      pgtypes.Xid     `json:"xmin"`      // xmin
	Ctid      pgtypes.Tid     `json:"ctid"`      // ctid
	Oid       pgtypes.Oid     `json:"oid"`       // oid
	Amname    string          `json:"amname"`    // amname
	Amhandler pgtypes.Regproc `json:"amhandler"` // amhandler
	Amtype    pgtypes.Char    `json:"amtype"`    // amtype
}

// PgAmop represents a row from 'pg_catalog.pg_amop'.
type PgAmop struct {
	Tableoid       pgtypes.Oid  `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid  `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid  `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid  `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid  `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid  `json:"ctid"`           // ctid
	Oid            pgtypes.Oid  `json:"oid"`            // oid
	Amopfamily     pgtypes.Oid  `json:"amopfamily"`     // amopfamily
	Amoplefttype   pgtypes.Oid  `json:"amoplefttype"`   // amoplefttype
	Amoprighttype  pgtypes.Oid  `json:"amoprighttype"`  // amoprighttype
	Amopstrategy   int16        `json:"amopstrategy"`   // amopstrategy
	Amoppurpose    pgtypes.Char `json:"amoppurpose"`    // amoppurpose
	Amopopr        pgtypes.Oid  `json:"amopopr"`        // amopopr
	Amopmethod     pgtypes.Oid  `json:"amopmethod"`     // amopmethod
	Amopsortfamily pgtypes.Oid  `json:"amopsortfamily"` // amopsortfamily
}

// PgAmproc represents a row from 'pg_catalog.pg_amproc'.
type PgAmproc struct {
	Tableoid        pgtypes.Oid     `json:"tableoid"`        // tableoid
	Cmax            pgtypes.Cid     `json:"cmax"`            // cmax
	Xmax            pgtypes.Xid     `json:"xmax"`            // xmax
	Cmin            pgtypes.Cid     `json:"cmin"`            // cmin
	Xmin            pgtypes.Xid     `json:"xmin"`            // xmin
	Ctid            pgtypes.Tid     `json:"ctid"`            // ctid
	Oid             pgtypes.Oid     `json:"oid"`             // oid
	Amprocfamily    pgtypes.Oid     `json:"amprocfamily"`    // amprocfamily
	Amproclefttype  pgtypes.Oid     `json:"amproclefttype"`  // amproclefttype
	Amprocrighttype pgtypes.Oid     `json:"amprocrighttype"` // amprocrighttype
	Amprocnum       int16           `json:"amprocnum"`       // amprocnum
	Amproc          pgtypes.Regproc `json:"amproc"`          // amproc
}

// PgAttrdef represents a row from 'pg_catalog.pg_attrdef'.
type PgAttrdef struct {
	Tableoid pgtypes.Oid        `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid        `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid        `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid        `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid        `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid        `json:"ctid"`     // ctid
	Oid      pgtypes.Oid        `json:"oid"`      // oid
	Adrelid  pgtypes.Oid        `json:"adrelid"`  // adrelid
	Adnum    int16              `json:"adnum"`    // adnum
	Adbin    pgtypes.PgNodeTree `json:"adbin"`    // adbin
}

// PgAttribute represents a row from 'pg_catalog.pg_attribute'.
type PgAttribute struct {
	Tableoid      pgtypes.Oid           `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid           `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid           `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid           `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid           `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid           `json:"ctid"`          // ctid
	Attrelid      pgtypes.Oid           `json:"attrelid"`      // attrelid
	Attname       string                `json:"attname"`       // attname
	Atttypid      pgtypes.Oid           `json:"atttypid"`      // atttypid
	Attstattarget int                   `json:"attstattarget"` // attstattarget
	Attlen        int16                 `json:"attlen"`        // attlen
	Attnum        int16                 `json:"attnum"`        // attnum
	Attndims      int                   `json:"attndims"`      // attndims
	Attcacheoff   int                   `json:"attcacheoff"`   // attcacheoff
	Atttypmod     int                   `json:"atttypmod"`     // atttypmod
	Attbyval      bool                  `json:"attbyval"`      // attbyval
	Attstorage    pgtypes.Char          `json:"attstorage"`    // attstorage
	Attalign      pgtypes.Char          `json:"attalign"`      // attalign
	Attnotnull    bool                  `json:"attnotnull"`    // attnotnull
	Atthasdef     bool                  `json:"atthasdef"`     // atthasdef
	Atthasmissing bool                  `json:"atthasmissing"` // atthasmissing
	Attidentity   pgtypes.Char          `json:"attidentity"`   // attidentity
	Attgenerated  pgtypes.Char          `json:"attgenerated"`  // attgenerated
	Attisdropped  bool                  `json:"attisdropped"`  // attisdropped
	Attislocal    bool                  `json:"attislocal"`    // attislocal
	Attinhcount   int                   `json:"attinhcount"`   // attinhcount
	Attcollation  pgtypes.Oid           `json:"attcollation"`  // attcollation
	Attacl        []pgtypes.NullAclitem `json:"attacl"`        // attacl
	Attoptions    []sql.NullString      `json:"attoptions"`    // attoptions
	Attfdwoptions []sql.NullString      `json:"attfdwoptions"` // attfdwoptions
	Attmissingval pgtypes.NullAnyarray  `json:"attmissingval"` // attmissingval
}

// PgAuthMember represents a row from 'pg_catalog.pg_auth_members'.
type PgAuthMember struct {
	Tableoid    pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax        pgtypes.Cid `json:"cmax"`         // cmax
	Xmax        pgtypes.Xid `json:"xmax"`         // xmax
	Cmin        pgtypes.Cid `json:"cmin"`         // cmin
	Xmin        pgtypes.Xid `json:"xmin"`         // xmin
	Ctid        pgtypes.Tid `json:"ctid"`         // ctid
	Roleid      pgtypes.Oid `json:"roleid"`       // roleid
	Member      pgtypes.Oid `json:"member"`       // member
	Grantor     pgtypes.Oid `json:"grantor"`      // grantor
	AdminOption bool        `json:"admin_option"` // admin_option
}

// PgAuthid represents a row from 'pg_catalog.pg_authid'.
type PgAuthid struct {
	Tableoid       pgtypes.Oid    `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid    `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid    `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid    `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid    `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid    `json:"ctid"`           // ctid
	Oid            pgtypes.Oid    `json:"oid"`            // oid
	Rolname        string         `json:"rolname"`        // rolname
	Rolsuper       bool           `json:"rolsuper"`       // rolsuper
	Rolinherit     bool           `json:"rolinherit"`     // rolinherit
	Rolcreaterole  bool           `json:"rolcreaterole"`  // rolcreaterole
	Rolcreatedb    bool           `json:"rolcreatedb"`    // rolcreatedb
	Rolcanlogin    bool           `json:"rolcanlogin"`    // rolcanlogin
	Rolreplication bool           `json:"rolreplication"` // rolreplication
	Rolbypassrls   bool           `json:"rolbypassrls"`   // rolbypassrls
	Rolconnlimit   int            `json:"rolconnlimit"`   // rolconnlimit
	Rolpassword    sql.NullString `json:"rolpassword"`    // rolpassword
	Rolvaliduntil  sql.NullTime   `json:"rolvaliduntil"`  // rolvaliduntil
}

// PgAvailableExtension represents a row from 'pg_catalog.pg_available_extensions'.
type PgAvailableExtension struct {
	Name             sql.NullString `json:"name"`              // name
	DefaultVersion   sql.NullString `json:"default_version"`   // default_version
	InstalledVersion sql.NullString `json:"installed_version"` // installed_version
	Comment          sql.NullString `json:"comment"`           // comment
}

// PgAvailableExtensionVersion represents a row from 'pg_catalog.pg_available_extension_versions'.
type PgAvailableExtensionVersion struct {
	Name        sql.NullString   `json:"name"`        // name
	Version     sql.NullString   `json:"version"`     // version
	Installed   sql.NullBool     `json:"installed"`   // installed
	Superuser   sql.NullBool     `json:"superuser"`   // superuser
	Trusted     sql.NullBool     `json:"trusted"`     // trusted
	Relocatable sql.NullBool     `json:"relocatable"` // relocatable
	Schema      sql.NullString   `json:"schema"`      // schema
	Requires    []sql.NullString `json:"requires"`    // requires
	Comment     sql.NullString   `json:"comment"`     // comment
}

// PgCast represents a row from 'pg_catalog.pg_cast'.
type PgCast struct {
	Tableoid    pgtypes.Oid  `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid  `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid  `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid  `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid  `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid  `json:"ctid"`        // ctid
	Oid         pgtypes.Oid  `json:"oid"`         // oid
	Castsource  pgtypes.Oid  `json:"castsource"`  // castsource
	Casttarget  pgtypes.Oid  `json:"casttarget"`  // casttarget
	Castfunc    pgtypes.Oid  `json:"castfunc"`    // castfunc
	Castcontext pgtypes.Char `json:"castcontext"` // castcontext
	Castmethod  pgtypes.Char `json:"castmethod"`  // castmethod
}

// PgClass represents a row from 'pg_catalog.pg_class'.
type PgClass struct {
	Tableoid            pgtypes.Oid            `json:"tableoid"`            // tableoid
	Cmax                pgtypes.Cid            `json:"cmax"`                // cmax
	Xmax                pgtypes.Xid            `json:"xmax"`                // xmax
	Cmin                pgtypes.Cid            `json:"cmin"`                // cmin
	Xmin                pgtypes.Xid            `json:"xmin"`                // xmin
	Ctid                pgtypes.Tid            `json:"ctid"`                // ctid
	Oid                 pgtypes.Oid            `json:"oid"`                 // oid
	Relname             string                 `json:"relname"`             // relname
	Relnamespace        pgtypes.Oid            `json:"relnamespace"`        // relnamespace
	Reltype             pgtypes.Oid            `json:"reltype"`             // reltype
	Reloftype           pgtypes.Oid            `json:"reloftype"`           // reloftype
	Relowner            pgtypes.Oid            `json:"relowner"`            // relowner
	Relam               pgtypes.Oid            `json:"relam"`               // relam
	Relfilenode         pgtypes.Oid            `json:"relfilenode"`         // relfilenode
	Reltablespace       pgtypes.Oid            `json:"reltablespace"`       // reltablespace
	Relpages            int                    `json:"relpages"`            // relpages
	Reltuples           float32                `json:"reltuples"`           // reltuples
	Relallvisible       int                    `json:"relallvisible"`       // relallvisible
	Reltoastrelid       pgtypes.Oid            `json:"reltoastrelid"`       // reltoastrelid
	Relhasindex         bool                   `json:"relhasindex"`         // relhasindex
	Relisshared         bool                   `json:"relisshared"`         // relisshared
	Relpersistence      pgtypes.Char           `json:"relpersistence"`      // relpersistence
	Relkind             pgtypes.Char           `json:"relkind"`             // relkind
	Relnatts            int16                  `json:"relnatts"`            // relnatts
	Relchecks           int16                  `json:"relchecks"`           // relchecks
	Relhasrules         bool                   `json:"relhasrules"`         // relhasrules
	Relhastriggers      bool                   `json:"relhastriggers"`      // relhastriggers
	Relhassubclass      bool                   `json:"relhassubclass"`      // relhassubclass
	Relrowsecurity      bool                   `json:"relrowsecurity"`      // relrowsecurity
	Relforcerowsecurity bool                   `json:"relforcerowsecurity"` // relforcerowsecurity
	Relispopulated      bool                   `json:"relispopulated"`      // relispopulated
	Relreplident        pgtypes.Char           `json:"relreplident"`        // relreplident
	Relispartition      bool                   `json:"relispartition"`      // relispartition
	Relrewrite          pgtypes.Oid            `json:"relrewrite"`          // relrewrite
	Relfrozenxid        pgtypes.Xid            `json:"relfrozenxid"`        // relfrozenxid
	Relminmxid          pgtypes.Xid            `json:"relminmxid"`          // relminmxid
	Relacl              []pgtypes.NullAclitem  `json:"relacl"`              // relacl
	Reloptions          []sql.NullString       `json:"reloptions"`          // reloptions
	Relpartbound        pgtypes.NullPgNodeTree `json:"relpartbound"`        // relpartbound
}

// PgCollation represents a row from 'pg_catalog.pg_collation'.
type PgCollation struct {
	Tableoid            pgtypes.Oid    `json:"tableoid"`            // tableoid
	Cmax                pgtypes.Cid    `json:"cmax"`                // cmax
	Xmax                pgtypes.Xid    `json:"xmax"`                // xmax
	Cmin                pgtypes.Cid    `json:"cmin"`                // cmin
	Xmin                pgtypes.Xid    `json:"xmin"`                // xmin
	Ctid                pgtypes.Tid    `json:"ctid"`                // ctid
	Oid                 pgtypes.Oid    `json:"oid"`                 // oid
	Collname            string         `json:"collname"`            // collname
	Collnamespace       pgtypes.Oid    `json:"collnamespace"`       // collnamespace
	Collowner           pgtypes.Oid    `json:"collowner"`           // collowner
	Collprovider        pgtypes.Char   `json:"collprovider"`        // collprovider
	Collisdeterministic bool           `json:"collisdeterministic"` // collisdeterministic
	Collencoding        int            `json:"collencoding"`        // collencoding
	Collcollate         string         `json:"collcollate"`         // collcollate
	Collctype           string         `json:"collctype"`           // collctype
	Collversion         sql.NullString `json:"collversion"`         // collversion
}

// PgConfig represents a row from 'pg_catalog.pg_config'.
type PgConfig struct {
	Name    sql.NullString `json:"name"`    // name
	Setting sql.NullString `json:"setting"` // setting
}

// PgConstraint represents a row from 'pg_catalog.pg_constraint'.
type PgConstraint struct {
	Tableoid      pgtypes.Oid            `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid            `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid            `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid            `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid            `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid            `json:"ctid"`          // ctid
	Oid           pgtypes.Oid            `json:"oid"`           // oid
	Conname       string                 `json:"conname"`       // conname
	Connamespace  pgtypes.Oid            `json:"connamespace"`  // connamespace
	Contype       pgtypes.Char           `json:"contype"`       // contype
	Condeferrable bool                   `json:"condeferrable"` // condeferrable
	Condeferred   bool                   `json:"condeferred"`   // condeferred
	Convalidated  bool                   `json:"convalidated"`  // convalidated
	Conrelid      pgtypes.Oid            `json:"conrelid"`      // conrelid
	Contypid      pgtypes.Oid            `json:"contypid"`      // contypid
	Conindid      pgtypes.Oid            `json:"conindid"`      // conindid
	Conparentid   pgtypes.Oid            `json:"conparentid"`   // conparentid
	Confrelid     pgtypes.Oid            `json:"confrelid"`     // confrelid
	Confupdtype   pgtypes.Char           `json:"confupdtype"`   // confupdtype
	Confdeltype   pgtypes.Char           `json:"confdeltype"`   // confdeltype
	Confmatchtype pgtypes.Char           `json:"confmatchtype"` // confmatchtype
	Conislocal    bool                   `json:"conislocal"`    // conislocal
	Coninhcount   int                    `json:"coninhcount"`   // coninhcount
	Connoinherit  bool                   `json:"connoinherit"`  // connoinherit
	Conkey        []sql.NullInt64        `json:"conkey"`        // conkey
	Confkey       []sql.NullInt64        `json:"confkey"`       // confkey
	Conpfeqop     []pgtypes.NullOid      `json:"conpfeqop"`     // conpfeqop
	Conppeqop     []pgtypes.NullOid      `json:"conppeqop"`     // conppeqop
	Conffeqop     []pgtypes.NullOid      `json:"conffeqop"`     // conffeqop
	Conexclop     []pgtypes.NullOid      `json:"conexclop"`     // conexclop
	Conbin        pgtypes.NullPgNodeTree `json:"conbin"`        // conbin
}

// PgConversion represents a row from 'pg_catalog.pg_conversion'.
type PgConversion struct {
	Tableoid       pgtypes.Oid     `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid     `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid     `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid     `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid     `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid     `json:"ctid"`           // ctid
	Oid            pgtypes.Oid     `json:"oid"`            // oid
	Conname        string          `json:"conname"`        // conname
	Connamespace   pgtypes.Oid     `json:"connamespace"`   // connamespace
	Conowner       pgtypes.Oid     `json:"conowner"`       // conowner
	Conforencoding int             `json:"conforencoding"` // conforencoding
	Contoencoding  int             `json:"contoencoding"`  // contoencoding
	Conproc        pgtypes.Regproc `json:"conproc"`        // conproc
	Condefault     bool            `json:"condefault"`     // condefault
}

// PgCursor represents a row from 'pg_catalog.pg_cursors'.
type PgCursor struct {
	Name         sql.NullString `json:"name"`          // name
	Statement    sql.NullString `json:"statement"`     // statement
	IsHoldable   sql.NullBool   `json:"is_holdable"`   // is_holdable
	IsBinary     sql.NullBool   `json:"is_binary"`     // is_binary
	IsScrollable sql.NullBool   `json:"is_scrollable"` // is_scrollable
	CreationTime sql.NullTime   `json:"creation_time"` // creation_time
}

// PgDatabase represents a row from 'pg_catalog.pg_database'.
type PgDatabase struct {
	Tableoid      pgtypes.Oid           `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid           `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid           `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid           `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid           `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid           `json:"ctid"`          // ctid
	Oid           pgtypes.Oid           `json:"oid"`           // oid
	Datname       string                `json:"datname"`       // datname
	Datdba        pgtypes.Oid           `json:"datdba"`        // datdba
	Encoding      int                   `json:"encoding"`      // encoding
	Datcollate    string                `json:"datcollate"`    // datcollate
	Datctype      string                `json:"datctype"`      // datctype
	Datistemplate bool                  `json:"datistemplate"` // datistemplate
	Datallowconn  bool                  `json:"datallowconn"`  // datallowconn
	Datconnlimit  int                   `json:"datconnlimit"`  // datconnlimit
	Datlastsysoid pgtypes.Oid           `json:"datlastsysoid"` // datlastsysoid
	Datfrozenxid  pgtypes.Xid           `json:"datfrozenxid"`  // datfrozenxid
	Datminmxid    pgtypes.Xid           `json:"datminmxid"`    // datminmxid
	Dattablespace pgtypes.Oid           `json:"dattablespace"` // dattablespace
	Datacl        []pgtypes.NullAclitem `json:"datacl"`        // datacl
}

// PgDbRoleSetting represents a row from 'pg_catalog.pg_db_role_setting'.
type PgDbRoleSetting struct {
	Tableoid    pgtypes.Oid      `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid      `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid      `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid      `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid      `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid      `json:"ctid"`        // ctid
	Setdatabase pgtypes.Oid      `json:"setdatabase"` // setdatabase
	Setrole     pgtypes.Oid      `json:"setrole"`     // setrole
	Setconfig   []sql.NullString `json:"setconfig"`   // setconfig
}

// PgDefaultACL represents a row from 'pg_catalog.pg_default_acl'.
type PgDefaultACL struct {
	Tableoid        pgtypes.Oid       `json:"tableoid"`        // tableoid
	Cmax            pgtypes.Cid       `json:"cmax"`            // cmax
	Xmax            pgtypes.Xid       `json:"xmax"`            // xmax
	Cmin            pgtypes.Cid       `json:"cmin"`            // cmin
	Xmin            pgtypes.Xid       `json:"xmin"`            // xmin
	Ctid            pgtypes.Tid       `json:"ctid"`            // ctid
	Oid             pgtypes.Oid       `json:"oid"`             // oid
	Defaclrole      pgtypes.Oid       `json:"defaclrole"`      // defaclrole
	Defaclnamespace pgtypes.Oid       `json:"defaclnamespace"` // defaclnamespace
	Defaclobjtype   pgtypes.Char      `json:"defaclobjtype"`   // defaclobjtype
	Defaclacl       []pgtypes.Aclitem `json:"defaclacl"`       // defaclacl
}

// PgDepend represents a row from 'pg_catalog.pg_depend'.
type PgDepend struct {
	Tableoid    pgtypes.Oid  `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid  `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid  `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid  `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid  `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid  `json:"ctid"`        // ctid
	Classid     pgtypes.Oid  `json:"classid"`     // classid
	Objid       pgtypes.Oid  `json:"objid"`       // objid
	Objsubid    int          `json:"objsubid"`    // objsubid
	Refclassid  pgtypes.Oid  `json:"refclassid"`  // refclassid
	Refobjid    pgtypes.Oid  `json:"refobjid"`    // refobjid
	Refobjsubid int          `json:"refobjsubid"` // refobjsubid
	Deptype     pgtypes.Char `json:"deptype"`     // deptype
}

// PgDescription represents a row from 'pg_catalog.pg_description'.
type PgDescription struct {
	Tableoid    pgtypes.Oid `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid `json:"ctid"`        // ctid
	Objoid      pgtypes.Oid `json:"objoid"`      // objoid
	Classoid    pgtypes.Oid `json:"classoid"`    // classoid
	Objsubid    int         `json:"objsubid"`    // objsubid
	Description string      `json:"description"` // description
}

// PgEnum represents a row from 'pg_catalog.pg_enum'.
type PgEnum struct {
	Tableoid      pgtypes.Oid `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid `json:"ctid"`          // ctid
	Oid           pgtypes.Oid `json:"oid"`           // oid
	Enumtypid     pgtypes.Oid `json:"enumtypid"`     // enumtypid
	Enumsortorder float32     `json:"enumsortorder"` // enumsortorder
	Enumlabel     string      `json:"enumlabel"`     // enumlabel
}

// PgEventTrigger represents a row from 'pg_catalog.pg_event_trigger'.
type PgEventTrigger struct {
	Tableoid   pgtypes.Oid      `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid      `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid      `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid      `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid      `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid      `json:"ctid"`       // ctid
	Oid        pgtypes.Oid      `json:"oid"`        // oid
	Evtname    string           `json:"evtname"`    // evtname
	Evtevent   string           `json:"evtevent"`   // evtevent
	Evtowner   pgtypes.Oid      `json:"evtowner"`   // evtowner
	Evtfoid    pgtypes.Oid      `json:"evtfoid"`    // evtfoid
	Evtenabled pgtypes.Char     `json:"evtenabled"` // evtenabled
	Evttags    []sql.NullString `json:"evttags"`    // evttags
}

// PgExtension represents a row from 'pg_catalog.pg_extension'.
type PgExtension struct {
	Tableoid       pgtypes.Oid       `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid       `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid       `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid       `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid       `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid       `json:"ctid"`           // ctid
	Oid            pgtypes.Oid       `json:"oid"`            // oid
	Extname        string            `json:"extname"`        // extname
	Extowner       pgtypes.Oid       `json:"extowner"`       // extowner
	Extnamespace   pgtypes.Oid       `json:"extnamespace"`   // extnamespace
	Extrelocatable bool              `json:"extrelocatable"` // extrelocatable
	Extversion     string            `json:"extversion"`     // extversion
	Extconfig      []pgtypes.NullOid `json:"extconfig"`      // extconfig
	Extcondition   []sql.NullString  `json:"extcondition"`   // extcondition
}

// PgFileSetting represents a row from 'pg_catalog.pg_file_settings'.
type PgFileSetting struct {
	Sourcefile sql.NullString `json:"sourcefile"` // sourcefile
	Sourceline sql.NullInt64  `json:"sourceline"` // sourceline
	Seqno      sql.NullInt64  `json:"seqno"`      // seqno
	Name       sql.NullString `json:"name"`       // name
	Setting    sql.NullString `json:"setting"`    // setting
	Applied    sql.NullBool   `json:"applied"`    // applied
	Error      sql.NullString `json:"error"`      // error
}

// PgForeignDataWrapper represents a row from 'pg_catalog.pg_foreign_data_wrapper'.
type PgForeignDataWrapper struct {
	Tableoid     pgtypes.Oid           `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid           `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid           `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid           `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid           `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid           `json:"ctid"`         // ctid
	Oid          pgtypes.Oid           `json:"oid"`          // oid
	Fdwname      string                `json:"fdwname"`      // fdwname
	Fdwowner     pgtypes.Oid           `json:"fdwowner"`     // fdwowner
	Fdwhandler   pgtypes.Oid           `json:"fdwhandler"`   // fdwhandler
	Fdwvalidator pgtypes.Oid           `json:"fdwvalidator"` // fdwvalidator
	Fdwacl       []pgtypes.NullAclitem `json:"fdwacl"`       // fdwacl
	Fdwoptions   []sql.NullString      `json:"fdwoptions"`   // fdwoptions
}

// PgForeignServer represents a row from 'pg_catalog.pg_foreign_server'.
type PgForeignServer struct {
	Tableoid   pgtypes.Oid           `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid           `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid           `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid           `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid           `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid           `json:"ctid"`       // ctid
	Oid        pgtypes.Oid           `json:"oid"`        // oid
	Srvname    string                `json:"srvname"`    // srvname
	Srvowner   pgtypes.Oid           `json:"srvowner"`   // srvowner
	Srvfdw     pgtypes.Oid           `json:"srvfdw"`     // srvfdw
	Srvtype    sql.NullString        `json:"srvtype"`    // srvtype
	Srvversion sql.NullString        `json:"srvversion"` // srvversion
	Srvacl     []pgtypes.NullAclitem `json:"srvacl"`     // srvacl
	Srvoptions []sql.NullString      `json:"srvoptions"` // srvoptions
}

// PgForeignTable represents a row from 'pg_catalog.pg_foreign_table'.
type PgForeignTable struct {
	Tableoid  pgtypes.Oid      `json:"tableoid"`  // tableoid
	Cmax      pgtypes.Cid      `json:"cmax"`      // cmax
	Xmax      pgtypes.Xid      `json:"xmax"`      // xmax
	Cmin      pgtypes.Cid      `json:"cmin"`      // cmin
	Xmin      pgtypes.Xid      `json:"xmin"`      // xmin
	Ctid      pgtypes.Tid      `json:"ctid"`      // ctid
	Ftrelid   pgtypes.Oid      `json:"ftrelid"`   // ftrelid
	Ftserver  pgtypes.Oid      `json:"ftserver"`  // ftserver
	Ftoptions []sql.NullString `json:"ftoptions"` // ftoptions
}

// PgGroup represents a row from 'pg_catalog.pg_group'.
type PgGroup struct {
	Groname  sql.NullString    `json:"groname"`  // groname
	Grosysid pgtypes.NullOid   `json:"grosysid"` // grosysid
	Grolist  []pgtypes.NullOid `json:"grolist"`  // grolist
}

// PgHbaFileRule represents a row from 'pg_catalog.pg_hba_file_rules'.
type PgHbaFileRule struct {
	LineNumber sql.NullInt64    `json:"line_number"` // line_number
	Type       sql.NullString   `json:"type"`        // type
	Database   []sql.NullString `json:"database"`    // database
	UserName   []sql.NullString `json:"user_name"`   // user_name
	Address    sql.NullString   `json:"address"`     // address
	Netmask    sql.NullString   `json:"netmask"`     // netmask
	AuthMethod sql.NullString   `json:"auth_method"` // auth_method
	Options    []sql.NullString `json:"options"`     // options
	Error      sql.NullString   `json:"error"`       // error
}

// PgIndex represents a row from 'pg_catalog.pg_indexes'.
type PgIndex struct {
	Schemaname sql.NullString `json:"schemaname"` // schemaname
	Tablename  sql.NullString `json:"tablename"`  // tablename
	Indexname  sql.NullString `json:"indexname"`  // indexname
	Tablespace sql.NullString `json:"tablespace"` // tablespace
	Indexdef   sql.NullString `json:"indexdef"`   // indexdef
}

// PgIndex represents a row from 'pg_catalog.pg_index'.
type PgIndex struct {
	Tableoid       pgtypes.Oid            `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid            `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid            `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid            `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid            `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid            `json:"ctid"`           // ctid
	Indexrelid     pgtypes.Oid            `json:"indexrelid"`     // indexrelid
	Indrelid       pgtypes.Oid            `json:"indrelid"`       // indrelid
	Indnatts       int16                  `json:"indnatts"`       // indnatts
	Indnkeyatts    int16                  `json:"indnkeyatts"`    // indnkeyatts
	Indisunique    bool                   `json:"indisunique"`    // indisunique
	Indisprimary   bool                   `json:"indisprimary"`   // indisprimary
	Indisexclusion bool                   `json:"indisexclusion"` // indisexclusion
	Indimmediate   bool                   `json:"indimmediate"`   // indimmediate
	Indisclustered bool                   `json:"indisclustered"` // indisclustered
	Indisvalid     bool                   `json:"indisvalid"`     // indisvalid
	Indcheckxmin   bool                   `json:"indcheckxmin"`   // indcheckxmin
	Indisready     bool                   `json:"indisready"`     // indisready
	Indislive      bool                   `json:"indislive"`      // indislive
	Indisreplident bool                   `json:"indisreplident"` // indisreplident
	Indkey         pgtypes.Int2vector     `json:"indkey"`         // indkey
	Indcollation   pgtypes.Oidvector      `json:"indcollation"`   // indcollation
	Indclass       pgtypes.Oidvector      `json:"indclass"`       // indclass
	Indoption      pgtypes.Int2vector     `json:"indoption"`      // indoption
	Indexprs       pgtypes.NullPgNodeTree `json:"indexprs"`       // indexprs
	Indpred        pgtypes.NullPgNodeTree `json:"indpred"`        // indpred
}

// PgInherit represents a row from 'pg_catalog.pg_inherits'.
type PgInherit struct {
	Tableoid  pgtypes.Oid `json:"tableoid"`  // tableoid
	Cmax      pgtypes.Cid `json:"cmax"`      // cmax
	Xmax      pgtypes.Xid `json:"xmax"`      // xmax
	Cmin      pgtypes.Cid `json:"cmin"`      // cmin
	Xmin      pgtypes.Xid `json:"xmin"`      // xmin
	Ctid      pgtypes.Tid `json:"ctid"`      // ctid
	Inhrelid  pgtypes.Oid `json:"inhrelid"`  // inhrelid
	Inhparent pgtypes.Oid `json:"inhparent"` // inhparent
	Inhseqno  int         `json:"inhseqno"`  // inhseqno
}

// PgInitPriv represents a row from 'pg_catalog.pg_init_privs'.
type PgInitPriv struct {
	Tableoid  pgtypes.Oid       `json:"tableoid"`  // tableoid
	Cmax      pgtypes.Cid       `json:"cmax"`      // cmax
	Xmax      pgtypes.Xid       `json:"xmax"`      // xmax
	Cmin      pgtypes.Cid       `json:"cmin"`      // cmin
	Xmin      pgtypes.Xid       `json:"xmin"`      // xmin
	Ctid      pgtypes.Tid       `json:"ctid"`      // ctid
	Objoid    pgtypes.Oid       `json:"objoid"`    // objoid
	Classoid  pgtypes.Oid       `json:"classoid"`  // classoid
	Objsubid  int               `json:"objsubid"`  // objsubid
	Privtype  pgtypes.Char      `json:"privtype"`  // privtype
	Initprivs []pgtypes.Aclitem `json:"initprivs"` // initprivs
}

// PgLanguage represents a row from 'pg_catalog.pg_language'.
type PgLanguage struct {
	Tableoid      pgtypes.Oid           `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid           `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid           `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid           `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid           `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid           `json:"ctid"`          // ctid
	Oid           pgtypes.Oid           `json:"oid"`           // oid
	Lanname       string                `json:"lanname"`       // lanname
	Lanowner      pgtypes.Oid           `json:"lanowner"`      // lanowner
	Lanispl       bool                  `json:"lanispl"`       // lanispl
	Lanpltrusted  bool                  `json:"lanpltrusted"`  // lanpltrusted
	Lanplcallfoid pgtypes.Oid           `json:"lanplcallfoid"` // lanplcallfoid
	Laninline     pgtypes.Oid           `json:"laninline"`     // laninline
	Lanvalidator  pgtypes.Oid           `json:"lanvalidator"`  // lanvalidator
	Lanacl        []pgtypes.NullAclitem `json:"lanacl"`        // lanacl
}

// PgLargeobject represents a row from 'pg_catalog.pg_largeobject'.
type PgLargeobject struct {
	Tableoid pgtypes.Oid `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid `json:"ctid"`     // ctid
	Loid     pgtypes.Oid `json:"loid"`     // loid
	Pageno   int         `json:"pageno"`   // pageno
	Data     []byte      `json:"data"`     // data
}

// PgLargeobjectMetadatum represents a row from 'pg_catalog.pg_largeobject_metadata'.
type PgLargeobjectMetadatum struct {
	Tableoid pgtypes.Oid           `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid           `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid           `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid           `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid           `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid           `json:"ctid"`     // ctid
	Oid      pgtypes.Oid           `json:"oid"`      // oid
	Lomowner pgtypes.Oid           `json:"lomowner"` // lomowner
	Lomacl   []pgtypes.NullAclitem `json:"lomacl"`   // lomacl
}

// PgLock represents a row from 'pg_catalog.pg_locks'.
type PgLock struct {
	Locktype           sql.NullString  `json:"locktype"`           // locktype
	Database           pgtypes.NullOid `json:"database"`           // database
	Relation           pgtypes.NullOid `json:"relation"`           // relation
	Page               sql.NullInt64   `json:"page"`               // page
	Tuple              sql.NullInt64   `json:"tuple"`              // tuple
	Virtualxid         sql.NullString  `json:"virtualxid"`         // virtualxid
	Transactionid      pgtypes.NullXid `json:"transactionid"`      // transactionid
	Classid            pgtypes.NullOid `json:"classid"`            // classid
	Objid              pgtypes.NullOid `json:"objid"`              // objid
	Objsubid           sql.NullInt64   `json:"objsubid"`           // objsubid
	Virtualtransaction sql.NullString  `json:"virtualtransaction"` // virtualtransaction
	Pid                sql.NullInt64   `json:"pid"`                // pid
	Mode               sql.NullString  `json:"mode"`               // mode
	Granted            sql.NullBool    `json:"granted"`            // granted
	Fastpath           sql.NullBool    `json:"fastpath"`           // fastpath
}

// PgMatview represents a row from 'pg_catalog.pg_matviews'.
type PgMatview struct {
	Schemaname   sql.NullString `json:"schemaname"`   // schemaname
	Matviewname  sql.NullString `json:"matviewname"`  // matviewname
	Matviewowner sql.NullString `json:"matviewowner"` // matviewowner
	Tablespace   sql.NullString `json:"tablespace"`   // tablespace
	Hasindexes   sql.NullBool   `json:"hasindexes"`   // hasindexes
	Ispopulated  sql.NullBool   `json:"ispopulated"`  // ispopulated
	Definition   sql.NullString `json:"definition"`   // definition
}

// PgNamespace represents a row from 'pg_catalog.pg_namespace'.
type PgNamespace struct {
	Tableoid pgtypes.Oid           `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid           `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid           `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid           `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid           `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid           `json:"ctid"`     // ctid
	Oid      pgtypes.Oid           `json:"oid"`      // oid
	Nspname  string                `json:"nspname"`  // nspname
	Nspowner pgtypes.Oid           `json:"nspowner"` // nspowner
	Nspacl   []pgtypes.NullAclitem `json:"nspacl"`   // nspacl
}

// PgOpclass represents a row from 'pg_catalog.pg_opclass'.
type PgOpclass struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Oid          pgtypes.Oid `json:"oid"`          // oid
	Opcmethod    pgtypes.Oid `json:"opcmethod"`    // opcmethod
	Opcname      string      `json:"opcname"`      // opcname
	Opcnamespace pgtypes.Oid `json:"opcnamespace"` // opcnamespace
	Opcowner     pgtypes.Oid `json:"opcowner"`     // opcowner
	Opcfamily    pgtypes.Oid `json:"opcfamily"`    // opcfamily
	Opcintype    pgtypes.Oid `json:"opcintype"`    // opcintype
	Opcdefault   bool        `json:"opcdefault"`   // opcdefault
	Opckeytype   pgtypes.Oid `json:"opckeytype"`   // opckeytype
}

// PgOperator represents a row from 'pg_catalog.pg_operator'.
type PgOperator struct {
	Tableoid     pgtypes.Oid     `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid     `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid     `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid     `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid     `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid     `json:"ctid"`         // ctid
	Oid          pgtypes.Oid     `json:"oid"`          // oid
	Oprname      string          `json:"oprname"`      // oprname
	Oprnamespace pgtypes.Oid     `json:"oprnamespace"` // oprnamespace
	Oprowner     pgtypes.Oid     `json:"oprowner"`     // oprowner
	Oprkind      pgtypes.Char    `json:"oprkind"`      // oprkind
	Oprcanmerge  bool            `json:"oprcanmerge"`  // oprcanmerge
	Oprcanhash   bool            `json:"oprcanhash"`   // oprcanhash
	Oprleft      pgtypes.Oid     `json:"oprleft"`      // oprleft
	Oprright     pgtypes.Oid     `json:"oprright"`     // oprright
	Oprresult    pgtypes.Oid     `json:"oprresult"`    // oprresult
	Oprcom       pgtypes.Oid     `json:"oprcom"`       // oprcom
	Oprnegate    pgtypes.Oid     `json:"oprnegate"`    // oprnegate
	Oprcode      pgtypes.Regproc `json:"oprcode"`      // oprcode
	Oprrest      pgtypes.Regproc `json:"oprrest"`      // oprrest
	Oprjoin      pgtypes.Regproc `json:"oprjoin"`      // oprjoin
}

// PgOpfamily represents a row from 'pg_catalog.pg_opfamily'.
type PgOpfamily struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Oid          pgtypes.Oid `json:"oid"`          // oid
	Opfmethod    pgtypes.Oid `json:"opfmethod"`    // opfmethod
	Opfname      string      `json:"opfname"`      // opfname
	Opfnamespace pgtypes.Oid `json:"opfnamespace"` // opfnamespace
	Opfowner     pgtypes.Oid `json:"opfowner"`     // opfowner
}

// PgPartitionedTable represents a row from 'pg_catalog.pg_partitioned_table'.
type PgPartitionedTable struct {
	Tableoid      pgtypes.Oid            `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid            `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid            `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid            `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid            `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid            `json:"ctid"`          // ctid
	Partrelid     pgtypes.Oid            `json:"partrelid"`     // partrelid
	Partstrat     pgtypes.Char           `json:"partstrat"`     // partstrat
	Partnatts     int16                  `json:"partnatts"`     // partnatts
	Partdefid     pgtypes.Oid            `json:"partdefid"`     // partdefid
	Partattrs     pgtypes.Int2vector     `json:"partattrs"`     // partattrs
	Partclass     pgtypes.Oidvector      `json:"partclass"`     // partclass
	Partcollation pgtypes.Oidvector      `json:"partcollation"` // partcollation
	Partexprs     pgtypes.NullPgNodeTree `json:"partexprs"`     // partexprs
}

// PgPolicy represents a row from 'pg_catalog.pg_policies'.
type PgPolicy struct {
	Schemaname sql.NullString   `json:"schemaname"` // schemaname
	Tablename  sql.NullString   `json:"tablename"`  // tablename
	Policyname sql.NullString   `json:"policyname"` // policyname
	Permissive sql.NullString   `json:"permissive"` // permissive
	Roles      []sql.NullString `json:"roles"`      // roles
	Cmd        sql.NullString   `json:"cmd"`        // cmd
	Qual       sql.NullString   `json:"qual"`       // qual
	WithCheck  sql.NullString   `json:"with_check"` // with_check
}

// PgPolicy represents a row from 'pg_catalog.pg_policy'.
type PgPolicy struct {
	Tableoid      pgtypes.Oid            `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid            `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid            `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid            `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid            `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid            `json:"ctid"`          // ctid
	Oid           pgtypes.Oid            `json:"oid"`           // oid
	Polname       string                 `json:"polname"`       // polname
	Polrelid      pgtypes.Oid            `json:"polrelid"`      // polrelid
	Polcmd        pgtypes.Char           `json:"polcmd"`        // polcmd
	Polpermissive bool                   `json:"polpermissive"` // polpermissive
	Polroles      []pgtypes.Oid          `json:"polroles"`      // polroles
	Polqual       pgtypes.NullPgNodeTree `json:"polqual"`       // polqual
	Polwithcheck  pgtypes.NullPgNodeTree `json:"polwithcheck"`  // polwithcheck
}

// PgPreparedStatement represents a row from 'pg_catalog.pg_prepared_statements'.
type PgPreparedStatement struct {
	Name           sql.NullString        `json:"name"`            // name
	Statement      sql.NullString        `json:"statement"`       // statement
	PrepareTime    sql.NullTime          `json:"prepare_time"`    // prepare_time
	ParameterTypes []pgtypes.NullRegtype `json:"parameter_types"` // parameter_types
	FromSQL        sql.NullBool          `json:"from_sql"`        // from_sql
}

// PgPreparedXact represents a row from 'pg_catalog.pg_prepared_xacts'.
type PgPreparedXact struct {
	Transaction pgtypes.NullXid `json:"transaction"` // transaction
	Gid         sql.NullString  `json:"gid"`         // gid
	Prepared    sql.NullTime    `json:"prepared"`    // prepared
	Owner       sql.NullString  `json:"owner"`       // owner
	Database    sql.NullString  `json:"database"`    // database
}

// PgProc represents a row from 'pg_catalog.pg_proc'.
type PgProc struct {
	Tableoid        pgtypes.Oid            `json:"tableoid"`        // tableoid
	Cmax            pgtypes.Cid            `json:"cmax"`            // cmax
	Xmax            pgtypes.Xid            `json:"xmax"`            // xmax
	Cmin            pgtypes.Cid            `json:"cmin"`            // cmin
	Xmin            pgtypes.Xid            `json:"xmin"`            // xmin
	Ctid            pgtypes.Tid            `json:"ctid"`            // ctid
	Oid             pgtypes.Oid            `json:"oid"`             // oid
	Proname         string                 `json:"proname"`         // proname
	Pronamespace    pgtypes.Oid            `json:"pronamespace"`    // pronamespace
	Proowner        pgtypes.Oid            `json:"proowner"`        // proowner
	Prolang         pgtypes.Oid            `json:"prolang"`         // prolang
	Procost         float32                `json:"procost"`         // procost
	Prorows         float32                `json:"prorows"`         // prorows
	Provariadic     pgtypes.Oid            `json:"provariadic"`     // provariadic
	Prosupport      pgtypes.Regproc        `json:"prosupport"`      // prosupport
	Prokind         pgtypes.Char           `json:"prokind"`         // prokind
	Prosecdef       bool                   `json:"prosecdef"`       // prosecdef
	Proleakproof    bool                   `json:"proleakproof"`    // proleakproof
	Proisstrict     bool                   `json:"proisstrict"`     // proisstrict
	Proretset       bool                   `json:"proretset"`       // proretset
	Provolatile     pgtypes.Char           `json:"provolatile"`     // provolatile
	Proparallel     pgtypes.Char           `json:"proparallel"`     // proparallel
	Pronargs        int16                  `json:"pronargs"`        // pronargs
	Pronargdefaults int16                  `json:"pronargdefaults"` // pronargdefaults
	Prorettype      pgtypes.Oid            `json:"prorettype"`      // prorettype
	Proargtypes     pgtypes.Oidvector      `json:"proargtypes"`     // proargtypes
	Proallargtypes  []pgtypes.NullOid      `json:"proallargtypes"`  // proallargtypes
	Proargmodes     []pgtypes.NullChar     `json:"proargmodes"`     // proargmodes
	Proargnames     []sql.NullString       `json:"proargnames"`     // proargnames
	Proargdefaults  pgtypes.NullPgNodeTree `json:"proargdefaults"`  // proargdefaults
	Protrftypes     []pgtypes.NullOid      `json:"protrftypes"`     // protrftypes
	Prosrc          string                 `json:"prosrc"`          // prosrc
	Probin          sql.NullString         `json:"probin"`          // probin
	Proconfig       []sql.NullString       `json:"proconfig"`       // proconfig
	Proacl          []pgtypes.NullAclitem  `json:"proacl"`          // proacl
}

// PgPublication represents a row from 'pg_catalog.pg_publication'.
type PgPublication struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Oid          pgtypes.Oid `json:"oid"`          // oid
	Pubname      string      `json:"pubname"`      // pubname
	Pubowner     pgtypes.Oid `json:"pubowner"`     // pubowner
	Puballtables bool        `json:"puballtables"` // puballtables
	Pubinsert    bool        `json:"pubinsert"`    // pubinsert
	Pubupdate    bool        `json:"pubupdate"`    // pubupdate
	Pubdelete    bool        `json:"pubdelete"`    // pubdelete
	Pubtruncate  bool        `json:"pubtruncate"`  // pubtruncate
	Pubviaroot   bool        `json:"pubviaroot"`   // pubviaroot
}

// PgPublicationRel represents a row from 'pg_catalog.pg_publication_rel'.
type PgPublicationRel struct {
	Tableoid pgtypes.Oid `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid `json:"ctid"`     // ctid
	Oid      pgtypes.Oid `json:"oid"`      // oid
	Prpubid  pgtypes.Oid `json:"prpubid"`  // prpubid
	Prrelid  pgtypes.Oid `json:"prrelid"`  // prrelid
}

// PgPublicationTable represents a row from 'pg_catalog.pg_publication_tables'.
type PgPublicationTable struct {
	Pubname    sql.NullString `json:"pubname"`    // pubname
	Schemaname sql.NullString `json:"schemaname"` // schemaname
	Tablename  sql.NullString `json:"tablename"`  // tablename
}

// PgRange represents a row from 'pg_catalog.pg_range'.
type PgRange struct {
	Tableoid     pgtypes.Oid     `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid     `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid     `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid     `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid     `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid     `json:"ctid"`         // ctid
	Rngtypid     pgtypes.Oid     `json:"rngtypid"`     // rngtypid
	Rngsubtype   pgtypes.Oid     `json:"rngsubtype"`   // rngsubtype
	Rngcollation pgtypes.Oid     `json:"rngcollation"` // rngcollation
	Rngsubopc    pgtypes.Oid     `json:"rngsubopc"`    // rngsubopc
	Rngcanonical pgtypes.Regproc `json:"rngcanonical"` // rngcanonical
	Rngsubdiff   pgtypes.Regproc `json:"rngsubdiff"`   // rngsubdiff
}

// PgReplicationOrigin represents a row from 'pg_catalog.pg_replication_origin'.
type PgReplicationOrigin struct {
	Tableoid pgtypes.Oid `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid `json:"ctid"`     // ctid
	Roident  pgtypes.Oid `json:"roident"`  // roident
	Roname   string      `json:"roname"`   // roname
}

// PgReplicationOriginStatus represents a row from 'pg_catalog.pg_replication_origin_status'.
type PgReplicationOriginStatus struct {
	LocalID    pgtypes.NullOid   `json:"local_id"`    // local_id
	ExternalID sql.NullString    `json:"external_id"` // external_id
	RemoteLsn  pgtypes.NullPgLsn `json:"remote_lsn"`  // remote_lsn
	LocalLsn   pgtypes.NullPgLsn `json:"local_lsn"`   // local_lsn
}

// PgReplicationSlot represents a row from 'pg_catalog.pg_replication_slots'.
type PgReplicationSlot struct {
	SlotName          sql.NullString    `json:"slot_name"`           // slot_name
	Plugin            sql.NullString    `json:"plugin"`              // plugin
	SlotType          sql.NullString    `json:"slot_type"`           // slot_type
	Datoid            pgtypes.NullOid   `json:"datoid"`              // datoid
	Database          sql.NullString    `json:"database"`            // database
	Temporary         sql.NullBool      `json:"temporary"`           // temporary
	Active            sql.NullBool      `json:"active"`              // active
	ActivePid         sql.NullInt64     `json:"active_pid"`          // active_pid
	Xmin              pgtypes.NullXid   `json:"xmin"`                // xmin
	CatalogXmin       pgtypes.NullXid   `json:"catalog_xmin"`        // catalog_xmin
	RestartLsn        pgtypes.NullPgLsn `json:"restart_lsn"`         // restart_lsn
	ConfirmedFlushLsn pgtypes.NullPgLsn `json:"confirmed_flush_lsn"` // confirmed_flush_lsn
	WalStatus         sql.NullString    `json:"wal_status"`          // wal_status
	SafeWalSize       sql.NullInt64     `json:"safe_wal_size"`       // safe_wal_size
}

// PgRewrite represents a row from 'pg_catalog.pg_rewrite'.
type PgRewrite struct {
	Tableoid  pgtypes.Oid        `json:"tableoid"`   // tableoid
	Cmax      pgtypes.Cid        `json:"cmax"`       // cmax
	Xmax      pgtypes.Xid        `json:"xmax"`       // xmax
	Cmin      pgtypes.Cid        `json:"cmin"`       // cmin
	Xmin      pgtypes.Xid        `json:"xmin"`       // xmin
	Ctid      pgtypes.Tid        `json:"ctid"`       // ctid
	Oid       pgtypes.Oid        `json:"oid"`        // oid
	Rulename  string             `json:"rulename"`   // rulename
	EvClass   pgtypes.Oid        `json:"ev_class"`   // ev_class
	EvType    pgtypes.Char       `json:"ev_type"`    // ev_type
	EvEnabled pgtypes.Char       `json:"ev_enabled"` // ev_enabled
	IsInstead bool               `json:"is_instead"` // is_instead
	EvQual    pgtypes.PgNodeTree `json:"ev_qual"`    // ev_qual
	EvAction  pgtypes.PgNodeTree `json:"ev_action"`  // ev_action
}

// PgRole represents a row from 'pg_catalog.pg_roles'.
type PgRole struct {
	Rolname        sql.NullString   `json:"rolname"`        // rolname
	Rolsuper       sql.NullBool     `json:"rolsuper"`       // rolsuper
	Rolinherit     sql.NullBool     `json:"rolinherit"`     // rolinherit
	Rolcreaterole  sql.NullBool     `json:"rolcreaterole"`  // rolcreaterole
	Rolcreatedb    sql.NullBool     `json:"rolcreatedb"`    // rolcreatedb
	Rolcanlogin    sql.NullBool     `json:"rolcanlogin"`    // rolcanlogin
	Rolreplication sql.NullBool     `json:"rolreplication"` // rolreplication
	Rolconnlimit   sql.NullInt64    `json:"rolconnlimit"`   // rolconnlimit
	Rolpassword    sql.NullString   `json:"rolpassword"`    // rolpassword
	Rolvaliduntil  sql.NullTime     `json:"rolvaliduntil"`  // rolvaliduntil
	Rolbypassrls   sql.NullBool     `json:"rolbypassrls"`   // rolbypassrls
	Rolconfig      []sql.NullString `json:"rolconfig"`      // rolconfig
	Oid            pgtypes.NullOid  `json:"oid"`            // oid
}

// PgRule represents a row from 'pg_catalog.pg_rules'.
type PgRule struct {
	Schemaname sql.NullString `json:"schemaname"` // schemaname
	Tablename  sql.NullString `json:"tablename"`  // tablename
	Rulename   sql.NullString `json:"rulename"`   // rulename
	Definition sql.NullString `json:"definition"` // definition
}

// PgSeclabel represents a row from 'pg_catalog.pg_seclabel'.
type PgSeclabel struct {
	Tableoid pgtypes.Oid `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid `json:"ctid"`     // ctid
	Objoid   pgtypes.Oid `json:"objoid"`   // objoid
	Classoid pgtypes.Oid `json:"classoid"` // classoid
	Objsubid int         `json:"objsubid"` // objsubid
	Provider string      `json:"provider"` // provider
	Label    string      `json:"label"`    // label
}

// PgSeclabel represents a row from 'pg_catalog.pg_seclabels'.
type PgSeclabel struct {
	Objoid       pgtypes.NullOid `json:"objoid"`       // objoid
	Classoid     pgtypes.NullOid `json:"classoid"`     // classoid
	Objsubid     sql.NullInt64   `json:"objsubid"`     // objsubid
	Objtype      sql.NullString  `json:"objtype"`      // objtype
	Objnamespace pgtypes.NullOid `json:"objnamespace"` // objnamespace
	Objname      sql.NullString  `json:"objname"`      // objname
	Provider     sql.NullString  `json:"provider"`     // provider
	Label        sql.NullString  `json:"label"`        // label
}

// PgSequence represents a row from 'pg_catalog.pg_sequence'.
type PgSequence struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Seqrelid     pgtypes.Oid `json:"seqrelid"`     // seqrelid
	Seqtypid     pgtypes.Oid `json:"seqtypid"`     // seqtypid
	Seqstart     int64       `json:"seqstart"`     // seqstart
	Seqincrement int64       `json:"seqincrement"` // seqincrement
	Seqmax       int64       `json:"seqmax"`       // seqmax
	Seqmin       int64       `json:"seqmin"`       // seqmin
	Seqcache     int64       `json:"seqcache"`     // seqcache
	Seqcycle     bool        `json:"seqcycle"`     // seqcycle
}

// PgSequence represents a row from 'pg_catalog.pg_sequences'.
type PgSequence struct {
	Schemaname    sql.NullString      `json:"schemaname"`    // schemaname
	Sequencename  sql.NullString      `json:"sequencename"`  // sequencename
	Sequenceowner sql.NullString      `json:"sequenceowner"` // sequenceowner
	DataType      pgtypes.NullRegtype `json:"data_type"`     // data_type
	StartValue    sql.NullInt64       `json:"start_value"`   // start_value
	MinValue      sql.NullInt64       `json:"min_value"`     // min_value
	MaxValue      sql.NullInt64       `json:"max_value"`     // max_value
	IncrementBy   sql.NullInt64       `json:"increment_by"`  // increment_by
	Cycle         sql.NullBool        `json:"cycle"`         // cycle
	CacheSize     sql.NullInt64       `json:"cache_size"`    // cache_size
	LastValue     sql.NullInt64       `json:"last_value"`    // last_value
}

// PgSetting represents a row from 'pg_catalog.pg_settings'.
type PgSetting struct {
	Name           sql.NullString   `json:"name"`            // name
	Setting        sql.NullString   `json:"setting"`         // setting
	Unit           sql.NullString   `json:"unit"`            // unit
	Category       sql.NullString   `json:"category"`        // category
	ShortDesc      sql.NullString   `json:"short_desc"`      // short_desc
	ExtraDesc      sql.NullString   `json:"extra_desc"`      // extra_desc
	Context        sql.NullString   `json:"context"`         // context
	Vartype        sql.NullString   `json:"vartype"`         // vartype
	Source         sql.NullString   `json:"source"`          // source
	MinVal         sql.NullString   `json:"min_val"`         // min_val
	MaxVal         sql.NullString   `json:"max_val"`         // max_val
	Enumvals       []sql.NullString `json:"enumvals"`        // enumvals
	BootVal        sql.NullString   `json:"boot_val"`        // boot_val
	ResetVal       sql.NullString   `json:"reset_val"`       // reset_val
	Sourcefile     sql.NullString   `json:"sourcefile"`      // sourcefile
	Sourceline     sql.NullInt64    `json:"sourceline"`      // sourceline
	PendingRestart sql.NullBool     `json:"pending_restart"` // pending_restart
}

// PgShadow represents a row from 'pg_catalog.pg_shadow'.
type PgShadow struct {
	Usename      sql.NullString   `json:"usename"`      // usename
	Usesysid     pgtypes.NullOid  `json:"usesysid"`     // usesysid
	Usecreatedb  sql.NullBool     `json:"usecreatedb"`  // usecreatedb
	Usesuper     sql.NullBool     `json:"usesuper"`     // usesuper
	Userepl      sql.NullBool     `json:"userepl"`      // userepl
	Usebypassrls sql.NullBool     `json:"usebypassrls"` // usebypassrls
	Passwd       sql.NullString   `json:"passwd"`       // passwd
	Valuntil     sql.NullTime     `json:"valuntil"`     // valuntil
	Useconfig    []sql.NullString `json:"useconfig"`    // useconfig
}

// PgShdepend represents a row from 'pg_catalog.pg_shdepend'.
type PgShdepend struct {
	Tableoid   pgtypes.Oid  `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid  `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid  `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid  `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid  `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid  `json:"ctid"`       // ctid
	Dbid       pgtypes.Oid  `json:"dbid"`       // dbid
	Classid    pgtypes.Oid  `json:"classid"`    // classid
	Objid      pgtypes.Oid  `json:"objid"`      // objid
	Objsubid   int          `json:"objsubid"`   // objsubid
	Refclassid pgtypes.Oid  `json:"refclassid"` // refclassid
	Refobjid   pgtypes.Oid  `json:"refobjid"`   // refobjid
	Deptype    pgtypes.Char `json:"deptype"`    // deptype
}

// PgShdescription represents a row from 'pg_catalog.pg_shdescription'.
type PgShdescription struct {
	Tableoid    pgtypes.Oid `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid `json:"ctid"`        // ctid
	Objoid      pgtypes.Oid `json:"objoid"`      // objoid
	Classoid    pgtypes.Oid `json:"classoid"`    // classoid
	Description string      `json:"description"` // description
}

// PgShmemAllocation represents a row from 'pg_catalog.pg_shmem_allocations'.
type PgShmemAllocation struct {
	Name          sql.NullString `json:"name"`           // name
	Off           sql.NullInt64  `json:"off"`            // off
	Size          sql.NullInt64  `json:"size"`           // size
	AllocatedSize sql.NullInt64  `json:"allocated_size"` // allocated_size
}

// PgShseclabel represents a row from 'pg_catalog.pg_shseclabel'.
type PgShseclabel struct {
	Tableoid pgtypes.Oid `json:"tableoid"` // tableoid
	Cmax     pgtypes.Cid `json:"cmax"`     // cmax
	Xmax     pgtypes.Xid `json:"xmax"`     // xmax
	Cmin     pgtypes.Cid `json:"cmin"`     // cmin
	Xmin     pgtypes.Xid `json:"xmin"`     // xmin
	Ctid     pgtypes.Tid `json:"ctid"`     // ctid
	Objoid   pgtypes.Oid `json:"objoid"`   // objoid
	Classoid pgtypes.Oid `json:"classoid"` // classoid
	Provider string      `json:"provider"` // provider
	Label    string      `json:"label"`    // label
}

// PgStat represents a row from 'pg_catalog.pg_stats'.
type PgStat struct {
	Schemaname          sql.NullString       `json:"schemaname"`             // schemaname
	Tablename           sql.NullString       `json:"tablename"`              // tablename
	Attname             sql.NullString       `json:"attname"`                // attname
	Inherited           sql.NullBool         `json:"inherited"`              // inherited
	NullFrac            sql.NullFloat64      `json:"null_frac"`              // null_frac
	AvgWidth            sql.NullInt64        `json:"avg_width"`              // avg_width
	NDistinct           sql.NullFloat64      `json:"n_distinct"`             // n_distinct
	MostCommonVals      pgtypes.NullAnyarray `json:"most_common_vals"`       // most_common_vals
	MostCommonFreqs     []sql.NullFloat64    `json:"most_common_freqs"`      // most_common_freqs
	HistogramBounds     pgtypes.NullAnyarray `json:"histogram_bounds"`       // histogram_bounds
	Correlation         sql.NullFloat64      `json:"correlation"`            // correlation
	MostCommonElems     pgtypes.NullAnyarray `json:"most_common_elems"`      // most_common_elems
	MostCommonElemFreqs []sql.NullFloat64    `json:"most_common_elem_freqs"` // most_common_elem_freqs
	ElemCountHistogram  []sql.NullFloat64    `json:"elem_count_histogram"`   // elem_count_histogram
}

// PgStatActivity represents a row from 'pg_catalog.pg_stat_activity'.
type PgStatActivity struct {
	Datid           pgtypes.NullOid `json:"datid"`            // datid
	Datname         sql.NullString  `json:"datname"`          // datname
	Pid             sql.NullInt64   `json:"pid"`              // pid
	LeaderPid       sql.NullInt64   `json:"leader_pid"`       // leader_pid
	Usesysid        pgtypes.NullOid `json:"usesysid"`         // usesysid
	Usename         sql.NullString  `json:"usename"`          // usename
	ApplicationName sql.NullString  `json:"application_name"` // application_name
	ClientAddr      sql.NullString  `json:"client_addr"`      // client_addr
	ClientHostname  sql.NullString  `json:"client_hostname"`  // client_hostname
	ClientPort      sql.NullInt64   `json:"client_port"`      // client_port
	BackendStart    sql.NullTime    `json:"backend_start"`    // backend_start
	XactStart       sql.NullTime    `json:"xact_start"`       // xact_start
	QueryStart      sql.NullTime    `json:"query_start"`      // query_start
	StateChange     sql.NullTime    `json:"state_change"`     // state_change
	WaitEventType   sql.NullString  `json:"wait_event_type"`  // wait_event_type
	WaitEvent       sql.NullString  `json:"wait_event"`       // wait_event
	State           sql.NullString  `json:"state"`            // state
	BackendXid      pgtypes.NullXid `json:"backend_xid"`      // backend_xid
	BackendXmin     pgtypes.NullXid `json:"backend_xmin"`     // backend_xmin
	Query           sql.NullString  `json:"query"`            // query
	BackendType     sql.NullString  `json:"backend_type"`     // backend_type
}

// PgStatAllIndex represents a row from 'pg_catalog.pg_stat_all_indexes'.
type PgStatAllIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxScan      sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupRead   sql.NullInt64   `json:"idx_tup_read"`  // idx_tup_read
	IdxTupFetch  sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
}

// PgStatAllTable represents a row from 'pg_catalog.pg_stat_all_tables'.
type PgStatAllTable struct {
	Relid            pgtypes.NullOid `json:"relid"`               // relid
	Schemaname       sql.NullString  `json:"schemaname"`          // schemaname
	Relname          sql.NullString  `json:"relname"`             // relname
	SeqScan          sql.NullInt64   `json:"seq_scan"`            // seq_scan
	SeqTupRead       sql.NullInt64   `json:"seq_tup_read"`        // seq_tup_read
	IdxScan          sql.NullInt64   `json:"idx_scan"`            // idx_scan
	IdxTupFetch      sql.NullInt64   `json:"idx_tup_fetch"`       // idx_tup_fetch
	NTupIns          sql.NullInt64   `json:"n_tup_ins"`           // n_tup_ins
	NTupUpd          sql.NullInt64   `json:"n_tup_upd"`           // n_tup_upd
	NTupDel          sql.NullInt64   `json:"n_tup_del"`           // n_tup_del
	NTupHotUpd       sql.NullInt64   `json:"n_tup_hot_upd"`       // n_tup_hot_upd
	NLiveTup         sql.NullInt64   `json:"n_live_tup"`          // n_live_tup
	NDeadTup         sql.NullInt64   `json:"n_dead_tup"`          // n_dead_tup
	NModSinceAnalyze sql.NullInt64   `json:"n_mod_since_analyze"` // n_mod_since_analyze
	NInsSinceVacuum  sql.NullInt64   `json:"n_ins_since_vacuum"`  // n_ins_since_vacuum
	LastVacuum       sql.NullTime    `json:"last_vacuum"`         // last_vacuum
	LastAutovacuum   sql.NullTime    `json:"last_autovacuum"`     // last_autovacuum
	LastAnalyze      sql.NullTime    `json:"last_analyze"`        // last_analyze
	LastAutoanalyze  sql.NullTime    `json:"last_autoanalyze"`    // last_autoanalyze
	VacuumCount      sql.NullInt64   `json:"vacuum_count"`        // vacuum_count
	AutovacuumCount  sql.NullInt64   `json:"autovacuum_count"`    // autovacuum_count
	AnalyzeCount     sql.NullInt64   `json:"analyze_count"`       // analyze_count
	AutoanalyzeCount sql.NullInt64   `json:"autoanalyze_count"`   // autoanalyze_count
}

// PgStatArchiver represents a row from 'pg_catalog.pg_stat_archiver'.
type PgStatArchiver struct {
	ArchivedCount    sql.NullInt64  `json:"archived_count"`     // archived_count
	LastArchivedWal  sql.NullString `json:"last_archived_wal"`  // last_archived_wal
	LastArchivedTime sql.NullTime   `json:"last_archived_time"` // last_archived_time
	FailedCount      sql.NullInt64  `json:"failed_count"`       // failed_count
	LastFailedWal    sql.NullString `json:"last_failed_wal"`    // last_failed_wal
	LastFailedTime   sql.NullTime   `json:"last_failed_time"`   // last_failed_time
	StatsReset       sql.NullTime   `json:"stats_reset"`        // stats_reset
}

// PgStatBgwriter represents a row from 'pg_catalog.pg_stat_bgwriter'.
type PgStatBgwriter struct {
	CheckpointsTimed    sql.NullInt64   `json:"checkpoints_timed"`     // checkpoints_timed
	CheckpointsReq      sql.NullInt64   `json:"checkpoints_req"`       // checkpoints_req
	CheckpointWriteTime sql.NullFloat64 `json:"checkpoint_write_time"` // checkpoint_write_time
	CheckpointSyncTime  sql.NullFloat64 `json:"checkpoint_sync_time"`  // checkpoint_sync_time
	BuffersCheckpoint   sql.NullInt64   `json:"buffers_checkpoint"`    // buffers_checkpoint
	BuffersClean        sql.NullInt64   `json:"buffers_clean"`         // buffers_clean
	MaxwrittenClean     sql.NullInt64   `json:"maxwritten_clean"`      // maxwritten_clean
	BuffersBackend      sql.NullInt64   `json:"buffers_backend"`       // buffers_backend
	BuffersBackendFsync sql.NullInt64   `json:"buffers_backend_fsync"` // buffers_backend_fsync
	BuffersAlloc        sql.NullInt64   `json:"buffers_alloc"`         // buffers_alloc
	StatsReset          sql.NullTime    `json:"stats_reset"`           // stats_reset
}

// PgStatDatabase represents a row from 'pg_catalog.pg_stat_database'.
type PgStatDatabase struct {
	Datid               pgtypes.NullOid `json:"datid"`                 // datid
	Datname             sql.NullString  `json:"datname"`               // datname
	Numbackends         sql.NullInt64   `json:"numbackends"`           // numbackends
	XactCommit          sql.NullInt64   `json:"xact_commit"`           // xact_commit
	XactRollback        sql.NullInt64   `json:"xact_rollback"`         // xact_rollback
	BlksRead            sql.NullInt64   `json:"blks_read"`             // blks_read
	BlksHit             sql.NullInt64   `json:"blks_hit"`              // blks_hit
	TupReturned         sql.NullInt64   `json:"tup_returned"`          // tup_returned
	TupFetched          sql.NullInt64   `json:"tup_fetched"`           // tup_fetched
	TupInserted         sql.NullInt64   `json:"tup_inserted"`          // tup_inserted
	TupUpdated          sql.NullInt64   `json:"tup_updated"`           // tup_updated
	TupDeleted          sql.NullInt64   `json:"tup_deleted"`           // tup_deleted
	Conflicts           sql.NullInt64   `json:"conflicts"`             // conflicts
	TempFiles           sql.NullInt64   `json:"temp_files"`            // temp_files
	TempBytes           sql.NullInt64   `json:"temp_bytes"`            // temp_bytes
	Deadlocks           sql.NullInt64   `json:"deadlocks"`             // deadlocks
	ChecksumFailures    sql.NullInt64   `json:"checksum_failures"`     // checksum_failures
	ChecksumLastFailure sql.NullTime    `json:"checksum_last_failure"` // checksum_last_failure
	BlkReadTime         sql.NullFloat64 `json:"blk_read_time"`         // blk_read_time
	BlkWriteTime        sql.NullFloat64 `json:"blk_write_time"`        // blk_write_time
	StatsReset          sql.NullTime    `json:"stats_reset"`           // stats_reset
}

// PgStatDatabaseConflict represents a row from 'pg_catalog.pg_stat_database_conflicts'.
type PgStatDatabaseConflict struct {
	Datid           pgtypes.NullOid `json:"datid"`            // datid
	Datname         sql.NullString  `json:"datname"`          // datname
	ConflTablespace sql.NullInt64   `json:"confl_tablespace"` // confl_tablespace
	ConflLock       sql.NullInt64   `json:"confl_lock"`       // confl_lock
	ConflSnapshot   sql.NullInt64   `json:"confl_snapshot"`   // confl_snapshot
	ConflBufferpin  sql.NullInt64   `json:"confl_bufferpin"`  // confl_bufferpin
	ConflDeadlock   sql.NullInt64   `json:"confl_deadlock"`   // confl_deadlock
}

// PgStatGssapi represents a row from 'pg_catalog.pg_stat_gssapi'.
type PgStatGssapi struct {
	Pid              sql.NullInt64  `json:"pid"`               // pid
	GssAuthenticated sql.NullBool   `json:"gss_authenticated"` // gss_authenticated
	Principal        sql.NullString `json:"principal"`         // principal
	Encrypted        sql.NullBool   `json:"encrypted"`         // encrypted
}

// PgStatProgressAnalyze represents a row from 'pg_catalog.pg_stat_progress_analyze'.
type PgStatProgressAnalyze struct {
	Pid                    sql.NullInt64   `json:"pid"`                       // pid
	Datid                  pgtypes.NullOid `json:"datid"`                     // datid
	Datname                sql.NullString  `json:"datname"`                   // datname
	Relid                  pgtypes.NullOid `json:"relid"`                     // relid
	Phase                  sql.NullString  `json:"phase"`                     // phase
	SampleBlksTotal        sql.NullInt64   `json:"sample_blks_total"`         // sample_blks_total
	SampleBlksScanned      sql.NullInt64   `json:"sample_blks_scanned"`       // sample_blks_scanned
	ExtStatsTotal          sql.NullInt64   `json:"ext_stats_total"`           // ext_stats_total
	ExtStatsComputed       sql.NullInt64   `json:"ext_stats_computed"`        // ext_stats_computed
	ChildTablesTotal       sql.NullInt64   `json:"child_tables_total"`        // child_tables_total
	ChildTablesDone        sql.NullInt64   `json:"child_tables_done"`         // child_tables_done
	CurrentChildTableRelid pgtypes.NullOid `json:"current_child_table_relid"` // current_child_table_relid
}

// PgStatProgressBasebackup represents a row from 'pg_catalog.pg_stat_progress_basebackup'.
type PgStatProgressBasebackup struct {
	Pid                 sql.NullInt64  `json:"pid"`                  // pid
	Phase               sql.NullString `json:"phase"`                // phase
	BackupTotal         sql.NullInt64  `json:"backup_total"`         // backup_total
	BackupStreamed      sql.NullInt64  `json:"backup_streamed"`      // backup_streamed
	TablespacesTotal    sql.NullInt64  `json:"tablespaces_total"`    // tablespaces_total
	TablespacesStreamed sql.NullInt64  `json:"tablespaces_streamed"` // tablespaces_streamed
}

// PgStatProgressCluster represents a row from 'pg_catalog.pg_stat_progress_cluster'.
type PgStatProgressCluster struct {
	Pid               sql.NullInt64   `json:"pid"`                 // pid
	Datid             pgtypes.NullOid `json:"datid"`               // datid
	Datname           sql.NullString  `json:"datname"`             // datname
	Relid             pgtypes.NullOid `json:"relid"`               // relid
	Command           sql.NullString  `json:"command"`             // command
	Phase             sql.NullString  `json:"phase"`               // phase
	ClusterIndexRelid pgtypes.NullOid `json:"cluster_index_relid"` // cluster_index_relid
	HeapTuplesScanned sql.NullInt64   `json:"heap_tuples_scanned"` // heap_tuples_scanned
	HeapTuplesWritten sql.NullInt64   `json:"heap_tuples_written"` // heap_tuples_written
	HeapBlksTotal     sql.NullInt64   `json:"heap_blks_total"`     // heap_blks_total
	HeapBlksScanned   sql.NullInt64   `json:"heap_blks_scanned"`   // heap_blks_scanned
	IndexRebuildCount sql.NullInt64   `json:"index_rebuild_count"` // index_rebuild_count
}

// PgStatProgressCreateIndex represents a row from 'pg_catalog.pg_stat_progress_create_index'.
type PgStatProgressCreateIndex struct {
	Pid              sql.NullInt64   `json:"pid"`                // pid
	Datid            pgtypes.NullOid `json:"datid"`              // datid
	Datname          sql.NullString  `json:"datname"`            // datname
	Relid            pgtypes.NullOid `json:"relid"`              // relid
	IndexRelid       pgtypes.NullOid `json:"index_relid"`        // index_relid
	Command          sql.NullString  `json:"command"`            // command
	Phase            sql.NullString  `json:"phase"`              // phase
	LockersTotal     sql.NullInt64   `json:"lockers_total"`      // lockers_total
	LockersDone      sql.NullInt64   `json:"lockers_done"`       // lockers_done
	CurrentLockerPid sql.NullInt64   `json:"current_locker_pid"` // current_locker_pid
	BlocksTotal      sql.NullInt64   `json:"blocks_total"`       // blocks_total
	BlocksDone       sql.NullInt64   `json:"blocks_done"`        // blocks_done
	TuplesTotal      sql.NullInt64   `json:"tuples_total"`       // tuples_total
	TuplesDone       sql.NullInt64   `json:"tuples_done"`        // tuples_done
	PartitionsTotal  sql.NullInt64   `json:"partitions_total"`   // partitions_total
	PartitionsDone   sql.NullInt64   `json:"partitions_done"`    // partitions_done
}

// PgStatProgressVacuum represents a row from 'pg_catalog.pg_stat_progress_vacuum'.
type PgStatProgressVacuum struct {
	Pid              sql.NullInt64   `json:"pid"`                // pid
	Datid            pgtypes.NullOid `json:"datid"`              // datid
	Datname          sql.NullString  `json:"datname"`            // datname
	Relid            pgtypes.NullOid `json:"relid"`              // relid
	Phase            sql.NullString  `json:"phase"`              // phase
	HeapBlksTotal    sql.NullInt64   `json:"heap_blks_total"`    // heap_blks_total
	HeapBlksScanned  sql.NullInt64   `json:"heap_blks_scanned"`  // heap_blks_scanned
	HeapBlksVacuumed sql.NullInt64   `json:"heap_blks_vacuumed"` // heap_blks_vacuumed
	IndexVacuumCount sql.NullInt64   `json:"index_vacuum_count"` // index_vacuum_count
	MaxDeadTuples    sql.NullInt64   `json:"max_dead_tuples"`    // max_dead_tuples
	NumDeadTuples    sql.NullInt64   `json:"num_dead_tuples"`    // num_dead_tuples
}

// PgStatReplication represents a row from 'pg_catalog.pg_stat_replication'.
type PgStatReplication struct {
	Pid             sql.NullInt64     `json:"pid"`              // pid
	Usesysid        pgtypes.NullOid   `json:"usesysid"`         // usesysid
	Usename         sql.NullString    `json:"usename"`          // usename
	ApplicationName sql.NullString    `json:"application_name"` // application_name
	ClientAddr      sql.NullString    `json:"client_addr"`      // client_addr
	ClientHostname  sql.NullString    `json:"client_hostname"`  // client_hostname
	ClientPort      sql.NullInt64     `json:"client_port"`      // client_port
	BackendStart    sql.NullTime      `json:"backend_start"`    // backend_start
	BackendXmin     pgtypes.NullXid   `json:"backend_xmin"`     // backend_xmin
	State           sql.NullString    `json:"state"`            // state
	SentLsn         pgtypes.NullPgLsn `json:"sent_lsn"`         // sent_lsn
	WriteLsn        pgtypes.NullPgLsn `json:"write_lsn"`        // write_lsn
	FlushLsn        pgtypes.NullPgLsn `json:"flush_lsn"`        // flush_lsn
	ReplayLsn       pgtypes.NullPgLsn `json:"replay_lsn"`       // replay_lsn
	WriteLag        []byte            `json:"write_lag"`        // write_lag
	FlushLag        []byte            `json:"flush_lag"`        // flush_lag
	ReplayLag       []byte            `json:"replay_lag"`       // replay_lag
	SyncPriority    sql.NullInt64     `json:"sync_priority"`    // sync_priority
	SyncState       sql.NullString    `json:"sync_state"`       // sync_state
	ReplyTime       sql.NullTime      `json:"reply_time"`       // reply_time
}

// PgStatSlru represents a row from 'pg_catalog.pg_stat_slru'.
type PgStatSlru struct {
	Name        sql.NullString `json:"name"`         // name
	BlksZeroed  sql.NullInt64  `json:"blks_zeroed"`  // blks_zeroed
	BlksHit     sql.NullInt64  `json:"blks_hit"`     // blks_hit
	BlksRead    sql.NullInt64  `json:"blks_read"`    // blks_read
	BlksWritten sql.NullInt64  `json:"blks_written"` // blks_written
	BlksExists  sql.NullInt64  `json:"blks_exists"`  // blks_exists
	Flushes     sql.NullInt64  `json:"flushes"`      // flushes
	Truncates   sql.NullInt64  `json:"truncates"`    // truncates
	StatsReset  sql.NullTime   `json:"stats_reset"`  // stats_reset
}

// PgStatSsl represents a row from 'pg_catalog.pg_stat_ssl'.
type PgStatSsl struct {
	Pid          sql.NullInt64   `json:"pid"`           // pid
	Ssl          sql.NullBool    `json:"ssl"`           // ssl
	Version      sql.NullString  `json:"version"`       // version
	Cipher       sql.NullString  `json:"cipher"`        // cipher
	Bits         sql.NullInt64   `json:"bits"`          // bits
	Compression  sql.NullBool    `json:"compression"`   // compression
	ClientDn     sql.NullString  `json:"client_dn"`     // client_dn
	ClientSerial sql.NullFloat64 `json:"client_serial"` // client_serial
	IssuerDn     sql.NullString  `json:"issuer_dn"`     // issuer_dn
}

// PgStatSubscription represents a row from 'pg_catalog.pg_stat_subscription'.
type PgStatSubscription struct {
	Subid              pgtypes.NullOid   `json:"subid"`                 // subid
	Subname            sql.NullString    `json:"subname"`               // subname
	Pid                sql.NullInt64     `json:"pid"`                   // pid
	Relid              pgtypes.NullOid   `json:"relid"`                 // relid
	ReceivedLsn        pgtypes.NullPgLsn `json:"received_lsn"`          // received_lsn
	LastMsgSendTime    sql.NullTime      `json:"last_msg_send_time"`    // last_msg_send_time
	LastMsgReceiptTime sql.NullTime      `json:"last_msg_receipt_time"` // last_msg_receipt_time
	LatestEndLsn       pgtypes.NullPgLsn `json:"latest_end_lsn"`        // latest_end_lsn
	LatestEndTime      sql.NullTime      `json:"latest_end_time"`       // latest_end_time
}

// PgStatSysIndex represents a row from 'pg_catalog.pg_stat_sys_indexes'.
type PgStatSysIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxScan      sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupRead   sql.NullInt64   `json:"idx_tup_read"`  // idx_tup_read
	IdxTupFetch  sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
}

// PgStatSysTable represents a row from 'pg_catalog.pg_stat_sys_tables'.
type PgStatSysTable struct {
	Relid            pgtypes.NullOid `json:"relid"`               // relid
	Schemaname       sql.NullString  `json:"schemaname"`          // schemaname
	Relname          sql.NullString  `json:"relname"`             // relname
	SeqScan          sql.NullInt64   `json:"seq_scan"`            // seq_scan
	SeqTupRead       sql.NullInt64   `json:"seq_tup_read"`        // seq_tup_read
	IdxScan          sql.NullInt64   `json:"idx_scan"`            // idx_scan
	IdxTupFetch      sql.NullInt64   `json:"idx_tup_fetch"`       // idx_tup_fetch
	NTupIns          sql.NullInt64   `json:"n_tup_ins"`           // n_tup_ins
	NTupUpd          sql.NullInt64   `json:"n_tup_upd"`           // n_tup_upd
	NTupDel          sql.NullInt64   `json:"n_tup_del"`           // n_tup_del
	NTupHotUpd       sql.NullInt64   `json:"n_tup_hot_upd"`       // n_tup_hot_upd
	NLiveTup         sql.NullInt64   `json:"n_live_tup"`          // n_live_tup
	NDeadTup         sql.NullInt64   `json:"n_dead_tup"`          // n_dead_tup
	NModSinceAnalyze sql.NullInt64   `json:"n_mod_since_analyze"` // n_mod_since_analyze
	NInsSinceVacuum  sql.NullInt64   `json:"n_ins_since_vacuum"`  // n_ins_since_vacuum
	LastVacuum       sql.NullTime    `json:"last_vacuum"`         // last_vacuum
	LastAutovacuum   sql.NullTime    `json:"last_autovacuum"`     // last_autovacuum
	LastAnalyze      sql.NullTime    `json:"last_analyze"`        // last_analyze
	LastAutoanalyze  sql.NullTime    `json:"last_autoanalyze"`    // last_autoanalyze
	VacuumCount      sql.NullInt64   `json:"vacuum_count"`        // vacuum_count
	AutovacuumCount  sql.NullInt64   `json:"autovacuum_count"`    // autovacuum_count
	AnalyzeCount     sql.NullInt64   `json:"analyze_count"`       // analyze_count
	AutoanalyzeCount sql.NullInt64   `json:"autoanalyze_count"`   // autoanalyze_count
}

// PgStatUserFunction represents a row from 'pg_catalog.pg_stat_user_functions'.
type PgStatUserFunction struct {
	Funcid     pgtypes.NullOid `json:"funcid"`     // funcid
	Schemaname sql.NullString  `json:"schemaname"` // schemaname
	Funcname   sql.NullString  `json:"funcname"`   // funcname
	Calls      sql.NullInt64   `json:"calls"`      // calls
	TotalTime  sql.NullFloat64 `json:"total_time"` // total_time
	SelfTime   sql.NullFloat64 `json:"self_time"`  // self_time
}

// PgStatUserIndex represents a row from 'pg_catalog.pg_stat_user_indexes'.
type PgStatUserIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxScan      sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupRead   sql.NullInt64   `json:"idx_tup_read"`  // idx_tup_read
	IdxTupFetch  sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
}

// PgStatUserTable represents a row from 'pg_catalog.pg_stat_user_tables'.
type PgStatUserTable struct {
	Relid            pgtypes.NullOid `json:"relid"`               // relid
	Schemaname       sql.NullString  `json:"schemaname"`          // schemaname
	Relname          sql.NullString  `json:"relname"`             // relname
	SeqScan          sql.NullInt64   `json:"seq_scan"`            // seq_scan
	SeqTupRead       sql.NullInt64   `json:"seq_tup_read"`        // seq_tup_read
	IdxScan          sql.NullInt64   `json:"idx_scan"`            // idx_scan
	IdxTupFetch      sql.NullInt64   `json:"idx_tup_fetch"`       // idx_tup_fetch
	NTupIns          sql.NullInt64   `json:"n_tup_ins"`           // n_tup_ins
	NTupUpd          sql.NullInt64   `json:"n_tup_upd"`           // n_tup_upd
	NTupDel          sql.NullInt64   `json:"n_tup_del"`           // n_tup_del
	NTupHotUpd       sql.NullInt64   `json:"n_tup_hot_upd"`       // n_tup_hot_upd
	NLiveTup         sql.NullInt64   `json:"n_live_tup"`          // n_live_tup
	NDeadTup         sql.NullInt64   `json:"n_dead_tup"`          // n_dead_tup
	NModSinceAnalyze sql.NullInt64   `json:"n_mod_since_analyze"` // n_mod_since_analyze
	NInsSinceVacuum  sql.NullInt64   `json:"n_ins_since_vacuum"`  // n_ins_since_vacuum
	LastVacuum       sql.NullTime    `json:"last_vacuum"`         // last_vacuum
	LastAutovacuum   sql.NullTime    `json:"last_autovacuum"`     // last_autovacuum
	LastAnalyze      sql.NullTime    `json:"last_analyze"`        // last_analyze
	LastAutoanalyze  sql.NullTime    `json:"last_autoanalyze"`    // last_autoanalyze
	VacuumCount      sql.NullInt64   `json:"vacuum_count"`        // vacuum_count
	AutovacuumCount  sql.NullInt64   `json:"autovacuum_count"`    // autovacuum_count
	AnalyzeCount     sql.NullInt64   `json:"analyze_count"`       // analyze_count
	AutoanalyzeCount sql.NullInt64   `json:"autoanalyze_count"`   // autoanalyze_count
}

// PgStatWalReceiver represents a row from 'pg_catalog.pg_stat_wal_receiver'.
type PgStatWalReceiver struct {
	Pid                sql.NullInt64     `json:"pid"`                   // pid
	Status             sql.NullString    `json:"status"`                // status
	ReceiveStartLsn    pgtypes.NullPgLsn `json:"receive_start_lsn"`     // receive_start_lsn
	ReceiveStartTli    sql.NullInt64     `json:"receive_start_tli"`     // receive_start_tli
	WrittenLsn         pgtypes.NullPgLsn `json:"written_lsn"`           // written_lsn
	FlushedLsn         pgtypes.NullPgLsn `json:"flushed_lsn"`           // flushed_lsn
	ReceivedTli        sql.NullInt64     `json:"received_tli"`          // received_tli
	LastMsgSendTime    sql.NullTime      `json:"last_msg_send_time"`    // last_msg_send_time
	LastMsgReceiptTime sql.NullTime      `json:"last_msg_receipt_time"` // last_msg_receipt_time
	LatestEndLsn       pgtypes.NullPgLsn `json:"latest_end_lsn"`        // latest_end_lsn
	LatestEndTime      sql.NullTime      `json:"latest_end_time"`       // latest_end_time
	SlotName           sql.NullString    `json:"slot_name"`             // slot_name
	SenderHost         sql.NullString    `json:"sender_host"`           // sender_host
	SenderPort         sql.NullInt64     `json:"sender_port"`           // sender_port
	Conninfo           sql.NullString    `json:"conninfo"`              // conninfo
}

// PgStatXactAllTable represents a row from 'pg_catalog.pg_stat_xact_all_tables'.
type PgStatXactAllTable struct {
	Relid       pgtypes.NullOid `json:"relid"`         // relid
	Schemaname  sql.NullString  `json:"schemaname"`    // schemaname
	Relname     sql.NullString  `json:"relname"`       // relname
	SeqScan     sql.NullInt64   `json:"seq_scan"`      // seq_scan
	SeqTupRead  sql.NullInt64   `json:"seq_tup_read"`  // seq_tup_read
	IdxScan     sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupFetch sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
	NTupIns     sql.NullInt64   `json:"n_tup_ins"`     // n_tup_ins
	NTupUpd     sql.NullInt64   `json:"n_tup_upd"`     // n_tup_upd
	NTupDel     sql.NullInt64   `json:"n_tup_del"`     // n_tup_del
	NTupHotUpd  sql.NullInt64   `json:"n_tup_hot_upd"` // n_tup_hot_upd
}

// PgStatXactSysTable represents a row from 'pg_catalog.pg_stat_xact_sys_tables'.
type PgStatXactSysTable struct {
	Relid       pgtypes.NullOid `json:"relid"`         // relid
	Schemaname  sql.NullString  `json:"schemaname"`    // schemaname
	Relname     sql.NullString  `json:"relname"`       // relname
	SeqScan     sql.NullInt64   `json:"seq_scan"`      // seq_scan
	SeqTupRead  sql.NullInt64   `json:"seq_tup_read"`  // seq_tup_read
	IdxScan     sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupFetch sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
	NTupIns     sql.NullInt64   `json:"n_tup_ins"`     // n_tup_ins
	NTupUpd     sql.NullInt64   `json:"n_tup_upd"`     // n_tup_upd
	NTupDel     sql.NullInt64   `json:"n_tup_del"`     // n_tup_del
	NTupHotUpd  sql.NullInt64   `json:"n_tup_hot_upd"` // n_tup_hot_upd
}

// PgStatXactUserFunction represents a row from 'pg_catalog.pg_stat_xact_user_functions'.
type PgStatXactUserFunction struct {
	Funcid     pgtypes.NullOid `json:"funcid"`     // funcid
	Schemaname sql.NullString  `json:"schemaname"` // schemaname
	Funcname   sql.NullString  `json:"funcname"`   // funcname
	Calls      sql.NullInt64   `json:"calls"`      // calls
	TotalTime  sql.NullFloat64 `json:"total_time"` // total_time
	SelfTime   sql.NullFloat64 `json:"self_time"`  // self_time
}

// PgStatXactUserTable represents a row from 'pg_catalog.pg_stat_xact_user_tables'.
type PgStatXactUserTable struct {
	Relid       pgtypes.NullOid `json:"relid"`         // relid
	Schemaname  sql.NullString  `json:"schemaname"`    // schemaname
	Relname     sql.NullString  `json:"relname"`       // relname
	SeqScan     sql.NullInt64   `json:"seq_scan"`      // seq_scan
	SeqTupRead  sql.NullInt64   `json:"seq_tup_read"`  // seq_tup_read
	IdxScan     sql.NullInt64   `json:"idx_scan"`      // idx_scan
	IdxTupFetch sql.NullInt64   `json:"idx_tup_fetch"` // idx_tup_fetch
	NTupIns     sql.NullInt64   `json:"n_tup_ins"`     // n_tup_ins
	NTupUpd     sql.NullInt64   `json:"n_tup_upd"`     // n_tup_upd
	NTupDel     sql.NullInt64   `json:"n_tup_del"`     // n_tup_del
	NTupHotUpd  sql.NullInt64   `json:"n_tup_hot_upd"` // n_tup_hot_upd
}

// PgStatioAllIndex represents a row from 'pg_catalog.pg_statio_all_indexes'.
type PgStatioAllIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxBlksRead  sql.NullInt64   `json:"idx_blks_read"` // idx_blks_read
	IdxBlksHit   sql.NullInt64   `json:"idx_blks_hit"`  // idx_blks_hit
}

// PgStatioAllSequence represents a row from 'pg_catalog.pg_statio_all_sequences'.
type PgStatioAllSequence struct {
	Relid      pgtypes.NullOid `json:"relid"`      // relid
	Schemaname sql.NullString  `json:"schemaname"` // schemaname
	Relname    sql.NullString  `json:"relname"`    // relname
	BlksRead   sql.NullInt64   `json:"blks_read"`  // blks_read
	BlksHit    sql.NullInt64   `json:"blks_hit"`   // blks_hit
}

// PgStatioAllTable represents a row from 'pg_catalog.pg_statio_all_tables'.
type PgStatioAllTable struct {
	Relid         pgtypes.NullOid `json:"relid"`           // relid
	Schemaname    sql.NullString  `json:"schemaname"`      // schemaname
	Relname       sql.NullString  `json:"relname"`         // relname
	HeapBlksRead  sql.NullInt64   `json:"heap_blks_read"`  // heap_blks_read
	HeapBlksHit   sql.NullInt64   `json:"heap_blks_hit"`   // heap_blks_hit
	IdxBlksRead   sql.NullInt64   `json:"idx_blks_read"`   // idx_blks_read
	IdxBlksHit    sql.NullInt64   `json:"idx_blks_hit"`    // idx_blks_hit
	ToastBlksRead sql.NullInt64   `json:"toast_blks_read"` // toast_blks_read
	ToastBlksHit  sql.NullInt64   `json:"toast_blks_hit"`  // toast_blks_hit
	TidxBlksRead  sql.NullInt64   `json:"tidx_blks_read"`  // tidx_blks_read
	TidxBlksHit   sql.NullInt64   `json:"tidx_blks_hit"`   // tidx_blks_hit
}

// PgStatioSysIndex represents a row from 'pg_catalog.pg_statio_sys_indexes'.
type PgStatioSysIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxBlksRead  sql.NullInt64   `json:"idx_blks_read"` // idx_blks_read
	IdxBlksHit   sql.NullInt64   `json:"idx_blks_hit"`  // idx_blks_hit
}

// PgStatioSysSequence represents a row from 'pg_catalog.pg_statio_sys_sequences'.
type PgStatioSysSequence struct {
	Relid      pgtypes.NullOid `json:"relid"`      // relid
	Schemaname sql.NullString  `json:"schemaname"` // schemaname
	Relname    sql.NullString  `json:"relname"`    // relname
	BlksRead   sql.NullInt64   `json:"blks_read"`  // blks_read
	BlksHit    sql.NullInt64   `json:"blks_hit"`   // blks_hit
}

// PgStatioSysTable represents a row from 'pg_catalog.pg_statio_sys_tables'.
type PgStatioSysTable struct {
	Relid         pgtypes.NullOid `json:"relid"`           // relid
	Schemaname    sql.NullString  `json:"schemaname"`      // schemaname
	Relname       sql.NullString  `json:"relname"`         // relname
	HeapBlksRead  sql.NullInt64   `json:"heap_blks_read"`  // heap_blks_read
	HeapBlksHit   sql.NullInt64   `json:"heap_blks_hit"`   // heap_blks_hit
	IdxBlksRead   sql.NullInt64   `json:"idx_blks_read"`   // idx_blks_read
	IdxBlksHit    sql.NullInt64   `json:"idx_blks_hit"`    // idx_blks_hit
	ToastBlksRead sql.NullInt64   `json:"toast_blks_read"` // toast_blks_read
	ToastBlksHit  sql.NullInt64   `json:"toast_blks_hit"`  // toast_blks_hit
	TidxBlksRead  sql.NullInt64   `json:"tidx_blks_read"`  // tidx_blks_read
	TidxBlksHit   sql.NullInt64   `json:"tidx_blks_hit"`   // tidx_blks_hit
}

// PgStatioUserIndex represents a row from 'pg_catalog.pg_statio_user_indexes'.
type PgStatioUserIndex struct {
	Relid        pgtypes.NullOid `json:"relid"`         // relid
	Indexrelid   pgtypes.NullOid `json:"indexrelid"`    // indexrelid
	Schemaname   sql.NullString  `json:"schemaname"`    // schemaname
	Relname      sql.NullString  `json:"relname"`       // relname
	Indexrelname sql.NullString  `json:"indexrelname"`  // indexrelname
	IdxBlksRead  sql.NullInt64   `json:"idx_blks_read"` // idx_blks_read
	IdxBlksHit   sql.NullInt64   `json:"idx_blks_hit"`  // idx_blks_hit
}

// PgStatioUserSequence represents a row from 'pg_catalog.pg_statio_user_sequences'.
type PgStatioUserSequence struct {
	Relid      pgtypes.NullOid `json:"relid"`      // relid
	Schemaname sql.NullString  `json:"schemaname"` // schemaname
	Relname    sql.NullString  `json:"relname"`    // relname
	BlksRead   sql.NullInt64   `json:"blks_read"`  // blks_read
	BlksHit    sql.NullInt64   `json:"blks_hit"`   // blks_hit
}

// PgStatioUserTable represents a row from 'pg_catalog.pg_statio_user_tables'.
type PgStatioUserTable struct {
	Relid         pgtypes.NullOid `json:"relid"`           // relid
	Schemaname    sql.NullString  `json:"schemaname"`      // schemaname
	Relname       sql.NullString  `json:"relname"`         // relname
	HeapBlksRead  sql.NullInt64   `json:"heap_blks_read"`  // heap_blks_read
	HeapBlksHit   sql.NullInt64   `json:"heap_blks_hit"`   // heap_blks_hit
	IdxBlksRead   sql.NullInt64   `json:"idx_blks_read"`   // idx_blks_read
	IdxBlksHit    sql.NullInt64   `json:"idx_blks_hit"`    // idx_blks_hit
	ToastBlksRead sql.NullInt64   `json:"toast_blks_read"` // toast_blks_read
	ToastBlksHit  sql.NullInt64   `json:"toast_blks_hit"`  // toast_blks_hit
	TidxBlksRead  sql.NullInt64   `json:"tidx_blks_read"`  // tidx_blks_read
	TidxBlksHit   sql.NullInt64   `json:"tidx_blks_hit"`   // tidx_blks_hit
}

// PgStatistic represents a row from 'pg_catalog.pg_statistic'.
type PgStatistic struct {
	Tableoid    pgtypes.Oid          `json:"tableoid"`    // tableoid
	Cmax        pgtypes.Cid          `json:"cmax"`        // cmax
	Xmax        pgtypes.Xid          `json:"xmax"`        // xmax
	Cmin        pgtypes.Cid          `json:"cmin"`        // cmin
	Xmin        pgtypes.Xid          `json:"xmin"`        // xmin
	Ctid        pgtypes.Tid          `json:"ctid"`        // ctid
	Starelid    pgtypes.Oid          `json:"starelid"`    // starelid
	Staattnum   int16                `json:"staattnum"`   // staattnum
	Stainherit  bool                 `json:"stainherit"`  // stainherit
	Stanullfrac float32              `json:"stanullfrac"` // stanullfrac
	Stawidth    int                  `json:"stawidth"`    // stawidth
	Stadistinct float32              `json:"stadistinct"` // stadistinct
	Stakind1    int16                `json:"stakind1"`    // stakind1
	Stakind2    int16                `json:"stakind2"`    // stakind2
	Stakind3    int16                `json:"stakind3"`    // stakind3
	Stakind4    int16                `json:"stakind4"`    // stakind4
	Stakind5    int16                `json:"stakind5"`    // stakind5
	Staop1      pgtypes.Oid          `json:"staop1"`      // staop1
	Staop2      pgtypes.Oid          `json:"staop2"`      // staop2
	Staop3      pgtypes.Oid          `json:"staop3"`      // staop3
	Staop4      pgtypes.Oid          `json:"staop4"`      // staop4
	Staop5      pgtypes.Oid          `json:"staop5"`      // staop5
	Stacoll1    pgtypes.Oid          `json:"stacoll1"`    // stacoll1
	Stacoll2    pgtypes.Oid          `json:"stacoll2"`    // stacoll2
	Stacoll3    pgtypes.Oid          `json:"stacoll3"`    // stacoll3
	Stacoll4    pgtypes.Oid          `json:"stacoll4"`    // stacoll4
	Stacoll5    pgtypes.Oid          `json:"stacoll5"`    // stacoll5
	Stanumbers1 []sql.NullFloat64    `json:"stanumbers1"` // stanumbers1
	Stanumbers2 []sql.NullFloat64    `json:"stanumbers2"` // stanumbers2
	Stanumbers3 []sql.NullFloat64    `json:"stanumbers3"` // stanumbers3
	Stanumbers4 []sql.NullFloat64    `json:"stanumbers4"` // stanumbers4
	Stanumbers5 []sql.NullFloat64    `json:"stanumbers5"` // stanumbers5
	Stavalues1  pgtypes.NullAnyarray `json:"stavalues1"`  // stavalues1
	Stavalues2  pgtypes.NullAnyarray `json:"stavalues2"`  // stavalues2
	Stavalues3  pgtypes.NullAnyarray `json:"stavalues3"`  // stavalues3
	Stavalues4  pgtypes.NullAnyarray `json:"stavalues4"`  // stavalues4
	Stavalues5  pgtypes.NullAnyarray `json:"stavalues5"`  // stavalues5
}

// PgStatisticExt represents a row from 'pg_catalog.pg_statistic_ext'.
type PgStatisticExt struct {
	Tableoid      pgtypes.Oid        `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid        `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid        `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid        `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid        `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid        `json:"ctid"`          // ctid
	Oid           pgtypes.Oid        `json:"oid"`           // oid
	Stxrelid      pgtypes.Oid        `json:"stxrelid"`      // stxrelid
	Stxname       string             `json:"stxname"`       // stxname
	Stxnamespace  pgtypes.Oid        `json:"stxnamespace"`  // stxnamespace
	Stxowner      pgtypes.Oid        `json:"stxowner"`      // stxowner
	Stxstattarget int                `json:"stxstattarget"` // stxstattarget
	Stxkeys       pgtypes.Int2vector `json:"stxkeys"`       // stxkeys
	Stxkind       []pgtypes.Char     `json:"stxkind"`       // stxkind
}

// PgStatisticExtDatum represents a row from 'pg_catalog.pg_statistic_ext_data'.
type PgStatisticExtDatum struct {
	Tableoid         pgtypes.Oid                `json:"tableoid"`         // tableoid
	Cmax             pgtypes.Cid                `json:"cmax"`             // cmax
	Xmax             pgtypes.Xid                `json:"xmax"`             // xmax
	Cmin             pgtypes.Cid                `json:"cmin"`             // cmin
	Xmin             pgtypes.Xid                `json:"xmin"`             // xmin
	Ctid             pgtypes.Tid                `json:"ctid"`             // ctid
	Stxoid           pgtypes.Oid                `json:"stxoid"`           // stxoid
	Stxdndistinct    pgtypes.NullPgNdistinct    `json:"stxdndistinct"`    // stxdndistinct
	Stxddependencies pgtypes.NullPgDependencies `json:"stxddependencies"` // stxddependencies
	Stxdmcv          pgtypes.NullPgMcvList      `json:"stxdmcv"`          // stxdmcv
}

// PgStatsExt represents a row from 'pg_catalog.pg_stats_ext'.
type PgStatsExt struct {
	Schemaname           sql.NullString             `json:"schemaname"`             // schemaname
	Tablename            sql.NullString             `json:"tablename"`              // tablename
	StatisticsSchemaname sql.NullString             `json:"statistics_schemaname"`  // statistics_schemaname
	StatisticsName       sql.NullString             `json:"statistics_name"`        // statistics_name
	StatisticsOwner      sql.NullString             `json:"statistics_owner"`       // statistics_owner
	Attnames             []sql.NullString           `json:"attnames"`               // attnames
	Kinds                []pgtypes.NullChar         `json:"kinds"`                  // kinds
	NDistinct            pgtypes.NullPgNdistinct    `json:"n_distinct"`             // n_distinct
	Dependencies         pgtypes.NullPgDependencies `json:"dependencies"`           // dependencies
	MostCommonVals       []sql.NullString           `json:"most_common_vals"`       // most_common_vals
	MostCommonValNulls   []sql.NullBool             `json:"most_common_val_nulls"`  // most_common_val_nulls
	MostCommonFreqs      []sql.NullFloat64          `json:"most_common_freqs"`      // most_common_freqs
	MostCommonBaseFreqs  []sql.NullFloat64          `json:"most_common_base_freqs"` // most_common_base_freqs
}

// PgSubscription represents a row from 'pg_catalog.pg_subscription'.
type PgSubscription struct {
	Tableoid        pgtypes.Oid    `json:"tableoid"`        // tableoid
	Cmax            pgtypes.Cid    `json:"cmax"`            // cmax
	Xmax            pgtypes.Xid    `json:"xmax"`            // xmax
	Cmin            pgtypes.Cid    `json:"cmin"`            // cmin
	Xmin            pgtypes.Xid    `json:"xmin"`            // xmin
	Ctid            pgtypes.Tid    `json:"ctid"`            // ctid
	Oid             pgtypes.Oid    `json:"oid"`             // oid
	Subdbid         pgtypes.Oid    `json:"subdbid"`         // subdbid
	Subname         string         `json:"subname"`         // subname
	Subowner        pgtypes.Oid    `json:"subowner"`        // subowner
	Subenabled      bool           `json:"subenabled"`      // subenabled
	Subconninfo     string         `json:"subconninfo"`     // subconninfo
	Subslotname     sql.NullString `json:"subslotname"`     // subslotname
	Subsynccommit   string         `json:"subsynccommit"`   // subsynccommit
	Subpublications StringSlice    `json:"subpublications"` // subpublications
}

// PgSubscriptionRel represents a row from 'pg_catalog.pg_subscription_rel'.
type PgSubscriptionRel struct {
	Tableoid   pgtypes.Oid       `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid       `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid       `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid       `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid       `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid       `json:"ctid"`       // ctid
	Srsubid    pgtypes.Oid       `json:"srsubid"`    // srsubid
	Srrelid    pgtypes.Oid       `json:"srrelid"`    // srrelid
	Srsubstate pgtypes.Char      `json:"srsubstate"` // srsubstate
	Srsublsn   pgtypes.NullPgLsn `json:"srsublsn"`   // srsublsn
}

// PgTable represents a row from 'pg_catalog.pg_tables'.
type PgTable struct {
	Schemaname  sql.NullString `json:"schemaname"`  // schemaname
	Tablename   sql.NullString `json:"tablename"`   // tablename
	Tableowner  sql.NullString `json:"tableowner"`  // tableowner
	Tablespace  sql.NullString `json:"tablespace"`  // tablespace
	Hasindexes  sql.NullBool   `json:"hasindexes"`  // hasindexes
	Hasrules    sql.NullBool   `json:"hasrules"`    // hasrules
	Hastriggers sql.NullBool   `json:"hastriggers"` // hastriggers
	Rowsecurity sql.NullBool   `json:"rowsecurity"` // rowsecurity
}

// PgTablespace represents a row from 'pg_catalog.pg_tablespace'.
type PgTablespace struct {
	Tableoid   pgtypes.Oid           `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid           `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid           `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid           `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid           `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid           `json:"ctid"`       // ctid
	Oid        pgtypes.Oid           `json:"oid"`        // oid
	Spcname    string                `json:"spcname"`    // spcname
	Spcowner   pgtypes.Oid           `json:"spcowner"`   // spcowner
	Spcacl     []pgtypes.NullAclitem `json:"spcacl"`     // spcacl
	Spcoptions []sql.NullString      `json:"spcoptions"` // spcoptions
}

// PgTimezoneAbbrev represents a row from 'pg_catalog.pg_timezone_abbrevs'.
type PgTimezoneAbbrev struct {
	Abbrev    sql.NullString `json:"abbrev"`     // abbrev
	UTCOffset []byte         `json:"utc_offset"` // utc_offset
	IsDst     sql.NullBool   `json:"is_dst"`     // is_dst
}

// PgTimezoneName represents a row from 'pg_catalog.pg_timezone_names'.
type PgTimezoneName struct {
	Name      sql.NullString `json:"name"`       // name
	Abbrev    sql.NullString `json:"abbrev"`     // abbrev
	UTCOffset []byte         `json:"utc_offset"` // utc_offset
	IsDst     sql.NullBool   `json:"is_dst"`     // is_dst
}

// PgTransform represents a row from 'pg_catalog.pg_transform'.
type PgTransform struct {
	Tableoid   pgtypes.Oid     `json:"tableoid"`   // tableoid
	Cmax       pgtypes.Cid     `json:"cmax"`       // cmax
	Xmax       pgtypes.Xid     `json:"xmax"`       // xmax
	Cmin       pgtypes.Cid     `json:"cmin"`       // cmin
	Xmin       pgtypes.Xid     `json:"xmin"`       // xmin
	Ctid       pgtypes.Tid     `json:"ctid"`       // ctid
	Oid        pgtypes.Oid     `json:"oid"`        // oid
	Trftype    pgtypes.Oid     `json:"trftype"`    // trftype
	Trflang    pgtypes.Oid     `json:"trflang"`    // trflang
	Trffromsql pgtypes.Regproc `json:"trffromsql"` // trffromsql
	Trftosql   pgtypes.Regproc `json:"trftosql"`   // trftosql
}

// PgTrigger represents a row from 'pg_catalog.pg_trigger'.
type PgTrigger struct {
	Tableoid       pgtypes.Oid            `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid            `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid            `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid            `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid            `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid            `json:"ctid"`           // ctid
	Oid            pgtypes.Oid            `json:"oid"`            // oid
	Tgrelid        pgtypes.Oid            `json:"tgrelid"`        // tgrelid
	Tgparentid     pgtypes.Oid            `json:"tgparentid"`     // tgparentid
	Tgname         string                 `json:"tgname"`         // tgname
	Tgfoid         pgtypes.Oid            `json:"tgfoid"`         // tgfoid
	Tgtype         int16                  `json:"tgtype"`         // tgtype
	Tgenabled      pgtypes.Char           `json:"tgenabled"`      // tgenabled
	Tgisinternal   bool                   `json:"tgisinternal"`   // tgisinternal
	Tgconstrrelid  pgtypes.Oid            `json:"tgconstrrelid"`  // tgconstrrelid
	Tgconstrindid  pgtypes.Oid            `json:"tgconstrindid"`  // tgconstrindid
	Tgconstraint   pgtypes.Oid            `json:"tgconstraint"`   // tgconstraint
	Tgdeferrable   bool                   `json:"tgdeferrable"`   // tgdeferrable
	Tginitdeferred bool                   `json:"tginitdeferred"` // tginitdeferred
	Tgnargs        int16                  `json:"tgnargs"`        // tgnargs
	Tgattr         pgtypes.Int2vector     `json:"tgattr"`         // tgattr
	Tgargs         []byte                 `json:"tgargs"`         // tgargs
	Tgqual         pgtypes.NullPgNodeTree `json:"tgqual"`         // tgqual
	Tgoldtable     sql.NullString         `json:"tgoldtable"`     // tgoldtable
	Tgnewtable     sql.NullString         `json:"tgnewtable"`     // tgnewtable
}

// PgTsConfig represents a row from 'pg_catalog.pg_ts_config'.
type PgTsConfig struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Oid          pgtypes.Oid `json:"oid"`          // oid
	Cfgname      string      `json:"cfgname"`      // cfgname
	Cfgnamespace pgtypes.Oid `json:"cfgnamespace"` // cfgnamespace
	Cfgowner     pgtypes.Oid `json:"cfgowner"`     // cfgowner
	Cfgparser    pgtypes.Oid `json:"cfgparser"`    // cfgparser
}

// PgTsConfigMap represents a row from 'pg_catalog.pg_ts_config_map'.
type PgTsConfigMap struct {
	Tableoid     pgtypes.Oid `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid `json:"ctid"`         // ctid
	Mapcfg       pgtypes.Oid `json:"mapcfg"`       // mapcfg
	Maptokentype int         `json:"maptokentype"` // maptokentype
	Mapseqno     int         `json:"mapseqno"`     // mapseqno
	Mapdict      pgtypes.Oid `json:"mapdict"`      // mapdict
}

// PgTsDict represents a row from 'pg_catalog.pg_ts_dict'.
type PgTsDict struct {
	Tableoid       pgtypes.Oid    `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid    `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid    `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid    `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid    `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid    `json:"ctid"`           // ctid
	Oid            pgtypes.Oid    `json:"oid"`            // oid
	Dictname       string         `json:"dictname"`       // dictname
	Dictnamespace  pgtypes.Oid    `json:"dictnamespace"`  // dictnamespace
	Dictowner      pgtypes.Oid    `json:"dictowner"`      // dictowner
	Dicttemplate   pgtypes.Oid    `json:"dicttemplate"`   // dicttemplate
	Dictinitoption sql.NullString `json:"dictinitoption"` // dictinitoption
}

// PgTsParser represents a row from 'pg_catalog.pg_ts_parser'.
type PgTsParser struct {
	Tableoid     pgtypes.Oid     `json:"tableoid"`     // tableoid
	Cmax         pgtypes.Cid     `json:"cmax"`         // cmax
	Xmax         pgtypes.Xid     `json:"xmax"`         // xmax
	Cmin         pgtypes.Cid     `json:"cmin"`         // cmin
	Xmin         pgtypes.Xid     `json:"xmin"`         // xmin
	Ctid         pgtypes.Tid     `json:"ctid"`         // ctid
	Oid          pgtypes.Oid     `json:"oid"`          // oid
	Prsname      string          `json:"prsname"`      // prsname
	Prsnamespace pgtypes.Oid     `json:"prsnamespace"` // prsnamespace
	Prsstart     pgtypes.Regproc `json:"prsstart"`     // prsstart
	Prstoken     pgtypes.Regproc `json:"prstoken"`     // prstoken
	Prsend       pgtypes.Regproc `json:"prsend"`       // prsend
	Prsheadline  pgtypes.Regproc `json:"prsheadline"`  // prsheadline
	Prslextype   pgtypes.Regproc `json:"prslextype"`   // prslextype
}

// PgTsTemplate represents a row from 'pg_catalog.pg_ts_template'.
type PgTsTemplate struct {
	Tableoid      pgtypes.Oid     `json:"tableoid"`      // tableoid
	Cmax          pgtypes.Cid     `json:"cmax"`          // cmax
	Xmax          pgtypes.Xid     `json:"xmax"`          // xmax
	Cmin          pgtypes.Cid     `json:"cmin"`          // cmin
	Xmin          pgtypes.Xid     `json:"xmin"`          // xmin
	Ctid          pgtypes.Tid     `json:"ctid"`          // ctid
	Oid           pgtypes.Oid     `json:"oid"`           // oid
	Tmplname      string          `json:"tmplname"`      // tmplname
	Tmplnamespace pgtypes.Oid     `json:"tmplnamespace"` // tmplnamespace
	Tmplinit      pgtypes.Regproc `json:"tmplinit"`      // tmplinit
	Tmpllexize    pgtypes.Regproc `json:"tmpllexize"`    // tmpllexize
}

// PgType represents a row from 'pg_catalog.pg_type'.
type PgType struct {
	Tableoid       pgtypes.Oid            `json:"tableoid"`       // tableoid
	Cmax           pgtypes.Cid            `json:"cmax"`           // cmax
	Xmax           pgtypes.Xid            `json:"xmax"`           // xmax
	Cmin           pgtypes.Cid            `json:"cmin"`           // cmin
	Xmin           pgtypes.Xid            `json:"xmin"`           // xmin
	Ctid           pgtypes.Tid            `json:"ctid"`           // ctid
	Oid            pgtypes.Oid            `json:"oid"`            // oid
	Typname        string                 `json:"typname"`        // typname
	Typnamespace   pgtypes.Oid            `json:"typnamespace"`   // typnamespace
	Typowner       pgtypes.Oid            `json:"typowner"`       // typowner
	Typlen         int16                  `json:"typlen"`         // typlen
	Typbyval       bool                   `json:"typbyval"`       // typbyval
	Typtype        pgtypes.Char           `json:"typtype"`        // typtype
	Typcategory    pgtypes.Char           `json:"typcategory"`    // typcategory
	Typispreferred bool                   `json:"typispreferred"` // typispreferred
	Typisdefined   bool                   `json:"typisdefined"`   // typisdefined
	Typdelim       pgtypes.Char           `json:"typdelim"`       // typdelim
	Typrelid       pgtypes.Oid            `json:"typrelid"`       // typrelid
	Typelem        pgtypes.Oid            `json:"typelem"`        // typelem
	Typarray       pgtypes.Oid            `json:"typarray"`       // typarray
	Typinput       pgtypes.Regproc        `json:"typinput"`       // typinput
	Typoutput      pgtypes.Regproc        `json:"typoutput"`      // typoutput
	Typreceive     pgtypes.Regproc        `json:"typreceive"`     // typreceive
	Typsend        pgtypes.Regproc        `json:"typsend"`        // typsend
	Typmodin       pgtypes.Regproc        `json:"typmodin"`       // typmodin
	Typmodout      pgtypes.Regproc        `json:"typmodout"`      // typmodout
	Typanalyze     pgtypes.Regproc        `json:"typanalyze"`     // typanalyze
	Typalign       pgtypes.Char           `json:"typalign"`       // typalign
	Typstorage     pgtypes.Char           `json:"typstorage"`     // typstorage
	Typnotnull     bool                   `json:"typnotnull"`     // typnotnull
	Typbasetype    pgtypes.Oid            `json:"typbasetype"`    // typbasetype
	Typtypmod      int                    `json:"typtypmod"`      // typtypmod
	Typndims       int                    `json:"typndims"`       // typndims
	Typcollation   pgtypes.Oid            `json:"typcollation"`   // typcollation
	Typdefaultbin  pgtypes.NullPgNodeTree `json:"typdefaultbin"`  // typdefaultbin
	Typdefault     sql.NullString         `json:"typdefault"`     // typdefault
	Typacl         []pgtypes.NullAclitem  `json:"typacl"`         // typacl
}

// PgUser represents a row from 'pg_catalog.pg_user'.
type PgUser struct {
	Usename      sql.NullString   `json:"usename"`      // usename
	Usesysid     pgtypes.NullOid  `json:"usesysid"`     // usesysid
	Usecreatedb  sql.NullBool     `json:"usecreatedb"`  // usecreatedb
	Usesuper     sql.NullBool     `json:"usesuper"`     // usesuper
	Userepl      sql.NullBool     `json:"userepl"`      // userepl
	Usebypassrls sql.NullBool     `json:"usebypassrls"` // usebypassrls
	Passwd       sql.NullString   `json:"passwd"`       // passwd
	Valuntil     sql.NullTime     `json:"valuntil"`     // valuntil
	Useconfig    []sql.NullString `json:"useconfig"`    // useconfig
}

// PgUserMapping represents a row from 'pg_catalog.pg_user_mapping'.
type PgUserMapping struct {
	Tableoid  pgtypes.Oid      `json:"tableoid"`  // tableoid
	Cmax      pgtypes.Cid      `json:"cmax"`      // cmax
	Xmax      pgtypes.Xid      `json:"xmax"`      // xmax
	Cmin      pgtypes.Cid      `json:"cmin"`      // cmin
	Xmin      pgtypes.Xid      `json:"xmin"`      // xmin
	Ctid      pgtypes.Tid      `json:"ctid"`      // ctid
	Oid       pgtypes.Oid      `json:"oid"`       // oid
	Umuser    pgtypes.Oid      `json:"umuser"`    // umuser
	Umserver  pgtypes.Oid      `json:"umserver"`  // umserver
	Umoptions []sql.NullString `json:"umoptions"` // umoptions
}

// PgUserMapping represents a row from 'pg_catalog.pg_user_mappings'.
type PgUserMapping struct {
	Umid      pgtypes.NullOid  `json:"umid"`      // umid
	Srvid     pgtypes.NullOid  `json:"srvid"`     // srvid
	Srvname   sql.NullString   `json:"srvname"`   // srvname
	Umuser    pgtypes.NullOid  `json:"umuser"`    // umuser
	Usename   sql.NullString   `json:"usename"`   // usename
	Umoptions []sql.NullString `json:"umoptions"` // umoptions
}

// PgView represents a row from 'pg_catalog.pg_views'.
type PgView struct {
	Schemaname sql.NullString `json:"schemaname"` // schemaname
	Viewname   sql.NullString `json:"viewname"`   // viewname
	Viewowner  sql.NullString `json:"viewowner"`  // viewowner
	Definition sql.NullString `json:"definition"` // definition
}

// PgAggregateByAggfnoid retrieves a row from 'pg_catalog.pg_aggregate' as a PgAggregate.
//
// Generated from index 'pg_aggregate_fnoid_index'.
func PgAggregateByAggfnoid(ctx context.Context, db DB, aggfnoid pgtypes.Regproc) (*PgAggregate, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggcombinefn, aggserialfn, aggdeserialfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggfinalmodify, aggmfinalmodify, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval ` +
		`FROM pg_catalog.pg_aggregate ` +
		`WHERE aggfnoid = $1`
	// run
	logf(sqlstr, aggfnoid)
	pa := PgAggregate{}
	if err := db.QueryRowContext(ctx, sqlstr, aggfnoid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggcombinefn, &pa.Aggserialfn, &pa.Aggdeserialfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggfinalmodify, &pa.Aggmfinalmodify, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmByAmname retrieves a row from 'pg_catalog.pg_am' as a PgAm.
//
// Generated from index 'pg_am_name_index'.
func PgAmByAmname(ctx context.Context, db DB, amname string) (*PgAm, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amname, amhandler, amtype ` +
		`FROM pg_catalog.pg_am ` +
		`WHERE amname = $1`
	// run
	logf(sqlstr, amname)
	pa := PgAm{}
	if err := db.QueryRowContext(ctx, sqlstr, amname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amname, &pa.Amhandler, &pa.Amtype); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmByOid retrieves a row from 'pg_catalog.pg_am' as a PgAm.
//
// Generated from index 'pg_am_oid_index'.
func PgAmByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgAm, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amname, amhandler, amtype ` +
		`FROM pg_catalog.pg_am ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pa := PgAm{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amname, &pa.Amhandler, &pa.Amtype); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_fam_strat_index'.
func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(ctx context.Context, db DB, amopfamily, amoplefttype, amoprighttype pgtypes.Oid, amopstrategy int16) (*PgAmop, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
		`FROM pg_catalog.pg_amop ` +
		`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`
	// run
	logf(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy)
	pa := PgAmop{}
	if err := db.QueryRowContext(ctx, sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmopByOid retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_oid_index'.
func PgAmopByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgAmop, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
		`FROM pg_catalog.pg_amop ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pa := PgAmop{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmopByAmopoprAmoppurposeAmopfamily retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_opr_fam_index'.
func PgAmopByAmopoprAmoppurposeAmopfamily(ctx context.Context, db DB, amopopr pgtypes.Oid, amoppurpose pgtypes.Char, amopfamily pgtypes.Oid) (*PgAmop, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
		`FROM pg_catalog.pg_amop ` +
		`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`
	// run
	logf(sqlstr, amopopr, amoppurpose, amopfamily)
	pa := PgAmop{}
	if err := db.QueryRowContext(ctx, sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_fam_proc_index'.
func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(ctx context.Context, db DB, amprocfamily, amproclefttype, amprocrighttype pgtypes.Oid, amprocnum int16) (*PgAmproc, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
		`FROM pg_catalog.pg_amproc ` +
		`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`
	// run
	logf(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum)
	pa := PgAmproc{}
	if err := db.QueryRowContext(ctx, sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAmprocByOid retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_oid_index'.
func PgAmprocByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgAmproc, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
		`FROM pg_catalog.pg_amproc ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pa := PgAmproc{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAttrdefByAdrelidAdnum retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_adrelid_adnum_index'.
func PgAttrdefByAdrelidAdnum(ctx context.Context, db DB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, adrelid, adnum, adbin ` +
		`FROM pg_catalog.pg_attrdef ` +
		`WHERE adrelid = $1 AND adnum = $2`
	// run
	logf(sqlstr, adrelid, adnum)
	pa := PgAttrdef{}
	if err := db.QueryRowContext(ctx, sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Adrelid, &pa.Adnum, &pa.Adbin); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAttrdefByOid retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_oid_index'.
func PgAttrdefByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgAttrdef, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, adrelid, adnum, adbin ` +
		`FROM pg_catalog.pg_attrdef ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pa := PgAttrdef{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Adrelid, &pa.Adnum, &pa.Adbin); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAttributeByAttrelidAttname retrieves a row from 'pg_catalog.pg_attribute' as a PgAttribute.
//
// Generated from index 'pg_attribute_relid_attnam_index'.
func PgAttributeByAttrelidAttname(ctx context.Context, db DB, attrelid pgtypes.Oid, attname string) (*PgAttribute, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, atthasmissing, attidentity, attgenerated, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions, attmissingval ` +
		`FROM pg_catalog.pg_attribute ` +
		`WHERE attrelid = $1 AND attname = $2`
	// run
	logf(sqlstr, attrelid, attname)
	pa := PgAttribute{}
	if err := db.QueryRowContext(ctx, sqlstr, attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Atthasmissing, &pa.Attidentity, &pa.Attgenerated, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions, &pa.Attmissingval); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAttributeByAttrelidAttnum retrieves a row from 'pg_catalog.pg_attribute' as a PgAttribute.
//
// Generated from index 'pg_attribute_relid_attnum_index'.
func PgAttributeByAttrelidAttnum(ctx context.Context, db DB, attrelid pgtypes.Oid, attnum int16) (*PgAttribute, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, atthasmissing, attidentity, attgenerated, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions, attmissingval ` +
		`FROM pg_catalog.pg_attribute ` +
		`WHERE attrelid = $1 AND attnum = $2`
	// run
	logf(sqlstr, attrelid, attnum)
	pa := PgAttribute{}
	if err := db.QueryRowContext(ctx, sqlstr, attrelid, attnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Atthasmissing, &pa.Attidentity, &pa.Attgenerated, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions, &pa.Attmissingval); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAuthMemberByMemberRoleid retrieves a row from 'pg_catalog.pg_auth_members' as a PgAuthMember.
//
// Generated from index 'pg_auth_members_member_role_index'.
func PgAuthMemberByMemberRoleid(ctx context.Context, db DB, member, roleid pgtypes.Oid) (*PgAuthMember, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
		`FROM pg_catalog.pg_auth_members ` +
		`WHERE member = $1 AND roleid = $2`
	// run
	logf(sqlstr, member, roleid)
	pam := PgAuthMember{}
	if err := db.QueryRowContext(ctx, sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption); err != nil {
		return nil, logerror(err)
	}
	return &pam, nil
}

// PgAuthMemberByRoleidMember retrieves a row from 'pg_catalog.pg_auth_members' as a PgAuthMember.
//
// Generated from index 'pg_auth_members_role_member_index'.
func PgAuthMemberByRoleidMember(ctx context.Context, db DB, roleid, member pgtypes.Oid) (*PgAuthMember, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
		`FROM pg_catalog.pg_auth_members ` +
		`WHERE roleid = $1 AND member = $2`
	// run
	logf(sqlstr, roleid, member)
	pam := PgAuthMember{}
	if err := db.QueryRowContext(ctx, sqlstr, roleid, member).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption); err != nil {
		return nil, logerror(err)
	}
	return &pam, nil
}

// PgAuthidByOid retrieves a row from 'pg_catalog.pg_authid' as a PgAuthid.
//
// Generated from index 'pg_authid_oid_index'.
func PgAuthidByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgAuthid, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
		`FROM pg_catalog.pg_authid ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pa := PgAuthid{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgAuthidByRolname retrieves a row from 'pg_catalog.pg_authid' as a PgAuthid.
//
// Generated from index 'pg_authid_rolname_index'.
func PgAuthidByRolname(ctx context.Context, db DB, rolname string) (*PgAuthid, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
		`FROM pg_catalog.pg_authid ` +
		`WHERE rolname = $1`
	// run
	logf(sqlstr, rolname)
	pa := PgAuthid{}
	if err := db.QueryRowContext(ctx, sqlstr, rolname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Oid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil); err != nil {
		return nil, logerror(err)
	}
	return &pa, nil
}

// PgCastByOid retrieves a row from 'pg_catalog.pg_cast' as a PgCast.
//
// Generated from index 'pg_cast_oid_index'.
func PgCastByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgCast, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, castsource, casttarget, castfunc, castcontext, castmethod ` +
		`FROM pg_catalog.pg_cast ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pc := PgCast{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgCastByCastsourceCasttarget retrieves a row from 'pg_catalog.pg_cast' as a PgCast.
//
// Generated from index 'pg_cast_source_target_index'.
func PgCastByCastsourceCasttarget(ctx context.Context, db DB, castsource, casttarget pgtypes.Oid) (*PgCast, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, castsource, casttarget, castfunc, castcontext, castmethod ` +
		`FROM pg_catalog.pg_cast ` +
		`WHERE castsource = $1 AND casttarget = $2`
	// run
	logf(sqlstr, castsource, casttarget)
	pc := PgCast{}
	if err := db.QueryRowContext(ctx, sqlstr, castsource, casttarget).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgClassByOid retrieves a row from 'pg_catalog.pg_class' as a PgClass.
//
// Generated from index 'pg_class_oid_index'.
func PgClassByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgClass, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relispartition, relrewrite, relfrozenxid, relminmxid, relacl, reloptions, relpartbound ` +
		`FROM pg_catalog.pg_class ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pc := PgClass{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relispartition, &pc.Relrewrite, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions, &pc.Relpartbound); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgClassByRelnameRelnamespace retrieves a row from 'pg_catalog.pg_class' as a PgClass.
//
// Generated from index 'pg_class_relname_nsp_index'.
func PgClassByRelnameRelnamespace(ctx context.Context, db DB, relname string, relnamespace pgtypes.Oid) (*PgClass, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relispartition, relrewrite, relfrozenxid, relminmxid, relacl, reloptions, relpartbound ` +
		`FROM pg_catalog.pg_class ` +
		`WHERE relname = $1 AND relnamespace = $2`
	// run
	logf(sqlstr, relname, relnamespace)
	pc := PgClass{}
	if err := db.QueryRowContext(ctx, sqlstr, relname, relnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relispartition, &pc.Relrewrite, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions, &pc.Relpartbound); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgClassByReltablespaceRelfilenode retrieves a row from 'pg_catalog.pg_class' as a PgClass.
//
// Generated from index 'pg_class_tblspc_relfilenode_index'.
func PgClassByReltablespaceRelfilenode(ctx context.Context, db DB, reltablespace, relfilenode pgtypes.Oid) ([]*PgClass, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relispartition, relrewrite, relfrozenxid, relminmxid, relacl, reloptions, relpartbound ` +
		`FROM pg_catalog.pg_class ` +
		`WHERE reltablespace = $1 AND relfilenode = $2`
	// run
	logf(sqlstr, reltablespace, relfilenode)
	rows, err := db.QueryContext(ctx, sqlstr, reltablespace, relfilenode)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgClass
	for rows.Next() {
		pc := PgClass{}
		// scan
		if err := rows.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relispartition, &pc.Relrewrite, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions, &pc.Relpartbound); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pc)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgCollationByCollnameCollencodingCollnamespace retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_name_enc_nsp_index'.
func PgCollationByCollnameCollencodingCollnamespace(ctx context.Context, db DB, collname string, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype, collversion ` +
		`FROM pg_catalog.pg_collation ` +
		`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`
	// run
	logf(sqlstr, collname, collencoding, collnamespace)
	pc := PgCollation{}
	if err := db.QueryRowContext(ctx, sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collprovider, &pc.Collisdeterministic, &pc.Collencoding, &pc.Collcollate, &pc.Collctype, &pc.Collversion); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgCollationByOid retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_oid_index'.
func PgCollationByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgCollation, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype, collversion ` +
		`FROM pg_catalog.pg_collation ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pc := PgCollation{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collprovider, &pc.Collisdeterministic, &pc.Collencoding, &pc.Collcollate, &pc.Collctype, &pc.Collversion); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgConstraintByConnameConnamespace retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_conname_nsp_index'.
func PgConstraintByConnameConnamespace(ctx context.Context, db DB, conname string, connamespace pgtypes.Oid) ([]*PgConstraint, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, conparentid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin ` +
		`FROM pg_catalog.pg_constraint ` +
		`WHERE conname = $1 AND connamespace = $2`
	// run
	logf(sqlstr, conname, connamespace)
	rows, err := db.QueryContext(ctx, sqlstr, conname, connamespace)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgConstraint
	for rows.Next() {
		pc := PgConstraint{}
		// scan
		if err := rows.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Conparentid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pc)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgConstraintByConparentid retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_conparentid_index'.
func PgConstraintByConparentid(ctx context.Context, db DB, conparentid pgtypes.Oid) ([]*PgConstraint, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, conparentid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin ` +
		`FROM pg_catalog.pg_constraint ` +
		`WHERE conparentid = $1`
	// run
	logf(sqlstr, conparentid)
	rows, err := db.QueryContext(ctx, sqlstr, conparentid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgConstraint
	for rows.Next() {
		pc := PgConstraint{}
		// scan
		if err := rows.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Conparentid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pc)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgConstraintByConrelidContypidConname retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_conrelid_contypid_conname_index'.
func PgConstraintByConrelidContypidConname(ctx context.Context, db DB, conrelid, contypid pgtypes.Oid, conname string) (*PgConstraint, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, conparentid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin ` +
		`FROM pg_catalog.pg_constraint ` +
		`WHERE conrelid = $1 AND contypid = $2 AND conname = $3`
	// run
	logf(sqlstr, conrelid, contypid, conname)
	pc := PgConstraint{}
	if err := db.QueryRowContext(ctx, sqlstr, conrelid, contypid, conname).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Conparentid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgConstraintByContypid retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_contypid_index'.
func PgConstraintByContypid(ctx context.Context, db DB, contypid pgtypes.Oid) ([]*PgConstraint, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, conparentid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin ` +
		`FROM pg_catalog.pg_constraint ` +
		`WHERE contypid = $1`
	// run
	logf(sqlstr, contypid)
	rows, err := db.QueryContext(ctx, sqlstr, contypid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgConstraint
	for rows.Next() {
		pc := PgConstraint{}
		// scan
		if err := rows.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Conparentid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pc)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgConstraintByOid retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_oid_index'.
func PgConstraintByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgConstraint, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, conparentid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin ` +
		`FROM pg_catalog.pg_constraint ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pc := PgConstraint{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Conparentid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgConversionByConnamespaceConforencodingContoencodingOid retrieves a row from 'pg_catalog.pg_conversion' as a PgConversion.
//
// Generated from index 'pg_conversion_default_index'.
func PgConversionByConnamespaceConforencodingContoencodingOid(ctx context.Context, db DB, connamespace pgtypes.Oid, conforencoding, contoencoding int, oid pgtypes.Oid) (*PgConversion, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
		`FROM pg_catalog.pg_conversion ` +
		`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`
	// run
	logf(sqlstr, connamespace, conforencoding, contoencoding, oid)
	pc := PgConversion{}
	if err := db.QueryRowContext(ctx, sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgConversionByConnameConnamespace retrieves a row from 'pg_catalog.pg_conversion' as a PgConversion.
//
// Generated from index 'pg_conversion_name_nsp_index'.
func PgConversionByConnameConnamespace(ctx context.Context, db DB, conname string, connamespace pgtypes.Oid) (*PgConversion, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
		`FROM pg_catalog.pg_conversion ` +
		`WHERE conname = $1 AND connamespace = $2`
	// run
	logf(sqlstr, conname, connamespace)
	pc := PgConversion{}
	if err := db.QueryRowContext(ctx, sqlstr, conname, connamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgConversionByOid retrieves a row from 'pg_catalog.pg_conversion' as a PgConversion.
//
// Generated from index 'pg_conversion_oid_index'.
func PgConversionByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgConversion, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
		`FROM pg_catalog.pg_conversion ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pc := PgConversion{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Ctid, &pc.Oid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault); err != nil {
		return nil, logerror(err)
	}
	return &pc, nil
}

// PgDatabaseByDatname retrieves a row from 'pg_catalog.pg_database' as a PgDatabase.
//
// Generated from index 'pg_database_datname_index'.
func PgDatabaseByDatname(ctx context.Context, db DB, datname string) (*PgDatabase, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
		`FROM pg_catalog.pg_database ` +
		`WHERE datname = $1`
	// run
	logf(sqlstr, datname)
	pd := PgDatabase{}
	if err := db.QueryRowContext(ctx, sqlstr, datname).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Oid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl); err != nil {
		return nil, logerror(err)
	}
	return &pd, nil
}

// PgDatabaseByOid retrieves a row from 'pg_catalog.pg_database' as a PgDatabase.
//
// Generated from index 'pg_database_oid_index'.
func PgDatabaseByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgDatabase, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
		`FROM pg_catalog.pg_database ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pd := PgDatabase{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Oid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl); err != nil {
		return nil, logerror(err)
	}
	return &pd, nil
}

// PgDbRoleSettingBySetdatabaseSetrole retrieves a row from 'pg_catalog.pg_db_role_setting' as a PgDbRoleSetting.
//
// Generated from index 'pg_db_role_setting_databaseid_rol_index'.
func PgDbRoleSettingBySetdatabaseSetrole(ctx context.Context, db DB, setdatabase, setrole pgtypes.Oid) (*PgDbRoleSetting, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig ` +
		`FROM pg_catalog.pg_db_role_setting ` +
		`WHERE setdatabase = $1 AND setrole = $2`
	// run
	logf(sqlstr, setdatabase, setrole)
	pdrs := PgDbRoleSetting{}
	if err := db.QueryRowContext(ctx, sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig); err != nil {
		return nil, logerror(err)
	}
	return &pdrs, nil
}

// PgDefaultACLByOid retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_oid_index'.
func PgDefaultACLByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgDefaultACL, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
		`FROM pg_catalog.pg_default_acl ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pda := PgDefaultACL{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Ctid, &pda.Oid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl); err != nil {
		return nil, logerror(err)
	}
	return &pda, nil
}

// PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_role_nsp_obj_index'.
func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(ctx context.Context, db DB, defaclrole, defaclnamespace pgtypes.Oid, defaclobjtype pgtypes.Char) (*PgDefaultACL, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
		`FROM pg_catalog.pg_default_acl ` +
		`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`
	// run
	logf(sqlstr, defaclrole, defaclnamespace, defaclobjtype)
	pda := PgDefaultACL{}
	if err := db.QueryRowContext(ctx, sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Ctid, &pda.Oid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl); err != nil {
		return nil, logerror(err)
	}
	return &pda, nil
}

// PgDependByClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_depend' as a PgDepend.
//
// Generated from index 'pg_depend_depender_index'.
func PgDependByClassidObjidObjsubid(ctx context.Context, db DB, classid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
		`FROM pg_catalog.pg_depend ` +
		`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
	// run
	logf(sqlstr, classid, objid, objsubid)
	rows, err := db.QueryContext(ctx, sqlstr, classid, objid, objsubid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgDepend
	for rows.Next() {
		pd := PgDepend{}
		// scan
		if err := rows.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pd)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgDependByRefclassidRefobjidRefobjsubid retrieves a row from 'pg_catalog.pg_depend' as a PgDepend.
//
// Generated from index 'pg_depend_reference_index'.
func PgDependByRefclassidRefobjidRefobjsubid(ctx context.Context, db DB, refclassid, refobjid pgtypes.Oid, refobjsubid int) ([]*PgDepend, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
		`FROM pg_catalog.pg_depend ` +
		`WHERE refclassid = $1 AND refobjid = $2 AND refobjsubid = $3`
	// run
	logf(sqlstr, refclassid, refobjid, refobjsubid)
	rows, err := db.QueryContext(ctx, sqlstr, refclassid, refobjid, refobjsubid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgDepend
	for rows.Next() {
		pd := PgDepend{}
		// scan
		if err := rows.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pd)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgDescriptionByObjoidClassoidObjsubid retrieves a row from 'pg_catalog.pg_description' as a PgDescription.
//
// Generated from index 'pg_description_o_c_o_index'.
func PgDescriptionByObjoidClassoidObjsubid(ctx context.Context, db DB, objoid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
		`FROM pg_catalog.pg_description ` +
		`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
	// run
	logf(sqlstr, objoid, classoid, objsubid)
	pd := PgDescription{}
	if err := db.QueryRowContext(ctx, sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description); err != nil {
		return nil, logerror(err)
	}
	return &pd, nil
}

// PgEnumByOid retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_oid_index'.
func PgEnumByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgEnum, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, enumtypid, enumsortorder, enumlabel ` +
		`FROM pg_catalog.pg_enum ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pe := PgEnum{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Ctid, &pe.Oid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel); err != nil {
		return nil, logerror(err)
	}
	return &pe, nil
}

// PgEnumByEnumtypidEnumlabel retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_label_index'.
func PgEnumByEnumtypidEnumlabel(ctx context.Context, db DB, enumtypid pgtypes.Oid, enumlabel string) (*PgEnum, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, enumtypid, enumsortorder, enumlabel ` +
		`FROM pg_catalog.pg_enum ` +
		`WHERE enumtypid = $1 AND enumlabel = $2`
	// run
	logf(sqlstr, enumtypid, enumlabel)
	pe := PgEnum{}
	if err := db.QueryRowContext(ctx, sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Ctid, &pe.Oid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel); err != nil {
		return nil, logerror(err)
	}
	return &pe, nil
}

// PgEnumByEnumtypidEnumsortorder retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_sortorder_index'.
func PgEnumByEnumtypidEnumsortorder(ctx context.Context, db DB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, enumtypid, enumsortorder, enumlabel ` +
		`FROM pg_catalog.pg_enum ` +
		`WHERE enumtypid = $1 AND enumsortorder = $2`
	// run
	logf(sqlstr, enumtypid, enumsortorder)
	pe := PgEnum{}
	if err := db.QueryRowContext(ctx, sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Ctid, &pe.Oid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel); err != nil {
		return nil, logerror(err)
	}
	return &pe, nil
}

// PgEventTriggerByEvtname retrieves a row from 'pg_catalog.pg_event_trigger' as a PgEventTrigger.
//
// Generated from index 'pg_event_trigger_evtname_index'.
func PgEventTriggerByEvtname(ctx context.Context, db DB, evtname string) (*PgEventTrigger, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
		`FROM pg_catalog.pg_event_trigger ` +
		`WHERE evtname = $1`
	// run
	logf(sqlstr, evtname)
	pet := PgEventTrigger{}
	if err := db.QueryRowContext(ctx, sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Ctid, &pet.Oid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags); err != nil {
		return nil, logerror(err)
	}
	return &pet, nil
}

// PgEventTriggerByOid retrieves a row from 'pg_catalog.pg_event_trigger' as a PgEventTrigger.
//
// Generated from index 'pg_event_trigger_oid_index'.
func PgEventTriggerByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgEventTrigger, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
		`FROM pg_catalog.pg_event_trigger ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pet := PgEventTrigger{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Ctid, &pet.Oid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags); err != nil {
		return nil, logerror(err)
	}
	return &pet, nil
}

// PgExtensionByExtname retrieves a row from 'pg_catalog.pg_extension' as a PgExtension.
//
// Generated from index 'pg_extension_name_index'.
func PgExtensionByExtname(ctx context.Context, db DB, extname string) (*PgExtension, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
		`FROM pg_catalog.pg_extension ` +
		`WHERE extname = $1`
	// run
	logf(sqlstr, extname)
	pe := PgExtension{}
	if err := db.QueryRowContext(ctx, sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Ctid, &pe.Oid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition); err != nil {
		return nil, logerror(err)
	}
	return &pe, nil
}

// PgExtensionByOid retrieves a row from 'pg_catalog.pg_extension' as a PgExtension.
//
// Generated from index 'pg_extension_oid_index'.
func PgExtensionByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgExtension, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
		`FROM pg_catalog.pg_extension ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pe := PgExtension{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Ctid, &pe.Oid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition); err != nil {
		return nil, logerror(err)
	}
	return &pe, nil
}

// PgForeignDataWrapperByFdwname retrieves a row from 'pg_catalog.pg_foreign_data_wrapper' as a PgForeignDataWrapper.
//
// Generated from index 'pg_foreign_data_wrapper_name_index'.
func PgForeignDataWrapperByFdwname(ctx context.Context, db DB, fdwname string) (*PgForeignDataWrapper, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
		`FROM pg_catalog.pg_foreign_data_wrapper ` +
		`WHERE fdwname = $1`
	// run
	logf(sqlstr, fdwname)
	pfdw := PgForeignDataWrapper{}
	if err := db.QueryRowContext(ctx, sqlstr, fdwname).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Ctid, &pfdw.Oid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions); err != nil {
		return nil, logerror(err)
	}
	return &pfdw, nil
}

// PgForeignDataWrapperByOid retrieves a row from 'pg_catalog.pg_foreign_data_wrapper' as a PgForeignDataWrapper.
//
// Generated from index 'pg_foreign_data_wrapper_oid_index'.
func PgForeignDataWrapperByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
		`FROM pg_catalog.pg_foreign_data_wrapper ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pfdw := PgForeignDataWrapper{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Ctid, &pfdw.Oid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions); err != nil {
		return nil, logerror(err)
	}
	return &pfdw, nil
}

// PgForeignServerBySrvname retrieves a row from 'pg_catalog.pg_foreign_server' as a PgForeignServer.
//
// Generated from index 'pg_foreign_server_name_index'.
func PgForeignServerBySrvname(ctx context.Context, db DB, srvname string) (*PgForeignServer, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
		`FROM pg_catalog.pg_foreign_server ` +
		`WHERE srvname = $1`
	// run
	logf(sqlstr, srvname)
	pfs := PgForeignServer{}
	if err := db.QueryRowContext(ctx, sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Ctid, &pfs.Oid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions); err != nil {
		return nil, logerror(err)
	}
	return &pfs, nil
}

// PgForeignServerByOid retrieves a row from 'pg_catalog.pg_foreign_server' as a PgForeignServer.
//
// Generated from index 'pg_foreign_server_oid_index'.
func PgForeignServerByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgForeignServer, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
		`FROM pg_catalog.pg_foreign_server ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pfs := PgForeignServer{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Ctid, &pfs.Oid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions); err != nil {
		return nil, logerror(err)
	}
	return &pfs, nil
}

// PgForeignTableByFtrelid retrieves a row from 'pg_catalog.pg_foreign_table' as a PgForeignTable.
//
// Generated from index 'pg_foreign_table_relid_index'.
func PgForeignTableByFtrelid(ctx context.Context, db DB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
		`FROM pg_catalog.pg_foreign_table ` +
		`WHERE ftrelid = $1`
	// run
	logf(sqlstr, ftrelid)
	pft := PgForeignTable{}
	if err := db.QueryRowContext(ctx, sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions); err != nil {
		return nil, logerror(err)
	}
	return &pft, nil
}

// PgIndexByIndexrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indexrelid_index'.
func PgIndexByIndexrelid(ctx context.Context, db DB, indexrelid pgtypes.Oid) (*PgIndex, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indnkeyatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
		`FROM pg_catalog.pg_index ` +
		`WHERE indexrelid = $1`
	// run
	logf(sqlstr, indexrelid)
	pi := PgIndex{}
	if err := db.QueryRowContext(ctx, sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indnkeyatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred); err != nil {
		return nil, logerror(err)
	}
	return &pi, nil
}

// PgIndexByIndrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indrelid_index'.
func PgIndexByIndrelid(ctx context.Context, db DB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indnkeyatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
		`FROM pg_catalog.pg_index ` +
		`WHERE indrelid = $1`
	// run
	logf(sqlstr, indrelid)
	rows, err := db.QueryContext(ctx, sqlstr, indrelid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgIndex
	for rows.Next() {
		pi := PgIndex{}
		// scan
		if err := rows.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indnkeyatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pi)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgInheritsByInhparent retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_parent_index'.
func PgInheritsByInhparent(ctx context.Context, db DB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
		`FROM pg_catalog.pg_inherits ` +
		`WHERE inhparent = $1`
	// run
	logf(sqlstr, inhparent)
	rows, err := db.QueryContext(ctx, sqlstr, inhparent)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgInherit
	for rows.Next() {
		pi := PgInherit{}
		// scan
		if err := rows.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pi)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgInheritByInhrelidInhseqno retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_relid_seqno_index'.
func PgInheritByInhrelidInhseqno(ctx context.Context, db DB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
		`FROM pg_catalog.pg_inherits ` +
		`WHERE inhrelid = $1 AND inhseqno = $2`
	// run
	logf(sqlstr, inhrelid, inhseqno)
	pi := PgInherit{}
	if err := db.QueryRowContext(ctx, sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno); err != nil {
		return nil, logerror(err)
	}
	return &pi, nil
}

// PgInitPrivByObjoidClassoidObjsubid retrieves a row from 'pg_catalog.pg_init_privs' as a PgInitPriv.
//
// Generated from index 'pg_init_privs_o_c_o_index'.
func PgInitPrivByObjoidClassoidObjsubid(ctx context.Context, db DB, objoid, classoid pgtypes.Oid, objsubid int) (*PgInitPriv, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, privtype, initprivs ` +
		`FROM pg_catalog.pg_init_privs ` +
		`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
	// run
	logf(sqlstr, objoid, classoid, objsubid)
	pip := PgInitPriv{}
	if err := db.QueryRowContext(ctx, sqlstr, objoid, classoid, objsubid).Scan(&pip.Tableoid, &pip.Cmax, &pip.Xmax, &pip.Cmin, &pip.Xmin, &pip.Ctid, &pip.Objoid, &pip.Classoid, &pip.Objsubid, &pip.Privtype, &pip.Initprivs); err != nil {
		return nil, logerror(err)
	}
	return &pip, nil
}

// PgLanguageByLanname retrieves a row from 'pg_catalog.pg_language' as a PgLanguage.
//
// Generated from index 'pg_language_name_index'.
func PgLanguageByLanname(ctx context.Context, db DB, lanname string) (*PgLanguage, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
		`FROM pg_catalog.pg_language ` +
		`WHERE lanname = $1`
	// run
	logf(sqlstr, lanname)
	pl := PgLanguage{}
	if err := db.QueryRowContext(ctx, sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Oid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl); err != nil {
		return nil, logerror(err)
	}
	return &pl, nil
}

// PgLanguageByOid retrieves a row from 'pg_catalog.pg_language' as a PgLanguage.
//
// Generated from index 'pg_language_oid_index'.
func PgLanguageByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgLanguage, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
		`FROM pg_catalog.pg_language ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pl := PgLanguage{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Oid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl); err != nil {
		return nil, logerror(err)
	}
	return &pl, nil
}

// PgLargeobjectByLoidPageno retrieves a row from 'pg_catalog.pg_largeobject' as a PgLargeobject.
//
// Generated from index 'pg_largeobject_loid_pn_index'.
func PgLargeobjectByLoidPageno(ctx context.Context, db DB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
		`FROM pg_catalog.pg_largeobject ` +
		`WHERE loid = $1 AND pageno = $2`
	// run
	logf(sqlstr, loid, pageno)
	pl := PgLargeobject{}
	if err := db.QueryRowContext(ctx, sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data); err != nil {
		return nil, logerror(err)
	}
	return &pl, nil
}

// PgLargeobjectMetadatumByOid retrieves a row from 'pg_catalog.pg_largeobject_metadata' as a PgLargeobjectMetadatum.
//
// Generated from index 'pg_largeobject_metadata_oid_index'.
func PgLargeobjectMetadatumByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, lomowner, lomacl ` +
		`FROM pg_catalog.pg_largeobject_metadata ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	plm := PgLargeobjectMetadatum{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Ctid, &plm.Oid, &plm.Lomowner, &plm.Lomacl); err != nil {
		return nil, logerror(err)
	}
	return &plm, nil
}

// PgNamespaceByNspname retrieves a row from 'pg_catalog.pg_namespace' as a PgNamespace.
//
// Generated from index 'pg_namespace_nspname_index'.
func PgNamespaceByNspname(ctx context.Context, db DB, nspname string) (*PgNamespace, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, nspname, nspowner, nspacl ` +
		`FROM pg_catalog.pg_namespace ` +
		`WHERE nspname = $1`
	// run
	logf(sqlstr, nspname)
	pn := PgNamespace{}
	if err := db.QueryRowContext(ctx, sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Ctid, &pn.Oid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl); err != nil {
		return nil, logerror(err)
	}
	return &pn, nil
}

// PgNamespaceByOid retrieves a row from 'pg_catalog.pg_namespace' as a PgNamespace.
//
// Generated from index 'pg_namespace_oid_index'.
func PgNamespaceByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgNamespace, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, nspname, nspowner, nspacl ` +
		`FROM pg_catalog.pg_namespace ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pn := PgNamespace{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Ctid, &pn.Oid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl); err != nil {
		return nil, logerror(err)
	}
	return &pn, nil
}

// PgOpclassByOpcmethodOpcnameOpcnamespace retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_am_name_nsp_index'.
func PgOpclassByOpcmethodOpcnameOpcnamespace(ctx context.Context, db DB, opcmethod pgtypes.Oid, opcname string, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
		`FROM pg_catalog.pg_opclass ` +
		`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
	// run
	logf(sqlstr, opcmethod, opcname, opcnamespace)
	po := PgOpclass{}
	if err := db.QueryRowContext(ctx, sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgOpclassByOid retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_oid_index'.
func PgOpclassByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgOpclass, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
		`FROM pg_catalog.pg_opclass ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	po := PgOpclass{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgOperatorByOid retrieves a row from 'pg_catalog.pg_operator' as a PgOperator.
//
// Generated from index 'pg_operator_oid_index'.
func PgOperatorByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgOperator, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
		`FROM pg_catalog.pg_operator ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	po := PgOperator{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgOperatorByOprnameOprleftOprrightOprnamespace retrieves a row from 'pg_catalog.pg_operator' as a PgOperator.
//
// Generated from index 'pg_operator_oprname_l_r_n_index'.
func PgOperatorByOprnameOprleftOprrightOprnamespace(ctx context.Context, db DB, oprname string, oprleft, oprright, oprnamespace pgtypes.Oid) (*PgOperator, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
		`FROM pg_catalog.pg_operator ` +
		`WHERE oprname = $1 AND oprleft = $2 AND oprright = $3 AND oprnamespace = $4`
	// run
	logf(sqlstr, oprname, oprleft, oprright, oprnamespace)
	po := PgOperator{}
	if err := db.QueryRowContext(ctx, sqlstr, oprname, oprleft, oprright, oprnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgOpfamilyByOpfmethodOpfnameOpfnamespace retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_am_name_nsp_index'.
func PgOpfamilyByOpfmethodOpfnameOpfnamespace(ctx context.Context, db DB, opfmethod pgtypes.Oid, opfname string, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, opfmethod, opfname, opfnamespace, opfowner ` +
		`FROM pg_catalog.pg_opfamily ` +
		`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
	// run
	logf(sqlstr, opfmethod, opfname, opfnamespace)
	po := PgOpfamily{}
	if err := db.QueryRowContext(ctx, sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgOpfamilyByOid retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_oid_index'.
func PgOpfamilyByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgOpfamily, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, opfmethod, opfname, opfnamespace, opfowner ` +
		`FROM pg_catalog.pg_opfamily ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	po := PgOpfamily{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Ctid, &po.Oid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner); err != nil {
		return nil, logerror(err)
	}
	return &po, nil
}

// PgPartitionedTableByPartrelid retrieves a row from 'pg_catalog.pg_partitioned_table' as a PgPartitionedTable.
//
// Generated from index 'pg_partitioned_table_partrelid_index'.
func PgPartitionedTableByPartrelid(ctx context.Context, db DB, partrelid pgtypes.Oid) (*PgPartitionedTable, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, partrelid, partstrat, partnatts, partdefid, partattrs, partclass, partcollation, partexprs ` +
		`FROM pg_catalog.pg_partitioned_table ` +
		`WHERE partrelid = $1`
	// run
	logf(sqlstr, partrelid)
	ppt := PgPartitionedTable{}
	if err := db.QueryRowContext(ctx, sqlstr, partrelid).Scan(&ppt.Tableoid, &ppt.Cmax, &ppt.Xmax, &ppt.Cmin, &ppt.Xmin, &ppt.Ctid, &ppt.Partrelid, &ppt.Partstrat, &ppt.Partnatts, &ppt.Partdefid, &ppt.Partattrs, &ppt.Partclass, &ppt.Partcollation, &ppt.Partexprs); err != nil {
		return nil, logerror(err)
	}
	return &ppt, nil
}

// PgPolicyByOid retrieves a row from 'pg_catalog.pg_policy' as a PgPolicy.
//
// Generated from index 'pg_policy_oid_index'.
func PgPolicyByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgPolicy, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, polname, polrelid, polcmd, polpermissive, polroles, polqual, polwithcheck ` +
		`FROM pg_catalog.pg_policy ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pp := PgPolicy{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polpermissive, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgPolicyByPolrelidPolname retrieves a row from 'pg_catalog.pg_policy' as a PgPolicy.
//
// Generated from index 'pg_policy_polrelid_polname_index'.
func PgPolicyByPolrelidPolname(ctx context.Context, db DB, polrelid pgtypes.Oid, polname string) (*PgPolicy, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, polname, polrelid, polcmd, polpermissive, polroles, polqual, polwithcheck ` +
		`FROM pg_catalog.pg_policy ` +
		`WHERE polrelid = $1 AND polname = $2`
	// run
	logf(sqlstr, polrelid, polname)
	pp := PgPolicy{}
	if err := db.QueryRowContext(ctx, sqlstr, polrelid, polname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polpermissive, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgProcByOid retrieves a row from 'pg_catalog.pg_proc' as a PgProc.
//
// Generated from index 'pg_proc_oid_index'.
func PgProcByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgProc, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, prosupport, prokind, prosecdef, proleakproof, proisstrict, proretset, provolatile, proparallel, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
		`FROM pg_catalog.pg_proc ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pp := PgProc{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Prosupport, &pp.Prokind, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Proparallel, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgProcByPronameProargtypesPronamespace retrieves a row from 'pg_catalog.pg_proc' as a PgProc.
//
// Generated from index 'pg_proc_proname_args_nsp_index'.
func PgProcByPronameProargtypesPronamespace(ctx context.Context, db DB, proname string, proargtypes pgtypes.Oidvector, pronamespace pgtypes.Oid) (*PgProc, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, prosupport, prokind, prosecdef, proleakproof, proisstrict, proretset, provolatile, proparallel, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
		`FROM pg_catalog.pg_proc ` +
		`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`
	// run
	logf(sqlstr, proname, proargtypes, pronamespace)
	pp := PgProc{}
	if err := db.QueryRowContext(ctx, sqlstr, proname, proargtypes, pronamespace).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Prosupport, &pp.Prokind, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Proparallel, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgPublicationByOid retrieves a row from 'pg_catalog.pg_publication' as a PgPublication.
//
// Generated from index 'pg_publication_oid_index'.
func PgPublicationByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgPublication, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, pubname, pubowner, puballtables, pubinsert, pubupdate, pubdelete, pubtruncate, pubviaroot ` +
		`FROM pg_catalog.pg_publication ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pp := PgPublication{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Pubname, &pp.Pubowner, &pp.Puballtables, &pp.Pubinsert, &pp.Pubupdate, &pp.Pubdelete, &pp.Pubtruncate, &pp.Pubviaroot); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgPublicationByPubname retrieves a row from 'pg_catalog.pg_publication' as a PgPublication.
//
// Generated from index 'pg_publication_pubname_index'.
func PgPublicationByPubname(ctx context.Context, db DB, pubname string) (*PgPublication, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, pubname, pubowner, puballtables, pubinsert, pubupdate, pubdelete, pubtruncate, pubviaroot ` +
		`FROM pg_catalog.pg_publication ` +
		`WHERE pubname = $1`
	// run
	logf(sqlstr, pubname)
	pp := PgPublication{}
	if err := db.QueryRowContext(ctx, sqlstr, pubname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Oid, &pp.Pubname, &pp.Pubowner, &pp.Puballtables, &pp.Pubinsert, &pp.Pubupdate, &pp.Pubdelete, &pp.Pubtruncate, &pp.Pubviaroot); err != nil {
		return nil, logerror(err)
	}
	return &pp, nil
}

// PgPublicationRelByOid retrieves a row from 'pg_catalog.pg_publication_rel' as a PgPublicationRel.
//
// Generated from index 'pg_publication_rel_oid_index'.
func PgPublicationRelByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgPublicationRel, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, prpubid, prrelid ` +
		`FROM pg_catalog.pg_publication_rel ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ppr := PgPublicationRel{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ppr.Tableoid, &ppr.Cmax, &ppr.Xmax, &ppr.Cmin, &ppr.Xmin, &ppr.Ctid, &ppr.Oid, &ppr.Prpubid, &ppr.Prrelid); err != nil {
		return nil, logerror(err)
	}
	return &ppr, nil
}

// PgPublicationRelByPrrelidPrpubid retrieves a row from 'pg_catalog.pg_publication_rel' as a PgPublicationRel.
//
// Generated from index 'pg_publication_rel_prrelid_prpubid_index'.
func PgPublicationRelByPrrelidPrpubid(ctx context.Context, db DB, prrelid, prpubid pgtypes.Oid) (*PgPublicationRel, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, prpubid, prrelid ` +
		`FROM pg_catalog.pg_publication_rel ` +
		`WHERE prrelid = $1 AND prpubid = $2`
	// run
	logf(sqlstr, prrelid, prpubid)
	ppr := PgPublicationRel{}
	if err := db.QueryRowContext(ctx, sqlstr, prrelid, prpubid).Scan(&ppr.Tableoid, &ppr.Cmax, &ppr.Xmax, &ppr.Cmin, &ppr.Xmin, &ppr.Ctid, &ppr.Oid, &ppr.Prpubid, &ppr.Prrelid); err != nil {
		return nil, logerror(err)
	}
	return &ppr, nil
}

// PgRangeByRngtypid retrieves a row from 'pg_catalog.pg_range' as a PgRange.
//
// Generated from index 'pg_range_rngtypid_index'.
func PgRangeByRngtypid(ctx context.Context, db DB, rngtypid pgtypes.Oid) (*PgRange, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff ` +
		`FROM pg_catalog.pg_range ` +
		`WHERE rngtypid = $1`
	// run
	logf(sqlstr, rngtypid)
	pr := PgRange{}
	if err := db.QueryRowContext(ctx, sqlstr, rngtypid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Rngtypid, &pr.Rngsubtype, &pr.Rngcollation, &pr.Rngsubopc, &pr.Rngcanonical, &pr.Rngsubdiff); err != nil {
		return nil, logerror(err)
	}
	return &pr, nil
}

// PgReplicationOriginByRoident retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roiident_index'.
func PgReplicationOriginByRoident(ctx context.Context, db DB, roident pgtypes.Oid) (*PgReplicationOrigin, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
		`FROM pg_catalog.pg_replication_origin ` +
		`WHERE roident = $1`
	// run
	logf(sqlstr, roident)
	pro := PgReplicationOrigin{}
	if err := db.QueryRowContext(ctx, sqlstr, roident).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname); err != nil {
		return nil, logerror(err)
	}
	return &pro, nil
}

// PgReplicationOriginByRoname retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roname_index'.
func PgReplicationOriginByRoname(ctx context.Context, db DB, roname string) (*PgReplicationOrigin, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
		`FROM pg_catalog.pg_replication_origin ` +
		`WHERE roname = $1`
	// run
	logf(sqlstr, roname)
	pro := PgReplicationOrigin{}
	if err := db.QueryRowContext(ctx, sqlstr, roname).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname); err != nil {
		return nil, logerror(err)
	}
	return &pro, nil
}

// PgRewriteByOid retrieves a row from 'pg_catalog.pg_rewrite' as a PgRewrite.
//
// Generated from index 'pg_rewrite_oid_index'.
func PgRewriteByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgRewrite, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
		`FROM pg_catalog.pg_rewrite ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pr := PgRewrite{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Oid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction); err != nil {
		return nil, logerror(err)
	}
	return &pr, nil
}

// PgRewriteByEvClassRulename retrieves a row from 'pg_catalog.pg_rewrite' as a PgRewrite.
//
// Generated from index 'pg_rewrite_rel_rulename_index'.
func PgRewriteByEvClassRulename(ctx context.Context, db DB, evClass pgtypes.Oid, rulename string) (*PgRewrite, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
		`FROM pg_catalog.pg_rewrite ` +
		`WHERE ev_class = $1 AND rulename = $2`
	// run
	logf(sqlstr, evClass, rulename)
	pr := PgRewrite{}
	if err := db.QueryRowContext(ctx, sqlstr, evClass, rulename).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Oid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction); err != nil {
		return nil, logerror(err)
	}
	return &pr, nil
}

// PgSeclabelByObjoidClassoidObjsubidProvider retrieves a row from 'pg_catalog.pg_seclabel' as a PgSeclabel.
//
// Generated from index 'pg_seclabel_object_index'.
func PgSeclabelByObjoidClassoidObjsubidProvider(ctx context.Context, db DB, objoid, classoid pgtypes.Oid, objsubid int, provider string) (*PgSeclabel, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label ` +
		`FROM pg_catalog.pg_seclabel ` +
		`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`
	// run
	logf(sqlstr, objoid, classoid, objsubid, provider)
	ps := PgSeclabel{}
	if err := db.QueryRowContext(ctx, sqlstr, objoid, classoid, objsubid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Objsubid, &ps.Provider, &ps.Label); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgSequenceBySeqrelid retrieves a row from 'pg_catalog.pg_sequence' as a PgSequence.
//
// Generated from index 'pg_sequence_seqrelid_index'.
func PgSequenceBySeqrelid(ctx context.Context, db DB, seqrelid pgtypes.Oid) (*PgSequence, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, seqrelid, seqtypid, seqstart, seqincrement, seqmax, seqmin, seqcache, seqcycle ` +
		`FROM pg_catalog.pg_sequence ` +
		`WHERE seqrelid = $1`
	// run
	logf(sqlstr, seqrelid)
	ps := PgSequence{}
	if err := db.QueryRowContext(ctx, sqlstr, seqrelid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Seqrelid, &ps.Seqtypid, &ps.Seqstart, &ps.Seqincrement, &ps.Seqmax, &ps.Seqmin, &ps.Seqcache, &ps.Seqcycle); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgShdependByDbidClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_depender_index'.
func PgShdependByDbidClassidObjidObjsubid(ctx context.Context, db DB, dbid, classid, objid pgtypes.Oid, objsubid int) ([]*PgShdepend, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
		`FROM pg_catalog.pg_shdepend ` +
		`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`
	// run
	logf(sqlstr, dbid, classid, objid, objsubid)
	rows, err := db.QueryContext(ctx, sqlstr, dbid, classid, objid, objsubid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgShdepend
	for rows.Next() {
		ps := PgShdepend{}
		// scan
		if err := rows.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &ps)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgShdependByRefclassidRefobjid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_reference_index'.
func PgShdependByRefclassidRefobjid(ctx context.Context, db DB, refclassid, refobjid pgtypes.Oid) ([]*PgShdepend, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
		`FROM pg_catalog.pg_shdepend ` +
		`WHERE refclassid = $1 AND refobjid = $2`
	// run
	logf(sqlstr, refclassid, refobjid)
	rows, err := db.QueryContext(ctx, sqlstr, refclassid, refobjid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgShdepend
	for rows.Next() {
		ps := PgShdepend{}
		// scan
		if err := rows.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &ps)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgShdescriptionByObjoidClassoid retrieves a row from 'pg_catalog.pg_shdescription' as a PgShdescription.
//
// Generated from index 'pg_shdescription_o_c_index'.
func PgShdescriptionByObjoidClassoid(ctx context.Context, db DB, objoid, classoid pgtypes.Oid) (*PgShdescription, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description ` +
		`FROM pg_catalog.pg_shdescription ` +
		`WHERE objoid = $1 AND classoid = $2`
	// run
	logf(sqlstr, objoid, classoid)
	ps := PgShdescription{}
	if err := db.QueryRowContext(ctx, sqlstr, objoid, classoid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Description); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgShseclabelByObjoidClassoidProvider retrieves a row from 'pg_catalog.pg_shseclabel' as a PgShseclabel.
//
// Generated from index 'pg_shseclabel_object_index'.
func PgShseclabelByObjoidClassoidProvider(ctx context.Context, db DB, objoid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label ` +
		`FROM pg_catalog.pg_shseclabel ` +
		`WHERE objoid = $1 AND classoid = $2 AND provider = $3`
	// run
	logf(sqlstr, objoid, classoid, provider)
	ps := PgShseclabel{}
	if err := db.QueryRowContext(ctx, sqlstr, objoid, classoid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Provider, &ps.Label); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgStatisticByStarelidStaattnumStainherit retrieves a row from 'pg_catalog.pg_statistic' as a PgStatistic.
//
// Generated from index 'pg_statistic_relid_att_inh_index'.
func PgStatisticByStarelidStaattnumStainherit(ctx context.Context, db DB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stacoll1, stacoll2, stacoll3, stacoll4, stacoll5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 ` +
		`FROM pg_catalog.pg_statistic ` +
		`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`
	// run
	logf(sqlstr, starelid, staattnum, stainherit)
	ps := PgStatistic{}
	if err := db.QueryRowContext(ctx, sqlstr, starelid, staattnum, stainherit).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Starelid, &ps.Staattnum, &ps.Stainherit, &ps.Stanullfrac, &ps.Stawidth, &ps.Stadistinct, &ps.Stakind1, &ps.Stakind2, &ps.Stakind3, &ps.Stakind4, &ps.Stakind5, &ps.Staop1, &ps.Staop2, &ps.Staop3, &ps.Staop4, &ps.Staop5, &ps.Stacoll1, &ps.Stacoll2, &ps.Stacoll3, &ps.Stacoll4, &ps.Stacoll5, &ps.Stanumbers1, &ps.Stanumbers2, &ps.Stanumbers3, &ps.Stanumbers4, &ps.Stanumbers5, &ps.Stavalues1, &ps.Stavalues2, &ps.Stavalues3, &ps.Stavalues4, &ps.Stavalues5); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgStatisticExtByStxnameStxnamespace retrieves a row from 'pg_catalog.pg_statistic_ext' as a PgStatisticExt.
//
// Generated from index 'pg_statistic_ext_name_index'.
func PgStatisticExtByStxnameStxnamespace(ctx context.Context, db DB, stxname string, stxnamespace pgtypes.Oid) (*PgStatisticExt, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, stxrelid, stxname, stxnamespace, stxowner, stxstattarget, stxkeys, stxkind ` +
		`FROM pg_catalog.pg_statistic_ext ` +
		`WHERE stxname = $1 AND stxnamespace = $2`
	// run
	logf(sqlstr, stxname, stxnamespace)
	pse := PgStatisticExt{}
	if err := db.QueryRowContext(ctx, sqlstr, stxname, stxnamespace).Scan(&pse.Tableoid, &pse.Cmax, &pse.Xmax, &pse.Cmin, &pse.Xmin, &pse.Ctid, &pse.Oid, &pse.Stxrelid, &pse.Stxname, &pse.Stxnamespace, &pse.Stxowner, &pse.Stxstattarget, &pse.Stxkeys, &pse.Stxkind); err != nil {
		return nil, logerror(err)
	}
	return &pse, nil
}

// PgStatisticExtByOid retrieves a row from 'pg_catalog.pg_statistic_ext' as a PgStatisticExt.
//
// Generated from index 'pg_statistic_ext_oid_index'.
func PgStatisticExtByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgStatisticExt, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, stxrelid, stxname, stxnamespace, stxowner, stxstattarget, stxkeys, stxkind ` +
		`FROM pg_catalog.pg_statistic_ext ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pse := PgStatisticExt{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pse.Tableoid, &pse.Cmax, &pse.Xmax, &pse.Cmin, &pse.Xmin, &pse.Ctid, &pse.Oid, &pse.Stxrelid, &pse.Stxname, &pse.Stxnamespace, &pse.Stxowner, &pse.Stxstattarget, &pse.Stxkeys, &pse.Stxkind); err != nil {
		return nil, logerror(err)
	}
	return &pse, nil
}

// PgStatisticExtByStxrelid retrieves a row from 'pg_catalog.pg_statistic_ext' as a PgStatisticExt.
//
// Generated from index 'pg_statistic_ext_relid_index'.
func PgStatisticExtByStxrelid(ctx context.Context, db DB, stxrelid pgtypes.Oid) ([]*PgStatisticExt, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, stxrelid, stxname, stxnamespace, stxowner, stxstattarget, stxkeys, stxkind ` +
		`FROM pg_catalog.pg_statistic_ext ` +
		`WHERE stxrelid = $1`
	// run
	logf(sqlstr, stxrelid)
	rows, err := db.QueryContext(ctx, sqlstr, stxrelid)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgStatisticExt
	for rows.Next() {
		pse := PgStatisticExt{}
		// scan
		if err := rows.Scan(&pse.Tableoid, &pse.Cmax, &pse.Xmax, &pse.Cmin, &pse.Xmin, &pse.Ctid, &pse.Oid, &pse.Stxrelid, &pse.Stxname, &pse.Stxnamespace, &pse.Stxowner, &pse.Stxstattarget, &pse.Stxkeys, &pse.Stxkind); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pse)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgStatisticExtDatumByStxoid retrieves a row from 'pg_catalog.pg_statistic_ext_data' as a PgStatisticExtDatum.
//
// Generated from index 'pg_statistic_ext_data_stxoid_index'.
func PgStatisticExtDatumByStxoid(ctx context.Context, db DB, stxoid pgtypes.Oid) (*PgStatisticExtDatum, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, stxoid, stxdndistinct, stxddependencies, stxdmcv ` +
		`FROM pg_catalog.pg_statistic_ext_data ` +
		`WHERE stxoid = $1`
	// run
	logf(sqlstr, stxoid)
	psed := PgStatisticExtDatum{}
	if err := db.QueryRowContext(ctx, sqlstr, stxoid).Scan(&psed.Tableoid, &psed.Cmax, &psed.Xmax, &psed.Cmin, &psed.Xmin, &psed.Ctid, &psed.Stxoid, &psed.Stxdndistinct, &psed.Stxddependencies, &psed.Stxdmcv); err != nil {
		return nil, logerror(err)
	}
	return &psed, nil
}

// PgSubscriptionByOid retrieves a row from 'pg_catalog.pg_subscription' as a PgSubscription.
//
// Generated from index 'pg_subscription_oid_index'.
func PgSubscriptionByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgSubscription, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, subdbid, subname, subowner, subenabled, subconninfo, subslotname, subsynccommit, subpublications ` +
		`FROM pg_catalog.pg_subscription ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ps := PgSubscription{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Oid, &ps.Subdbid, &ps.Subname, &ps.Subowner, &ps.Subenabled, &ps.Subconninfo, &ps.Subslotname, &ps.Subsynccommit, &ps.Subpublications); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgSubscriptionBySubdbidSubname retrieves a row from 'pg_catalog.pg_subscription' as a PgSubscription.
//
// Generated from index 'pg_subscription_subname_index'.
func PgSubscriptionBySubdbidSubname(ctx context.Context, db DB, subdbid pgtypes.Oid, subname string) (*PgSubscription, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, subdbid, subname, subowner, subenabled, subconninfo, subslotname, subsynccommit, subpublications ` +
		`FROM pg_catalog.pg_subscription ` +
		`WHERE subdbid = $1 AND subname = $2`
	// run
	logf(sqlstr, subdbid, subname)
	ps := PgSubscription{}
	if err := db.QueryRowContext(ctx, sqlstr, subdbid, subname).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Oid, &ps.Subdbid, &ps.Subname, &ps.Subowner, &ps.Subenabled, &ps.Subconninfo, &ps.Subslotname, &ps.Subsynccommit, &ps.Subpublications); err != nil {
		return nil, logerror(err)
	}
	return &ps, nil
}

// PgSubscriptionRelBySrrelidSrsubid retrieves a row from 'pg_catalog.pg_subscription_rel' as a PgSubscriptionRel.
//
// Generated from index 'pg_subscription_rel_srrelid_srsubid_index'.
func PgSubscriptionRelBySrrelidSrsubid(ctx context.Context, db DB, srrelid, srsubid pgtypes.Oid) (*PgSubscriptionRel, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, srsubid, srrelid, srsubstate, srsublsn ` +
		`FROM pg_catalog.pg_subscription_rel ` +
		`WHERE srrelid = $1 AND srsubid = $2`
	// run
	logf(sqlstr, srrelid, srsubid)
	psr := PgSubscriptionRel{}
	if err := db.QueryRowContext(ctx, sqlstr, srrelid, srsubid).Scan(&psr.Tableoid, &psr.Cmax, &psr.Xmax, &psr.Cmin, &psr.Xmin, &psr.Ctid, &psr.Srsubid, &psr.Srrelid, &psr.Srsubstate, &psr.Srsublsn); err != nil {
		return nil, logerror(err)
	}
	return &psr, nil
}

// PgTablespaceByOid retrieves a row from 'pg_catalog.pg_tablespace' as a PgTablespace.
//
// Generated from index 'pg_tablespace_oid_index'.
func PgTablespaceByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTablespace, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, spcname, spcowner, spcacl, spcoptions ` +
		`FROM pg_catalog.pg_tablespace ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pt := PgTablespace{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTablespaceBySpcname retrieves a row from 'pg_catalog.pg_tablespace' as a PgTablespace.
//
// Generated from index 'pg_tablespace_spcname_index'.
func PgTablespaceBySpcname(ctx context.Context, db DB, spcname string) (*PgTablespace, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, spcname, spcowner, spcacl, spcoptions ` +
		`FROM pg_catalog.pg_tablespace ` +
		`WHERE spcname = $1`
	// run
	logf(sqlstr, spcname)
	pt := PgTablespace{}
	if err := db.QueryRowContext(ctx, sqlstr, spcname).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTransformByOid retrieves a row from 'pg_catalog.pg_transform' as a PgTransform.
//
// Generated from index 'pg_transform_oid_index'.
func PgTransformByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTransform, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, trftype, trflang, trffromsql, trftosql ` +
		`FROM pg_catalog.pg_transform ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pt := PgTransform{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTransformByTrftypeTrflang retrieves a row from 'pg_catalog.pg_transform' as a PgTransform.
//
// Generated from index 'pg_transform_type_lang_index'.
func PgTransformByTrftypeTrflang(ctx context.Context, db DB, trftype, trflang pgtypes.Oid) (*PgTransform, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, trftype, trflang, trffromsql, trftosql ` +
		`FROM pg_catalog.pg_transform ` +
		`WHERE trftype = $1 AND trflang = $2`
	// run
	logf(sqlstr, trftype, trflang)
	pt := PgTransform{}
	if err := db.QueryRowContext(ctx, sqlstr, trftype, trflang).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTriggerByOid retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_oid_index'.
func PgTriggerByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTrigger, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, tgrelid, tgparentid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual, tgoldtable, tgnewtable ` +
		`FROM pg_catalog.pg_trigger ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pt := PgTrigger{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Tgrelid, &pt.Tgparentid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual, &pt.Tgoldtable, &pt.Tgnewtable); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTriggerByTgconstraint retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_tgconstraint_index'.
func PgTriggerByTgconstraint(ctx context.Context, db DB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, tgrelid, tgparentid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual, tgoldtable, tgnewtable ` +
		`FROM pg_catalog.pg_trigger ` +
		`WHERE tgconstraint = $1`
	// run
	logf(sqlstr, tgconstraint)
	rows, err := db.QueryContext(ctx, sqlstr, tgconstraint)
	if err != nil {
		return nil, logerror(err)
	}
	defer rows.Close()
	// process
	var res []*PgTrigger
	for rows.Next() {
		pt := PgTrigger{}
		// scan
		if err := rows.Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Tgrelid, &pt.Tgparentid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual, &pt.Tgoldtable, &pt.Tgnewtable); err != nil {
			return nil, logerror(err)
		}
		res = append(res, &pt)
	}
	if err := rows.Err(); err != nil {
		return nil, logerror(err)
	}
	return res, nil
}

// PgTriggerByTgrelidTgname retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_tgrelid_tgname_index'.
func PgTriggerByTgrelidTgname(ctx context.Context, db DB, tgrelid pgtypes.Oid, tgname string) (*PgTrigger, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, tgrelid, tgparentid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual, tgoldtable, tgnewtable ` +
		`FROM pg_catalog.pg_trigger ` +
		`WHERE tgrelid = $1 AND tgname = $2`
	// run
	logf(sqlstr, tgrelid, tgname)
	pt := PgTrigger{}
	if err := db.QueryRowContext(ctx, sqlstr, tgrelid, tgname).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Tgrelid, &pt.Tgparentid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual, &pt.Tgoldtable, &pt.Tgnewtable); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTsConfigByCfgnameCfgnamespace retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_cfgname_index'.
func PgTsConfigByCfgnameCfgnamespace(ctx context.Context, db DB, cfgname string, cfgnamespace pgtypes.Oid) (*PgTsConfig, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
		`FROM pg_catalog.pg_ts_config ` +
		`WHERE cfgname = $1 AND cfgnamespace = $2`
	// run
	logf(sqlstr, cfgname, cfgnamespace)
	ptc := PgTsConfig{}
	if err := db.QueryRowContext(ctx, sqlstr, cfgname, cfgnamespace).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Ctid, &ptc.Oid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser); err != nil {
		return nil, logerror(err)
	}
	return &ptc, nil
}

// PgTsConfigByOid retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_oid_index'.
func PgTsConfigByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTsConfig, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
		`FROM pg_catalog.pg_ts_config ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ptc := PgTsConfig{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Ctid, &ptc.Oid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser); err != nil {
		return nil, logerror(err)
	}
	return &ptc, nil
}

// PgTsConfigMapByMapcfgMaptokentypeMapseqno retrieves a row from 'pg_catalog.pg_ts_config_map' as a PgTsConfigMap.
//
// Generated from index 'pg_ts_config_map_index'.
func PgTsConfigMapByMapcfgMaptokentypeMapseqno(ctx context.Context, db DB, mapcfg pgtypes.Oid, maptokentype, mapseqno int) (*PgTsConfigMap, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict ` +
		`FROM pg_catalog.pg_ts_config_map ` +
		`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`
	// run
	logf(sqlstr, mapcfg, maptokentype, mapseqno)
	ptcm := PgTsConfigMap{}
	if err := db.QueryRowContext(ctx, sqlstr, mapcfg, maptokentype, mapseqno).Scan(&ptcm.Tableoid, &ptcm.Cmax, &ptcm.Xmax, &ptcm.Cmin, &ptcm.Xmin, &ptcm.Ctid, &ptcm.Mapcfg, &ptcm.Maptokentype, &ptcm.Mapseqno, &ptcm.Mapdict); err != nil {
		return nil, logerror(err)
	}
	return &ptcm, nil
}

// PgTsDictByDictnameDictnamespace retrieves a row from 'pg_catalog.pg_ts_dict' as a PgTsDict.
//
// Generated from index 'pg_ts_dict_dictname_index'.
func PgTsDictByDictnameDictnamespace(ctx context.Context, db DB, dictname string, dictnamespace pgtypes.Oid) (*PgTsDict, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
		`FROM pg_catalog.pg_ts_dict ` +
		`WHERE dictname = $1 AND dictnamespace = $2`
	// run
	logf(sqlstr, dictname, dictnamespace)
	ptd := PgTsDict{}
	if err := db.QueryRowContext(ctx, sqlstr, dictname, dictnamespace).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Ctid, &ptd.Oid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption); err != nil {
		return nil, logerror(err)
	}
	return &ptd, nil
}

// PgTsDictByOid retrieves a row from 'pg_catalog.pg_ts_dict' as a PgTsDict.
//
// Generated from index 'pg_ts_dict_oid_index'.
func PgTsDictByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTsDict, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
		`FROM pg_catalog.pg_ts_dict ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ptd := PgTsDict{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Ctid, &ptd.Oid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption); err != nil {
		return nil, logerror(err)
	}
	return &ptd, nil
}

// PgTsParserByOid retrieves a row from 'pg_catalog.pg_ts_parser' as a PgTsParser.
//
// Generated from index 'pg_ts_parser_oid_index'.
func PgTsParserByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTsParser, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
		`FROM pg_catalog.pg_ts_parser ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ptp := PgTsParser{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Ctid, &ptp.Oid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype); err != nil {
		return nil, logerror(err)
	}
	return &ptp, nil
}

// PgTsParserByPrsnamePrsnamespace retrieves a row from 'pg_catalog.pg_ts_parser' as a PgTsParser.
//
// Generated from index 'pg_ts_parser_prsname_index'.
func PgTsParserByPrsnamePrsnamespace(ctx context.Context, db DB, prsname string, prsnamespace pgtypes.Oid) (*PgTsParser, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
		`FROM pg_catalog.pg_ts_parser ` +
		`WHERE prsname = $1 AND prsnamespace = $2`
	// run
	logf(sqlstr, prsname, prsnamespace)
	ptp := PgTsParser{}
	if err := db.QueryRowContext(ctx, sqlstr, prsname, prsnamespace).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Ctid, &ptp.Oid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype); err != nil {
		return nil, logerror(err)
	}
	return &ptp, nil
}

// PgTsTemplateByOid retrieves a row from 'pg_catalog.pg_ts_template' as a PgTsTemplate.
//
// Generated from index 'pg_ts_template_oid_index'.
func PgTsTemplateByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgTsTemplate, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
		`FROM pg_catalog.pg_ts_template ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	ptt := PgTsTemplate{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Ctid, &ptt.Oid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize); err != nil {
		return nil, logerror(err)
	}
	return &ptt, nil
}

// PgTsTemplateByTmplnameTmplnamespace retrieves a row from 'pg_catalog.pg_ts_template' as a PgTsTemplate.
//
// Generated from index 'pg_ts_template_tmplname_index'.
func PgTsTemplateByTmplnameTmplnamespace(ctx context.Context, db DB, tmplname string, tmplnamespace pgtypes.Oid) (*PgTsTemplate, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
		`FROM pg_catalog.pg_ts_template ` +
		`WHERE tmplname = $1 AND tmplnamespace = $2`
	// run
	logf(sqlstr, tmplname, tmplnamespace)
	ptt := PgTsTemplate{}
	if err := db.QueryRowContext(ctx, sqlstr, tmplname, tmplnamespace).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Ctid, &ptt.Oid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize); err != nil {
		return nil, logerror(err)
	}
	return &ptt, nil
}

// PgTypeByOid retrieves a row from 'pg_catalog.pg_type' as a PgType.
//
// Generated from index 'pg_type_oid_index'.
func PgTypeByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgType, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl ` +
		`FROM pg_catalog.pg_type ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pt := PgType{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Typname, &pt.Typnamespace, &pt.Typowner, &pt.Typlen, &pt.Typbyval, &pt.Typtype, &pt.Typcategory, &pt.Typispreferred, &pt.Typisdefined, &pt.Typdelim, &pt.Typrelid, &pt.Typelem, &pt.Typarray, &pt.Typinput, &pt.Typoutput, &pt.Typreceive, &pt.Typsend, &pt.Typmodin, &pt.Typmodout, &pt.Typanalyze, &pt.Typalign, &pt.Typstorage, &pt.Typnotnull, &pt.Typbasetype, &pt.Typtypmod, &pt.Typndims, &pt.Typcollation, &pt.Typdefaultbin, &pt.Typdefault, &pt.Typacl); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgTypeByTypnameTypnamespace retrieves a row from 'pg_catalog.pg_type' as a PgType.
//
// Generated from index 'pg_type_typname_nsp_index'.
func PgTypeByTypnameTypnamespace(ctx context.Context, db DB, typname string, typnamespace pgtypes.Oid) (*PgType, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl ` +
		`FROM pg_catalog.pg_type ` +
		`WHERE typname = $1 AND typnamespace = $2`
	// run
	logf(sqlstr, typname, typnamespace)
	pt := PgType{}
	if err := db.QueryRowContext(ctx, sqlstr, typname, typnamespace).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Ctid, &pt.Oid, &pt.Typname, &pt.Typnamespace, &pt.Typowner, &pt.Typlen, &pt.Typbyval, &pt.Typtype, &pt.Typcategory, &pt.Typispreferred, &pt.Typisdefined, &pt.Typdelim, &pt.Typrelid, &pt.Typelem, &pt.Typarray, &pt.Typinput, &pt.Typoutput, &pt.Typreceive, &pt.Typsend, &pt.Typmodin, &pt.Typmodout, &pt.Typanalyze, &pt.Typalign, &pt.Typstorage, &pt.Typnotnull, &pt.Typbasetype, &pt.Typtypmod, &pt.Typndims, &pt.Typcollation, &pt.Typdefaultbin, &pt.Typdefault, &pt.Typacl); err != nil {
		return nil, logerror(err)
	}
	return &pt, nil
}

// PgUserMappingByOid retrieves a row from 'pg_catalog.pg_user_mapping' as a PgUserMapping.
//
// Generated from index 'pg_user_mapping_oid_index'.
func PgUserMappingByOid(ctx context.Context, db DB, oid pgtypes.Oid) (*PgUserMapping, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, umuser, umserver, umoptions ` +
		`FROM pg_catalog.pg_user_mapping ` +
		`WHERE oid = $1`
	// run
	logf(sqlstr, oid)
	pum := PgUserMapping{}
	if err := db.QueryRowContext(ctx, sqlstr, oid).Scan(&pum.Tableoid, &pum.Cmax, &pum.Xmax, &pum.Cmin, &pum.Xmin, &pum.Ctid, &pum.Oid, &pum.Umuser, &pum.Umserver, &pum.Umoptions); err != nil {
		return nil, logerror(err)
	}
	return &pum, nil
}

// PgUserMappingByUmuserUmserver retrieves a row from 'pg_catalog.pg_user_mapping' as a PgUserMapping.
//
// Generated from index 'pg_user_mapping_user_server_index'.
func PgUserMappingByUmuserUmserver(ctx context.Context, db DB, umuser, umserver pgtypes.Oid) (*PgUserMapping, error) {
	// query
	const sqlstr = `SELECT ` +
		`tableoid, cmax, xmax, cmin, xmin, ctid, oid, umuser, umserver, umoptions ` +
		`FROM pg_catalog.pg_user_mapping ` +
		`WHERE umuser = $1 AND umserver = $2`
	// run
	logf(sqlstr, umuser, umserver)
	pum := PgUserMapping{}
	if err := db.QueryRowContext(ctx, sqlstr, umuser, umserver).Scan(&pum.Tableoid, &pum.Cmax, &pum.Xmax, &pum.Cmin, &pum.Xmin, &pum.Ctid, &pum.Oid, &pum.Umuser, &pum.Umserver, &pum.Umoptions); err != nil {
		return nil, logerror(err)
	}
	return &pum, nil
}

// ASCII calls the stored function 'pg_catalog.ascii(text) integer' on db.
func ASCII(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.ascii
	const sqlstr = `SELECT * FROM pg_catalog.ascii($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// AbbrevByInet calls the stored function 'pg_catalog.abbrev(inet) text' on db.
func AbbrevByInet(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.abbrev
	const sqlstr = `SELECT * FROM pg_catalog.abbrev($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// AbbrevByCidr calls the stored function 'pg_catalog.abbrev(cidr) text' on db.
func AbbrevByCidr(ctx context.Context, db DB, p0 pgtypes.Cidr) (string, error) {
	// call pg_catalog.abbrev
	const sqlstr = `SELECT * FROM pg_catalog.abbrev($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// AbsByReal calls the stored function 'pg_catalog.abs(real) real' on db.
func AbsByReal(ctx context.Context, db DB, p0 float32) (float32, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// AbsByDoublePrecision calls the stored function 'pg_catalog.abs(double precision) double precision' on db.
func AbsByDoublePrecision(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// AbsByBigint calls the stored function 'pg_catalog.abs(bigint) bigint' on db.
func AbsByBigint(ctx context.Context, db DB, p0 int64) (int64, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 int64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// AbsByInteger calls the stored function 'pg_catalog.abs(integer) integer' on db.
func AbsByInteger(ctx context.Context, db DB, p0 int) (int, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// AbsBySmallint calls the stored function 'pg_catalog.abs(smallint) smallint' on db.
func AbsBySmallint(ctx context.Context, db DB, p0 int16) (int16, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 int16
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// AbsByNumeric calls the stored function 'pg_catalog.abs(numeric) numeric' on db.
func AbsByNumeric(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.abs
	const sqlstr = `SELECT * FROM pg_catalog.abs($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Aclcontains calls the stored function 'pg_catalog.aclcontains(aclitem, aclitem) boolean' on db.
func Aclcontains(ctx context.Context, db DB, p0 []pgtypes.Aclitem, p1 pgtypes.Aclitem) (bool, error) {
	// call pg_catalog.aclcontains
	const sqlstr = `SELECT * FROM pg_catalog.aclcontains($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Acldefault calls the stored function 'pg_catalog.acldefault("char", oid) aclitem' on db.
func Acldefault(ctx context.Context, db DB, p0 pgtypes.Char, p1 pgtypes.Oid) ([]pgtypes.Aclitem, error) {
	// call pg_catalog.acldefault
	const sqlstr = `SELECT * FROM pg_catalog.acldefault($1, $2)`
	// run
	var r0 []pgtypes.Aclitem
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Aclexplode calls the stored function 'pg_catalog.aclexplode(aclitem) (oid, oid, text, boolean)' on db.
func Aclexplode(ctx context.Context, db DB, acl []pgtypes.Aclitem) (pgtypes.Oid, pgtypes.Oid, string, bool, error) {
	// call pg_catalog.aclexplode
	const sqlstr = `SELECT * FROM pg_catalog.aclexplode($1)`
	// run
	var grantor pgtypes.Oid
	var grantee pgtypes.Oid
	var privilegeType string
	var isGrantable bool
	logf(sqlstr, acl)
	if err := db.QueryRowContext(ctx, sqlstr, acl).Scan(&grantor, &grantee, &privilegeType, &isGrantable); err != nil {
		return pgtypes.Oid{}, pgtypes.Oid{}, "", false, logerror(err)
	}
	return grantor, grantee, privilegeType, isGrantable, nil
}

// Aclinsert calls the stored function 'pg_catalog.aclinsert(aclitem, aclitem) aclitem' on db.
func Aclinsert(ctx context.Context, db DB, p0 []pgtypes.Aclitem, p1 pgtypes.Aclitem) ([]pgtypes.Aclitem, error) {
	// call pg_catalog.aclinsert
	const sqlstr = `SELECT * FROM pg_catalog.aclinsert($1, $2)`
	// run
	var r0 []pgtypes.Aclitem
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Aclitemeq calls the stored function 'pg_catalog.aclitemeq(aclitem, aclitem) boolean' on db.
func Aclitemeq(ctx context.Context, db DB, p0, p1 pgtypes.Aclitem) (bool, error) {
	// call pg_catalog.aclitemeq
	const sqlstr = `SELECT * FROM pg_catalog.aclitemeq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Aclremove calls the stored function 'pg_catalog.aclremove(aclitem, aclitem) aclitem' on db.
func Aclremove(ctx context.Context, db DB, p0 []pgtypes.Aclitem, p1 pgtypes.Aclitem) ([]pgtypes.Aclitem, error) {
	// call pg_catalog.aclremove
	const sqlstr = `SELECT * FROM pg_catalog.aclremove($1, $2)`
	// run
	var r0 []pgtypes.Aclitem
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Acos calls the stored function 'pg_catalog.acos(double precision) double precision' on db.
func Acos(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.acos
	const sqlstr = `SELECT * FROM pg_catalog.acos($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Acosd calls the stored function 'pg_catalog.acosd(double precision) double precision' on db.
func Acosd(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.acosd
	const sqlstr = `SELECT * FROM pg_catalog.acosd($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Acosh calls the stored function 'pg_catalog.acosh(double precision) double precision' on db.
func Acosh(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.acosh
	const sqlstr = `SELECT * FROM pg_catalog.acosh($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// AgeByXid calls the stored function 'pg_catalog.age(xid) integer' on db.
func AgeByXid(ctx context.Context, db DB, p0 pgtypes.Xid) (int, error) {
	// call pg_catalog.age
	const sqlstr = `SELECT * FROM pg_catalog.age($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// AgeByTimestampWithTimeZoneAndTimestampWithTimeZone calls the stored function 'pg_catalog.age(timestamp with time zone, timestamp with time zone) interval' on db.
func AgeByTimestampWithTimeZoneAndTimestampWithTimeZone(ctx context.Context, db DB, p0, p1 time.Time) ([]byte, error) {
	// call pg_catalog.age
	const sqlstr = `SELECT * FROM pg_catalog.age($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// AgeByTimestampWithTimeZone calls the stored function 'pg_catalog.age(timestamp with time zone) interval' on db.
func AgeByTimestampWithTimeZone(ctx context.Context, db DB, p0 time.Time) ([]byte, error) {
	// call pg_catalog.age
	const sqlstr = `SELECT * FROM pg_catalog.age($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// AgeByTimestampWithoutTimeZoneAndTimestampWithoutTimeZone calls the stored function 'pg_catalog.age(timestamp without time zone, timestamp without time zone) interval' on db.
func AgeByTimestampWithoutTimeZoneAndTimestampWithoutTimeZone(ctx context.Context, db DB, p0, p1 time.Time) ([]byte, error) {
	// call pg_catalog.age
	const sqlstr = `SELECT * FROM pg_catalog.age($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// AgeByTimestampWithoutTimeZone calls the stored function 'pg_catalog.age(timestamp without time zone) interval' on db.
func AgeByTimestampWithoutTimeZone(ctx context.Context, db DB, p0 time.Time) ([]byte, error) {
	// call pg_catalog.age
	const sqlstr = `SELECT * FROM pg_catalog.age($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Amvalidate calls the stored function 'pg_catalog.amvalidate(oid) boolean' on db.
func Amvalidate(ctx context.Context, db DB, p0 pgtypes.Oid) (bool, error) {
	// call pg_catalog.amvalidate
	const sqlstr = `SELECT * FROM pg_catalog.amvalidate($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// AnyarrayRecv calls the stored function 'pg_catalog.anyarray_recv(internal) anyarray' on db.
func AnyarrayRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Anyarray, error) {
	// call pg_catalog.anyarray_recv
	const sqlstr = `SELECT * FROM pg_catalog.anyarray_recv($1)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// AnyarraySend calls the stored function 'pg_catalog.anyarray_send(anyarray) bytea' on db.
func AnyarraySend(ctx context.Context, db DB, p0 pgtypes.Anyarray) ([]byte, error) {
	// call pg_catalog.anyarray_send
	const sqlstr = `SELECT * FROM pg_catalog.anyarray_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// AnycompatiblearrayRecv calls the stored function 'pg_catalog.anycompatiblearray_recv(internal) anycompatiblearray' on db.
func AnycompatiblearrayRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Anycompatiblearray, error) {
	// call pg_catalog.anycompatiblearray_recv
	const sqlstr = `SELECT * FROM pg_catalog.anycompatiblearray_recv($1)`
	// run
	var r0 pgtypes.Anycompatiblearray
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Anycompatiblearray{}, logerror(err)
	}
	return r0, nil
}

// AnycompatiblearraySend calls the stored function 'pg_catalog.anycompatiblearray_send(anycompatiblearray) bytea' on db.
func AnycompatiblearraySend(ctx context.Context, db DB, p0 pgtypes.Anycompatiblearray) ([]byte, error) {
	// call pg_catalog.anycompatiblearray_send
	const sqlstr = `SELECT * FROM pg_catalog.anycompatiblearray_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Anytextcat calls the stored function 'pg_catalog.anytextcat(anynonarray, text) text' on db.
func Anytextcat(ctx context.Context, db DB, p0 pgtypes.Anynonarray, p1 string) (string, error) {
	// call pg_catalog.anytextcat
	const sqlstr = `SELECT * FROM pg_catalog.anytextcat($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// AreaByCircle calls the stored function 'pg_catalog.area(circle) double precision' on db.
func AreaByCircle(ctx context.Context, db DB, p0 pgtypes.Circle) (float64, error) {
	// call pg_catalog.area
	const sqlstr = `SELECT * FROM pg_catalog.area($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// AreaByBox calls the stored function 'pg_catalog.area(box) double precision' on db.
func AreaByBox(ctx context.Context, db DB, p0 pgtypes.Box) (float64, error) {
	// call pg_catalog.area
	const sqlstr = `SELECT * FROM pg_catalog.area($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// AreaByPath calls the stored function 'pg_catalog.area(path) double precision' on db.
func AreaByPath(ctx context.Context, db DB, p0 pgtypes.Path) (float64, error) {
	// call pg_catalog.area
	const sqlstr = `SELECT * FROM pg_catalog.area($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Areajoinsel calls the stored function 'pg_catalog.areajoinsel(internal, oid, internal, smallint, internal) double precision' on db.
func Areajoinsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int16, p4 pgtypes.Internal) (float64, error) {
	// call pg_catalog.areajoinsel
	const sqlstr = `SELECT * FROM pg_catalog.areajoinsel($1, $2, $3, $4, $5)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3, p4)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3, p4).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Areasel calls the stored function 'pg_catalog.areasel(internal, oid, internal, integer) double precision' on db.
func Areasel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int) (float64, error) {
	// call pg_catalog.areasel
	const sqlstr = `SELECT * FROM pg_catalog.areasel($1, $2, $3, $4)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// ArrayAggArrayFinalfn calls the stored function 'pg_catalog.array_agg_array_finalfn(internal, anyarray) anyarray' on db.
func ArrayAggArrayFinalfn(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Anyarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_agg_array_finalfn
	const sqlstr = `SELECT * FROM pg_catalog.array_agg_array_finalfn($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayAggArrayTransfn calls the stored function 'pg_catalog.array_agg_array_transfn(internal, anyarray) internal' on db.
func ArrayAggArrayTransfn(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Anyarray) (pgtypes.Internal, error) {
	// call pg_catalog.array_agg_array_transfn
	const sqlstr = `SELECT * FROM pg_catalog.array_agg_array_transfn($1, $2)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// ArrayAggFinalfn calls the stored function 'pg_catalog.array_agg_finalfn(internal, anynonarray) anyarray' on db.
func ArrayAggFinalfn(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Anynonarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_agg_finalfn
	const sqlstr = `SELECT * FROM pg_catalog.array_agg_finalfn($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayAggTransfn calls the stored function 'pg_catalog.array_agg_transfn(internal, anynonarray) internal' on db.
func ArrayAggTransfn(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Anynonarray) (pgtypes.Internal, error) {
	// call pg_catalog.array_agg_transfn
	const sqlstr = `SELECT * FROM pg_catalog.array_agg_transfn($1, $2)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// ArrayAppend calls the stored function 'pg_catalog.array_append(anyarray, anyelement) anyarray' on db.
func ArrayAppend(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 pgtypes.Anyelement) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_append
	const sqlstr = `SELECT * FROM pg_catalog.array_append($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayCat calls the stored function 'pg_catalog.array_cat(anyarray, anyarray) anyarray' on db.
func ArrayCat(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_cat
	const sqlstr = `SELECT * FROM pg_catalog.array_cat($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayDims calls the stored function 'pg_catalog.array_dims(anyarray) text' on db.
func ArrayDims(ctx context.Context, db DB, p0 pgtypes.Anyarray) (string, error) {
	// call pg_catalog.array_dims
	const sqlstr = `SELECT * FROM pg_catalog.array_dims($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// ArrayEq calls the stored function 'pg_catalog.array_eq(anyarray, anyarray) boolean' on db.
func ArrayEq(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_eq
	const sqlstr = `SELECT * FROM pg_catalog.array_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayFillByAnyelementAndInteger calls the stored function 'pg_catalog.array_fill(anyelement, integer) anyarray' on db.
func ArrayFillByAnyelementAndInteger(ctx context.Context, db DB, p0 pgtypes.Anyelement, p1 []int) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_fill
	const sqlstr = `SELECT * FROM pg_catalog.array_fill($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayFillByAnyelementIntegerAndInteger calls the stored function 'pg_catalog.array_fill(anyelement, integer, integer) anyarray' on db.
func ArrayFillByAnyelementIntegerAndInteger(ctx context.Context, db DB, p0 pgtypes.Anyelement, p1, p2 []int) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_fill
	const sqlstr = `SELECT * FROM pg_catalog.array_fill($1, $2, $3)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayGe calls the stored function 'pg_catalog.array_ge(anyarray, anyarray) boolean' on db.
func ArrayGe(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_ge
	const sqlstr = `SELECT * FROM pg_catalog.array_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayGt calls the stored function 'pg_catalog.array_gt(anyarray, anyarray) boolean' on db.
func ArrayGt(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_gt
	const sqlstr = `SELECT * FROM pg_catalog.array_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayLarger calls the stored function 'pg_catalog.array_larger(anyarray, anyarray) anyarray' on db.
func ArrayLarger(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_larger
	const sqlstr = `SELECT * FROM pg_catalog.array_larger($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayLe calls the stored function 'pg_catalog.array_le(anyarray, anyarray) boolean' on db.
func ArrayLe(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_le
	const sqlstr = `SELECT * FROM pg_catalog.array_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayLength calls the stored function 'pg_catalog.array_length(anyarray, integer) integer' on db.
func ArrayLength(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 int) (int, error) {
	// call pg_catalog.array_length
	const sqlstr = `SELECT * FROM pg_catalog.array_length($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// ArrayLower calls the stored function 'pg_catalog.array_lower(anyarray, integer) integer' on db.
func ArrayLower(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 int) (int, error) {
	// call pg_catalog.array_lower
	const sqlstr = `SELECT * FROM pg_catalog.array_lower($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// ArrayLt calls the stored function 'pg_catalog.array_lt(anyarray, anyarray) boolean' on db.
func ArrayLt(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_lt
	const sqlstr = `SELECT * FROM pg_catalog.array_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayNdims calls the stored function 'pg_catalog.array_ndims(anyarray) integer' on db.
func ArrayNdims(ctx context.Context, db DB, p0 pgtypes.Anyarray) (int, error) {
	// call pg_catalog.array_ndims
	const sqlstr = `SELECT * FROM pg_catalog.array_ndims($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// ArrayNe calls the stored function 'pg_catalog.array_ne(anyarray, anyarray) boolean' on db.
func ArrayNe(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.array_ne
	const sqlstr = `SELECT * FROM pg_catalog.array_ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayPositionByAnyarrayAndAnyelement calls the stored function 'pg_catalog.array_position(anyarray, anyelement) integer' on db.
func ArrayPositionByAnyarrayAndAnyelement(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 pgtypes.Anyelement) (int, error) {
	// call pg_catalog.array_position
	const sqlstr = `SELECT * FROM pg_catalog.array_position($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// ArrayPositionByAnyarrayAnyelementAndInteger calls the stored function 'pg_catalog.array_position(anyarray, anyelement, integer) integer' on db.
func ArrayPositionByAnyarrayAnyelementAndInteger(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 pgtypes.Anyelement, p2 int) (int, error) {
	// call pg_catalog.array_position
	const sqlstr = `SELECT * FROM pg_catalog.array_position($1, $2, $3)`
	// run
	var r0 int
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// ArrayPositions calls the stored function 'pg_catalog.array_positions(anyarray, anyelement) integer' on db.
func ArrayPositions(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 pgtypes.Anyelement) ([]int, error) {
	// call pg_catalog.array_positions
	const sqlstr = `SELECT * FROM pg_catalog.array_positions($1, $2)`
	// run
	var r0 []int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ArrayPrepend calls the stored function 'pg_catalog.array_prepend(anyelement, anyarray) anyarray' on db.
func ArrayPrepend(ctx context.Context, db DB, p0 pgtypes.Anyelement, p1 pgtypes.Anyarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_prepend
	const sqlstr = `SELECT * FROM pg_catalog.array_prepend($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayRecv calls the stored function 'pg_catalog.array_recv(internal, oid, integer) anyarray' on db.
func ArrayRecv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 int) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_recv
	const sqlstr = `SELECT * FROM pg_catalog.array_recv($1, $2, $3)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayRemove calls the stored function 'pg_catalog.array_remove(anyarray, anyelement) anyarray' on db.
func ArrayRemove(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 pgtypes.Anyelement) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_remove
	const sqlstr = `SELECT * FROM pg_catalog.array_remove($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayReplace calls the stored function 'pg_catalog.array_replace(anyarray, anyelement, anyelement) anyarray' on db.
func ArrayReplace(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1, p2 pgtypes.Anyelement) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_replace
	const sqlstr = `SELECT * FROM pg_catalog.array_replace($1, $2, $3)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArraySend calls the stored function 'pg_catalog.array_send(anyarray) bytea' on db.
func ArraySend(ctx context.Context, db DB, p0 pgtypes.Anyarray) ([]byte, error) {
	// call pg_catalog.array_send
	const sqlstr = `SELECT * FROM pg_catalog.array_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ArraySmaller calls the stored function 'pg_catalog.array_smaller(anyarray, anyarray) anyarray' on db.
func ArraySmaller(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (pgtypes.Anyarray, error) {
	// call pg_catalog.array_smaller
	const sqlstr = `SELECT * FROM pg_catalog.array_smaller($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// ArrayToJSONByAnyarray calls the stored function 'pg_catalog.array_to_json(anyarray) json' on db.
func ArrayToJSONByAnyarray(ctx context.Context, db DB, p0 pgtypes.Anyarray) ([]byte, error) {
	// call pg_catalog.array_to_json
	const sqlstr = `SELECT * FROM pg_catalog.array_to_json($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ArrayToJSONByAnyarrayAndBoolean calls the stored function 'pg_catalog.array_to_json(anyarray, boolean) json' on db.
func ArrayToJSONByAnyarrayAndBoolean(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 bool) ([]byte, error) {
	// call pg_catalog.array_to_json
	const sqlstr = `SELECT * FROM pg_catalog.array_to_json($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ArrayToStringByAnyarrayTextAndText calls the stored function 'pg_catalog.array_to_string(anyarray, text, text) text' on db.
func ArrayToStringByAnyarrayTextAndText(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1, p2 string) (string, error) {
	// call pg_catalog.array_to_string
	const sqlstr = `SELECT * FROM pg_catalog.array_to_string($1, $2, $3)`
	// run
	var r0 string
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// ArrayToStringByAnyarrayAndText calls the stored function 'pg_catalog.array_to_string(anyarray, text) text' on db.
func ArrayToStringByAnyarrayAndText(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 string) (string, error) {
	// call pg_catalog.array_to_string
	const sqlstr = `SELECT * FROM pg_catalog.array_to_string($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// ArrayToTsvector calls the stored function 'pg_catalog.array_to_tsvector(text) tsvector' on db.
func ArrayToTsvector(ctx context.Context, db DB, p0 StringSlice) (pgtypes.Tsvector, error) {
	// call pg_catalog.array_to_tsvector
	const sqlstr = `SELECT * FROM pg_catalog.array_to_tsvector($1)`
	// run
	var r0 pgtypes.Tsvector
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Tsvector{}, logerror(err)
	}
	return r0, nil
}

// ArrayTypanalyze calls the stored function 'pg_catalog.array_typanalyze(internal) boolean' on db.
func ArrayTypanalyze(ctx context.Context, db DB, p0 pgtypes.Internal) (bool, error) {
	// call pg_catalog.array_typanalyze
	const sqlstr = `SELECT * FROM pg_catalog.array_typanalyze($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ArrayUnnestSupport calls the stored function 'pg_catalog.array_unnest_support(internal) internal' on db.
func ArrayUnnestSupport(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.array_unnest_support
	const sqlstr = `SELECT * FROM pg_catalog.array_unnest_support($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// ArrayUpper calls the stored function 'pg_catalog.array_upper(anyarray, integer) integer' on db.
func ArrayUpper(ctx context.Context, db DB, p0 pgtypes.Anyarray, p1 int) (int, error) {
	// call pg_catalog.array_upper
	const sqlstr = `SELECT * FROM pg_catalog.array_upper($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Arraycontained calls the stored function 'pg_catalog.arraycontained(anyarray, anyarray) boolean' on db.
func Arraycontained(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.arraycontained
	const sqlstr = `SELECT * FROM pg_catalog.arraycontained($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Arraycontains calls the stored function 'pg_catalog.arraycontains(anyarray, anyarray) boolean' on db.
func Arraycontains(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.arraycontains
	const sqlstr = `SELECT * FROM pg_catalog.arraycontains($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Arraycontjoinsel calls the stored function 'pg_catalog.arraycontjoinsel(internal, oid, internal, smallint, internal) double precision' on db.
func Arraycontjoinsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int16, p4 pgtypes.Internal) (float64, error) {
	// call pg_catalog.arraycontjoinsel
	const sqlstr = `SELECT * FROM pg_catalog.arraycontjoinsel($1, $2, $3, $4, $5)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3, p4)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3, p4).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Arraycontsel calls the stored function 'pg_catalog.arraycontsel(internal, oid, internal, integer) double precision' on db.
func Arraycontsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int) (float64, error) {
	// call pg_catalog.arraycontsel
	const sqlstr = `SELECT * FROM pg_catalog.arraycontsel($1, $2, $3, $4)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Arrayoverlap calls the stored function 'pg_catalog.arrayoverlap(anyarray, anyarray) boolean' on db.
func Arrayoverlap(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (bool, error) {
	// call pg_catalog.arrayoverlap
	const sqlstr = `SELECT * FROM pg_catalog.arrayoverlap($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Asin calls the stored function 'pg_catalog.asin(double precision) double precision' on db.
func Asin(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.asin
	const sqlstr = `SELECT * FROM pg_catalog.asin($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Asind calls the stored function 'pg_catalog.asind(double precision) double precision' on db.
func Asind(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.asind
	const sqlstr = `SELECT * FROM pg_catalog.asind($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Asinh calls the stored function 'pg_catalog.asinh(double precision) double precision' on db.
func Asinh(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.asinh
	const sqlstr = `SELECT * FROM pg_catalog.asinh($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Atan calls the stored function 'pg_catalog.atan(double precision) double precision' on db.
func Atan(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.atan
	const sqlstr = `SELECT * FROM pg_catalog.atan($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Atan2 calls the stored function 'pg_catalog.atan2(double precision, double precision) double precision' on db.
func Atan2(ctx context.Context, db DB, p0, p1 float64) (float64, error) {
	// call pg_catalog.atan2
	const sqlstr = `SELECT * FROM pg_catalog.atan2($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Atan2d calls the stored function 'pg_catalog.atan2d(double precision, double precision) double precision' on db.
func Atan2d(ctx context.Context, db DB, p0, p1 float64) (float64, error) {
	// call pg_catalog.atan2d
	const sqlstr = `SELECT * FROM pg_catalog.atan2d($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Atand calls the stored function 'pg_catalog.atand(double precision) double precision' on db.
func Atand(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.atand
	const sqlstr = `SELECT * FROM pg_catalog.atand($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Atanh calls the stored function 'pg_catalog.atanh(double precision) double precision' on db.
func Atanh(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.atanh
	const sqlstr = `SELECT * FROM pg_catalog.atanh($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Bernoulli calls the stored function 'pg_catalog.bernoulli(internal) tsm_handler' on db.
func Bernoulli(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.TsmHandler, error) {
	// call pg_catalog.bernoulli
	const sqlstr = `SELECT * FROM pg_catalog.bernoulli($1)`
	// run
	var r0 pgtypes.TsmHandler
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.TsmHandler{}, logerror(err)
	}
	return r0, nil
}

// Big5ToEucTw calls the stored function 'pg_catalog.big5_to_euc_tw(integer, integer, cstring, internal, integer)' on db.
func Big5ToEucTw(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.big5_to_euc_tw
	const sqlstr = `SELECT * FROM pg_catalog.big5_to_euc_tw($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// Big5ToMic calls the stored function 'pg_catalog.big5_to_mic(integer, integer, cstring, internal, integer)' on db.
func Big5ToMic(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.big5_to_mic
	const sqlstr = `SELECT * FROM pg_catalog.big5_to_mic($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// Big5ToUTF8 calls the stored function 'pg_catalog.big5_to_utf8(integer, integer, cstring, internal, integer)' on db.
func Big5ToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.big5_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.big5_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeCreateEmptyExtension calls the stored function 'pg_catalog.binary_upgrade_create_empty_extension(text, text, boolean, text, oid, text, text)' on db.
func BinaryUpgradeCreateEmptyExtension(ctx context.Context, db DB, p0, p1 string, p2 bool, p3 string, p4 []pgtypes.Oid, p5, p6 StringSlice) error {
	// call pg_catalog.binary_upgrade_create_empty_extension
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_create_empty_extension($1, $2, $3, $4, $5, $6, $7)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4, p5, p6); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetMissingValue calls the stored function 'pg_catalog.binary_upgrade_set_missing_value(oid, text, text)' on db.
func BinaryUpgradeSetMissingValue(ctx context.Context, db DB, p0 pgtypes.Oid, p1, p2 string) error {
	// call pg_catalog.binary_upgrade_set_missing_value
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_missing_value($1, $2, $3)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextArrayPgTypeOid calls the stored function 'pg_catalog.binary_upgrade_set_next_array_pg_type_oid(oid)' on db.
func BinaryUpgradeSetNextArrayPgTypeOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_array_pg_type_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_array_pg_type_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextHeapPgClassOid calls the stored function 'pg_catalog.binary_upgrade_set_next_heap_pg_class_oid(oid)' on db.
func BinaryUpgradeSetNextHeapPgClassOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_heap_pg_class_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_heap_pg_class_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextIndexPgClassOid calls the stored function 'pg_catalog.binary_upgrade_set_next_index_pg_class_oid(oid)' on db.
func BinaryUpgradeSetNextIndexPgClassOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_index_pg_class_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_index_pg_class_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextPgAuthidOid calls the stored function 'pg_catalog.binary_upgrade_set_next_pg_authid_oid(oid)' on db.
func BinaryUpgradeSetNextPgAuthidOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_pg_authid_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_pg_authid_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextPgEnumOid calls the stored function 'pg_catalog.binary_upgrade_set_next_pg_enum_oid(oid)' on db.
func BinaryUpgradeSetNextPgEnumOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_pg_enum_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_pg_enum_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextPgTypeOid calls the stored function 'pg_catalog.binary_upgrade_set_next_pg_type_oid(oid)' on db.
func BinaryUpgradeSetNextPgTypeOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_pg_type_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_pg_type_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextToastPgClassOid calls the stored function 'pg_catalog.binary_upgrade_set_next_toast_pg_class_oid(oid)' on db.
func BinaryUpgradeSetNextToastPgClassOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_toast_pg_class_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_toast_pg_class_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetNextToastPgTypeOid calls the stored function 'pg_catalog.binary_upgrade_set_next_toast_pg_type_oid(oid)' on db.
func BinaryUpgradeSetNextToastPgTypeOid(ctx context.Context, db DB, p0 pgtypes.Oid) error {
	// call pg_catalog.binary_upgrade_set_next_toast_pg_type_oid
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_next_toast_pg_type_oid($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BinaryUpgradeSetRecordInitPrivs calls the stored function 'pg_catalog.binary_upgrade_set_record_init_privs(boolean)' on db.
func BinaryUpgradeSetRecordInitPrivs(ctx context.Context, db DB, p0 bool) error {
	// call pg_catalog.binary_upgrade_set_record_init_privs
	const sqlstr = `SELECT * FROM pg_catalog.binary_upgrade_set_record_init_privs($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// BitByIntegerAndInteger calls the stored function 'pg_catalog.bit(integer, integer) bit' on db.
func BitByIntegerAndInteger(ctx context.Context, db DB, p0, p1 int) (uint8, error) {
	// call pg_catalog.bit
	const sqlstr = `SELECT * FROM pg_catalog.bit($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitByBitIntegerAndBoolean calls the stored function 'pg_catalog.bit(bit, integer, boolean) bit' on db.
func BitByBitIntegerAndBoolean(ctx context.Context, db DB, p0 uint8, p1 int, p2 bool) (uint8, error) {
	// call pg_catalog.bit
	const sqlstr = `SELECT * FROM pg_catalog.bit($1, $2, $3)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitByBigintAndInteger calls the stored function 'pg_catalog.bit(bigint, integer) bit' on db.
func BitByBigintAndInteger(ctx context.Context, db DB, p0 int64, p1 int) (uint8, error) {
	// call pg_catalog.bit
	const sqlstr = `SELECT * FROM pg_catalog.bit($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitLengthByBytea calls the stored function 'pg_catalog.bit_length(bytea) integer' on db.
func BitLengthByBytea(ctx context.Context, db DB, p0 []byte) (int, error) {
	// call pg_catalog.bit_length
	const sqlstr = `SELECT * FROM pg_catalog.bit_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitLengthByText calls the stored function 'pg_catalog.bit_length(text) integer' on db.
func BitLengthByText(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.bit_length
	const sqlstr = `SELECT * FROM pg_catalog.bit_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitLengthByBit calls the stored function 'pg_catalog.bit_length(bit) integer' on db.
func BitLengthByBit(ctx context.Context, db DB, p0 uint8) (int, error) {
	// call pg_catalog.bit_length
	const sqlstr = `SELECT * FROM pg_catalog.bit_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitRecv calls the stored function 'pg_catalog.bit_recv(internal, oid, integer) bit' on db.
func BitRecv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 int) (uint8, error) {
	// call pg_catalog.bit_recv
	const sqlstr = `SELECT * FROM pg_catalog.bit_recv($1, $2, $3)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BitSend calls the stored function 'pg_catalog.bit_send(bit) bytea' on db.
func BitSend(ctx context.Context, db DB, p0 uint8) ([]byte, error) {
	// call pg_catalog.bit_send
	const sqlstr = `SELECT * FROM pg_catalog.bit_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Bitand calls the stored function 'pg_catalog.bitand(bit, bit) bit' on db.
func Bitand(ctx context.Context, db DB, p0, p1 uint8) (uint8, error) {
	// call pg_catalog.bitand
	const sqlstr = `SELECT * FROM pg_catalog.bitand($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bitcat calls the stored function 'pg_catalog.bitcat(bit varying, bit varying) bit varying' on db.
func Bitcat(ctx context.Context, db DB, p0, p1 []byte) ([]byte, error) {
	// call pg_catalog.bitcat
	const sqlstr = `SELECT * FROM pg_catalog.bitcat($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Bitcmp calls the stored function 'pg_catalog.bitcmp(bit, bit) integer' on db.
func Bitcmp(ctx context.Context, db DB, p0, p1 uint8) (int, error) {
	// call pg_catalog.bitcmp
	const sqlstr = `SELECT * FROM pg_catalog.bitcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Biteq calls the stored function 'pg_catalog.biteq(bit, bit) boolean' on db.
func Biteq(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.biteq
	const sqlstr = `SELECT * FROM pg_catalog.biteq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitge calls the stored function 'pg_catalog.bitge(bit, bit) boolean' on db.
func Bitge(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.bitge
	const sqlstr = `SELECT * FROM pg_catalog.bitge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitgt calls the stored function 'pg_catalog.bitgt(bit, bit) boolean' on db.
func Bitgt(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.bitgt
	const sqlstr = `SELECT * FROM pg_catalog.bitgt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitle calls the stored function 'pg_catalog.bitle(bit, bit) boolean' on db.
func Bitle(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.bitle
	const sqlstr = `SELECT * FROM pg_catalog.bitle($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitlt calls the stored function 'pg_catalog.bitlt(bit, bit) boolean' on db.
func Bitlt(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.bitlt
	const sqlstr = `SELECT * FROM pg_catalog.bitlt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitne calls the stored function 'pg_catalog.bitne(bit, bit) boolean' on db.
func Bitne(ctx context.Context, db DB, p0, p1 uint8) (bool, error) {
	// call pg_catalog.bitne
	const sqlstr = `SELECT * FROM pg_catalog.bitne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bitnot calls the stored function 'pg_catalog.bitnot(bit) bit' on db.
func Bitnot(ctx context.Context, db DB, p0 uint8) (uint8, error) {
	// call pg_catalog.bitnot
	const sqlstr = `SELECT * FROM pg_catalog.bitnot($1)`
	// run
	var r0 uint8
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bitor calls the stored function 'pg_catalog.bitor(bit, bit) bit' on db.
func Bitor(ctx context.Context, db DB, p0, p1 uint8) (uint8, error) {
	// call pg_catalog.bitor
	const sqlstr = `SELECT * FROM pg_catalog.bitor($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bitshiftleft calls the stored function 'pg_catalog.bitshiftleft(bit, integer) bit' on db.
func Bitshiftleft(ctx context.Context, db DB, p0 uint8, p1 int) (uint8, error) {
	// call pg_catalog.bitshiftleft
	const sqlstr = `SELECT * FROM pg_catalog.bitshiftleft($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bitshiftright calls the stored function 'pg_catalog.bitshiftright(bit, integer) bit' on db.
func Bitshiftright(ctx context.Context, db DB, p0 uint8, p1 int) (uint8, error) {
	// call pg_catalog.bitshiftright
	const sqlstr = `SELECT * FROM pg_catalog.bitshiftright($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bittypmodin calls the stored function 'pg_catalog.bittypmodin(cstring) integer' on db.
func Bittypmodin(ctx context.Context, db DB, p0 []pgtypes.Cstring) (int, error) {
	// call pg_catalog.bittypmodin
	const sqlstr = `SELECT * FROM pg_catalog.bittypmodin($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bitxor calls the stored function 'pg_catalog.bitxor(bit, bit) bit' on db.
func Bitxor(ctx context.Context, db DB, p0, p1 uint8) (uint8, error) {
	// call pg_catalog.bitxor
	const sqlstr = `SELECT * FROM pg_catalog.bitxor($1, $2)`
	// run
	var r0 uint8
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BoolByInteger calls the stored function 'pg_catalog.bool(integer) boolean' on db.
func BoolByInteger(ctx context.Context, db DB, p0 int) (bool, error) {
	// call pg_catalog.bool
	const sqlstr = `SELECT * FROM pg_catalog.bool($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoolByJsonb calls the stored function 'pg_catalog.bool(jsonb) boolean' on db.
func BoolByJsonb(ctx context.Context, db DB, p0 []byte) (bool, error) {
	// call pg_catalog.bool
	const sqlstr = `SELECT * FROM pg_catalog.bool($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoolAccum calls the stored function 'pg_catalog.bool_accum(internal, boolean) internal' on db.
func BoolAccum(ctx context.Context, db DB, p0 pgtypes.Internal, p1 bool) (pgtypes.Internal, error) {
	// call pg_catalog.bool_accum
	const sqlstr = `SELECT * FROM pg_catalog.bool_accum($1, $2)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// BoolAccumInv calls the stored function 'pg_catalog.bool_accum_inv(internal, boolean) internal' on db.
func BoolAccumInv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 bool) (pgtypes.Internal, error) {
	// call pg_catalog.bool_accum_inv
	const sqlstr = `SELECT * FROM pg_catalog.bool_accum_inv($1, $2)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// BoolAlltrue calls the stored function 'pg_catalog.bool_alltrue(internal) boolean' on db.
func BoolAlltrue(ctx context.Context, db DB, p0 pgtypes.Internal) (bool, error) {
	// call pg_catalog.bool_alltrue
	const sqlstr = `SELECT * FROM pg_catalog.bool_alltrue($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoolAnytrue calls the stored function 'pg_catalog.bool_anytrue(internal) boolean' on db.
func BoolAnytrue(ctx context.Context, db DB, p0 pgtypes.Internal) (bool, error) {
	// call pg_catalog.bool_anytrue
	const sqlstr = `SELECT * FROM pg_catalog.bool_anytrue($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoolandStatefunc calls the stored function 'pg_catalog.booland_statefunc(boolean, boolean) boolean' on db.
func BoolandStatefunc(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.booland_statefunc
	const sqlstr = `SELECT * FROM pg_catalog.booland_statefunc($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Booleq calls the stored function 'pg_catalog.booleq(boolean, boolean) boolean' on db.
func Booleq(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.booleq
	const sqlstr = `SELECT * FROM pg_catalog.booleq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolge calls the stored function 'pg_catalog.boolge(boolean, boolean) boolean' on db.
func Boolge(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boolge
	const sqlstr = `SELECT * FROM pg_catalog.boolge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolgt calls the stored function 'pg_catalog.boolgt(boolean, boolean) boolean' on db.
func Boolgt(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boolgt
	const sqlstr = `SELECT * FROM pg_catalog.boolgt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolle calls the stored function 'pg_catalog.boolle(boolean, boolean) boolean' on db.
func Boolle(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boolle
	const sqlstr = `SELECT * FROM pg_catalog.boolle($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boollt calls the stored function 'pg_catalog.boollt(boolean, boolean) boolean' on db.
func Boollt(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boollt
	const sqlstr = `SELECT * FROM pg_catalog.boollt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolne calls the stored function 'pg_catalog.boolne(boolean, boolean) boolean' on db.
func Boolne(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boolne
	const sqlstr = `SELECT * FROM pg_catalog.boolne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoolorStatefunc calls the stored function 'pg_catalog.boolor_statefunc(boolean, boolean) boolean' on db.
func BoolorStatefunc(ctx context.Context, db DB, p0, p1 bool) (bool, error) {
	// call pg_catalog.boolor_statefunc
	const sqlstr = `SELECT * FROM pg_catalog.boolor_statefunc($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolrecv calls the stored function 'pg_catalog.boolrecv(internal) boolean' on db.
func Boolrecv(ctx context.Context, db DB, p0 pgtypes.Internal) (bool, error) {
	// call pg_catalog.boolrecv
	const sqlstr = `SELECT * FROM pg_catalog.boolrecv($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Boolsend calls the stored function 'pg_catalog.boolsend(boolean) bytea' on db.
func Boolsend(ctx context.Context, db DB, p0 bool) ([]byte, error) {
	// call pg_catalog.boolsend
	const sqlstr = `SELECT * FROM pg_catalog.boolsend($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// BoundBox calls the stored function 'pg_catalog.bound_box(box, box) box' on db.
func BoundBox(ctx context.Context, db DB, p0, p1 pgtypes.Box) (pgtypes.Box, error) {
	// call pg_catalog.bound_box
	const sqlstr = `SELECT * FROM pg_catalog.bound_box($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxByPointAndPoint calls the stored function 'pg_catalog.box(point, point) box' on db.
func BoxByPointAndPoint(ctx context.Context, db DB, p0, p1 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box
	const sqlstr = `SELECT * FROM pg_catalog.box($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxByPolygon calls the stored function 'pg_catalog.box(polygon) box' on db.
func BoxByPolygon(ctx context.Context, db DB, p0 pgtypes.Polygon) (pgtypes.Box, error) {
	// call pg_catalog.box
	const sqlstr = `SELECT * FROM pg_catalog.box($1)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxByCircle calls the stored function 'pg_catalog.box(circle) box' on db.
func BoxByCircle(ctx context.Context, db DB, p0 pgtypes.Circle) (pgtypes.Box, error) {
	// call pg_catalog.box
	const sqlstr = `SELECT * FROM pg_catalog.box($1)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxByPoint calls the stored function 'pg_catalog.box(point) box' on db.
func BoxByPoint(ctx context.Context, db DB, p0 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box
	const sqlstr = `SELECT * FROM pg_catalog.box($1)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxAbove calls the stored function 'pg_catalog.box_above(box, box) boolean' on db.
func BoxAbove(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_above
	const sqlstr = `SELECT * FROM pg_catalog.box_above($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxAboveEq calls the stored function 'pg_catalog.box_above_eq(box, box) boolean' on db.
func BoxAboveEq(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_above_eq
	const sqlstr = `SELECT * FROM pg_catalog.box_above_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxAdd calls the stored function 'pg_catalog.box_add(box, point) box' on db.
func BoxAdd(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box_add
	const sqlstr = `SELECT * FROM pg_catalog.box_add($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxBelow calls the stored function 'pg_catalog.box_below(box, box) boolean' on db.
func BoxBelow(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_below
	const sqlstr = `SELECT * FROM pg_catalog.box_below($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxBelowEq calls the stored function 'pg_catalog.box_below_eq(box, box) boolean' on db.
func BoxBelowEq(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_below_eq
	const sqlstr = `SELECT * FROM pg_catalog.box_below_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxCenter calls the stored function 'pg_catalog.box_center(box) point' on db.
func BoxCenter(ctx context.Context, db DB, p0 pgtypes.Box) (pgtypes.Point, error) {
	// call pg_catalog.box_center
	const sqlstr = `SELECT * FROM pg_catalog.box_center($1)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// BoxContain calls the stored function 'pg_catalog.box_contain(box, box) boolean' on db.
func BoxContain(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_contain
	const sqlstr = `SELECT * FROM pg_catalog.box_contain($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxContainPt calls the stored function 'pg_catalog.box_contain_pt(box, point) boolean' on db.
func BoxContainPt(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (bool, error) {
	// call pg_catalog.box_contain_pt
	const sqlstr = `SELECT * FROM pg_catalog.box_contain_pt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxContained calls the stored function 'pg_catalog.box_contained(box, box) boolean' on db.
func BoxContained(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_contained
	const sqlstr = `SELECT * FROM pg_catalog.box_contained($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxDistance calls the stored function 'pg_catalog.box_distance(box, box) double precision' on db.
func BoxDistance(ctx context.Context, db DB, p0, p1 pgtypes.Box) (float64, error) {
	// call pg_catalog.box_distance
	const sqlstr = `SELECT * FROM pg_catalog.box_distance($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// BoxDiv calls the stored function 'pg_catalog.box_div(box, point) box' on db.
func BoxDiv(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box_div
	const sqlstr = `SELECT * FROM pg_catalog.box_div($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxEq calls the stored function 'pg_catalog.box_eq(box, box) boolean' on db.
func BoxEq(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_eq
	const sqlstr = `SELECT * FROM pg_catalog.box_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxGe calls the stored function 'pg_catalog.box_ge(box, box) boolean' on db.
func BoxGe(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_ge
	const sqlstr = `SELECT * FROM pg_catalog.box_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxGt calls the stored function 'pg_catalog.box_gt(box, box) boolean' on db.
func BoxGt(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_gt
	const sqlstr = `SELECT * FROM pg_catalog.box_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxIntersect calls the stored function 'pg_catalog.box_intersect(box, box) box' on db.
func BoxIntersect(ctx context.Context, db DB, p0, p1 pgtypes.Box) (pgtypes.Box, error) {
	// call pg_catalog.box_intersect
	const sqlstr = `SELECT * FROM pg_catalog.box_intersect($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxLe calls the stored function 'pg_catalog.box_le(box, box) boolean' on db.
func BoxLe(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_le
	const sqlstr = `SELECT * FROM pg_catalog.box_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxLeft calls the stored function 'pg_catalog.box_left(box, box) boolean' on db.
func BoxLeft(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_left
	const sqlstr = `SELECT * FROM pg_catalog.box_left($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxLt calls the stored function 'pg_catalog.box_lt(box, box) boolean' on db.
func BoxLt(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_lt
	const sqlstr = `SELECT * FROM pg_catalog.box_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxMul calls the stored function 'pg_catalog.box_mul(box, point) box' on db.
func BoxMul(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box_mul
	const sqlstr = `SELECT * FROM pg_catalog.box_mul($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxOverabove calls the stored function 'pg_catalog.box_overabove(box, box) boolean' on db.
func BoxOverabove(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_overabove
	const sqlstr = `SELECT * FROM pg_catalog.box_overabove($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxOverbelow calls the stored function 'pg_catalog.box_overbelow(box, box) boolean' on db.
func BoxOverbelow(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_overbelow
	const sqlstr = `SELECT * FROM pg_catalog.box_overbelow($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxOverlap calls the stored function 'pg_catalog.box_overlap(box, box) boolean' on db.
func BoxOverlap(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_overlap
	const sqlstr = `SELECT * FROM pg_catalog.box_overlap($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxOverleft calls the stored function 'pg_catalog.box_overleft(box, box) boolean' on db.
func BoxOverleft(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_overleft
	const sqlstr = `SELECT * FROM pg_catalog.box_overleft($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxOverright calls the stored function 'pg_catalog.box_overright(box, box) boolean' on db.
func BoxOverright(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_overright
	const sqlstr = `SELECT * FROM pg_catalog.box_overright($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxRecv calls the stored function 'pg_catalog.box_recv(internal) box' on db.
func BoxRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Box, error) {
	// call pg_catalog.box_recv
	const sqlstr = `SELECT * FROM pg_catalog.box_recv($1)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BoxRight calls the stored function 'pg_catalog.box_right(box, box) boolean' on db.
func BoxRight(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_right
	const sqlstr = `SELECT * FROM pg_catalog.box_right($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxSame calls the stored function 'pg_catalog.box_same(box, box) boolean' on db.
func BoxSame(ctx context.Context, db DB, p0, p1 pgtypes.Box) (bool, error) {
	// call pg_catalog.box_same
	const sqlstr = `SELECT * FROM pg_catalog.box_same($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BoxSend calls the stored function 'pg_catalog.box_send(box) bytea' on db.
func BoxSend(ctx context.Context, db DB, p0 pgtypes.Box) ([]byte, error) {
	// call pg_catalog.box_send
	const sqlstr = `SELECT * FROM pg_catalog.box_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// BoxSub calls the stored function 'pg_catalog.box_sub(box, point) box' on db.
func BoxSub(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (pgtypes.Box, error) {
	// call pg_catalog.box_sub
	const sqlstr = `SELECT * FROM pg_catalog.box_sub($1, $2)`
	// run
	var r0 pgtypes.Box
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Box{}, logerror(err)
	}
	return r0, nil
}

// BpcharByName calls the stored function 'pg_catalog.bpchar(name) character' on db.
func BpcharByName(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.bpchar
	const sqlstr = `SELECT * FROM pg_catalog.bpchar($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BpcharByCharacterIntegerAndBoolean calls the stored function 'pg_catalog.bpchar(character, integer, boolean) character' on db.
func BpcharByCharacterIntegerAndBoolean(ctx context.Context, db DB, p0 string, p1 int, p2 bool) (string, error) {
	// call pg_catalog.bpchar
	const sqlstr = `SELECT * FROM pg_catalog.bpchar($1, $2, $3)`
	// run
	var r0 string
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BpcharByChar calls the stored function 'pg_catalog.bpchar("char") character' on db.
func BpcharByChar(ctx context.Context, db DB, p0 pgtypes.Char) (string, error) {
	// call pg_catalog.bpchar
	const sqlstr = `SELECT * FROM pg_catalog.bpchar($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BpcharLarger calls the stored function 'pg_catalog.bpchar_larger(character, character) character' on db.
func BpcharLarger(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.bpchar_larger
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_larger($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BpcharPatternGe calls the stored function 'pg_catalog.bpchar_pattern_ge(character, character) boolean' on db.
func BpcharPatternGe(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchar_pattern_ge
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_pattern_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BpcharPatternGt calls the stored function 'pg_catalog.bpchar_pattern_gt(character, character) boolean' on db.
func BpcharPatternGt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchar_pattern_gt
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_pattern_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BpcharPatternLe calls the stored function 'pg_catalog.bpchar_pattern_le(character, character) boolean' on db.
func BpcharPatternLe(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchar_pattern_le
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_pattern_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BpcharPatternLt calls the stored function 'pg_catalog.bpchar_pattern_lt(character, character) boolean' on db.
func BpcharPatternLt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchar_pattern_lt
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_pattern_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BpcharSmaller calls the stored function 'pg_catalog.bpchar_smaller(character, character) character' on db.
func BpcharSmaller(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.bpchar_smaller
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_smaller($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BpcharSortsupport calls the stored function 'pg_catalog.bpchar_sortsupport(internal)' on db.
func BpcharSortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.bpchar_sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.bpchar_sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Bpcharcmp calls the stored function 'pg_catalog.bpcharcmp(character, character) integer' on db.
func Bpcharcmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.bpcharcmp
	const sqlstr = `SELECT * FROM pg_catalog.bpcharcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bpchareq calls the stored function 'pg_catalog.bpchareq(character, character) boolean' on db.
func Bpchareq(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchareq
	const sqlstr = `SELECT * FROM pg_catalog.bpchareq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharge calls the stored function 'pg_catalog.bpcharge(character, character) boolean' on db.
func Bpcharge(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharge
	const sqlstr = `SELECT * FROM pg_catalog.bpcharge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpchargt calls the stored function 'pg_catalog.bpchargt(character, character) boolean' on db.
func Bpchargt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchargt
	const sqlstr = `SELECT * FROM pg_catalog.bpchargt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpchariclike calls the stored function 'pg_catalog.bpchariclike(character, text) boolean' on db.
func Bpchariclike(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpchariclike
	const sqlstr = `SELECT * FROM pg_catalog.bpchariclike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharicnlike calls the stored function 'pg_catalog.bpcharicnlike(character, text) boolean' on db.
func Bpcharicnlike(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharicnlike
	const sqlstr = `SELECT * FROM pg_catalog.bpcharicnlike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharicregexeq calls the stored function 'pg_catalog.bpcharicregexeq(character, text) boolean' on db.
func Bpcharicregexeq(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharicregexeq
	const sqlstr = `SELECT * FROM pg_catalog.bpcharicregexeq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharicregexne calls the stored function 'pg_catalog.bpcharicregexne(character, text) boolean' on db.
func Bpcharicregexne(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharicregexne
	const sqlstr = `SELECT * FROM pg_catalog.bpcharicregexne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharle calls the stored function 'pg_catalog.bpcharle(character, character) boolean' on db.
func Bpcharle(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharle
	const sqlstr = `SELECT * FROM pg_catalog.bpcharle($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharlike calls the stored function 'pg_catalog.bpcharlike(character, text) boolean' on db.
func Bpcharlike(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharlike
	const sqlstr = `SELECT * FROM pg_catalog.bpcharlike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharlt calls the stored function 'pg_catalog.bpcharlt(character, character) boolean' on db.
func Bpcharlt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharlt
	const sqlstr = `SELECT * FROM pg_catalog.bpcharlt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharne calls the stored function 'pg_catalog.bpcharne(character, character) boolean' on db.
func Bpcharne(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharne
	const sqlstr = `SELECT * FROM pg_catalog.bpcharne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharnlike calls the stored function 'pg_catalog.bpcharnlike(character, text) boolean' on db.
func Bpcharnlike(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharnlike
	const sqlstr = `SELECT * FROM pg_catalog.bpcharnlike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharrecv calls the stored function 'pg_catalog.bpcharrecv(internal, oid, integer) character' on db.
func Bpcharrecv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 int) (string, error) {
	// call pg_catalog.bpcharrecv
	const sqlstr = `SELECT * FROM pg_catalog.bpcharrecv($1, $2, $3)`
	// run
	var r0 string
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Bpcharregexeq calls the stored function 'pg_catalog.bpcharregexeq(character, text) boolean' on db.
func Bpcharregexeq(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharregexeq
	const sqlstr = `SELECT * FROM pg_catalog.bpcharregexeq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharregexne calls the stored function 'pg_catalog.bpcharregexne(character, text) boolean' on db.
func Bpcharregexne(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.bpcharregexne
	const sqlstr = `SELECT * FROM pg_catalog.bpcharregexne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bpcharsend calls the stored function 'pg_catalog.bpcharsend(character) bytea' on db.
func Bpcharsend(ctx context.Context, db DB, p0 string) ([]byte, error) {
	// call pg_catalog.bpcharsend
	const sqlstr = `SELECT * FROM pg_catalog.bpcharsend($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Bpchartypmodin calls the stored function 'pg_catalog.bpchartypmodin(cstring) integer' on db.
func Bpchartypmodin(ctx context.Context, db DB, p0 []pgtypes.Cstring) (int, error) {
	// call pg_catalog.bpchartypmodin
	const sqlstr = `SELECT * FROM pg_catalog.bpchartypmodin($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BrinDesummarizeRange calls the stored function 'pg_catalog.brin_desummarize_range(regclass, bigint)' on db.
func BrinDesummarizeRange(ctx context.Context, db DB, p0 pgtypes.Regclass, p1 int64) error {
	// call pg_catalog.brin_desummarize_range
	const sqlstr = `SELECT * FROM pg_catalog.brin_desummarize_range($1, $2)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1); err != nil {
		return logerror(err)
	}
	return nil
}

// BrinInclusionAddValue calls the stored function 'pg_catalog.brin_inclusion_add_value(internal, internal, internal, internal) boolean' on db.
func BrinInclusionAddValue(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_inclusion_add_value
	const sqlstr = `SELECT * FROM pg_catalog.brin_inclusion_add_value($1, $2, $3, $4)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinInclusionConsistent calls the stored function 'pg_catalog.brin_inclusion_consistent(internal, internal, internal) boolean' on db.
func BrinInclusionConsistent(ctx context.Context, db DB, p0, p1, p2 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_inclusion_consistent
	const sqlstr = `SELECT * FROM pg_catalog.brin_inclusion_consistent($1, $2, $3)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinInclusionOpcinfo calls the stored function 'pg_catalog.brin_inclusion_opcinfo(internal) internal' on db.
func BrinInclusionOpcinfo(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.brin_inclusion_opcinfo
	const sqlstr = `SELECT * FROM pg_catalog.brin_inclusion_opcinfo($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// BrinInclusionUnion calls the stored function 'pg_catalog.brin_inclusion_union(internal, internal, internal) boolean' on db.
func BrinInclusionUnion(ctx context.Context, db DB, p0, p1, p2 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_inclusion_union
	const sqlstr = `SELECT * FROM pg_catalog.brin_inclusion_union($1, $2, $3)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinMinmaxAddValue calls the stored function 'pg_catalog.brin_minmax_add_value(internal, internal, internal, internal) boolean' on db.
func BrinMinmaxAddValue(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_minmax_add_value
	const sqlstr = `SELECT * FROM pg_catalog.brin_minmax_add_value($1, $2, $3, $4)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinMinmaxConsistent calls the stored function 'pg_catalog.brin_minmax_consistent(internal, internal, internal) boolean' on db.
func BrinMinmaxConsistent(ctx context.Context, db DB, p0, p1, p2 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_minmax_consistent
	const sqlstr = `SELECT * FROM pg_catalog.brin_minmax_consistent($1, $2, $3)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinMinmaxOpcinfo calls the stored function 'pg_catalog.brin_minmax_opcinfo(internal) internal' on db.
func BrinMinmaxOpcinfo(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.brin_minmax_opcinfo
	const sqlstr = `SELECT * FROM pg_catalog.brin_minmax_opcinfo($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// BrinMinmaxUnion calls the stored function 'pg_catalog.brin_minmax_union(internal, internal, internal) boolean' on db.
func BrinMinmaxUnion(ctx context.Context, db DB, p0, p1, p2 pgtypes.Internal) (bool, error) {
	// call pg_catalog.brin_minmax_union
	const sqlstr = `SELECT * FROM pg_catalog.brin_minmax_union($1, $2, $3)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// BrinSummarizeNewValues calls the stored function 'pg_catalog.brin_summarize_new_values(regclass) integer' on db.
func BrinSummarizeNewValues(ctx context.Context, db DB, p0 pgtypes.Regclass) (int, error) {
	// call pg_catalog.brin_summarize_new_values
	const sqlstr = `SELECT * FROM pg_catalog.brin_summarize_new_values($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BrinSummarizeRange calls the stored function 'pg_catalog.brin_summarize_range(regclass, bigint) integer' on db.
func BrinSummarizeRange(ctx context.Context, db DB, p0 pgtypes.Regclass, p1 int64) (int, error) {
	// call pg_catalog.brin_summarize_range
	const sqlstr = `SELECT * FROM pg_catalog.brin_summarize_range($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Brinhandler calls the stored function 'pg_catalog.brinhandler(internal) index_am_handler' on db.
func Brinhandler(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.IndexAmHandler, error) {
	// call pg_catalog.brinhandler
	const sqlstr = `SELECT * FROM pg_catalog.brinhandler($1)`
	// run
	var r0 pgtypes.IndexAmHandler
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.IndexAmHandler{}, logerror(err)
	}
	return r0, nil
}

// Broadcast calls the stored function 'pg_catalog.broadcast(inet) inet' on db.
func Broadcast(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.broadcast
	const sqlstr = `SELECT * FROM pg_catalog.broadcast($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Btarraycmp calls the stored function 'pg_catalog.btarraycmp(anyarray, anyarray) integer' on db.
func Btarraycmp(ctx context.Context, db DB, p0, p1 pgtypes.Anyarray) (int, error) {
	// call pg_catalog.btarraycmp
	const sqlstr = `SELECT * FROM pg_catalog.btarraycmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btboolcmp calls the stored function 'pg_catalog.btboolcmp(boolean, boolean) integer' on db.
func Btboolcmp(ctx context.Context, db DB, p0, p1 bool) (int, error) {
	// call pg_catalog.btboolcmp
	const sqlstr = `SELECT * FROM pg_catalog.btboolcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BtbpcharPatternCmp calls the stored function 'pg_catalog.btbpchar_pattern_cmp(character, character) integer' on db.
func BtbpcharPatternCmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.btbpchar_pattern_cmp
	const sqlstr = `SELECT * FROM pg_catalog.btbpchar_pattern_cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BtbpcharPatternSortsupport calls the stored function 'pg_catalog.btbpchar_pattern_sortsupport(internal)' on db.
func BtbpcharPatternSortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btbpchar_pattern_sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btbpchar_pattern_sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btcharcmp calls the stored function 'pg_catalog.btcharcmp("char", "char") integer' on db.
func Btcharcmp(ctx context.Context, db DB, p0, p1 pgtypes.Char) (int, error) {
	// call pg_catalog.btcharcmp
	const sqlstr = `SELECT * FROM pg_catalog.btcharcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btequalimage calls the stored function 'pg_catalog.btequalimage(oid) boolean' on db.
func Btequalimage(ctx context.Context, db DB, p0 pgtypes.Oid) (bool, error) {
	// call pg_catalog.btequalimage
	const sqlstr = `SELECT * FROM pg_catalog.btequalimage($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Btfloat48cmp calls the stored function 'pg_catalog.btfloat48cmp(real, double precision) integer' on db.
func Btfloat48cmp(ctx context.Context, db DB, p0 float32, p1 float64) (int, error) {
	// call pg_catalog.btfloat48cmp
	const sqlstr = `SELECT * FROM pg_catalog.btfloat48cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btfloat4cmp calls the stored function 'pg_catalog.btfloat4cmp(real, real) integer' on db.
func Btfloat4cmp(ctx context.Context, db DB, p0, p1 float32) (int, error) {
	// call pg_catalog.btfloat4cmp
	const sqlstr = `SELECT * FROM pg_catalog.btfloat4cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btfloat4sortsupport calls the stored function 'pg_catalog.btfloat4sortsupport(internal)' on db.
func Btfloat4sortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btfloat4sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btfloat4sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btfloat84cmp calls the stored function 'pg_catalog.btfloat84cmp(double precision, real) integer' on db.
func Btfloat84cmp(ctx context.Context, db DB, p0 float64, p1 float32) (int, error) {
	// call pg_catalog.btfloat84cmp
	const sqlstr = `SELECT * FROM pg_catalog.btfloat84cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btfloat8cmp calls the stored function 'pg_catalog.btfloat8cmp(double precision, double precision) integer' on db.
func Btfloat8cmp(ctx context.Context, db DB, p0, p1 float64) (int, error) {
	// call pg_catalog.btfloat8cmp
	const sqlstr = `SELECT * FROM pg_catalog.btfloat8cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btfloat8sortsupport calls the stored function 'pg_catalog.btfloat8sortsupport(internal)' on db.
func Btfloat8sortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btfloat8sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btfloat8sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Bthandler calls the stored function 'pg_catalog.bthandler(internal) index_am_handler' on db.
func Bthandler(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.IndexAmHandler, error) {
	// call pg_catalog.bthandler
	const sqlstr = `SELECT * FROM pg_catalog.bthandler($1)`
	// run
	var r0 pgtypes.IndexAmHandler
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.IndexAmHandler{}, logerror(err)
	}
	return r0, nil
}

// Btint24cmp calls the stored function 'pg_catalog.btint24cmp(smallint, integer) integer' on db.
func Btint24cmp(ctx context.Context, db DB, p0 int16, p1 int) (int, error) {
	// call pg_catalog.btint24cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint24cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint28cmp calls the stored function 'pg_catalog.btint28cmp(smallint, bigint) integer' on db.
func Btint28cmp(ctx context.Context, db DB, p0 int16, p1 int64) (int, error) {
	// call pg_catalog.btint28cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint28cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint2cmp calls the stored function 'pg_catalog.btint2cmp(smallint, smallint) integer' on db.
func Btint2cmp(ctx context.Context, db DB, p0, p1 int16) (int, error) {
	// call pg_catalog.btint2cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint2cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint2sortsupport calls the stored function 'pg_catalog.btint2sortsupport(internal)' on db.
func Btint2sortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btint2sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btint2sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btint42cmp calls the stored function 'pg_catalog.btint42cmp(integer, smallint) integer' on db.
func Btint42cmp(ctx context.Context, db DB, p0 int, p1 int16) (int, error) {
	// call pg_catalog.btint42cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint42cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint48cmp calls the stored function 'pg_catalog.btint48cmp(integer, bigint) integer' on db.
func Btint48cmp(ctx context.Context, db DB, p0 int, p1 int64) (int, error) {
	// call pg_catalog.btint48cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint48cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint4cmp calls the stored function 'pg_catalog.btint4cmp(integer, integer) integer' on db.
func Btint4cmp(ctx context.Context, db DB, p0, p1 int) (int, error) {
	// call pg_catalog.btint4cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint4cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint4sortsupport calls the stored function 'pg_catalog.btint4sortsupport(internal)' on db.
func Btint4sortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btint4sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btint4sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btint82cmp calls the stored function 'pg_catalog.btint82cmp(bigint, smallint) integer' on db.
func Btint82cmp(ctx context.Context, db DB, p0 int64, p1 int16) (int, error) {
	// call pg_catalog.btint82cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint82cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint84cmp calls the stored function 'pg_catalog.btint84cmp(bigint, integer) integer' on db.
func Btint84cmp(ctx context.Context, db DB, p0 int64, p1 int) (int, error) {
	// call pg_catalog.btint84cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint84cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint8cmp calls the stored function 'pg_catalog.btint8cmp(bigint, bigint) integer' on db.
func Btint8cmp(ctx context.Context, db DB, p0, p1 int64) (int, error) {
	// call pg_catalog.btint8cmp
	const sqlstr = `SELECT * FROM pg_catalog.btint8cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btint8sortsupport calls the stored function 'pg_catalog.btint8sortsupport(internal)' on db.
func Btint8sortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btint8sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btint8sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btnamecmp calls the stored function 'pg_catalog.btnamecmp(name, name) integer' on db.
func Btnamecmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.btnamecmp
	const sqlstr = `SELECT * FROM pg_catalog.btnamecmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btnamesortsupport calls the stored function 'pg_catalog.btnamesortsupport(internal)' on db.
func Btnamesortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btnamesortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btnamesortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btnametextcmp calls the stored function 'pg_catalog.btnametextcmp(name, text) integer' on db.
func Btnametextcmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.btnametextcmp
	const sqlstr = `SELECT * FROM pg_catalog.btnametextcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btoidcmp calls the stored function 'pg_catalog.btoidcmp(oid, oid) integer' on db.
func Btoidcmp(ctx context.Context, db DB, p0, p1 pgtypes.Oid) (int, error) {
	// call pg_catalog.btoidcmp
	const sqlstr = `SELECT * FROM pg_catalog.btoidcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btoidsortsupport calls the stored function 'pg_catalog.btoidsortsupport(internal)' on db.
func Btoidsortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.btoidsortsupport
	const sqlstr = `SELECT * FROM pg_catalog.btoidsortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Btoidvectorcmp calls the stored function 'pg_catalog.btoidvectorcmp(oidvector, oidvector) integer' on db.
func Btoidvectorcmp(ctx context.Context, db DB, p0, p1 pgtypes.Oidvector) (int, error) {
	// call pg_catalog.btoidvectorcmp
	const sqlstr = `SELECT * FROM pg_catalog.btoidvectorcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btrecordcmp calls the stored function 'pg_catalog.btrecordcmp(record, record) integer' on db.
func Btrecordcmp(ctx context.Context, db DB, p0, p1 pgtypes.Record) (int, error) {
	// call pg_catalog.btrecordcmp
	const sqlstr = `SELECT * FROM pg_catalog.btrecordcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btrecordimagecmp calls the stored function 'pg_catalog.btrecordimagecmp(record, record) integer' on db.
func Btrecordimagecmp(ctx context.Context, db DB, p0, p1 pgtypes.Record) (int, error) {
	// call pg_catalog.btrecordimagecmp
	const sqlstr = `SELECT * FROM pg_catalog.btrecordimagecmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BtrimByByteaAndBytea calls the stored function 'pg_catalog.btrim(bytea, bytea) bytea' on db.
func BtrimByByteaAndBytea(ctx context.Context, db DB, p0, p1 []byte) ([]byte, error) {
	// call pg_catalog.btrim
	const sqlstr = `SELECT * FROM pg_catalog.btrim($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// BtrimByTextAndText calls the stored function 'pg_catalog.btrim(text, text) text' on db.
func BtrimByTextAndText(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.btrim
	const sqlstr = `SELECT * FROM pg_catalog.btrim($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BtrimByText calls the stored function 'pg_catalog.btrim(text) text' on db.
func BtrimByText(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.btrim
	const sqlstr = `SELECT * FROM pg_catalog.btrim($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// BttextPatternCmp calls the stored function 'pg_catalog.bttext_pattern_cmp(text, text) integer' on db.
func BttextPatternCmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.bttext_pattern_cmp
	const sqlstr = `SELECT * FROM pg_catalog.bttext_pattern_cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// BttextPatternSortsupport calls the stored function 'pg_catalog.bttext_pattern_sortsupport(internal)' on db.
func BttextPatternSortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.bttext_pattern_sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.bttext_pattern_sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Bttextcmp calls the stored function 'pg_catalog.bttextcmp(text, text) integer' on db.
func Bttextcmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.bttextcmp
	const sqlstr = `SELECT * FROM pg_catalog.bttextcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bttextnamecmp calls the stored function 'pg_catalog.bttextnamecmp(text, name) integer' on db.
func Bttextnamecmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.bttextnamecmp
	const sqlstr = `SELECT * FROM pg_catalog.bttextnamecmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Bttextsortsupport calls the stored function 'pg_catalog.bttextsortsupport(internal)' on db.
func Bttextsortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.bttextsortsupport
	const sqlstr = `SELECT * FROM pg_catalog.bttextsortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// Bttidcmp calls the stored function 'pg_catalog.bttidcmp(tid, tid) integer' on db.
func Bttidcmp(ctx context.Context, db DB, p0, p1 pgtypes.Tid) (int, error) {
	// call pg_catalog.bttidcmp
	const sqlstr = `SELECT * FROM pg_catalog.bttidcmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Btvarstrequalimage calls the stored function 'pg_catalog.btvarstrequalimage(oid) boolean' on db.
func Btvarstrequalimage(ctx context.Context, db DB, p0 pgtypes.Oid) (bool, error) {
	// call pg_catalog.btvarstrequalimage
	const sqlstr = `SELECT * FROM pg_catalog.btvarstrequalimage($1)`
	// run
	var r0 bool
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// ByteaSortsupport calls the stored function 'pg_catalog.bytea_sortsupport(internal)' on db.
func ByteaSortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.bytea_sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.bytea_sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// ByteaStringAggFinalfn calls the stored function 'pg_catalog.bytea_string_agg_finalfn(internal) bytea' on db.
func ByteaStringAggFinalfn(ctx context.Context, db DB, p0 pgtypes.Internal) ([]byte, error) {
	// call pg_catalog.bytea_string_agg_finalfn
	const sqlstr = `SELECT * FROM pg_catalog.bytea_string_agg_finalfn($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ByteaStringAggTransfn calls the stored function 'pg_catalog.bytea_string_agg_transfn(internal, bytea, bytea) internal' on db.
func ByteaStringAggTransfn(ctx context.Context, db DB, p0 pgtypes.Internal, p1, p2 []byte) (pgtypes.Internal, error) {
	// call pg_catalog.bytea_string_agg_transfn
	const sqlstr = `SELECT * FROM pg_catalog.bytea_string_agg_transfn($1, $2, $3)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// Byteacat calls the stored function 'pg_catalog.byteacat(bytea, bytea) bytea' on db.
func Byteacat(ctx context.Context, db DB, p0, p1 []byte) ([]byte, error) {
	// call pg_catalog.byteacat
	const sqlstr = `SELECT * FROM pg_catalog.byteacat($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Byteacmp calls the stored function 'pg_catalog.byteacmp(bytea, bytea) integer' on db.
func Byteacmp(ctx context.Context, db DB, p0, p1 []byte) (int, error) {
	// call pg_catalog.byteacmp
	const sqlstr = `SELECT * FROM pg_catalog.byteacmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Byteaeq calls the stored function 'pg_catalog.byteaeq(bytea, bytea) boolean' on db.
func Byteaeq(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteaeq
	const sqlstr = `SELECT * FROM pg_catalog.byteaeq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Byteage calls the stored function 'pg_catalog.byteage(bytea, bytea) boolean' on db.
func Byteage(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteage
	const sqlstr = `SELECT * FROM pg_catalog.byteage($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Byteagt calls the stored function 'pg_catalog.byteagt(bytea, bytea) boolean' on db.
func Byteagt(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteagt
	const sqlstr = `SELECT * FROM pg_catalog.byteagt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Byteale calls the stored function 'pg_catalog.byteale(bytea, bytea) boolean' on db.
func Byteale(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteale
	const sqlstr = `SELECT * FROM pg_catalog.byteale($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bytealike calls the stored function 'pg_catalog.bytealike(bytea, bytea) boolean' on db.
func Bytealike(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.bytealike
	const sqlstr = `SELECT * FROM pg_catalog.bytealike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bytealt calls the stored function 'pg_catalog.bytealt(bytea, bytea) boolean' on db.
func Bytealt(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.bytealt
	const sqlstr = `SELECT * FROM pg_catalog.bytealt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Byteane calls the stored function 'pg_catalog.byteane(bytea, bytea) boolean' on db.
func Byteane(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteane
	const sqlstr = `SELECT * FROM pg_catalog.byteane($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Byteanlike calls the stored function 'pg_catalog.byteanlike(bytea, bytea) boolean' on db.
func Byteanlike(ctx context.Context, db DB, p0, p1 []byte) (bool, error) {
	// call pg_catalog.byteanlike
	const sqlstr = `SELECT * FROM pg_catalog.byteanlike($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Bytearecv calls the stored function 'pg_catalog.bytearecv(internal) bytea' on db.
func Bytearecv(ctx context.Context, db DB, p0 pgtypes.Internal) ([]byte, error) {
	// call pg_catalog.bytearecv
	const sqlstr = `SELECT * FROM pg_catalog.bytearecv($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Byteasend calls the stored function 'pg_catalog.byteasend(bytea) bytea' on db.
func Byteasend(ctx context.Context, db DB, p0 []byte) ([]byte, error) {
	// call pg_catalog.byteasend
	const sqlstr = `SELECT * FROM pg_catalog.byteasend($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Cardinality calls the stored function 'pg_catalog.cardinality(anyarray) integer' on db.
func Cardinality(ctx context.Context, db DB, p0 pgtypes.Anyarray) (int, error) {
	// call pg_catalog.cardinality
	const sqlstr = `SELECT * FROM pg_catalog.cardinality($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CashCmp calls the stored function 'pg_catalog.cash_cmp(money, money) integer' on db.
func CashCmp(ctx context.Context, db DB, p0, p1 string) (int, error) {
	// call pg_catalog.cash_cmp
	const sqlstr = `SELECT * FROM pg_catalog.cash_cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CashDivCash calls the stored function 'pg_catalog.cash_div_cash(money, money) double precision' on db.
func CashDivCash(ctx context.Context, db DB, p0, p1 string) (float64, error) {
	// call pg_catalog.cash_div_cash
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_cash($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CashDivFlt4 calls the stored function 'pg_catalog.cash_div_flt4(money, real) money' on db.
func CashDivFlt4(ctx context.Context, db DB, p0 string, p1 float32) (string, error) {
	// call pg_catalog.cash_div_flt4
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_flt4($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashDivFlt8 calls the stored function 'pg_catalog.cash_div_flt8(money, double precision) money' on db.
func CashDivFlt8(ctx context.Context, db DB, p0 string, p1 float64) (string, error) {
	// call pg_catalog.cash_div_flt8
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_flt8($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashDivInt2 calls the stored function 'pg_catalog.cash_div_int2(money, smallint) money' on db.
func CashDivInt2(ctx context.Context, db DB, p0 string, p1 int16) (string, error) {
	// call pg_catalog.cash_div_int2
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_int2($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashDivInt4 calls the stored function 'pg_catalog.cash_div_int4(money, integer) money' on db.
func CashDivInt4(ctx context.Context, db DB, p0 string, p1 int) (string, error) {
	// call pg_catalog.cash_div_int4
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_int4($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashDivInt8 calls the stored function 'pg_catalog.cash_div_int8(money, bigint) money' on db.
func CashDivInt8(ctx context.Context, db DB, p0 string, p1 int64) (string, error) {
	// call pg_catalog.cash_div_int8
	const sqlstr = `SELECT * FROM pg_catalog.cash_div_int8($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashEq calls the stored function 'pg_catalog.cash_eq(money, money) boolean' on db.
func CashEq(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_eq
	const sqlstr = `SELECT * FROM pg_catalog.cash_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashGe calls the stored function 'pg_catalog.cash_ge(money, money) boolean' on db.
func CashGe(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_ge
	const sqlstr = `SELECT * FROM pg_catalog.cash_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashGt calls the stored function 'pg_catalog.cash_gt(money, money) boolean' on db.
func CashGt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_gt
	const sqlstr = `SELECT * FROM pg_catalog.cash_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashLe calls the stored function 'pg_catalog.cash_le(money, money) boolean' on db.
func CashLe(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_le
	const sqlstr = `SELECT * FROM pg_catalog.cash_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashLt calls the stored function 'pg_catalog.cash_lt(money, money) boolean' on db.
func CashLt(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_lt
	const sqlstr = `SELECT * FROM pg_catalog.cash_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashMi calls the stored function 'pg_catalog.cash_mi(money, money) money' on db.
func CashMi(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.cash_mi
	const sqlstr = `SELECT * FROM pg_catalog.cash_mi($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashMulFlt4 calls the stored function 'pg_catalog.cash_mul_flt4(money, real) money' on db.
func CashMulFlt4(ctx context.Context, db DB, p0 string, p1 float32) (string, error) {
	// call pg_catalog.cash_mul_flt4
	const sqlstr = `SELECT * FROM pg_catalog.cash_mul_flt4($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashMulFlt8 calls the stored function 'pg_catalog.cash_mul_flt8(money, double precision) money' on db.
func CashMulFlt8(ctx context.Context, db DB, p0 string, p1 float64) (string, error) {
	// call pg_catalog.cash_mul_flt8
	const sqlstr = `SELECT * FROM pg_catalog.cash_mul_flt8($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashMulInt2 calls the stored function 'pg_catalog.cash_mul_int2(money, smallint) money' on db.
func CashMulInt2(ctx context.Context, db DB, p0 string, p1 int16) (string, error) {
	// call pg_catalog.cash_mul_int2
	const sqlstr = `SELECT * FROM pg_catalog.cash_mul_int2($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashMulInt4 calls the stored function 'pg_catalog.cash_mul_int4(money, integer) money' on db.
func CashMulInt4(ctx context.Context, db DB, p0 string, p1 int) (string, error) {
	// call pg_catalog.cash_mul_int4
	const sqlstr = `SELECT * FROM pg_catalog.cash_mul_int4($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashMulInt8 calls the stored function 'pg_catalog.cash_mul_int8(money, bigint) money' on db.
func CashMulInt8(ctx context.Context, db DB, p0 string, p1 int64) (string, error) {
	// call pg_catalog.cash_mul_int8
	const sqlstr = `SELECT * FROM pg_catalog.cash_mul_int8($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashNe calls the stored function 'pg_catalog.cash_ne(money, money) boolean' on db.
func CashNe(ctx context.Context, db DB, p0, p1 string) (bool, error) {
	// call pg_catalog.cash_ne
	const sqlstr = `SELECT * FROM pg_catalog.cash_ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CashPl calls the stored function 'pg_catalog.cash_pl(money, money) money' on db.
func CashPl(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.cash_pl
	const sqlstr = `SELECT * FROM pg_catalog.cash_pl($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashRecv calls the stored function 'pg_catalog.cash_recv(internal) money' on db.
func CashRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (string, error) {
	// call pg_catalog.cash_recv
	const sqlstr = `SELECT * FROM pg_catalog.cash_recv($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CashSend calls the stored function 'pg_catalog.cash_send(money) bytea' on db.
func CashSend(ctx context.Context, db DB, p0 string) ([]byte, error) {
	// call pg_catalog.cash_send
	const sqlstr = `SELECT * FROM pg_catalog.cash_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// CashWords calls the stored function 'pg_catalog.cash_words(money) text' on db.
func CashWords(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.cash_words
	const sqlstr = `SELECT * FROM pg_catalog.cash_words($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Cashlarger calls the stored function 'pg_catalog.cashlarger(money, money) money' on db.
func Cashlarger(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.cashlarger
	const sqlstr = `SELECT * FROM pg_catalog.cashlarger($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Cashsmaller calls the stored function 'pg_catalog.cashsmaller(money, money) money' on db.
func Cashsmaller(ctx context.Context, db DB, p0, p1 string) (string, error) {
	// call pg_catalog.cashsmaller
	const sqlstr = `SELECT * FROM pg_catalog.cashsmaller($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Cbrt calls the stored function 'pg_catalog.cbrt(double precision) double precision' on db.
func Cbrt(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cbrt
	const sqlstr = `SELECT * FROM pg_catalog.cbrt($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CeilByNumeric calls the stored function 'pg_catalog.ceil(numeric) numeric' on db.
func CeilByNumeric(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.ceil
	const sqlstr = `SELECT * FROM pg_catalog.ceil($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CeilByDoublePrecision calls the stored function 'pg_catalog.ceil(double precision) double precision' on db.
func CeilByDoublePrecision(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.ceil
	const sqlstr = `SELECT * FROM pg_catalog.ceil($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CeilingByNumeric calls the stored function 'pg_catalog.ceiling(numeric) numeric' on db.
func CeilingByNumeric(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.ceiling
	const sqlstr = `SELECT * FROM pg_catalog.ceiling($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CeilingByDoublePrecision calls the stored function 'pg_catalog.ceiling(double precision) double precision' on db.
func CeilingByDoublePrecision(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.ceiling
	const sqlstr = `SELECT * FROM pg_catalog.ceiling($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CenterByBox calls the stored function 'pg_catalog.center(box) point' on db.
func CenterByBox(ctx context.Context, db DB, p0 pgtypes.Box) (pgtypes.Point, error) {
	// call pg_catalog.center
	const sqlstr = `SELECT * FROM pg_catalog.center($1)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CenterByCircle calls the stored function 'pg_catalog.center(circle) point' on db.
func CenterByCircle(ctx context.Context, db DB, p0 pgtypes.Circle) (pgtypes.Point, error) {
	// call pg_catalog.center
	const sqlstr = `SELECT * FROM pg_catalog.center($1)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CharByInteger calls the stored function 'pg_catalog.char(integer) "char"' on db.
func CharByInteger(ctx context.Context, db DB, p0 int) (pgtypes.Char, error) {
	// call pg_catalog.char
	const sqlstr = `SELECT * FROM pg_catalog.char($1)`
	// run
	var r0 pgtypes.Char
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Char{}, logerror(err)
	}
	return r0, nil
}

// CharByText calls the stored function 'pg_catalog.char(text) "char"' on db.
func CharByText(ctx context.Context, db DB, p0 string) (pgtypes.Char, error) {
	// call pg_catalog.char
	const sqlstr = `SELECT * FROM pg_catalog.char($1)`
	// run
	var r0 pgtypes.Char
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Char{}, logerror(err)
	}
	return r0, nil
}

// CharLengthByCharacter calls the stored function 'pg_catalog.char_length(character) integer' on db.
func CharLengthByCharacter(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.char_length
	const sqlstr = `SELECT * FROM pg_catalog.char_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CharLengthByText calls the stored function 'pg_catalog.char_length(text) integer' on db.
func CharLengthByText(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.char_length
	const sqlstr = `SELECT * FROM pg_catalog.char_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CharacterLengthByCharacter calls the stored function 'pg_catalog.character_length(character) integer' on db.
func CharacterLengthByCharacter(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.character_length
	const sqlstr = `SELECT * FROM pg_catalog.character_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CharacterLengthByText calls the stored function 'pg_catalog.character_length(text) integer' on db.
func CharacterLengthByText(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.character_length
	const sqlstr = `SELECT * FROM pg_catalog.character_length($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Chareq calls the stored function 'pg_catalog.chareq("char", "char") boolean' on db.
func Chareq(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.chareq
	const sqlstr = `SELECT * FROM pg_catalog.chareq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Charge calls the stored function 'pg_catalog.charge("char", "char") boolean' on db.
func Charge(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.charge
	const sqlstr = `SELECT * FROM pg_catalog.charge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Chargt calls the stored function 'pg_catalog.chargt("char", "char") boolean' on db.
func Chargt(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.chargt
	const sqlstr = `SELECT * FROM pg_catalog.chargt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Charle calls the stored function 'pg_catalog.charle("char", "char") boolean' on db.
func Charle(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.charle
	const sqlstr = `SELECT * FROM pg_catalog.charle($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Charlt calls the stored function 'pg_catalog.charlt("char", "char") boolean' on db.
func Charlt(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.charlt
	const sqlstr = `SELECT * FROM pg_catalog.charlt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Charne calls the stored function 'pg_catalog.charne("char", "char") boolean' on db.
func Charne(ctx context.Context, db DB, p0, p1 pgtypes.Char) (bool, error) {
	// call pg_catalog.charne
	const sqlstr = `SELECT * FROM pg_catalog.charne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Charrecv calls the stored function 'pg_catalog.charrecv(internal) "char"' on db.
func Charrecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Char, error) {
	// call pg_catalog.charrecv
	const sqlstr = `SELECT * FROM pg_catalog.charrecv($1)`
	// run
	var r0 pgtypes.Char
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Char{}, logerror(err)
	}
	return r0, nil
}

// Charsend calls the stored function 'pg_catalog.charsend("char") bytea' on db.
func Charsend(ctx context.Context, db DB, p0 pgtypes.Char) ([]byte, error) {
	// call pg_catalog.charsend
	const sqlstr = `SELECT * FROM pg_catalog.charsend($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Chr calls the stored function 'pg_catalog.chr(integer) text' on db.
func Chr(ctx context.Context, db DB, p0 int) (string, error) {
	// call pg_catalog.chr
	const sqlstr = `SELECT * FROM pg_catalog.chr($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Cideq calls the stored function 'pg_catalog.cideq(cid, cid) boolean' on db.
func Cideq(ctx context.Context, db DB, p0, p1 pgtypes.Cid) (bool, error) {
	// call pg_catalog.cideq
	const sqlstr = `SELECT * FROM pg_catalog.cideq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Cidr calls the stored function 'pg_catalog.cidr(inet) cidr' on db.
func Cidr(ctx context.Context, db DB, p0 string) (pgtypes.Cidr, error) {
	// call pg_catalog.cidr
	const sqlstr = `SELECT * FROM pg_catalog.cidr($1)`
	// run
	var r0 pgtypes.Cidr
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Cidr{}, logerror(err)
	}
	return r0, nil
}

// CidrRecv calls the stored function 'pg_catalog.cidr_recv(internal) cidr' on db.
func CidrRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Cidr, error) {
	// call pg_catalog.cidr_recv
	const sqlstr = `SELECT * FROM pg_catalog.cidr_recv($1)`
	// run
	var r0 pgtypes.Cidr
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Cidr{}, logerror(err)
	}
	return r0, nil
}

// CidrSend calls the stored function 'pg_catalog.cidr_send(cidr) bytea' on db.
func CidrSend(ctx context.Context, db DB, p0 pgtypes.Cidr) ([]byte, error) {
	// call pg_catalog.cidr_send
	const sqlstr = `SELECT * FROM pg_catalog.cidr_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Cidrecv calls the stored function 'pg_catalog.cidrecv(internal) cid' on db.
func Cidrecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Cid, error) {
	// call pg_catalog.cidrecv
	const sqlstr = `SELECT * FROM pg_catalog.cidrecv($1)`
	// run
	var r0 pgtypes.Cid
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Cid{}, logerror(err)
	}
	return r0, nil
}

// Cidsend calls the stored function 'pg_catalog.cidsend(cid) bytea' on db.
func Cidsend(ctx context.Context, db DB, p0 pgtypes.Cid) ([]byte, error) {
	// call pg_catalog.cidsend
	const sqlstr = `SELECT * FROM pg_catalog.cidsend($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// CircleByPointAndDoublePrecision calls the stored function 'pg_catalog.circle(point, double precision) circle' on db.
func CircleByPointAndDoublePrecision(ctx context.Context, db DB, p0 pgtypes.Point, p1 float64) (pgtypes.Circle, error) {
	// call pg_catalog.circle
	const sqlstr = `SELECT * FROM pg_catalog.circle($1, $2)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleByPolygon calls the stored function 'pg_catalog.circle(polygon) circle' on db.
func CircleByPolygon(ctx context.Context, db DB, p0 pgtypes.Polygon) (pgtypes.Circle, error) {
	// call pg_catalog.circle
	const sqlstr = `SELECT * FROM pg_catalog.circle($1)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleByBox calls the stored function 'pg_catalog.circle(box) circle' on db.
func CircleByBox(ctx context.Context, db DB, p0 pgtypes.Box) (pgtypes.Circle, error) {
	// call pg_catalog.circle
	const sqlstr = `SELECT * FROM pg_catalog.circle($1)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleAbove calls the stored function 'pg_catalog.circle_above(circle, circle) boolean' on db.
func CircleAbove(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_above
	const sqlstr = `SELECT * FROM pg_catalog.circle_above($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleAddPt calls the stored function 'pg_catalog.circle_add_pt(circle, point) circle' on db.
func CircleAddPt(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (pgtypes.Circle, error) {
	// call pg_catalog.circle_add_pt
	const sqlstr = `SELECT * FROM pg_catalog.circle_add_pt($1, $2)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleBelow calls the stored function 'pg_catalog.circle_below(circle, circle) boolean' on db.
func CircleBelow(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_below
	const sqlstr = `SELECT * FROM pg_catalog.circle_below($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleCenter calls the stored function 'pg_catalog.circle_center(circle) point' on db.
func CircleCenter(ctx context.Context, db DB, p0 pgtypes.Circle) (pgtypes.Point, error) {
	// call pg_catalog.circle_center
	const sqlstr = `SELECT * FROM pg_catalog.circle_center($1)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CircleContain calls the stored function 'pg_catalog.circle_contain(circle, circle) boolean' on db.
func CircleContain(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_contain
	const sqlstr = `SELECT * FROM pg_catalog.circle_contain($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleContainPt calls the stored function 'pg_catalog.circle_contain_pt(circle, point) boolean' on db.
func CircleContainPt(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (bool, error) {
	// call pg_catalog.circle_contain_pt
	const sqlstr = `SELECT * FROM pg_catalog.circle_contain_pt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleContained calls the stored function 'pg_catalog.circle_contained(circle, circle) boolean' on db.
func CircleContained(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_contained
	const sqlstr = `SELECT * FROM pg_catalog.circle_contained($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleDistance calls the stored function 'pg_catalog.circle_distance(circle, circle) double precision' on db.
func CircleDistance(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (float64, error) {
	// call pg_catalog.circle_distance
	const sqlstr = `SELECT * FROM pg_catalog.circle_distance($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CircleDivPt calls the stored function 'pg_catalog.circle_div_pt(circle, point) circle' on db.
func CircleDivPt(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (pgtypes.Circle, error) {
	// call pg_catalog.circle_div_pt
	const sqlstr = `SELECT * FROM pg_catalog.circle_div_pt($1, $2)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleEq calls the stored function 'pg_catalog.circle_eq(circle, circle) boolean' on db.
func CircleEq(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_eq
	const sqlstr = `SELECT * FROM pg_catalog.circle_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleGe calls the stored function 'pg_catalog.circle_ge(circle, circle) boolean' on db.
func CircleGe(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_ge
	const sqlstr = `SELECT * FROM pg_catalog.circle_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleGt calls the stored function 'pg_catalog.circle_gt(circle, circle) boolean' on db.
func CircleGt(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_gt
	const sqlstr = `SELECT * FROM pg_catalog.circle_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleLe calls the stored function 'pg_catalog.circle_le(circle, circle) boolean' on db.
func CircleLe(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_le
	const sqlstr = `SELECT * FROM pg_catalog.circle_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleLeft calls the stored function 'pg_catalog.circle_left(circle, circle) boolean' on db.
func CircleLeft(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_left
	const sqlstr = `SELECT * FROM pg_catalog.circle_left($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleLt calls the stored function 'pg_catalog.circle_lt(circle, circle) boolean' on db.
func CircleLt(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_lt
	const sqlstr = `SELECT * FROM pg_catalog.circle_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleMulPt calls the stored function 'pg_catalog.circle_mul_pt(circle, point) circle' on db.
func CircleMulPt(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (pgtypes.Circle, error) {
	// call pg_catalog.circle_mul_pt
	const sqlstr = `SELECT * FROM pg_catalog.circle_mul_pt($1, $2)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleNe calls the stored function 'pg_catalog.circle_ne(circle, circle) boolean' on db.
func CircleNe(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_ne
	const sqlstr = `SELECT * FROM pg_catalog.circle_ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleOverabove calls the stored function 'pg_catalog.circle_overabove(circle, circle) boolean' on db.
func CircleOverabove(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_overabove
	const sqlstr = `SELECT * FROM pg_catalog.circle_overabove($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleOverbelow calls the stored function 'pg_catalog.circle_overbelow(circle, circle) boolean' on db.
func CircleOverbelow(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_overbelow
	const sqlstr = `SELECT * FROM pg_catalog.circle_overbelow($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleOverlap calls the stored function 'pg_catalog.circle_overlap(circle, circle) boolean' on db.
func CircleOverlap(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_overlap
	const sqlstr = `SELECT * FROM pg_catalog.circle_overlap($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleOverleft calls the stored function 'pg_catalog.circle_overleft(circle, circle) boolean' on db.
func CircleOverleft(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_overleft
	const sqlstr = `SELECT * FROM pg_catalog.circle_overleft($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleOverright calls the stored function 'pg_catalog.circle_overright(circle, circle) boolean' on db.
func CircleOverright(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_overright
	const sqlstr = `SELECT * FROM pg_catalog.circle_overright($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleRecv calls the stored function 'pg_catalog.circle_recv(internal) circle' on db.
func CircleRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Circle, error) {
	// call pg_catalog.circle_recv
	const sqlstr = `SELECT * FROM pg_catalog.circle_recv($1)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// CircleRight calls the stored function 'pg_catalog.circle_right(circle, circle) boolean' on db.
func CircleRight(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_right
	const sqlstr = `SELECT * FROM pg_catalog.circle_right($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleSame calls the stored function 'pg_catalog.circle_same(circle, circle) boolean' on db.
func CircleSame(ctx context.Context, db DB, p0, p1 pgtypes.Circle) (bool, error) {
	// call pg_catalog.circle_same
	const sqlstr = `SELECT * FROM pg_catalog.circle_same($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// CircleSend calls the stored function 'pg_catalog.circle_send(circle) bytea' on db.
func CircleSend(ctx context.Context, db DB, p0 pgtypes.Circle) ([]byte, error) {
	// call pg_catalog.circle_send
	const sqlstr = `SELECT * FROM pg_catalog.circle_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// CircleSubPt calls the stored function 'pg_catalog.circle_sub_pt(circle, point) circle' on db.
func CircleSubPt(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (pgtypes.Circle, error) {
	// call pg_catalog.circle_sub_pt
	const sqlstr = `SELECT * FROM pg_catalog.circle_sub_pt($1, $2)`
	// run
	var r0 pgtypes.Circle
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Circle{}, logerror(err)
	}
	return r0, nil
}

// ClockTimestamp calls the stored function 'pg_catalog.clock_timestamp() timestamp with time zone' on db.
func ClockTimestamp(ctx context.Context, db DB) (time.Time, error) {
	// call pg_catalog.clock_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.clock_timestamp()`
	// run
	var r0 time.Time
	logf(sqlstr)
	if err := db.QueryRowContext(ctx, sqlstr).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// CloseLb calls the stored function 'pg_catalog.close_lb(line, box) point' on db.
func CloseLb(ctx context.Context, db DB, p0 pgtypes.Line, p1 pgtypes.Box) (pgtypes.Point, error) {
	// call pg_catalog.close_lb
	const sqlstr = `SELECT * FROM pg_catalog.close_lb($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CloseLs calls the stored function 'pg_catalog.close_ls(line, lseg) point' on db.
func CloseLs(ctx context.Context, db DB, p0 pgtypes.Line, p1 pgtypes.Lseg) (pgtypes.Point, error) {
	// call pg_catalog.close_ls
	const sqlstr = `SELECT * FROM pg_catalog.close_ls($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CloseLseg calls the stored function 'pg_catalog.close_lseg(lseg, lseg) point' on db.
func CloseLseg(ctx context.Context, db DB, p0, p1 pgtypes.Lseg) (pgtypes.Point, error) {
	// call pg_catalog.close_lseg
	const sqlstr = `SELECT * FROM pg_catalog.close_lseg($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// ClosePb calls the stored function 'pg_catalog.close_pb(point, box) point' on db.
func ClosePb(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Box) (pgtypes.Point, error) {
	// call pg_catalog.close_pb
	const sqlstr = `SELECT * FROM pg_catalog.close_pb($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// ClosePl calls the stored function 'pg_catalog.close_pl(point, line) point' on db.
func ClosePl(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Line) (pgtypes.Point, error) {
	// call pg_catalog.close_pl
	const sqlstr = `SELECT * FROM pg_catalog.close_pl($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// ClosePs calls the stored function 'pg_catalog.close_ps(point, lseg) point' on db.
func ClosePs(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Lseg) (pgtypes.Point, error) {
	// call pg_catalog.close_ps
	const sqlstr = `SELECT * FROM pg_catalog.close_ps($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CloseSb calls the stored function 'pg_catalog.close_sb(lseg, box) point' on db.
func CloseSb(ctx context.Context, db DB, p0 pgtypes.Lseg, p1 pgtypes.Box) (pgtypes.Point, error) {
	// call pg_catalog.close_sb
	const sqlstr = `SELECT * FROM pg_catalog.close_sb($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// CloseSl calls the stored function 'pg_catalog.close_sl(lseg, line) point' on db.
func CloseSl(ctx context.Context, db DB, p0 pgtypes.Lseg, p1 pgtypes.Line) (pgtypes.Point, error) {
	// call pg_catalog.close_sl
	const sqlstr = `SELECT * FROM pg_catalog.close_sl($1, $2)`
	// run
	var r0 pgtypes.Point
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Point{}, logerror(err)
	}
	return r0, nil
}

// ColDescription calls the stored function 'pg_catalog.col_description(oid, integer) text' on db.
func ColDescription(ctx context.Context, db DB, p0 pgtypes.Oid, p1 int) (string, error) {
	// call pg_catalog.col_description
	const sqlstr = `SELECT * FROM pg_catalog.col_description($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Contjoinsel calls the stored function 'pg_catalog.contjoinsel(internal, oid, internal, smallint, internal) double precision' on db.
func Contjoinsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int16, p4 pgtypes.Internal) (float64, error) {
	// call pg_catalog.contjoinsel
	const sqlstr = `SELECT * FROM pg_catalog.contjoinsel($1, $2, $3, $4, $5)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3, p4)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3, p4).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Contsel calls the stored function 'pg_catalog.contsel(internal, oid, internal, integer) double precision' on db.
func Contsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int) (float64, error) {
	// call pg_catalog.contsel
	const sqlstr = `SELECT * FROM pg_catalog.contsel($1, $2, $3, $4)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Convert calls the stored function 'pg_catalog.convert(bytea, name, name) bytea' on db.
func Convert(ctx context.Context, db DB, p0 []byte, p1, p2 string) ([]byte, error) {
	// call pg_catalog.convert
	const sqlstr = `SELECT * FROM pg_catalog.convert($1, $2, $3)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// ConvertFrom calls the stored function 'pg_catalog.convert_from(bytea, name) text' on db.
func ConvertFrom(ctx context.Context, db DB, p0 []byte, p1 string) (string, error) {
	// call pg_catalog.convert_from
	const sqlstr = `SELECT * FROM pg_catalog.convert_from($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// ConvertTo calls the stored function 'pg_catalog.convert_to(text, name) bytea' on db.
func ConvertTo(ctx context.Context, db DB, p0, p1 string) ([]byte, error) {
	// call pg_catalog.convert_to
	const sqlstr = `SELECT * FROM pg_catalog.convert_to($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Cos calls the stored function 'pg_catalog.cos(double precision) double precision' on db.
func Cos(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cos
	const sqlstr = `SELECT * FROM pg_catalog.cos($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Cosd calls the stored function 'pg_catalog.cosd(double precision) double precision' on db.
func Cosd(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cosd
	const sqlstr = `SELECT * FROM pg_catalog.cosd($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Cosh calls the stored function 'pg_catalog.cosh(double precision) double precision' on db.
func Cosh(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cosh
	const sqlstr = `SELECT * FROM pg_catalog.cosh($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Cot calls the stored function 'pg_catalog.cot(double precision) double precision' on db.
func Cot(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cot
	const sqlstr = `SELECT * FROM pg_catalog.cot($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Cotd calls the stored function 'pg_catalog.cotd(double precision) double precision' on db.
func Cotd(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.cotd
	const sqlstr = `SELECT * FROM pg_catalog.cotd($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// CurrentDatabase calls the stored function 'pg_catalog.current_database() name' on db.
func CurrentDatabase(ctx context.Context, db DB) (string, error) {
	// call pg_catalog.current_database
	const sqlstr = `SELECT * FROM pg_catalog.current_database()`
	// run
	var r0 string
	logf(sqlstr)
	if err := db.QueryRowContext(ctx, sqlstr).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CurrentQuery calls the stored function 'pg_catalog.current_query() text' on db.
func CurrentQuery(ctx context.Context, db DB) (string, error) {
	// call pg_catalog.current_query
	const sqlstr = `SELECT * FROM pg_catalog.current_query()`
	// run
	var r0 string
	logf(sqlstr)
	if err := db.QueryRowContext(ctx, sqlstr).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CurrentSchema calls the stored function 'pg_catalog.current_schema() name' on db.
func CurrentSchema(ctx context.Context, db DB) (string, error) {
	// call pg_catalog.current_schema
	const sqlstr = `SELECT * FROM pg_catalog.current_schema()`
	// run
	var r0 string
	logf(sqlstr)
	if err := db.QueryRowContext(ctx, sqlstr).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CurrentSchemas calls the stored function 'pg_catalog.current_schemas(boolean) name' on db.
func CurrentSchemas(ctx context.Context, db DB, p0 bool) (StringSlice, error) {
	// call pg_catalog.current_schemas
	const sqlstr = `SELECT * FROM pg_catalog.current_schemas($1)`
	// run
	var r0 StringSlice
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return StringSlice{}, logerror(err)
	}
	return r0, nil
}

// CurrentSettingByText calls the stored function 'pg_catalog.current_setting(text) text' on db.
func CurrentSettingByText(ctx context.Context, db DB, p0 string) (string, error) {
	// call pg_catalog.current_setting
	const sqlstr = `SELECT * FROM pg_catalog.current_setting($1)`
	// run
	var r0 string
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CurrentSettingByTextAndBoolean calls the stored function 'pg_catalog.current_setting(text, boolean) text' on db.
func CurrentSettingByTextAndBoolean(ctx context.Context, db DB, p0 string, p1 bool) (string, error) {
	// call pg_catalog.current_setting
	const sqlstr = `SELECT * FROM pg_catalog.current_setting($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// CurrentUser calls the stored function 'pg_catalog.current_user() name' on db.
func CurrentUser(ctx context.Context, db DB) (string, error) {
	// call pg_catalog.current_user
	const sqlstr = `SELECT * FROM pg_catalog.current_user()`
	// run
	var r0 string
	logf(sqlstr)
	if err := db.QueryRowContext(ctx, sqlstr).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// Currtid calls the stored function 'pg_catalog.currtid(oid, tid) tid' on db.
func Currtid(ctx context.Context, db DB, p0 pgtypes.Oid, p1 pgtypes.Tid) (pgtypes.Tid, error) {
	// call pg_catalog.currtid
	const sqlstr = `SELECT * FROM pg_catalog.currtid($1, $2)`
	// run
	var r0 pgtypes.Tid
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Tid{}, logerror(err)
	}
	return r0, nil
}

// Currtid2 calls the stored function 'pg_catalog.currtid2(text, tid) tid' on db.
func Currtid2(ctx context.Context, db DB, p0 string, p1 pgtypes.Tid) (pgtypes.Tid, error) {
	// call pg_catalog.currtid2
	const sqlstr = `SELECT * FROM pg_catalog.currtid2($1, $2)`
	// run
	var r0 pgtypes.Tid
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Tid{}, logerror(err)
	}
	return r0, nil
}

// Currval calls the stored function 'pg_catalog.currval(regclass) bigint' on db.
func Currval(ctx context.Context, db DB, p0 pgtypes.Regclass) (int64, error) {
	// call pg_catalog.currval
	const sqlstr = `SELECT * FROM pg_catalog.currval($1)`
	// run
	var r0 int64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// CursorToXML calls the stored function 'pg_catalog.cursor_to_xml(refcursor, integer, boolean, boolean, text) xml' on db.
func CursorToXML(ctx context.Context, db DB, cursor pgtypes.Refcursor, count int, nulls, tableforest bool, targetns string) ([]byte, error) {
	// call pg_catalog.cursor_to_xml
	const sqlstr = `SELECT * FROM pg_catalog.cursor_to_xml($1, $2, $3, $4, $5)`
	// run
	var r0 []byte
	logf(sqlstr, cursor, count, nulls, tableforest, targetns)
	if err := db.QueryRowContext(ctx, sqlstr, cursor, count, nulls, tableforest, targetns).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// CursorToXmlschema calls the stored function 'pg_catalog.cursor_to_xmlschema(refcursor, boolean, boolean, text) xml' on db.
func CursorToXmlschema(ctx context.Context, db DB, cursor pgtypes.Refcursor, nulls, tableforest bool, targetns string) ([]byte, error) {
	// call pg_catalog.cursor_to_xmlschema
	const sqlstr = `SELECT * FROM pg_catalog.cursor_to_xmlschema($1, $2, $3, $4)`
	// run
	var r0 []byte
	logf(sqlstr, cursor, nulls, tableforest, targetns)
	if err := db.QueryRowContext(ctx, sqlstr, cursor, nulls, tableforest, targetns).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DatabaseToXML calls the stored function 'pg_catalog.database_to_xml(boolean, boolean, text) xml' on db.
func DatabaseToXML(ctx context.Context, db DB, nulls, tableforest bool, targetns string) ([]byte, error) {
	// call pg_catalog.database_to_xml
	const sqlstr = `SELECT * FROM pg_catalog.database_to_xml($1, $2, $3)`
	// run
	var r0 []byte
	logf(sqlstr, nulls, tableforest, targetns)
	if err := db.QueryRowContext(ctx, sqlstr, nulls, tableforest, targetns).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DatabaseToXMLAndXmlschema calls the stored function 'pg_catalog.database_to_xml_and_xmlschema(boolean, boolean, text) xml' on db.
func DatabaseToXMLAndXmlschema(ctx context.Context, db DB, nulls, tableforest bool, targetns string) ([]byte, error) {
	// call pg_catalog.database_to_xml_and_xmlschema
	const sqlstr = `SELECT * FROM pg_catalog.database_to_xml_and_xmlschema($1, $2, $3)`
	// run
	var r0 []byte
	logf(sqlstr, nulls, tableforest, targetns)
	if err := db.QueryRowContext(ctx, sqlstr, nulls, tableforest, targetns).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DatabaseToXmlschema calls the stored function 'pg_catalog.database_to_xmlschema(boolean, boolean, text) xml' on db.
func DatabaseToXmlschema(ctx context.Context, db DB, nulls, tableforest bool, targetns string) ([]byte, error) {
	// call pg_catalog.database_to_xmlschema
	const sqlstr = `SELECT * FROM pg_catalog.database_to_xmlschema($1, $2, $3)`
	// run
	var r0 []byte
	logf(sqlstr, nulls, tableforest, targetns)
	if err := db.QueryRowContext(ctx, sqlstr, nulls, tableforest, targetns).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DateByTimestampWithTimeZone calls the stored function 'pg_catalog.date(timestamp with time zone) date' on db.
func DateByTimestampWithTimeZone(ctx context.Context, db DB, p0 time.Time) (time.Time, error) {
	// call pg_catalog.date
	const sqlstr = `SELECT * FROM pg_catalog.date($1)`
	// run
	var r0 time.Time
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateByTimestampWithoutTimeZone calls the stored function 'pg_catalog.date(timestamp without time zone) date' on db.
func DateByTimestampWithoutTimeZone(ctx context.Context, db DB, p0 time.Time) (time.Time, error) {
	// call pg_catalog.date
	const sqlstr = `SELECT * FROM pg_catalog.date($1)`
	// run
	var r0 time.Time
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateCmp calls the stored function 'pg_catalog.date_cmp(date, date) integer' on db.
func DateCmp(ctx context.Context, db DB, p0, p1 time.Time) (int, error) {
	// call pg_catalog.date_cmp
	const sqlstr = `SELECT * FROM pg_catalog.date_cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// DateCmpTimestamp calls the stored function 'pg_catalog.date_cmp_timestamp(date, timestamp without time zone) integer' on db.
func DateCmpTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (int, error) {
	// call pg_catalog.date_cmp_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_cmp_timestamp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// DateCmpTimestamptz calls the stored function 'pg_catalog.date_cmp_timestamptz(date, timestamp with time zone) integer' on db.
func DateCmpTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (int, error) {
	// call pg_catalog.date_cmp_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_cmp_timestamptz($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// DateEq calls the stored function 'pg_catalog.date_eq(date, date) boolean' on db.
func DateEq(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_eq
	const sqlstr = `SELECT * FROM pg_catalog.date_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateEqTimestamp calls the stored function 'pg_catalog.date_eq_timestamp(date, timestamp without time zone) boolean' on db.
func DateEqTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_eq_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_eq_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateEqTimestamptz calls the stored function 'pg_catalog.date_eq_timestamptz(date, timestamp with time zone) boolean' on db.
func DateEqTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_eq_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_eq_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGe calls the stored function 'pg_catalog.date_ge(date, date) boolean' on db.
func DateGe(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ge
	const sqlstr = `SELECT * FROM pg_catalog.date_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGeTimestamp calls the stored function 'pg_catalog.date_ge_timestamp(date, timestamp without time zone) boolean' on db.
func DateGeTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ge_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_ge_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGeTimestamptz calls the stored function 'pg_catalog.date_ge_timestamptz(date, timestamp with time zone) boolean' on db.
func DateGeTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ge_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_ge_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGt calls the stored function 'pg_catalog.date_gt(date, date) boolean' on db.
func DateGt(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_gt
	const sqlstr = `SELECT * FROM pg_catalog.date_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGtTimestamp calls the stored function 'pg_catalog.date_gt_timestamp(date, timestamp without time zone) boolean' on db.
func DateGtTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_gt_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_gt_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateGtTimestamptz calls the stored function 'pg_catalog.date_gt_timestamptz(date, timestamp with time zone) boolean' on db.
func DateGtTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_gt_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_gt_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLarger calls the stored function 'pg_catalog.date_larger(date, date) date' on db.
func DateLarger(ctx context.Context, db DB, p0, p1 time.Time) (time.Time, error) {
	// call pg_catalog.date_larger
	const sqlstr = `SELECT * FROM pg_catalog.date_larger($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateLe calls the stored function 'pg_catalog.date_le(date, date) boolean' on db.
func DateLe(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_le
	const sqlstr = `SELECT * FROM pg_catalog.date_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLeTimestamp calls the stored function 'pg_catalog.date_le_timestamp(date, timestamp without time zone) boolean' on db.
func DateLeTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_le_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_le_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLeTimestamptz calls the stored function 'pg_catalog.date_le_timestamptz(date, timestamp with time zone) boolean' on db.
func DateLeTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_le_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_le_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLt calls the stored function 'pg_catalog.date_lt(date, date) boolean' on db.
func DateLt(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_lt
	const sqlstr = `SELECT * FROM pg_catalog.date_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLtTimestamp calls the stored function 'pg_catalog.date_lt_timestamp(date, timestamp without time zone) boolean' on db.
func DateLtTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_lt_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_lt_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateLtTimestamptz calls the stored function 'pg_catalog.date_lt_timestamptz(date, timestamp with time zone) boolean' on db.
func DateLtTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_lt_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_lt_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateMi calls the stored function 'pg_catalog.date_mi(date, date) integer' on db.
func DateMi(ctx context.Context, db DB, p0, p1 time.Time) (int, error) {
	// call pg_catalog.date_mi
	const sqlstr = `SELECT * FROM pg_catalog.date_mi($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// DateMiInterval calls the stored function 'pg_catalog.date_mi_interval(date, interval) timestamp without time zone' on db.
func DateMiInterval(ctx context.Context, db DB, p0 time.Time, p1 []byte) (time.Time, error) {
	// call pg_catalog.date_mi_interval
	const sqlstr = `SELECT * FROM pg_catalog.date_mi_interval($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateMii calls the stored function 'pg_catalog.date_mii(date, integer) date' on db.
func DateMii(ctx context.Context, db DB, p0 time.Time, p1 int) (time.Time, error) {
	// call pg_catalog.date_mii
	const sqlstr = `SELECT * FROM pg_catalog.date_mii($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateNe calls the stored function 'pg_catalog.date_ne(date, date) boolean' on db.
func DateNe(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ne
	const sqlstr = `SELECT * FROM pg_catalog.date_ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateNeTimestamp calls the stored function 'pg_catalog.date_ne_timestamp(date, timestamp without time zone) boolean' on db.
func DateNeTimestamp(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ne_timestamp
	const sqlstr = `SELECT * FROM pg_catalog.date_ne_timestamp($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DateNeTimestamptz calls the stored function 'pg_catalog.date_ne_timestamptz(date, timestamp with time zone) boolean' on db.
func DateNeTimestamptz(ctx context.Context, db DB, p0, p1 time.Time) (bool, error) {
	// call pg_catalog.date_ne_timestamptz
	const sqlstr = `SELECT * FROM pg_catalog.date_ne_timestamptz($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndTimestampWithTimeZone calls the stored function 'pg_catalog.date_part(text, timestamp with time zone) double precision' on db.
func DatePartByTextAndTimestampWithTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndInterval calls the stored function 'pg_catalog.date_part(text, interval) double precision' on db.
func DatePartByTextAndInterval(ctx context.Context, db DB, p0 string, p1 []byte) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndTimeWithTimeZone calls the stored function 'pg_catalog.date_part(text, time with time zone) double precision' on db.
func DatePartByTextAndTimeWithTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndDate calls the stored function 'pg_catalog.date_part(text, date) double precision' on db.
func DatePartByTextAndDate(ctx context.Context, db DB, p0 string, p1 time.Time) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndTimeWithoutTimeZone calls the stored function 'pg_catalog.date_part(text, time without time zone) double precision' on db.
func DatePartByTextAndTimeWithoutTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePartByTextAndTimestampWithoutTimeZone calls the stored function 'pg_catalog.date_part(text, timestamp without time zone) double precision' on db.
func DatePartByTextAndTimestampWithoutTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (float64, error) {
	// call pg_catalog.date_part
	const sqlstr = `SELECT * FROM pg_catalog.date_part($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatePlInterval calls the stored function 'pg_catalog.date_pl_interval(date, interval) timestamp without time zone' on db.
func DatePlInterval(ctx context.Context, db DB, p0 time.Time, p1 []byte) (time.Time, error) {
	// call pg_catalog.date_pl_interval
	const sqlstr = `SELECT * FROM pg_catalog.date_pl_interval($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DatePli calls the stored function 'pg_catalog.date_pli(date, integer) date' on db.
func DatePli(ctx context.Context, db DB, p0 time.Time, p1 int) (time.Time, error) {
	// call pg_catalog.date_pli
	const sqlstr = `SELECT * FROM pg_catalog.date_pli($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateRecv calls the stored function 'pg_catalog.date_recv(internal) date' on db.
func DateRecv(ctx context.Context, db DB, p0 pgtypes.Internal) (time.Time, error) {
	// call pg_catalog.date_recv
	const sqlstr = `SELECT * FROM pg_catalog.date_recv($1)`
	// run
	var r0 time.Time
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateSend calls the stored function 'pg_catalog.date_send(date) bytea' on db.
func DateSend(ctx context.Context, db DB, p0 time.Time) ([]byte, error) {
	// call pg_catalog.date_send
	const sqlstr = `SELECT * FROM pg_catalog.date_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DateSmaller calls the stored function 'pg_catalog.date_smaller(date, date) date' on db.
func DateSmaller(ctx context.Context, db DB, p0, p1 time.Time) (time.Time, error) {
	// call pg_catalog.date_smaller
	const sqlstr = `SELECT * FROM pg_catalog.date_smaller($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateSortsupport calls the stored function 'pg_catalog.date_sortsupport(internal)' on db.
func DateSortsupport(ctx context.Context, db DB, p0 pgtypes.Internal) error {
	// call pg_catalog.date_sortsupport
	const sqlstr = `SELECT * FROM pg_catalog.date_sortsupport($1)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0); err != nil {
		return logerror(err)
	}
	return nil
}

// DateTruncByTextAndTimestampWithTimeZone calls the stored function 'pg_catalog.date_trunc(text, timestamp with time zone) timestamp with time zone' on db.
func DateTruncByTextAndTimestampWithTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (time.Time, error) {
	// call pg_catalog.date_trunc
	const sqlstr = `SELECT * FROM pg_catalog.date_trunc($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateTruncByTextAndInterval calls the stored function 'pg_catalog.date_trunc(text, interval) interval' on db.
func DateTruncByTextAndInterval(ctx context.Context, db DB, p0 string, p1 []byte) ([]byte, error) {
	// call pg_catalog.date_trunc
	const sqlstr = `SELECT * FROM pg_catalog.date_trunc($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// DateTruncByTextTimestampWithTimeZoneAndText calls the stored function 'pg_catalog.date_trunc(text, timestamp with time zone, text) timestamp with time zone' on db.
func DateTruncByTextTimestampWithTimeZoneAndText(ctx context.Context, db DB, p0 string, p1 time.Time, p2 string) (time.Time, error) {
	// call pg_catalog.date_trunc
	const sqlstr = `SELECT * FROM pg_catalog.date_trunc($1, $2, $3)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DateTruncByTextAndTimestampWithoutTimeZone calls the stored function 'pg_catalog.date_trunc(text, timestamp without time zone) timestamp without time zone' on db.
func DateTruncByTextAndTimestampWithoutTimeZone(ctx context.Context, db DB, p0 string, p1 time.Time) (time.Time, error) {
	// call pg_catalog.date_trunc
	const sqlstr = `SELECT * FROM pg_catalog.date_trunc($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DaterangeByDateAndDate calls the stored function 'pg_catalog.daterange(date, date) daterange' on db.
func DaterangeByDateAndDate(ctx context.Context, db DB, p0, p1 time.Time) (pgtypes.Daterange, error) {
	// call pg_catalog.daterange
	const sqlstr = `SELECT * FROM pg_catalog.daterange($1, $2)`
	// run
	var r0 pgtypes.Daterange
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Daterange{}, logerror(err)
	}
	return r0, nil
}

// DaterangeByDateDateAndText calls the stored function 'pg_catalog.daterange(date, date, text) daterange' on db.
func DaterangeByDateDateAndText(ctx context.Context, db DB, p0, p1 time.Time, p2 string) (pgtypes.Daterange, error) {
	// call pg_catalog.daterange
	const sqlstr = `SELECT * FROM pg_catalog.daterange($1, $2, $3)`
	// run
	var r0 pgtypes.Daterange
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Daterange{}, logerror(err)
	}
	return r0, nil
}

// DaterangeCanonical calls the stored function 'pg_catalog.daterange_canonical(daterange) daterange' on db.
func DaterangeCanonical(ctx context.Context, db DB, p0 pgtypes.Daterange) (pgtypes.Daterange, error) {
	// call pg_catalog.daterange_canonical
	const sqlstr = `SELECT * FROM pg_catalog.daterange_canonical($1)`
	// run
	var r0 pgtypes.Daterange
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Daterange{}, logerror(err)
	}
	return r0, nil
}

// DaterangeSubdiff calls the stored function 'pg_catalog.daterange_subdiff(date, date) double precision' on db.
func DaterangeSubdiff(ctx context.Context, db DB, p0, p1 time.Time) (float64, error) {
	// call pg_catalog.daterange_subdiff
	const sqlstr = `SELECT * FROM pg_catalog.daterange_subdiff($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DatetimePl calls the stored function 'pg_catalog.datetime_pl(date, time without time zone) timestamp without time zone' on db.
func DatetimePl(ctx context.Context, db DB, p0, p1 time.Time) (time.Time, error) {
	// call pg_catalog.datetime_pl
	const sqlstr = `SELECT * FROM pg_catalog.datetime_pl($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// DatetimetzPl calls the stored function 'pg_catalog.datetimetz_pl(date, time with time zone) timestamp with time zone' on db.
func DatetimetzPl(ctx context.Context, db DB, p0, p1 time.Time) (time.Time, error) {
	// call pg_catalog.datetimetz_pl
	const sqlstr = `SELECT * FROM pg_catalog.datetimetz_pl($1, $2)`
	// run
	var r0 time.Time
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return time.Time{}, logerror(err)
	}
	return r0, nil
}

// Dcbrt calls the stored function 'pg_catalog.dcbrt(double precision) double precision' on db.
func Dcbrt(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dcbrt
	const sqlstr = `SELECT * FROM pg_catalog.dcbrt($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Decode calls the stored function 'pg_catalog.decode(text, text) bytea' on db.
func Decode(ctx context.Context, db DB, p0, p1 string) ([]byte, error) {
	// call pg_catalog.decode
	const sqlstr = `SELECT * FROM pg_catalog.decode($1, $2)`
	// run
	var r0 []byte
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Degrees calls the stored function 'pg_catalog.degrees(double precision) double precision' on db.
func Degrees(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.degrees
	const sqlstr = `SELECT * FROM pg_catalog.degrees($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Dexp calls the stored function 'pg_catalog.dexp(double precision) double precision' on db.
func Dexp(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dexp
	const sqlstr = `SELECT * FROM pg_catalog.dexp($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Diagonal calls the stored function 'pg_catalog.diagonal(box) lseg' on db.
func Diagonal(ctx context.Context, db DB, p0 pgtypes.Box) (pgtypes.Lseg, error) {
	// call pg_catalog.diagonal
	const sqlstr = `SELECT * FROM pg_catalog.diagonal($1)`
	// run
	var r0 pgtypes.Lseg
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Lseg{}, logerror(err)
	}
	return r0, nil
}

// Diameter calls the stored function 'pg_catalog.diameter(circle) double precision' on db.
func Diameter(ctx context.Context, db DB, p0 pgtypes.Circle) (float64, error) {
	// call pg_catalog.diameter
	const sqlstr = `SELECT * FROM pg_catalog.diameter($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DispellInit calls the stored function 'pg_catalog.dispell_init(internal) internal' on db.
func DispellInit(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dispell_init
	const sqlstr = `SELECT * FROM pg_catalog.dispell_init($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DispellLexize calls the stored function 'pg_catalog.dispell_lexize(internal, internal, internal, internal) internal' on db.
func DispellLexize(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dispell_lexize
	const sqlstr = `SELECT * FROM pg_catalog.dispell_lexize($1, $2, $3, $4)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DistBl calls the stored function 'pg_catalog.dist_bl(box, line) double precision' on db.
func DistBl(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Line) (float64, error) {
	// call pg_catalog.dist_bl
	const sqlstr = `SELECT * FROM pg_catalog.dist_bl($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistBp calls the stored function 'pg_catalog.dist_bp(box, point) double precision' on db.
func DistBp(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_bp
	const sqlstr = `SELECT * FROM pg_catalog.dist_bp($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistBs calls the stored function 'pg_catalog.dist_bs(box, lseg) double precision' on db.
func DistBs(ctx context.Context, db DB, p0 pgtypes.Box, p1 pgtypes.Lseg) (float64, error) {
	// call pg_catalog.dist_bs
	const sqlstr = `SELECT * FROM pg_catalog.dist_bs($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistCpoint calls the stored function 'pg_catalog.dist_cpoint(circle, point) double precision' on db.
func DistCpoint(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_cpoint
	const sqlstr = `SELECT * FROM pg_catalog.dist_cpoint($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistCpoly calls the stored function 'pg_catalog.dist_cpoly(circle, polygon) double precision' on db.
func DistCpoly(ctx context.Context, db DB, p0 pgtypes.Circle, p1 pgtypes.Polygon) (float64, error) {
	// call pg_catalog.dist_cpoly
	const sqlstr = `SELECT * FROM pg_catalog.dist_cpoly($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistLb calls the stored function 'pg_catalog.dist_lb(line, box) double precision' on db.
func DistLb(ctx context.Context, db DB, p0 pgtypes.Line, p1 pgtypes.Box) (float64, error) {
	// call pg_catalog.dist_lb
	const sqlstr = `SELECT * FROM pg_catalog.dist_lb($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistLp calls the stored function 'pg_catalog.dist_lp(line, point) double precision' on db.
func DistLp(ctx context.Context, db DB, p0 pgtypes.Line, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_lp
	const sqlstr = `SELECT * FROM pg_catalog.dist_lp($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistLs calls the stored function 'pg_catalog.dist_ls(line, lseg) double precision' on db.
func DistLs(ctx context.Context, db DB, p0 pgtypes.Line, p1 pgtypes.Lseg) (float64, error) {
	// call pg_catalog.dist_ls
	const sqlstr = `SELECT * FROM pg_catalog.dist_ls($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPathp calls the stored function 'pg_catalog.dist_pathp(path, point) double precision' on db.
func DistPathp(ctx context.Context, db DB, p0 pgtypes.Path, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_pathp
	const sqlstr = `SELECT * FROM pg_catalog.dist_pathp($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPb calls the stored function 'pg_catalog.dist_pb(point, box) double precision' on db.
func DistPb(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Box) (float64, error) {
	// call pg_catalog.dist_pb
	const sqlstr = `SELECT * FROM pg_catalog.dist_pb($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPc calls the stored function 'pg_catalog.dist_pc(point, circle) double precision' on db.
func DistPc(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Circle) (float64, error) {
	// call pg_catalog.dist_pc
	const sqlstr = `SELECT * FROM pg_catalog.dist_pc($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPl calls the stored function 'pg_catalog.dist_pl(point, line) double precision' on db.
func DistPl(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Line) (float64, error) {
	// call pg_catalog.dist_pl
	const sqlstr = `SELECT * FROM pg_catalog.dist_pl($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPolyc calls the stored function 'pg_catalog.dist_polyc(polygon, circle) double precision' on db.
func DistPolyc(ctx context.Context, db DB, p0 pgtypes.Polygon, p1 pgtypes.Circle) (float64, error) {
	// call pg_catalog.dist_polyc
	const sqlstr = `SELECT * FROM pg_catalog.dist_polyc($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPolyp calls the stored function 'pg_catalog.dist_polyp(polygon, point) double precision' on db.
func DistPolyp(ctx context.Context, db DB, p0 pgtypes.Polygon, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_polyp
	const sqlstr = `SELECT * FROM pg_catalog.dist_polyp($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPpath calls the stored function 'pg_catalog.dist_ppath(point, path) double precision' on db.
func DistPpath(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Path) (float64, error) {
	// call pg_catalog.dist_ppath
	const sqlstr = `SELECT * FROM pg_catalog.dist_ppath($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPpoly calls the stored function 'pg_catalog.dist_ppoly(point, polygon) double precision' on db.
func DistPpoly(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Polygon) (float64, error) {
	// call pg_catalog.dist_ppoly
	const sqlstr = `SELECT * FROM pg_catalog.dist_ppoly($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistPs calls the stored function 'pg_catalog.dist_ps(point, lseg) double precision' on db.
func DistPs(ctx context.Context, db DB, p0 pgtypes.Point, p1 pgtypes.Lseg) (float64, error) {
	// call pg_catalog.dist_ps
	const sqlstr = `SELECT * FROM pg_catalog.dist_ps($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistSb calls the stored function 'pg_catalog.dist_sb(lseg, box) double precision' on db.
func DistSb(ctx context.Context, db DB, p0 pgtypes.Lseg, p1 pgtypes.Box) (float64, error) {
	// call pg_catalog.dist_sb
	const sqlstr = `SELECT * FROM pg_catalog.dist_sb($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistSl calls the stored function 'pg_catalog.dist_sl(lseg, line) double precision' on db.
func DistSl(ctx context.Context, db DB, p0 pgtypes.Lseg, p1 pgtypes.Line) (float64, error) {
	// call pg_catalog.dist_sl
	const sqlstr = `SELECT * FROM pg_catalog.dist_sl($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DistSp calls the stored function 'pg_catalog.dist_sp(lseg, point) double precision' on db.
func DistSp(ctx context.Context, db DB, p0 pgtypes.Lseg, p1 pgtypes.Point) (float64, error) {
	// call pg_catalog.dist_sp
	const sqlstr = `SELECT * FROM pg_catalog.dist_sp($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Div calls the stored function 'pg_catalog.div(numeric, numeric) numeric' on db.
func Div(ctx context.Context, db DB, p0, p1 float64) (float64, error) {
	// call pg_catalog.div
	const sqlstr = `SELECT * FROM pg_catalog.div($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Dlog1 calls the stored function 'pg_catalog.dlog1(double precision) double precision' on db.
func Dlog1(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dlog1
	const sqlstr = `SELECT * FROM pg_catalog.dlog1($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Dlog10 calls the stored function 'pg_catalog.dlog10(double precision) double precision' on db.
func Dlog10(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dlog10
	const sqlstr = `SELECT * FROM pg_catalog.dlog10($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DomainRecv calls the stored function 'pg_catalog.domain_recv(internal, oid, integer) "any"' on db.
func DomainRecv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 int) (pgtypes.Any, error) {
	// call pg_catalog.domain_recv
	const sqlstr = `SELECT * FROM pg_catalog.domain_recv($1, $2, $3)`
	// run
	var r0 pgtypes.Any
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return pgtypes.Any{}, logerror(err)
	}
	return r0, nil
}

// Dpow calls the stored function 'pg_catalog.dpow(double precision, double precision) double precision' on db.
func Dpow(ctx context.Context, db DB, p0, p1 float64) (float64, error) {
	// call pg_catalog.dpow
	const sqlstr = `SELECT * FROM pg_catalog.dpow($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Dround calls the stored function 'pg_catalog.dround(double precision) double precision' on db.
func Dround(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dround
	const sqlstr = `SELECT * FROM pg_catalog.dround($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DsimpleInit calls the stored function 'pg_catalog.dsimple_init(internal) internal' on db.
func DsimpleInit(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsimple_init
	const sqlstr = `SELECT * FROM pg_catalog.dsimple_init($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DsimpleLexize calls the stored function 'pg_catalog.dsimple_lexize(internal, internal, internal, internal) internal' on db.
func DsimpleLexize(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsimple_lexize
	const sqlstr = `SELECT * FROM pg_catalog.dsimple_lexize($1, $2, $3, $4)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DsnowballInit calls the stored function 'pg_catalog.dsnowball_init(internal) internal' on db.
func DsnowballInit(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsnowball_init
	const sqlstr = `SELECT * FROM pg_catalog.dsnowball_init($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DsnowballLexize calls the stored function 'pg_catalog.dsnowball_lexize(internal, internal, internal, internal) internal' on db.
func DsnowballLexize(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsnowball_lexize
	const sqlstr = `SELECT * FROM pg_catalog.dsnowball_lexize($1, $2, $3, $4)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// Dsqrt calls the stored function 'pg_catalog.dsqrt(double precision) double precision' on db.
func Dsqrt(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dsqrt
	const sqlstr = `SELECT * FROM pg_catalog.dsqrt($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// DsynonymInit calls the stored function 'pg_catalog.dsynonym_init(internal) internal' on db.
func DsynonymInit(ctx context.Context, db DB, p0 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsynonym_init
	const sqlstr = `SELECT * FROM pg_catalog.dsynonym_init($1)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// DsynonymLexize calls the stored function 'pg_catalog.dsynonym_lexize(internal, internal, internal, internal) internal' on db.
func DsynonymLexize(ctx context.Context, db DB, p0, p1, p2, p3 pgtypes.Internal) (pgtypes.Internal, error) {
	// call pg_catalog.dsynonym_lexize
	const sqlstr = `SELECT * FROM pg_catalog.dsynonym_lexize($1, $2, $3, $4)`
	// run
	var r0 pgtypes.Internal
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return pgtypes.Internal{}, logerror(err)
	}
	return r0, nil
}

// Dtrunc calls the stored function 'pg_catalog.dtrunc(double precision) double precision' on db.
func Dtrunc(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.dtrunc
	const sqlstr = `SELECT * FROM pg_catalog.dtrunc($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// ElemContainedByRange calls the stored function 'pg_catalog.elem_contained_by_range(anyelement, anyrange) boolean' on db.
func ElemContainedByRange(ctx context.Context, db DB, p0 pgtypes.Anyelement, p1 pgtypes.Anyrange) (bool, error) {
	// call pg_catalog.elem_contained_by_range
	const sqlstr = `SELECT * FROM pg_catalog.elem_contained_by_range($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Encode calls the stored function 'pg_catalog.encode(bytea, text) text' on db.
func Encode(ctx context.Context, db DB, p0 []byte, p1 string) (string, error) {
	// call pg_catalog.encode
	const sqlstr = `SELECT * FROM pg_catalog.encode($1, $2)`
	// run
	var r0 string
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return "", logerror(err)
	}
	return r0, nil
}

// EnumCmp calls the stored function 'pg_catalog.enum_cmp(anyenum, anyenum) integer' on db.
func EnumCmp(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (int, error) {
	// call pg_catalog.enum_cmp
	const sqlstr = `SELECT * FROM pg_catalog.enum_cmp($1, $2)`
	// run
	var r0 int
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// EnumEq calls the stored function 'pg_catalog.enum_eq(anyenum, anyenum) boolean' on db.
func EnumEq(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_eq
	const sqlstr = `SELECT * FROM pg_catalog.enum_eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumFirst calls the stored function 'pg_catalog.enum_first(anyenum) anyenum' on db.
func EnumFirst(ctx context.Context, db DB, p0 pgtypes.Anyenum) (pgtypes.Anyenum, error) {
	// call pg_catalog.enum_first
	const sqlstr = `SELECT * FROM pg_catalog.enum_first($1)`
	// run
	var r0 pgtypes.Anyenum
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Anyenum{}, logerror(err)
	}
	return r0, nil
}

// EnumGe calls the stored function 'pg_catalog.enum_ge(anyenum, anyenum) boolean' on db.
func EnumGe(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_ge
	const sqlstr = `SELECT * FROM pg_catalog.enum_ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumGt calls the stored function 'pg_catalog.enum_gt(anyenum, anyenum) boolean' on db.
func EnumGt(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_gt
	const sqlstr = `SELECT * FROM pg_catalog.enum_gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumLarger calls the stored function 'pg_catalog.enum_larger(anyenum, anyenum) anyenum' on db.
func EnumLarger(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (pgtypes.Anyenum, error) {
	// call pg_catalog.enum_larger
	const sqlstr = `SELECT * FROM pg_catalog.enum_larger($1, $2)`
	// run
	var r0 pgtypes.Anyenum
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyenum{}, logerror(err)
	}
	return r0, nil
}

// EnumLast calls the stored function 'pg_catalog.enum_last(anyenum) anyenum' on db.
func EnumLast(ctx context.Context, db DB, p0 pgtypes.Anyenum) (pgtypes.Anyenum, error) {
	// call pg_catalog.enum_last
	const sqlstr = `SELECT * FROM pg_catalog.enum_last($1)`
	// run
	var r0 pgtypes.Anyenum
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Anyenum{}, logerror(err)
	}
	return r0, nil
}

// EnumLe calls the stored function 'pg_catalog.enum_le(anyenum, anyenum) boolean' on db.
func EnumLe(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_le
	const sqlstr = `SELECT * FROM pg_catalog.enum_le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumLt calls the stored function 'pg_catalog.enum_lt(anyenum, anyenum) boolean' on db.
func EnumLt(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_lt
	const sqlstr = `SELECT * FROM pg_catalog.enum_lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumNe calls the stored function 'pg_catalog.enum_ne(anyenum, anyenum) boolean' on db.
func EnumNe(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (bool, error) {
	// call pg_catalog.enum_ne
	const sqlstr = `SELECT * FROM pg_catalog.enum_ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// EnumRangeByAnyenumAndAnyenum calls the stored function 'pg_catalog.enum_range(anyenum, anyenum) anyarray' on db.
func EnumRangeByAnyenumAndAnyenum(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (pgtypes.Anyarray, error) {
	// call pg_catalog.enum_range
	const sqlstr = `SELECT * FROM pg_catalog.enum_range($1, $2)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// EnumRangeByAnyenum calls the stored function 'pg_catalog.enum_range(anyenum) anyarray' on db.
func EnumRangeByAnyenum(ctx context.Context, db DB, p0 pgtypes.Anyenum) (pgtypes.Anyarray, error) {
	// call pg_catalog.enum_range
	const sqlstr = `SELECT * FROM pg_catalog.enum_range($1)`
	// run
	var r0 pgtypes.Anyarray
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return pgtypes.Anyarray{}, logerror(err)
	}
	return r0, nil
}

// EnumRecv calls the stored function 'pg_catalog.enum_recv(internal, oid) anyenum' on db.
func EnumRecv(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid) (pgtypes.Anyenum, error) {
	// call pg_catalog.enum_recv
	const sqlstr = `SELECT * FROM pg_catalog.enum_recv($1, $2)`
	// run
	var r0 pgtypes.Anyenum
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyenum{}, logerror(err)
	}
	return r0, nil
}

// EnumSend calls the stored function 'pg_catalog.enum_send(anyenum) bytea' on db.
func EnumSend(ctx context.Context, db DB, p0 pgtypes.Anyenum) ([]byte, error) {
	// call pg_catalog.enum_send
	const sqlstr = `SELECT * FROM pg_catalog.enum_send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// EnumSmaller calls the stored function 'pg_catalog.enum_smaller(anyenum, anyenum) anyenum' on db.
func EnumSmaller(ctx context.Context, db DB, p0, p1 pgtypes.Anyenum) (pgtypes.Anyenum, error) {
	// call pg_catalog.enum_smaller
	const sqlstr = `SELECT * FROM pg_catalog.enum_smaller($1, $2)`
	// run
	var r0 pgtypes.Anyenum
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return pgtypes.Anyenum{}, logerror(err)
	}
	return r0, nil
}

// Eqjoinsel calls the stored function 'pg_catalog.eqjoinsel(internal, oid, internal, smallint, internal) double precision' on db.
func Eqjoinsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int16, p4 pgtypes.Internal) (float64, error) {
	// call pg_catalog.eqjoinsel
	const sqlstr = `SELECT * FROM pg_catalog.eqjoinsel($1, $2, $3, $4, $5)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3, p4)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3, p4).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Eqsel calls the stored function 'pg_catalog.eqsel(internal, oid, internal, integer) double precision' on db.
func Eqsel(ctx context.Context, db DB, p0 pgtypes.Internal, p1 pgtypes.Oid, p2 pgtypes.Internal, p3 int) (float64, error) {
	// call pg_catalog.eqsel
	const sqlstr = `SELECT * FROM pg_catalog.eqsel($1, $2, $3, $4)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1, p2, p3)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2, p3).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// EucCnToMic calls the stored function 'pg_catalog.euc_cn_to_mic(integer, integer, cstring, internal, integer)' on db.
func EucCnToMic(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_cn_to_mic
	const sqlstr = `SELECT * FROM pg_catalog.euc_cn_to_mic($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucCnToUTF8 calls the stored function 'pg_catalog.euc_cn_to_utf8(integer, integer, cstring, internal, integer)' on db.
func EucCnToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_cn_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.euc_cn_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucJis2004ToShiftJis2004 calls the stored function 'pg_catalog.euc_jis_2004_to_shift_jis_2004(integer, integer, cstring, internal, integer)' on db.
func EucJis2004ToShiftJis2004(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_jis_2004_to_shift_jis_2004
	const sqlstr = `SELECT * FROM pg_catalog.euc_jis_2004_to_shift_jis_2004($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucJis2004ToUTF8 calls the stored function 'pg_catalog.euc_jis_2004_to_utf8(integer, integer, cstring, internal, integer)' on db.
func EucJis2004ToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_jis_2004_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.euc_jis_2004_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucJpToMic calls the stored function 'pg_catalog.euc_jp_to_mic(integer, integer, cstring, internal, integer)' on db.
func EucJpToMic(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_jp_to_mic
	const sqlstr = `SELECT * FROM pg_catalog.euc_jp_to_mic($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucJpToSjis calls the stored function 'pg_catalog.euc_jp_to_sjis(integer, integer, cstring, internal, integer)' on db.
func EucJpToSjis(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_jp_to_sjis
	const sqlstr = `SELECT * FROM pg_catalog.euc_jp_to_sjis($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucJpToUTF8 calls the stored function 'pg_catalog.euc_jp_to_utf8(integer, integer, cstring, internal, integer)' on db.
func EucJpToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_jp_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.euc_jp_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucKrToMic calls the stored function 'pg_catalog.euc_kr_to_mic(integer, integer, cstring, internal, integer)' on db.
func EucKrToMic(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_kr_to_mic
	const sqlstr = `SELECT * FROM pg_catalog.euc_kr_to_mic($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucKrToUTF8 calls the stored function 'pg_catalog.euc_kr_to_utf8(integer, integer, cstring, internal, integer)' on db.
func EucKrToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_kr_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.euc_kr_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucTwToBig5 calls the stored function 'pg_catalog.euc_tw_to_big5(integer, integer, cstring, internal, integer)' on db.
func EucTwToBig5(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_tw_to_big5
	const sqlstr = `SELECT * FROM pg_catalog.euc_tw_to_big5($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucTwToMic calls the stored function 'pg_catalog.euc_tw_to_mic(integer, integer, cstring, internal, integer)' on db.
func EucTwToMic(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_tw_to_mic
	const sqlstr = `SELECT * FROM pg_catalog.euc_tw_to_mic($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// EucTwToUTF8 calls the stored function 'pg_catalog.euc_tw_to_utf8(integer, integer, cstring, internal, integer)' on db.
func EucTwToUTF8(ctx context.Context, db DB, p0, p1 int, p2 pgtypes.Cstring, p3 pgtypes.Internal, p4 int) error {
	// call pg_catalog.euc_tw_to_utf8
	const sqlstr = `SELECT * FROM pg_catalog.euc_tw_to_utf8($1, $2, $3, $4, $5)`
	// run
	logf(sqlstr)
	if _, err := db.ExecContext(ctx, sqlstr, p0, p1, p2, p3, p4); err != nil {
		return logerror(err)
	}
	return nil
}

// ExpByDoublePrecision calls the stored function 'pg_catalog.exp(double precision) double precision' on db.
func ExpByDoublePrecision(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.exp
	const sqlstr = `SELECT * FROM pg_catalog.exp($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// ExpByNumeric calls the stored function 'pg_catalog.exp(numeric) numeric' on db.
func ExpByNumeric(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.exp
	const sqlstr = `SELECT * FROM pg_catalog.exp($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Factorial calls the stored function 'pg_catalog.factorial(bigint) numeric' on db.
func Factorial(ctx context.Context, db DB, p0 int64) (float64, error) {
	// call pg_catalog.factorial
	const sqlstr = `SELECT * FROM pg_catalog.factorial($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Family calls the stored function 'pg_catalog.family(inet) integer' on db.
func Family(ctx context.Context, db DB, p0 string) (int, error) {
	// call pg_catalog.family
	const sqlstr = `SELECT * FROM pg_catalog.family($1)`
	// run
	var r0 int
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0, logerror(err)
	}
	return r0, nil
}

// Float4ByNumeric calls the stored function 'pg_catalog.float4(numeric) real' on db.
func Float4ByNumeric(ctx context.Context, db DB, p0 float64) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4BySmallint calls the stored function 'pg_catalog.float4(smallint) real' on db.
func Float4BySmallint(ctx context.Context, db DB, p0 int16) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4ByDoublePrecision calls the stored function 'pg_catalog.float4(double precision) real' on db.
func Float4ByDoublePrecision(ctx context.Context, db DB, p0 float64) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4ByInteger calls the stored function 'pg_catalog.float4(integer) real' on db.
func Float4ByInteger(ctx context.Context, db DB, p0 int) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4ByJsonb calls the stored function 'pg_catalog.float4(jsonb) real' on db.
func Float4ByJsonb(ctx context.Context, db DB, p0 []byte) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4ByBigint calls the stored function 'pg_catalog.float4(bigint) real' on db.
func Float4ByBigint(ctx context.Context, db DB, p0 int64) (float32, error) {
	// call pg_catalog.float4
	const sqlstr = `SELECT * FROM pg_catalog.float4($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float48div calls the stored function 'pg_catalog.float48div(real, double precision) double precision' on db.
func Float48div(ctx context.Context, db DB, p0 float32, p1 float64) (float64, error) {
	// call pg_catalog.float48div
	const sqlstr = `SELECT * FROM pg_catalog.float48div($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float48eq calls the stored function 'pg_catalog.float48eq(real, double precision) boolean' on db.
func Float48eq(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48eq
	const sqlstr = `SELECT * FROM pg_catalog.float48eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48ge calls the stored function 'pg_catalog.float48ge(real, double precision) boolean' on db.
func Float48ge(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48ge
	const sqlstr = `SELECT * FROM pg_catalog.float48ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48gt calls the stored function 'pg_catalog.float48gt(real, double precision) boolean' on db.
func Float48gt(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48gt
	const sqlstr = `SELECT * FROM pg_catalog.float48gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48le calls the stored function 'pg_catalog.float48le(real, double precision) boolean' on db.
func Float48le(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48le
	const sqlstr = `SELECT * FROM pg_catalog.float48le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48lt calls the stored function 'pg_catalog.float48lt(real, double precision) boolean' on db.
func Float48lt(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48lt
	const sqlstr = `SELECT * FROM pg_catalog.float48lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48mi calls the stored function 'pg_catalog.float48mi(real, double precision) double precision' on db.
func Float48mi(ctx context.Context, db DB, p0 float32, p1 float64) (float64, error) {
	// call pg_catalog.float48mi
	const sqlstr = `SELECT * FROM pg_catalog.float48mi($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float48mul calls the stored function 'pg_catalog.float48mul(real, double precision) double precision' on db.
func Float48mul(ctx context.Context, db DB, p0 float32, p1 float64) (float64, error) {
	// call pg_catalog.float48mul
	const sqlstr = `SELECT * FROM pg_catalog.float48mul($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float48ne calls the stored function 'pg_catalog.float48ne(real, double precision) boolean' on db.
func Float48ne(ctx context.Context, db DB, p0 float32, p1 float64) (bool, error) {
	// call pg_catalog.float48ne
	const sqlstr = `SELECT * FROM pg_catalog.float48ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float48pl calls the stored function 'pg_catalog.float48pl(real, double precision) double precision' on db.
func Float48pl(ctx context.Context, db DB, p0 float32, p1 float64) (float64, error) {
	// call pg_catalog.float48pl
	const sqlstr = `SELECT * FROM pg_catalog.float48pl($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4Accum calls the stored function 'pg_catalog.float4_accum(double precision, real) double precision' on db.
func Float4Accum(ctx context.Context, db DB, p0 []float64, p1 float32) ([]float64, error) {
	// call pg_catalog.float4_accum
	const sqlstr = `SELECT * FROM pg_catalog.float4_accum($1, $2)`
	// run
	var r0 []float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float4abs calls the stored function 'pg_catalog.float4abs(real) real' on db.
func Float4abs(ctx context.Context, db DB, p0 float32) (float32, error) {
	// call pg_catalog.float4abs
	const sqlstr = `SELECT * FROM pg_catalog.float4abs($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4div calls the stored function 'pg_catalog.float4div(real, real) real' on db.
func Float4div(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4div
	const sqlstr = `SELECT * FROM pg_catalog.float4div($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4eq calls the stored function 'pg_catalog.float4eq(real, real) boolean' on db.
func Float4eq(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4eq
	const sqlstr = `SELECT * FROM pg_catalog.float4eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4ge calls the stored function 'pg_catalog.float4ge(real, real) boolean' on db.
func Float4ge(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4ge
	const sqlstr = `SELECT * FROM pg_catalog.float4ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4gt calls the stored function 'pg_catalog.float4gt(real, real) boolean' on db.
func Float4gt(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4gt
	const sqlstr = `SELECT * FROM pg_catalog.float4gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4larger calls the stored function 'pg_catalog.float4larger(real, real) real' on db.
func Float4larger(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4larger
	const sqlstr = `SELECT * FROM pg_catalog.float4larger($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4le calls the stored function 'pg_catalog.float4le(real, real) boolean' on db.
func Float4le(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4le
	const sqlstr = `SELECT * FROM pg_catalog.float4le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4lt calls the stored function 'pg_catalog.float4lt(real, real) boolean' on db.
func Float4lt(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4lt
	const sqlstr = `SELECT * FROM pg_catalog.float4lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4mi calls the stored function 'pg_catalog.float4mi(real, real) real' on db.
func Float4mi(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4mi
	const sqlstr = `SELECT * FROM pg_catalog.float4mi($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4mul calls the stored function 'pg_catalog.float4mul(real, real) real' on db.
func Float4mul(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4mul
	const sqlstr = `SELECT * FROM pg_catalog.float4mul($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4ne calls the stored function 'pg_catalog.float4ne(real, real) boolean' on db.
func Float4ne(ctx context.Context, db DB, p0, p1 float32) (bool, error) {
	// call pg_catalog.float4ne
	const sqlstr = `SELECT * FROM pg_catalog.float4ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float4pl calls the stored function 'pg_catalog.float4pl(real, real) real' on db.
func Float4pl(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4pl
	const sqlstr = `SELECT * FROM pg_catalog.float4pl($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4recv calls the stored function 'pg_catalog.float4recv(internal) real' on db.
func Float4recv(ctx context.Context, db DB, p0 pgtypes.Internal) (float32, error) {
	// call pg_catalog.float4recv
	const sqlstr = `SELECT * FROM pg_catalog.float4recv($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4send calls the stored function 'pg_catalog.float4send(real) bytea' on db.
func Float4send(ctx context.Context, db DB, p0 float32) ([]byte, error) {
	// call pg_catalog.float4send
	const sqlstr = `SELECT * FROM pg_catalog.float4send($1)`
	// run
	var r0 []byte
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float4smaller calls the stored function 'pg_catalog.float4smaller(real, real) real' on db.
func Float4smaller(ctx context.Context, db DB, p0, p1 float32) (float32, error) {
	// call pg_catalog.float4smaller
	const sqlstr = `SELECT * FROM pg_catalog.float4smaller($1, $2)`
	// run
	var r0 float32
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4um calls the stored function 'pg_catalog.float4um(real) real' on db.
func Float4um(ctx context.Context, db DB, p0 float32) (float32, error) {
	// call pg_catalog.float4um
	const sqlstr = `SELECT * FROM pg_catalog.float4um($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float4up calls the stored function 'pg_catalog.float4up(real) real' on db.
func Float4up(ctx context.Context, db DB, p0 float32) (float32, error) {
	// call pg_catalog.float4up
	const sqlstr = `SELECT * FROM pg_catalog.float4up($1)`
	// run
	var r0 float32
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8ByNumeric calls the stored function 'pg_catalog.float8(numeric) double precision' on db.
func Float8ByNumeric(ctx context.Context, db DB, p0 float64) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8BySmallint calls the stored function 'pg_catalog.float8(smallint) double precision' on db.
func Float8BySmallint(ctx context.Context, db DB, p0 int16) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8ByJsonb calls the stored function 'pg_catalog.float8(jsonb) double precision' on db.
func Float8ByJsonb(ctx context.Context, db DB, p0 []byte) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8ByReal calls the stored function 'pg_catalog.float8(real) double precision' on db.
func Float8ByReal(ctx context.Context, db DB, p0 float32) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8ByInteger calls the stored function 'pg_catalog.float8(integer) double precision' on db.
func Float8ByInteger(ctx context.Context, db DB, p0 int) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8ByBigint calls the stored function 'pg_catalog.float8(bigint) double precision' on db.
func Float8ByBigint(ctx context.Context, db DB, p0 int64) (float64, error) {
	// call pg_catalog.float8
	const sqlstr = `SELECT * FROM pg_catalog.float8($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float84div calls the stored function 'pg_catalog.float84div(double precision, real) double precision' on db.
func Float84div(ctx context.Context, db DB, p0 float64, p1 float32) (float64, error) {
	// call pg_catalog.float84div
	const sqlstr = `SELECT * FROM pg_catalog.float84div($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float84eq calls the stored function 'pg_catalog.float84eq(double precision, real) boolean' on db.
func Float84eq(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84eq
	const sqlstr = `SELECT * FROM pg_catalog.float84eq($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84ge calls the stored function 'pg_catalog.float84ge(double precision, real) boolean' on db.
func Float84ge(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84ge
	const sqlstr = `SELECT * FROM pg_catalog.float84ge($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84gt calls the stored function 'pg_catalog.float84gt(double precision, real) boolean' on db.
func Float84gt(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84gt
	const sqlstr = `SELECT * FROM pg_catalog.float84gt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84le calls the stored function 'pg_catalog.float84le(double precision, real) boolean' on db.
func Float84le(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84le
	const sqlstr = `SELECT * FROM pg_catalog.float84le($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84lt calls the stored function 'pg_catalog.float84lt(double precision, real) boolean' on db.
func Float84lt(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84lt
	const sqlstr = `SELECT * FROM pg_catalog.float84lt($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84mi calls the stored function 'pg_catalog.float84mi(double precision, real) double precision' on db.
func Float84mi(ctx context.Context, db DB, p0 float64, p1 float32) (float64, error) {
	// call pg_catalog.float84mi
	const sqlstr = `SELECT * FROM pg_catalog.float84mi($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float84mul calls the stored function 'pg_catalog.float84mul(double precision, real) double precision' on db.
func Float84mul(ctx context.Context, db DB, p0 float64, p1 float32) (float64, error) {
	// call pg_catalog.float84mul
	const sqlstr = `SELECT * FROM pg_catalog.float84mul($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float84ne calls the stored function 'pg_catalog.float84ne(double precision, real) boolean' on db.
func Float84ne(ctx context.Context, db DB, p0 float64, p1 float32) (bool, error) {
	// call pg_catalog.float84ne
	const sqlstr = `SELECT * FROM pg_catalog.float84ne($1, $2)`
	// run
	var r0 bool
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return false, logerror(err)
	}
	return r0, nil
}

// Float84pl calls the stored function 'pg_catalog.float84pl(double precision, real) double precision' on db.
func Float84pl(ctx context.Context, db DB, p0 float64, p1 float32) (float64, error) {
	// call pg_catalog.float84pl
	const sqlstr = `SELECT * FROM pg_catalog.float84pl($1, $2)`
	// run
	var r0 float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8Accum calls the stored function 'pg_catalog.float8_accum(double precision, double precision) double precision' on db.
func Float8Accum(ctx context.Context, db DB, p0 []float64, p1 float64) ([]float64, error) {
	// call pg_catalog.float8_accum
	const sqlstr = `SELECT * FROM pg_catalog.float8_accum($1, $2)`
	// run
	var r0 []float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float8Avg calls the stored function 'pg_catalog.float8_avg(double precision) double precision' on db.
func Float8Avg(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_avg
	const sqlstr = `SELECT * FROM pg_catalog.float8_avg($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8Combine calls the stored function 'pg_catalog.float8_combine(double precision, double precision) double precision' on db.
func Float8Combine(ctx context.Context, db DB, p0, p1 []float64) ([]float64, error) {
	// call pg_catalog.float8_combine
	const sqlstr = `SELECT * FROM pg_catalog.float8_combine($1, $2)`
	// run
	var r0 []float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float8Corr calls the stored function 'pg_catalog.float8_corr(double precision) double precision' on db.
func Float8Corr(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_corr
	const sqlstr = `SELECT * FROM pg_catalog.float8_corr($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8CovarPop calls the stored function 'pg_catalog.float8_covar_pop(double precision) double precision' on db.
func Float8CovarPop(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_covar_pop
	const sqlstr = `SELECT * FROM pg_catalog.float8_covar_pop($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8CovarSamp calls the stored function 'pg_catalog.float8_covar_samp(double precision) double precision' on db.
func Float8CovarSamp(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_covar_samp
	const sqlstr = `SELECT * FROM pg_catalog.float8_covar_samp($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrAccum calls the stored function 'pg_catalog.float8_regr_accum(double precision, double precision, double precision) double precision' on db.
func Float8RegrAccum(ctx context.Context, db DB, p0 []float64, p1, p2 float64) ([]float64, error) {
	// call pg_catalog.float8_regr_accum
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_accum($1, $2, $3)`
	// run
	var r0 []float64
	logf(sqlstr, p0, p1, p2)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1, p2).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float8RegrAvgx calls the stored function 'pg_catalog.float8_regr_avgx(double precision) double precision' on db.
func Float8RegrAvgx(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_avgx
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_avgx($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrAvgy calls the stored function 'pg_catalog.float8_regr_avgy(double precision) double precision' on db.
func Float8RegrAvgy(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_avgy
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_avgy($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrCombine calls the stored function 'pg_catalog.float8_regr_combine(double precision, double precision) double precision' on db.
func Float8RegrCombine(ctx context.Context, db DB, p0, p1 []float64) ([]float64, error) {
	// call pg_catalog.float8_regr_combine
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_combine($1, $2)`
	// run
	var r0 []float64
	logf(sqlstr, p0, p1)
	if err := db.QueryRowContext(ctx, sqlstr, p0, p1).Scan(&r0); err != nil {
		return nil, logerror(err)
	}
	return r0, nil
}

// Float8RegrIntercept calls the stored function 'pg_catalog.float8_regr_intercept(double precision) double precision' on db.
func Float8RegrIntercept(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_intercept
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_intercept($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrR2 calls the stored function 'pg_catalog.float8_regr_r2(double precision) double precision' on db.
func Float8RegrR2(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_r2
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_r2($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrSlope calls the stored function 'pg_catalog.float8_regr_slope(double precision) double precision' on db.
func Float8RegrSlope(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_slope
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_slope($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrSxx calls the stored function 'pg_catalog.float8_regr_sxx(double precision) double precision' on db.
func Float8RegrSxx(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_sxx
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_sxx($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrSxy calls the stored function 'pg_catalog.float8_regr_sxy(double precision) double precision' on db.
func Float8RegrSxy(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_sxy
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_sxy($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8RegrSyy calls the stored function 'pg_catalog.float8_regr_syy(double precision) double precision' on db.
func Float8RegrSyy(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_regr_syy
	const sqlstr = `SELECT * FROM pg_catalog.float8_regr_syy($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)
	}
	return r0, nil
}

// Float8StddevPop calls the stored function 'pg_catalog.float8_stddev_pop(double precision) double precision' on db.
func Float8StddevPop(ctx context.Context, db DB, p0 []float64) (float64, error) {
	// call pg_catalog.float8_stddev_pop
	const sqlstr = `SELECT * FROM pg_catalog.float8_stddev_pop($1)`
	// run
	var r0 float64
	logf(sqlstr, p0)
	if err := db.QueryRowContext(ctx, sqlstr, p0).Scan(&r0); err != nil {
		return 0.0, logerror(err)