Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

64.6 KB
Raw Blame
package tsql

import (
	"context"
	"reflect"
	"slices"
	"strings"
	"unicode"

	"github.com/bytebase/omni/mssql/ast"
	"github.com/pkg/errors"

	"github.com/bytebase/bytebase/backend/plugin/parser/base"
)

type querySpanExtractor struct {
	ctx context.Context

	defaultDatabase     string
	defaultSchema       string
	ignoreCaseSensitive bool

	gCtx base.GetQuerySpanContext
	// ctes records the common table expressions visible in the current scope.
	// Pushed when entering a WITH clause; truncated on exit.
	ctes []*base.PseudoTable

	// outerTableSources lets correlated subqueries resolve columns against the
	// enclosing query's FROM clause.
	outerTableSources []base.TableSource

	// tableSourcesFrom is this scope's FROM clause.
	tableSourcesFrom []base.TableSource

	predicateColumns base.SourceColumnSet

	viewResolutionStack map[string]bool
}

func newQuerySpanExtractor(defaultDatabase string, defaultSchema string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *querySpanExtractor {
	if defaultSchema == "" {
		// Fall back to the default schema `dbo`.
		// Reference: https://learn.microsoft.com/en-us/sql/relational-databases/security/authentication-access/ownership-and-user-schema-separation#the-dbo-schema
		defaultSchema = "dbo"
	}
	return &querySpanExtractor{
		defaultDatabase:     defaultDatabase,
		defaultSchema:       defaultSchema,
		gCtx:                gCtx,
		ignoreCaseSensitive: ignoreCaseSensitive,
		predicateColumns:    make(base.SourceColumnSet),
	}
}

func (q *querySpanExtractor) findTempTable(rawName string) (*base.PhysicalTable, bool) {
	for name, tempTable := range q.gCtx.TempTables {
		if q.isIdentifierEqual(rawName, name) {
			return tempTable, true
		}
	}
	return nil, false
}

// tsqlFindTableSchemaByParts resolves a (linkedServer, database, schema, table)
// tuple to a TableSource. Empty strings for database/schema mean "not specified
// by the user"; defaults are applied here when looking up metadata. CTEs
// registered in q.ctes shadow physical tables when no database/schema was
// specified.
func (q *querySpanExtractor) tsqlFindTableSchemaByParts(linkedServer, rawDatabase, rawSchema, rawTable string) (base.TableSource, error) {
	if linkedServer != "" {
		// TODO(zp): How do we handle the linked server?
		return nil, errors.Errorf("linked server is not supported yet, but found %q", linkedServer)
	}
	if strings.HasPrefix(rawTable, "#") {
		if tempTable, ok := q.findTempTable(rawTable); ok {
			return tempTable, nil
		}
		// TODO(masking): Considering SELECT * INTO #temp FROM dbo.t1; SELECT * FROM #temp. We should mask the #temp.
		return &base.PseudoTable{}, nil
	}

	// SQL Server: CTEs shadow physical tables — check first, nearest match wins.
	if rawDatabase == "" && rawSchema == "" {
		for _, cte := range q.ctes {
			if q.isIdentifierEqual(rawTable, cte.Name) {
				return cte, nil
			}
		}
	}

	database := q.defaultDatabase
	if rawDatabase != "" {
		database = rawDatabase
	}
	schema := q.defaultSchema
	if rawSchema != "" {
		schema = rawSchema
	}

	allDatabases, err := q.gCtx.ListDatabaseNamesFunc(q.ctx, q.gCtx.InstanceID)
	if err != nil {
		return nil, errors.Errorf("failed to list databases: %v", err)
	}

	for _, databaseName := range allDatabases {
		if database != "" && !q.isIdentifierEqual(database, databaseName) {
			continue
		}
		_, databaseMeta, err := q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, databaseName)
		if err != nil {
			return nil, errors.Wrapf(err, "failed to get database %s metadata", databaseName)
		}
		if databaseMeta == nil {
			return nil, errors.Errorf("database metadata for database %q not found (database not synced)", databaseName)
		}

		for _, schemaName := range databaseMeta.ListSchemaNames() {
			if schema != "" && !q.isIdentifierEqual(schema, schemaName) {
				continue
			}
			schemaSchema := databaseMeta.GetSchemaMetadata(schemaName)
			for _, tableName := range schemaSchema.ListTableNames() {
				if !q.isIdentifierEqual(rawTable, tableName) {
					continue
				}
				table := schemaSchema.GetTable(tableName)
				columns := make([]string, 0, len(table.GetProto().GetColumns()))
				for _, c := range table.GetProto().GetColumns() {
					columns = append(columns, c.Name)
				}
				return &base.PhysicalTable{
					Database: databaseName,
					Schema:   schemaName,
					Name:     table.GetProto().Name,
					Columns:  columns,
				}, nil
			}
			for _, viewName := range schemaSchema.ListViewNames() {
				if !q.isIdentifierEqual(rawTable, viewName) {
					continue
				}
				view := schemaSchema.GetView(viewName)
				viewColumns, err := q.getColumnsFromCreateView(view.Definition, databaseName, schemaName, viewName)
				if err != nil {
					return nil, errors.Wrapf(err, "failed to get columns for view %s.%s.%s", databaseName, schemaName, viewName)
				}
				return &base.PhysicalView{
					Database: databaseName,
					Schema:   schemaName,
					Name:     view.Name,
					Columns:  viewColumns,
				}, nil
			}
		}
	}
	return nil, &base.ResourceNotFoundError{
		Database: &database,
		Schema:   &schema,
		Table:    &rawTable,
	}
}

// getColumnsFromCreateView parses a CREATE VIEW definition with omni, extracts
// the body's result columns, and applies the optional column alias list.
func (q *querySpanExtractor) getColumnsFromCreateView(definition string, viewDatabaseName string, viewSchemaName string, viewName string) ([]base.QuerySpanResult, error) {
	key := tsqlViewResolutionKey(viewDatabaseName, viewSchemaName, viewName)
	if q.viewResolutionStack[key] {
		return nil, errors.Errorf("cyclic view reference detected while resolving %q", viewName)
	}

	stmts, err := ParseTSQL(definition)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to parse CREATE VIEW definition")
	}
	var createView *ast.CreateViewStmt
	for _, s := range stmts {
		if cv, ok := s.AST.(*ast.CreateViewStmt); ok {
			createView = cv
			break
		}
	}
	if createView == nil {
		return nil, errors.Errorf("no CREATE VIEW statement found in definition")
	}
	body, ok := createView.Query.(*ast.SelectStmt)
	if !ok || body == nil {
		return nil, errors.Errorf("CREATE VIEW body is not a SELECT")
	}
	var columnAliases []string
	if createView.Columns != nil {
		for _, it := range createView.Columns.Items {
			if s, ok := it.(*ast.String); ok {
				columnAliases = append(columnAliases, s.Str)
			}
		}
	}

	newQ := newOmniQuerySpanExtractor(viewDatabaseName, viewSchemaName, q.gCtx, q.ignoreCaseSensitive)
	newQ.ctx = q.ctx
	newQ.source = definition
	newQ.viewResolutionStack = cloneViewResolutionStack(q.viewResolutionStack)
	newQ.viewResolutionStack[key] = true
	pseudo, err := newQ.extractFromSelectStmt(body)
	if err != nil {
		var resourceNotFound *base.ResourceNotFoundError
		if errors.As(err, &resourceNotFound) {
			return nil, resourceNotFound
		}
		return nil, errors.Wrapf(err, "failed to extract view body")
	}
	results := pseudo.GetQuerySpanResult()

	if len(columnAliases) > 0 && len(columnAliases) == len(results) {
		for i, alias := range columnAliases {
			results[i].Name = normIdent(alias)
		}
	}
	return results, nil
}

func tsqlViewResolutionKey(databaseName, schemaName, viewName string) string {
	return databaseName + "\x00" + schemaName + "\x00" + viewName
}

func cloneViewResolutionStack(in map[string]bool) map[string]bool {
	out := make(map[string]bool, len(in))
	for k, v := range in {
		out[k] = v
	}
	return out
}

