dbbrowse

type Column struct {
	Name string `json:"name"`
	// Type is the column's type as Postgres prints it (format_type):
	// "uuid", "timestamp with time zone", "character varying(40)", "text[]",
	// an enum's name. It is for display; the compiler never writes it into
	// SQL.
	Type     string `json:"type"`
	Nullable bool   `json:"nullable"`
	Comment  string `json:"comment,omitempty"`
	// Ordinal is the column's attribute number (pg_attribute.attnum): 1-based,
	// with gaps where columns were dropped.
	Ordinal int `json:"ordinal"`
	// Sortable reports whether the type has a default btree operator class,
	// so it can be ordered and compared with <, <=, >, >=. Enums, ranges,
	// records and arrays of sortable types are; json, xml, point and the other
	// geometric types are not.
	Sortable bool `json:"sortable"`
}

type Compiled struct {
	// Table is the described table the request reads.
	Table *Table
	// Columns are the selected columns, in result order.
	Columns []Column
	Limit   int
	Offset  int
	Count   CountMode
	// contains filtered or unexported fields
}

type CountMode string

type Database struct {
	// Tables are sorted by schema, then name.
	Tables []Table `json:"tables"`
}

type Filter struct {
	Column string   `json:"column"`
	Op     Op       `json:"op"`
	Values []string `json:"values,omitempty"`
}

type ForeignKey struct {
	Name string `json:"name"`
	// Schema, Table and Columns are the referencing side.
	Schema  string   `json:"schema"`
	Table   string   `json:"table"`
	Columns []string `json:"columns"`
	// RefSchema, RefTable and RefColumns are the referenced side.
	RefSchema  string   `json:"ref_schema"`
	RefTable   string   `json:"ref_table"`
	RefColumns []string `json:"ref_columns"`
	// OnDelete is the referential action: "NO ACTION", "RESTRICT",
	// "CASCADE", "SET NULL" or "SET DEFAULT".
	OnDelete string `json:"on_delete"`
}

type Op string

type Page struct {
	// Columns and Rows are dbquery's: each row has one cell per column, a
	// nil, bool, json.Number, string or json.RawMessage (see
	// [dbquery.Result]).
	Columns []dbquery.Column `json:"columns"`
	Rows    [][]any          `json:"rows"`
	// HasMore reports whether rows follow this page: the extra row the page
	// statement fetched came back, or the byte cap cut the page short.
	HasMore bool `json:"has_more"`
	// Total is the table's size under the request's filters, -1 with
	// CountNone or when the estimate is unknown. TotalIsEstimate marks a
	// planner estimate (CountEstimated); TotalAtLeast marks an exact count
	// that stopped at ExactCountCap, so the size is at least Total.
	Total           int64 `json:"total"`
	TotalIsEstimate bool  `json:"total_is_estimate,omitempty"`
	TotalAtLeast    bool  `json:"total_at_least,omitempty"`
	// Truncated is true when dbquery's byte cap, not the page size, ended the
	// page; CellsTruncated counts the page's cells cut to
	// dbquery.MaxCellBytes, and TruncatedCells says which: nil when none was,
	// otherwise one entry per row, aligned with Rows, listing the 0-based
	// column indexes of that row's cut cells (see
	// [dbquery.Result.TruncatedCells]).
	Truncated      bool    `json:"truncated,omitempty"`
	CellsTruncated int     `json:"cells_truncated,omitempty"`
	TruncatedCells [][]int `json:"truncated_cells,omitempty"`
	DurationMS     int64   `json:"duration_ms"`
}

type Query struct {
	SQL  string
	Args []any
}

type Request struct {
	// Table is schema-qualified, as [Table.QualifiedName] prints it.
	Table string `json:"table"`
	// Columns to return, in order; empty means every readable column.
	Columns []string `json:"columns,omitempty"`
	Filters []Filter `json:"filters,omitempty"`
	// Sort keys, most significant first. The primary key follows them as a
	// tiebreaker (for a table without one, every sortable column does), so a
	// page boundary is stable; with no Sort, the primary key ascending is
	// the order.
	Sort []Sort `json:"sort,omitempty"`
	// Limit is the page size: 0 means DefaultLimit, above MaxLimit is
	// refused. Offset is how many rows to skip.
	Limit  int `json:"limit,omitempty"`
	Offset int `json:"offset,omitempty"`
	// Count is CountNone when empty.
	Count CountMode `json:"count,omitempty"`
}

type Sort struct {
	Column string `json:"column"`
	Desc   bool   `json:"desc,omitempty"`
}

type Table struct {
	Schema  string    `json:"schema"`
	Name    string    `json:"name"`
	Kind    TableKind `json:"kind"`
	Comment string    `json:"comment,omitempty"`
	// Columns are the readable columns, in ordinal order. A column the role
	// may not SELECT (a forge:secret column) is absent.
	Columns []Column `json:"columns"`
	// PrimaryKey names the key's columns in key order, nil when the table has
	// none (always, for a view) or when the role may not read all of them.
	PrimaryKey []string `json:"primary_key,omitempty"`
	// ForeignKeys are this table's references to other tables; ReferencedBy
	// are the references other tables make to this one (a row page's
	// "Related" section). Each is listed only when the role can follow it:
	// both tables are in the description and every column on both sides is
	// readable.
	ForeignKeys  []ForeignKey `json:"foreign_keys,omitempty"`
	ReferencedBy []ForeignKey `json:"referenced_by,omitempty"`
	// EstimatedRows is the planner's row estimate (pg_class.reltuples), -1
	// when the server has none: a table never vacuumed or analyzed, a view,
	// a partitioned parent.
	EstimatedRows int64 `json:"estimated_rows"`
	// contains filtered or unexported fields
}

type TableKind string