pg

package
v0.0.0-...-1a642c0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 19, 2023 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	Bool             = BaseType{ID: pgtype.BoolOID, Name: "bool"}
	Bytea            = BaseType{ID: pgtype.ByteaOID, Name: "bytea"}
	QChar            = BaseType{ID: pgtype.QCharOID, Name: "char"}
	Name             = BaseType{ID: pgtype.NameOID, Name: "name"}
	Int8             = BaseType{ID: pgtype.Int8OID, Name: "int8"}
	Int2             = BaseType{ID: pgtype.Int2OID, Name: "int2"}
	Int4             = BaseType{ID: pgtype.Int4OID, Name: "int4"}
	Text             = BaseType{ID: pgtype.TextOID, Name: "text"}
	OID              = BaseType{ID: pgtype.OIDOID, Name: "oid"}
	TID              = BaseType{ID: pgtype.TIDOID, Name: "tid"}
	XID              = BaseType{ID: pgtype.XIDOID, Name: "xid"}
	CID              = BaseType{ID: pgtype.CIDOID, Name: "cid"}
	JSON             = BaseType{ID: pgtype.JSONOID, Name: "json"}
	PgNodeTree       = BaseType{ID: pgoid.PgNodeTree, Name: "pg_node_tree"}
	Point            = BaseType{ID: pgtype.PointOID, Name: "point"}
	Lseg             = BaseType{ID: pgtype.LsegOID, Name: "lseg"}
	Path             = BaseType{ID: pgtype.PathOID, Name: "path"}
	Box              = BaseType{ID: pgtype.BoxOID, Name: "box"}
	Polygon          = BaseType{ID: pgtype.PolygonOID, Name: "polygon"}
	Line             = BaseType{ID: pgtype.LineOID, Name: "line"}
	CIDR             = BaseType{ID: pgtype.CIDROID, Name: "cidr"}
	CIDRArray        = ArrayType{ID: pgtype.CIDRArrayOID, Name: "_cidr"}
	Float4           = BaseType{ID: pgtype.Float4OID, Name: "float4"}
	Float8           = BaseType{ID: pgtype.Float8OID, Name: "float8"}
	Unknown          = BaseType{ID: pgtype.UnknownOID, Name: "unknown"}
	Circle           = BaseType{ID: pgtype.CircleOID, Name: "circle"}
	Macaddr          = BaseType{ID: pgtype.MacaddrOID, Name: "macaddr"}
	Inet             = BaseType{ID: pgtype.InetOID, Name: "inet"}
	BoolArray        = ArrayType{ID: pgtype.BoolArrayOID, Name: "_bool"}
	ByteaArray       = ArrayType{ID: pgtype.ByteaArrayOID, Name: "_bytea"}
	Int2Array        = ArrayType{ID: pgtype.Int2ArrayOID, Name: "_int2"}
	Int4Array        = ArrayType{ID: pgtype.Int4ArrayOID, Name: "_int4"}
	TextArray        = ArrayType{ID: pgtype.TextArrayOID, Name: "_text"}
	BPCharArray      = ArrayType{ID: pgtype.BPCharArrayOID, Name: "_bpchar"}
	VarcharArray     = ArrayType{ID: pgtype.VarcharArrayOID, Name: "_varchar"}
	Int8Array        = ArrayType{ID: pgtype.Int8ArrayOID, Name: "_int8"}
	Float4Array      = ArrayType{ID: pgtype.Float4ArrayOID, Name: "_float4"}
	Float8Array      = ArrayType{ID: pgtype.Float8ArrayOID, Name: "_float8"}
	OIDArray         = ArrayType{ID: pgoid.OIDArray, Name: "_oid"}
	ACLItem          = BaseType{ID: pgtype.ACLItemOID, Name: "aclitem"}
	ACLItemArray     = ArrayType{ID: pgtype.ACLItemArrayOID, Name: "_aclitem"}
	InetArray        = ArrayType{ID: pgtype.InetArrayOID, Name: "_inet"}
	MacaddrArray     = ArrayType{ID: pgoid.MacaddrArray, Name: "_macaddr"}
	BPChar           = BaseType{ID: pgtype.BPCharOID, Name: "bpchar"}
	Varchar          = BaseType{ID: pgtype.VarcharOID, Name: "varchar"}
	Date             = BaseType{ID: pgtype.DateOID, Name: "date"}
	Time             = BaseType{ID: pgtype.TimeOID, Name: "time"}
	Timestamp        = BaseType{ID: pgtype.TimestampOID, Name: "timestamp"}
	TimestampArray   = ArrayType{ID: pgtype.TimestampArrayOID, Name: "_timestamp"}
	DateArray        = ArrayType{ID: pgtype.DateArrayOID, Name: "_date"}
	Timestamptz      = BaseType{ID: pgtype.TimestamptzOID, Name: "timestamptz"}
	TimestamptzArray = ArrayType{ID: pgtype.TimestamptzArrayOID, Name: "_timestamptz"}
	Interval         = BaseType{ID: pgtype.IntervalOID, Name: "interval"}
	NumericArray     = ArrayType{ID: pgtype.NumericArrayOID, Name: "_numeric"}
	Bit              = BaseType{ID: pgtype.BitOID, Name: "bit"}
	Varbit           = BaseType{ID: pgtype.VarbitOID, Name: "varbit"}
	Numeric          = BaseType{ID: pgtype.NumericOID, Name: "numeric"}
	Record           = BaseType{ID: pgtype.RecordOID, Name: "record"}
	Void             = VoidType{}
	UUID             = BaseType{ID: pgtype.UUIDOID, Name: "uuid"}
	UUIDArray        = ArrayType{ID: pgtype.UUIDArrayOID, Name: "_uuid"}
	JSONB            = BaseType{ID: pgtype.JSONBOID, Name: "jsonb"}
	JSONBArray       = ArrayType{ID: pgtype.JSONBArrayOID, Name: "_jsonb"}
	Int4range        = BaseType{ID: pgtype.Int4rangeOID, Name: "int4range"}
	Numrange         = BaseType{ID: pgtype.NumrangeOID, Name: "numrange"}
	Tsrange          = BaseType{ID: pgtype.TsrangeOID, Name: "tsrange"}
	Tstzrange        = BaseType{ID: pgtype.TstzrangeOID, Name: "tstzrange"}
	Daterange        = BaseType{ID: pgtype.DaterangeOID, Name: "daterange"}
	Int8range        = BaseType{ID: pgtype.Int8rangeOID, Name: "int8range"}
)