// tsqlGetAllFieldsOfTableInFromOrOuterCTE expands `table.*` to the column set
// of the matching table source in scope.
func (q *querySpanExtractor) tsqlGetAllFieldsOfTableInFromOrOuterCTE(normalizedDatabaseName, normalizedSchemaName, normalizedTableName string) ([]base.QuerySpanResult, error) {
	type maskType = uint8
	const (
		maskNone         maskType = 0
		maskDatabaseName maskType = 1 << iota
		maskSchemaName
		maskTableName
	)
	mask := maskNone
	if normalizedTableName != "" {
		mask |= maskTableName
	}
	if normalizedSchemaName != "" {
		if mask&maskTableName == 0 {
			return nil, errors.Errorf(`table name %s is specified without column name`, normalizedTableName)
		}
		mask |= maskSchemaName
	}
	if normalizedDatabaseName != "" {
		if mask&maskSchemaName == 0 {
			return nil, errors.Errorf(`database name %s is specified without schema name`, normalizedDatabaseName)
		}
		mask |= maskDatabaseName
	}

	for _, tableSource := range q.tableSourcesFrom {
		if mask&maskDatabaseName != 0 && !q.isIdentifierEqual(normalizedDatabaseName, tableSource.GetDatabaseName()) {
			continue
		}
		if mask&maskSchemaName != 0 && !q.isIdentifierEqual(normalizedSchemaName, tableSource.GetSchemaName()) {
			continue
		}
		if mask&maskTableName != 0 && !q.isIdentifierEqual(normalizedTableName, tableSource.GetTableName()) {
			continue
		}
		return tableSource.GetQuerySpanResult(), nil
	}
	return nil, errors.Errorf(`no matching table %q.%q.%q`, normalizedDatabaseName, normalizedSchemaName, normalizedTableName)
}

// tsqlIsFieldSensitive resolves a (database, schema, table, column) tuple to a
// QuerySpanResult by scanning tableSourcesFrom first, then outerTableSources
// (nearest-first) for correlated-subquery resolution.
func (q *querySpanExtractor) tsqlIsFieldSensitive(normalizedDatabaseName string, normalizedSchemaName string, normalizedTableName string, normalizedColumnName string) (base.QuerySpanResult, error) {
	type maskType = uint8
	const (
		maskNone         maskType = 0
		maskDatabaseName maskType = 1 << iota
		maskSchemaName
		maskTableName
		maskColumnName
	)
	mask := maskNone
	if normalizedColumnName != "" {
		mask |= maskColumnName
	}
	if normalizedTableName != "" {
		if mask&maskColumnName == 0 {
			return base.QuerySpanResult{}, errors.Errorf(`table name %s is specified without column name`, normalizedTableName)
		}
		mask |= maskTableName
	}
	if normalizedSchemaName != "" {
		if mask&maskTableName == 0 {
			return base.QuerySpanResult{}, errors.Errorf(`schema name %s is specified without table name`, normalizedSchemaName)
		}
		mask |= maskSchemaName
	}
	if normalizedDatabaseName != "" {
		if mask&maskSchemaName == 0 {
			return base.QuerySpanResult{}, errors.Errorf(`database name %s is specified without schema name`, normalizedDatabaseName)
		}
		mask |= maskDatabaseName
	}

	if mask == maskNone {
		return base.QuerySpanResult{}, errors.Errorf(`no object name is specified`)
	}

	// We just need to iterate through the fromFieldList sequentially until we find the first matching object.
	//
	// It is safe if there are two or more objects in the fromFieldList have the same column name, because the executor
	// will throw a compilation error if the column name is ambiguous.
	// For example, there are two tables T1 and T2, and both of them have a column named "C1". The following query will throw
	// a compilation error:
	//   SELECT C1 FROM T1, T2;
	// Users can specify the table name to disambiguate:
	//   SELECT T1.C1 FROM T1, T2;
	// If an alias is set the original table name is shadowed:
	//   SELECT T1.C1 FROM T1 AS T3, T2;  -- invalid
	for _, tableSource := range q.tableSourcesFrom {
		if mask&maskDatabaseName != 0 && !q.isIdentifierEqual(normalizedDatabaseName, tableSource.GetDatabaseName()) {
			continue
		}
		if mask&maskSchemaName != 0 && !q.isIdentifierEqual(normalizedSchemaName, tableSource.GetSchemaName()) {
			continue
		}
		if mask&maskTableName != 0 && !q.isIdentifierEqual(normalizedTableName, tableSource.GetTableName()) {
			continue
		}
		for _, column := range tableSource.GetQuerySpanResult() {
			if mask&maskColumnName != 0 && !q.isIdentifierEqual(normalizedColumnName, column.Name) {
				continue
			}
			return column, nil
		}
	}

	for i := len(q.outerTableSources) - 1; i >= 0; i-- {
		tableSource := q.outerTableSources[i]
		if mask&maskDatabaseName != 0 && !q.isIdentifierEqual(normalizedDatabaseName, tableSource.GetDatabaseName()) {
			continue
		}
		if mask&maskSchemaName != 0 && !q.isIdentifierEqual(normalizedSchemaName, tableSource.GetSchemaName()) {
			continue
		}
		if mask&maskTableName != 0 && !q.isIdentifierEqual(normalizedTableName, tableSource.GetTableName()) {
			continue
		}
		for _, column := range tableSource.GetQuerySpanResult() {
			if mask&maskColumnName != 0 && !q.isIdentifierEqual(normalizedColumnName, column.Name) {
				continue
			}
			return column, nil
		}
	}
	return base.QuerySpanResult{}, errors.Errorf(`no matching column %q.%q.%q.%q`, normalizedDatabaseName, normalizedSchemaName, normalizedTableName, normalizedColumnName)
}

// isIdentifierEqual compares identifiers using the extractor's case sensitivity flag.
func (q *querySpanExtractor) isIdentifierEqual(a, b string) bool {
	if !q.ignoreCaseSensitive {
		return a == b
	}
	if len(a) != len(b) {
		return false
	}
	runeA, runeB := []rune(a), []rune(b)
	for i := 0; i < len(runeA); i++ {
		if unicode.ToLower(runeA[i]) != unicode.ToLower(runeB[i]) {
			return false
		}
	}
	return true
}

// unionTableSources unions two or more table sources column-wise.
func unionTableSources(tableSources ...base.TableSource) ([]base.QuerySpanResult, error) {
	if len(tableSources) == 0 {
		return nil, errors.New("no table source to union")
	}

	anchor := tableSources[0].GetQuerySpanResult()
	for i := 1; i < len(tableSources); i++ {
		current := tableSources[i].GetQuerySpanResult()
		if len(current) != len(anchor) {
			return nil, errors.Errorf("the %dth table source has different column number with previous anchors, previous: %d, current %d", i+1, len(anchor), len(current))
		}
		for j := range anchor {
			anchor[j].SourceColumns, _ = base.MergeSourceColumnSet(anchor[j].SourceColumns, current[j].SourceColumns)
		}
	}
	return anchor, nil
}

// isMixedQuery reports (allSystems, mixed): mixed=true means the query touches
// both user tables and system tables simultaneously, which we treat as an
// error. allSystems=true means every accessed table is a system table.
func isMixedQuery(m base.SourceColumnSet, ignoreCaseSensitive bool) (bool, bool) {
	hasSystem, hasUser := false, false
	for table := range m {
		if isSystemResource(table, ignoreCaseSensitive) {
			hasSystem = true
		} else {
			hasUser = true
		}
	}
	if hasSystem && hasUser {
		return false, true
	}
	return !hasUser && hasSystem, false
}

func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bool {
	if IsSystemDatabase(resource.Database, !ignoreCaseSensitive) {
		return true
	}
	if IsSystemSchema(resource.Schema, !ignoreCaseSensitive) {
		return true
	}
	return false
}

// omniQuerySpanExtractor extracts query span information from omni MSSQL AST.
// It embeds querySpanExtractor so string-based resolution helpers
// (tsqlIsFieldSensitive, tsqlFindTableSchemaByParts, isIdentifierEqual,
// tsqlGetAllFieldsOfTableInFromOrOuterCTE) are reused directly.
type omniQuerySpanExtractor struct {
	*querySpanExtractor
	// source is the original SQL text, used to slice expression names via Loc.
	source string
	// setOption is the statement when it is a SET of session options.
	setOption *ast.SetOptionStmt
}

