sqldsl

type Add ¶

type Add struct {
	Left  Expr
	Right Expr
}

Add represents addition (+).

func (a Add) SQL() string

type Alias ¶

type Alias struct {
	Expr Expr
	Name string
}

Alias wraps an expression with an alias (expr AS alias).

func SelectAs(expr Expr, alias string) Alias

func (a Alias) SQL() string

type AndExpr ¶

type AndExpr struct {
	Exprs []Expr
}

AndExpr represents a logical AND of multiple expressions.

func And(exprs ...Expr) AndExpr

func (a AndExpr) SQL() string

type ArrayAppend ¶

type ArrayAppend struct {
	Array  Expr   // The base array expression
	Values []Expr // Values to append (rendered as ARRAY[...])
}

ArrayAppend represents array concatenation: arr || ARRAY[values]. Used for building the visited array in recursive check functions.

Example:

ArrayAppend{
    Array:  Param("p_visited"),
    Values: []Expr{Concat{Parts: []Expr{Lit("doc:"), ObjectID, Lit(":viewer")}}},
}

Renders: p_visited || ARRAY['doc:' || p_object_id || ':viewer']

func VisitedWithKey(objectType, relation string, objectID Expr) ArrayAppend

VisitedWithKey("document", "viewer", ObjectID)

func (a ArrayAppend) SQL() string

type ArrayContains ¶

type ArrayContains struct {
	Value Expr
	Array Expr
}

ArrayContains represents the ANY() check: value = ANY(array).

func (a ArrayContains) SQL() string

type ArrayLength ¶

type ArrayLength struct {
	Array     Expr
	Dimension int // Usually 1
}

ArrayLength represents array_length(arr, dim).

func (a ArrayLength) SQL() string

type ArrayLiteral ¶

type ArrayLiteral struct {
	Values []Expr
}

ArrayLiteral represents a SQL array literal: ARRAY[values].

func (a ArrayLiteral) SQL() string

type Bool ¶

type Bool bool

Bool represents a boolean literal.

func (b Bool) SQL() string

type CTEDef ¶

type CTEDef struct {
	Name    string   // CTE name (e.g., "accessible", "base_results")
	Columns []string // Optional column names (e.g., ["object_id", "depth"])
	Query   SQLer    // The CTE query body
}

CTEDef represents a single Common Table Expression definition. Used within WithCTE to define named subqueries.

func (c CTEDef) SQL() string

type CaseExpr ¶

type CaseExpr struct {
	Whens []CaseWhen
	Else  Expr // optional default value
}

CaseExpr represents a CASE expression with multiple WHEN clauses.

func (c CaseExpr) SQL() string

type CaseWhen ¶

type CaseWhen struct {
	Cond   Expr
	Result Expr
}

CaseWhen represents a single WHEN clause in a CASE expression.

type Col ¶

type Col struct {
	Table  string
	Column string
}

Col represents a table column reference (e.g., t.object_id).

func (c Col) SQL() string

type CommentedSQL ¶

type CommentedSQL struct {
	Comment string // Comment text (without -- prefix)
	Query   SQLer  // The query to render after the comment
}

CommentedSQL wraps a query with a SQL comment prefix. Useful for adding descriptive comments to parts of a UNION or CTE body.

Example:

CommentedSQL{Comment: "Base case: seed with starting value", Query: baseQuery}

Renders:

-- Base case: seed with starting value
<base query>

func MultiLineComment(comments []string, query SQLer) CommentedSQL

func (c CommentedSQL) SQL() string

type Concat ¶

type Concat struct {
	Parts []Expr
}

Concat represents SQL string concatenation (||).

func (c Concat) SQL() string

type EmptyArray ¶

type EmptyArray struct{}

EmptyArray represents an empty text array (ARRAY[]::TEXT[]).

func (EmptyArray) SQL() string

type Eq ¶

type Eq struct {
	Left  Expr
	Right Expr
}

Eq represents an equality comparison (=).

func (e Eq) SQL() string

type Exists ¶

type Exists struct {
	Query interface{ SQL() string }
}

