base

type ANTLRAST struct {
	// StartPosition is the 1-based position where this statement starts.
	StartPosition *storepb.Position
	Tree          antlr.Tree
	Tokens        *antlr.CommonTokenStream
}

type AST interface {
	// ASTStartPosition returns the 1-based position where this SQL statement starts
	// in the original multi-statement input. Used for error position reporting.
	// Returns nil if position is unknown.
	// Named to avoid collision with protobuf-generated GetStartPosition methods.
	ASTStartPosition() *storepb.Position
}

type ArraySelector struct {
	Identifier string
	Index      int
	Next       SelectorNode
}

type BackupStatement struct {
	Statement       string
	SourceSchema    string
	SourceTableName string
	TargetTableName string

	StartPosition *storebp.Position
	EndPosition   *storebp.Position
}

type Candidate struct {
	Text       string
	Type       CandidateType
	Definition string
	Comment    string
	// The smaller the number, the higher the priority.
	Priority int
}

type CandidateType string

type CandidatesCollection struct {
	Tokens map[int][]int
	Rules  map[int][]*RuleContext
}

type ChangeSummary struct {
	ChangedResources *model.ChangedResources
	SampleDMLS       []string
	DMLCount         int
	InsertCount      int
}

type CodeCompletionCore struct {
	IgnoredTokens  map[int]bool
	PreferredRules map[int]bool

	// QueryRule and SelectItemAliasRule are used to determine the select item alias
	// for the completion candidates.
	// They can be used in GROUP BY, ORDER BY and HAVING clauses.
	QueryRule           int
	ShadowQueryRule     int
	SelectItemAliasRule int
	// CTERule is used to determine the CTE alias for the completion candidates.
	// Currently, it always uses in ShadowQueryRule for MySQL.
	CTERule int
	// contains filtered or unexported fields
}

type ColumnOptionType int

type ColumnResource struct {
	// Server is the normalized server name, it's empty if the column comes from the connected server.
	Server string
	// Database is the normalized database name, it should not be empty.
	Database string
	// Schema is the normalized schema name, it should not be empty for the engines that support schema, and should be empty for the engines that don't support schema.
	Schema string
	// Table is the normalized table name, it should not be empty.
	Table string
	// Column is the normalized column name, it should not be empty.
	Column string
}

type CompletionContext struct {
	Scene             SceneType
	InstanceID        string
	DefaultDatabase   string
	DefaultSchema     string
	Metadata          GetDatabaseMetadataFunc
	ListDatabaseNames ListDatabaseNamesFunc
}

type CompletionFunc func(ctx context.Context, cCtx CompletionContext, statement string, caretLine int, caretOffset int) ([]Candidate, error)

type DiagnoseContext struct {
}

type DiagnoseFunc func(ctx context.Context, dCtx DiagnoseContext, statement string) ([]Diagnostic, error)

type Diagnostic = lsp.Diagnostic

type DiffContext struct {
	IgnoreCaseSensitive bool
	StrictMode          bool
}

type Edge struct {
	Start string
	End   string
}

type ExtractChangedResourcesFunc func(string, string, *model.DatabaseMetadata, []AST, string) (*ChangeSummary, error)

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

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

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

type FollowSetsList []FollowSetWithPath

type GenerateRestoreSQLFunc func(ctx context.Context, rCtx RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error)

type GetDatabaseMetadataFunc func(context.Context, string, string) (string, *model.DatabaseMetadata, error)

type GetLinkedDatabaseMetadataFunc func(context.Context, string, string, string) (string, string, *model.DatabaseMetadata, error)

type GetQuerySpanContext struct {
	InstanceID                    string
	GetDatabaseMetadataFunc       GetDatabaseMetadataFunc
	ListDatabaseNamesFunc         ListDatabaseNamesFunc
	GetLinkedDatabaseMetadataFunc GetLinkedDatabaseMetadataFunc
	// TempTables is the temporary tables created in the query span.
	// It's used to store the temporary tables declared in one batch for SQL Server.
	TempTables map[string]*PhysicalTable

	// Adding the engine information here is a trade-off between the copy-pasted and shared code.
	// For engines with more different, we implement the getQuerySpan separately.
	// For some similar engines, we can share the same getQuerySpan implementation.
	// But they may have some differences, so we need to pass the engine information here.
	// No need to set this field when call GetQuerySpan, because the base.GetQuerySpan already has the engine information.
	// We'll deal this field in the base.GetQuerySpan.
	Engine storepb.Engine
}