func newOmniQuerySpanExtractor(defaultDatabase, defaultSchema string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {
	return &omniQuerySpanExtractor{
		querySpanExtractor: newQuerySpanExtractor(defaultDatabase, defaultSchema, gCtx, ignoreCaseSensitive),
	}
}

// getOmniQuerySpan is the public entry point. Mirrors the ANTLR getQuerySpan flow.
func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {
	q.ctx = ctx
	q.source = statement

	stmts, err := ParseTSQL(statement)
	if err != nil {
		return nil, err
	}
	if len(stmts) == 0 {
		return &base.QuerySpan{
			Type:          base.Select,
			SourceColumns: make(base.SourceColumnSet),
			Results:       []base.QuerySpanResult{},
		}, nil
	}
	if len(stmts) != 1 {
		return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts))
	}

	root := stmts[0].AST
	if root == nil {
		// An empty statement. Match ANTLR's zero-AST behavior.
		return &base.QuerySpan{
			Type:          base.Select,
			SourceColumns: make(base.SourceColumnSet),
			Results:       []base.QuerySpanResult{},
		}, nil
	}
	if _, isGo := root.(*ast.GoStmt); isGo {
		// A bare "GO" batch separator. ANTLR discards it and returns an empty
		// Select span; match that.
		return &base.QuerySpan{
			Type:          base.Select,
			SourceColumns: make(base.SourceColumnSet),
			Results:       []base.QuerySpanResult{},
		}, nil
	}

	// DECLARE @t TABLE(...) populates gCtx.TempTables so subsequent statements
	// in the same session (the caller loops over split statements) can resolve
	// @t. Mirrors the legacy ANTLR tsqlSelectOnlyListener.EnterDeclare_statement
	// side-effect. Non-table DECLARE (plain scalar variables) is a no-op.
	if d, ok := root.(*ast.DeclareStmt); ok {
		populateOmniTempTables(d, q.gCtx.TempTables)
	}
	if set, ok := root.(*ast.SetOptionStmt); ok {
		q.setOption = set
	}
	if c, ok := root.(*ast.CreateTableStmt); ok {
		populateOmniCreateTempTable(c, q.gCtx.TempTables)
	}

	accessTables := collectOmniAccessTables(root, q.defaultDatabase, q.defaultSchema)
	allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)
	if mixed {
		return nil, base.MixUserSystemTablesError
	}

	queryType := classifyQueryType(root, allSystems)
	sel, isSelect := root.(*ast.SelectStmt)
	// classifyQueryType maps SET/DECLARE/SetOption to base.Select for historical
	// reasons; those have no result columns. Return early if the root isn't a
	// real SELECT.
	if queryType != base.Select || !isSelect {
		return &base.QuerySpan{
			Type:          queryType,
			SourceColumns: accessTables,
			Results:       []base.QuerySpanResult{},
		}, nil
	}

	pseudo, err := q.extractFromSelectStmt(sel)
	if err != nil {
		var resourceNotFound *base.ResourceNotFoundError
		if errors.As(err, &resourceNotFound) {
			return &base.QuerySpan{
				Type:          base.Select,
				SourceColumns: accessTables,
				Results:       []base.QuerySpanResult{},
				NotFoundError: resourceNotFound,
			}, nil
		}
		return nil, err
	}

	return &base.QuerySpan{
		Type:             base.Select,
		SourceColumns:    accessTables,
		Results:          pseudo.GetQuerySpanResult(),
		PredicateColumns: q.predicateColumns,
	}, nil
}

// -------------------- SELECT processing --------------------

// extractFromSelectStmt processes a full SELECT statement (including set-ops,
// WITH clause) and returns the result column set as a PseudoTable.
func (q *omniQuerySpanExtractor) extractFromSelectStmt(sel *ast.SelectStmt) (*base.PseudoTable, error) {
	// WITH clause: populate CTE list BEFORE dispatching set-ops so that both
	// arms of a `WITH cte AS (...) SELECT ... FROM cte UNION SELECT ... FROM cte`
	// see the CTE in scope. The defer restores q.ctes on exit.
	ctesSnapshot := len(q.ctes)
	defer func() { q.ctes = q.ctes[:ctesSnapshot] }()
	if sel.WithClause != nil {
		if err := q.processWithClause(sel.WithClause); err != nil {
			return nil, err
		}
	}

	// Set operations: recurse into arms and union. The WITH clause above is
	// already in q.ctes, so both arms resolve CTE references correctly.
	if sel.Op != ast.SetOpNone && (sel.Larg != nil || sel.Rarg != nil) {
		return q.extractFromSetOp(sel)
	}

	// FROM clause — a SELECT without FROM is legal (e.g. SELECT 1).
	tableSourcesSnapshot := len(q.tableSourcesFrom)
	defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()
	if sel.FromClause != nil {
		for _, item := range sel.FromClause.Items {
			ts, err := q.extractTableSource(item)
			if err != nil {
				return nil, err
			}
			q.tableSourcesFrom = append(q.tableSourcesFrom, ts...)
		}
	}

	// WHERE / HAVING predicate columns — resolved in THIS select's scope.
	// Subquery expressions encountered during the walk get cloned extractors;
	// their results merge back into q.predicateColumns. Errors (including
	// ResourceNotFoundError from a subquery referencing a missing table)
	// propagate up to getOmniQuerySpan which converts them into a span with
	// NotFoundError populated.
	if err := q.collectPredicatesInScope(sel.WhereClause); err != nil {
		return nil, err
	}
	if err := q.collectPredicatesInScope(sel.HavingClause); err != nil {
		return nil, err
	}
	if err := q.collectRowCountPredicates(sel); err != nil {
		return nil, err
	}

	// Target list.
	results, err := q.extractTargetList(sel.TargetList)
	if err != nil {
		return nil, err
	}
	q.populateSelectIntoTempTable(sel, results)

	return &base.PseudoTable{Columns: results}, nil
}

// collectPredicatesInScope walks a boolean expression in the extractor's
// current scope: plain ColumnRefs resolve against q.tableSourcesFrom +
// q.outerTableSources; subquery nodes trigger a scope clone, and the
// subquery's output-column sources plus its own predicate-column set merge
// back into q.predicateColumns.
//
// Errors from nested subquery extraction (ResourceNotFoundError or real
// parser errors) propagate so the caller can surface them via the top-level
// NotFoundError path instead of producing a silently-partial span.
func (q *omniQuerySpanExtractor) collectPredicatesInScope(expr ast.Node) error {
	if expr == nil {
		return nil
	}
	switch v := expr.(type) {
	case *ast.ColumnRef:
		if r, handled, err := q.resolvePseudoColumnRef(v); handled {
			if err != nil {
				return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)
			}
			q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)
			return nil
		}
		r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)
		if err != nil {
			return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)
		}
		q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)
		return nil
	case *ast.FullTextPredicate:
		if v.Columns != nil {
			for _, it := range v.Columns.Items {
				if cr, ok := it.(*ast.ColumnRef); ok {
					if err := q.collectPredicatesInScope(cr); err != nil {
						return err
					}
				}
			}
		}
		if err := q.collectPredicatesInScope(v.Value); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.LanguageTerm)
	case *ast.SubqueryExpr:
		return q.mergeSubqueryIntoPredicates(v.Query)
	case *ast.ExistsExpr:
		return q.mergeSubqueryIntoPredicates(v.Subquery)
	case *ast.SubqueryComparisonExpr:
		if err := q.collectPredicatesInScope(v.Left); err != nil {
			return err
		}
		return q.mergeSubqueryIntoPredicates(v.Subquery)
	case *ast.InExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		if v.List != nil {
			for _, it := range v.List.Items {
				if err := q.collectPredicatesInScope(it); err != nil {
					return err
				}
			}
		}
		return q.collectPredicatesInScope(v.Subquery)
	case *ast.BinaryExpr:
		if err := q.collectPredicatesInScope(v.Left); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.Right)
	case *ast.UnaryExpr:
		return q.collectPredicatesInScope(v.Operand)
	case *ast.BetweenExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		if err := q.collectPredicatesInScope(v.Low); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.High)
	case *ast.LikeExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		if err := q.collectPredicatesInScope(v.Pattern); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.Escape)
	case *ast.IsExpr:
		return q.collectPredicatesInScope(v.Expr)
	case *ast.CaseExpr:
		if err := q.collectPredicatesInScope(v.Arg); err != nil {
			return err
		}
		if err := q.collectPredicatesInScope(v.ElseExpr); err != nil {
			return err
		}
		if v.WhenList != nil {
			for _, it := range v.WhenList.Items {
				if cw, ok := it.(*ast.CaseWhen); ok {
					if err := q.collectPredicatesInScope(cw.Condition); err != nil {
						return err
					}
					if err := q.collectPredicatesInScope(cw.Result); err != nil {
						return err
					}
				}
			}
		}
		return nil
	case *ast.IifExpr:
		if err := q.collectPredicatesInScope(v.Condition); err != nil {
			return err
		}
		if err := q.collectPredicatesInScope(v.TrueVal); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.FalseVal)
	case *ast.CoalesceExpr:
		if v.Args != nil {
			for _, it := range v.Args.Items {
				if err := q.collectPredicatesInScope(it); err != nil {
					return err
				}
			}
		}
		return nil
	case *ast.NullifExpr:
		if err := q.collectPredicatesInScope(v.Left); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.Right)
	case *ast.FuncCallExpr:
		if v.Args != nil {
			for _, it := range v.Args.Items {
				if err := q.collectPredicatesInScope(it); err != nil {
					return err
				}
			}
		}
		return nil
	case *ast.MethodCallExpr:
		if v.Args != nil {
			for _, it := range v.Args.Items {
				if err := q.collectPredicatesInScope(it); err != nil {
					return err
				}
			}
		}
		return nil
	case *ast.CastExpr:
		return q.collectPredicatesInScope(v.Expr)
	case *ast.ConvertExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.Style)
	case *ast.TryCastExpr:
		return q.collectPredicatesInScope(v.Expr)
	case *ast.TryConvertExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.Style)
	case *ast.ParenExpr:
		return q.collectPredicatesInScope(v.Expr)
	case *ast.CollateExpr:
		return q.collectPredicatesInScope(v.Expr)
	case *ast.AtTimeZoneExpr:
		if err := q.collectPredicatesInScope(v.Expr); err != nil {
			return err
		}
		return q.collectPredicatesInScope(v.TimeZone)
	default:
		// Literal, VariableRef, StarExpr, etc. — nothing to collect.
		return nil
	}
}