If you add to this list, also add to defaultKnownTypes below.

Functions

func PrepareAllQueries 

func PrepareAllQueries(ctx context.Context, p preparer) error

PrepareAllQueries executes a PREPARE statement for all sqlgen generated SQL queries in querier files. Typical usage is as the AfterConnect callback for pgxpool.Config

pgx will use the prepared statement if available. Calling PrepareAllQueries is an optional optimization to avoid a network round-trip the first time pgx runs a query if pgx statement caching is enabled.

Types

type ArrayType 

type ArrayType struct {
	ID pgtype.OID // pg_type.oid: row identifier
	// The name of the type, like _int4. Array types in Postgres typically
	// begin with an underscore. From pg_type.typname.
	Name string
	// pg_type.typelem: the element type of the array
	Elem Type
}

ArrayType is an array type where pg_type.typelem != 0 and the name begins with an underscore.

func (ArrayType) Kind 

func (b ArrayType) Kind() TypeKind

func (ArrayType) OID 

func (b ArrayType) OID() pgtype.OID

func (ArrayType) String 

func (b ArrayType) String() string

type BaseType 

type BaseType struct {
	ID   pgtype.OID // pg_type.oid: row identifier
	Name string     // pg_type.typname: data type name
}

BaseType is a fundamental Postgres type like text and bool. https://www.postgresql.org/docs/13/catalog-pg-type.html

func (BaseType) Kind 

func (b BaseType) Kind() TypeKind

func (BaseType) OID 

func (b BaseType) OID() pgtype.OID

func (BaseType) String 

func (b BaseType) String() string

type Column 

type Column struct {
	Name      string     // pg_attribute.attname: column name
	TableOID  pgtype.OID // pg_attribute:attrelid: table the column belongs to
	TableName string     // pg_class.relname: name of table that owns the column
	Number    uint16     // pg_attribute.attnum: the number of column starting from 1
	Type      Type       // pg_attribute.atttypid: data type of the column
	Null      bool       // pg_attribute.attnotnull: represents a not-null constraint
}

