filterquery

type And ¶

type And struct {
	Terms []Node
	At    int
}

And is a conjunction — explicit (expression level) or implicit (sequence level). The two levels share a node type; precedence is settled at parse.

func (n *And) Pos() int

type Bare ¶

type Bare struct {
	Text string
	At   int
}

Bare is an unqualified term (AIP-160 global restriction). The v1 registry rejects these at validation; the parser still produces them so the rejection error can name the term precisely.

func (n *Bare) Pos() int

type Comparison ¶

type Comparison struct {
	Field  string // dotted path, e.g. "label" or "metrics.latency"
	Op     string // one of ":", "=", "!=", "<", "<=", ">", ">="
	Raw    string // value text (unescaped contents for quoted strings)
	Quoted bool   // value was a quoted string
	Value  any    // coerced value, set by Validate

	At int
	// contains filtered or unexported fields
}

Comparison is `field op value`. Value holds the coerced value and is set by Registry.Validate; before validation only Raw is meaningful. A comparison may emit only through the registry that validated it.

func (n *Comparison) Pos() int

type Dialect ¶

type Dialect interface {
	Placeholder(n int) string
}

Dialect abstracts SQL placeholder style. Task 4 adds the built-in Postgres adapter; defining the interface here keeps EmitCtx compilable.

type EmitCtx ¶

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

EmitCtx hands FieldSpec.Emit sequential placeholders and collects args.

func (e *EmitCtx) PH(arg any) string

type ErrKind ¶

type ErrKind int

ErrKind classifies an *Error for the HTTP layer (all map to 400 today; the distinction exists for metrics and future client hints).

const (
	ErrParse ErrKind = iota
	ErrValidate
	ErrCap
)

type Error ¶

type Error struct {
	Kind ErrKind
	Pos  int
	Msg  string
}

Error is a positioned filter-language error. Pos is a 0-based byte offset into the input; -1 when not position-specific. The displayed column is therefore byte-based: with multibyte input before the error position it overcounts runes. Inputs are short (capped) and the column is a hint, so this is accepted rather than paying for rune indexing.

func (e *Error) Error() string

type Expr ¶

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

Expr is a parsed + validated filter, ready to emit at any placeholder offset. Safe for concurrent Emit calls: the AST is immutable after Parse, and Emit constructs a fresh EmitCtx per call.

func Parse(q string, reg *Registry) (*Expr, error)

func (e *Expr) Emit(d Dialect, start int) (string, []any, error)

func (e *Expr) Empty() bool

type FieldSpec ¶

type FieldSpec struct {
	Name string
	Ops  []string // allowed operators, e.g. []string{":"}
	// Coerce converts the raw value text into the typed value stored on
	// Comparison.Value. quoted reports that the input was a quoted string.
	Coerce func(raw string, quoted bool) (any, error)
	// Emit renders one boolean predicate. Placeholders and args are bound
	// through EmitCtx.PH. Fields binding no value (boolean flags) simply
	// don't call PH.
	Emit func(c *Comparison, e *EmitCtx) (string, error)
}

FieldSpec describes one filterable field: which operators it accepts, how raw values coerce, and how a validated comparison emits SQL. Coerce and Emit must be deterministic and safe for concurrent calls: emission re-coerces a private comparison copy on every call.

type Node ¶

type Node interface {
	Pos() int
}

Node is one AST node. Pos is the 0-based byte offset of the node's first character in the input, for error messages.

type Not ¶

type Not struct {
	X  Node
	At int
}

func (n *Not) Pos() int

type Or ¶

type Or struct {
	Terms []Node
	At    int
}

func (n *Or) Pos() int

type PostgresDialect ¶

type PostgresDialect struct{}

PostgresDialect uses $n placeholders.

func (PostgresDialect) Placeholder(n int) string

type Registry ¶

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

Registry is the adopter-supplied field set. Construct once at startup; safe for concurrent use after construction. Note the concurrency guarantee covers the REGISTRY, not a shared AST: Validate coerces Comparison values in place, so a single parsed AST must not be validated (or compiled) concurrently — parse per request. The Expr flow (Parse once, then concurrent Expr.Emit) is immutable and is the supported shared path.

func NewRegistry(specs ...FieldSpec) (*Registry, error)

func (r *Registry) Emit(n Node, d Dialect, start int) (string, []any, error)

func (r *Registry) Names() []string

func (r *Registry) Validate(n Node) error