// collectRowCountPredicates records what TOP, OFFSET, and FETCH read, since
// they decide how many rows come back, and the conditions of subqueries in
// ORDER BY. The ORDER BY keys themselves only order the rows.
func (q *omniQuerySpanExtractor) collectRowCountPredicates(sel *ast.SelectStmt) error {
	if sel.Top != nil {
		if err := q.collectPredicatesInScope(sel.Top.Count); err != nil {
			return err
		}
	}
	if err := q.collectPredicatesInScope(sel.OffsetClause); err != nil {
		return err
	}
	if sel.FetchClause != nil {
		if err := q.collectPredicatesInScope(sel.FetchClause.Count); err != nil {
			return err
		}
	}
	if sel.OrderByClause == nil {
		return nil
	}
	var err error
	ast.Inspect(sel.OrderByClause, func(n ast.Node) bool {
		if err != nil {
			return false
		}
		sub, ok := n.(*ast.SelectStmt)
		if !ok {
			return true
		}
		clone := q.cloneForSubquery()
		if _, err = clone.extractFromSelectStmt(sub); err == nil {
			q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
		}
		return false
	})
	return err
}

func (q *omniQuerySpanExtractor) mergeSubqueryIntoPredicates(body ast.Node) error {
	sel, ok := body.(*ast.SelectStmt)
	if !ok {
		return nil
	}
	clone := q.cloneForSubquery()
	pseudo, err := clone.extractFromSelectStmt(sel)
	if err != nil {
		return err
	}
	// Subquery output columns become outer-scope predicate columns.
	for _, c := range pseudo.GetQuerySpanResult() {
		q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, c.SourceColumns)
	}
	// And the clone's own predicate columns (from its WHERE etc.) propagate up.
	q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
	return nil
}

func (q *omniQuerySpanExtractor) extractFromSetOp(sel *ast.SelectStmt) (*base.PseudoTable, error) {
	// Omni puts the WITH clause on the leftmost set-op arm (the parser attaches
	// the WITH to the first SELECT expression, not to the outer Op node). Lift
	// it into the current scope so the CTE is visible in BOTH arms, then
	// recurse into a copy of Larg with WithClause cleared to avoid double
	// processing.
	larg := sel.Larg
	if larg != nil && larg.WithClause != nil {
		if err := q.processWithClause(larg.WithClause); err != nil {
			return nil, err
		}
		cp := *larg
		cp.WithClause = nil
		larg = &cp
	}
	left, err := q.extractFromSelectStmt(larg)
	if err != nil {
		return nil, err
	}
	right, err := q.extractFromSelectStmt(sel.Rarg)
	if err != nil {
		return nil, err
	}
	if sel.Op == ast.SetOpIntersect || sel.Op == ast.SetOpExcept {
		// INTERSECT and EXCEPT keep a row by whether the other arm has it, so
		// both arms' output columns decide which rows come back.
		for _, arm := range []base.TableSource{left, right} {
			for _, c := range arm.GetQuerySpanResult() {
				q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, c.SourceColumns)
			}
		}
	}
	merged, err := unionTableSources(left, right)
	if err != nil {
		return nil, err
	}
	return &base.PseudoTable{Columns: merged}, nil
}

func (q *omniQuerySpanExtractor) processWithClause(w *ast.WithClause) error {
	if w.CTEs == nil {
		return nil
	}
	for _, item := range w.CTEs.Items {
		cte, ok := item.(*ast.CommonTableExpr)
		if !ok {
			continue
		}
		body, ok := cte.Query.(*ast.SelectStmt)
		if !ok {
			return unsupportedNodeError("only SELECT CTE bodies are supported", cte.Query)
		}

		cteName := normIdent(cte.Name)
		cols, predicates, err := q.extractCTEBody(cteName, body)
		if err != nil {
			return err
		}
		if cte.Columns != nil && cte.Columns.Len() > 0 {
			if cte.Columns.Len() != len(cols) {
				return errors.Errorf("CTE %q column alias count %d does not match body column count %d", cte.Name, cte.Columns.Len(), len(cols))
			}
			for i, it := range cte.Columns.Items {
				if s, ok := it.(*ast.String); ok {
					cols[i].Name = normIdent(s.Str)
				}
			}
		}
		q.ctes = append(q.ctes, &base.PseudoTable{Name: cteName, Columns: cols})
		q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, predicates)
	}
	return nil
}

// extractCTEBody extracts the column set of a CTE body. For recursive CTEs
// (body is a set-op SelectStmt whose recursive arm references the CTE name),
// the extractor iterates until the column sources stabilize.
func (q *omniQuerySpanExtractor) extractCTEBody(cteName string, body *ast.SelectStmt) ([]base.QuerySpanResult, base.SourceColumnSet, error) {
	newClone := func() *omniQuerySpanExtractor {
		return &omniQuerySpanExtractor{
			querySpanExtractor: &querySpanExtractor{
				ctx:                 q.ctx,
				defaultDatabase:     q.defaultDatabase,
				defaultSchema:       q.defaultSchema,
				ignoreCaseSensitive: q.ignoreCaseSensitive,
				gCtx:                q.gCtx,
				ctes:                append([]*base.PseudoTable{}, q.ctes...),
				outerTableSources:   nil,
				predicateColumns:    make(base.SourceColumnSet),
				viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),
			},
			source: q.source,
		}
	}

	// Only UNION can be recursive; extract every other CTE directly.
	if body.Op != ast.SetOpUnion || (body.Larg == nil && body.Rarg == nil) {
		clone := newClone()
		pseudo, err := clone.extractFromSelectStmt(body)
		if err != nil {
			return nil, nil, err
		}
		return pseudo.GetQuerySpanResult(), clone.predicateColumns, nil
	}

	// Set-op CTE: extract anchor (Larg), register placeholder, then iterate Rarg
	// until the source column sets for the CTE columns stabilize.
	anchorClone := newClone()
	anchorPseudo, err := anchorClone.extractFromSelectStmt(body.Larg)
	if err != nil {
		return nil, nil, err
	}
	cols := append([]base.QuerySpanResult{}, anchorPseudo.GetQuerySpanResult()...)
	predicates := base.SourceColumnSet{}
	predicates, _ = base.MergeSourceColumnSet(predicates, anchorClone.predicateColumns)

	for iter := 0; iter < 16; iter++ {
		placeholder := &base.PseudoTable{Name: cteName, Columns: cols}
		clone := newClone()
		clone.ctes = append(clone.ctes, placeholder)
		rarg, rerr := clone.extractFromSelectStmt(body.Rarg)
		if rerr != nil {
			// Recursive arm failed to resolve (e.g. ResourceNotFoundError from
			// a missing table). Propagate — the top-level getOmniQuerySpan
			// converts ResourceNotFoundError into a span with NotFoundError
			// populated so callers don't see a silently-partial lineage.
			return nil, nil, rerr
		}
		rcols := rarg.GetQuerySpanResult()
		if len(rcols) != len(cols) {
			return nil, nil, errors.Errorf("CTE %q recursive arm returns %d columns, anchor returns %d", cteName, len(rcols), len(cols))
		}
		changed := false
		for i := range rcols {
			merged, anyChange := base.MergeSourceColumnSet(cols[i].SourceColumns, rcols[i].SourceColumns)
			cols[i].SourceColumns = merged
			if anyChange {
				changed = true
			}
		}
		predicates, _ = base.MergeSourceColumnSet(predicates, clone.predicateColumns)
		if !changed {
			break
		}
	}
	return cols, predicates, nil
}

// -------------------- FROM / table source --------------------

