query

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

type Cond struct {
	// Table qualifies the column. It is empty at the top level, where only one
	// table is in scope, and set inside a subquery, where two are: an
	// unqualified name there resolves to whichever scope happens to have it,
	// which is a silent correlation to the wrong row rather than an error.
	Table  string
	Column string
	Op     Op
	// Value is the operand. It is nil for the null checks, and a slice for the
	// set-membership ones.
	Value any

	// Exists is a condition on a related table. When it is set, the column and
	// the operator are not used.
	Exists *Exists
}

type Exists struct {
	// From is the table and alias, or a join chain for a many-to-many. It is
	// generated, never built from anything a client sent.
	From string
	// On correlates the subquery to the outer row, and is generated the same way.
	On string
	// Where is the caller's condition on the related table, its columns
	// qualified with the alias From declares.
	Where Group
	// Not inverts it: no such row rather than at least one.
	//
	// Which is not the same as negating a condition inside Where, and the
	// difference is the one callers get wrong. A negated comparison still needs
	// the row to be there — "there is a related row whose name differs" — so a
	// row with no related row fails it. This asks whether a matching row exists
	// at all, so a row with none satisfies it.
	Not bool
}

type Group struct {
	// Or joins this group's members with OR instead of AND. It applies to the
	// group, not to a member, which is why mixing the two needs a nested group
	// rather than a flag per condition.
	Or     bool
	Conds  []Cond
	Groups []Group
}

type Join struct {
	// Table is the table and its alias, and On correlates it to the outer row.
	// Both are generated from the schema, never built from anything a client
	// sent.
	Table string
	On    string

	// Where is what the far side is scoped by: the tenant, and whatever
	// lifecycle predicates it has.
	//
	// It renders into the ON clause rather than the statement's WHERE, and that
	// is not a stylistic choice. A predicate on the joined table in WHERE is
	// false for a row that matched nothing, so it would discard exactly the rows
	// the left join was chosen to keep — an inner join with extra steps.
	Where Group
}

type Op string

type Order struct {
	// Table qualifies the column, and has to whenever the statement joins: two
	// tables with a created_at make an unqualified one ambiguous, and Postgres
	// is right to refuse it.
	Table  string
	Column string
	Desc   bool
}

type Page struct {
	Limit  int
	Offset int
}