Column stores information about a column in a TableOID. https://www.postgresql.org/docs/13/catalog-pg-attribute.html

func FetchColumns 

func FetchColumns(conn *pgx.Conn, keys []ColumnKey) ([]Column, error)

FetchColumns fetches meta information about a Postgres column from the pg_class and pg_attribute catalog tables.

type ColumnKey 

type ColumnKey struct {
	TableOID pgtype.OID
	Number   uint16 // the number of column starting from 1
}

ColumnKey is a composite key of a table OID and the number of the column within the table.

type CompositeType 

type CompositeType struct {
	ID          pgtype.OID // pg_class.oid: row identifier
	Name        string     // pg_class.relname: name of the composite type
	ColumnNames []string   // pg_attribute.attname: names of the column, in order
	ColumnTypes []Type     // pg_attribute JOIN pg_type: information about columns of the composite type
}

CompositeType is a type containing multiple columns and is represented as a class. https://www.postgresql.org/docs/13/catalog-pg-class.html

func (CompositeType) Kind 

func (e CompositeType) Kind() TypeKind

func (CompositeType) OID 

func (e CompositeType) OID() pgtype.OID

func (CompositeType) String 

func (e CompositeType) String() string

type DBQuerier 

type DBQuerier struct {
	// contains filtered or unexported fields
}

func NewQuerier 

func NewQuerier(conn genericConn) *DBQuerier

NewQuerier creates a DBQuerier that implements Querier. conn is typically *pgx.Conn, pgx.Tx, or *pgxpool.Pool.

func NewQuerierConfig 

func NewQuerierConfig(conn genericConn, cfg QuerierConfig) *DBQuerier

NewQuerierConfig creates a DBQuerier that implements Querier with the given config. conn is typically *pgx.Conn, pgx.Tx, or *pgxpool.Pool.

func (*DBQuerier) FindArrayTypes 

func (q *DBQuerier) FindArrayTypes(ctx context.Context, oids []uint32) ([]FindArrayTypesRow, error)

FindArrayTypes implements Querier.FindArrayTypes.

func (*DBQuerier) FindArrayTypesBatch 

func (q *DBQuerier) FindArrayTypesBatch(batch genericBatch, oids []uint32)

FindArrayTypesBatch implements Querier.FindArrayTypesBatch.

func (*DBQuerier) FindArrayTypesScan 

func (q *DBQuerier) FindArrayTypesScan(results pgx.BatchResults) ([]FindArrayTypesRow, error)

FindArrayTypesScan implements Querier.FindArrayTypesScan.

func (*DBQuerier) FindCompositeTypes 

func (q *DBQuerier) FindCompositeTypes(ctx context.Context, oids []uint32) ([]FindCompositeTypesRow, error)

FindCompositeTypes implements Querier.FindCompositeTypes.

func (*DBQuerier) FindCompositeTypesBatch 

func (q *DBQuerier) FindCompositeTypesBatch(batch genericBatch, oids []uint32)

FindCompositeTypesBatch implements Querier.FindCompositeTypesBatch.

func (*DBQuerier) FindCompositeTypesScan 

func (q *DBQuerier) FindCompositeTypesScan(results pgx.BatchResults) ([]FindCompositeTypesRow, error)

FindCompositeTypesScan implements Querier.FindCompositeTypesScan.

func (*DBQuerier) FindDescendantOIDs 

func (q *DBQuerier) FindDescendantOIDs(ctx context.Context, oids []uint32) ([]pgtype.OID, error)

FindDescendantOIDs implements Querier.FindDescendantOIDs.

func (*DBQuerier) FindDescendantOIDsBatch 

func (q *DBQuerier) FindDescendantOIDsBatch(batch genericBatch, oids []uint32)

FindDescendantOIDsBatch implements Querier.FindDescendantOIDsBatch.

func (*DBQuerier) FindDescendantOIDsScan 

func (q *DBQuerier) FindDescendantOIDsScan(results pgx.BatchResults) ([]pgtype.OID, error)

