pg

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
}

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

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
}

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

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
}

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

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
}

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
}

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 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 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 struct {
	OID  pgtype.OID   `json:"oid"`
	Name pgtype.Name  `json:"name"`
	Kind pgtype.QChar `json:"kind"`
}

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)
}

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

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

type TypeKind byte

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

type VoidType struct{}