Function walkNode

transpiler/transform/transform.go:76–300

walkNode recursively walks a node and its children

(node *pg_query.Node, fn func(*pg_query.Node) bool)

	// final query. When populated, the normal deparse result should be ignored.
	Statements []string

	// CleanupStatements contains statements to execute after obtaining the cursor
	// for the final query but before streaming results. Typically DROP TEMP TABLE
	// and COMMIT statements. Execute these with best-effort (ignore errors).
	CleanupStatements []string
}

// Transform defines the interface for SQL transformations.
// Each transform modifies the AST in place and can set result metadata.
type Transform interface {
	// Name returns the transform identifier for logging/debugging
	Name() string

	// Transform modifies the AST in place.
	// Returns true if any changes were made.
	// The result parameter can be used to set metadata like IsNoOp.
	Transform(tree *pg_query.ParseResult, result *Result) (changed bool, err error)
}

// WalkFunc walks all nodes in a ParseResult and calls fn for each.
// If fn returns false, walking stops.
func WalkFunc(tree *pg_query.ParseResult, fn func(node *pg_query.Node) bool) {
	for _, stmt := range tree.Stmts {
		if stmt.Stmt != nil {
			walkNode(stmt.Stmt, fn)
		}
	}
}

// walkNode recursively walks a node and its children
func walkNode(node *pg_query.Node, fn func(*pg_query.Node) bool) bool {
	if node == nil {
		return true
	}

	if !fn(node) {
		return false
	}

	// Walk children based on node type
	// pg_query uses a union type, so we need to check each possibility
	switch n := node.Node.(type) {
	case *pg_query.Node_SelectStmt:
		if n.SelectStmt != nil {
			walkSelectStmt(n.SelectStmt, fn)
		}
	case *pg_query.Node_InsertStmt:
		if n.InsertStmt != nil {
			walkInsertStmt(n.InsertStmt, fn)
		}
	case *pg_query.Node_UpdateStmt:
		if n.UpdateStmt != nil {
			walkUpdateStmt(n.UpdateStmt, fn)
		}
	case *pg_query.Node_DeleteStmt:
		if n.DeleteStmt != nil {
			walkDeleteStmt(n.DeleteStmt, fn)
		}