FindDescendantOIDsScan implements Querier.FindDescendantOIDsScan.

func (*DBQuerier) FindEnumTypes 

func (q *DBQuerier) FindEnumTypes(ctx context.Context, oids []uint32) ([]FindEnumTypesRow, error)

FindEnumTypes implements Querier.FindEnumTypes.

func (*DBQuerier) FindEnumTypesBatch 

func (q *DBQuerier) FindEnumTypesBatch(batch genericBatch, oids []uint32)

FindEnumTypesBatch implements Querier.FindEnumTypesBatch.

func (*DBQuerier) FindEnumTypesScan 

func (q *DBQuerier) FindEnumTypesScan(results pgx.BatchResults) ([]FindEnumTypesRow, error)

FindEnumTypesScan implements Querier.FindEnumTypesScan.

func (*DBQuerier) FindOIDByName 

func (q *DBQuerier) FindOIDByName(ctx context.Context, name string) (pgtype.OID, error)

FindOIDByName implements Querier.FindOIDByName.

func (*DBQuerier) FindOIDByNameBatch 

func (q *DBQuerier) FindOIDByNameBatch(batch genericBatch, name string)

FindOIDByNameBatch implements Querier.FindOIDByNameBatch.

func (*DBQuerier) FindOIDByNameScan 

func (q *DBQuerier) FindOIDByNameScan(results pgx.BatchResults) (pgtype.OID, error)

FindOIDByNameScan implements Querier.FindOIDByNameScan.

func (*DBQuerier) FindOIDName 

func (q *DBQuerier) FindOIDName(ctx context.Context, oid pgtype.OID) (pgtype.Name, error)

FindOIDName implements Querier.FindOIDName.

func (*DBQuerier) FindOIDNameBatch 

func (q *DBQuerier) FindOIDNameBatch(batch genericBatch, oid pgtype.OID)

FindOIDNameBatch implements Querier.FindOIDNameBatch.

func (*DBQuerier) FindOIDNameScan 

func (q *DBQuerier) FindOIDNameScan(results pgx.BatchResults) (pgtype.Name, error)

FindOIDNameScan implements Querier.FindOIDNameScan.

func (*DBQuerier) FindOIDNames 

func (q *DBQuerier) FindOIDNames(ctx context.Context, oid []uint32) ([]FindOIDNamesRow, error)

FindOIDNames implements Querier.FindOIDNames.

func (*DBQuerier) FindOIDNamesBatch 

func (q *DBQuerier) FindOIDNamesBatch(batch genericBatch, oid []uint32)

FindOIDNamesBatch implements Querier.FindOIDNamesBatch.

func (*DBQuerier) FindOIDNamesScan 

func (q *DBQuerier) FindOIDNamesScan(results pgx.BatchResults) ([]FindOIDNamesRow, error)

FindOIDNamesScan implements Querier.FindOIDNamesScan.

func (*DBQuerier) WithTx 

func (q *DBQuerier) WithTx(tx pgx.Tx) (*DBQuerier, error)

WithTx creates a new DBQuerier that uses the transaction to run all queries.

type DomainType 

type DomainType struct {
	ID         pgtype.OID // pg_type.oid: row identifier
	Name       string     // pg_type.typname: data type name
	IsNotNull  bool       // pg_type.typnotnull: domains only, not null constraint for domains
	HasDefault bool       // pg_type.typdefault: domains only, if there's a default value
	BaseType   BaseType   // pg_type.typbasetype: domains only, the base type
	Dimensions int        // pg_type.typndims: domains on array type only, 0 otherwise, number of array dimensions
}

DomainType is a user-create domain type.

func (DomainType) Kind 

func (e DomainType) Kind() TypeKind

func (DomainType) OID 

func (e DomainType) OID() pgtype.OID

func (DomainType) String 

func (e DomainType) String() string

type EnumType 

type EnumType struct {
	ID pgtype.OID // pg_type.oid: row identifier
	// The name of the enum, like 'device_type' in:
	//     CREATE TYPE device_type AS ENUM ('foo');
	// From pg_type.typname.
	Name string
	// All textual labels for this enum in sort order.
	Labels []string
	// When an enum type is created, its members are assigned sort-order
	// positions 1...n. But members added later might be given negative or
	// fractional values of enumsortorder. The only requirement on these
	// values is that they be correctly ordered and unique within each enum
	// type.
	Orders    []float32
	ChildOIDs []pgtype.OID
}