type GetQuerySpanFunc func(ctx context.Context, gCtx GetQuerySpanContext, statement, database, schema string, ignoreCaseSensitive bool) (*QuerySpan, error)

type Graph struct {
	NodeMap  map[string]*Node
	EdgeList []*Edge
}

type ItemSelector struct {
	Identifier string
	Next       SelectorNode
}

type ListDatabaseNamesFunc func(context.Context, string) ([]string, error)

type Node struct {
	ID string
}

type ParseErrorListener struct {
	// StartPosition is the 1-based position where this statement starts in the original multi-statement input.
	// Used to calculate error positions relative to the original script.
	StartPosition *storepb.Position
	Err           *SyntaxError
	Statement     string
}

type ParseFunc func(statement string) ([]AST, error)

type ParseResult struct {
	Tree   antlr.Tree
	Tokens *antlr.CommonTokenStream
	// BaseLine stores the zero-based line offset where this SQL statement starts in the original multi-statement input.
	// When splitting a multi-statement SQL script (e.g., "SELECT 1;\nSELECT 2;"), each statement is parsed separately.
	// BaseLine tracks the original line number (minus 1) of the first token in this statement, allowing error messages
	// and positions to be correctly reported relative to the original script rather than the isolated statement.
	// Calculated from StartPosition.Line - 1 (since StartPosition uses 1-based line numbers, but BaseLine is 0-based for offset arithmetic).
	BaseLine int
}

type PathAST struct {
	Root SelectorNode
}

type PhysicalTable struct {

	// Server is the normalized server name, it's empty if the column comes from the connected server.
	Server string
	// Database is the normalized database name, it should not be empty.
	Database string
	// Schema is the normalized schema name, it should not be empty for the engines that support schema, and should be empty for the engines that don't support schema.
	Schema string
	// Name is the normalized table name, it should not be empty.
	Name string
	// Columns are the columns of the table.
	Columns []string
	// contains filtered or unexported fields
}

type PhysicalTableReference struct {
	Database string
	Schema   string
	Table    string
	Alias    string
}

type PhysicalView struct {

	// Server is the normalized server name, it's empty if the column comes from the connected server.
	Server string
	// Database is the normalized database name, it should not be empty.
	Database string
	// Schema is the normalized schema name, it should not be empty for the engines that support schema, and should be empty for the engines that don't support schema.
	Schema string
	// Name is the normalized table name, it should not be empty.
	Name string
	// Columns are the columns of the table.
	Columns []QuerySpanResult
	// contains filtered or unexported fields
}

type PipelineEntry struct {
	State      antlr.ATNState
	TokenIndex int
}

type PseudoTable struct {

	// Name is the normalized table name.
	Name string

	// Columns are the columns of the table.
	Columns []QuerySpanResult
	// contains filtered or unexported fields
}

type QuerySpan struct {
	Type QueryType
	// Results are the result columns of a query span.
	// Currently, SourceColumns in the QuerySpanResult are only for the fields in the Query.
	Results []QuerySpanResult
	// SourceColumns are the source columns contributing to the span.
	// SourceColumns here are the source columns for the whole query span, containing fields, where conditions, join conditions, etc.
	SourceColumns SourceColumnSet
	// PredicateColumns are the source columns contributing to the span.
	// PredicateColumns here are the source columns for the where conditions.
	PredicateColumns SourceColumnSet
	// PredicatePaths is predicateColumns used by Cosmos DB only, to store the path of the field, all the
	// paths should begin with the container name.
	PredicatePaths            map[string]*PathAST
	NotFoundError             error
	FunctionNotSupportedError error
}

type QuerySpanResult struct {
	// Name is the result name of a query.
	Name string
	// SourceColumns are the source columns contributing to the span result.
	SourceColumns SourceColumnSet
	// IsPlainField indicates whether the field is a plain column reference (true) or an expression (false).
	IsPlainField bool
	// SourceFieldPaths is used for Cosmos DB only, to store the path of the field, the root is the container name.
	SourceFieldPaths map[string]*PathAST
	// SelectAsterisk indicates whether the field is selected by asterisk, used by Cosmos DB.
	SelectAsterisk bool
}

type QueryType int

type Range = lsp.Range

