walk_internal.go

// Code generated by tools/gen-ast-walk; DO NOT EDIT.

package ast

func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem {
	switch n := node.(type) {
	case *BadNode:
		// nothing to do

	case *BadStatement:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *BadQueryExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *BadExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})

	case *BadType:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})

	case *BadDDL:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})

	case *BadDML:
		stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *QueryStatement:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *Query:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.PipeOperators), visitor: v.Field("PipeOperators")})
		stack = append(stack, &stackItem{node: wrapNode(n.ForUpdate), visitor: v.Field("ForUpdate")})
		stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")})
		stack = append(stack, &stackItem{node: wrapNode(n.OrderBy), visitor: v.Field("OrderBy")})
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})
		stack = append(stack, &stackItem{node: wrapNode(n.With), visitor: v.Field("With")})

	case *ForUpdate:
		// nothing to do

	case *Hint:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Records), visitor: v.Field("Records")})

	case *HintRecord:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})
		stack = append(stack, &stackItem{node: wrapNode(n.Key), visitor: v.Field("Key")})

	case *With:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.CTEs), visitor: v.Field("CTEs")})

	case *CTE:
		stack = append(stack, &stackItem{node: wrapNode(n.QueryExpr), visitor: v.Field("QueryExpr")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *Select:
		stack = append(stack, &stackItem{node: wrapNode(n.Having), visitor: v.Field("Having")})
		stack = append(stack, &stackItem{node: wrapNode(n.GroupBy), visitor: v.Field("GroupBy")})
		stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")})
		stack = append(stack, &stackItem{node: wrapNode(n.From), visitor: v.Field("From")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Results), visitor: v.Field("Results")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})

	case *AsStruct:
		// nothing to do

	case *AsValue:
		// nothing to do

	case *AsTypeName:
		stack = append(stack, &stackItem{node: wrapNode(n.TypeName), visitor: v.Field("TypeName")})

	case *FromQuery:
		stack = append(stack, &stackItem{node: wrapNode(n.From), visitor: v.Field("From")})

	case *CompoundQuery:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Queries), visitor: v.Field("Queries")})

	case *SubQuery:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *StarModifierExcept:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *StarModifierReplaceItem:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *StarModifierReplace:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *Star:
		stack = append(stack, &stackItem{node: wrapNode(n.Replace), visitor: v.Field("Replace")})
		stack = append(stack, &stackItem{node: wrapNode(n.Except), visitor: v.Field("Except")})

	case *DotStar:
		stack = append(stack, &stackItem{node: wrapNode(n.Replace), visitor: v.Field("Replace")})
		stack = append(stack, &stackItem{node: wrapNode(n.Except), visitor: v.Field("Except")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *Alias:
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *AsAlias:
		stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")})

	case *ExprSelectItem:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *From:
		stack = append(stack, &stackItem{node: wrapNode(n.Source), visitor: v.Field("Source")})

	case *Where:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *GroupBy:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")})

	case *Having:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *OrderBy:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")})

	case *OrderByItem:
		stack = append(stack, &stackItem{node: wrapNode(n.Collate), visitor: v.Field("Collate")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *Collate:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *Limit:
		stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")})
		stack = append(stack, &stackItem{node: wrapNode(n.Count), visitor: v.Field("Count")})

	case *Offset:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *PipeSelect:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Results), visitor: v.Field("Results")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})

	case *PipeWhere:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *Unnest:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.WithOffset), visitor: v.Field("WithOffset")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *WithOffset:
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})

	case *TableName:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Table), visitor: v.Field("Table")})

	case *PathTableExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.WithOffset), visitor: v.Field("WithOffset")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Path), visitor: v.Field("Path")})

	case *SubQueryTableExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *ParenTableExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.Source), visitor: v.Field("Source")})

	case *Join:
		stack = append(stack, &stackItem{node: wrapNode(n.Cond), visitor: v.Field("Cond")})
		stack = append(stack, &stackItem{node: wrapNode(n.Right), visitor: v.Field("Right")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *On:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *Using:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Idents), visitor: v.Field("Idents")})

	case *TableSample:
		stack = append(stack, &stackItem{node: wrapNode(n.Size), visitor: v.Field("Size")})

	case *TableSampleSize:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *BinaryExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Right), visitor: v.Field("Right")})
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *UnaryExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *InExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Right), visitor: v.Field("Right")})
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *UnnestInCondition:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *SubQueryInCondition:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *ValuesInCondition:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")})

	case *IsNullExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *IsBoolExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *BetweenExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.RightEnd), visitor: v.Field("RightEnd")})
		stack = append(stack, &stackItem{node: wrapNode(n.RightStart), visitor: v.Field("RightStart")})
		stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")})

	case *SelectorExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *IndexExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Index), visitor: v.Field("Index")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *SubscriptSpecifierKeyword:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *CallExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Having), visitor: v.Field("Having")})
		stack = append(stack, &stackItem{node: wrapNode(n.NullHandling), visitor: v.Field("NullHandling")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")})
		stack = append(stack, &stackItem{node: wrapNode(n.Func), visitor: v.Field("Func")})

	case *TVFCallExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ExprArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *IntervalArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Unit), visitor: v.Field("Unit")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *SequenceArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *LambdaArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")})

	case *ModelArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *TableArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *NamedArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *IgnoreNulls:
		// nothing to do

	case *RespectNulls:
		// nothing to do

	case *HavingMax:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *HavingMin:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *CountStarExpr:
		// nothing to do

	case *ExtractExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.AtTimeZone), visitor: v.Field("AtTimeZone")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})
		stack = append(stack, &stackItem{node: wrapNode(n.Part), visitor: v.Field("Part")})

	case *ReplaceFieldsArg:
		stack = append(stack, &stackItem{node: wrapNode(n.Field), visitor: v.Field("Field")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *ReplaceFieldsExpr:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *AtTimeZone:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *WithExprVar:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *WithExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Vars), visitor: v.Field("Vars")})

	case *CastExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *CaseExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Else), visitor: v.Field("Else")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Whens), visitor: v.Field("Whens")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *CaseWhen:
		stack = append(stack, &stackItem{node: wrapNode(n.Then), visitor: v.Field("Then")})
		stack = append(stack, &stackItem{node: wrapNode(n.Cond), visitor: v.Field("Cond")})

	case *CaseElse:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *IfExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.ElseResult), visitor: v.Field("ElseResult")})
		stack = append(stack, &stackItem{node: wrapNode(n.TrueResult), visitor: v.Field("TrueResult")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *ParenExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *ScalarSubQuery:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *ArraySubQuery:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *ExistsSubQuery:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *Param:
		// nothing to do

	case *Ident:
		// nothing to do

	case *Path:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Idents), visitor: v.Field("Idents")})

	case *ArrayLiteral:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")})
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})

	case *TupleStructLiteral:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")})

	case *TypedStructLiteral:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")})

	case *TypelessStructLiteral:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")})

	case *NullLiteral:
		// nothing to do

	case *BoolLiteral:
		// nothing to do

	case *IntLiteral:
		// nothing to do

	case *FloatLiteral:
		// nothing to do

	case *StringLiteral:
		// nothing to do

	case *BytesLiteral:
		// nothing to do

	case *DateLiteral:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *TimestampLiteral:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *NumericLiteral:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *JSONLiteral:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})

	case *NewConstructor:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")})
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})

	case *BracedNewConstructor:
		stack = append(stack, &stackItem{node: wrapNode(n.Body), visitor: v.Field("Body")})
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})

	case *BracedConstructor:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")})

	case *BracedConstructorField:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *BracedConstructorFieldValueExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *SimpleType:
		// nothing to do

	case *ArrayType:
		stack = append(stack, &stackItem{node: wrapNode(n.Item), visitor: v.Field("Item")})

	case *StructType:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")})

	case *StructField:
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})
		stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")})

	case *NamedType:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Path), visitor: v.Field("Path")})

	case *CastIntValue:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *CastNumValue:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *Options:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Records), visitor: v.Field("Records")})

	case *OptionsDef:
		stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateSchema:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropSchema:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateDatabase:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterDatabase:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateLocalityGroup:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterLocalityGroup:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropLocalityGroup:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreatePlacement:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ProtoBundleTypes:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Types), visitor: v.Field("Types")})

	case *CreateProtoBundle:
		stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")})

	case *AlterProtoBundle:
		stack = append(stack, &stackItem{node: wrapNode(n.Delete), visitor: v.Field("Delete")})
		stack = append(stack, &stackItem{node: wrapNode(n.Update), visitor: v.Field("Update")})
		stack = append(stack, &stackItem{node: wrapNode(n.Insert), visitor: v.Field("Insert")})

	case *AlterProtoBundleInsert:
		stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")})

	case *AlterProtoBundleUpdate:
		stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")})

	case *AlterProtoBundleDelete:
		stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")})

	case *DropProtoBundle:
		// nothing to do

	case *CreateTable:
		stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")})
		stack = append(stack, &stackItem{node: wrapNode(n.Cluster), visitor: v.Field("Cluster")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Synonyms), visitor: v.Field("Synonyms")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.PrimaryKeys), visitor: v.Field("PrimaryKeys")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.TableConstraints), visitor: v.Field("TableConstraints")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *Synonym:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateSequence:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Params), visitor: v.Field("Params")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *SkipRange:
		stack = append(stack, &stackItem{node: wrapNode(n.Max), visitor: v.Field("Max")})
		stack = append(stack, &stackItem{node: wrapNode(n.Min), visitor: v.Field("Min")})

	case *StartCounterWith:
		stack = append(stack, &stackItem{node: wrapNode(n.Counter), visitor: v.Field("Counter")})

	case *BitReversedPositive:
		// nothing to do

	case *ColumnDef:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.DefaultSemantics), visitor: v.Field("DefaultSemantics")})
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ColumnDefaultExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *GeneratedColumnExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *IdentityColumn:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Params), visitor: v.Field("Params")})

	case *AutoIncrement:
		// nothing to do

	case *TableConstraint:
		stack = append(stack, &stackItem{node: wrapNode(n.Constraint), visitor: v.Field("Constraint")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ForeignKey:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")})
		stack = append(stack, &stackItem{node: wrapNode(n.ReferenceTable), visitor: v.Field("ReferenceTable")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *Check:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *IndexKey:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *Cluster:
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})

	case *CreateRowDeletionPolicy:
		stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")})

	case *RowDeletionPolicy:
		stack = append(stack, &stackItem{node: wrapNode(n.NumDays), visitor: v.Field("NumDays")})
		stack = append(stack, &stackItem{node: wrapNode(n.ColumnName), visitor: v.Field("ColumnName")})

	case *CreateView:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropView:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterTable:
		stack = append(stack, &stackItem{node: wrapNode(n.TableAlteration), visitor: v.Field("TableAlteration")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.IndexAlteration), visitor: v.Field("IndexAlteration")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterSequence:
		stack = append(stack, &stackItem{node: wrapNode(n.NoSkipRange), visitor: v.Field("NoSkipRange")})
		stack = append(stack, &stackItem{node: wrapNode(n.SkipRange), visitor: v.Field("SkipRange")})
		stack = append(stack, &stackItem{node: wrapNode(n.RestartCounterWith), visitor: v.Field("RestartCounterWith")})
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterChangeStream:
		stack = append(stack, &stackItem{node: wrapNode(n.ChangeStreamAlteration), visitor: v.Field("ChangeStreamAlteration")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AddSynonym:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropSynonym:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *RenameTo:
		stack = append(stack, &stackItem{node: wrapNode(n.AddSynonym), visitor: v.Field("AddSynonym")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AddColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Column), visitor: v.Field("Column")})

	case *AddTableConstraint:
		stack = append(stack, &stackItem{node: wrapNode(n.TableConstraint), visitor: v.Field("TableConstraint")})

	case *AddRowDeletionPolicy:
		stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")})

	case *DropColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropConstraint:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropRowDeletionPolicy:
		// nothing to do

	case *ReplaceRowDeletionPolicy:
		stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")})

	case *SetOnDelete:
		// nothing to do

	case *AlterColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Alteration), visitor: v.Field("Alteration")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterColumnType:
		stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")})
		stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")})

	case *AlterColumnSetOptions:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})

	case *AlterColumnSetDefault:
		stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")})

	case *AlterColumnDropDefault:
		// nothing to do

	case *AlterColumnAlterIdentity:
		stack = append(stack, &stackItem{node: wrapNode(n.Alteration), visitor: v.Field("Alteration")})

	case *RestartCounterWith:
		stack = append(stack, &stackItem{node: wrapNode(n.Counter), visitor: v.Field("Counter")})

	case *SetSkipRange:
		stack = append(stack, &stackItem{node: wrapNode(n.SkipRange), visitor: v.Field("SkipRange")})

	case *NoSkipRange:
		// nothing to do

	case *SetNoSkipRange:
		stack = append(stack, &stackItem{node: wrapNode(n.NoSkipRange), visitor: v.Field("NoSkipRange")})

	case *DropTable:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *RenameTable:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Tos), visitor: v.Field("Tos")})

	case *RenameTableTo:
		stack = append(stack, &stackItem{node: wrapNode(n.New), visitor: v.Field("New")})
		stack = append(stack, &stackItem{node: wrapNode(n.Old), visitor: v.Field("Old")})

	case *CreateIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.InterleaveIn), visitor: v.Field("InterleaveIn")})
		stack = append(stack, &stackItem{node: wrapNode(n.Storing), visitor: v.Field("Storing")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Keys), visitor: v.Field("Keys")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateVectorIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")})
		stack = append(stack, &stackItem{node: wrapNode(n.ColumnName), visitor: v.Field("ColumnName")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateChangeStream:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.For), visitor: v.Field("For")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ChangeStreamForAll:
		// nothing to do

	case *ChangeStreamForTables:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Tables), visitor: v.Field("Tables")})

	case *ChangeStreamForTable:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})

	case *ChangeStreamSetFor:
		stack = append(stack, &stackItem{node: wrapNode(n.For), visitor: v.Field("For")})

	case *ChangeStreamDropForAll:
		// nothing to do

	case *ChangeStreamSetOptions:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})

	case *Storing:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *InterleaveIn:
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})

	case *AddStoredColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropStoredColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropVectorIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropSequence:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateRole:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropRole:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropChangeStream:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *Grant:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Roles), visitor: v.Field("Roles")})
		stack = append(stack, &stackItem{node: wrapNode(n.Privilege), visitor: v.Field("Privilege")})

	case *Revoke:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Roles), visitor: v.Field("Roles")})
		stack = append(stack, &stackItem{node: wrapNode(n.Privilege), visitor: v.Field("Privilege")})

	case *PrivilegeOnTable:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Privileges), visitor: v.Field("Privileges")})

	case *SelectPrivilege:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *InsertPrivilege:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *UpdatePrivilege:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})

	case *DeletePrivilege:
		// nothing to do

	case *SelectPrivilegeOnChangeStream:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")})

	case *SelectPrivilegeOnView:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")})

	case *ExecutePrivilegeOnTableFunction:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")})

	case *RolePrivilege:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")})

	case *AlterStatistics:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *Analyze:
		// nothing to do

	case *CreateModelColumn:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.DataType), visitor: v.Field("DataType")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreateModelInputOutput:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.OutputColumns), visitor: v.Field("OutputColumns")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.InputColumns), visitor: v.Field("InputColumns")})

	case *CreateModel:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.InputOutput), visitor: v.Field("InputOutput")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterModel:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropModel:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *ScalarSchemaType:
		// nothing to do

	case *SizedSchemaType:
		stack = append(stack, &stackItem{node: wrapNode(n.Size), visitor: v.Field("Size")})

	case *ArraySchemaType:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")})
		stack = append(stack, &stackItem{node: wrapNode(n.Item), visitor: v.Field("Item")})

	case *CreateSearchIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")})
		stack = append(stack, &stackItem{node: wrapNode(n.Interleave), visitor: v.Field("Interleave")})
		stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")})
		stack = append(stack, &stackItem{node: wrapNode(n.OrderBy), visitor: v.Field("OrderBy")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.PartitionColumns), visitor: v.Field("PartitionColumns")})
		stack = append(stack, &stackItem{node: wrapNode(n.Storing), visitor: v.Field("Storing")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.TokenListPart), visitor: v.Field("TokenListPart")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *DropSearchIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *AlterSearchIndex:
		stack = append(stack, &stackItem{node: wrapNode(n.IndexAlteration), visitor: v.Field("IndexAlteration")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *CreatePropertyGraph:
		stack = append(stack, &stackItem{node: wrapNode(n.Content), visitor: v.Field("Content")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *PropertyGraphContent:
		stack = append(stack, &stackItem{node: wrapNode(n.EdgeTables), visitor: v.Field("EdgeTables")})
		stack = append(stack, &stackItem{node: wrapNode(n.NodeTables), visitor: v.Field("NodeTables")})

	case *PropertyGraphNodeTables:
		stack = append(stack, &stackItem{node: wrapNode(n.Tables), visitor: v.Field("Tables")})

	case *PropertyGraphEdgeTables:
		stack = append(stack, &stackItem{node: wrapNode(n.Tables), visitor: v.Field("Tables")})

	case *PropertyGraphElementList:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Elements), visitor: v.Field("Elements")})

	case *PropertyGraphElement:
		stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")})
		stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")})
		stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *PropertyGraphSingleProperties:
		stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")})

	case *PropertyGraphLabelAndPropertiesList:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.LabelAndProperties), visitor: v.Field("LabelAndProperties")})

	case *PropertyGraphLabelAndProperties:
		stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")})
		stack = append(stack, &stackItem{node: wrapNode(n.Label), visitor: v.Field("Label")})

	case *PropertyGraphElementLabelLabelName:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *PropertyGraphElementLabelDefaultLabel:
		// nothing to do

	case *PropertyGraphNodeElementKey:
		stack = append(stack, &stackItem{node: wrapNode(n.Key), visitor: v.Field("Key")})

	case *PropertyGraphEdgeElementKeys:
		stack = append(stack, &stackItem{node: wrapNode(n.Destination), visitor: v.Field("Destination")})
		stack = append(stack, &stackItem{node: wrapNode(n.Source), visitor: v.Field("Source")})
		stack = append(stack, &stackItem{node: wrapNode(n.Element), visitor: v.Field("Element")})

	case *PropertyGraphElementKey:
		stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")})

	case *PropertyGraphSourceKey:
		stack = append(stack, &stackItem{node: wrapNode(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")})
		stack = append(stack, &stackItem{node: wrapNode(n.ElementReference), visitor: v.Field("ElementReference")})
		stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")})

	case *PropertyGraphDestinationKey:
		stack = append(stack, &stackItem{node: wrapNode(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")})
		stack = append(stack, &stackItem{node: wrapNode(n.ElementReference), visitor: v.Field("ElementReference")})
		stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")})

	case *PropertyGraphColumnNameList:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.ColumnNameList), visitor: v.Field("ColumnNameList")})

	case *PropertyGraphNoProperties:
		// nothing to do

	case *PropertyGraphPropertiesAre:
		stack = append(stack, &stackItem{node: wrapNode(n.ExceptColumns), visitor: v.Field("ExceptColumns")})

	case *PropertyGraphDerivedPropertyList:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.DerivedProperties), visitor: v.Field("DerivedProperties")})

	case *PropertyGraphDerivedProperty:
		stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")})
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *DropPropertyGraph:
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})

	case *WithAction:
		stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")})

	case *ThenReturn:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")})
		stack = append(stack, &stackItem{node: wrapNode(n.WithAction), visitor: v.Field("WithAction")})

	case *Insert:
		stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")})
		stack = append(stack, &stackItem{node: wrapNode(n.Input), visitor: v.Field("Input")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableHint), visitor: v.Field("TableHint")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *ValuesInput:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Rows), visitor: v.Field("Rows")})

	case *ValuesRow:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")})

	case *DefaultExpr:
		stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")})

	case *SubQueryInput:
		stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")})

	case *Delete:
		stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")})
		stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableHint), visitor: v.Field("TableHint")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *Update:
		stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")})
		stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Updates), visitor: v.Field("Updates")})
		stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableHint), visitor: v.Field("TableHint")})
		stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")})
		stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")})

	case *UpdateItem:
		stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")})
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Path), visitor: v.Field("Path")})

	case *Call:
		stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")})
		stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")})
	}
	return stack
}