Exists represents an EXISTS subquery.

func ExistsExpr(stmt SelectStmt) Exists

func (e Exists) SQL() string

type Expr ¶

type Expr interface {
	SQL() string
}

Expr is the interface that all SQL expression types implement.

func NormalizedUsersetSubject(subjectID, relation Expr) Expr

func SubjectIDMatch(column, subjectID Expr, allowWildcard bool) Expr

func VisitedKey(objectType, relation string, objectID Expr) Expr

VisitedKey("document", "viewer", ObjectID)

type Func ¶

type Func struct {
	Name string
	Args []Expr
}

Func represents a SQL function call.

func (f Func) SQL() string

type FuncCallEq ¶

type FuncCallEq struct {
	FuncName string
	Args     []Expr
	Value    Expr // The value to compare against (typically Int(1) or Int(0))
}

FuncCallEq compares a function call result to a value. Used for authorization check expressions like "check_permission(...) = 1".

Example:

FuncCallEq{
    FuncName: "check_doc_viewer",
    Args:     []Expr{SubjectType, SubjectID, ObjectID, Visited},
    Value:    Int(1),
}

Renders: check_doc_viewer(p_subject_type, p_subject_id, p_object_id, p_visited) = 1

func InternalCheckCall(subjectType, subjectID Expr, relation string, parentType, parentID, visited Expr) FuncCallEq

InternalCheckCall(SubjectType, SubjectID, "viewer", Col{Table: "link", Column: "subject_type"}, Col{Table: "link", Column: "subject_id"}, visited)

func InternalPermissionCheckCall(relation, objectType string, objectID, visited Expr) FuncCallEq

InternalPermissionCheckCall("viewer", "document", Col{Table: "t", Column: "object_id"}, Visited)

func NoWildcardPermissionCheckCall(relation, objectType string, subjectID, objectID Expr) FuncCallEq

func SpecializedCheckCall(funcName string, subjectType, subjectID, objectID, visited Expr) FuncCallEq

SpecializedCheckCall("check_doc_owner", SubjectType, SubjectID, ObjectID, Visited)

func (f FuncCallEq) SQL() string

type FuncCallNe ¶

type FuncCallNe struct {
	FuncName string
	Args     []Expr
	Value    Expr
}

FuncCallNe compares a function call result for inequality. Used for negative authorization checks like "check_permission(...) <> 1".

func (f FuncCallNe) SQL() string

type FunctionCallExpr ¶

type FunctionCallExpr struct {
	Name  string // Function name
	Args  []Expr // Function arguments
	Alias string // Table alias for the result
}

FunctionCallExpr represents a function call that can be used as a table expression. Used for LATERAL joins with table-returning functions.

func (f FunctionCallExpr) TableAlias() string

func (f FunctionCallExpr) TableSQL() string

type Gt ¶

type Gt struct {
	Left  Expr
	Right Expr
}

Gt represents a greater-than comparison (>).

func (g Gt) SQL() string

type Gte ¶

type Gte struct {
	Left  Expr
	Right Expr
}

Gte represents a greater-than-or-equal comparison (>=).

func (g Gte) SQL() string

type HasUserset ¶

type HasUserset struct {
	Source Expr
}

