shapegen

type Column struct {
	Name string
	Kind Kind
	Lits []string
	// Bool marks a BOOLEAN column, which is a fact about the DOMAIN rather
	// than about the operators Kind selects: a BOOL is KindOpaque for every
	// arm that needs arithmetic or a string function, and is the ONE column
	// shape that can stand alone as a predicate. genBarePredicate is the only
	// reader.
	Bool bool
}

type Edge struct {
	LTable, LCol string
	RTable, RCol string
}

type From struct {
	Table   string // base table, or the CTE name
	Derived string // rendered subquery, for an inline derived table
	Alias   string
	Join    string // "JOIN", "LEFT JOIN", ","
	On      string
	// PK is a column set unique within this entry's rows, as reachable from
	// Alias. Empty when the entry exposes no unique key, which is what makes
	// an ordering non-total.
	PK []string
}

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

type Item struct {
	Expr string
	// Alias is the output column name. Empty only for Star items.
	Alias string
	// Star renders instead of Expr when set ("*" or "t.*").
	Star string
	// Exact marks a value both engines must produce bit-identically: a bare
	// column reference, or an integer-valued expression. Float arithmetic and
	// aggregates are not exact, so an ordering on them may legitimately break
	// ties differently.
	Exact bool
	Agg   bool
	// Opaque marks a value whose RENDERED form does not order the way the
	// value does: an IPv4 renders "10.0.0.9" and "10.0.0.10", which compare
	// lexicographically in the opposite order to the addresses. The absolute
	// order check reads rendered cells, so it cannot judge an ORDER BY over
	// one of these — see Query.OrderKeys.
	Opaque bool
}

type Kind int

type Order struct {
	Expr string
	Desc bool
	// Key is the output column carrying this term's value, or "" when the
	// term orders by something the select list does not project.
	Key string
	// Exact marks a term both engines compute bit-identically (see Item).
	Exact bool
	// Opaque marks a term the absolute order check cannot judge (see Item).
	Opaque bool
}

type Query struct {
	With     string // rendered "WITH x AS (...)" prefix, or ""
	Distinct bool
	Items    []Item
	From     []From
	Where    []string
	GroupBy  []string
	Having   string
	Order    []Order
	Limit    int
	Offset   int
	// LimitZero renders `LIMIT 0`, the boundary Limit cannot carry: zero is
	// how every other field here spells "no LIMIT", so the generator could
	// not emit the one value with a rule of its own (#487). `LIMIT 0` returns
	// no rows whatever the ORDER BY, on every engine, so it is the shape that
	// separates "the limit bound" from "the limit was ignored" — and it is
	// also the shape a paginating client sends to fetch a result's SHAPE
	// without its rows.
	LimitZero bool
	// TotalOrder records that the generator appended a uniqueness tiebreaker,
	// so no two output rows tie on the full ORDER BY list.
	TotalOrder bool
	// Shape tags the generator arm that produced this query, for coverage
	// reporting.
	Shape string
	Seed  int64
	// contains filtered or unexported fields
}

type Schema struct {
	Tables []Table
	Edges  []Edge
}

type Table struct {
	Name string
	PK   []string
	Cols []Column
	// SelfJoin marks a table small enough that joining it to itself stays
	// bounded. genSelfJoin picks only from these; a schema with none gets the
	// single-table FROM instead.
	SelfJoin bool
}