// extractTableSource returns the TableSource(s) produced by a single FROM item.
// A JoinClause contributes multiple sources (left + right flattened).
func (q *omniQuerySpanExtractor) extractTableSource(node ast.Node) ([]base.TableSource, error) {
	switch v := node.(type) {
	case *ast.JoinClause:
		return q.extractFromJoin(v)
	case *ast.TableRef:
		ts, err := q.resolveTableRef(v)
		if err != nil {
			return nil, err
		}
		return []base.TableSource{ts}, nil
	case *ast.AliasedTableRef:
		ts, err := q.resolveAliasedTableRef(v)
		if err != nil {
			return nil, err
		}
		return []base.TableSource{ts}, nil
	case *ast.SubqueryExpr:
		ts, err := q.resolveSubqueryAsTable(v, "")
		if err != nil {
			return nil, err
		}
		return []base.TableSource{ts}, nil
	case *ast.ValuesClause:
		ts, err := q.resolveValuesClause(v, "", nil)
		if err != nil {
			return nil, err
		}
		return []base.TableSource{ts}, nil
	case *ast.TableVarRef:
		return q.resolveTableVar(v, v.Alias)
	case *ast.TableVarMethodCallRef:
		return []base.TableSource{&base.PseudoTable{Name: v.Alias, Columns: xmlNodesColumns(v.Columns)}}, nil
	case *ast.PivotExpr:
		return nil, unsupportedTableSourceError(node)
	case *ast.UnpivotExpr:
		return nil, unsupportedTableSourceError(node)
	case *ast.FuncCallExpr:
		ts, err := q.resolveTableValuedFunction(v, "", nil)
		if err != nil {
			return nil, err
		}
		return []base.TableSource{ts}, nil
	default:
		return nil, unsupportedTableSourceError(node)
	}
}

func unsupportedTableSourceError(node ast.Node) error {
	return unsupportedNodeError("only full table name, supported TVF, derived table, values clause, and temp table in table source item are supported", node)
}

func unsupportedNodeError(message string, node ast.Node) error {
	typeName := "<nil>"
	if typ := reflect.TypeOf(node); typ != nil {
		typeName = typ.String()
	}
	return &base.TypeNotSupportedError{
		Err:  errors.New(message),
		Type: typeName,
	}
}

func (q *omniQuerySpanExtractor) extractFromJoin(j *ast.JoinClause) ([]base.TableSource, error) {
	tableSourcesSnapshot := len(q.tableSourcesFrom)
	defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()
	left, err := q.extractTableSource(j.Left)
	if err != nil {
		return nil, err
	}
	if j.Type == ast.JoinCrossApply || j.Type == ast.JoinOuterApply {
		q.tableSourcesFrom = append(q.tableSourcesFrom, left...)
	}
	right, err := q.extractTableSource(j.Right)
	if err != nil {
		return nil, err
	}
	if j.Condition != nil {
		q.tableSourcesFrom = append(q.tableSourcesFrom[:tableSourcesSnapshot], left...)
		q.tableSourcesFrom = append(q.tableSourcesFrom, right...)
		if err := q.collectPredicatesInScope(j.Condition); err != nil {
			return nil, err
		}
	}
	return append(left, right...), nil
}

func (q *omniQuerySpanExtractor) resolveTableRef(t *ast.TableRef) (base.TableSource, error) {
	ts, err := q.tsqlFindTableSchemaByParts(t.Server, t.Database, t.Schema, t.Object)
	if err != nil {
		return nil, err
	}
	if t.Alias != "" {
		ts = &base.PseudoTable{
			Name:    normIdent(t.Alias),
			Columns: ts.GetQuerySpanResult(),
		}
	}
	return ts, nil
}

func (q *omniQuerySpanExtractor) resolveAliasedTableRef(at *ast.AliasedTableRef) (base.TableSource, error) {
	var columnAliases []string
	if at.Columns != nil {
		for _, it := range at.Columns.Items {
			if s, ok := it.(*ast.String); ok {
				columnAliases = append(columnAliases, s.Str)
			}
		}
	}
	switch inner := at.Table.(type) {
	case *ast.TableRef:
		ts, err := q.tsqlFindTableSchemaByParts(inner.Server, inner.Database, inner.Schema, inner.Object)
		if err != nil {
			return nil, err
		}
		cols := append([]base.QuerySpanResult{}, ts.GetQuerySpanResult()...)
		if err := applyColumnAliases(cols, columnAliases); err != nil {
			return nil, err
		}
		name := inner.Object
		if at.Alias != "" {
			name = at.Alias
		}
		return &base.PseudoTable{Name: name, Columns: cols}, nil
	case *ast.SubqueryExpr:
		return q.resolveSubqueryAsTable(inner, at.Alias, columnAliases...)
	case *ast.ValuesClause:
		return q.resolveValuesClause(inner, at.Alias, columnAliases)
	case *ast.TableVarRef:
		inners, err := q.resolveTableVar(inner, at.Alias)
		if err != nil {
			return nil, err
		}
		if len(inners) == 1 {
			return inners[0], nil
		}
		return nil, unsupportedNodeError("aliased table variable must produce a single table source", at.Table)
	case *ast.FuncCallExpr:
		return q.resolveTableValuedFunction(inner, at.Alias, columnAliases)
	case *ast.TableVarMethodCallRef:
		cols := xmlNodesColumns(inner.Columns)
		if err := applyColumnAliases(cols, columnAliases); err != nil {
			return nil, err
		}
		return &base.PseudoTable{Name: normIdent(at.Alias), Columns: cols}, nil
	default:
		return nil, unsupportedNodeError("unsupported aliased table source item", at.Table)
	}
}

func (q *omniQuerySpanExtractor) resolveTableValuedFunction(fn *ast.FuncCallExpr, alias string, columnAliases []string) (base.TableSource, error) {
	if fn == nil || fn.Name == nil {
		return nil, unsupportedTableSourceError(fn)
	}
	var columnNames []string
	switch strings.ToUpper(fn.Name.Object) {
	case "STRING_SPLIT":
		columnNames = []string{"value"}
		hasOrdinal, err := stringSplitHasOrdinalColumn(fn.Args)
		if err != nil {
			return nil, err
		}
		if hasOrdinal {
			columnNames = append(columnNames, "ordinal")
		}
	case "OPENJSON":
		columnNames = []string{"key", "value", "type"}
	default:
		return nil, unsupportedTableSourceError(fn)
	}

	argSources, err := q.mergeListSources(fn.Args)
	if err != nil {
		return nil, err
	}
	// The arguments decide how many rows the function returns.
	q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, argSources.SourceColumns)
	columns := make([]base.QuerySpanResult, 0, len(columnNames))
	for _, name := range columnNames {
		columns = append(columns, base.QuerySpanResult{
			Name:          name,
			SourceColumns: argSources.SourceColumns,
		})
	}
	if strings.EqualFold(fn.Name.Object, "STRING_SPLIT") && len(columns) > 1 {
		columns[1].SourceColumns = make(base.SourceColumnSet)
	}
	if err := applyColumnAliases(columns, columnAliases); err != nil {
		return nil, err
	}
	return &base.PseudoTable{Name: normIdent(alias), Columns: columns}, nil
}

func stringSplitHasOrdinalColumn(args *ast.List) (bool, error) {
	if args == nil || args.Len() < 3 {
		return false, nil
	}
	arg := args.Items[2]
	for {
		paren, ok := arg.(*ast.ParenExpr)
		if !ok {
			break
		}
		arg = paren.Expr
	}
	literal, ok := arg.(*ast.Literal)
	if !ok {
		return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)
	}
	switch literal.Type {
	case ast.LitInteger:
		switch literal.Ival {
		case 0:
			return false, nil
		case 1:
			return true, nil
		default:
			return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be 0 or 1", arg)
		}
	case ast.LitNull:
		return false, nil
	default:
		return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)
	}
}

func (q *omniQuerySpanExtractor) resolveSubqueryAsTable(sq *ast.SubqueryExpr, alias string, columnAliases ...string) (base.TableSource, error) {
	body, ok := sq.Query.(*ast.SelectStmt)
	if !ok {
		return nil, unsupportedNodeError("only SELECT subqueries in table source are supported", sq.Query)
	}
	clone := q.cloneForSubquery()
	pseudo, err := clone.extractFromSelectStmt(body)
	if err != nil {
		return nil, err
	}
	cols := append([]base.QuerySpanResult{}, pseudo.GetQuerySpanResult()...)
	if err := applyColumnAliases(cols, columnAliases); err != nil {
		return nil, err
	}
	q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
	return &base.PseudoTable{Name: normIdent(alias), Columns: cols}, nil
}

func (q *omniQuerySpanExtractor) resolveValuesClause(vc *ast.ValuesClause, alias string, columnAliases []string) (base.TableSource, error) {
	name := normIdent(alias)
	if vc.Rows == nil || vc.Rows.Len() == 0 {
		return &base.PseudoTable{Name: name}, nil
	}
	firstRow, ok := vc.Rows.Items[0].(*ast.List)
	if !ok {
		return &base.PseudoTable{Name: name}, nil
	}
	cols := make([]base.QuerySpanResult, 0, firstRow.Len())
	for rowIndex, item := range vc.Rows.Items {
		row, ok := item.(*ast.List)
		if !ok {
			continue
		}
		if row.Len() != firstRow.Len() {
			return nil, errors.Errorf("VALUES row %d has %d columns, first row has %d", rowIndex+1, row.Len(), firstRow.Len())
		}
		for i, it := range row.Items {
			expr, ok := it.(ast.ExprNode)
			if !ok {
				if rowIndex == 0 {
					cols = append(cols, base.QuerySpanResult{})
				}
				continue
			}
			r, err := q.resolveExpression(expr)
			if err != nil {
				return nil, err
			}
			if rowIndex == 0 {
				cols = append(cols, r)
				continue
			}
			cols[i].SourceColumns, _ = base.MergeSourceColumnSet(cols[i].SourceColumns, r.SourceColumns)
		}
	}
	if err := applyColumnAliases(cols, columnAliases); err != nil {
		return nil, err
	}
	return &base.PseudoTable{Name: name, Columns: cols}, nil
}