HasUserset checks if an expression contains a userset marker (#).

func (h HasUserset) SQL() string

type In ¶

type In struct {
	Expr   Expr
	Values []string
}

In represents an IN clause for string values.

func (i In) SQL() string

type InFunctionSelect ¶

type InFunctionSelect struct {
	Expr      Expr   // The expression to check (left side of IN)
	FuncName  string // The function to call
	Args      []Expr // Function arguments
	Alias     string // Alias for the function result
	SelectCol string // Column to select from the function result
}

InFunctionSelect represents "expr IN (SELECT column FROM func(args...) alias)". Used for checking membership against results of a list function.

Example:

InFunctionSelect{
    Expr:       Col{Table: "t", Column: "subject_id"},
    FuncName:   "list_doc_viewer_objects",
    Args:       []Expr{SubjectType, SubjectID, Null{}, Null{}},
    Alias:      "obj",
    SelectCol:  "object_id",
}

Renders: t.subject_id IN (SELECT obj.object_id FROM list_doc_viewer_objects(p_subject_type, p_subject_id, NULL, NULL) obj)

func (i InFunctionSelect) SQL() string

type Int ¶

type Int int

Int represents an integer literal.

func (i Int) SQL() string

type IntersectSubquery ¶

type IntersectSubquery struct {
	Queries []SelectStmt
	Alias   string
}

IntersectSubquery represents an INTERSECT of multiple queries as a subquery. Used for intersection groups where all parts must be satisfied.

Example: IntersectSubquery{Queries: [q1, q2], Alias: "ig"} Renders: (q1 INTERSECT q2) AS ig

func (i IntersectSubquery) TableAlias() string

func (i IntersectSubquery) TableSQL() string

type IsNotNull ¶

type IsNotNull struct {
	Expr Expr
}

IsNotNull represents IS NOT NULL check.

func (i IsNotNull) SQL() string

type IsNull ¶

type IsNull struct {
	Expr Expr
}

IsNull represents IS NULL check.

func (i IsNull) SQL() string

type IsWildcard ¶

type IsWildcard struct {
	Source Expr
}

IsWildcard checks if an expression equals the wildcard value "*".

func (w IsWildcard) SQL() string

type JoinClause ¶

type JoinClause struct {
	Type      string    // "INNER", "LEFT", etc.
	Table     string    // Deprecated: use TableExpr instead
	TableExpr TableExpr // Preferred: typed table expression
	Alias     string    // Deprecated: use TableExpr's alias instead
	On        Expr
}

JoinClause represents a SQL JOIN clause.

func (j JoinClause) SQL() string

type LateralFunction ¶

type LateralFunction struct {
	Name  string
	Args  []Expr
	Alias string
}

LateralFunction represents a LATERAL function call in a JOIN. Example: LateralFunction{Name: "list_doc_viewer_subjects", Args: []Expr{...}, Alias: "s"} Renders: LATERAL list_doc_viewer_subjects(...) AS s

func (l LateralFunction) SQL() string

func (l LateralFunction) TableAlias() string

func (l LateralFunction) TableSQL() string

type Lit ¶

type Lit string

Lit represents a literal string value (auto-quoted with single quotes).

func LitText(v string) Lit

func (l Lit) SQL() string

type Lt ¶

type Lt struct {
	Left  Expr
	Right Expr
}

Lt represents a less-than comparison (<).

func (l Lt) SQL() string

type Lte ¶

type Lte struct {
	Left  Expr
	Right Expr
}

Lte represents a less-than-or-equal comparison (<=).

func (l Lte) SQL() string

type Ne ¶

type Ne struct {
	Left  Expr
	Right Expr
}

Ne represents a not-equal comparison (<>).

func (n Ne) SQL() string

type NoUserset ¶

type NoUserset struct {
	Source Expr
}

NoUserset checks if an expression does NOT contain a userset marker (#).

func (n NoUserset) SQL() string

type NotExists ¶

type NotExists struct {
	Query interface{ SQL() string }
}

NotExists represents a NOT EXISTS subquery.

func (n NotExists) SQL() string

type NotExpr ¶

type NotExpr struct {
	Expr Expr
}

NotExpr represents a logical NOT of an expression.

func Not(expr Expr) NotExpr

func (n NotExpr) SQL() string

type NotIn ¶

type NotIn struct {
	Expr   Expr
	Values []string
}

NotIn represents a NOT IN clause for string values.

func (n NotIn) SQL() string

type Null ¶

type Null struct{}

Null represents SQL NULL.

func (Null) SQL() string

type ObjectRef ¶

type ObjectRef struct {
	Type Expr
	ID   Expr
}

ObjectRef represents an object reference (type + id).

func LiteralObject(objectType string, id Expr) ObjectRef

type OrExpr ¶

type OrExpr struct {
	Exprs []Expr
}

OrExpr represents a logical OR of multiple expressions.

func Or(exprs ...Expr) OrExpr

func (o OrExpr) SQL() string

type Param ¶

type Param string

Param represents a function parameter (e.g., p_subject_type, p_object_id).

func ParamRef(name string) Param

func (p Param) SQL() string

type Paren ¶

type Paren struct {
	Expr Expr
}

Paren wraps an expression in parentheses.

func (p Paren) SQL() string

type Position ¶

type Position struct {
	Needle   Expr
	Haystack Expr
}

Position represents SQL position(needle in haystack). Returns the position of the first occurrence of needle in haystack.

func (p Position) SQL() string

type QueryBlock ¶

type QueryBlock struct {
	Comments []string // Comment lines (without -- prefix)
	Query    SQLer    // The query as typed DSL (SelectStmt, Raw, etc.)
}

QueryBlock represents a query with optional comments. Used to build UNION queries with descriptive comments for each branch.

type Raw ¶

type Raw string

Raw is an escape hatch for arbitrary SQL expressions.

func (r Raw) SQL() string

type SQLer ¶

type SQLer interface {
	SQL() string
}

SQLer is an interface for types that can render SQL. SelectStmt, Raw, and other query types implement this interface.

type SelectIntoVar ¶

type SelectIntoVar struct {
	Query    SQLer  // The query (e.g., a CTE)
	Variable string // Variable name to select into
}

SelectIntoVar wraps a query for use with PL/pgSQL SELECT INTO. Appends "INTO <variable>" after the query.

Example:

SelectIntoVar{Query: cteQuery, Variable: "v_max_depth"}

Renders:

<query> INTO v_max_depth

func (s SelectIntoVar) SQL() string

type SelectStmt ¶

type SelectStmt struct {
	Distinct    bool
	Columns     []string  // Deprecated: use ColumnExprs instead
	ColumnExprs []Expr    // Preferred: typed column expressions
	From        string    // Deprecated: use FromExpr instead
	FromExpr    TableExpr // Preferred: typed table expression
	Alias       string    // Deprecated: use FromExpr's alias instead
	Joins       []JoinClause
	Where       Expr
	Limit       int
}

SelectStmt represents a SELECT query.

func (s SelectStmt) Exists() string

func (s SelectStmt) NotExists() string

func (s SelectStmt) SQL() string

type Sub ¶

type Sub struct {
	Left  Expr
	Right Expr
}

Sub represents subtraction (-).

func (s Sub) SQL() string

type SubjectRef ¶

type SubjectRef struct {
	Type Expr
	ID   Expr
}

SubjectRef represents a subject reference (type + id).

func SubjectParams() SubjectRef

type Substring ¶

type Substring struct {
	Source Expr
	From   Expr
	For    Expr // optional
}

Substring represents SQL substring(source from start [for length]). If For is nil, renders substring(source from start). If For is provided, renders substring(source from start for length).

func (s Substring) SQL() string

type SubstringUsersetRelation ¶

type SubstringUsersetRelation struct {
	Source Expr
}

SubstringUsersetRelation extracts the relation portion after the '#' marker. Used when the input contains a userset marker and we need just the relation.

func (s SubstringUsersetRelation) SQL() string

type TableExpr ¶

type TableExpr interface {
	// TableSQL returns the SQL for use in FROM/JOIN clauses.
	TableSQL() string
	// TableAlias returns the alias if any (empty string if none).
	TableAlias() string
}

TableExpr is the interface for table expressions in FROM and JOIN clauses. Types that can be used as table sources implement this interface.

func ClosureTable(rows []ValuesRow, alias string) TableExpr

func UsersetTable(rows []ValuesRow, alias string) TableExpr

type TableRef ¶

type TableRef struct {
	Name  string
	Alias string
}

TableRef wraps a raw table name for use as a TableExpr.

func TableAs(name, alias string) TableRef

func (t TableRef) TableAlias() string

func (t TableRef) TableSQL() string

type TypedValuesTable ¶

type TypedValuesTable struct {
	Rows    []ValuesRow // Typed expression rows
	Alias   string      // Table alias
	Columns []string    // Column names
}

TypedValuesTable represents a VALUES clause with typed expression rows. Unlike ValuesTable which uses a pre-formatted string, TypedValuesTable uses structured ValuesRow elements that render via the Expr DSL.

Example:

TypedValuesTable{
    Rows: []ValuesRow{{Lit("doc"), Lit("viewer"), Lit("editor")}},
    Alias: "c",
    Columns: []string{"object_type", "relation", "satisfying_relation"},
}

Renders: (VALUES ('doc', 'viewer', 'editor')) AS c(object_type, relation, satisfying_relation)

func TypedClosureValuesTable(rows []ValuesRow, alias string) TypedValuesTable

func TypedUsersetValuesTable(rows []ValuesRow, alias string) TypedValuesTable

func (v TypedValuesTable) SQL() string

func (v TypedValuesTable) TableAlias() string

func (v TypedValuesTable) TableSQL() string

type UnionAll ¶

type UnionAll struct {
	Queries []SQLer
	Indent  string // Optional indent prefix for each query (default: empty)
}

UnionAll represents multiple queries combined with UNION ALL. Each query is rendered and joined with UNION ALL.

Example:

UnionAll{Queries: []SQLer{query1, query2}}

Renders:

query1
UNION ALL
query2

func (u UnionAll) SQL() string

type UsersetNormalized ¶

type UsersetNormalized struct {
	Source   Expr
	Relation Expr
}

UsersetNormalized replaces the relation in a userset with a new relation. Example: "group:1#admin" with relation "member" -> "group:1#member"

func (u UsersetNormalized) SQL() string

type UsersetObjectID ¶

type UsersetObjectID struct {
	Source Expr
}

UsersetObjectID extracts the object ID: "group:1#member" -> "group:1"

func (u UsersetObjectID) SQL() string

type UsersetRelation ¶

type UsersetRelation struct {
	Source Expr
}

UsersetRelation extracts the relation: "group:1#member" -> "member"

func (u UsersetRelation) SQL() string

type ValuesRow ¶

type ValuesRow []Expr

ValuesRow represents a single row in a VALUES clause as typed expressions. Each element in the slice corresponds to a column value.

func (r ValuesRow) SQL() string

type ValuesTable ¶

type ValuesTable struct {
	Values  string   // The VALUES content (e.g., "('a', 'b'), ('c', 'd')")
	Alias   string   // Table alias (e.g., "c")
	Columns []string // Column names (e.g., ["object_type", "relation"])
}

ValuesTable represents a VALUES clause as a table expression. Used to inline data like closure values without database tables.

Example: ValuesTable{Values: "('doc', 'viewer', 'editor')", Alias: "c", Columns: []string{"object_type", "relation", "satisfying_relation"}} Renders: (VALUES ('doc', 'viewer', 'editor')) AS c(object_type, relation, satisfying_relation)

func (v ValuesTable) SQL() string

func (v ValuesTable) TableAlias() string

func (v ValuesTable) TableSQL() string

type WithCTE ¶

type WithCTE struct {
	Recursive bool     // If true, renders WITH RECURSIVE
	CTEs      []CTEDef // One or more CTE definitions
	Query     SQLer    // The final SELECT that uses the CTEs
}

WithCTE represents a WITH clause wrapping a final query. Supports both regular and recursive CTEs.

Example:

WithCTE{
    Recursive: true,
    CTEs: []CTEDef{{Name: "accessible", Columns: []string{"object_id", "depth"}, Query: cteQuery}},
    Query: finalSelect,
}

Renders:

WITH RECURSIVE accessible(object_id, depth) AS (
    <cte query>
)
<final query>

func MultiCTE(recursive bool, ctes []CTEDef, finalQuery SQLer) WithCTE

func RecursiveCTE(name string, columns []string, cteQuery, finalQuery SQLer) WithCTE

func SimpleCTE(name string, cteQuery, finalQuery SQLer) WithCTE

func (w WithCTE) SQL() string