func (EnumType) Kind 

func (e EnumType) Kind() TypeKind

func (EnumType) OID 

func (e EnumType) OID() pgtype.OID

func (EnumType) String 

func (e EnumType) String() string

type FindArrayTypesRow 

type FindArrayTypesRow struct {
	OID      pgtype.OID   `json:"oid"`
	TypeName string       `json:"type_name"`
	ElemOID  pgtype.OID   `json:"elem_oid"`
	TypeKind pgtype.QChar `json:"type_kind"`
}

type FindCompositeTypesRow 

type FindCompositeTypesRow struct {
	TableTypeName string           `json:"table_type_name"`
	TableTypeOID  pgtype.OID       `json:"table_type_oid"`
	TableName     pgtype.Name      `json:"table_name"`
	ColNames      []string         `json:"col_names"`
	ColOIDs       []int            `json:"col_oids"`
	ColOrders     []int            `json:"col_orders"`
	ColNotNulls   pgtype.BoolArray `json:"col_not_nulls"`
	ColTypeNames  []string         `json:"col_type_names"`
}

type FindEnumTypesRow 

type FindEnumTypesRow struct {
	OID         pgtype.OID   `json:"oid"`
	TypeName    string       `json:"type_name"`
	ChildOIDs   []int        `json:"child_oids"`
	Orders      []float32    `json:"orders"`
	Labels      []string     `json:"labels"`
	TypeKind    pgtype.QChar `json:"type_kind"`
	DefaultExpr string       `json:"default_expr"`
}

type FindOIDNamesRow 

type FindOIDNamesRow struct {
	OID  pgtype.OID   `json:"oid"`
	Name pgtype.Name  `json:"name"`
	Kind pgtype.QChar `json:"kind"`
}

type Querier 

type Querier interface {
	FindEnumTypes(ctx context.Context, oids []uint32) ([]FindEnumTypesRow, error)
	// FindEnumTypesBatch enqueues a FindEnumTypes query into batch to be executed
	// later by the batch.
	FindEnumTypesBatch(batch genericBatch, oids []uint32)
	// FindEnumTypesScan scans the result of an executed FindEnumTypesBatch query.
	FindEnumTypesScan(results pgx.BatchResults) ([]FindEnumTypesRow, error)

	FindArrayTypes(ctx context.Context, oids []uint32) ([]FindArrayTypesRow, error)
	// FindArrayTypesBatch enqueues a FindArrayTypes query into batch to be executed
	// later by the batch.
	FindArrayTypesBatch(batch genericBatch, oids []uint32)
	// FindArrayTypesScan scans the result of an executed FindArrayTypesBatch query.
	FindArrayTypesScan(results pgx.BatchResults) ([]FindArrayTypesRow, error)

	// A composite type represents a row or record, defined implicitly for each
	// table, or explicitly with CREATE TYPE.
	// https://www.postgresql.org/docs/13/rowtypes.html
	FindCompositeTypes(ctx context.Context, oids []uint32) ([]FindCompositeTypesRow, error)
	// FindCompositeTypesBatch enqueues a FindCompositeTypes query into batch to be executed
	// later by the batch.
	FindCompositeTypesBatch(batch genericBatch, oids []uint32)
	// FindCompositeTypesScan scans the result of an executed FindCompositeTypesBatch query.
	FindCompositeTypesScan(results pgx.BatchResults) ([]FindCompositeTypesRow, error)

	// Recursively expands all given OIDs to all descendants through composite
	// types.
	FindDescendantOIDs(ctx context.Context, oids []uint32) ([]pgtype.OID, error)
	// FindDescendantOIDsBatch enqueues a FindDescendantOIDs query into batch to be executed
	// later by the batch.
	FindDescendantOIDsBatch(batch genericBatch, oids []uint32)
	// FindDescendantOIDsScan scans the result of an executed FindDescendantOIDsBatch query.
	FindDescendantOIDsScan(results pgx.BatchResults) ([]pgtype.OID, error)

	FindOIDByName(ctx context.Context, name string) (pgtype.OID, error)
	// FindOIDByNameBatch enqueues a FindOIDByName query into batch to be executed
	// later by the batch.
	FindOIDByNameBatch(batch genericBatch, name string)
	// FindOIDByNameScan scans the result of an executed FindOIDByNameBatch query.
	FindOIDByNameScan(results pgx.BatchResults) (pgtype.OID, error)

	FindOIDName(ctx context.Context, oid pgtype.OID) (pgtype.Name, error)
	// FindOIDNameBatch enqueues a FindOIDName query into batch to be executed
	// later by the batch.
	FindOIDNameBatch(batch genericBatch, oid pgtype.OID)
	// FindOIDNameScan scans the result of an executed FindOIDNameBatch query.
	FindOIDNameScan(results pgx.BatchResults) (pgtype.Name, error)

	FindOIDNames(ctx context.Context, oid []uint32) ([]FindOIDNamesRow, error)
	// FindOIDNamesBatch enqueues a FindOIDNames query into batch to be executed
	// later by the batch.
	FindOIDNamesBatch(batch genericBatch, oid []uint32)
	// FindOIDNamesScan scans the result of an executed FindOIDNamesBatch query.
	FindOIDNamesScan(results pgx.BatchResults) ([]FindOIDNamesRow, error)
}