func (q *omniQuerySpanExtractor) resolveTableVar(tv *ast.TableVarRef, alias string) ([]base.TableSource, error) {
	if tv == nil {
		return nil, nil
	}
	name := tv.Name
	if temp, ok := q.findTempTable(name); ok {
		tableName := name
		if alias != "" {
			tableName = alias
		}
		cols := make([]base.QuerySpanResult, 0, len(temp.Columns))
		for _, c := range temp.Columns {
			cols = append(cols, base.QuerySpanResult{
				Name: c,
				SourceColumns: base.SourceColumnSet{
					base.ColumnResource{
						Server:   temp.Server,
						Database: temp.Database,
						Schema:   temp.Schema,
						Table:    temp.Name,
						Column:   c,
					}: true,
				},
				IsPlainField: true,
			})
		}
		return []base.TableSource{&base.PseudoTable{Name: tableName, Columns: cols}}, nil
	}
	return nil, &base.ResourceNotFoundError{
		Table: &name,
		Err:   errors.Errorf("temp table %s not found", name),
	}
}

// populateOmniTempTables mirrors the ANTLR tempTableColumnDefinitionListener:
// for each VariableDecl of table type, build a PhysicalTable keyed by the
// variable name (including the leading '@') and store it in the shared map.
func populateOmniTempTables(d *ast.DeclareStmt, out map[string]*base.PhysicalTable) {
	if d == nil || d.Variables == nil || out == nil {
		return
	}
	for _, it := range d.Variables.Items {
		v, ok := it.(*ast.VariableDecl)
		if !ok || !v.IsTable || v.TableDef == nil {
			continue
		}
		columns := make([]string, 0, v.TableDef.Len())
		for _, cdef := range v.TableDef.Items {
			if cd, ok := cdef.(*ast.ColumnDef); ok {
				columns = append(columns, cd.Name)
			}
		}
		out[v.Name] = &base.PhysicalTable{
			Name:    v.Name,
			Columns: columns,
		}
	}
}

func populateOmniCreateTempTable(c *ast.CreateTableStmt, out map[string]*base.PhysicalTable) {
	if c == nil || c.Name == nil || out == nil || !strings.HasPrefix(c.Name.Object, "#") {
		return
	}
	var columns []string
	if c.Columns != nil {
		columns = make([]string, 0, c.Columns.Len())
		for _, item := range c.Columns.Items {
			if cd, ok := item.(*ast.ColumnDef); ok {
				columns = append(columns, cd.Name)
			}
		}
	}
	out[c.Name.Object] = &base.PhysicalTable{
		Name:    c.Name.Object,
		Columns: columns,
	}
}

func (q *omniQuerySpanExtractor) populateSelectIntoTempTable(sel *ast.SelectStmt, results []base.QuerySpanResult) {
	if sel == nil || sel.IntoTable == nil || q.gCtx.TempTables == nil || !strings.HasPrefix(sel.IntoTable.Object, "#") {
		return
	}
	columns := make([]string, 0, len(results))
	for i, result := range results {
		name := result.Name
		if name == "" && sel.TargetList != nil && i < len(sel.TargetList.Items) {
			name = q.sliceName(sel.TargetList.Items[i])
		}
		columns = append(columns, name)
	}
	q.gCtx.TempTables[sel.IntoTable.Object] = &base.PhysicalTable{
		Name:    sel.IntoTable.Object,
		Columns: columns,
	}
}

func xmlNodesColumns(cols []string) []base.QuerySpanResult {
	out := make([]base.QuerySpanResult, 0, len(cols))
	for _, c := range cols {
		out = append(out, base.QuerySpanResult{Name: c})
	}
	return out
}

func applyColumnAliases(cols []base.QuerySpanResult, aliases []string) error {
	if len(aliases) == 0 {
		return nil
	}
	if len(aliases) != len(cols) {
		return errors.Errorf("column alias count %d does not match column count %d", len(aliases), len(cols))
	}
	for i, name := range aliases {
		cols[i].Name = normIdent(name)
	}
	return nil
}

func (q *omniQuerySpanExtractor) cloneForSubquery() *omniQuerySpanExtractor {
	clone := &omniQuerySpanExtractor{
		querySpanExtractor: &querySpanExtractor{
			ctx:                 q.ctx,
			defaultDatabase:     q.defaultDatabase,
			defaultSchema:       q.defaultSchema,
			ignoreCaseSensitive: q.ignoreCaseSensitive,
			gCtx:                q.gCtx,
			ctes:                append([]*base.PseudoTable{}, q.ctes...),
			outerTableSources:   slices.Concat(q.outerTableSources, q.tableSourcesFrom),
			predicateColumns:    make(base.SourceColumnSet),
			viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),
		},
		source: q.source,
	}
	return clone
}

// -------------------- Target list --------------------

func (q *omniQuerySpanExtractor) extractTargetList(list *ast.List) ([]base.QuerySpanResult, error) {
	if list == nil {
		return nil, nil
	}
	var results []base.QuerySpanResult
	for _, item := range list.Items {
		switch v := item.(type) {
		case *ast.ResTarget:
			if star, ok := v.Val.(*ast.StarExpr); ok {
				fields, err := q.expandStar(star)
				if err != nil {
					return nil, err
				}
				results = append(results, fields...)
				continue
			}
			r, err := q.resolveExpression(v.Val)
			if err != nil {
				return nil, err
			}
			if v.Name != "" {
				r.Name = normIdent(v.Name)
			}
			results = append(results, r)
		case *ast.StarExpr:
			fields, err := q.expandStar(v)
			if err != nil {
				return nil, err
			}
			results = append(results, fields...)
		case *ast.SelectAssign:
			// SELECT @v = expr — no result column produced; just fold the expr
			// for predicate/source tracking (omitted here since it doesn't emit a column).
			continue
		default:
			if expr, ok := item.(ast.ExprNode); ok {
				r, err := q.resolveExpression(expr)
				if err != nil {
					return nil, err
				}
				results = append(results, r)
				continue
			}
			return nil, unsupportedNodeError("unsupported SELECT target item", item)
		}
	}
	return results, nil
}

func (q *omniQuerySpanExtractor) expandStar(s *ast.StarExpr) ([]base.QuerySpanResult, error) {
	if s.Qualifier == "" {
		var out []base.QuerySpanResult
		for _, ts := range q.tableSourcesFrom {
			out = append(out, ts.GetQuerySpanResult()...)
		}
		return out, nil
	}
	return q.tsqlGetAllFieldsOfTableInFromOrOuterCTE("", "", s.Qualifier)
}

// -------------------- Expression resolver --------------------

// resolveExpression maps an omni ExprNode to a QuerySpanResult. This is the
// omni equivalent of the ANTLR getQuerySpanResultFromExpr.
func (q *omniQuerySpanExtractor) resolveExpression(expr ast.ExprNode) (base.QuerySpanResult, error) {
	return q.resolveExpressionNode(expr)
}