type RestoreContext struct {
	InstanceID              string
	GetDatabaseMetadataFunc GetDatabaseMetadataFunc
	ListDatabaseNamesFunc   ListDatabaseNamesFunc
	IsCaseSensitive         bool
}

type RuleContext struct {
	ID int
	// SelectItemAliases is the map of token index of select item aliases.
	// Only the QueryRule has the SelectItemAliases.
	SelectItemAliases map[int]bool
	CTEList           []int
}

type RuleEndStatus map[int]bool

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

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

type SceneType string

type SchemaResource struct {
	Database string
	Schema   string
	Table    string

	// LinkedServer is the special resource for MSSQL, which can be used to specify the linked server.
	LinkedServer string
}

type SelectorNode interface {
	GetIdentifier() string
	SetNext(SelectorNode)
	GetNext() SelectorNode
	// contains filtered or unexported methods
}

type Sequence struct {

	// Server is the normalized server name, it's empty if the column comes from the connected server.
	Server string
	// Database is the normalized database name, it should not be empty.
	Database string
	// Schema is the normalized schema name, it should not be empty for the engines that support schema, and should be empty for the engines that don't support schema.
	Schema string
	// Name is the normalized sequence name, it should not be empty.
	Name string
	// Columns are the columns of the sequence.
	Columns []string
	// contains filtered or unexported fields
}

type SingleSQL struct {
	Text string
	// BaseLine is the line number of the first line of the SQL in the original SQL.
	// HINT: ZERO based.
	BaseLine int
	// The inclusive start position of the SQL starts in the original SQL.
	Start *storepb.Position
	// The inclusive end position of the SQL ends in the original SQL.
	End *storepb.Position
	// The sql is empty, such as `/* comments */;` or just `;`.
	Empty bool

	// ByteOffsetStart is the start position of the sql.
	// This field may not be present for every engine.
	// ByteOffsetStart is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
	ByteOffsetStart int
	// ByteOffsetEnd is the end position of the sql.
	// This field may not be present for every engine.
	// ByteOffsetEnd is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
	ByteOffsetEnd int
}

type SourceColumnSet map[ColumnResource]bool

type SplitMultiSQLFunc func(string) ([]SingleSQL, error)

type StatementRangeContext struct{}

type StatementRangeFunc func(ctx context.Context, sCtx StatementRangeContext, statement string) ([]Range, error)

type StringsManipulatorAction interface {
	GetType() StringsManipulatorActionType
	GetSchemaName() string
	GetTopLevelNaming() string
	GetSecondLevelNaming() string
}

type StringsManipulatorActionBase struct {
	Type       StringsManipulatorActionType
	SchemaName string
}

type StringsManipulatorActionType int

type SyntaxError struct {
	Position   *storepb.Position
	Message    string
	RawMessage string
}

type TableConstraintType int

type TableReference interface {
	// contains filtered or unexported methods
}

type TableSource interface {
	GetTableName() string
	GetSchemaName() string
	GetDatabaseName() string
	GetServerName() string
	// GetQuerySpanResult returns the query span result of the table, it's callers' responsibility
	// to make a copy of the result if they want to modify it.
	GetQuerySpanResult() []QuerySpanResult
	// contains filtered or unexported methods
}

type Token struct {
	Type          int
	StartPosition int
}

type TransformContext struct {
	Version                 any
	InstanceID              string
	GetDatabaseMetadataFunc GetDatabaseMetadataFunc
	ListDatabaseNamesFunc   ListDatabaseNamesFunc
	IsCaseSensitive         bool
	DatabaseName            string
}

type TransformDMLToSelectFunc func(ctx context.Context, tCtx TransformContext, statement string, sourceDatabase string, targetDatabase string, tablePrefix string) ([]BackupStatement, error)

type ValidateSQLForEditorFunc func(string) (bool, bool, error)

type VirtualTableReference struct {
	Table   string
	Columns []string
}

type YamlQuerySpan struct {
	Type             QueryType
	Results          []YamlQuerySpanResult
	SourceColumns    []ColumnResource
	PredicateColumns []ColumnResource
}

type YamlQuerySpanResult struct {
	Name             string
	SourceColumns    []ColumnResource
	IsPlainField     bool
	SourceFieldPaths []YamlQuerySpanResultSourceFieldPaths
	SelectAsterisk   bool
}

type YamlQuerySpanResultSourceFieldPaths struct {
	Name string
	Path string
}