sqlbind

type BinaryExpr = syntax.BinaryExpr

type Body = []Node

type CallExpr = syntax.CallExpr

type CheckNode = syntax.CheckNode

type CompileError struct {
	Filename string
	Pos      Position
	Message  string
}

type ConditionalExpr = syntax.ConditionalExpr

type Declaration = syntax.Declaration

type EnumDecl = syntax.EnumDecl

type ExecutorResolver struct {
	PackagePath string
	Name        string
}

type Expr = syntax.Expr

type ExpressionNode = syntax.ExpressionNode

type ExternalDecl = syntax.ExternalDecl

type Field = syntax.Field

type ForNode = syntax.ForNode

type GenerateOptions struct {
	Package string
	// Dialect selects the target database. It is required: there is no implicit
	// default, because a silently assumed dialect emits placeholders the target
	// engine rejects.
	Dialect string
	// ErrorExternals names the external functions whose Go implementation
	// returns a trailing error. A non-nil error fails the statement build, so
	// such a function may only be called as the whole value of a
	// requirement:template-value-binding binding, where the failure has a place
	// to go and a name in the source.
	//
	// The caller discovers this by reading the package's Go sources, so the
	// template declaration stays the same either way.
	ErrorExternals map[string]bool
	// ContextAPI adds <Component>Context wrappers which resolve an executor
	// from context.Context while preserving the explicit executor APIs.
	ContextAPI bool
	// ContextOnly publishes the Context-resolved function under the declared
	// component name and makes the executor-taking function unexported. It
	// implies ContextAPI and generates no <Component>Context wrapper.
	ContextOnly bool
	// ExecutorResolver selects a framework-specific Context resolver. A nil
	// resolver uses sqlbind.SQLExecutorFromContext. Setting it implies ContextAPI.
	ExecutorResolver *ExecutorResolver
	// LineDirectives maps each emitted statement line back to the template line
	// that produced it, so a compile error and a runtime stack frame both name
	// the .tb.sql file rather than the generated Go one.
	//
	// It is off by default. Turning it on changes the bytes of every generated
	// file carrying a statement, and a covered test run reports lines that do
	// not exist in the file it names, per rule:line-directive-emission.
	LineDirectives bool
	// OutputName is the base name of the Go file this output becomes. A mapped
	// span ends with a directive naming that file and the line the reader is on,
	// and neither is known until the bytes are final.
	//
	// Leaving it empty returns the output with those directives unresolved, for
	// a caller that concatenates several results and resolves the combined file
	// itself with generator.ResolveTemplatePositions. A caller writing this
	// result as a whole file must name it here.
	OutputName string
}

type IdentifierExpr = syntax.IdentifierExpr

type IfNode = syntax.IfNode

type IndexExpr = syntax.IndexExpr

type LiteralExpr = syntax.LiteralExpr

type MemberExpr = syntax.MemberExpr

type MessageExpr = syntax.MessageExpr

type Module = syntax.Module

type Node = syntax.Node

type Parameter = syntax.Parameter

type ParseError = syntax.ParseError

type Position = syntax.Position

type RelationNode struct {
	Kind      string   `json:"kind"`
	Pos       Position `json:"pos"`
	Name      string   `json:"name"`
	Arguments []Expr   `json:"arguments,omitempty"`
	Alias     string   `json:"alias"`
}

type TemplateDecl = syntax.TemplateDecl

type TextNode struct {
	Kind string   `json:"kind"`
	Pos  Position `json:"pos"`
	Text string   `json:"text"`
}

type TypeDecl = syntax.TypeDecl

type TypeRef = syntax.TypeRef

type UnaryExpr = syntax.UnaryExpr

type ValBinding = syntax.ValBinding

type ValNode = syntax.ValNode