func (q *omniQuerySpanExtractor) resolveExpressionNode(n ast.Node) (base.QuerySpanResult, error) {
	if n == nil {
		return base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}, nil
	}
	if r, handled, err := q.resolveSimpleExpressionNode(n); handled {
		return r, err
	}
	switch v := n.(type) {
	case *ast.ColumnRef:
		if r, handled, err := q.resolvePseudoColumnRef(v); handled {
			if err != nil {
				return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)
			}
			return r, nil
		}
		r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)
		if err != nil {
			return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)
		}
		r.IsPlainField = true
		return r, nil
	case *ast.AtTimeZoneExpr:
		r, err := q.mergeExprSources(v.Expr, v.TimeZone)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.BinaryExpr:
		r, err := q.mergeExprSources(v.Left, v.Right)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.UnaryExpr:
		r, err := q.resolveExpressionNode(v.Operand)
		if err != nil {
			return r, err
		}
		r.Name = q.sliceName(n)
		r.IsPlainField = false
		return r, nil
	case *ast.BetweenExpr:
		r, err := q.mergeExprSources(v.Expr, v.Low, v.High)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.LikeExpr:
		r, err := q.mergeExprSources(v.Expr, v.Pattern, v.Escape)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.IsExpr:
		r, err := q.resolveExpressionNode(v.Expr)
		if err != nil {
			return r, err
		}
		r.Name = q.sliceName(n)
		r.IsPlainField = false
		return r, nil
	case *ast.InExpr:
		exprs := []ast.ExprNode{v.Expr}
		if v.List != nil {
			for _, it := range v.List.Items {
				if e, ok := it.(ast.ExprNode); ok {
					exprs = append(exprs, e)
				}
			}
		}
		if v.Subquery != nil {
			exprs = append(exprs, v.Subquery)
		}
		r, err := q.mergeExprSources(exprs...)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.CaseExpr:
		exprs := []ast.ExprNode{v.Arg, v.ElseExpr}
		if v.WhenList != nil {
			for _, it := range v.WhenList.Items {
				if cw, ok := it.(*ast.CaseWhen); ok {
					exprs = append(exprs, cw.Condition, cw.Result)
				}
			}
		}
		r, err := q.mergeExprSources(exprs...)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.IifExpr:
		r, err := q.mergeExprSources(v.Condition, v.TrueVal, v.FalseVal)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.CoalesceExpr:
		r, err := q.mergeListSources(v.Args)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.NullifExpr:
		r, err := q.mergeExprSources(v.Left, v.Right)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.FuncCallExpr:
		r, err := q.mergeListSources(v.Args)
		if err != nil {
			return r, err
		}
		// Also merge Over clause partition/order.
		if v.Over != nil {
			sub, err := q.mergeListSources(v.Over.PartitionBy)
			if err != nil {
				return r, err
			}
			r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
			sub, err = q.mergeOrderBySources(v.Over.OrderBy)
			if err != nil {
				return r, err
			}
			r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
		}
		if v.Within != nil {
			sub, err := q.mergeOrderBySources(v.Within)
			if err != nil {
				return r, err
			}
			r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
		}
		r.Name = q.sliceName(n)
		return r, nil
	case *ast.MethodCallExpr:
		r, err := q.mergeListSources(v.Args)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.CastExpr:
		r, err := q.resolveExpressionNode(v.Expr)
		if err != nil {
			return r, err
		}
		r.Name = q.sliceName(n)
		r.IsPlainField = false
		return r, nil
	case *ast.ConvertExpr:
		r, err := q.mergeExprSources(v.Expr, v.Style)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.TryCastExpr:
		r, err := q.resolveExpressionNode(v.Expr)
		if err != nil {
			return r, err
		}
		r.Name = q.sliceName(n)
		r.IsPlainField = false
		return r, nil
	case *ast.TryConvertExpr:
		r, err := q.mergeExprSources(v.Expr, v.Style)
		r.Name = q.sliceName(n)
		return r, err
	case *ast.SubqueryExpr:
		return q.resolveSubqueryExpr(v)
	case *ast.SubqueryComparisonExpr:
		r, err := q.resolveExpressionNode(v.Left)
		if err != nil {
			return r, err
		}
		if body, ok := v.Subquery.(*ast.SelectStmt); ok {
			clone := q.cloneForSubquery()
			sub, subErr := clone.extractFromSelectStmt(body)
			if subErr != nil {
				return r, subErr
			}
			for _, sc := range sub.GetQuerySpanResult() {
				r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sc.SourceColumns)
			}
			q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
		}
		r.Name = q.sliceName(n)
		r.IsPlainField = false
		return r, nil
	case *ast.ExistsExpr:
		r := base.QuerySpanResult{
			Name:          q.sliceName(n),
			SourceColumns: make(base.SourceColumnSet),
		}
		if body, ok := v.Subquery.(*ast.SelectStmt); ok {
			clone := q.cloneForSubquery()
			if _, err := clone.extractFromSelectStmt(body); err != nil {
				return r, err
			}
			q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
		}
		return r, nil
	case *ast.FullTextPredicate:
		r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}
		if v.Columns != nil {
			for _, it := range v.Columns.Items {
				if cr, ok := it.(*ast.ColumnRef); ok {
					sub, err := q.tsqlIsFieldSensitive(cr.Database, cr.Schema, cr.Table, cr.Column)
					if err != nil {
						return r, errors.Wrapf(err, "failed to resolve full-text predicate column %q", cr.Column)
					}
					r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
				}
			}
		}
		if v.Value != nil {
			sub, err := q.resolveExpressionNode(v.Value)
			if err != nil {
				return r, err
			}
			r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
		}
		r.Name = q.sliceName(n)
		return r, nil
	case *ast.StarExpr:
		// Star in scalar context: treat as empty (already handled at target-list level).
		return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil
	case *ast.GroupingSetsExpr, *ast.RollupExpr, *ast.CubeExpr:
		// Appear in GROUP BY; not typical targets. Fallback to empty.
		return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil
	case *ast.ResTarget:
		r, err := q.resolveExpressionNode(v.Val)
		if err != nil {
			return r, err
		}
		if v.Name != "" {
			r.Name = v.Name
		}
		return r, nil
	case *ast.SelectAssign:
		return q.resolveExpressionNode(v.Value)
	case *ast.CaseWhen:
		return q.mergeExprSources(v.Condition, v.Result)
	case *ast.CurrentOfExpr:
		return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil
	default:
		return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil
	}
}

func (q *omniQuerySpanExtractor) resolveSimpleExpressionNode(n ast.Node) (base.QuerySpanResult, bool, error) {
	switch v := n.(type) {
	case *ast.Literal, *ast.VariableRef, *ast.Boolean:
		return base.QuerySpanResult{Name: q.sliceName(v), SourceColumns: make(base.SourceColumnSet)}, true, nil
	case *ast.ParenExpr:
		r, err := q.resolveExpressionNode(v.Expr)
		return r, true, err
	case *ast.CollateExpr:
		r, err := q.resolveExpressionNode(v.Expr)
		return r, true, err
	default:
		return base.QuerySpanResult{}, false, nil
	}
}

func (q *omniQuerySpanExtractor) resolveSubqueryExpr(sq *ast.SubqueryExpr) (base.QuerySpanResult, error) {
	r := base.QuerySpanResult{
		Name:          q.sliceName(sq),
		SourceColumns: make(base.SourceColumnSet),
	}
	body, ok := sq.Query.(*ast.SelectStmt)
	if !ok {
		return r, nil
	}
	clone := q.cloneForSubquery()
	pseudo, err := clone.extractFromSelectStmt(body)
	if err != nil {
		return r, err
	}
	// Scalar subquery contributes its first result column's source columns.
	results := pseudo.GetQuerySpanResult()
	for _, c := range results {
		r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, c.SourceColumns)
	}
	q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)
	return r, nil
}

func (q *omniQuerySpanExtractor) mergeExprSources(exprs ...ast.ExprNode) (base.QuerySpanResult, error) {
	r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}
	for _, e := range exprs {
		if e == nil {
			continue
		}
		sub, err := q.resolveExpressionNode(e)
		if err != nil {
			return r, err
		}
		r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
	}
	return r, nil
}

func (q *omniQuerySpanExtractor) mergeListSources(list *ast.List) (base.QuerySpanResult, error) {
	r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}
	if list == nil {
		return r, nil
	}
	for _, it := range list.Items {
		if e, ok := it.(ast.ExprNode); ok {
			sub, err := q.resolveExpressionNode(e)
			if err != nil {
				return r, err
			}
			r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
		}
	}
	return r, nil
}

func (q *omniQuerySpanExtractor) mergeOrderBySources(list *ast.List) (base.QuerySpanResult, error) {
	r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}
	if list == nil {
		return r, nil
	}
	for _, it := range list.Items {
		var expr ast.Node
		switch v := it.(type) {
		case *ast.OrderByItem:
			expr = v.Expr
		case ast.ExprNode:
			expr = v
		default:
			return r, unsupportedNodeError("unsupported ORDER BY item", it)
		}
		sub, err := q.resolveExpressionNode(expr)
		if err != nil {
			return r, err
		}
		r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)
	}
	return r, nil
}

// -------------------- Helpers --------------------

// sliceName returns the whitespace-stripped source text covering a node's Loc.
// Mirrors ANTLR's ctx.GetText() convention for naming expression results.
// For *SubqueryExpr (and similar paren-wrapped nodes) the Loc spans the
// surrounding parens; we strip a matching leading `(` / trailing `)` pair to
// match the ANTLR subquery.getText() output.
func (q *omniQuerySpanExtractor) sliceName(n ast.Node) string {
	loc := omniNodeLoc(n)
	if loc.Start < 0 || loc.End < 0 || loc.Start >= len(q.source) {
		return ""
	}
	end := loc.End
	if end > len(q.source) {
		end = len(q.source)
	}
	text := stripSpaces(q.source[loc.Start:end])
	switch n.(type) {
	case *ast.SubqueryExpr, *ast.ExistsExpr, *ast.SubqueryComparisonExpr:
		if len(text) >= 2 && text[0] == '(' && text[len(text)-1] == ')' {
			text = text[1 : len(text)-1]
		}
	default:
	}
	return text
}