Querier is a typesafe Go interface backed by SQL queries.

Methods ending with Batch enqueue a query to run later in a pgx.Batch. After calling SendBatch on pgx.Conn, pgxpool.Pool, or pgx.Tx, use the Scan methods to parse the results.

type QuerierConfig 

type QuerierConfig struct {
	// DataTypes contains pgtype.Value to use for encoding and decoding instead
	// of sqlgen-generated pgtype.ValueTranscoder.
	//
	// If OIDs are available for an input parameter type and all of its
	// transitive dependencies, sqlgen will use the binary encoding format for
	// the input parameter.
	DataTypes []pgtype.DataType
}

type Type 

type Type interface {
	OID() pgtype.OID // pg_type.oid: row identifier
	String() string  // pg_type.typname: data type name
	Kind() TypeKind
}

Type is a Postgres type.

type TypeFetcher 

type TypeFetcher struct {
	// contains filtered or unexported fields
}

TypeFetcher fetches Postgres types by the OID.

func NewTypeFetcher 

func NewTypeFetcher(conn *pgx.Conn) *TypeFetcher

func (*TypeFetcher) FindTypesByOIDs 

func (tf *TypeFetcher) FindTypesByOIDs(oids ...uint32) (map[pgtype.OID]Type, error)

FindTypesByOIDs returns a map of a type OID to the Type description. The returned map contains every unique OID in oids (oids may contain duplicates) unless there's an error.

type TypeKind 

type TypeKind byte

TypeKind is the pg_type.typtype column, describing the meta type of Type. 

const (
	KindBaseType      TypeKind = 'b' // includes array types
	KindCompositeType TypeKind = 'c'
	KindDomainType    TypeKind = 'd'
	KindEnumType      TypeKind = 'e'
	KindPseudoType    TypeKind = 'p'
	KindRangeType     TypeKind = 'r'
)

func (TypeKind) String 

func (k TypeKind) String() string

type UnknownType 

type UnknownType struct {
	ID     pgtype.OID // pg_type.oid: row identifier
	Name   string     // pg_type.typname: data type name
	PgKind TypeKind
}

UnknownType is a Postgres type that's not a well-known type in defaultKnownTypes, and not an enum, domain, or composite type. The code generator might be able to resolve this type from a user-provided mapping like --go-type my_int=int.

func (UnknownType) Kind 

func (e UnknownType) Kind() TypeKind

func (UnknownType) OID 

func (e UnknownType) OID() pgtype.OID

func (UnknownType) String 

func (e UnknownType) String() string

type VoidType 

type VoidType struct{}

VoidType is an empty type. A void type doesn't appear in output, but it's necessary to scan rows.

func (VoidType) Kind 

func (b VoidType) Kind() TypeKind

func (VoidType) OID 

func (b VoidType) OID() pgtype.OID

func (VoidType) String 

func (b VoidType) String() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.