sqldocument

type Batch struct {
	// Nodes contains all unparsed tokens accumulated before a statement.
	// These are prepended to CREATE statement bodies to preserve
	// leading whitespace and comments in the output.
	Nodes []Unparsed

	// DocString holds single-line comments that precede a statement.
	// These comments form the documentation for procedures/functions.
	// Reset when non-comment, non-whitespace tokens are encountered.
	DocString []PosString

	// TokenCalls tracks how many Token handlers have been
	// called in this batch. Can be used to enforce the validation rules
	// that procedures and functions must be alone in their batch.
	TokenCalls map[string]int

	// TokenHandlers maps reserved words to their processing functions.
	// When a ReservedWordToken is encountered, its lowercase form is
	// looked up here. If found, the handler is called with the scanner
	// and batch.
	// The handler returns 1 if parsing should continue
	// with a new batch (e.g., after processing a batch separator).
	// 		1 = break and parse a new batch
	// 		0 = continue (no return)
	//  	-1 = return false (stop parsing)
	TokenHandlers map[string]func(Scanner, *Batch) int

	// Errors accumulates parsing errors encountered during batch processing.
	// Errors are collected rather than stopping parsing immediately,
	// allowing partial results even with syntax errors.
	Errors []Error

	// BatchSeparatorHandler is called when a token is encountered.
	BatchSeparatorHandler func(Scanner, *Batch)
}

type Create struct {
	// CreateType specifies the type of object being created.
	// Valid values are "procedure", "function", or "type".
	CreateType CreateType

	// QuotedName is the name of the object being created, including square brackets.
	// For example: [MyProcedure].
	QuotedName PosString

	// Body contains the full body of the CREATE statement, including all tokens.
	// This includes the CREATE keyword, object definition, and any trailing comments.
	Body []Unparsed

	// DependsOn lists other objects that this CREATE statement depends on.
	// Each dependency is represented as a PosString.
	DependsOn []PosString

	// Docstring contains comments that precede the CREATE statement.
	// These comments are typically used for documentation purposes.
	Docstring []PosString

	// Driver specifies the SQL driver associated with this CREATE statement.
	// This is used to determine dialect-specific behavior.
	Driver driver.Driver
}

type CreateType int

type Declare struct {
	Start        Pos
	Stop         Pos
	VariableName string
	Datatype     Type
	Literal      Unparsed
}

type Document interface {
	// Parse parses the input SQL document and populates the Document structure.
	Parse(input []byte, file FileRef) error
	// Returns true if the document contains no create statements or declarations
	Empty() bool
	// Returns true if the document contains any parsing errors
	HasErrors() bool
	// Returns the list of create statements in the document
	Creates() []Create
	// Returns the list of variable declarations in the document
	Declares() []Declare
	// Returns the list of parsing errors in the document
	Errors() []Error
	// Returns the list of pragma include-if statements in the document
	PragmaIncludeIf() []string
	// Includes the content of another Document into this one
	Include(other Document)
	// Performs a topological sort of the create statements based on their dependencies
	Sort()
}

type Error struct {
	Pos     Pos
	Message string
}

type FileRef string

type NotFoundError struct {
	Name string
}

type Pos struct {
	File      FileRef
	Line, Col int
}

type PosString struct {
	Pos
	Value string
}

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

type Scanner interface {
	// TokenType returns the type of the current token.
	// This may return dialect-specific token types.
	TokenType() TokenType

	// Token returns the text of the current token.
	Token() string

	// File returns a reference to the source file being scanned.
	File() FileRef

	// TokenLower returns the current token text converted to lowercase.
	TokenLower() string

	// ReservedWord returns the lowercase reserved word if the current token
	// is a ReservedWordToken, or an empty string otherwise.
	ReservedWord() string

	// Start returns the position where the current token begins.
	Start() Pos

	// Stop returns the position where the current token ends.
	Stop() Pos

	// NextToken scans the next token and advances the scanner's position.
	NextToken() TokenType

	// NextNonWhitespaceToken advances to the next non-whitespace token.
	NextNonWhitespaceToken() TokenType

	// NextNonWhitespaceCommentToken advances to the next significant token.
	NextNonWhitespaceCommentToken() TokenType

	// SkipWhitespace advances past any whitespace tokens.
	SkipWhitespace()

	// SkipWhitespaceComments advances past any whitespace and comment tokens.
	SkipWhitespaceComments()

	// Set the scanner's input to the given byte slice.
	SetInput([]byte)

	// Set the scanner's input file reference.
	SetFile(FileRef)
}

type TokenType int

type Type struct {
	BaseType string
	Args     []string
}

type Unparsed struct {
	Type        TokenType
	Start, Stop Pos
	RawValue    string
}