func stripSpaces(s string) string {
	var b strings.Builder
	b.Grow(len(s))
	for _, r := range s {
		if !unicode.IsSpace(r) {
			b.WriteRune(r)
		}
	}
	return b.String()
}

// normIdent lowercases a SQL-text-sourced identifier (table alias, column
// alias, CTE name, ResTarget name). Matches the legacy ANTLR
// NormalizeTSQLIdentifier behavior which lowercases unconditionally. Does not
// apply to identifiers sourced from metadata (physical table/column names);
// those are compared case-insensitively but stored as-is.
func normIdent(s string) string {
	return strings.ToLower(s)
}

// omniNodeLoc extracts the Loc field from an ast.Node via type switching.
// Not every node has a Loc (the Node interface doesn't expose it), so we
// enumerate the types we care about. Returns zero Loc otherwise.
func omniNodeLoc(n ast.Node) ast.Loc {
	if n == nil {
		return ast.NoLoc()
	}
	if loc, ok := omniExpressionNodeLoc(n); ok {
		return loc
	}
	switch v := n.(type) {
	case *ast.SelectStmt:
		return v.Loc
	case *ast.TableRef:
		return v.Loc
	case *ast.ResTarget:
		return v.Loc
	case *ast.SelectAssign:
		return v.Loc
	default:
		return ast.NoLoc()
	}
}

func omniExpressionNodeLoc(n ast.Node) (ast.Loc, bool) {
	switch v := n.(type) {
	case *ast.ColumnRef:
		return v.Loc, true
	case *ast.Literal:
		return v.Loc, true
	case *ast.VariableRef:
		return v.Loc, true
	case *ast.StarExpr:
		return v.Loc, true
	case *ast.BinaryExpr:
		return v.Loc, true
	case *ast.UnaryExpr:
		return v.Loc, true
	case *ast.BetweenExpr:
		return v.Loc, true
	case *ast.LikeExpr:
		return v.Loc, true
	case *ast.IsExpr:
		return v.Loc, true
	case *ast.InExpr:
		return v.Loc, true
	case *ast.CaseExpr:
		return v.Loc, true
	case *ast.CaseWhen:
		return v.Loc, true
	case *ast.IifExpr:
		return v.Loc, true
	case *ast.CoalesceExpr:
		return v.Loc, true
	case *ast.NullifExpr:
		return v.Loc, true
	case *ast.FuncCallExpr:
		return v.Loc, true
	case *ast.MethodCallExpr:
		return v.Loc, true
	case *ast.CastExpr:
		return v.Loc, true
	case *ast.ConvertExpr:
		return v.Loc, true
	case *ast.TryCastExpr:
		return v.Loc, true
	case *ast.TryConvertExpr:
		return v.Loc, true
	case *ast.SubqueryExpr:
		return v.Loc, true
	case *ast.SubqueryComparisonExpr:
		return v.Loc, true
	case *ast.ExistsExpr:
		return v.Loc, true
	case *ast.FullTextPredicate:
		return v.Loc, true
	case *ast.ParenExpr:
		return v.Loc, true
	case *ast.CollateExpr:
		return v.Loc, true
	case *ast.AtTimeZoneExpr:
		return v.Loc, true
	default:
		return ast.NoLoc(), false
	}
}

// -------------------- Access tables --------------------

// collectOmniAccessTables walks the AST and records every table-source
// position reference. Mirrors the ANTLR accessTableListener.
func collectOmniAccessTables(root ast.Node, currentDatabase, currentSchema string) base.SourceColumnSet {
	out := make(base.SourceColumnSet)
	walkAccessTables(root, currentDatabase, currentSchema, out)
	return out
}

func walkTableList(list *ast.List, db, schema string, out base.SourceColumnSet) {
	if list == nil {
		return
	}
	for _, it := range list.Items {
		walkAccessTables(it, db, schema, out)
	}
}

func walkAccessTables(n ast.Node, db, schema string, out base.SourceColumnSet) {
	if n == nil {
		return
	}
	switch v := n.(type) {
	case *ast.SelectStmt:
		if v.WithClause != nil {
			walkAccessTables(v.WithClause, db, schema, out)
		}
		if v.FromClause != nil {
			for _, it := range v.FromClause.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
		if v.WhereClause != nil {
			walkAccessTables(v.WhereClause, db, schema, out)
		}
		if v.HavingClause != nil {
			walkAccessTables(v.HavingClause, db, schema, out)
		}
		if v.TargetList != nil {
			for _, it := range v.TargetList.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
		if v.Larg != nil {
			walkAccessTables(v.Larg, db, schema, out)
		}
		if v.Rarg != nil {
			walkAccessTables(v.Rarg, db, schema, out)
		}
		if v.OrderByClause != nil {
			for _, it := range v.OrderByClause.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
	case *ast.OrderByItem:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.InsertStmt:
		walkAccessTables(v.Relation, db, schema, out)
		walkAccessTables(v.Source, db, schema, out)
	case *ast.UpdateStmt:
		walkAccessTables(v.Relation, db, schema, out)
		walkTableList(v.FromClause, db, schema, out)
		walkAccessTables(v.WhereClause, db, schema, out)
	case *ast.DeleteStmt:
		walkAccessTables(v.Relation, db, schema, out)
		walkTableList(v.FromClause, db, schema, out)
		walkAccessTables(v.WhereClause, db, schema, out)
	case *ast.MergeStmt:
		walkAccessTables(v.Target, db, schema, out)
		walkAccessTables(v.Source, db, schema, out)
	case *ast.WithClause:
		if v.CTEs != nil {
			for _, it := range v.CTEs.Items {
				if c, ok := it.(*ast.CommonTableExpr); ok {
					walkAccessTables(c.Query, db, schema, out)
				}
			}
		}
	case *ast.TableRef:
		addAccessTable(v, db, schema, out)
	case *ast.AliasedTableRef:
		walkAccessTables(v.Table, db, schema, out)
	case *ast.JoinClause:
		walkAccessTables(v.Left, db, schema, out)
		walkAccessTables(v.Right, db, schema, out)
		if v.Condition != nil {
			walkAccessTables(v.Condition, db, schema, out)
		}
	case *ast.SubqueryExpr:
		walkAccessTables(v.Query, db, schema, out)
	case *ast.PivotExpr:
		walkAccessTables(v.Source, db, schema, out)
	case *ast.UnpivotExpr:
		walkAccessTables(v.Source, db, schema, out)
	case *ast.ExistsExpr:
		walkAccessTables(v.Subquery, db, schema, out)
	case *ast.SubqueryComparisonExpr:
		walkAccessTables(v.Left, db, schema, out)
		walkAccessTables(v.Subquery, db, schema, out)
	case *ast.InExpr:
		walkAccessTables(v.Expr, db, schema, out)
		if v.List != nil {
			for _, it := range v.List.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
		walkAccessTables(v.Subquery, db, schema, out)
	case *ast.BinaryExpr:
		walkAccessTables(v.Left, db, schema, out)
		walkAccessTables(v.Right, db, schema, out)
	case *ast.UnaryExpr:
		walkAccessTables(v.Operand, db, schema, out)
	case *ast.BetweenExpr:
		walkAccessTables(v.Expr, db, schema, out)
		walkAccessTables(v.Low, db, schema, out)
		walkAccessTables(v.High, db, schema, out)
	case *ast.LikeExpr:
		walkAccessTables(v.Expr, db, schema, out)
		walkAccessTables(v.Pattern, db, schema, out)
	case *ast.IsExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.CaseExpr:
		walkAccessTables(v.Arg, db, schema, out)
		walkAccessTables(v.ElseExpr, db, schema, out)
		if v.WhenList != nil {
			for _, it := range v.WhenList.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
	case *ast.CaseWhen:
		walkAccessTables(v.Condition, db, schema, out)
		walkAccessTables(v.Result, db, schema, out)
	case *ast.ParenExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.CastExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.ConvertExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.TryCastExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.TryConvertExpr:
		walkAccessTables(v.Expr, db, schema, out)
	case *ast.FuncCallExpr:
		if v.Args != nil {
			for _, it := range v.Args.Items {
				walkAccessTables(it, db, schema, out)
			}
		}
	case *ast.ResTarget:
		walkAccessTables(v.Val, db, schema, out)
	case *ast.ValuesClause:
		// No table access.
	case *ast.TableVarRef, *ast.TableVarMethodCallRef:
		// Temp-table var: no physical access.
	default:
	}
}

func addAccessTable(t *ast.TableRef, defDB, defSchema string, out base.SourceColumnSet) {
	if t == nil || strings.HasPrefix(t.Object, "#") {
		return
	}
	database := defDB
	if t.Database != "" {
		database = t.Database
	}
	schema := defSchema
	if t.Schema != "" {
		schema = t.Schema
	}
	out[base.ColumnResource{
		Server:   t.Server,
		Database: database,
		Schema:   schema,
		Table:    t.Object,
	}] = true
}