pg

type ArrayType struct {
	ID uint32 // 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   uint32 // pg_type.oid: row identifier
	Name string // pg_type.typname: data type name
}

type Column struct {
	Name      string // pg_attribute.attname: column name
	TableOID  uint32 // 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 uint32
	Number   uint16 // the number of column starting from 1
}

type CompositeType struct {
	ID          uint32   // 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 DebugCodec struct {
}

type DomainType struct {
	ID         uint32   // 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 uint32 // 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 []uint32
}

type FindArrayTypesRow struct {
	OID      uint32 `json:"oid"`
	TypeName string `json:"type_name"`
	ElemOID  uint32 `json:"elem_oid"`
	TypeKind byte   `json:"type_kind"`
}

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

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

type FindOIDNamesRow struct {
	OID  uint32 `json:"oid"`
	Name string `json:"name"`
	Kind byte   `json:"kind"`
}

type Querier interface {
	FindEnumTypes(ctx context.Context, oids []uint32) ([]FindEnumTypesRow, error)

	FindArrayTypes(ctx context.Context, oids []uint32) ([]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)

	// Recursively expands all given OIDs to all descendants through composite
	// types.
	FindDescendantOIDs(ctx context.Context, oids []uint32) ([]uint32, error)

	FindOIDByName(ctx context.Context, name string) (uint32, error)

	FindOIDName(ctx context.Context, oid uint32) (string, error)

	FindOIDNames(ctx context.Context, oid []uint32) ([]FindOIDNamesRow, error)
}

type Type interface {
	OID() uint32    // 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     uint32 // pg_type.oid: row identifier
	Name   string // pg_type.typname: data type name
	PgKind TypeKind
}

type VoidType struct{}