1pub trait Fold<T: AstInfo, T2: AstInfo, > {
2 fn fold_abbreviated_grant_or_revoke_statement(&mut self, node: AbbreviatedGrantOrRevokeStatement<T>) -> AbbreviatedGrantOrRevokeStatement<T2> {
3 fold_abbreviated_grant_or_revoke_statement(self, node)
4 }
5 fn fold_abbreviated_grant_statement(&mut self, node: AbbreviatedGrantStatement<T>) -> AbbreviatedGrantStatement<T2> {
6 fold_abbreviated_grant_statement(self, node)
7 }
8 fn fold_abbreviated_revoke_statement(&mut self, node: AbbreviatedRevokeStatement<T>) -> AbbreviatedRevokeStatement<T2> {
9 fold_abbreviated_revoke_statement(self, node)
10 }
11 fn fold_alter_cluster_action(&mut self, node: AlterClusterAction<T>) -> AlterClusterAction<T2> {
12 fold_alter_cluster_action(self, node)
13 }
14 fn fold_alter_cluster_statement(&mut self, node: AlterClusterStatement<T>) -> AlterClusterStatement<T2> {
15 fold_alter_cluster_statement(self, node)
16 }
17 fn fold_alter_connection_action(&mut self, node: AlterConnectionAction<T>) -> AlterConnectionAction<T2> {
18 fold_alter_connection_action(self, node)
19 }
20 fn fold_alter_connection_option(&mut self, node: AlterConnectionOption<T>) -> AlterConnectionOption<T2> {
21 fold_alter_connection_option(self, node)
22 }
23 fn fold_alter_connection_option_name(&mut self, node: AlterConnectionOptionName) -> AlterConnectionOptionName {
24 fold_alter_connection_option_name(self, node)
25 }
26 fn fold_alter_connection_statement(&mut self, node: AlterConnectionStatement<T>) -> AlterConnectionStatement<T2> {
27 fold_alter_connection_statement(self, node)
28 }
29 fn fold_alter_default_privileges_statement(&mut self, node: AlterDefaultPrivilegesStatement<T>) -> AlterDefaultPrivilegesStatement<T2> {
30 fold_alter_default_privileges_statement(self, node)
31 }
32 fn fold_alter_index_action(&mut self, node: AlterIndexAction<T>) -> AlterIndexAction<T2> {
33 fold_alter_index_action(self, node)
34 }
35 fn fold_alter_index_statement(&mut self, node: AlterIndexStatement<T>) -> AlterIndexStatement<T2> {
36 fold_alter_index_statement(self, node)
37 }
38 fn fold_alter_network_policy_statement(&mut self, node: AlterNetworkPolicyStatement<T>) -> AlterNetworkPolicyStatement<T2> {
39 fold_alter_network_policy_statement(self, node)
40 }
41 fn fold_alter_object_rename_statement(&mut self, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement {
42 fold_alter_object_rename_statement(self, node)
43 }
44 fn fold_alter_object_swap_statement(&mut self, node: AlterObjectSwapStatement) -> AlterObjectSwapStatement {
45 fold_alter_object_swap_statement(self, node)
46 }
47 fn fold_alter_owner_statement(&mut self, node: AlterOwnerStatement<T>) -> AlterOwnerStatement<T2> {
48 fold_alter_owner_statement(self, node)
49 }
50 fn fold_alter_retain_history_statement(&mut self, node: AlterRetainHistoryStatement<T>) -> AlterRetainHistoryStatement<T2> {
51 fold_alter_retain_history_statement(self, node)
52 }
53 fn fold_alter_role_option(&mut self, node: AlterRoleOption) -> AlterRoleOption {
54 fold_alter_role_option(self, node)
55 }
56 fn fold_alter_role_statement(&mut self, node: AlterRoleStatement<T>) -> AlterRoleStatement<T2> {
57 fold_alter_role_statement(self, node)
58 }
59 fn fold_alter_secret_statement(&mut self, node: AlterSecretStatement<T>) -> AlterSecretStatement<T2> {
60 fold_alter_secret_statement(self, node)
61 }
62 fn fold_alter_set_cluster_statement(&mut self, node: AlterSetClusterStatement<T>) -> AlterSetClusterStatement<T2> {
63 fold_alter_set_cluster_statement(self, node)
64 }
65 fn fold_alter_sink_action(&mut self, node: AlterSinkAction<T>) -> AlterSinkAction<T2> {
66 fold_alter_sink_action(self, node)
67 }
68 fn fold_alter_sink_statement(&mut self, node: AlterSinkStatement<T>) -> AlterSinkStatement<T2> {
69 fold_alter_sink_statement(self, node)
70 }
71 fn fold_alter_source_action(&mut self, node: AlterSourceAction<T>) -> AlterSourceAction<T2> {
72 fold_alter_source_action(self, node)
73 }
74 fn fold_alter_source_add_subsource_option(&mut self, node: AlterSourceAddSubsourceOption<T>) -> AlterSourceAddSubsourceOption<T2> {
75 fold_alter_source_add_subsource_option(self, node)
76 }
77 fn fold_alter_source_add_subsource_option_name(&mut self, node: AlterSourceAddSubsourceOptionName) -> AlterSourceAddSubsourceOptionName {
78 fold_alter_source_add_subsource_option_name(self, node)
79 }
80 fn fold_alter_source_statement(&mut self, node: AlterSourceStatement<T>) -> AlterSourceStatement<T2> {
81 fold_alter_source_statement(self, node)
82 }
83 fn fold_alter_system_reset_all_statement(&mut self, node: AlterSystemResetAllStatement) -> AlterSystemResetAllStatement {
84 fold_alter_system_reset_all_statement(self, node)
85 }
86 fn fold_alter_system_reset_statement(&mut self, node: AlterSystemResetStatement) -> AlterSystemResetStatement {
87 fold_alter_system_reset_statement(self, node)
88 }
89 fn fold_alter_system_set_statement(&mut self, node: AlterSystemSetStatement) -> AlterSystemSetStatement {
90 fold_alter_system_set_statement(self, node)
91 }
92 fn fold_alter_table_add_column_statement(&mut self, node: AlterTableAddColumnStatement<T>) -> AlterTableAddColumnStatement<T2> {
93 fold_alter_table_add_column_statement(self, node)
94 }
95 fn fold_as_of(&mut self, node: AsOf<T>) -> AsOf<T2> {
96 fold_as_of(self, node)
97 }
98 fn fold_assignment(&mut self, node: Assignment<T>) -> Assignment<T2> {
99 fold_assignment(self, node)
100 }
101 fn fold_avro_doc_on(&mut self, node: AvroDocOn<T>) -> AvroDocOn<T2> {
102 fold_avro_doc_on(self, node)
103 }
104 fn fold_avro_schema(&mut self, node: AvroSchema<T>) -> AvroSchema<T2> {
105 fold_avro_schema(self, node)
106 }
107 fn fold_avro_schema_option(&mut self, node: AvroSchemaOption<T>) -> AvroSchemaOption<T2> {
108 fold_avro_schema_option(self, node)
109 }
110 fn fold_avro_schema_option_name(&mut self, node: AvroSchemaOptionName) -> AvroSchemaOptionName {
111 fold_avro_schema_option_name(self, node)
112 }
113 fn fold_catalog_name(&mut self, node: CatalogName) -> CatalogName {
114 fold_catalog_name(self, node)
115 }
116 fn fold_close_statement(&mut self, node: CloseStatement) -> CloseStatement {
117 fold_close_statement(self, node)
118 }
119 fn fold_cluster_alter_option(&mut self, node: ClusterAlterOption<T>) -> ClusterAlterOption<T2> {
120 fold_cluster_alter_option(self, node)
121 }
122 fn fold_cluster_alter_option_name(&mut self, node: ClusterAlterOptionName) -> ClusterAlterOptionName {
123 fold_cluster_alter_option_name(self, node)
124 }
125 fn fold_cluster_alter_option_value(&mut self, node: ClusterAlterOptionValue<T>) -> ClusterAlterOptionValue<T2> {
126 fold_cluster_alter_option_value(self, node)
127 }
128 fn fold_cluster_alter_until_ready_option(&mut self, node: ClusterAlterUntilReadyOption<T>) -> ClusterAlterUntilReadyOption<T2> {
129 fold_cluster_alter_until_ready_option(self, node)
130 }
131 fn fold_cluster_alter_until_ready_option_name(&mut self, node: ClusterAlterUntilReadyOptionName) -> ClusterAlterUntilReadyOptionName {
132 fold_cluster_alter_until_ready_option_name(self, node)
133 }
134 fn fold_cluster_feature(&mut self, node: ClusterFeature<T>) -> ClusterFeature<T2> {
135 fold_cluster_feature(self, node)
136 }
137 fn fold_cluster_feature_name(&mut self, node: ClusterFeatureName) -> ClusterFeatureName {
138 fold_cluster_feature_name(self, node)
139 }
140 fn fold_cluster_option(&mut self, node: ClusterOption<T>) -> ClusterOption<T2> {
141 fold_cluster_option(self, node)
142 }
143 fn fold_cluster_option_name(&mut self, node: ClusterOptionName) -> ClusterOptionName {
144 fold_cluster_option_name(self, node)
145 }
146 fn fold_cluster_schedule_option_value(&mut self, node: ClusterScheduleOptionValue) -> ClusterScheduleOptionValue {
147 fold_cluster_schedule_option_value(self, node)
148 }
149 fn fold_column_def(&mut self, node: ColumnDef<T>) -> ColumnDef<T2> {
150 fold_column_def(self, node)
151 }
152 fn fold_column_name(&mut self, node: ColumnName<T>) -> ColumnName<T2> {
153 fold_column_name(self, node)
154 }
155 fn fold_column_option(&mut self, node: ColumnOption<T>) -> ColumnOption<T2> {
156 fold_column_option(self, node)
157 }
158 fn fold_column_option_def(&mut self, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2> {
159 fold_column_option_def(self, node)
160 }
161 fn fold_column_versioned(&mut self, node: ColumnVersioned) -> ColumnVersioned {
162 fold_column_versioned(self, node)
163 }
164 fn fold_comment_object_type(&mut self, node: CommentObjectType<T>) -> CommentObjectType<T2> {
165 fold_comment_object_type(self, node)
166 }
167 fn fold_comment_statement(&mut self, node: CommentStatement<T>) -> CommentStatement<T2> {
168 fold_comment_statement(self, node)
169 }
170 fn fold_commit_statement(&mut self, node: CommitStatement) -> CommitStatement {
171 fold_commit_statement(self, node)
172 }
173 fn fold_connection_default_aws_privatelink(&mut self, node: ConnectionDefaultAwsPrivatelink<T>) -> ConnectionDefaultAwsPrivatelink<T2> {
174 fold_connection_default_aws_privatelink(self, node)
175 }
176 fn fold_connection_option(&mut self, node: ConnectionOption<T>) -> ConnectionOption<T2> {
177 fold_connection_option(self, node)
178 }
179 fn fold_connection_option_name(&mut self, node: ConnectionOptionName) -> ConnectionOptionName {
180 fold_connection_option_name(self, node)
181 }
182 fn fold_continual_task_option(&mut self, node: ContinualTaskOption<T>) -> ContinualTaskOption<T2> {
183 fold_continual_task_option(self, node)
184 }
185 fn fold_continual_task_option_name(&mut self, node: ContinualTaskOptionName) -> ContinualTaskOptionName {
186 fold_continual_task_option_name(self, node)
187 }
188 fn fold_continual_task_stmt(&mut self, node: ContinualTaskStmt<T>) -> ContinualTaskStmt<T2> {
189 fold_continual_task_stmt(self, node)
190 }
191 fn fold_copy_direction(&mut self, node: CopyDirection) -> CopyDirection {
192 fold_copy_direction(self, node)
193 }
194 fn fold_copy_option(&mut self, node: CopyOption<T>) -> CopyOption<T2> {
195 fold_copy_option(self, node)
196 }
197 fn fold_copy_option_name(&mut self, node: CopyOptionName) -> CopyOptionName {
198 fold_copy_option_name(self, node)
199 }
200 fn fold_copy_relation(&mut self, node: CopyRelation<T>) -> CopyRelation<T2> {
201 fold_copy_relation(self, node)
202 }
203 fn fold_copy_statement(&mut self, node: CopyStatement<T>) -> CopyStatement<T2> {
204 fold_copy_statement(self, node)
205 }
206 fn fold_copy_target(&mut self, node: CopyTarget<T>) -> CopyTarget<T2> {
207 fold_copy_target(self, node)
208 }
209 fn fold_create_cluster_replica_statement(&mut self, node: CreateClusterReplicaStatement<T>) -> CreateClusterReplicaStatement<T2> {
210 fold_create_cluster_replica_statement(self, node)
211 }
212 fn fold_create_cluster_statement(&mut self, node: CreateClusterStatement<T>) -> CreateClusterStatement<T2> {
213 fold_create_cluster_statement(self, node)
214 }
215 fn fold_create_connection_option(&mut self, node: CreateConnectionOption<T>) -> CreateConnectionOption<T2> {
216 fold_create_connection_option(self, node)
217 }
218 fn fold_create_connection_option_name(&mut self, node: CreateConnectionOptionName) -> CreateConnectionOptionName {
219 fold_create_connection_option_name(self, node)
220 }
221 fn fold_create_connection_statement(&mut self, node: CreateConnectionStatement<T>) -> CreateConnectionStatement<T2> {
222 fold_create_connection_statement(self, node)
223 }
224 fn fold_create_connection_type(&mut self, node: CreateConnectionType) -> CreateConnectionType {
225 fold_create_connection_type(self, node)
226 }
227 fn fold_create_continual_task_statement(&mut self, node: CreateContinualTaskStatement<T>) -> CreateContinualTaskStatement<T2> {
228 fold_create_continual_task_statement(self, node)
229 }
230 fn fold_create_continual_task_sugar(&mut self, node: CreateContinualTaskSugar<T>) -> CreateContinualTaskSugar<T2> {
231 fold_create_continual_task_sugar(self, node)
232 }
233 fn fold_create_database_statement(&mut self, node: CreateDatabaseStatement) -> CreateDatabaseStatement {
234 fold_create_database_statement(self, node)
235 }
236 fn fold_create_index_statement(&mut self, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2> {
237 fold_create_index_statement(self, node)
238 }
239 fn fold_create_materialized_view_statement(&mut self, node: CreateMaterializedViewStatement<T>) -> CreateMaterializedViewStatement<T2> {
240 fold_create_materialized_view_statement(self, node)
241 }
242 fn fold_create_network_policy_statement(&mut self, node: CreateNetworkPolicyStatement<T>) -> CreateNetworkPolicyStatement<T2> {
243 fold_create_network_policy_statement(self, node)
244 }
245 fn fold_create_role_statement(&mut self, node: CreateRoleStatement) -> CreateRoleStatement {
246 fold_create_role_statement(self, node)
247 }
248 fn fold_create_schema_statement(&mut self, node: CreateSchemaStatement) -> CreateSchemaStatement {
249 fold_create_schema_statement(self, node)
250 }
251 fn fold_create_secret_statement(&mut self, node: CreateSecretStatement<T>) -> CreateSecretStatement<T2> {
252 fold_create_secret_statement(self, node)
253 }
254 fn fold_create_sink_connection(&mut self, node: CreateSinkConnection<T>) -> CreateSinkConnection<T2> {
255 fold_create_sink_connection(self, node)
256 }
257 fn fold_create_sink_option(&mut self, node: CreateSinkOption<T>) -> CreateSinkOption<T2> {
258 fold_create_sink_option(self, node)
259 }
260 fn fold_create_sink_option_name(&mut self, node: CreateSinkOptionName) -> CreateSinkOptionName {
261 fold_create_sink_option_name(self, node)
262 }
263 fn fold_create_sink_statement(&mut self, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2> {
264 fold_create_sink_statement(self, node)
265 }
266 fn fold_create_source_connection(&mut self, node: CreateSourceConnection<T>) -> CreateSourceConnection<T2> {
267 fold_create_source_connection(self, node)
268 }
269 fn fold_create_source_option(&mut self, node: CreateSourceOption<T>) -> CreateSourceOption<T2> {
270 fold_create_source_option(self, node)
271 }
272 fn fold_create_source_option_name(&mut self, node: CreateSourceOptionName) -> CreateSourceOptionName {
273 fold_create_source_option_name(self, node)
274 }
275 fn fold_create_source_statement(&mut self, node: CreateSourceStatement<T>) -> CreateSourceStatement<T2> {
276 fold_create_source_statement(self, node)
277 }
278 fn fold_create_subsource_option(&mut self, node: CreateSubsourceOption<T>) -> CreateSubsourceOption<T2> {
279 fold_create_subsource_option(self, node)
280 }
281 fn fold_create_subsource_option_name(&mut self, node: CreateSubsourceOptionName) -> CreateSubsourceOptionName {
282 fold_create_subsource_option_name(self, node)
283 }
284 fn fold_create_subsource_statement(&mut self, node: CreateSubsourceStatement<T>) -> CreateSubsourceStatement<T2> {
285 fold_create_subsource_statement(self, node)
286 }
287 fn fold_create_table_from_source_statement(&mut self, node: CreateTableFromSourceStatement<T>) -> CreateTableFromSourceStatement<T2> {
288 fold_create_table_from_source_statement(self, node)
289 }
290 fn fold_create_table_statement(&mut self, node: CreateTableStatement<T>) -> CreateTableStatement<T2> {
291 fold_create_table_statement(self, node)
292 }
293 fn fold_create_type_as(&mut self, node: CreateTypeAs<T>) -> CreateTypeAs<T2> {
294 fold_create_type_as(self, node)
295 }
296 fn fold_create_type_list_option(&mut self, node: CreateTypeListOption<T>) -> CreateTypeListOption<T2> {
297 fold_create_type_list_option(self, node)
298 }
299 fn fold_create_type_list_option_name(&mut self, node: CreateTypeListOptionName) -> CreateTypeListOptionName {
300 fold_create_type_list_option_name(self, node)
301 }
302 fn fold_create_type_map_option(&mut self, node: CreateTypeMapOption<T>) -> CreateTypeMapOption<T2> {
303 fold_create_type_map_option(self, node)
304 }
305 fn fold_create_type_map_option_name(&mut self, node: CreateTypeMapOptionName) -> CreateTypeMapOptionName {
306 fold_create_type_map_option_name(self, node)
307 }
308 fn fold_create_type_statement(&mut self, node: CreateTypeStatement<T>) -> CreateTypeStatement<T2> {
309 fold_create_type_statement(self, node)
310 }
311 fn fold_create_view_statement(&mut self, node: CreateViewStatement<T>) -> CreateViewStatement<T2> {
312 fold_create_view_statement(self, node)
313 }
314 fn fold_create_webhook_source_body(&mut self, node: CreateWebhookSourceBody) -> CreateWebhookSourceBody {
315 fold_create_webhook_source_body(self, node)
316 }
317 fn fold_create_webhook_source_check(&mut self, node: CreateWebhookSourceCheck<T>) -> CreateWebhookSourceCheck<T2> {
318 fold_create_webhook_source_check(self, node)
319 }
320 fn fold_create_webhook_source_check_options(&mut self, node: CreateWebhookSourceCheckOptions<T>) -> CreateWebhookSourceCheckOptions<T2> {
321 fold_create_webhook_source_check_options(self, node)
322 }
323 fn fold_create_webhook_source_filter_header(&mut self, node: CreateWebhookSourceFilterHeader) -> CreateWebhookSourceFilterHeader {
324 fold_create_webhook_source_filter_header(self, node)
325 }
326 fn fold_create_webhook_source_header(&mut self, node: CreateWebhookSourceHeader) -> CreateWebhookSourceHeader {
327 fold_create_webhook_source_header(self, node)
328 }
329 fn fold_create_webhook_source_include_headers(&mut self, node: CreateWebhookSourceIncludeHeaders) -> CreateWebhookSourceIncludeHeaders {
330 fold_create_webhook_source_include_headers(self, node)
331 }
332 fn fold_create_webhook_source_map_header(&mut self, node: CreateWebhookSourceMapHeader) -> CreateWebhookSourceMapHeader {
333 fold_create_webhook_source_map_header(self, node)
334 }
335 fn fold_create_webhook_source_secret(&mut self, node: CreateWebhookSourceSecret<T>) -> CreateWebhookSourceSecret<T2> {
336 fold_create_webhook_source_secret(self, node)
337 }
338 fn fold_create_webhook_source_statement(&mut self, node: CreateWebhookSourceStatement<T>) -> CreateWebhookSourceStatement<T2> {
339 fold_create_webhook_source_statement(self, node)
340 }
341 fn fold_csr_config_option(&mut self, node: CsrConfigOption<T>) -> CsrConfigOption<T2> {
342 fold_csr_config_option(self, node)
343 }
344 fn fold_csr_config_option_name(&mut self, node: CsrConfigOptionName<T>) -> CsrConfigOptionName<T2> {
345 fold_csr_config_option_name(self, node)
346 }
347 fn fold_csr_connection(&mut self, node: CsrConnection<T>) -> CsrConnection<T2> {
348 fold_csr_connection(self, node)
349 }
350 fn fold_csr_connection_avro(&mut self, node: CsrConnectionAvro<T>) -> CsrConnectionAvro<T2> {
351 fold_csr_connection_avro(self, node)
352 }
353 fn fold_csr_connection_protobuf(&mut self, node: CsrConnectionProtobuf<T>) -> CsrConnectionProtobuf<T2> {
354 fold_csr_connection_protobuf(self, node)
355 }
356 fn fold_csr_seed_avro(&mut self, node: CsrSeedAvro) -> CsrSeedAvro {
357 fold_csr_seed_avro(self, node)
358 }
359 fn fold_csr_seed_protobuf(&mut self, node: CsrSeedProtobuf) -> CsrSeedProtobuf {
360 fold_csr_seed_protobuf(self, node)
361 }
362 fn fold_csr_seed_protobuf_schema(&mut self, node: CsrSeedProtobufSchema) -> CsrSeedProtobufSchema {
363 fold_csr_seed_protobuf_schema(self, node)
364 }
365 fn fold_csv_columns(&mut self, node: CsvColumns) -> CsvColumns {
366 fold_csv_columns(self, node)
367 }
368 fn fold_cte(&mut self, node: Cte<T>) -> Cte<T2> {
369 fold_cte(self, node)
370 }
371 fn fold_cte_block(&mut self, node: CteBlock<T>) -> CteBlock<T2> {
372 fold_cte_block(self, node)
373 }
374 fn fold_cte_mut_rec(&mut self, node: CteMutRec<T>) -> CteMutRec<T2> {
375 fold_cte_mut_rec(self, node)
376 }
377 fn fold_cte_mut_rec_column_def(&mut self, node: CteMutRecColumnDef<T>) -> CteMutRecColumnDef<T2> {
378 fold_cte_mut_rec_column_def(self, node)
379 }
380 fn fold_date_time_field(&mut self, node: DateTimeField) -> DateTimeField {
381 fold_date_time_field(self, node)
382 }
383 fn fold_deallocate_statement(&mut self, node: DeallocateStatement) -> DeallocateStatement {
384 fold_deallocate_statement(self, node)
385 }
386 fn fold_declare_statement(&mut self, node: DeclareStatement<T>) -> DeclareStatement<T2> {
387 fold_declare_statement(self, node)
388 }
389 fn fold_deferred_item_name(&mut self, node: DeferredItemName<T>) -> DeferredItemName<T2> {
390 fold_deferred_item_name(self, node)
391 }
392 fn fold_delete_statement(&mut self, node: DeleteStatement<T>) -> DeleteStatement<T2> {
393 fold_delete_statement(self, node)
394 }
395 fn fold_discard_statement(&mut self, node: DiscardStatement) -> DiscardStatement {
396 fold_discard_statement(self, node)
397 }
398 fn fold_discard_target(&mut self, node: DiscardTarget) -> DiscardTarget {
399 fold_discard_target(self, node)
400 }
401 fn fold_distinct(&mut self, node: Distinct<T>) -> Distinct<T2> {
402 fold_distinct(self, node)
403 }
404 fn fold_doc_on_identifier(&mut self, node: DocOnIdentifier<T>) -> DocOnIdentifier<T2> {
405 fold_doc_on_identifier(self, node)
406 }
407 fn fold_doc_on_schema(&mut self, node: DocOnSchema) -> DocOnSchema {
408 fold_doc_on_schema(self, node)
409 }
410 fn fold_drop_objects_statement(&mut self, node: DropObjectsStatement) -> DropObjectsStatement {
411 fold_drop_objects_statement(self, node)
412 }
413 fn fold_drop_owned_statement(&mut self, node: DropOwnedStatement<T>) -> DropOwnedStatement<T2> {
414 fold_drop_owned_statement(self, node)
415 }
416 fn fold_execute_statement(&mut self, node: ExecuteStatement<T>) -> ExecuteStatement<T2> {
417 fold_execute_statement(self, node)
418 }
419 fn fold_explain_analyze_cluster_statement(&mut self, node: ExplainAnalyzeClusterStatement) -> ExplainAnalyzeClusterStatement {
420 fold_explain_analyze_cluster_statement(self, node)
421 }
422 fn fold_explain_analyze_computation_properties(&mut self, node: ExplainAnalyzeComputationProperties) -> ExplainAnalyzeComputationProperties {
423 fold_explain_analyze_computation_properties(self, node)
424 }
425 fn fold_explain_analyze_computation_property(&mut self, node: ExplainAnalyzeComputationProperty) -> ExplainAnalyzeComputationProperty {
426 fold_explain_analyze_computation_property(self, node)
427 }
428 fn fold_explain_analyze_object_statement(&mut self, node: ExplainAnalyzeObjectStatement<T>) -> ExplainAnalyzeObjectStatement<T2> {
429 fold_explain_analyze_object_statement(self, node)
430 }
431 fn fold_explain_analyze_property(&mut self, node: ExplainAnalyzeProperty) -> ExplainAnalyzeProperty {
432 fold_explain_analyze_property(self, node)
433 }
434 fn fold_explain_format(&mut self, node: ExplainFormat) -> ExplainFormat {
435 fold_explain_format(self, node)
436 }
437 fn fold_explain_plan_option(&mut self, node: ExplainPlanOption<T>) -> ExplainPlanOption<T2> {
438 fold_explain_plan_option(self, node)
439 }
440 fn fold_explain_plan_option_name(&mut self, node: ExplainPlanOptionName) -> ExplainPlanOptionName {
441 fold_explain_plan_option_name(self, node)
442 }
443 fn fold_explain_plan_statement(&mut self, node: ExplainPlanStatement<T>) -> ExplainPlanStatement<T2> {
444 fold_explain_plan_statement(self, node)
445 }
446 fn fold_explain_pushdown_statement(&mut self, node: ExplainPushdownStatement<T>) -> ExplainPushdownStatement<T2> {
447 fold_explain_pushdown_statement(self, node)
448 }
449 fn fold_explain_sink_schema_for(&mut self, node: ExplainSinkSchemaFor) -> ExplainSinkSchemaFor {
450 fold_explain_sink_schema_for(self, node)
451 }
452 fn fold_explain_sink_schema_statement(&mut self, node: ExplainSinkSchemaStatement<T>) -> ExplainSinkSchemaStatement<T2> {
453 fold_explain_sink_schema_statement(self, node)
454 }
455 fn fold_explain_stage(&mut self, node: ExplainStage) -> ExplainStage {
456 fold_explain_stage(self, node)
457 }
458 fn fold_explain_timestamp_statement(&mut self, node: ExplainTimestampStatement<T>) -> ExplainTimestampStatement<T2> {
459 fold_explain_timestamp_statement(self, node)
460 }
461 fn fold_explainee(&mut self, node: Explainee<T>) -> Explainee<T2> {
462 fold_explainee(self, node)
463 }
464 fn fold_expr(&mut self, node: Expr<T>) -> Expr<T2> {
465 fold_expr(self, node)
466 }
467 fn fold_external_reference_export(&mut self, node: ExternalReferenceExport) -> ExternalReferenceExport {
468 fold_external_reference_export(self, node)
469 }
470 fn fold_external_references(&mut self, node: ExternalReferences) -> ExternalReferences {
471 fold_external_references(self, node)
472 }
473 fn fold_fetch_direction(&mut self, node: FetchDirection) -> FetchDirection {
474 fold_fetch_direction(self, node)
475 }
476 fn fold_fetch_option(&mut self, node: FetchOption<T>) -> FetchOption<T2> {
477 fold_fetch_option(self, node)
478 }
479 fn fold_fetch_option_name(&mut self, node: FetchOptionName) -> FetchOptionName {
480 fold_fetch_option_name(self, node)
481 }
482 fn fold_fetch_statement(&mut self, node: FetchStatement<T>) -> FetchStatement<T2> {
483 fold_fetch_statement(self, node)
484 }
485 fn fold_format(&mut self, node: Format<T>) -> Format<T2> {
486 fold_format(self, node)
487 }
488 fn fold_format_specifier(&mut self, node: FormatSpecifier<T>) -> FormatSpecifier<T2> {
489 fold_format_specifier(self, node)
490 }
491 fn fold_function(&mut self, node: Function<T>) -> Function<T2> {
492 fold_function(self, node)
493 }
494 fn fold_function_args(&mut self, node: FunctionArgs<T>) -> FunctionArgs<T2> {
495 fold_function_args(self, node)
496 }
497 fn fold_grant_privileges_statement(&mut self, node: GrantPrivilegesStatement<T>) -> GrantPrivilegesStatement<T2> {
498 fold_grant_privileges_statement(self, node)
499 }
500 fn fold_grant_role_statement(&mut self, node: GrantRoleStatement<T>) -> GrantRoleStatement<T2> {
501 fold_grant_role_statement(self, node)
502 }
503 fn fold_grant_target_all_specification(&mut self, node: GrantTargetAllSpecification<T>) -> GrantTargetAllSpecification<T2> {
504 fold_grant_target_all_specification(self, node)
505 }
506 fn fold_grant_target_specification(&mut self, node: GrantTargetSpecification<T>) -> GrantTargetSpecification<T2> {
507 fold_grant_target_specification(self, node)
508 }
509 fn fold_grant_target_specification_inner(&mut self, node: GrantTargetSpecificationInner<T>) -> GrantTargetSpecificationInner<T2> {
510 fold_grant_target_specification_inner(self, node)
511 }
512 fn fold_homogenizing_function(&mut self, node: HomogenizingFunction) -> HomogenizingFunction {
513 fold_homogenizing_function(self, node)
514 }
515 fn fold_iceberg_sink_config_option(&mut self, node: IcebergSinkConfigOption<T>) -> IcebergSinkConfigOption<T2> {
516 fold_iceberg_sink_config_option(self, node)
517 }
518 fn fold_iceberg_sink_config_option_name(&mut self, node: IcebergSinkConfigOptionName) -> IcebergSinkConfigOptionName {
519 fold_iceberg_sink_config_option_name(self, node)
520 }
521 fn fold_ident(&mut self, node: Ident) -> Ident {
522 fold_ident(self, node)
523 }
524 fn fold_ident_error(&mut self, node: IdentError) -> IdentError {
525 fold_ident_error(self, node)
526 }
527 fn fold_if_exists_behavior(&mut self, node: IfExistsBehavior) -> IfExistsBehavior {
528 fold_if_exists_behavior(self, node)
529 }
530 fn fold_index_option(&mut self, node: IndexOption<T>) -> IndexOption<T2> {
531 fold_index_option(self, node)
532 }
533 fn fold_index_option_name(&mut self, node: IndexOptionName) -> IndexOptionName {
534 fold_index_option_name(self, node)
535 }
536 fn fold_insert_source(&mut self, node: InsertSource<T>) -> InsertSource<T2> {
537 fold_insert_source(self, node)
538 }
539 fn fold_insert_statement(&mut self, node: InsertStatement<T>) -> InsertStatement<T2> {
540 fold_insert_statement(self, node)
541 }
542 fn fold_inspect_shard_statement(&mut self, node: InspectShardStatement) -> InspectShardStatement {
543 fold_inspect_shard_statement(self, node)
544 }
545 fn fold_interval_value(&mut self, node: IntervalValue) -> IntervalValue {
546 fold_interval_value(self, node)
547 }
548 fn fold_is_expr_construct(&mut self, node: IsExprConstruct<T>) -> IsExprConstruct<T2> {
549 fold_is_expr_construct(self, node)
550 }
551 fn fold_join(&mut self, node: Join<T>) -> Join<T2> {
552 fold_join(self, node)
553 }
554 fn fold_join_constraint(&mut self, node: JoinConstraint<T>) -> JoinConstraint<T2> {
555 fold_join_constraint(self, node)
556 }
557 fn fold_join_operator(&mut self, node: JoinOperator<T>) -> JoinOperator<T2> {
558 fold_join_operator(self, node)
559 }
560 fn fold_kafka_broker(&mut self, node: KafkaBroker<T>) -> KafkaBroker<T2> {
561 fold_kafka_broker(self, node)
562 }
563 fn fold_kafka_broker_aws_privatelink(&mut self, node: KafkaBrokerAwsPrivatelink<T>) -> KafkaBrokerAwsPrivatelink<T2> {
564 fold_kafka_broker_aws_privatelink(self, node)
565 }
566 fn fold_kafka_broker_aws_privatelink_option(&mut self, node: KafkaBrokerAwsPrivatelinkOption<T>) -> KafkaBrokerAwsPrivatelinkOption<T2> {
567 fold_kafka_broker_aws_privatelink_option(self, node)
568 }
569 fn fold_kafka_broker_aws_privatelink_option_name(&mut self, node: KafkaBrokerAwsPrivatelinkOptionName) -> KafkaBrokerAwsPrivatelinkOptionName {
570 fold_kafka_broker_aws_privatelink_option_name(self, node)
571 }
572 fn fold_kafka_broker_tunnel(&mut self, node: KafkaBrokerTunnel<T>) -> KafkaBrokerTunnel<T2> {
573 fold_kafka_broker_tunnel(self, node)
574 }
575 fn fold_kafka_sink_config_option(&mut self, node: KafkaSinkConfigOption<T>) -> KafkaSinkConfigOption<T2> {
576 fold_kafka_sink_config_option(self, node)
577 }
578 fn fold_kafka_sink_config_option_name(&mut self, node: KafkaSinkConfigOptionName) -> KafkaSinkConfigOptionName {
579 fold_kafka_sink_config_option_name(self, node)
580 }
581 fn fold_kafka_source_config_option(&mut self, node: KafkaSourceConfigOption<T>) -> KafkaSourceConfigOption<T2> {
582 fold_kafka_source_config_option(self, node)
583 }
584 fn fold_kafka_source_config_option_name(&mut self, node: KafkaSourceConfigOptionName) -> KafkaSourceConfigOptionName {
585 fold_kafka_source_config_option_name(self, node)
586 }
587 fn fold_key_constraint(&mut self, node: KeyConstraint) -> KeyConstraint {
588 fold_key_constraint(self, node)
589 }
590 fn fold_limit(&mut self, node: Limit<T>) -> Limit<T2> {
591 fold_limit(self, node)
592 }
593 fn fold_load_generator(&mut self, node: LoadGenerator) -> LoadGenerator {
594 fold_load_generator(self, node)
595 }
596 fn fold_load_generator_option(&mut self, node: LoadGeneratorOption<T>) -> LoadGeneratorOption<T2> {
597 fold_load_generator_option(self, node)
598 }
599 fn fold_load_generator_option_name(&mut self, node: LoadGeneratorOptionName) -> LoadGeneratorOptionName {
600 fold_load_generator_option_name(self, node)
601 }
602 fn fold_map_entry(&mut self, node: MapEntry<T>) -> MapEntry<T2> {
603 fold_map_entry(self, node)
604 }
605 fn fold_materialized_view_option(&mut self, node: MaterializedViewOption<T>) -> MaterializedViewOption<T2> {
606 fold_materialized_view_option(self, node)
607 }
608 fn fold_materialized_view_option_name(&mut self, node: MaterializedViewOptionName) -> MaterializedViewOptionName {
609 fold_materialized_view_option_name(self, node)
610 }
611 fn fold_mut_rec_block(&mut self, node: MutRecBlock<T>) -> MutRecBlock<T2> {
612 fold_mut_rec_block(self, node)
613 }
614 fn fold_mut_rec_block_option(&mut self, node: MutRecBlockOption<T>) -> MutRecBlockOption<T2> {
615 fold_mut_rec_block_option(self, node)
616 }
617 fn fold_mut_rec_block_option_name(&mut self, node: MutRecBlockOptionName) -> MutRecBlockOptionName {
618 fold_mut_rec_block_option_name(self, node)
619 }
620 fn fold_my_sql_config_option(&mut self, node: MySqlConfigOption<T>) -> MySqlConfigOption<T2> {
621 fold_my_sql_config_option(self, node)
622 }
623 fn fold_my_sql_config_option_name(&mut self, node: MySqlConfigOptionName) -> MySqlConfigOptionName {
624 fold_my_sql_config_option_name(self, node)
625 }
626 fn fold_named_plan(&mut self, node: NamedPlan) -> NamedPlan {
627 fold_named_plan(self, node)
628 }
629 fn fold_network_policy_option(&mut self, node: NetworkPolicyOption<T>) -> NetworkPolicyOption<T2> {
630 fold_network_policy_option(self, node)
631 }
632 fn fold_network_policy_option_name(&mut self, node: NetworkPolicyOptionName) -> NetworkPolicyOptionName {
633 fold_network_policy_option_name(self, node)
634 }
635 fn fold_network_policy_rule_definition(&mut self, node: NetworkPolicyRuleDefinition<T>) -> NetworkPolicyRuleDefinition<T2> {
636 fold_network_policy_rule_definition(self, node)
637 }
638 fn fold_network_policy_rule_option(&mut self, node: NetworkPolicyRuleOption<T>) -> NetworkPolicyRuleOption<T2> {
639 fold_network_policy_rule_option(self, node)
640 }
641 fn fold_network_policy_rule_option_name(&mut self, node: NetworkPolicyRuleOptionName) -> NetworkPolicyRuleOptionName {
642 fold_network_policy_rule_option_name(self, node)
643 }
644 fn fold_notice_severity(&mut self, node: NoticeSeverity) -> NoticeSeverity {
645 fold_notice_severity(self, node)
646 }
647 fn fold_object_type(&mut self, node: ObjectType) -> ObjectType {
648 fold_object_type(self, node)
649 }
650 fn fold_op(&mut self, node: Op) -> Op {
651 fold_op(self, node)
652 }
653 fn fold_order_by_expr(&mut self, node: OrderByExpr<T>) -> OrderByExpr<T2> {
654 fold_order_by_expr(self, node)
655 }
656 fn fold_pg_config_option(&mut self, node: PgConfigOption<T>) -> PgConfigOption<T2> {
657 fold_pg_config_option(self, node)
658 }
659 fn fold_pg_config_option_name(&mut self, node: PgConfigOptionName) -> PgConfigOptionName {
660 fold_pg_config_option_name(self, node)
661 }
662 fn fold_prepare_statement(&mut self, node: PrepareStatement<T>) -> PrepareStatement<T2> {
663 fold_prepare_statement(self, node)
664 }
665 fn fold_privilege(&mut self, node: Privilege) -> Privilege {
666 fold_privilege(self, node)
667 }
668 fn fold_privilege_specification(&mut self, node: PrivilegeSpecification) -> PrivilegeSpecification {
669 fold_privilege_specification(self, node)
670 }
671 fn fold_protobuf_schema(&mut self, node: ProtobufSchema<T>) -> ProtobufSchema<T2> {
672 fold_protobuf_schema(self, node)
673 }
674 fn fold_qualified_replica(&mut self, node: QualifiedReplica) -> QualifiedReplica {
675 fold_qualified_replica(self, node)
676 }
677 fn fold_query(&mut self, node: Query<T>) -> Query<T2> {
678 fold_query(self, node)
679 }
680 fn fold_raise_statement(&mut self, node: RaiseStatement) -> RaiseStatement {
681 fold_raise_statement(self, node)
682 }
683 fn fold_reader_schema_selection_strategy(&mut self, node: ReaderSchemaSelectionStrategy) -> ReaderSchemaSelectionStrategy {
684 fold_reader_schema_selection_strategy(self, node)
685 }
686 fn fold_reassign_owned_statement(&mut self, node: ReassignOwnedStatement<T>) -> ReassignOwnedStatement<T2> {
687 fold_reassign_owned_statement(self, node)
688 }
689 fn fold_refresh_at_option_value(&mut self, node: RefreshAtOptionValue<T>) -> RefreshAtOptionValue<T2> {
690 fold_refresh_at_option_value(self, node)
691 }
692 fn fold_refresh_every_option_value(&mut self, node: RefreshEveryOptionValue<T>) -> RefreshEveryOptionValue<T2> {
693 fold_refresh_every_option_value(self, node)
694 }
695 fn fold_refresh_option_value(&mut self, node: RefreshOptionValue<T>) -> RefreshOptionValue<T2> {
696 fold_refresh_option_value(self, node)
697 }
698 fn fold_replica_definition(&mut self, node: ReplicaDefinition<T>) -> ReplicaDefinition<T2> {
699 fold_replica_definition(self, node)
700 }
701 fn fold_replica_option(&mut self, node: ReplicaOption<T>) -> ReplicaOption<T2> {
702 fold_replica_option(self, node)
703 }
704 fn fold_replica_option_name(&mut self, node: ReplicaOptionName) -> ReplicaOptionName {
705 fold_replica_option_name(self, node)
706 }
707 fn fold_reset_variable_statement(&mut self, node: ResetVariableStatement) -> ResetVariableStatement {
708 fold_reset_variable_statement(self, node)
709 }
710 fn fold_revoke_privileges_statement(&mut self, node: RevokePrivilegesStatement<T>) -> RevokePrivilegesStatement<T2> {
711 fold_revoke_privileges_statement(self, node)
712 }
713 fn fold_revoke_role_statement(&mut self, node: RevokeRoleStatement<T>) -> RevokeRoleStatement<T2> {
714 fold_revoke_role_statement(self, node)
715 }
716 fn fold_role_attribute(&mut self, node: RoleAttribute) -> RoleAttribute {
717 fold_role_attribute(self, node)
718 }
719 fn fold_rollback_statement(&mut self, node: RollbackStatement) -> RollbackStatement {
720 fold_rollback_statement(self, node)
721 }
722 fn fold_schema(&mut self, node: Schema) -> Schema {
723 fold_schema(self, node)
724 }
725 fn fold_select(&mut self, node: Select<T>) -> Select<T2> {
726 fold_select(self, node)
727 }
728 fn fold_select_item(&mut self, node: SelectItem<T>) -> SelectItem<T2> {
729 fold_select_item(self, node)
730 }
731 fn fold_select_option(&mut self, node: SelectOption<T>) -> SelectOption<T2> {
732 fold_select_option(self, node)
733 }
734 fn fold_select_option_name(&mut self, node: SelectOptionName) -> SelectOptionName {
735 fold_select_option_name(self, node)
736 }
737 fn fold_select_statement(&mut self, node: SelectStatement<T>) -> SelectStatement<T2> {
738 fold_select_statement(self, node)
739 }
740 fn fold_set_expr(&mut self, node: SetExpr<T>) -> SetExpr<T2> {
741 fold_set_expr(self, node)
742 }
743 fn fold_set_operator(&mut self, node: SetOperator) -> SetOperator {
744 fold_set_operator(self, node)
745 }
746 fn fold_set_role_var(&mut self, node: SetRoleVar) -> SetRoleVar {
747 fold_set_role_var(self, node)
748 }
749 fn fold_set_transaction_statement(&mut self, node: SetTransactionStatement) -> SetTransactionStatement {
750 fold_set_transaction_statement(self, node)
751 }
752 fn fold_set_variable_statement(&mut self, node: SetVariableStatement) -> SetVariableStatement {
753 fold_set_variable_statement(self, node)
754 }
755 fn fold_set_variable_to(&mut self, node: SetVariableTo) -> SetVariableTo {
756 fold_set_variable_to(self, node)
757 }
758 fn fold_set_variable_value(&mut self, node: SetVariableValue) -> SetVariableValue {
759 fold_set_variable_value(self, node)
760 }
761 fn fold_show_columns_statement(&mut self, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2> {
762 fold_show_columns_statement(self, node)
763 }
764 fn fold_show_create_cluster_statement(&mut self, node: ShowCreateClusterStatement<T>) -> ShowCreateClusterStatement<T2> {
765 fold_show_create_cluster_statement(self, node)
766 }
767 fn fold_show_create_connection_statement(&mut self, node: ShowCreateConnectionStatement<T>) -> ShowCreateConnectionStatement<T2> {
768 fold_show_create_connection_statement(self, node)
769 }
770 fn fold_show_create_index_statement(&mut self, node: ShowCreateIndexStatement<T>) -> ShowCreateIndexStatement<T2> {
771 fold_show_create_index_statement(self, node)
772 }
773 fn fold_show_create_materialized_view_statement(&mut self, node: ShowCreateMaterializedViewStatement<T>) -> ShowCreateMaterializedViewStatement<T2> {
774 fold_show_create_materialized_view_statement(self, node)
775 }
776 fn fold_show_create_sink_statement(&mut self, node: ShowCreateSinkStatement<T>) -> ShowCreateSinkStatement<T2> {
777 fold_show_create_sink_statement(self, node)
778 }
779 fn fold_show_create_source_statement(&mut self, node: ShowCreateSourceStatement<T>) -> ShowCreateSourceStatement<T2> {
780 fold_show_create_source_statement(self, node)
781 }
782 fn fold_show_create_table_statement(&mut self, node: ShowCreateTableStatement<T>) -> ShowCreateTableStatement<T2> {
783 fold_show_create_table_statement(self, node)
784 }
785 fn fold_show_create_type_statement(&mut self, node: ShowCreateTypeStatement<T>) -> ShowCreateTypeStatement<T2> {
786 fold_show_create_type_statement(self, node)
787 }
788 fn fold_show_create_view_statement(&mut self, node: ShowCreateViewStatement<T>) -> ShowCreateViewStatement<T2> {
789 fold_show_create_view_statement(self, node)
790 }
791 fn fold_show_object_type(&mut self, node: ShowObjectType<T>) -> ShowObjectType<T2> {
792 fold_show_object_type(self, node)
793 }
794 fn fold_show_objects_statement(&mut self, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2> {
795 fold_show_objects_statement(self, node)
796 }
797 fn fold_show_statement(&mut self, node: ShowStatement<T>) -> ShowStatement<T2> {
798 fold_show_statement(self, node)
799 }
800 fn fold_show_statement_filter(&mut self, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2> {
801 fold_show_statement_filter(self, node)
802 }
803 fn fold_show_variable_statement(&mut self, node: ShowVariableStatement) -> ShowVariableStatement {
804 fold_show_variable_statement(self, node)
805 }
806 fn fold_sink_envelope(&mut self, node: SinkEnvelope) -> SinkEnvelope {
807 fold_sink_envelope(self, node)
808 }
809 fn fold_sink_key(&mut self, node: SinkKey) -> SinkKey {
810 fold_sink_key(self, node)
811 }
812 fn fold_source_envelope(&mut self, node: SourceEnvelope) -> SourceEnvelope {
813 fold_source_envelope(self, node)
814 }
815 fn fold_source_error_policy(&mut self, node: SourceErrorPolicy) -> SourceErrorPolicy {
816 fold_source_error_policy(self, node)
817 }
818 fn fold_source_include_metadata(&mut self, node: SourceIncludeMetadata) -> SourceIncludeMetadata {
819 fold_source_include_metadata(self, node)
820 }
821 fn fold_sql_server_config_option(&mut self, node: SqlServerConfigOption<T>) -> SqlServerConfigOption<T2> {
822 fold_sql_server_config_option(self, node)
823 }
824 fn fold_sql_server_config_option_name(&mut self, node: SqlServerConfigOptionName) -> SqlServerConfigOptionName {
825 fold_sql_server_config_option_name(self, node)
826 }
827 fn fold_start_transaction_statement(&mut self, node: StartTransactionStatement) -> StartTransactionStatement {
828 fold_start_transaction_statement(self, node)
829 }
830 fn fold_statement(&mut self, node: Statement<T>) -> Statement<T2> {
831 fold_statement(self, node)
832 }
833 fn fold_subscribe_option(&mut self, node: SubscribeOption<T>) -> SubscribeOption<T2> {
834 fold_subscribe_option(self, node)
835 }
836 fn fold_subscribe_option_name(&mut self, node: SubscribeOptionName) -> SubscribeOptionName {
837 fold_subscribe_option_name(self, node)
838 }
839 fn fold_subscribe_output(&mut self, node: SubscribeOutput<T>) -> SubscribeOutput<T2> {
840 fold_subscribe_output(self, node)
841 }
842 fn fold_subscribe_relation(&mut self, node: SubscribeRelation<T>) -> SubscribeRelation<T2> {
843 fold_subscribe_relation(self, node)
844 }
845 fn fold_subscribe_statement(&mut self, node: SubscribeStatement<T>) -> SubscribeStatement<T2> {
846 fold_subscribe_statement(self, node)
847 }
848 fn fold_subscript_position(&mut self, node: SubscriptPosition<T>) -> SubscriptPosition<T2> {
849 fold_subscript_position(self, node)
850 }
851 fn fold_system_object_type(&mut self, node: SystemObjectType) -> SystemObjectType {
852 fold_system_object_type(self, node)
853 }
854 fn fold_cluster_name(&mut self, node: T::ClusterName) -> T2::ClusterName;
855 fn fold_column_reference(&mut self, node: T::ColumnReference) -> T2::ColumnReference;
856 fn fold_cte_id(&mut self, node: T::CteId) -> T2::CteId;
857 fn fold_data_type(&mut self, node: T::DataType) -> T2::DataType;
858 fn fold_database_name(&mut self, node: T::DatabaseName) -> T2::DatabaseName;
859 fn fold_item_name(&mut self, node: T::ItemName) -> T2::ItemName;
860 fn fold_nested_statement(&mut self, node: T::NestedStatement) -> T2::NestedStatement;
861 fn fold_network_policy_name(&mut self, node: T::NetworkPolicyName) -> T2::NetworkPolicyName;
862 fn fold_object_name(&mut self, node: T::ObjectName) -> T2::ObjectName;
863 fn fold_role_name(&mut self, node: T::RoleName) -> T2::RoleName;
864 fn fold_schema_name(&mut self, node: T::SchemaName) -> T2::SchemaName;
865 fn fold_table_alias(&mut self, node: TableAlias) -> TableAlias {
866 fold_table_alias(self, node)
867 }
868 fn fold_table_constraint(&mut self, node: TableConstraint<T>) -> TableConstraint<T2> {
869 fold_table_constraint(self, node)
870 }
871 fn fold_table_factor(&mut self, node: TableFactor<T>) -> TableFactor<T2> {
872 fold_table_factor(self, node)
873 }
874 fn fold_table_from_source_columns(&mut self, node: TableFromSourceColumns<T>) -> TableFromSourceColumns<T2> {
875 fold_table_from_source_columns(self, node)
876 }
877 fn fold_table_from_source_option(&mut self, node: TableFromSourceOption<T>) -> TableFromSourceOption<T2> {
878 fold_table_from_source_option(self, node)
879 }
880 fn fold_table_from_source_option_name(&mut self, node: TableFromSourceOptionName) -> TableFromSourceOptionName {
881 fold_table_from_source_option_name(self, node)
882 }
883 fn fold_table_option(&mut self, node: TableOption<T>) -> TableOption<T2> {
884 fold_table_option(self, node)
885 }
886 fn fold_table_option_name(&mut self, node: TableOptionName) -> TableOptionName {
887 fold_table_option_name(self, node)
888 }
889 fn fold_table_with_joins(&mut self, node: TableWithJoins<T>) -> TableWithJoins<T2> {
890 fold_table_with_joins(self, node)
891 }
892 fn fold_target_role_specification(&mut self, node: TargetRoleSpecification<T>) -> TargetRoleSpecification<T2> {
893 fold_target_role_specification(self, node)
894 }
895 fn fold_transaction_access_mode(&mut self, node: TransactionAccessMode) -> TransactionAccessMode {
896 fold_transaction_access_mode(self, node)
897 }
898 fn fold_transaction_isolation_level(&mut self, node: TransactionIsolationLevel) -> TransactionIsolationLevel {
899 fold_transaction_isolation_level(self, node)
900 }
901 fn fold_transaction_mode(&mut self, node: TransactionMode) -> TransactionMode {
902 fold_transaction_mode(self, node)
903 }
904 fn fold_unresolved_database_name(&mut self, node: UnresolvedDatabaseName) -> UnresolvedDatabaseName {
905 fold_unresolved_database_name(self, node)
906 }
907 fn fold_unresolved_item_name(&mut self, node: UnresolvedItemName) -> UnresolvedItemName {
908 fold_unresolved_item_name(self, node)
909 }
910 fn fold_unresolved_object_name(&mut self, node: UnresolvedObjectName) -> UnresolvedObjectName {
911 fold_unresolved_object_name(self, node)
912 }
913 fn fold_unresolved_schema_name(&mut self, node: UnresolvedSchemaName) -> UnresolvedSchemaName {
914 fold_unresolved_schema_name(self, node)
915 }
916 fn fold_update_statement(&mut self, node: UpdateStatement<T>) -> UpdateStatement<T2> {
917 fold_update_statement(self, node)
918 }
919 fn fold_validate_connection_statement(&mut self, node: ValidateConnectionStatement<T>) -> ValidateConnectionStatement<T2> {
920 fold_validate_connection_statement(self, node)
921 }
922 fn fold_value(&mut self, node: Value) -> Value {
923 fold_value(self, node)
924 }
925 fn fold_value_error(&mut self, node: ValueError) -> ValueError {
926 fold_value_error(self, node)
927 }
928 fn fold_values(&mut self, node: Values<T>) -> Values<T2> {
929 fold_values(self, node)
930 }
931 fn fold_version(&mut self, node: Version) -> Version {
932 fold_version(self, node)
933 }
934 fn fold_view_definition(&mut self, node: ViewDefinition<T>) -> ViewDefinition<T2> {
935 fold_view_definition(self, node)
936 }
937 fn fold_window_frame(&mut self, node: WindowFrame) -> WindowFrame {
938 fold_window_frame(self, node)
939 }
940 fn fold_window_frame_bound(&mut self, node: WindowFrameBound) -> WindowFrameBound {
941 fold_window_frame_bound(self, node)
942 }
943 fn fold_window_frame_units(&mut self, node: WindowFrameUnits) -> WindowFrameUnits {
944 fold_window_frame_units(self, node)
945 }
946 fn fold_window_spec(&mut self, node: WindowSpec<T>) -> WindowSpec<T2> {
947 fold_window_spec(self, node)
948 }
949 fn fold_with_option_value(&mut self, node: WithOptionValue<T>) -> WithOptionValue<T2> {
950 fold_with_option_value(self, node)
951 }
952}
953pub trait FoldNode<T: AstInfo, T2: AstInfo, > {
954 type Folded;
955 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded;
956}
957impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedGrantOrRevokeStatement<T> {
958 type Folded = AbbreviatedGrantOrRevokeStatement<T2>;
959 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
960 folder.fold_abbreviated_grant_or_revoke_statement(self)
961 }
962}
963#[allow(clippy::needless_pass_by_ref_mut)]
964pub fn fold_abbreviated_grant_or_revoke_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedGrantOrRevokeStatement<T>) -> AbbreviatedGrantOrRevokeStatement<T2>
965where
966 F: Fold<T, T2, > + ?Sized,
967{
968 match node {
969 AbbreviatedGrantOrRevokeStatement::Grant {
970 0: binding0,
971 } => {
972 AbbreviatedGrantOrRevokeStatement::Grant {
973 0: folder.fold_abbreviated_grant_statement(binding0),
974 }
975 }
976 AbbreviatedGrantOrRevokeStatement::Revoke {
977 0: binding0,
978 } => {
979 AbbreviatedGrantOrRevokeStatement::Revoke {
980 0: folder.fold_abbreviated_revoke_statement(binding0),
981 }
982 }
983 }
984}
985impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedGrantStatement<T> {
986 type Folded = AbbreviatedGrantStatement<T2>;
987 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
988 folder.fold_abbreviated_grant_statement(self)
989 }
990}
991#[allow(clippy::needless_pass_by_ref_mut)]
992pub fn fold_abbreviated_grant_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedGrantStatement<T>) -> AbbreviatedGrantStatement<T2>
993where
994 F: Fold<T, T2, > + ?Sized,
995{
996 AbbreviatedGrantStatement {
997 privileges: folder.fold_privilege_specification(node.privileges),
998 object_type: folder.fold_object_type(node.object_type),
999 grantees: node.grantees.into_iter().map(|v| folder.fold_role_name(v)).collect(),
1000 }
1001}
1002impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AbbreviatedRevokeStatement<T> {
1003 type Folded = AbbreviatedRevokeStatement<T2>;
1004 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1005 folder.fold_abbreviated_revoke_statement(self)
1006 }
1007}
1008#[allow(clippy::needless_pass_by_ref_mut)]
1009pub fn fold_abbreviated_revoke_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AbbreviatedRevokeStatement<T>) -> AbbreviatedRevokeStatement<T2>
1010where
1011 F: Fold<T, T2, > + ?Sized,
1012{
1013 AbbreviatedRevokeStatement {
1014 privileges: folder.fold_privilege_specification(node.privileges),
1015 object_type: folder.fold_object_type(node.object_type),
1016 revokees: node.revokees.into_iter().map(|v| folder.fold_role_name(v)).collect(),
1017 }
1018}
1019impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterClusterAction<T> {
1020 type Folded = AlterClusterAction<T2>;
1021 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1022 folder.fold_alter_cluster_action(self)
1023 }
1024}
1025#[allow(clippy::needless_pass_by_ref_mut)]
1026pub fn fold_alter_cluster_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterClusterAction<T>) -> AlterClusterAction<T2>
1027where
1028 F: Fold<T, T2, > + ?Sized,
1029{
1030 match node {
1031 AlterClusterAction::SetOptions {
1032 options: binding0,
1033 with_options: binding1,
1034 } => {
1035 AlterClusterAction::SetOptions {
1036 options: binding0.into_iter().map(|v| folder.fold_cluster_option(v)).collect(),
1037 with_options: binding1.into_iter().map(|v| folder.fold_cluster_alter_option(v)).collect(),
1038 }
1039 }
1040 AlterClusterAction::ResetOptions {
1041 0: binding0,
1042 } => {
1043 AlterClusterAction::ResetOptions {
1044 0: binding0.into_iter().map(|v| folder.fold_cluster_option_name(v)).collect(),
1045 }
1046 }
1047 }
1048}
1049impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterClusterStatement<T> {
1050 type Folded = AlterClusterStatement<T2>;
1051 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1052 folder.fold_alter_cluster_statement(self)
1053 }
1054}
1055#[allow(clippy::needless_pass_by_ref_mut)]
1056pub fn fold_alter_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterClusterStatement<T>) -> AlterClusterStatement<T2>
1057where
1058 F: Fold<T, T2, > + ?Sized,
1059{
1060 AlterClusterStatement {
1061 if_exists: node.if_exists,
1062 name: folder.fold_ident(node.name),
1063 action: folder.fold_alter_cluster_action(node.action),
1064 }
1065}
1066impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionAction<T> {
1067 type Folded = AlterConnectionAction<T2>;
1068 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1069 folder.fold_alter_connection_action(self)
1070 }
1071}
1072#[allow(clippy::needless_pass_by_ref_mut)]
1073pub fn fold_alter_connection_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionAction<T>) -> AlterConnectionAction<T2>
1074where
1075 F: Fold<T, T2, > + ?Sized,
1076{
1077 match node {
1078 AlterConnectionAction::RotateKeys {
1079 } => {
1080 AlterConnectionAction::RotateKeys {
1081 }
1082 }
1083 AlterConnectionAction::SetOption {
1084 0: binding0,
1085 } => {
1086 AlterConnectionAction::SetOption {
1087 0: folder.fold_connection_option(binding0),
1088 }
1089 }
1090 AlterConnectionAction::DropOption {
1091 0: binding0,
1092 } => {
1093 AlterConnectionAction::DropOption {
1094 0: folder.fold_connection_option_name(binding0),
1095 }
1096 }
1097 }
1098}
1099impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionOption<T> {
1100 type Folded = AlterConnectionOption<T2>;
1101 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1102 folder.fold_alter_connection_option(self)
1103 }
1104}
1105#[allow(clippy::needless_pass_by_ref_mut)]
1106pub fn fold_alter_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionOption<T>) -> AlterConnectionOption<T2>
1107where
1108 F: Fold<T, T2, > + ?Sized,
1109{
1110 AlterConnectionOption {
1111 name: folder.fold_alter_connection_option_name(node.name),
1112 value: node.value.map(|v| folder.fold_with_option_value(v)),
1113 }
1114}
1115impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionOptionName {
1116 type Folded = AlterConnectionOptionName;
1117 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1118 folder.fold_alter_connection_option_name(self)
1119 }
1120}
1121#[allow(clippy::needless_pass_by_ref_mut)]
1122pub fn fold_alter_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionOptionName) -> AlterConnectionOptionName
1123where
1124 F: Fold<T, T2, > + ?Sized,
1125{
1126 match node {
1127 AlterConnectionOptionName::Validate {
1128 } => {
1129 AlterConnectionOptionName::Validate {
1130 }
1131 }
1132 }
1133}
1134impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterConnectionStatement<T> {
1135 type Folded = AlterConnectionStatement<T2>;
1136 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1137 folder.fold_alter_connection_statement(self)
1138 }
1139}
1140#[allow(clippy::needless_pass_by_ref_mut)]
1141pub fn fold_alter_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterConnectionStatement<T>) -> AlterConnectionStatement<T2>
1142where
1143 F: Fold<T, T2, > + ?Sized,
1144{
1145 AlterConnectionStatement {
1146 name: folder.fold_unresolved_item_name(node.name),
1147 if_exists: node.if_exists,
1148 actions: node.actions.into_iter().map(|v| folder.fold_alter_connection_action(v)).collect(),
1149 with_options: node.with_options.into_iter().map(|v| folder.fold_alter_connection_option(v)).collect(),
1150 }
1151}
1152impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterDefaultPrivilegesStatement<T> {
1153 type Folded = AlterDefaultPrivilegesStatement<T2>;
1154 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1155 folder.fold_alter_default_privileges_statement(self)
1156 }
1157}
1158#[allow(clippy::needless_pass_by_ref_mut)]
1159pub fn fold_alter_default_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterDefaultPrivilegesStatement<T>) -> AlterDefaultPrivilegesStatement<T2>
1160where
1161 F: Fold<T, T2, > + ?Sized,
1162{
1163 AlterDefaultPrivilegesStatement {
1164 target_roles: folder.fold_target_role_specification(node.target_roles),
1165 target_objects: folder.fold_grant_target_all_specification(node.target_objects),
1166 grant_or_revoke: folder.fold_abbreviated_grant_or_revoke_statement(node.grant_or_revoke),
1167 }
1168}
1169impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterIndexAction<T> {
1170 type Folded = AlterIndexAction<T2>;
1171 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1172 folder.fold_alter_index_action(self)
1173 }
1174}
1175#[allow(clippy::needless_pass_by_ref_mut)]
1176pub fn fold_alter_index_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexAction<T>) -> AlterIndexAction<T2>
1177where
1178 F: Fold<T, T2, > + ?Sized,
1179{
1180 match node {
1181 AlterIndexAction::SetOptions {
1182 0: binding0,
1183 } => {
1184 AlterIndexAction::SetOptions {
1185 0: binding0.into_iter().map(|v| folder.fold_index_option(v)).collect(),
1186 }
1187 }
1188 AlterIndexAction::ResetOptions {
1189 0: binding0,
1190 } => {
1191 AlterIndexAction::ResetOptions {
1192 0: binding0.into_iter().map(|v| folder.fold_index_option_name(v)).collect(),
1193 }
1194 }
1195 }
1196}
1197impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterIndexStatement<T> {
1198 type Folded = AlterIndexStatement<T2>;
1199 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1200 folder.fold_alter_index_statement(self)
1201 }
1202}
1203#[allow(clippy::needless_pass_by_ref_mut)]
1204pub fn fold_alter_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexStatement<T>) -> AlterIndexStatement<T2>
1205where
1206 F: Fold<T, T2, > + ?Sized,
1207{
1208 AlterIndexStatement {
1209 index_name: folder.fold_unresolved_item_name(node.index_name),
1210 if_exists: node.if_exists,
1211 action: folder.fold_alter_index_action(node.action),
1212 }
1213}
1214impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterNetworkPolicyStatement<T> {
1215 type Folded = AlterNetworkPolicyStatement<T2>;
1216 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1217 folder.fold_alter_network_policy_statement(self)
1218 }
1219}
1220#[allow(clippy::needless_pass_by_ref_mut)]
1221pub fn fold_alter_network_policy_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterNetworkPolicyStatement<T>) -> AlterNetworkPolicyStatement<T2>
1222where
1223 F: Fold<T, T2, > + ?Sized,
1224{
1225 AlterNetworkPolicyStatement {
1226 name: folder.fold_ident(node.name),
1227 options: node.options.into_iter().map(|v| folder.fold_network_policy_option(v)).collect(),
1228 }
1229}
1230impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterObjectRenameStatement {
1231 type Folded = AlterObjectRenameStatement;
1232 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1233 folder.fold_alter_object_rename_statement(self)
1234 }
1235}
1236#[allow(clippy::needless_pass_by_ref_mut)]
1237pub fn fold_alter_object_rename_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement
1238where
1239 F: Fold<T, T2, > + ?Sized,
1240{
1241 AlterObjectRenameStatement {
1242 object_type: folder.fold_object_type(node.object_type),
1243 if_exists: node.if_exists,
1244 name: folder.fold_unresolved_object_name(node.name),
1245 to_item_name: folder.fold_ident(node.to_item_name),
1246 }
1247}
1248impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterObjectSwapStatement {
1249 type Folded = AlterObjectSwapStatement;
1250 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1251 folder.fold_alter_object_swap_statement(self)
1252 }
1253}
1254#[allow(clippy::needless_pass_by_ref_mut)]
1255pub fn fold_alter_object_swap_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterObjectSwapStatement) -> AlterObjectSwapStatement
1256where
1257 F: Fold<T, T2, > + ?Sized,
1258{
1259 AlterObjectSwapStatement {
1260 object_type: folder.fold_object_type(node.object_type),
1261 name_a: folder.fold_unresolved_object_name(node.name_a),
1262 name_b: folder.fold_ident(node.name_b),
1263 }
1264}
1265impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterOwnerStatement<T> {
1266 type Folded = AlterOwnerStatement<T2>;
1267 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1268 folder.fold_alter_owner_statement(self)
1269 }
1270}
1271#[allow(clippy::needless_pass_by_ref_mut)]
1272pub fn fold_alter_owner_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterOwnerStatement<T>) -> AlterOwnerStatement<T2>
1273where
1274 F: Fold<T, T2, > + ?Sized,
1275{
1276 AlterOwnerStatement {
1277 object_type: folder.fold_object_type(node.object_type),
1278 if_exists: node.if_exists,
1279 name: folder.fold_unresolved_object_name(node.name),
1280 new_owner: folder.fold_role_name(node.new_owner),
1281 }
1282}
1283impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRetainHistoryStatement<T> {
1284 type Folded = AlterRetainHistoryStatement<T2>;
1285 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1286 folder.fold_alter_retain_history_statement(self)
1287 }
1288}
1289#[allow(clippy::needless_pass_by_ref_mut)]
1290pub fn fold_alter_retain_history_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRetainHistoryStatement<T>) -> AlterRetainHistoryStatement<T2>
1291where
1292 F: Fold<T, T2, > + ?Sized,
1293{
1294 AlterRetainHistoryStatement {
1295 object_type: folder.fold_object_type(node.object_type),
1296 if_exists: node.if_exists,
1297 name: folder.fold_unresolved_object_name(node.name),
1298 history: node.history.map(|v| folder.fold_with_option_value(v)),
1299 }
1300}
1301impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRoleOption {
1302 type Folded = AlterRoleOption;
1303 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1304 folder.fold_alter_role_option(self)
1305 }
1306}
1307#[allow(clippy::needless_pass_by_ref_mut)]
1308pub fn fold_alter_role_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRoleOption) -> AlterRoleOption
1309where
1310 F: Fold<T, T2, > + ?Sized,
1311{
1312 match node {
1313 AlterRoleOption::Attributes {
1314 0: binding0,
1315 } => {
1316 AlterRoleOption::Attributes {
1317 0: binding0.into_iter().map(|v| folder.fold_role_attribute(v)).collect(),
1318 }
1319 }
1320 AlterRoleOption::Variable {
1321 0: binding0,
1322 } => {
1323 AlterRoleOption::Variable {
1324 0: folder.fold_set_role_var(binding0),
1325 }
1326 }
1327 }
1328}
1329impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterRoleStatement<T> {
1330 type Folded = AlterRoleStatement<T2>;
1331 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1332 folder.fold_alter_role_statement(self)
1333 }
1334}
1335#[allow(clippy::needless_pass_by_ref_mut)]
1336pub fn fold_alter_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterRoleStatement<T>) -> AlterRoleStatement<T2>
1337where
1338 F: Fold<T, T2, > + ?Sized,
1339{
1340 AlterRoleStatement {
1341 name: folder.fold_role_name(node.name),
1342 option: folder.fold_alter_role_option(node.option),
1343 }
1344}
1345impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSecretStatement<T> {
1346 type Folded = AlterSecretStatement<T2>;
1347 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1348 folder.fold_alter_secret_statement(self)
1349 }
1350}
1351#[allow(clippy::needless_pass_by_ref_mut)]
1352pub fn fold_alter_secret_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSecretStatement<T>) -> AlterSecretStatement<T2>
1353where
1354 F: Fold<T, T2, > + ?Sized,
1355{
1356 AlterSecretStatement {
1357 name: folder.fold_unresolved_item_name(node.name),
1358 if_exists: node.if_exists,
1359 value: folder.fold_expr(node.value),
1360 }
1361}
1362impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSetClusterStatement<T> {
1363 type Folded = AlterSetClusterStatement<T2>;
1364 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1365 folder.fold_alter_set_cluster_statement(self)
1366 }
1367}
1368#[allow(clippy::needless_pass_by_ref_mut)]
1369pub fn fold_alter_set_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSetClusterStatement<T>) -> AlterSetClusterStatement<T2>
1370where
1371 F: Fold<T, T2, > + ?Sized,
1372{
1373 AlterSetClusterStatement {
1374 if_exists: node.if_exists,
1375 name: folder.fold_unresolved_item_name(node.name),
1376 object_type: folder.fold_object_type(node.object_type),
1377 set_cluster: folder.fold_cluster_name(node.set_cluster),
1378 }
1379}
1380impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSinkAction<T> {
1381 type Folded = AlterSinkAction<T2>;
1382 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1383 folder.fold_alter_sink_action(self)
1384 }
1385}
1386#[allow(clippy::needless_pass_by_ref_mut)]
1387pub fn fold_alter_sink_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSinkAction<T>) -> AlterSinkAction<T2>
1388where
1389 F: Fold<T, T2, > + ?Sized,
1390{
1391 match node {
1392 AlterSinkAction::SetOptions {
1393 0: binding0,
1394 } => {
1395 AlterSinkAction::SetOptions {
1396 0: binding0.into_iter().map(|v| folder.fold_create_sink_option(v)).collect(),
1397 }
1398 }
1399 AlterSinkAction::ResetOptions {
1400 0: binding0,
1401 } => {
1402 AlterSinkAction::ResetOptions {
1403 0: binding0.into_iter().map(|v| folder.fold_create_sink_option_name(v)).collect(),
1404 }
1405 }
1406 AlterSinkAction::ChangeRelation {
1407 0: binding0,
1408 } => {
1409 AlterSinkAction::ChangeRelation {
1410 0: folder.fold_item_name(binding0),
1411 }
1412 }
1413 }
1414}
1415impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSinkStatement<T> {
1416 type Folded = AlterSinkStatement<T2>;
1417 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1418 folder.fold_alter_sink_statement(self)
1419 }
1420}
1421#[allow(clippy::needless_pass_by_ref_mut)]
1422pub fn fold_alter_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSinkStatement<T>) -> AlterSinkStatement<T2>
1423where
1424 F: Fold<T, T2, > + ?Sized,
1425{
1426 AlterSinkStatement {
1427 sink_name: folder.fold_unresolved_item_name(node.sink_name),
1428 if_exists: node.if_exists,
1429 action: folder.fold_alter_sink_action(node.action),
1430 }
1431}
1432impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAction<T> {
1433 type Folded = AlterSourceAction<T2>;
1434 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1435 folder.fold_alter_source_action(self)
1436 }
1437}
1438#[allow(clippy::needless_pass_by_ref_mut)]
1439pub fn fold_alter_source_action<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAction<T>) -> AlterSourceAction<T2>
1440where
1441 F: Fold<T, T2, > + ?Sized,
1442{
1443 match node {
1444 AlterSourceAction::SetOptions {
1445 0: binding0,
1446 } => {
1447 AlterSourceAction::SetOptions {
1448 0: binding0.into_iter().map(|v| folder.fold_create_source_option(v)).collect(),
1449 }
1450 }
1451 AlterSourceAction::ResetOptions {
1452 0: binding0,
1453 } => {
1454 AlterSourceAction::ResetOptions {
1455 0: binding0.into_iter().map(|v| folder.fold_create_source_option_name(v)).collect(),
1456 }
1457 }
1458 AlterSourceAction::AddSubsources {
1459 external_references: binding0,
1460 options: binding1,
1461 } => {
1462 AlterSourceAction::AddSubsources {
1463 external_references: binding0.into_iter().map(|v| folder.fold_external_reference_export(v)).collect(),
1464 options: binding1.into_iter().map(|v| folder.fold_alter_source_add_subsource_option(v)).collect(),
1465 }
1466 }
1467 AlterSourceAction::DropSubsources {
1468 if_exists: binding0,
1469 cascade: binding1,
1470 names: binding2,
1471 } => {
1472 AlterSourceAction::DropSubsources {
1473 if_exists: binding0,
1474 cascade: binding1,
1475 names: binding2.into_iter().map(|v| folder.fold_unresolved_item_name(v)).collect(),
1476 }
1477 }
1478 AlterSourceAction::RefreshReferences {
1479 } => {
1480 AlterSourceAction::RefreshReferences {
1481 }
1482 }
1483 }
1484}
1485impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAddSubsourceOption<T> {
1486 type Folded = AlterSourceAddSubsourceOption<T2>;
1487 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1488 folder.fold_alter_source_add_subsource_option(self)
1489 }
1490}
1491#[allow(clippy::needless_pass_by_ref_mut)]
1492pub fn fold_alter_source_add_subsource_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAddSubsourceOption<T>) -> AlterSourceAddSubsourceOption<T2>
1493where
1494 F: Fold<T, T2, > + ?Sized,
1495{
1496 AlterSourceAddSubsourceOption {
1497 name: folder.fold_alter_source_add_subsource_option_name(node.name),
1498 value: node.value.map(|v| folder.fold_with_option_value(v)),
1499 }
1500}
1501impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceAddSubsourceOptionName {
1502 type Folded = AlterSourceAddSubsourceOptionName;
1503 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1504 folder.fold_alter_source_add_subsource_option_name(self)
1505 }
1506}
1507#[allow(clippy::needless_pass_by_ref_mut)]
1508pub fn fold_alter_source_add_subsource_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceAddSubsourceOptionName) -> AlterSourceAddSubsourceOptionName
1509where
1510 F: Fold<T, T2, > + ?Sized,
1511{
1512 match node {
1513 AlterSourceAddSubsourceOptionName::TextColumns {
1514 } => {
1515 AlterSourceAddSubsourceOptionName::TextColumns {
1516 }
1517 }
1518 AlterSourceAddSubsourceOptionName::ExcludeColumns {
1519 } => {
1520 AlterSourceAddSubsourceOptionName::ExcludeColumns {
1521 }
1522 }
1523 AlterSourceAddSubsourceOptionName::Details {
1524 } => {
1525 AlterSourceAddSubsourceOptionName::Details {
1526 }
1527 }
1528 }
1529}
1530impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSourceStatement<T> {
1531 type Folded = AlterSourceStatement<T2>;
1532 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1533 folder.fold_alter_source_statement(self)
1534 }
1535}
1536#[allow(clippy::needless_pass_by_ref_mut)]
1537pub fn fold_alter_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSourceStatement<T>) -> AlterSourceStatement<T2>
1538where
1539 F: Fold<T, T2, > + ?Sized,
1540{
1541 AlterSourceStatement {
1542 source_name: folder.fold_unresolved_item_name(node.source_name),
1543 if_exists: node.if_exists,
1544 action: folder.fold_alter_source_action(node.action),
1545 }
1546}
1547impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemResetAllStatement {
1548 type Folded = AlterSystemResetAllStatement;
1549 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1550 folder.fold_alter_system_reset_all_statement(self)
1551 }
1552}
1553#[allow(clippy::needless_pass_by_ref_mut)]
1554pub fn fold_alter_system_reset_all_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemResetAllStatement) -> AlterSystemResetAllStatement
1555where
1556 F: Fold<T, T2, > + ?Sized,
1557{
1558 AlterSystemResetAllStatement {
1559 }
1560}
1561impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemResetStatement {
1562 type Folded = AlterSystemResetStatement;
1563 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1564 folder.fold_alter_system_reset_statement(self)
1565 }
1566}
1567#[allow(clippy::needless_pass_by_ref_mut)]
1568pub fn fold_alter_system_reset_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemResetStatement) -> AlterSystemResetStatement
1569where
1570 F: Fold<T, T2, > + ?Sized,
1571{
1572 AlterSystemResetStatement {
1573 name: folder.fold_ident(node.name),
1574 }
1575}
1576impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterSystemSetStatement {
1577 type Folded = AlterSystemSetStatement;
1578 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1579 folder.fold_alter_system_set_statement(self)
1580 }
1581}
1582#[allow(clippy::needless_pass_by_ref_mut)]
1583pub fn fold_alter_system_set_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterSystemSetStatement) -> AlterSystemSetStatement
1584where
1585 F: Fold<T, T2, > + ?Sized,
1586{
1587 AlterSystemSetStatement {
1588 name: folder.fold_ident(node.name),
1589 to: folder.fold_set_variable_to(node.to),
1590 }
1591}
1592impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AlterTableAddColumnStatement<T> {
1593 type Folded = AlterTableAddColumnStatement<T2>;
1594 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1595 folder.fold_alter_table_add_column_statement(self)
1596 }
1597}
1598#[allow(clippy::needless_pass_by_ref_mut)]
1599pub fn fold_alter_table_add_column_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterTableAddColumnStatement<T>) -> AlterTableAddColumnStatement<T2>
1600where
1601 F: Fold<T, T2, > + ?Sized,
1602{
1603 AlterTableAddColumnStatement {
1604 if_exists: node.if_exists,
1605 name: folder.fold_unresolved_item_name(node.name),
1606 if_col_not_exist: node.if_col_not_exist,
1607 column_name: folder.fold_ident(node.column_name),
1608 data_type: folder.fold_data_type(node.data_type),
1609 }
1610}
1611impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AsOf<T> {
1612 type Folded = AsOf<T2>;
1613 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1614 folder.fold_as_of(self)
1615 }
1616}
1617#[allow(clippy::needless_pass_by_ref_mut)]
1618pub fn fold_as_of<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AsOf<T>) -> AsOf<T2>
1619where
1620 F: Fold<T, T2, > + ?Sized,
1621{
1622 match node {
1623 AsOf::At {
1624 0: binding0,
1625 } => {
1626 AsOf::At {
1627 0: folder.fold_expr(binding0),
1628 }
1629 }
1630 AsOf::AtLeast {
1631 0: binding0,
1632 } => {
1633 AsOf::AtLeast {
1634 0: folder.fold_expr(binding0),
1635 }
1636 }
1637 }
1638}
1639impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Assignment<T> {
1640 type Folded = Assignment<T2>;
1641 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1642 folder.fold_assignment(self)
1643 }
1644}
1645#[allow(clippy::needless_pass_by_ref_mut)]
1646pub fn fold_assignment<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Assignment<T>) -> Assignment<T2>
1647where
1648 F: Fold<T, T2, > + ?Sized,
1649{
1650 Assignment {
1651 id: folder.fold_ident(node.id),
1652 value: folder.fold_expr(node.value),
1653 }
1654}
1655impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroDocOn<T> {
1656 type Folded = AvroDocOn<T2>;
1657 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1658 folder.fold_avro_doc_on(self)
1659 }
1660}
1661#[allow(clippy::needless_pass_by_ref_mut)]
1662pub fn fold_avro_doc_on<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroDocOn<T>) -> AvroDocOn<T2>
1663where
1664 F: Fold<T, T2, > + ?Sized,
1665{
1666 AvroDocOn {
1667 identifier: folder.fold_doc_on_identifier(node.identifier),
1668 for_schema: folder.fold_doc_on_schema(node.for_schema),
1669 }
1670}
1671impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchema<T> {
1672 type Folded = AvroSchema<T2>;
1673 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1674 folder.fold_avro_schema(self)
1675 }
1676}
1677#[allow(clippy::needless_pass_by_ref_mut)]
1678pub fn fold_avro_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchema<T>) -> AvroSchema<T2>
1679where
1680 F: Fold<T, T2, > + ?Sized,
1681{
1682 match node {
1683 AvroSchema::Csr {
1684 csr_connection: binding0,
1685 } => {
1686 AvroSchema::Csr {
1687 csr_connection: folder.fold_csr_connection_avro(binding0),
1688 }
1689 }
1690 AvroSchema::InlineSchema {
1691 schema: binding0,
1692 with_options: binding1,
1693 } => {
1694 AvroSchema::InlineSchema {
1695 schema: folder.fold_schema(binding0),
1696 with_options: binding1.into_iter().map(|v| folder.fold_avro_schema_option(v)).collect(),
1697 }
1698 }
1699 }
1700}
1701impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchemaOption<T> {
1702 type Folded = AvroSchemaOption<T2>;
1703 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1704 folder.fold_avro_schema_option(self)
1705 }
1706}
1707#[allow(clippy::needless_pass_by_ref_mut)]
1708pub fn fold_avro_schema_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchemaOption<T>) -> AvroSchemaOption<T2>
1709where
1710 F: Fold<T, T2, > + ?Sized,
1711{
1712 AvroSchemaOption {
1713 name: folder.fold_avro_schema_option_name(node.name),
1714 value: node.value.map(|v| folder.fold_with_option_value(v)),
1715 }
1716}
1717impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for AvroSchemaOptionName {
1718 type Folded = AvroSchemaOptionName;
1719 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1720 folder.fold_avro_schema_option_name(self)
1721 }
1722}
1723#[allow(clippy::needless_pass_by_ref_mut)]
1724pub fn fold_avro_schema_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchemaOptionName) -> AvroSchemaOptionName
1725where
1726 F: Fold<T, T2, > + ?Sized,
1727{
1728 match node {
1729 AvroSchemaOptionName::ConfluentWireFormat {
1730 } => {
1731 AvroSchemaOptionName::ConfluentWireFormat {
1732 }
1733 }
1734 }
1735}
1736impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CatalogName {
1737 type Folded = CatalogName;
1738 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1739 folder.fold_catalog_name(self)
1740 }
1741}
1742#[allow(clippy::needless_pass_by_ref_mut)]
1743pub fn fold_catalog_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CatalogName) -> CatalogName
1744where
1745 F: Fold<T, T2, > + ?Sized,
1746{
1747 match node {
1748 CatalogName::ItemName {
1749 0: binding0,
1750 } => {
1751 CatalogName::ItemName {
1752 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
1753 }
1754 }
1755 CatalogName::FuncName {
1756 0: binding0,
1757 } => {
1758 CatalogName::FuncName {
1759 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
1760 }
1761 }
1762 }
1763}
1764impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CloseStatement {
1765 type Folded = CloseStatement;
1766 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1767 folder.fold_close_statement(self)
1768 }
1769}
1770#[allow(clippy::needless_pass_by_ref_mut)]
1771pub fn fold_close_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CloseStatement) -> CloseStatement
1772where
1773 F: Fold<T, T2, > + ?Sized,
1774{
1775 CloseStatement {
1776 name: folder.fold_ident(node.name),
1777 }
1778}
1779impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOption<T> {
1780 type Folded = ClusterAlterOption<T2>;
1781 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1782 folder.fold_cluster_alter_option(self)
1783 }
1784}
1785#[allow(clippy::needless_pass_by_ref_mut)]
1786pub fn fold_cluster_alter_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOption<T>) -> ClusterAlterOption<T2>
1787where
1788 F: Fold<T, T2, > + ?Sized,
1789{
1790 ClusterAlterOption {
1791 name: folder.fold_cluster_alter_option_name(node.name),
1792 value: node.value.map(|v| folder.fold_with_option_value(v)),
1793 }
1794}
1795impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOptionName {
1796 type Folded = ClusterAlterOptionName;
1797 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1798 folder.fold_cluster_alter_option_name(self)
1799 }
1800}
1801#[allow(clippy::needless_pass_by_ref_mut)]
1802pub fn fold_cluster_alter_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOptionName) -> ClusterAlterOptionName
1803where
1804 F: Fold<T, T2, > + ?Sized,
1805{
1806 match node {
1807 ClusterAlterOptionName::Wait {
1808 } => {
1809 ClusterAlterOptionName::Wait {
1810 }
1811 }
1812 }
1813}
1814impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterOptionValue<T> {
1815 type Folded = ClusterAlterOptionValue<T2>;
1816 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1817 folder.fold_cluster_alter_option_value(self)
1818 }
1819}
1820#[allow(clippy::needless_pass_by_ref_mut)]
1821pub fn fold_cluster_alter_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterOptionValue<T>) -> ClusterAlterOptionValue<T2>
1822where
1823 F: Fold<T, T2, > + ?Sized,
1824{
1825 match node {
1826 ClusterAlterOptionValue::For {
1827 0: binding0,
1828 } => {
1829 ClusterAlterOptionValue::For {
1830 0: folder.fold_value(binding0),
1831 }
1832 }
1833 ClusterAlterOptionValue::UntilReady {
1834 0: binding0,
1835 } => {
1836 ClusterAlterOptionValue::UntilReady {
1837 0: binding0.into_iter().map(|v| folder.fold_cluster_alter_until_ready_option(v)).collect(),
1838 }
1839 }
1840 }
1841}
1842impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterUntilReadyOption<T> {
1843 type Folded = ClusterAlterUntilReadyOption<T2>;
1844 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1845 folder.fold_cluster_alter_until_ready_option(self)
1846 }
1847}
1848#[allow(clippy::needless_pass_by_ref_mut)]
1849pub fn fold_cluster_alter_until_ready_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterUntilReadyOption<T>) -> ClusterAlterUntilReadyOption<T2>
1850where
1851 F: Fold<T, T2, > + ?Sized,
1852{
1853 ClusterAlterUntilReadyOption {
1854 name: folder.fold_cluster_alter_until_ready_option_name(node.name),
1855 value: node.value.map(|v| folder.fold_with_option_value(v)),
1856 }
1857}
1858impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterAlterUntilReadyOptionName {
1859 type Folded = ClusterAlterUntilReadyOptionName;
1860 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1861 folder.fold_cluster_alter_until_ready_option_name(self)
1862 }
1863}
1864#[allow(clippy::needless_pass_by_ref_mut)]
1865pub fn fold_cluster_alter_until_ready_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterAlterUntilReadyOptionName) -> ClusterAlterUntilReadyOptionName
1866where
1867 F: Fold<T, T2, > + ?Sized,
1868{
1869 match node {
1870 ClusterAlterUntilReadyOptionName::Timeout {
1871 } => {
1872 ClusterAlterUntilReadyOptionName::Timeout {
1873 }
1874 }
1875 ClusterAlterUntilReadyOptionName::OnTimeout {
1876 } => {
1877 ClusterAlterUntilReadyOptionName::OnTimeout {
1878 }
1879 }
1880 }
1881}
1882impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterFeature<T> {
1883 type Folded = ClusterFeature<T2>;
1884 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1885 folder.fold_cluster_feature(self)
1886 }
1887}
1888#[allow(clippy::needless_pass_by_ref_mut)]
1889pub fn fold_cluster_feature<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterFeature<T>) -> ClusterFeature<T2>
1890where
1891 F: Fold<T, T2, > + ?Sized,
1892{
1893 ClusterFeature {
1894 name: folder.fold_cluster_feature_name(node.name),
1895 value: node.value.map(|v| folder.fold_with_option_value(v)),
1896 }
1897}
1898impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterFeatureName {
1899 type Folded = ClusterFeatureName;
1900 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1901 folder.fold_cluster_feature_name(self)
1902 }
1903}
1904#[allow(clippy::needless_pass_by_ref_mut)]
1905pub fn fold_cluster_feature_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterFeatureName) -> ClusterFeatureName
1906where
1907 F: Fold<T, T2, > + ?Sized,
1908{
1909 match node {
1910 ClusterFeatureName::ReoptimizeImportedViews {
1911 } => {
1912 ClusterFeatureName::ReoptimizeImportedViews {
1913 }
1914 }
1915 ClusterFeatureName::EnableNewOuterJoinLowering {
1916 } => {
1917 ClusterFeatureName::EnableNewOuterJoinLowering {
1918 }
1919 }
1920 ClusterFeatureName::EnableEagerDeltaJoins {
1921 } => {
1922 ClusterFeatureName::EnableEagerDeltaJoins {
1923 }
1924 }
1925 ClusterFeatureName::EnableVariadicLeftJoinLowering {
1926 } => {
1927 ClusterFeatureName::EnableVariadicLeftJoinLowering {
1928 }
1929 }
1930 ClusterFeatureName::EnableLetrecFixpointAnalysis {
1931 } => {
1932 ClusterFeatureName::EnableLetrecFixpointAnalysis {
1933 }
1934 }
1935 ClusterFeatureName::EnableJoinPrioritizeArranged {
1936 } => {
1937 ClusterFeatureName::EnableJoinPrioritizeArranged {
1938 }
1939 }
1940 ClusterFeatureName::EnableProjectionPushdownAfterRelationCse {
1941 } => {
1942 ClusterFeatureName::EnableProjectionPushdownAfterRelationCse {
1943 }
1944 }
1945 }
1946}
1947impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterOption<T> {
1948 type Folded = ClusterOption<T2>;
1949 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1950 folder.fold_cluster_option(self)
1951 }
1952}
1953#[allow(clippy::needless_pass_by_ref_mut)]
1954pub fn fold_cluster_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterOption<T>) -> ClusterOption<T2>
1955where
1956 F: Fold<T, T2, > + ?Sized,
1957{
1958 ClusterOption {
1959 name: folder.fold_cluster_option_name(node.name),
1960 value: node.value.map(|v| folder.fold_with_option_value(v)),
1961 }
1962}
1963impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterOptionName {
1964 type Folded = ClusterOptionName;
1965 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
1966 folder.fold_cluster_option_name(self)
1967 }
1968}
1969#[allow(clippy::needless_pass_by_ref_mut)]
1970pub fn fold_cluster_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterOptionName) -> ClusterOptionName
1971where
1972 F: Fold<T, T2, > + ?Sized,
1973{
1974 match node {
1975 ClusterOptionName::AvailabilityZones {
1976 } => {
1977 ClusterOptionName::AvailabilityZones {
1978 }
1979 }
1980 ClusterOptionName::Disk {
1981 } => {
1982 ClusterOptionName::Disk {
1983 }
1984 }
1985 ClusterOptionName::IntrospectionInterval {
1986 } => {
1987 ClusterOptionName::IntrospectionInterval {
1988 }
1989 }
1990 ClusterOptionName::IntrospectionDebugging {
1991 } => {
1992 ClusterOptionName::IntrospectionDebugging {
1993 }
1994 }
1995 ClusterOptionName::Managed {
1996 } => {
1997 ClusterOptionName::Managed {
1998 }
1999 }
2000 ClusterOptionName::Replicas {
2001 } => {
2002 ClusterOptionName::Replicas {
2003 }
2004 }
2005 ClusterOptionName::ReplicationFactor {
2006 } => {
2007 ClusterOptionName::ReplicationFactor {
2008 }
2009 }
2010 ClusterOptionName::Size {
2011 } => {
2012 ClusterOptionName::Size {
2013 }
2014 }
2015 ClusterOptionName::Schedule {
2016 } => {
2017 ClusterOptionName::Schedule {
2018 }
2019 }
2020 ClusterOptionName::WorkloadClass {
2021 } => {
2022 ClusterOptionName::WorkloadClass {
2023 }
2024 }
2025 }
2026}
2027impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ClusterScheduleOptionValue {
2028 type Folded = ClusterScheduleOptionValue;
2029 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2030 folder.fold_cluster_schedule_option_value(self)
2031 }
2032}
2033#[allow(clippy::needless_pass_by_ref_mut)]
2034pub fn fold_cluster_schedule_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ClusterScheduleOptionValue) -> ClusterScheduleOptionValue
2035where
2036 F: Fold<T, T2, > + ?Sized,
2037{
2038 match node {
2039 ClusterScheduleOptionValue::Manual {
2040 } => {
2041 ClusterScheduleOptionValue::Manual {
2042 }
2043 }
2044 ClusterScheduleOptionValue::Refresh {
2045 hydration_time_estimate: binding0,
2046 } => {
2047 ClusterScheduleOptionValue::Refresh {
2048 hydration_time_estimate: binding0.map(|v| folder.fold_interval_value(v)),
2049 }
2050 }
2051 }
2052}
2053impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnDef<T> {
2054 type Folded = ColumnDef<T2>;
2055 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2056 folder.fold_column_def(self)
2057 }
2058}
2059#[allow(clippy::needless_pass_by_ref_mut)]
2060pub fn fold_column_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnDef<T>) -> ColumnDef<T2>
2061where
2062 F: Fold<T, T2, > + ?Sized,
2063{
2064 ColumnDef {
2065 name: folder.fold_ident(node.name),
2066 data_type: folder.fold_data_type(node.data_type),
2067 collation: node.collation.map(|v| folder.fold_unresolved_item_name(v)),
2068 options: node.options.into_iter().map(|v| folder.fold_column_option_def(v)).collect(),
2069 }
2070}
2071impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnName<T> {
2072 type Folded = ColumnName<T2>;
2073 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2074 folder.fold_column_name(self)
2075 }
2076}
2077#[allow(clippy::needless_pass_by_ref_mut)]
2078pub fn fold_column_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnName<T>) -> ColumnName<T2>
2079where
2080 F: Fold<T, T2, > + ?Sized,
2081{
2082 ColumnName {
2083 relation: folder.fold_item_name(node.relation),
2084 column: folder.fold_column_reference(node.column),
2085 }
2086}
2087impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnOption<T> {
2088 type Folded = ColumnOption<T2>;
2089 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2090 folder.fold_column_option(self)
2091 }
2092}
2093#[allow(clippy::needless_pass_by_ref_mut)]
2094pub fn fold_column_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOption<T>) -> ColumnOption<T2>
2095where
2096 F: Fold<T, T2, > + ?Sized,
2097{
2098 match node {
2099 ColumnOption::Null {
2100 } => {
2101 ColumnOption::Null {
2102 }
2103 }
2104 ColumnOption::NotNull {
2105 } => {
2106 ColumnOption::NotNull {
2107 }
2108 }
2109 ColumnOption::Default {
2110 0: binding0,
2111 } => {
2112 ColumnOption::Default {
2113 0: folder.fold_expr(binding0),
2114 }
2115 }
2116 ColumnOption::Unique {
2117 is_primary: binding0,
2118 } => {
2119 ColumnOption::Unique {
2120 is_primary: binding0,
2121 }
2122 }
2123 ColumnOption::ForeignKey {
2124 foreign_table: binding0,
2125 referred_columns: binding1,
2126 } => {
2127 ColumnOption::ForeignKey {
2128 foreign_table: folder.fold_unresolved_item_name(binding0),
2129 referred_columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
2130 }
2131 }
2132 ColumnOption::Check {
2133 0: binding0,
2134 } => {
2135 ColumnOption::Check {
2136 0: folder.fold_expr(binding0),
2137 }
2138 }
2139 ColumnOption::Versioned {
2140 action: binding0,
2141 version: binding1,
2142 } => {
2143 ColumnOption::Versioned {
2144 action: folder.fold_column_versioned(binding0),
2145 version: folder.fold_version(binding1),
2146 }
2147 }
2148 }
2149}
2150impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnOptionDef<T> {
2151 type Folded = ColumnOptionDef<T2>;
2152 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2153 folder.fold_column_option_def(self)
2154 }
2155}
2156#[allow(clippy::needless_pass_by_ref_mut)]
2157pub fn fold_column_option_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2>
2158where
2159 F: Fold<T, T2, > + ?Sized,
2160{
2161 ColumnOptionDef {
2162 name: node.name.map(|v| folder.fold_ident(v)),
2163 option: folder.fold_column_option(node.option),
2164 }
2165}
2166impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ColumnVersioned {
2167 type Folded = ColumnVersioned;
2168 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2169 folder.fold_column_versioned(self)
2170 }
2171}
2172#[allow(clippy::needless_pass_by_ref_mut)]
2173pub fn fold_column_versioned<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnVersioned) -> ColumnVersioned
2174where
2175 F: Fold<T, T2, > + ?Sized,
2176{
2177 match node {
2178 ColumnVersioned::Added {
2179 } => {
2180 ColumnVersioned::Added {
2181 }
2182 }
2183 }
2184}
2185impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommentObjectType<T> {
2186 type Folded = CommentObjectType<T2>;
2187 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2188 folder.fold_comment_object_type(self)
2189 }
2190}
2191#[allow(clippy::needless_pass_by_ref_mut)]
2192pub fn fold_comment_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommentObjectType<T>) -> CommentObjectType<T2>
2193where
2194 F: Fold<T, T2, > + ?Sized,
2195{
2196 match node {
2197 CommentObjectType::Table {
2198 name: binding0,
2199 } => {
2200 CommentObjectType::Table {
2201 name: folder.fold_item_name(binding0),
2202 }
2203 }
2204 CommentObjectType::View {
2205 name: binding0,
2206 } => {
2207 CommentObjectType::View {
2208 name: folder.fold_item_name(binding0),
2209 }
2210 }
2211 CommentObjectType::Column {
2212 name: binding0,
2213 } => {
2214 CommentObjectType::Column {
2215 name: folder.fold_column_name(binding0),
2216 }
2217 }
2218 CommentObjectType::MaterializedView {
2219 name: binding0,
2220 } => {
2221 CommentObjectType::MaterializedView {
2222 name: folder.fold_item_name(binding0),
2223 }
2224 }
2225 CommentObjectType::Source {
2226 name: binding0,
2227 } => {
2228 CommentObjectType::Source {
2229 name: folder.fold_item_name(binding0),
2230 }
2231 }
2232 CommentObjectType::Sink {
2233 name: binding0,
2234 } => {
2235 CommentObjectType::Sink {
2236 name: folder.fold_item_name(binding0),
2237 }
2238 }
2239 CommentObjectType::Index {
2240 name: binding0,
2241 } => {
2242 CommentObjectType::Index {
2243 name: folder.fold_item_name(binding0),
2244 }
2245 }
2246 CommentObjectType::Func {
2247 name: binding0,
2248 } => {
2249 CommentObjectType::Func {
2250 name: folder.fold_item_name(binding0),
2251 }
2252 }
2253 CommentObjectType::Connection {
2254 name: binding0,
2255 } => {
2256 CommentObjectType::Connection {
2257 name: folder.fold_item_name(binding0),
2258 }
2259 }
2260 CommentObjectType::Type {
2261 ty: binding0,
2262 } => {
2263 CommentObjectType::Type {
2264 ty: folder.fold_data_type(binding0),
2265 }
2266 }
2267 CommentObjectType::Secret {
2268 name: binding0,
2269 } => {
2270 CommentObjectType::Secret {
2271 name: folder.fold_item_name(binding0),
2272 }
2273 }
2274 CommentObjectType::Role {
2275 name: binding0,
2276 } => {
2277 CommentObjectType::Role {
2278 name: folder.fold_role_name(binding0),
2279 }
2280 }
2281 CommentObjectType::Database {
2282 name: binding0,
2283 } => {
2284 CommentObjectType::Database {
2285 name: folder.fold_database_name(binding0),
2286 }
2287 }
2288 CommentObjectType::Schema {
2289 name: binding0,
2290 } => {
2291 CommentObjectType::Schema {
2292 name: folder.fold_schema_name(binding0),
2293 }
2294 }
2295 CommentObjectType::Cluster {
2296 name: binding0,
2297 } => {
2298 CommentObjectType::Cluster {
2299 name: folder.fold_cluster_name(binding0),
2300 }
2301 }
2302 CommentObjectType::ClusterReplica {
2303 name: binding0,
2304 } => {
2305 CommentObjectType::ClusterReplica {
2306 name: folder.fold_qualified_replica(binding0),
2307 }
2308 }
2309 CommentObjectType::ContinualTask {
2310 name: binding0,
2311 } => {
2312 CommentObjectType::ContinualTask {
2313 name: folder.fold_item_name(binding0),
2314 }
2315 }
2316 CommentObjectType::NetworkPolicy {
2317 name: binding0,
2318 } => {
2319 CommentObjectType::NetworkPolicy {
2320 name: folder.fold_network_policy_name(binding0),
2321 }
2322 }
2323 }
2324}
2325impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommentStatement<T> {
2326 type Folded = CommentStatement<T2>;
2327 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2328 folder.fold_comment_statement(self)
2329 }
2330}
2331#[allow(clippy::needless_pass_by_ref_mut)]
2332pub fn fold_comment_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommentStatement<T>) -> CommentStatement<T2>
2333where
2334 F: Fold<T, T2, > + ?Sized,
2335{
2336 CommentStatement {
2337 object: folder.fold_comment_object_type(node.object),
2338 comment: node.comment.map(|v| v),
2339 }
2340}
2341impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CommitStatement {
2342 type Folded = CommitStatement;
2343 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2344 folder.fold_commit_statement(self)
2345 }
2346}
2347#[allow(clippy::needless_pass_by_ref_mut)]
2348pub fn fold_commit_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommitStatement) -> CommitStatement
2349where
2350 F: Fold<T, T2, > + ?Sized,
2351{
2352 CommitStatement {
2353 chain: node.chain,
2354 }
2355}
2356impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionDefaultAwsPrivatelink<T> {
2357 type Folded = ConnectionDefaultAwsPrivatelink<T2>;
2358 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2359 folder.fold_connection_default_aws_privatelink(self)
2360 }
2361}
2362#[allow(clippy::needless_pass_by_ref_mut)]
2363pub fn fold_connection_default_aws_privatelink<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionDefaultAwsPrivatelink<T>) -> ConnectionDefaultAwsPrivatelink<T2>
2364where
2365 F: Fold<T, T2, > + ?Sized,
2366{
2367 ConnectionDefaultAwsPrivatelink {
2368 connection: folder.fold_item_name(node.connection),
2369 port: node.port.map(|v| v),
2370 }
2371}
2372impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionOption<T> {
2373 type Folded = ConnectionOption<T2>;
2374 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2375 folder.fold_connection_option(self)
2376 }
2377}
2378#[allow(clippy::needless_pass_by_ref_mut)]
2379pub fn fold_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionOption<T>) -> ConnectionOption<T2>
2380where
2381 F: Fold<T, T2, > + ?Sized,
2382{
2383 ConnectionOption {
2384 name: folder.fold_connection_option_name(node.name),
2385 value: node.value.map(|v| folder.fold_with_option_value(v)),
2386 }
2387}
2388impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ConnectionOptionName {
2389 type Folded = ConnectionOptionName;
2390 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2391 folder.fold_connection_option_name(self)
2392 }
2393}
2394#[allow(clippy::needless_pass_by_ref_mut)]
2395pub fn fold_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ConnectionOptionName) -> ConnectionOptionName
2396where
2397 F: Fold<T, T2, > + ?Sized,
2398{
2399 match node {
2400 ConnectionOptionName::AccessKeyId {
2401 } => {
2402 ConnectionOptionName::AccessKeyId {
2403 }
2404 }
2405 ConnectionOptionName::AssumeRoleArn {
2406 } => {
2407 ConnectionOptionName::AssumeRoleArn {
2408 }
2409 }
2410 ConnectionOptionName::AssumeRoleSessionName {
2411 } => {
2412 ConnectionOptionName::AssumeRoleSessionName {
2413 }
2414 }
2415 ConnectionOptionName::AvailabilityZones {
2416 } => {
2417 ConnectionOptionName::AvailabilityZones {
2418 }
2419 }
2420 ConnectionOptionName::AwsConnection {
2421 } => {
2422 ConnectionOptionName::AwsConnection {
2423 }
2424 }
2425 ConnectionOptionName::AwsPrivatelink {
2426 } => {
2427 ConnectionOptionName::AwsPrivatelink {
2428 }
2429 }
2430 ConnectionOptionName::Broker {
2431 } => {
2432 ConnectionOptionName::Broker {
2433 }
2434 }
2435 ConnectionOptionName::Brokers {
2436 } => {
2437 ConnectionOptionName::Brokers {
2438 }
2439 }
2440 ConnectionOptionName::Credential {
2441 } => {
2442 ConnectionOptionName::Credential {
2443 }
2444 }
2445 ConnectionOptionName::Database {
2446 } => {
2447 ConnectionOptionName::Database {
2448 }
2449 }
2450 ConnectionOptionName::Endpoint {
2451 } => {
2452 ConnectionOptionName::Endpoint {
2453 }
2454 }
2455 ConnectionOptionName::Host {
2456 } => {
2457 ConnectionOptionName::Host {
2458 }
2459 }
2460 ConnectionOptionName::Password {
2461 } => {
2462 ConnectionOptionName::Password {
2463 }
2464 }
2465 ConnectionOptionName::Port {
2466 } => {
2467 ConnectionOptionName::Port {
2468 }
2469 }
2470 ConnectionOptionName::ProgressTopic {
2471 } => {
2472 ConnectionOptionName::ProgressTopic {
2473 }
2474 }
2475 ConnectionOptionName::ProgressTopicReplicationFactor {
2476 } => {
2477 ConnectionOptionName::ProgressTopicReplicationFactor {
2478 }
2479 }
2480 ConnectionOptionName::PublicKey1 {
2481 } => {
2482 ConnectionOptionName::PublicKey1 {
2483 }
2484 }
2485 ConnectionOptionName::PublicKey2 {
2486 } => {
2487 ConnectionOptionName::PublicKey2 {
2488 }
2489 }
2490 ConnectionOptionName::Region {
2491 } => {
2492 ConnectionOptionName::Region {
2493 }
2494 }
2495 ConnectionOptionName::SaslMechanisms {
2496 } => {
2497 ConnectionOptionName::SaslMechanisms {
2498 }
2499 }
2500 ConnectionOptionName::SaslPassword {
2501 } => {
2502 ConnectionOptionName::SaslPassword {
2503 }
2504 }
2505 ConnectionOptionName::SaslUsername {
2506 } => {
2507 ConnectionOptionName::SaslUsername {
2508 }
2509 }
2510 ConnectionOptionName::Scope {
2511 } => {
2512 ConnectionOptionName::Scope {
2513 }
2514 }
2515 ConnectionOptionName::SecretAccessKey {
2516 } => {
2517 ConnectionOptionName::SecretAccessKey {
2518 }
2519 }
2520 ConnectionOptionName::SecurityProtocol {
2521 } => {
2522 ConnectionOptionName::SecurityProtocol {
2523 }
2524 }
2525 ConnectionOptionName::ServiceName {
2526 } => {
2527 ConnectionOptionName::ServiceName {
2528 }
2529 }
2530 ConnectionOptionName::SshTunnel {
2531 } => {
2532 ConnectionOptionName::SshTunnel {
2533 }
2534 }
2535 ConnectionOptionName::SslCertificate {
2536 } => {
2537 ConnectionOptionName::SslCertificate {
2538 }
2539 }
2540 ConnectionOptionName::SslCertificateAuthority {
2541 } => {
2542 ConnectionOptionName::SslCertificateAuthority {
2543 }
2544 }
2545 ConnectionOptionName::SslKey {
2546 } => {
2547 ConnectionOptionName::SslKey {
2548 }
2549 }
2550 ConnectionOptionName::SslMode {
2551 } => {
2552 ConnectionOptionName::SslMode {
2553 }
2554 }
2555 ConnectionOptionName::SessionToken {
2556 } => {
2557 ConnectionOptionName::SessionToken {
2558 }
2559 }
2560 ConnectionOptionName::CatalogType {
2561 } => {
2562 ConnectionOptionName::CatalogType {
2563 }
2564 }
2565 ConnectionOptionName::Url {
2566 } => {
2567 ConnectionOptionName::Url {
2568 }
2569 }
2570 ConnectionOptionName::User {
2571 } => {
2572 ConnectionOptionName::User {
2573 }
2574 }
2575 ConnectionOptionName::Warehouse {
2576 } => {
2577 ConnectionOptionName::Warehouse {
2578 }
2579 }
2580 }
2581}
2582impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ContinualTaskOption<T> {
2583 type Folded = ContinualTaskOption<T2>;
2584 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2585 folder.fold_continual_task_option(self)
2586 }
2587}
2588#[allow(clippy::needless_pass_by_ref_mut)]
2589pub fn fold_continual_task_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ContinualTaskOption<T>) -> ContinualTaskOption<T2>
2590where
2591 F: Fold<T, T2, > + ?Sized,
2592{
2593 ContinualTaskOption {
2594 name: folder.fold_continual_task_option_name(node.name),
2595 value: node.value.map(|v| folder.fold_with_option_value(v)),
2596 }
2597}
2598impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ContinualTaskOptionName {
2599 type Folded = ContinualTaskOptionName;
2600 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2601 folder.fold_continual_task_option_name(self)
2602 }
2603}
2604#[allow(clippy::needless_pass_by_ref_mut)]
2605pub fn fold_continual_task_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ContinualTaskOptionName) -> ContinualTaskOptionName
2606where
2607 F: Fold<T, T2, > + ?Sized,
2608{
2609 match node {
2610 ContinualTaskOptionName::Snapshot {
2611 } => {
2612 ContinualTaskOptionName::Snapshot {
2613 }
2614 }
2615 }
2616}
2617impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ContinualTaskStmt<T> {
2618 type Folded = ContinualTaskStmt<T2>;
2619 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2620 folder.fold_continual_task_stmt(self)
2621 }
2622}
2623#[allow(clippy::needless_pass_by_ref_mut)]
2624pub fn fold_continual_task_stmt<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ContinualTaskStmt<T>) -> ContinualTaskStmt<T2>
2625where
2626 F: Fold<T, T2, > + ?Sized,
2627{
2628 match node {
2629 ContinualTaskStmt::Delete {
2630 0: binding0,
2631 } => {
2632 ContinualTaskStmt::Delete {
2633 0: folder.fold_delete_statement(binding0),
2634 }
2635 }
2636 ContinualTaskStmt::Insert {
2637 0: binding0,
2638 } => {
2639 ContinualTaskStmt::Insert {
2640 0: folder.fold_insert_statement(binding0),
2641 }
2642 }
2643 }
2644}
2645impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyDirection {
2646 type Folded = CopyDirection;
2647 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2648 folder.fold_copy_direction(self)
2649 }
2650}
2651#[allow(clippy::needless_pass_by_ref_mut)]
2652pub fn fold_copy_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyDirection) -> CopyDirection
2653where
2654 F: Fold<T, T2, > + ?Sized,
2655{
2656 match node {
2657 CopyDirection::To {
2658 } => {
2659 CopyDirection::To {
2660 }
2661 }
2662 CopyDirection::From {
2663 } => {
2664 CopyDirection::From {
2665 }
2666 }
2667 }
2668}
2669impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyOption<T> {
2670 type Folded = CopyOption<T2>;
2671 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2672 folder.fold_copy_option(self)
2673 }
2674}
2675#[allow(clippy::needless_pass_by_ref_mut)]
2676pub fn fold_copy_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyOption<T>) -> CopyOption<T2>
2677where
2678 F: Fold<T, T2, > + ?Sized,
2679{
2680 CopyOption {
2681 name: folder.fold_copy_option_name(node.name),
2682 value: node.value.map(|v| folder.fold_with_option_value(v)),
2683 }
2684}
2685impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyOptionName {
2686 type Folded = CopyOptionName;
2687 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2688 folder.fold_copy_option_name(self)
2689 }
2690}
2691#[allow(clippy::needless_pass_by_ref_mut)]
2692pub fn fold_copy_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyOptionName) -> CopyOptionName
2693where
2694 F: Fold<T, T2, > + ?Sized,
2695{
2696 match node {
2697 CopyOptionName::Format {
2698 } => {
2699 CopyOptionName::Format {
2700 }
2701 }
2702 CopyOptionName::Delimiter {
2703 } => {
2704 CopyOptionName::Delimiter {
2705 }
2706 }
2707 CopyOptionName::Null {
2708 } => {
2709 CopyOptionName::Null {
2710 }
2711 }
2712 CopyOptionName::Escape {
2713 } => {
2714 CopyOptionName::Escape {
2715 }
2716 }
2717 CopyOptionName::Quote {
2718 } => {
2719 CopyOptionName::Quote {
2720 }
2721 }
2722 CopyOptionName::Header {
2723 } => {
2724 CopyOptionName::Header {
2725 }
2726 }
2727 CopyOptionName::AwsConnection {
2728 } => {
2729 CopyOptionName::AwsConnection {
2730 }
2731 }
2732 CopyOptionName::MaxFileSize {
2733 } => {
2734 CopyOptionName::MaxFileSize {
2735 }
2736 }
2737 CopyOptionName::Files {
2738 } => {
2739 CopyOptionName::Files {
2740 }
2741 }
2742 CopyOptionName::Pattern {
2743 } => {
2744 CopyOptionName::Pattern {
2745 }
2746 }
2747 }
2748}
2749impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyRelation<T> {
2750 type Folded = CopyRelation<T2>;
2751 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2752 folder.fold_copy_relation(self)
2753 }
2754}
2755#[allow(clippy::needless_pass_by_ref_mut)]
2756pub fn fold_copy_relation<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyRelation<T>) -> CopyRelation<T2>
2757where
2758 F: Fold<T, T2, > + ?Sized,
2759{
2760 match node {
2761 CopyRelation::Named {
2762 name: binding0,
2763 columns: binding1,
2764 } => {
2765 CopyRelation::Named {
2766 name: folder.fold_item_name(binding0),
2767 columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
2768 }
2769 }
2770 CopyRelation::Select {
2771 0: binding0,
2772 } => {
2773 CopyRelation::Select {
2774 0: folder.fold_select_statement(binding0),
2775 }
2776 }
2777 CopyRelation::Subscribe {
2778 0: binding0,
2779 } => {
2780 CopyRelation::Subscribe {
2781 0: folder.fold_subscribe_statement(binding0),
2782 }
2783 }
2784 }
2785}
2786impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyStatement<T> {
2787 type Folded = CopyStatement<T2>;
2788 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2789 folder.fold_copy_statement(self)
2790 }
2791}
2792#[allow(clippy::needless_pass_by_ref_mut)]
2793pub fn fold_copy_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyStatement<T>) -> CopyStatement<T2>
2794where
2795 F: Fold<T, T2, > + ?Sized,
2796{
2797 CopyStatement {
2798 relation: folder.fold_copy_relation(node.relation),
2799 direction: folder.fold_copy_direction(node.direction),
2800 target: folder.fold_copy_target(node.target),
2801 options: node.options.into_iter().map(|v| folder.fold_copy_option(v)).collect(),
2802 }
2803}
2804impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CopyTarget<T> {
2805 type Folded = CopyTarget<T2>;
2806 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2807 folder.fold_copy_target(self)
2808 }
2809}
2810#[allow(clippy::needless_pass_by_ref_mut)]
2811pub fn fold_copy_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyTarget<T>) -> CopyTarget<T2>
2812where
2813 F: Fold<T, T2, > + ?Sized,
2814{
2815 match node {
2816 CopyTarget::Stdin {
2817 } => {
2818 CopyTarget::Stdin {
2819 }
2820 }
2821 CopyTarget::Stdout {
2822 } => {
2823 CopyTarget::Stdout {
2824 }
2825 }
2826 CopyTarget::Expr {
2827 0: binding0,
2828 } => {
2829 CopyTarget::Expr {
2830 0: folder.fold_expr(binding0),
2831 }
2832 }
2833 }
2834}
2835impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateClusterReplicaStatement<T> {
2836 type Folded = CreateClusterReplicaStatement<T2>;
2837 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2838 folder.fold_create_cluster_replica_statement(self)
2839 }
2840}
2841#[allow(clippy::needless_pass_by_ref_mut)]
2842pub fn fold_create_cluster_replica_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateClusterReplicaStatement<T>) -> CreateClusterReplicaStatement<T2>
2843where
2844 F: Fold<T, T2, > + ?Sized,
2845{
2846 CreateClusterReplicaStatement {
2847 of_cluster: folder.fold_ident(node.of_cluster),
2848 definition: folder.fold_replica_definition(node.definition),
2849 }
2850}
2851impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateClusterStatement<T> {
2852 type Folded = CreateClusterStatement<T2>;
2853 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2854 folder.fold_create_cluster_statement(self)
2855 }
2856}
2857#[allow(clippy::needless_pass_by_ref_mut)]
2858pub fn fold_create_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateClusterStatement<T>) -> CreateClusterStatement<T2>
2859where
2860 F: Fold<T, T2, > + ?Sized,
2861{
2862 CreateClusterStatement {
2863 name: folder.fold_ident(node.name),
2864 options: node.options.into_iter().map(|v| folder.fold_cluster_option(v)).collect(),
2865 features: node.features.into_iter().map(|v| folder.fold_cluster_feature(v)).collect(),
2866 }
2867}
2868impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionOption<T> {
2869 type Folded = CreateConnectionOption<T2>;
2870 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2871 folder.fold_create_connection_option(self)
2872 }
2873}
2874#[allow(clippy::needless_pass_by_ref_mut)]
2875pub fn fold_create_connection_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionOption<T>) -> CreateConnectionOption<T2>
2876where
2877 F: Fold<T, T2, > + ?Sized,
2878{
2879 CreateConnectionOption {
2880 name: folder.fold_create_connection_option_name(node.name),
2881 value: node.value.map(|v| folder.fold_with_option_value(v)),
2882 }
2883}
2884impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionOptionName {
2885 type Folded = CreateConnectionOptionName;
2886 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2887 folder.fold_create_connection_option_name(self)
2888 }
2889}
2890#[allow(clippy::needless_pass_by_ref_mut)]
2891pub fn fold_create_connection_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionOptionName) -> CreateConnectionOptionName
2892where
2893 F: Fold<T, T2, > + ?Sized,
2894{
2895 match node {
2896 CreateConnectionOptionName::Validate {
2897 } => {
2898 CreateConnectionOptionName::Validate {
2899 }
2900 }
2901 }
2902}
2903impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionStatement<T> {
2904 type Folded = CreateConnectionStatement<T2>;
2905 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2906 folder.fold_create_connection_statement(self)
2907 }
2908}
2909#[allow(clippy::needless_pass_by_ref_mut)]
2910pub fn fold_create_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionStatement<T>) -> CreateConnectionStatement<T2>
2911where
2912 F: Fold<T, T2, > + ?Sized,
2913{
2914 CreateConnectionStatement {
2915 name: folder.fold_unresolved_item_name(node.name),
2916 connection_type: folder.fold_create_connection_type(node.connection_type),
2917 if_not_exists: node.if_not_exists,
2918 values: node.values.into_iter().map(|v| folder.fold_connection_option(v)).collect(),
2919 with_options: node.with_options.into_iter().map(|v| folder.fold_create_connection_option(v)).collect(),
2920 }
2921}
2922impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateConnectionType {
2923 type Folded = CreateConnectionType;
2924 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2925 folder.fold_create_connection_type(self)
2926 }
2927}
2928#[allow(clippy::needless_pass_by_ref_mut)]
2929pub fn fold_create_connection_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateConnectionType) -> CreateConnectionType
2930where
2931 F: Fold<T, T2, > + ?Sized,
2932{
2933 match node {
2934 CreateConnectionType::Aws {
2935 } => {
2936 CreateConnectionType::Aws {
2937 }
2938 }
2939 CreateConnectionType::AwsPrivatelink {
2940 } => {
2941 CreateConnectionType::AwsPrivatelink {
2942 }
2943 }
2944 CreateConnectionType::Kafka {
2945 } => {
2946 CreateConnectionType::Kafka {
2947 }
2948 }
2949 CreateConnectionType::Csr {
2950 } => {
2951 CreateConnectionType::Csr {
2952 }
2953 }
2954 CreateConnectionType::Postgres {
2955 } => {
2956 CreateConnectionType::Postgres {
2957 }
2958 }
2959 CreateConnectionType::Ssh {
2960 } => {
2961 CreateConnectionType::Ssh {
2962 }
2963 }
2964 CreateConnectionType::SqlServer {
2965 } => {
2966 CreateConnectionType::SqlServer {
2967 }
2968 }
2969 CreateConnectionType::MySql {
2970 } => {
2971 CreateConnectionType::MySql {
2972 }
2973 }
2974 CreateConnectionType::IcebergCatalog {
2975 } => {
2976 CreateConnectionType::IcebergCatalog {
2977 }
2978 }
2979 }
2980}
2981impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateContinualTaskStatement<T> {
2982 type Folded = CreateContinualTaskStatement<T2>;
2983 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
2984 folder.fold_create_continual_task_statement(self)
2985 }
2986}
2987#[allow(clippy::needless_pass_by_ref_mut)]
2988pub fn fold_create_continual_task_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateContinualTaskStatement<T>) -> CreateContinualTaskStatement<T2>
2989where
2990 F: Fold<T, T2, > + ?Sized,
2991{
2992 CreateContinualTaskStatement {
2993 name: folder.fold_item_name(node.name),
2994 columns: node.columns.map(|v| v.into_iter().map(|v| folder.fold_cte_mut_rec_column_def(v)).collect()),
2995 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
2996 as_of: node.as_of.map(|v| v),
2997 with_options: node.with_options.into_iter().map(|v| folder.fold_continual_task_option(v)).collect(),
2998 input: folder.fold_item_name(node.input),
2999 stmts: node.stmts.into_iter().map(|v| folder.fold_continual_task_stmt(v)).collect(),
3000 sugar: node.sugar.map(|v| folder.fold_create_continual_task_sugar(v)),
3001 }
3002}
3003impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateContinualTaskSugar<T> {
3004 type Folded = CreateContinualTaskSugar<T2>;
3005 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3006 folder.fold_create_continual_task_sugar(self)
3007 }
3008}
3009#[allow(clippy::needless_pass_by_ref_mut)]
3010pub fn fold_create_continual_task_sugar<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateContinualTaskSugar<T>) -> CreateContinualTaskSugar<T2>
3011where
3012 F: Fold<T, T2, > + ?Sized,
3013{
3014 match node {
3015 CreateContinualTaskSugar::Transform {
3016 transform: binding0,
3017 } => {
3018 CreateContinualTaskSugar::Transform {
3019 transform: folder.fold_query(binding0),
3020 }
3021 }
3022 CreateContinualTaskSugar::Retain {
3023 retain: binding0,
3024 } => {
3025 CreateContinualTaskSugar::Retain {
3026 retain: folder.fold_expr(binding0),
3027 }
3028 }
3029 }
3030}
3031impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateDatabaseStatement {
3032 type Folded = CreateDatabaseStatement;
3033 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3034 folder.fold_create_database_statement(self)
3035 }
3036}
3037#[allow(clippy::needless_pass_by_ref_mut)]
3038pub fn fold_create_database_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateDatabaseStatement) -> CreateDatabaseStatement
3039where
3040 F: Fold<T, T2, > + ?Sized,
3041{
3042 CreateDatabaseStatement {
3043 name: folder.fold_unresolved_database_name(node.name),
3044 if_not_exists: node.if_not_exists,
3045 }
3046}
3047impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateIndexStatement<T> {
3048 type Folded = CreateIndexStatement<T2>;
3049 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3050 folder.fold_create_index_statement(self)
3051 }
3052}
3053#[allow(clippy::needless_pass_by_ref_mut)]
3054pub fn fold_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2>
3055where
3056 F: Fold<T, T2, > + ?Sized,
3057{
3058 CreateIndexStatement {
3059 name: node.name.map(|v| folder.fold_ident(v)),
3060 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
3061 on_name: folder.fold_item_name(node.on_name),
3062 key_parts: node.key_parts.map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()),
3063 with_options: node.with_options.into_iter().map(|v| folder.fold_index_option(v)).collect(),
3064 if_not_exists: node.if_not_exists,
3065 }
3066}
3067impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateMaterializedViewStatement<T> {
3068 type Folded = CreateMaterializedViewStatement<T2>;
3069 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3070 folder.fold_create_materialized_view_statement(self)
3071 }
3072}
3073#[allow(clippy::needless_pass_by_ref_mut)]
3074pub fn fold_create_materialized_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateMaterializedViewStatement<T>) -> CreateMaterializedViewStatement<T2>
3075where
3076 F: Fold<T, T2, > + ?Sized,
3077{
3078 CreateMaterializedViewStatement {
3079 if_exists: folder.fold_if_exists_behavior(node.if_exists),
3080 name: folder.fold_unresolved_item_name(node.name),
3081 columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
3082 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
3083 query: folder.fold_query(node.query),
3084 as_of: node.as_of.map(|v| v),
3085 with_options: node.with_options.into_iter().map(|v| folder.fold_materialized_view_option(v)).collect(),
3086 }
3087}
3088impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateNetworkPolicyStatement<T> {
3089 type Folded = CreateNetworkPolicyStatement<T2>;
3090 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3091 folder.fold_create_network_policy_statement(self)
3092 }
3093}
3094#[allow(clippy::needless_pass_by_ref_mut)]
3095pub fn fold_create_network_policy_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateNetworkPolicyStatement<T>) -> CreateNetworkPolicyStatement<T2>
3096where
3097 F: Fold<T, T2, > + ?Sized,
3098{
3099 CreateNetworkPolicyStatement {
3100 name: folder.fold_ident(node.name),
3101 options: node.options.into_iter().map(|v| folder.fold_network_policy_option(v)).collect(),
3102 }
3103}
3104impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateRoleStatement {
3105 type Folded = CreateRoleStatement;
3106 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3107 folder.fold_create_role_statement(self)
3108 }
3109}
3110#[allow(clippy::needless_pass_by_ref_mut)]
3111pub fn fold_create_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateRoleStatement) -> CreateRoleStatement
3112where
3113 F: Fold<T, T2, > + ?Sized,
3114{
3115 CreateRoleStatement {
3116 name: folder.fold_ident(node.name),
3117 options: node.options.into_iter().map(|v| folder.fold_role_attribute(v)).collect(),
3118 }
3119}
3120impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSchemaStatement {
3121 type Folded = CreateSchemaStatement;
3122 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3123 folder.fold_create_schema_statement(self)
3124 }
3125}
3126#[allow(clippy::needless_pass_by_ref_mut)]
3127pub fn fold_create_schema_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSchemaStatement) -> CreateSchemaStatement
3128where
3129 F: Fold<T, T2, > + ?Sized,
3130{
3131 CreateSchemaStatement {
3132 name: folder.fold_unresolved_schema_name(node.name),
3133 if_not_exists: node.if_not_exists,
3134 }
3135}
3136impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSecretStatement<T> {
3137 type Folded = CreateSecretStatement<T2>;
3138 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3139 folder.fold_create_secret_statement(self)
3140 }
3141}
3142#[allow(clippy::needless_pass_by_ref_mut)]
3143pub fn fold_create_secret_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSecretStatement<T>) -> CreateSecretStatement<T2>
3144where
3145 F: Fold<T, T2, > + ?Sized,
3146{
3147 CreateSecretStatement {
3148 name: folder.fold_unresolved_item_name(node.name),
3149 if_not_exists: node.if_not_exists,
3150 value: folder.fold_expr(node.value),
3151 }
3152}
3153impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkConnection<T> {
3154 type Folded = CreateSinkConnection<T2>;
3155 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3156 folder.fold_create_sink_connection(self)
3157 }
3158}
3159#[allow(clippy::needless_pass_by_ref_mut)]
3160pub fn fold_create_sink_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkConnection<T>) -> CreateSinkConnection<T2>
3161where
3162 F: Fold<T, T2, > + ?Sized,
3163{
3164 match node {
3165 CreateSinkConnection::Kafka {
3166 connection: binding0,
3167 options: binding1,
3168 key: binding2,
3169 headers: binding3,
3170 } => {
3171 CreateSinkConnection::Kafka {
3172 connection: folder.fold_item_name(binding0),
3173 options: binding1.into_iter().map(|v| folder.fold_kafka_sink_config_option(v)).collect(),
3174 key: binding2.map(|v| folder.fold_sink_key(v)),
3175 headers: binding3.map(|v| folder.fold_ident(v)),
3176 }
3177 }
3178 CreateSinkConnection::Iceberg {
3179 connection: binding0,
3180 aws_connection: binding1,
3181 key: binding2,
3182 options: binding3,
3183 } => {
3184 CreateSinkConnection::Iceberg {
3185 connection: folder.fold_item_name(binding0),
3186 aws_connection: folder.fold_item_name(binding1),
3187 key: binding2.map(|v| folder.fold_sink_key(v)),
3188 options: binding3.into_iter().map(|v| folder.fold_iceberg_sink_config_option(v)).collect(),
3189 }
3190 }
3191 }
3192}
3193impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkOption<T> {
3194 type Folded = CreateSinkOption<T2>;
3195 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3196 folder.fold_create_sink_option(self)
3197 }
3198}
3199#[allow(clippy::needless_pass_by_ref_mut)]
3200pub fn fold_create_sink_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkOption<T>) -> CreateSinkOption<T2>
3201where
3202 F: Fold<T, T2, > + ?Sized,
3203{
3204 CreateSinkOption {
3205 name: folder.fold_create_sink_option_name(node.name),
3206 value: node.value.map(|v| folder.fold_with_option_value(v)),
3207 }
3208}
3209impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkOptionName {
3210 type Folded = CreateSinkOptionName;
3211 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3212 folder.fold_create_sink_option_name(self)
3213 }
3214}
3215#[allow(clippy::needless_pass_by_ref_mut)]
3216pub fn fold_create_sink_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkOptionName) -> CreateSinkOptionName
3217where
3218 F: Fold<T, T2, > + ?Sized,
3219{
3220 match node {
3221 CreateSinkOptionName::Snapshot {
3222 } => {
3223 CreateSinkOptionName::Snapshot {
3224 }
3225 }
3226 CreateSinkOptionName::Version {
3227 } => {
3228 CreateSinkOptionName::Version {
3229 }
3230 }
3231 CreateSinkOptionName::PartitionStrategy {
3232 } => {
3233 CreateSinkOptionName::PartitionStrategy {
3234 }
3235 }
3236 CreateSinkOptionName::CommitInterval {
3237 } => {
3238 CreateSinkOptionName::CommitInterval {
3239 }
3240 }
3241 }
3242}
3243impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSinkStatement<T> {
3244 type Folded = CreateSinkStatement<T2>;
3245 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3246 folder.fold_create_sink_statement(self)
3247 }
3248}
3249#[allow(clippy::needless_pass_by_ref_mut)]
3250pub fn fold_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2>
3251where
3252 F: Fold<T, T2, > + ?Sized,
3253{
3254 CreateSinkStatement {
3255 name: node.name.map(|v| folder.fold_unresolved_item_name(v)),
3256 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
3257 if_not_exists: node.if_not_exists,
3258 from: folder.fold_item_name(node.from),
3259 connection: folder.fold_create_sink_connection(node.connection),
3260 format: node.format.map(|v| folder.fold_format_specifier(v)),
3261 envelope: node.envelope.map(|v| folder.fold_sink_envelope(v)),
3262 with_options: node.with_options.into_iter().map(|v| folder.fold_create_sink_option(v)).collect(),
3263 }
3264}
3265impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceConnection<T> {
3266 type Folded = CreateSourceConnection<T2>;
3267 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3268 folder.fold_create_source_connection(self)
3269 }
3270}
3271#[allow(clippy::needless_pass_by_ref_mut)]
3272pub fn fold_create_source_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceConnection<T>) -> CreateSourceConnection<T2>
3273where
3274 F: Fold<T, T2, > + ?Sized,
3275{
3276 match node {
3277 CreateSourceConnection::Kafka {
3278 connection: binding0,
3279 options: binding1,
3280 } => {
3281 CreateSourceConnection::Kafka {
3282 connection: folder.fold_item_name(binding0),
3283 options: binding1.into_iter().map(|v| folder.fold_kafka_source_config_option(v)).collect(),
3284 }
3285 }
3286 CreateSourceConnection::Postgres {
3287 connection: binding0,
3288 options: binding1,
3289 } => {
3290 CreateSourceConnection::Postgres {
3291 connection: folder.fold_item_name(binding0),
3292 options: binding1.into_iter().map(|v| folder.fold_pg_config_option(v)).collect(),
3293 }
3294 }
3295 CreateSourceConnection::SqlServer {
3296 connection: binding0,
3297 options: binding1,
3298 } => {
3299 CreateSourceConnection::SqlServer {
3300 connection: folder.fold_item_name(binding0),
3301 options: binding1.into_iter().map(|v| folder.fold_sql_server_config_option(v)).collect(),
3302 }
3303 }
3304 CreateSourceConnection::MySql {
3305 connection: binding0,
3306 options: binding1,
3307 } => {
3308 CreateSourceConnection::MySql {
3309 connection: folder.fold_item_name(binding0),
3310 options: binding1.into_iter().map(|v| folder.fold_my_sql_config_option(v)).collect(),
3311 }
3312 }
3313 CreateSourceConnection::LoadGenerator {
3314 generator: binding0,
3315 options: binding1,
3316 } => {
3317 CreateSourceConnection::LoadGenerator {
3318 generator: folder.fold_load_generator(binding0),
3319 options: binding1.into_iter().map(|v| folder.fold_load_generator_option(v)).collect(),
3320 }
3321 }
3322 }
3323}
3324impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceOption<T> {
3325 type Folded = CreateSourceOption<T2>;
3326 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3327 folder.fold_create_source_option(self)
3328 }
3329}
3330#[allow(clippy::needless_pass_by_ref_mut)]
3331pub fn fold_create_source_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceOption<T>) -> CreateSourceOption<T2>
3332where
3333 F: Fold<T, T2, > + ?Sized,
3334{
3335 CreateSourceOption {
3336 name: folder.fold_create_source_option_name(node.name),
3337 value: node.value.map(|v| folder.fold_with_option_value(v)),
3338 }
3339}
3340impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceOptionName {
3341 type Folded = CreateSourceOptionName;
3342 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3343 folder.fold_create_source_option_name(self)
3344 }
3345}
3346#[allow(clippy::needless_pass_by_ref_mut)]
3347pub fn fold_create_source_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceOptionName) -> CreateSourceOptionName
3348where
3349 F: Fold<T, T2, > + ?Sized,
3350{
3351 match node {
3352 CreateSourceOptionName::TimestampInterval {
3353 } => {
3354 CreateSourceOptionName::TimestampInterval {
3355 }
3356 }
3357 CreateSourceOptionName::RetainHistory {
3358 } => {
3359 CreateSourceOptionName::RetainHistory {
3360 }
3361 }
3362 }
3363}
3364impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSourceStatement<T> {
3365 type Folded = CreateSourceStatement<T2>;
3366 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3367 folder.fold_create_source_statement(self)
3368 }
3369}
3370#[allow(clippy::needless_pass_by_ref_mut)]
3371pub fn fold_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceStatement<T>) -> CreateSourceStatement<T2>
3372where
3373 F: Fold<T, T2, > + ?Sized,
3374{
3375 CreateSourceStatement {
3376 name: folder.fold_unresolved_item_name(node.name),
3377 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
3378 col_names: node.col_names.into_iter().map(|v| folder.fold_ident(v)).collect(),
3379 connection: folder.fold_create_source_connection(node.connection),
3380 include_metadata: node.include_metadata.into_iter().map(|v| folder.fold_source_include_metadata(v)).collect(),
3381 format: node.format.map(|v| folder.fold_format_specifier(v)),
3382 envelope: node.envelope.map(|v| folder.fold_source_envelope(v)),
3383 if_not_exists: node.if_not_exists,
3384 key_constraint: node.key_constraint.map(|v| folder.fold_key_constraint(v)),
3385 with_options: node.with_options.into_iter().map(|v| folder.fold_create_source_option(v)).collect(),
3386 external_references: node.external_references.map(|v| folder.fold_external_references(v)),
3387 progress_subsource: node.progress_subsource.map(|v| folder.fold_deferred_item_name(v)),
3388 }
3389}
3390impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceOption<T> {
3391 type Folded = CreateSubsourceOption<T2>;
3392 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3393 folder.fold_create_subsource_option(self)
3394 }
3395}
3396#[allow(clippy::needless_pass_by_ref_mut)]
3397pub fn fold_create_subsource_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceOption<T>) -> CreateSubsourceOption<T2>
3398where
3399 F: Fold<T, T2, > + ?Sized,
3400{
3401 CreateSubsourceOption {
3402 name: folder.fold_create_subsource_option_name(node.name),
3403 value: node.value.map(|v| folder.fold_with_option_value(v)),
3404 }
3405}
3406impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceOptionName {
3407 type Folded = CreateSubsourceOptionName;
3408 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3409 folder.fold_create_subsource_option_name(self)
3410 }
3411}
3412#[allow(clippy::needless_pass_by_ref_mut)]
3413pub fn fold_create_subsource_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceOptionName) -> CreateSubsourceOptionName
3414where
3415 F: Fold<T, T2, > + ?Sized,
3416{
3417 match node {
3418 CreateSubsourceOptionName::Progress {
3419 } => {
3420 CreateSubsourceOptionName::Progress {
3421 }
3422 }
3423 CreateSubsourceOptionName::ExternalReference {
3424 } => {
3425 CreateSubsourceOptionName::ExternalReference {
3426 }
3427 }
3428 CreateSubsourceOptionName::RetainHistory {
3429 } => {
3430 CreateSubsourceOptionName::RetainHistory {
3431 }
3432 }
3433 CreateSubsourceOptionName::TextColumns {
3434 } => {
3435 CreateSubsourceOptionName::TextColumns {
3436 }
3437 }
3438 CreateSubsourceOptionName::ExcludeColumns {
3439 } => {
3440 CreateSubsourceOptionName::ExcludeColumns {
3441 }
3442 }
3443 CreateSubsourceOptionName::Details {
3444 } => {
3445 CreateSubsourceOptionName::Details {
3446 }
3447 }
3448 }
3449}
3450impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateSubsourceStatement<T> {
3451 type Folded = CreateSubsourceStatement<T2>;
3452 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3453 folder.fold_create_subsource_statement(self)
3454 }
3455}
3456#[allow(clippy::needless_pass_by_ref_mut)]
3457pub fn fold_create_subsource_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSubsourceStatement<T>) -> CreateSubsourceStatement<T2>
3458where
3459 F: Fold<T, T2, > + ?Sized,
3460{
3461 CreateSubsourceStatement {
3462 name: folder.fold_unresolved_item_name(node.name),
3463 columns: node.columns.into_iter().map(|v| folder.fold_column_def(v)).collect(),
3464 of_source: node.of_source.map(|v| folder.fold_item_name(v)),
3465 constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(),
3466 if_not_exists: node.if_not_exists,
3467 with_options: node.with_options.into_iter().map(|v| folder.fold_create_subsource_option(v)).collect(),
3468 }
3469}
3470impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTableFromSourceStatement<T> {
3471 type Folded = CreateTableFromSourceStatement<T2>;
3472 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3473 folder.fold_create_table_from_source_statement(self)
3474 }
3475}
3476#[allow(clippy::needless_pass_by_ref_mut)]
3477pub fn fold_create_table_from_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTableFromSourceStatement<T>) -> CreateTableFromSourceStatement<T2>
3478where
3479 F: Fold<T, T2, > + ?Sized,
3480{
3481 CreateTableFromSourceStatement {
3482 name: folder.fold_unresolved_item_name(node.name),
3483 columns: folder.fold_table_from_source_columns(node.columns),
3484 constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(),
3485 if_not_exists: node.if_not_exists,
3486 source: folder.fold_item_name(node.source),
3487 external_reference: node.external_reference.map(|v| folder.fold_unresolved_item_name(v)),
3488 with_options: node.with_options.into_iter().map(|v| folder.fold_table_from_source_option(v)).collect(),
3489 include_metadata: node.include_metadata.into_iter().map(|v| folder.fold_source_include_metadata(v)).collect(),
3490 format: node.format.map(|v| folder.fold_format_specifier(v)),
3491 envelope: node.envelope.map(|v| folder.fold_source_envelope(v)),
3492 }
3493}
3494impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTableStatement<T> {
3495 type Folded = CreateTableStatement<T2>;
3496 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3497 folder.fold_create_table_statement(self)
3498 }
3499}
3500#[allow(clippy::needless_pass_by_ref_mut)]
3501pub fn fold_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTableStatement<T>) -> CreateTableStatement<T2>
3502where
3503 F: Fold<T, T2, > + ?Sized,
3504{
3505 CreateTableStatement {
3506 name: folder.fold_unresolved_item_name(node.name),
3507 columns: node.columns.into_iter().map(|v| folder.fold_column_def(v)).collect(),
3508 constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(),
3509 if_not_exists: node.if_not_exists,
3510 temporary: node.temporary,
3511 with_options: node.with_options.into_iter().map(|v| folder.fold_table_option(v)).collect(),
3512 }
3513}
3514impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeAs<T> {
3515 type Folded = CreateTypeAs<T2>;
3516 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3517 folder.fold_create_type_as(self)
3518 }
3519}
3520#[allow(clippy::needless_pass_by_ref_mut)]
3521pub fn fold_create_type_as<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeAs<T>) -> CreateTypeAs<T2>
3522where
3523 F: Fold<T, T2, > + ?Sized,
3524{
3525 match node {
3526 CreateTypeAs::List {
3527 options: binding0,
3528 } => {
3529 CreateTypeAs::List {
3530 options: binding0.into_iter().map(|v| folder.fold_create_type_list_option(v)).collect(),
3531 }
3532 }
3533 CreateTypeAs::Map {
3534 options: binding0,
3535 } => {
3536 CreateTypeAs::Map {
3537 options: binding0.into_iter().map(|v| folder.fold_create_type_map_option(v)).collect(),
3538 }
3539 }
3540 CreateTypeAs::Record {
3541 column_defs: binding0,
3542 } => {
3543 CreateTypeAs::Record {
3544 column_defs: binding0.into_iter().map(|v| folder.fold_column_def(v)).collect(),
3545 }
3546 }
3547 }
3548}
3549impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeListOption<T> {
3550 type Folded = CreateTypeListOption<T2>;
3551 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3552 folder.fold_create_type_list_option(self)
3553 }
3554}
3555#[allow(clippy::needless_pass_by_ref_mut)]
3556pub fn fold_create_type_list_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeListOption<T>) -> CreateTypeListOption<T2>
3557where
3558 F: Fold<T, T2, > + ?Sized,
3559{
3560 CreateTypeListOption {
3561 name: folder.fold_create_type_list_option_name(node.name),
3562 value: node.value.map(|v| folder.fold_with_option_value(v)),
3563 }
3564}
3565impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeListOptionName {
3566 type Folded = CreateTypeListOptionName;
3567 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3568 folder.fold_create_type_list_option_name(self)
3569 }
3570}
3571#[allow(clippy::needless_pass_by_ref_mut)]
3572pub fn fold_create_type_list_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeListOptionName) -> CreateTypeListOptionName
3573where
3574 F: Fold<T, T2, > + ?Sized,
3575{
3576 match node {
3577 CreateTypeListOptionName::ElementType {
3578 } => {
3579 CreateTypeListOptionName::ElementType {
3580 }
3581 }
3582 }
3583}
3584impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeMapOption<T> {
3585 type Folded = CreateTypeMapOption<T2>;
3586 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3587 folder.fold_create_type_map_option(self)
3588 }
3589}
3590#[allow(clippy::needless_pass_by_ref_mut)]
3591pub fn fold_create_type_map_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeMapOption<T>) -> CreateTypeMapOption<T2>
3592where
3593 F: Fold<T, T2, > + ?Sized,
3594{
3595 CreateTypeMapOption {
3596 name: folder.fold_create_type_map_option_name(node.name),
3597 value: node.value.map(|v| folder.fold_with_option_value(v)),
3598 }
3599}
3600impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeMapOptionName {
3601 type Folded = CreateTypeMapOptionName;
3602 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3603 folder.fold_create_type_map_option_name(self)
3604 }
3605}
3606#[allow(clippy::needless_pass_by_ref_mut)]
3607pub fn fold_create_type_map_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeMapOptionName) -> CreateTypeMapOptionName
3608where
3609 F: Fold<T, T2, > + ?Sized,
3610{
3611 match node {
3612 CreateTypeMapOptionName::KeyType {
3613 } => {
3614 CreateTypeMapOptionName::KeyType {
3615 }
3616 }
3617 CreateTypeMapOptionName::ValueType {
3618 } => {
3619 CreateTypeMapOptionName::ValueType {
3620 }
3621 }
3622 }
3623}
3624impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateTypeStatement<T> {
3625 type Folded = CreateTypeStatement<T2>;
3626 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3627 folder.fold_create_type_statement(self)
3628 }
3629}
3630#[allow(clippy::needless_pass_by_ref_mut)]
3631pub fn fold_create_type_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeStatement<T>) -> CreateTypeStatement<T2>
3632where
3633 F: Fold<T, T2, > + ?Sized,
3634{
3635 CreateTypeStatement {
3636 name: folder.fold_unresolved_item_name(node.name),
3637 as_type: folder.fold_create_type_as(node.as_type),
3638 }
3639}
3640impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateViewStatement<T> {
3641 type Folded = CreateViewStatement<T2>;
3642 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3643 folder.fold_create_view_statement(self)
3644 }
3645}
3646#[allow(clippy::needless_pass_by_ref_mut)]
3647pub fn fold_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateViewStatement<T>) -> CreateViewStatement<T2>
3648where
3649 F: Fold<T, T2, > + ?Sized,
3650{
3651 CreateViewStatement {
3652 if_exists: folder.fold_if_exists_behavior(node.if_exists),
3653 temporary: node.temporary,
3654 definition: folder.fold_view_definition(node.definition),
3655 }
3656}
3657impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceBody {
3658 type Folded = CreateWebhookSourceBody;
3659 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3660 folder.fold_create_webhook_source_body(self)
3661 }
3662}
3663#[allow(clippy::needless_pass_by_ref_mut)]
3664pub fn fold_create_webhook_source_body<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceBody) -> CreateWebhookSourceBody
3665where
3666 F: Fold<T, T2, > + ?Sized,
3667{
3668 CreateWebhookSourceBody {
3669 alias: node.alias.map(|v| folder.fold_ident(v)),
3670 use_bytes: node.use_bytes,
3671 }
3672}
3673impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceCheck<T> {
3674 type Folded = CreateWebhookSourceCheck<T2>;
3675 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3676 folder.fold_create_webhook_source_check(self)
3677 }
3678}
3679#[allow(clippy::needless_pass_by_ref_mut)]
3680pub fn fold_create_webhook_source_check<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceCheck<T>) -> CreateWebhookSourceCheck<T2>
3681where
3682 F: Fold<T, T2, > + ?Sized,
3683{
3684 CreateWebhookSourceCheck {
3685 options: node.options.map(|v| folder.fold_create_webhook_source_check_options(v)),
3686 using: folder.fold_expr(node.using),
3687 }
3688}
3689impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceCheckOptions<T> {
3690 type Folded = CreateWebhookSourceCheckOptions<T2>;
3691 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3692 folder.fold_create_webhook_source_check_options(self)
3693 }
3694}
3695#[allow(clippy::needless_pass_by_ref_mut)]
3696pub fn fold_create_webhook_source_check_options<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceCheckOptions<T>) -> CreateWebhookSourceCheckOptions<T2>
3697where
3698 F: Fold<T, T2, > + ?Sized,
3699{
3700 CreateWebhookSourceCheckOptions {
3701 secrets: node.secrets.into_iter().map(|v| folder.fold_create_webhook_source_secret(v)).collect(),
3702 headers: node.headers.into_iter().map(|v| folder.fold_create_webhook_source_header(v)).collect(),
3703 bodies: node.bodies.into_iter().map(|v| folder.fold_create_webhook_source_body(v)).collect(),
3704 }
3705}
3706impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceFilterHeader {
3707 type Folded = CreateWebhookSourceFilterHeader;
3708 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3709 folder.fold_create_webhook_source_filter_header(self)
3710 }
3711}
3712#[allow(clippy::needless_pass_by_ref_mut)]
3713pub fn fold_create_webhook_source_filter_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceFilterHeader) -> CreateWebhookSourceFilterHeader
3714where
3715 F: Fold<T, T2, > + ?Sized,
3716{
3717 CreateWebhookSourceFilterHeader {
3718 block: node.block,
3719 header_name: node.header_name,
3720 }
3721}
3722impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceHeader {
3723 type Folded = CreateWebhookSourceHeader;
3724 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3725 folder.fold_create_webhook_source_header(self)
3726 }
3727}
3728#[allow(clippy::needless_pass_by_ref_mut)]
3729pub fn fold_create_webhook_source_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceHeader) -> CreateWebhookSourceHeader
3730where
3731 F: Fold<T, T2, > + ?Sized,
3732{
3733 CreateWebhookSourceHeader {
3734 alias: node.alias.map(|v| folder.fold_ident(v)),
3735 use_bytes: node.use_bytes,
3736 }
3737}
3738impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceIncludeHeaders {
3739 type Folded = CreateWebhookSourceIncludeHeaders;
3740 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3741 folder.fold_create_webhook_source_include_headers(self)
3742 }
3743}
3744#[allow(clippy::needless_pass_by_ref_mut)]
3745pub fn fold_create_webhook_source_include_headers<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceIncludeHeaders) -> CreateWebhookSourceIncludeHeaders
3746where
3747 F: Fold<T, T2, > + ?Sized,
3748{
3749 CreateWebhookSourceIncludeHeaders {
3750 mappings: node.mappings.into_iter().map(|v| folder.fold_create_webhook_source_map_header(v)).collect(),
3751 column: node.column.map(|v| v.into_iter().map(|v| folder.fold_create_webhook_source_filter_header(v)).collect()),
3752 }
3753}
3754impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceMapHeader {
3755 type Folded = CreateWebhookSourceMapHeader;
3756 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3757 folder.fold_create_webhook_source_map_header(self)
3758 }
3759}
3760#[allow(clippy::needless_pass_by_ref_mut)]
3761pub fn fold_create_webhook_source_map_header<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceMapHeader) -> CreateWebhookSourceMapHeader
3762where
3763 F: Fold<T, T2, > + ?Sized,
3764{
3765 CreateWebhookSourceMapHeader {
3766 header_name: node.header_name,
3767 column_name: folder.fold_ident(node.column_name),
3768 use_bytes: node.use_bytes,
3769 }
3770}
3771impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceSecret<T> {
3772 type Folded = CreateWebhookSourceSecret<T2>;
3773 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3774 folder.fold_create_webhook_source_secret(self)
3775 }
3776}
3777#[allow(clippy::needless_pass_by_ref_mut)]
3778pub fn fold_create_webhook_source_secret<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceSecret<T>) -> CreateWebhookSourceSecret<T2>
3779where
3780 F: Fold<T, T2, > + ?Sized,
3781{
3782 CreateWebhookSourceSecret {
3783 secret: folder.fold_item_name(node.secret),
3784 alias: node.alias.map(|v| folder.fold_ident(v)),
3785 use_bytes: node.use_bytes,
3786 }
3787}
3788impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CreateWebhookSourceStatement<T> {
3789 type Folded = CreateWebhookSourceStatement<T2>;
3790 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3791 folder.fold_create_webhook_source_statement(self)
3792 }
3793}
3794#[allow(clippy::needless_pass_by_ref_mut)]
3795pub fn fold_create_webhook_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateWebhookSourceStatement<T>) -> CreateWebhookSourceStatement<T2>
3796where
3797 F: Fold<T, T2, > + ?Sized,
3798{
3799 CreateWebhookSourceStatement {
3800 name: folder.fold_unresolved_item_name(node.name),
3801 is_table: node.is_table,
3802 if_not_exists: node.if_not_exists,
3803 body_format: folder.fold_format(node.body_format),
3804 include_headers: folder.fold_create_webhook_source_include_headers(node.include_headers),
3805 validate_using: node.validate_using.map(|v| folder.fold_create_webhook_source_check(v)),
3806 in_cluster: node.in_cluster.map(|v| folder.fold_cluster_name(v)),
3807 }
3808}
3809impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConfigOption<T> {
3810 type Folded = CsrConfigOption<T2>;
3811 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3812 folder.fold_csr_config_option(self)
3813 }
3814}
3815#[allow(clippy::needless_pass_by_ref_mut)]
3816pub fn fold_csr_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConfigOption<T>) -> CsrConfigOption<T2>
3817where
3818 F: Fold<T, T2, > + ?Sized,
3819{
3820 CsrConfigOption {
3821 name: folder.fold_csr_config_option_name(node.name),
3822 value: node.value.map(|v| folder.fold_with_option_value(v)),
3823 }
3824}
3825impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConfigOptionName<T> {
3826 type Folded = CsrConfigOptionName<T2>;
3827 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3828 folder.fold_csr_config_option_name(self)
3829 }
3830}
3831#[allow(clippy::needless_pass_by_ref_mut)]
3832pub fn fold_csr_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConfigOptionName<T>) -> CsrConfigOptionName<T2>
3833where
3834 F: Fold<T, T2, > + ?Sized,
3835{
3836 match node {
3837 CsrConfigOptionName::AvroKeyFullname {
3838 } => {
3839 CsrConfigOptionName::AvroKeyFullname {
3840 }
3841 }
3842 CsrConfigOptionName::AvroValueFullname {
3843 } => {
3844 CsrConfigOptionName::AvroValueFullname {
3845 }
3846 }
3847 CsrConfigOptionName::NullDefaults {
3848 } => {
3849 CsrConfigOptionName::NullDefaults {
3850 }
3851 }
3852 CsrConfigOptionName::AvroDocOn {
3853 0: binding0,
3854 } => {
3855 CsrConfigOptionName::AvroDocOn {
3856 0: folder.fold_avro_doc_on(binding0),
3857 }
3858 }
3859 CsrConfigOptionName::KeyCompatibilityLevel {
3860 } => {
3861 CsrConfigOptionName::KeyCompatibilityLevel {
3862 }
3863 }
3864 CsrConfigOptionName::ValueCompatibilityLevel {
3865 } => {
3866 CsrConfigOptionName::ValueCompatibilityLevel {
3867 }
3868 }
3869 }
3870}
3871impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnection<T> {
3872 type Folded = CsrConnection<T2>;
3873 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3874 folder.fold_csr_connection(self)
3875 }
3876}
3877#[allow(clippy::needless_pass_by_ref_mut)]
3878pub fn fold_csr_connection<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnection<T>) -> CsrConnection<T2>
3879where
3880 F: Fold<T, T2, > + ?Sized,
3881{
3882 CsrConnection {
3883 connection: folder.fold_item_name(node.connection),
3884 options: node.options.into_iter().map(|v| folder.fold_csr_config_option(v)).collect(),
3885 }
3886}
3887impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnectionAvro<T> {
3888 type Folded = CsrConnectionAvro<T2>;
3889 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3890 folder.fold_csr_connection_avro(self)
3891 }
3892}
3893#[allow(clippy::needless_pass_by_ref_mut)]
3894pub fn fold_csr_connection_avro<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnectionAvro<T>) -> CsrConnectionAvro<T2>
3895where
3896 F: Fold<T, T2, > + ?Sized,
3897{
3898 CsrConnectionAvro {
3899 connection: folder.fold_csr_connection(node.connection),
3900 key_strategy: node.key_strategy.map(|v| folder.fold_reader_schema_selection_strategy(v)),
3901 value_strategy: node.value_strategy.map(|v| folder.fold_reader_schema_selection_strategy(v)),
3902 seed: node.seed.map(|v| folder.fold_csr_seed_avro(v)),
3903 }
3904}
3905impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrConnectionProtobuf<T> {
3906 type Folded = CsrConnectionProtobuf<T2>;
3907 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3908 folder.fold_csr_connection_protobuf(self)
3909 }
3910}
3911#[allow(clippy::needless_pass_by_ref_mut)]
3912pub fn fold_csr_connection_protobuf<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrConnectionProtobuf<T>) -> CsrConnectionProtobuf<T2>
3913where
3914 F: Fold<T, T2, > + ?Sized,
3915{
3916 CsrConnectionProtobuf {
3917 connection: folder.fold_csr_connection(node.connection),
3918 seed: node.seed.map(|v| folder.fold_csr_seed_protobuf(v)),
3919 }
3920}
3921impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedAvro {
3922 type Folded = CsrSeedAvro;
3923 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3924 folder.fold_csr_seed_avro(self)
3925 }
3926}
3927#[allow(clippy::needless_pass_by_ref_mut)]
3928pub fn fold_csr_seed_avro<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedAvro) -> CsrSeedAvro
3929where
3930 F: Fold<T, T2, > + ?Sized,
3931{
3932 CsrSeedAvro {
3933 key_schema: node.key_schema.map(|v| v),
3934 value_schema: node.value_schema,
3935 }
3936}
3937impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedProtobuf {
3938 type Folded = CsrSeedProtobuf;
3939 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3940 folder.fold_csr_seed_protobuf(self)
3941 }
3942}
3943#[allow(clippy::needless_pass_by_ref_mut)]
3944pub fn fold_csr_seed_protobuf<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedProtobuf) -> CsrSeedProtobuf
3945where
3946 F: Fold<T, T2, > + ?Sized,
3947{
3948 CsrSeedProtobuf {
3949 key: node.key.map(|v| folder.fold_csr_seed_protobuf_schema(v)),
3950 value: folder.fold_csr_seed_protobuf_schema(node.value),
3951 }
3952}
3953impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsrSeedProtobufSchema {
3954 type Folded = CsrSeedProtobufSchema;
3955 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3956 folder.fold_csr_seed_protobuf_schema(self)
3957 }
3958}
3959#[allow(clippy::needless_pass_by_ref_mut)]
3960pub fn fold_csr_seed_protobuf_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeedProtobufSchema) -> CsrSeedProtobufSchema
3961where
3962 F: Fold<T, T2, > + ?Sized,
3963{
3964 CsrSeedProtobufSchema {
3965 schema: node.schema,
3966 message_name: node.message_name,
3967 }
3968}
3969impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CsvColumns {
3970 type Folded = CsvColumns;
3971 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
3972 folder.fold_csv_columns(self)
3973 }
3974}
3975#[allow(clippy::needless_pass_by_ref_mut)]
3976pub fn fold_csv_columns<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsvColumns) -> CsvColumns
3977where
3978 F: Fold<T, T2, > + ?Sized,
3979{
3980 match node {
3981 CsvColumns::Count {
3982 0: binding0,
3983 } => {
3984 CsvColumns::Count {
3985 0: binding0,
3986 }
3987 }
3988 CsvColumns::Header {
3989 names: binding0,
3990 } => {
3991 CsvColumns::Header {
3992 names: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
3993 }
3994 }
3995 }
3996}
3997impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Cte<T> {
3998 type Folded = Cte<T2>;
3999 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4000 folder.fold_cte(self)
4001 }
4002}
4003#[allow(clippy::needless_pass_by_ref_mut)]
4004pub fn fold_cte<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Cte<T>) -> Cte<T2>
4005where
4006 F: Fold<T, T2, > + ?Sized,
4007{
4008 Cte {
4009 alias: folder.fold_table_alias(node.alias),
4010 id: folder.fold_cte_id(node.id),
4011 query: folder.fold_query(node.query),
4012 }
4013}
4014impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteBlock<T> {
4015 type Folded = CteBlock<T2>;
4016 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4017 folder.fold_cte_block(self)
4018 }
4019}
4020#[allow(clippy::needless_pass_by_ref_mut)]
4021pub fn fold_cte_block<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteBlock<T>) -> CteBlock<T2>
4022where
4023 F: Fold<T, T2, > + ?Sized,
4024{
4025 match node {
4026 CteBlock::Simple {
4027 0: binding0,
4028 } => {
4029 CteBlock::Simple {
4030 0: binding0.into_iter().map(|v| folder.fold_cte(v)).collect(),
4031 }
4032 }
4033 CteBlock::MutuallyRecursive {
4034 0: binding0,
4035 } => {
4036 CteBlock::MutuallyRecursive {
4037 0: folder.fold_mut_rec_block(binding0),
4038 }
4039 }
4040 }
4041}
4042impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteMutRec<T> {
4043 type Folded = CteMutRec<T2>;
4044 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4045 folder.fold_cte_mut_rec(self)
4046 }
4047}
4048#[allow(clippy::needless_pass_by_ref_mut)]
4049pub fn fold_cte_mut_rec<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteMutRec<T>) -> CteMutRec<T2>
4050where
4051 F: Fold<T, T2, > + ?Sized,
4052{
4053 CteMutRec {
4054 name: folder.fold_ident(node.name),
4055 columns: node.columns.into_iter().map(|v| folder.fold_cte_mut_rec_column_def(v)).collect(),
4056 id: folder.fold_cte_id(node.id),
4057 query: folder.fold_query(node.query),
4058 }
4059}
4060impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for CteMutRecColumnDef<T> {
4061 type Folded = CteMutRecColumnDef<T2>;
4062 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4063 folder.fold_cte_mut_rec_column_def(self)
4064 }
4065}
4066#[allow(clippy::needless_pass_by_ref_mut)]
4067pub fn fold_cte_mut_rec_column_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CteMutRecColumnDef<T>) -> CteMutRecColumnDef<T2>
4068where
4069 F: Fold<T, T2, > + ?Sized,
4070{
4071 CteMutRecColumnDef {
4072 name: folder.fold_ident(node.name),
4073 data_type: folder.fold_data_type(node.data_type),
4074 }
4075}
4076impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DateTimeField {
4077 type Folded = DateTimeField;
4078 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4079 folder.fold_date_time_field(self)
4080 }
4081}
4082#[allow(clippy::needless_pass_by_ref_mut)]
4083pub fn fold_date_time_field<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DateTimeField) -> DateTimeField
4084where
4085 F: Fold<T, T2, > + ?Sized,
4086{
4087 match node {
4088 DateTimeField::Millennium {
4089 } => {
4090 DateTimeField::Millennium {
4091 }
4092 }
4093 DateTimeField::Century {
4094 } => {
4095 DateTimeField::Century {
4096 }
4097 }
4098 DateTimeField::Decade {
4099 } => {
4100 DateTimeField::Decade {
4101 }
4102 }
4103 DateTimeField::Year {
4104 } => {
4105 DateTimeField::Year {
4106 }
4107 }
4108 DateTimeField::Month {
4109 } => {
4110 DateTimeField::Month {
4111 }
4112 }
4113 DateTimeField::Day {
4114 } => {
4115 DateTimeField::Day {
4116 }
4117 }
4118 DateTimeField::Hour {
4119 } => {
4120 DateTimeField::Hour {
4121 }
4122 }
4123 DateTimeField::Minute {
4124 } => {
4125 DateTimeField::Minute {
4126 }
4127 }
4128 DateTimeField::Second {
4129 } => {
4130 DateTimeField::Second {
4131 }
4132 }
4133 DateTimeField::Milliseconds {
4134 } => {
4135 DateTimeField::Milliseconds {
4136 }
4137 }
4138 DateTimeField::Microseconds {
4139 } => {
4140 DateTimeField::Microseconds {
4141 }
4142 }
4143 }
4144}
4145impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeallocateStatement {
4146 type Folded = DeallocateStatement;
4147 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4148 folder.fold_deallocate_statement(self)
4149 }
4150}
4151#[allow(clippy::needless_pass_by_ref_mut)]
4152pub fn fold_deallocate_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeallocateStatement) -> DeallocateStatement
4153where
4154 F: Fold<T, T2, > + ?Sized,
4155{
4156 DeallocateStatement {
4157 name: node.name.map(|v| folder.fold_ident(v)),
4158 }
4159}
4160impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeclareStatement<T> {
4161 type Folded = DeclareStatement<T2>;
4162 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4163 folder.fold_declare_statement(self)
4164 }
4165}
4166#[allow(clippy::needless_pass_by_ref_mut)]
4167pub fn fold_declare_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeclareStatement<T>) -> DeclareStatement<T2>
4168where
4169 F: Fold<T, T2, > + ?Sized,
4170{
4171 DeclareStatement {
4172 name: folder.fold_ident(node.name),
4173 stmt: Box::new(folder.fold_nested_statement(*node.stmt)),
4174 sql: node.sql,
4175 }
4176}
4177impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeferredItemName<T> {
4178 type Folded = DeferredItemName<T2>;
4179 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4180 folder.fold_deferred_item_name(self)
4181 }
4182}
4183#[allow(clippy::needless_pass_by_ref_mut)]
4184pub fn fold_deferred_item_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeferredItemName<T>) -> DeferredItemName<T2>
4185where
4186 F: Fold<T, T2, > + ?Sized,
4187{
4188 match node {
4189 DeferredItemName::Named {
4190 0: binding0,
4191 } => {
4192 DeferredItemName::Named {
4193 0: folder.fold_item_name(binding0),
4194 }
4195 }
4196 DeferredItemName::Deferred {
4197 0: binding0,
4198 } => {
4199 DeferredItemName::Deferred {
4200 0: folder.fold_unresolved_item_name(binding0),
4201 }
4202 }
4203 }
4204}
4205impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DeleteStatement<T> {
4206 type Folded = DeleteStatement<T2>;
4207 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4208 folder.fold_delete_statement(self)
4209 }
4210}
4211#[allow(clippy::needless_pass_by_ref_mut)]
4212pub fn fold_delete_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeleteStatement<T>) -> DeleteStatement<T2>
4213where
4214 F: Fold<T, T2, > + ?Sized,
4215{
4216 DeleteStatement {
4217 table_name: folder.fold_item_name(node.table_name),
4218 alias: node.alias.map(|v| folder.fold_table_alias(v)),
4219 using: node.using.into_iter().map(|v| folder.fold_table_with_joins(v)).collect(),
4220 selection: node.selection.map(|v| folder.fold_expr(v)),
4221 }
4222}
4223impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DiscardStatement {
4224 type Folded = DiscardStatement;
4225 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4226 folder.fold_discard_statement(self)
4227 }
4228}
4229#[allow(clippy::needless_pass_by_ref_mut)]
4230pub fn fold_discard_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardStatement) -> DiscardStatement
4231where
4232 F: Fold<T, T2, > + ?Sized,
4233{
4234 DiscardStatement {
4235 target: folder.fold_discard_target(node.target),
4236 }
4237}
4238impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DiscardTarget {
4239 type Folded = DiscardTarget;
4240 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4241 folder.fold_discard_target(self)
4242 }
4243}
4244#[allow(clippy::needless_pass_by_ref_mut)]
4245pub fn fold_discard_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardTarget) -> DiscardTarget
4246where
4247 F: Fold<T, T2, > + ?Sized,
4248{
4249 match node {
4250 DiscardTarget::Plans {
4251 } => {
4252 DiscardTarget::Plans {
4253 }
4254 }
4255 DiscardTarget::Sequences {
4256 } => {
4257 DiscardTarget::Sequences {
4258 }
4259 }
4260 DiscardTarget::Temp {
4261 } => {
4262 DiscardTarget::Temp {
4263 }
4264 }
4265 DiscardTarget::All {
4266 } => {
4267 DiscardTarget::All {
4268 }
4269 }
4270 }
4271}
4272impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Distinct<T> {
4273 type Folded = Distinct<T2>;
4274 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4275 folder.fold_distinct(self)
4276 }
4277}
4278#[allow(clippy::needless_pass_by_ref_mut)]
4279pub fn fold_distinct<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Distinct<T>) -> Distinct<T2>
4280where
4281 F: Fold<T, T2, > + ?Sized,
4282{
4283 match node {
4284 Distinct::EntireRow {
4285 } => {
4286 Distinct::EntireRow {
4287 }
4288 }
4289 Distinct::On {
4290 0: binding0,
4291 } => {
4292 Distinct::On {
4293 0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
4294 }
4295 }
4296 }
4297}
4298impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DocOnIdentifier<T> {
4299 type Folded = DocOnIdentifier<T2>;
4300 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4301 folder.fold_doc_on_identifier(self)
4302 }
4303}
4304#[allow(clippy::needless_pass_by_ref_mut)]
4305pub fn fold_doc_on_identifier<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DocOnIdentifier<T>) -> DocOnIdentifier<T2>
4306where
4307 F: Fold<T, T2, > + ?Sized,
4308{
4309 match node {
4310 DocOnIdentifier::Column {
4311 0: binding0,
4312 } => {
4313 DocOnIdentifier::Column {
4314 0: folder.fold_column_name(binding0),
4315 }
4316 }
4317 DocOnIdentifier::Type {
4318 0: binding0,
4319 } => {
4320 DocOnIdentifier::Type {
4321 0: folder.fold_item_name(binding0),
4322 }
4323 }
4324 }
4325}
4326impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DocOnSchema {
4327 type Folded = DocOnSchema;
4328 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4329 folder.fold_doc_on_schema(self)
4330 }
4331}
4332#[allow(clippy::needless_pass_by_ref_mut)]
4333pub fn fold_doc_on_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DocOnSchema) -> DocOnSchema
4334where
4335 F: Fold<T, T2, > + ?Sized,
4336{
4337 match node {
4338 DocOnSchema::KeyOnly {
4339 } => {
4340 DocOnSchema::KeyOnly {
4341 }
4342 }
4343 DocOnSchema::ValueOnly {
4344 } => {
4345 DocOnSchema::ValueOnly {
4346 }
4347 }
4348 DocOnSchema::All {
4349 } => {
4350 DocOnSchema::All {
4351 }
4352 }
4353 }
4354}
4355impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DropObjectsStatement {
4356 type Folded = DropObjectsStatement;
4357 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4358 folder.fold_drop_objects_statement(self)
4359 }
4360}
4361#[allow(clippy::needless_pass_by_ref_mut)]
4362pub fn fold_drop_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropObjectsStatement) -> DropObjectsStatement
4363where
4364 F: Fold<T, T2, > + ?Sized,
4365{
4366 DropObjectsStatement {
4367 object_type: folder.fold_object_type(node.object_type),
4368 if_exists: node.if_exists,
4369 names: node.names.into_iter().map(|v| folder.fold_unresolved_object_name(v)).collect(),
4370 cascade: node.cascade,
4371 }
4372}
4373impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for DropOwnedStatement<T> {
4374 type Folded = DropOwnedStatement<T2>;
4375 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4376 folder.fold_drop_owned_statement(self)
4377 }
4378}
4379#[allow(clippy::needless_pass_by_ref_mut)]
4380pub fn fold_drop_owned_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropOwnedStatement<T>) -> DropOwnedStatement<T2>
4381where
4382 F: Fold<T, T2, > + ?Sized,
4383{
4384 DropOwnedStatement {
4385 role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
4386 cascade: node.cascade.map(|v| v),
4387 }
4388}
4389impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExecuteStatement<T> {
4390 type Folded = ExecuteStatement<T2>;
4391 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4392 folder.fold_execute_statement(self)
4393 }
4394}
4395#[allow(clippy::needless_pass_by_ref_mut)]
4396pub fn fold_execute_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExecuteStatement<T>) -> ExecuteStatement<T2>
4397where
4398 F: Fold<T, T2, > + ?Sized,
4399{
4400 ExecuteStatement {
4401 name: folder.fold_ident(node.name),
4402 params: node.params.into_iter().map(|v| folder.fold_expr(v)).collect(),
4403 }
4404}
4405impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainAnalyzeClusterStatement {
4406 type Folded = ExplainAnalyzeClusterStatement;
4407 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4408 folder.fold_explain_analyze_cluster_statement(self)
4409 }
4410}
4411#[allow(clippy::needless_pass_by_ref_mut)]
4412pub fn fold_explain_analyze_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainAnalyzeClusterStatement) -> ExplainAnalyzeClusterStatement
4413where
4414 F: Fold<T, T2, > + ?Sized,
4415{
4416 ExplainAnalyzeClusterStatement {
4417 properties: folder.fold_explain_analyze_computation_properties(node.properties),
4418 as_sql: node.as_sql,
4419 }
4420}
4421impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainAnalyzeComputationProperties {
4422 type Folded = ExplainAnalyzeComputationProperties;
4423 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4424 folder.fold_explain_analyze_computation_properties(self)
4425 }
4426}
4427#[allow(clippy::needless_pass_by_ref_mut)]
4428pub fn fold_explain_analyze_computation_properties<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainAnalyzeComputationProperties) -> ExplainAnalyzeComputationProperties
4429where
4430 F: Fold<T, T2, > + ?Sized,
4431{
4432 ExplainAnalyzeComputationProperties {
4433 properties: node.properties.into_iter().map(|v| folder.fold_explain_analyze_computation_property(v)).collect(),
4434 skew: node.skew,
4435 }
4436}
4437impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainAnalyzeComputationProperty {
4438 type Folded = ExplainAnalyzeComputationProperty;
4439 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4440 folder.fold_explain_analyze_computation_property(self)
4441 }
4442}
4443#[allow(clippy::needless_pass_by_ref_mut)]
4444pub fn fold_explain_analyze_computation_property<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainAnalyzeComputationProperty) -> ExplainAnalyzeComputationProperty
4445where
4446 F: Fold<T, T2, > + ?Sized,
4447{
4448 match node {
4449 ExplainAnalyzeComputationProperty::Cpu {
4450 } => {
4451 ExplainAnalyzeComputationProperty::Cpu {
4452 }
4453 }
4454 ExplainAnalyzeComputationProperty::Memory {
4455 } => {
4456 ExplainAnalyzeComputationProperty::Memory {
4457 }
4458 }
4459 }
4460}
4461impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainAnalyzeObjectStatement<T> {
4462 type Folded = ExplainAnalyzeObjectStatement<T2>;
4463 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4464 folder.fold_explain_analyze_object_statement(self)
4465 }
4466}
4467#[allow(clippy::needless_pass_by_ref_mut)]
4468pub fn fold_explain_analyze_object_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainAnalyzeObjectStatement<T>) -> ExplainAnalyzeObjectStatement<T2>
4469where
4470 F: Fold<T, T2, > + ?Sized,
4471{
4472 ExplainAnalyzeObjectStatement {
4473 properties: folder.fold_explain_analyze_property(node.properties),
4474 explainee: folder.fold_explainee(node.explainee),
4475 as_sql: node.as_sql,
4476 }
4477}
4478impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainAnalyzeProperty {
4479 type Folded = ExplainAnalyzeProperty;
4480 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4481 folder.fold_explain_analyze_property(self)
4482 }
4483}
4484#[allow(clippy::needless_pass_by_ref_mut)]
4485pub fn fold_explain_analyze_property<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainAnalyzeProperty) -> ExplainAnalyzeProperty
4486where
4487 F: Fold<T, T2, > + ?Sized,
4488{
4489 match node {
4490 ExplainAnalyzeProperty::Computation {
4491 0: binding0,
4492 } => {
4493 ExplainAnalyzeProperty::Computation {
4494 0: folder.fold_explain_analyze_computation_properties(binding0),
4495 }
4496 }
4497 ExplainAnalyzeProperty::Hints {
4498 } => {
4499 ExplainAnalyzeProperty::Hints {
4500 }
4501 }
4502 }
4503}
4504impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainFormat {
4505 type Folded = ExplainFormat;
4506 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4507 folder.fold_explain_format(self)
4508 }
4509}
4510#[allow(clippy::needless_pass_by_ref_mut)]
4511pub fn fold_explain_format<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainFormat) -> ExplainFormat
4512where
4513 F: Fold<T, T2, > + ?Sized,
4514{
4515 match node {
4516 ExplainFormat::Text {
4517 } => {
4518 ExplainFormat::Text {
4519 }
4520 }
4521 ExplainFormat::VerboseText {
4522 } => {
4523 ExplainFormat::VerboseText {
4524 }
4525 }
4526 ExplainFormat::Json {
4527 } => {
4528 ExplainFormat::Json {
4529 }
4530 }
4531 ExplainFormat::Dot {
4532 } => {
4533 ExplainFormat::Dot {
4534 }
4535 }
4536 }
4537}
4538impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanOption<T> {
4539 type Folded = ExplainPlanOption<T2>;
4540 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4541 folder.fold_explain_plan_option(self)
4542 }
4543}
4544#[allow(clippy::needless_pass_by_ref_mut)]
4545pub fn fold_explain_plan_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanOption<T>) -> ExplainPlanOption<T2>
4546where
4547 F: Fold<T, T2, > + ?Sized,
4548{
4549 ExplainPlanOption {
4550 name: folder.fold_explain_plan_option_name(node.name),
4551 value: node.value.map(|v| folder.fold_with_option_value(v)),
4552 }
4553}
4554impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanOptionName {
4555 type Folded = ExplainPlanOptionName;
4556 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4557 folder.fold_explain_plan_option_name(self)
4558 }
4559}
4560#[allow(clippy::needless_pass_by_ref_mut)]
4561pub fn fold_explain_plan_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanOptionName) -> ExplainPlanOptionName
4562where
4563 F: Fold<T, T2, > + ?Sized,
4564{
4565 match node {
4566 ExplainPlanOptionName::Arity {
4567 } => {
4568 ExplainPlanOptionName::Arity {
4569 }
4570 }
4571 ExplainPlanOptionName::Cardinality {
4572 } => {
4573 ExplainPlanOptionName::Cardinality {
4574 }
4575 }
4576 ExplainPlanOptionName::ColumnNames {
4577 } => {
4578 ExplainPlanOptionName::ColumnNames {
4579 }
4580 }
4581 ExplainPlanOptionName::FilterPushdown {
4582 } => {
4583 ExplainPlanOptionName::FilterPushdown {
4584 }
4585 }
4586 ExplainPlanOptionName::HumanizedExpressions {
4587 } => {
4588 ExplainPlanOptionName::HumanizedExpressions {
4589 }
4590 }
4591 ExplainPlanOptionName::JoinImplementations {
4592 } => {
4593 ExplainPlanOptionName::JoinImplementations {
4594 }
4595 }
4596 ExplainPlanOptionName::Keys {
4597 } => {
4598 ExplainPlanOptionName::Keys {
4599 }
4600 }
4601 ExplainPlanOptionName::LinearChains {
4602 } => {
4603 ExplainPlanOptionName::LinearChains {
4604 }
4605 }
4606 ExplainPlanOptionName::NonNegative {
4607 } => {
4608 ExplainPlanOptionName::NonNegative {
4609 }
4610 }
4611 ExplainPlanOptionName::NoFastPath {
4612 } => {
4613 ExplainPlanOptionName::NoFastPath {
4614 }
4615 }
4616 ExplainPlanOptionName::NoNotices {
4617 } => {
4618 ExplainPlanOptionName::NoNotices {
4619 }
4620 }
4621 ExplainPlanOptionName::NodeIdentifiers {
4622 } => {
4623 ExplainPlanOptionName::NodeIdentifiers {
4624 }
4625 }
4626 ExplainPlanOptionName::RawPlans {
4627 } => {
4628 ExplainPlanOptionName::RawPlans {
4629 }
4630 }
4631 ExplainPlanOptionName::RawSyntax {
4632 } => {
4633 ExplainPlanOptionName::RawSyntax {
4634 }
4635 }
4636 ExplainPlanOptionName::Raw {
4637 } => {
4638 ExplainPlanOptionName::Raw {
4639 }
4640 }
4641 ExplainPlanOptionName::Redacted {
4642 } => {
4643 ExplainPlanOptionName::Redacted {
4644 }
4645 }
4646 ExplainPlanOptionName::SubtreeSize {
4647 } => {
4648 ExplainPlanOptionName::SubtreeSize {
4649 }
4650 }
4651 ExplainPlanOptionName::Timing {
4652 } => {
4653 ExplainPlanOptionName::Timing {
4654 }
4655 }
4656 ExplainPlanOptionName::Types {
4657 } => {
4658 ExplainPlanOptionName::Types {
4659 }
4660 }
4661 ExplainPlanOptionName::Equivalences {
4662 } => {
4663 ExplainPlanOptionName::Equivalences {
4664 }
4665 }
4666 ExplainPlanOptionName::ReoptimizeImportedViews {
4667 } => {
4668 ExplainPlanOptionName::ReoptimizeImportedViews {
4669 }
4670 }
4671 ExplainPlanOptionName::EnableNewOuterJoinLowering {
4672 } => {
4673 ExplainPlanOptionName::EnableNewOuterJoinLowering {
4674 }
4675 }
4676 ExplainPlanOptionName::EnableEagerDeltaJoins {
4677 } => {
4678 ExplainPlanOptionName::EnableEagerDeltaJoins {
4679 }
4680 }
4681 ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
4682 } => {
4683 ExplainPlanOptionName::EnableVariadicLeftJoinLowering {
4684 }
4685 }
4686 ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
4687 } => {
4688 ExplainPlanOptionName::EnableLetrecFixpointAnalysis {
4689 }
4690 }
4691 ExplainPlanOptionName::EnableJoinPrioritizeArranged {
4692 } => {
4693 ExplainPlanOptionName::EnableJoinPrioritizeArranged {
4694 }
4695 }
4696 ExplainPlanOptionName::EnableProjectionPushdownAfterRelationCse {
4697 } => {
4698 ExplainPlanOptionName::EnableProjectionPushdownAfterRelationCse {
4699 }
4700 }
4701 }
4702}
4703impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPlanStatement<T> {
4704 type Folded = ExplainPlanStatement<T2>;
4705 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4706 folder.fold_explain_plan_statement(self)
4707 }
4708}
4709#[allow(clippy::needless_pass_by_ref_mut)]
4710pub fn fold_explain_plan_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPlanStatement<T>) -> ExplainPlanStatement<T2>
4711where
4712 F: Fold<T, T2, > + ?Sized,
4713{
4714 ExplainPlanStatement {
4715 stage: node.stage.map(|v| folder.fold_explain_stage(v)),
4716 with_options: node.with_options.into_iter().map(|v| folder.fold_explain_plan_option(v)).collect(),
4717 format: node.format.map(|v| folder.fold_explain_format(v)),
4718 explainee: folder.fold_explainee(node.explainee),
4719 }
4720}
4721impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainPushdownStatement<T> {
4722 type Folded = ExplainPushdownStatement<T2>;
4723 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4724 folder.fold_explain_pushdown_statement(self)
4725 }
4726}
4727#[allow(clippy::needless_pass_by_ref_mut)]
4728pub fn fold_explain_pushdown_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainPushdownStatement<T>) -> ExplainPushdownStatement<T2>
4729where
4730 F: Fold<T, T2, > + ?Sized,
4731{
4732 ExplainPushdownStatement {
4733 explainee: folder.fold_explainee(node.explainee),
4734 }
4735}
4736impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainSinkSchemaFor {
4737 type Folded = ExplainSinkSchemaFor;
4738 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4739 folder.fold_explain_sink_schema_for(self)
4740 }
4741}
4742#[allow(clippy::needless_pass_by_ref_mut)]
4743pub fn fold_explain_sink_schema_for<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainSinkSchemaFor) -> ExplainSinkSchemaFor
4744where
4745 F: Fold<T, T2, > + ?Sized,
4746{
4747 match node {
4748 ExplainSinkSchemaFor::Key {
4749 } => {
4750 ExplainSinkSchemaFor::Key {
4751 }
4752 }
4753 ExplainSinkSchemaFor::Value {
4754 } => {
4755 ExplainSinkSchemaFor::Value {
4756 }
4757 }
4758 }
4759}
4760impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainSinkSchemaStatement<T> {
4761 type Folded = ExplainSinkSchemaStatement<T2>;
4762 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4763 folder.fold_explain_sink_schema_statement(self)
4764 }
4765}
4766#[allow(clippy::needless_pass_by_ref_mut)]
4767pub fn fold_explain_sink_schema_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainSinkSchemaStatement<T>) -> ExplainSinkSchemaStatement<T2>
4768where
4769 F: Fold<T, T2, > + ?Sized,
4770{
4771 ExplainSinkSchemaStatement {
4772 schema_for: folder.fold_explain_sink_schema_for(node.schema_for),
4773 format: node.format.map(|v| folder.fold_explain_format(v)),
4774 statement: folder.fold_create_sink_statement(node.statement),
4775 }
4776}
4777impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainStage {
4778 type Folded = ExplainStage;
4779 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4780 folder.fold_explain_stage(self)
4781 }
4782}
4783#[allow(clippy::needless_pass_by_ref_mut)]
4784pub fn fold_explain_stage<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainStage) -> ExplainStage
4785where
4786 F: Fold<T, T2, > + ?Sized,
4787{
4788 match node {
4789 ExplainStage::RawPlan {
4790 } => {
4791 ExplainStage::RawPlan {
4792 }
4793 }
4794 ExplainStage::DecorrelatedPlan {
4795 } => {
4796 ExplainStage::DecorrelatedPlan {
4797 }
4798 }
4799 ExplainStage::LocalPlan {
4800 } => {
4801 ExplainStage::LocalPlan {
4802 }
4803 }
4804 ExplainStage::GlobalPlan {
4805 } => {
4806 ExplainStage::GlobalPlan {
4807 }
4808 }
4809 ExplainStage::PhysicalPlan {
4810 } => {
4811 ExplainStage::PhysicalPlan {
4812 }
4813 }
4814 ExplainStage::Trace {
4815 } => {
4816 ExplainStage::Trace {
4817 }
4818 }
4819 ExplainStage::PlanInsights {
4820 } => {
4821 ExplainStage::PlanInsights {
4822 }
4823 }
4824 }
4825}
4826impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExplainTimestampStatement<T> {
4827 type Folded = ExplainTimestampStatement<T2>;
4828 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4829 folder.fold_explain_timestamp_statement(self)
4830 }
4831}
4832#[allow(clippy::needless_pass_by_ref_mut)]
4833pub fn fold_explain_timestamp_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainTimestampStatement<T>) -> ExplainTimestampStatement<T2>
4834where
4835 F: Fold<T, T2, > + ?Sized,
4836{
4837 ExplainTimestampStatement {
4838 format: node.format.map(|v| folder.fold_explain_format(v)),
4839 select: folder.fold_select_statement(node.select),
4840 }
4841}
4842impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Explainee<T> {
4843 type Folded = Explainee<T2>;
4844 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4845 folder.fold_explainee(self)
4846 }
4847}
4848#[allow(clippy::needless_pass_by_ref_mut)]
4849pub fn fold_explainee<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Explainee<T>) -> Explainee<T2>
4850where
4851 F: Fold<T, T2, > + ?Sized,
4852{
4853 match node {
4854 Explainee::View {
4855 0: binding0,
4856 } => {
4857 Explainee::View {
4858 0: folder.fold_item_name(binding0),
4859 }
4860 }
4861 Explainee::MaterializedView {
4862 0: binding0,
4863 } => {
4864 Explainee::MaterializedView {
4865 0: folder.fold_item_name(binding0),
4866 }
4867 }
4868 Explainee::Index {
4869 0: binding0,
4870 } => {
4871 Explainee::Index {
4872 0: folder.fold_item_name(binding0),
4873 }
4874 }
4875 Explainee::ReplanView {
4876 0: binding0,
4877 } => {
4878 Explainee::ReplanView {
4879 0: folder.fold_item_name(binding0),
4880 }
4881 }
4882 Explainee::ReplanMaterializedView {
4883 0: binding0,
4884 } => {
4885 Explainee::ReplanMaterializedView {
4886 0: folder.fold_item_name(binding0),
4887 }
4888 }
4889 Explainee::ReplanIndex {
4890 0: binding0,
4891 } => {
4892 Explainee::ReplanIndex {
4893 0: folder.fold_item_name(binding0),
4894 }
4895 }
4896 Explainee::Select {
4897 0: binding0,
4898 1: binding1,
4899 } => {
4900 Explainee::Select {
4901 0: Box::new(folder.fold_select_statement(*binding0)),
4902 1: binding1,
4903 }
4904 }
4905 Explainee::CreateView {
4906 0: binding0,
4907 1: binding1,
4908 } => {
4909 Explainee::CreateView {
4910 0: Box::new(folder.fold_create_view_statement(*binding0)),
4911 1: binding1,
4912 }
4913 }
4914 Explainee::CreateMaterializedView {
4915 0: binding0,
4916 1: binding1,
4917 } => {
4918 Explainee::CreateMaterializedView {
4919 0: Box::new(folder.fold_create_materialized_view_statement(*binding0)),
4920 1: binding1,
4921 }
4922 }
4923 Explainee::CreateIndex {
4924 0: binding0,
4925 1: binding1,
4926 } => {
4927 Explainee::CreateIndex {
4928 0: Box::new(folder.fold_create_index_statement(*binding0)),
4929 1: binding1,
4930 }
4931 }
4932 }
4933}
4934impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Expr<T> {
4935 type Folded = Expr<T2>;
4936 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
4937 folder.fold_expr(self)
4938 }
4939}
4940#[allow(clippy::needless_pass_by_ref_mut)]
4941pub fn fold_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Expr<T>) -> Expr<T2>
4942where
4943 F: Fold<T, T2, > + ?Sized,
4944{
4945 match node {
4946 Expr::Identifier {
4947 0: binding0,
4948 } => {
4949 Expr::Identifier {
4950 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
4951 }
4952 }
4953 Expr::QualifiedWildcard {
4954 0: binding0,
4955 } => {
4956 Expr::QualifiedWildcard {
4957 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
4958 }
4959 }
4960 Expr::FieldAccess {
4961 expr: binding0,
4962 field: binding1,
4963 } => {
4964 Expr::FieldAccess {
4965 expr: Box::new(folder.fold_expr(*binding0)),
4966 field: folder.fold_ident(binding1),
4967 }
4968 }
4969 Expr::WildcardAccess {
4970 0: binding0,
4971 } => {
4972 Expr::WildcardAccess {
4973 0: Box::new(folder.fold_expr(*binding0)),
4974 }
4975 }
4976 Expr::Parameter {
4977 0: binding0,
4978 } => {
4979 Expr::Parameter {
4980 0: binding0,
4981 }
4982 }
4983 Expr::Not {
4984 expr: binding0,
4985 } => {
4986 Expr::Not {
4987 expr: Box::new(folder.fold_expr(*binding0)),
4988 }
4989 }
4990 Expr::And {
4991 left: binding0,
4992 right: binding1,
4993 } => {
4994 Expr::And {
4995 left: Box::new(folder.fold_expr(*binding0)),
4996 right: Box::new(folder.fold_expr(*binding1)),
4997 }
4998 }
4999 Expr::Or {
5000 left: binding0,
5001 right: binding1,
5002 } => {
5003 Expr::Or {
5004 left: Box::new(folder.fold_expr(*binding0)),
5005 right: Box::new(folder.fold_expr(*binding1)),
5006 }
5007 }
5008 Expr::IsExpr {
5009 expr: binding0,
5010 construct: binding1,
5011 negated: binding2,
5012 } => {
5013 Expr::IsExpr {
5014 expr: Box::new(folder.fold_expr(*binding0)),
5015 construct: folder.fold_is_expr_construct(binding1),
5016 negated: binding2,
5017 }
5018 }
5019 Expr::InList {
5020 expr: binding0,
5021 list: binding1,
5022 negated: binding2,
5023 } => {
5024 Expr::InList {
5025 expr: Box::new(folder.fold_expr(*binding0)),
5026 list: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
5027 negated: binding2,
5028 }
5029 }
5030 Expr::InSubquery {
5031 expr: binding0,
5032 subquery: binding1,
5033 negated: binding2,
5034 } => {
5035 Expr::InSubquery {
5036 expr: Box::new(folder.fold_expr(*binding0)),
5037 subquery: Box::new(folder.fold_query(*binding1)),
5038 negated: binding2,
5039 }
5040 }
5041 Expr::Like {
5042 expr: binding0,
5043 pattern: binding1,
5044 escape: binding2,
5045 case_insensitive: binding3,
5046 negated: binding4,
5047 } => {
5048 Expr::Like {
5049 expr: Box::new(folder.fold_expr(*binding0)),
5050 pattern: Box::new(folder.fold_expr(*binding1)),
5051 escape: binding2.map(|v| Box::new(folder.fold_expr(*v))),
5052 case_insensitive: binding3,
5053 negated: binding4,
5054 }
5055 }
5056 Expr::Between {
5057 expr: binding0,
5058 negated: binding1,
5059 low: binding2,
5060 high: binding3,
5061 } => {
5062 Expr::Between {
5063 expr: Box::new(folder.fold_expr(*binding0)),
5064 negated: binding1,
5065 low: Box::new(folder.fold_expr(*binding2)),
5066 high: Box::new(folder.fold_expr(*binding3)),
5067 }
5068 }
5069 Expr::Op {
5070 op: binding0,
5071 expr1: binding1,
5072 expr2: binding2,
5073 } => {
5074 Expr::Op {
5075 op: folder.fold_op(binding0),
5076 expr1: Box::new(folder.fold_expr(*binding1)),
5077 expr2: binding2.map(|v| Box::new(folder.fold_expr(*v))),
5078 }
5079 }
5080 Expr::Cast {
5081 expr: binding0,
5082 data_type: binding1,
5083 } => {
5084 Expr::Cast {
5085 expr: Box::new(folder.fold_expr(*binding0)),
5086 data_type: folder.fold_data_type(binding1),
5087 }
5088 }
5089 Expr::Collate {
5090 expr: binding0,
5091 collation: binding1,
5092 } => {
5093 Expr::Collate {
5094 expr: Box::new(folder.fold_expr(*binding0)),
5095 collation: folder.fold_unresolved_item_name(binding1),
5096 }
5097 }
5098 Expr::HomogenizingFunction {
5099 function: binding0,
5100 exprs: binding1,
5101 } => {
5102 Expr::HomogenizingFunction {
5103 function: folder.fold_homogenizing_function(binding0),
5104 exprs: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
5105 }
5106 }
5107 Expr::NullIf {
5108 l_expr: binding0,
5109 r_expr: binding1,
5110 } => {
5111 Expr::NullIf {
5112 l_expr: Box::new(folder.fold_expr(*binding0)),
5113 r_expr: Box::new(folder.fold_expr(*binding1)),
5114 }
5115 }
5116 Expr::Nested {
5117 0: binding0,
5118 } => {
5119 Expr::Nested {
5120 0: Box::new(folder.fold_expr(*binding0)),
5121 }
5122 }
5123 Expr::Row {
5124 exprs: binding0,
5125 } => {
5126 Expr::Row {
5127 exprs: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
5128 }
5129 }
5130 Expr::Value {
5131 0: binding0,
5132 } => {
5133 Expr::Value {
5134 0: folder.fold_value(binding0),
5135 }
5136 }
5137 Expr::Function {
5138 0: binding0,
5139 } => {
5140 Expr::Function {
5141 0: folder.fold_function(binding0),
5142 }
5143 }
5144 Expr::Case {
5145 operand: binding0,
5146 conditions: binding1,
5147 results: binding2,
5148 else_result: binding3,
5149 } => {
5150 Expr::Case {
5151 operand: binding0.map(|v| Box::new(folder.fold_expr(*v))),
5152 conditions: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(),
5153 results: binding2.into_iter().map(|v| folder.fold_expr(v)).collect(),
5154 else_result: binding3.map(|v| Box::new(folder.fold_expr(*v))),
5155 }
5156 }
5157 Expr::Exists {
5158 0: binding0,
5159 } => {
5160 Expr::Exists {
5161 0: Box::new(folder.fold_query(*binding0)),
5162 }
5163 }
5164 Expr::Subquery {
5165 0: binding0,
5166 } => {
5167 Expr::Subquery {
5168 0: Box::new(folder.fold_query(*binding0)),
5169 }
5170 }
5171 Expr::AnySubquery {
5172 left: binding0,
5173 op: binding1,
5174 right: binding2,
5175 } => {
5176 Expr::AnySubquery {
5177 left: Box::new(folder.fold_expr(*binding0)),
5178 op: folder.fold_op(binding1),
5179 right: Box::new(folder.fold_query(*binding2)),
5180 }
5181 }
5182 Expr::AnyExpr {
5183 left: binding0,
5184 op: binding1,
5185 right: binding2,
5186 } => {
5187 Expr::AnyExpr {
5188 left: Box::new(folder.fold_expr(*binding0)),
5189 op: folder.fold_op(binding1),
5190 right: Box::new(folder.fold_expr(*binding2)),
5191 }
5192 }
5193 Expr::AllSubquery {
5194 left: binding0,
5195 op: binding1,
5196 right: binding2,
5197 } => {
5198 Expr::AllSubquery {
5199 left: Box::new(folder.fold_expr(*binding0)),
5200 op: folder.fold_op(binding1),
5201 right: Box::new(folder.fold_query(*binding2)),
5202 }
5203 }
5204 Expr::AllExpr {
5205 left: binding0,
5206 op: binding1,
5207 right: binding2,
5208 } => {
5209 Expr::AllExpr {
5210 left: Box::new(folder.fold_expr(*binding0)),
5211 op: folder.fold_op(binding1),
5212 right: Box::new(folder.fold_expr(*binding2)),
5213 }
5214 }
5215 Expr::Array {
5216 0: binding0,
5217 } => {
5218 Expr::Array {
5219 0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
5220 }
5221 }
5222 Expr::ArraySubquery {
5223 0: binding0,
5224 } => {
5225 Expr::ArraySubquery {
5226 0: Box::new(folder.fold_query(*binding0)),
5227 }
5228 }
5229 Expr::List {
5230 0: binding0,
5231 } => {
5232 Expr::List {
5233 0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
5234 }
5235 }
5236 Expr::ListSubquery {
5237 0: binding0,
5238 } => {
5239 Expr::ListSubquery {
5240 0: Box::new(folder.fold_query(*binding0)),
5241 }
5242 }
5243 Expr::Map {
5244 0: binding0,
5245 } => {
5246 Expr::Map {
5247 0: binding0.into_iter().map(|v| folder.fold_map_entry(v)).collect(),
5248 }
5249 }
5250 Expr::MapSubquery {
5251 0: binding0,
5252 } => {
5253 Expr::MapSubquery {
5254 0: Box::new(folder.fold_query(*binding0)),
5255 }
5256 }
5257 Expr::Subscript {
5258 expr: binding0,
5259 positions: binding1,
5260 } => {
5261 Expr::Subscript {
5262 expr: Box::new(folder.fold_expr(*binding0)),
5263 positions: binding1.into_iter().map(|v| folder.fold_subscript_position(v)).collect(),
5264 }
5265 }
5266 }
5267}
5268impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExternalReferenceExport {
5269 type Folded = ExternalReferenceExport;
5270 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5271 folder.fold_external_reference_export(self)
5272 }
5273}
5274#[allow(clippy::needless_pass_by_ref_mut)]
5275pub fn fold_external_reference_export<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExternalReferenceExport) -> ExternalReferenceExport
5276where
5277 F: Fold<T, T2, > + ?Sized,
5278{
5279 ExternalReferenceExport {
5280 reference: folder.fold_unresolved_item_name(node.reference),
5281 alias: node.alias.map(|v| folder.fold_unresolved_item_name(v)),
5282 }
5283}
5284impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ExternalReferences {
5285 type Folded = ExternalReferences;
5286 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5287 folder.fold_external_references(self)
5288 }
5289}
5290#[allow(clippy::needless_pass_by_ref_mut)]
5291pub fn fold_external_references<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExternalReferences) -> ExternalReferences
5292where
5293 F: Fold<T, T2, > + ?Sized,
5294{
5295 match node {
5296 ExternalReferences::SubsetTables {
5297 0: binding0,
5298 } => {
5299 ExternalReferences::SubsetTables {
5300 0: binding0.into_iter().map(|v| folder.fold_external_reference_export(v)).collect(),
5301 }
5302 }
5303 ExternalReferences::SubsetSchemas {
5304 0: binding0,
5305 } => {
5306 ExternalReferences::SubsetSchemas {
5307 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
5308 }
5309 }
5310 ExternalReferences::All {
5311 } => {
5312 ExternalReferences::All {
5313 }
5314 }
5315 }
5316}
5317impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchDirection {
5318 type Folded = FetchDirection;
5319 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5320 folder.fold_fetch_direction(self)
5321 }
5322}
5323#[allow(clippy::needless_pass_by_ref_mut)]
5324pub fn fold_fetch_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchDirection) -> FetchDirection
5325where
5326 F: Fold<T, T2, > + ?Sized,
5327{
5328 match node {
5329 FetchDirection::ForwardAll {
5330 } => {
5331 FetchDirection::ForwardAll {
5332 }
5333 }
5334 FetchDirection::ForwardCount {
5335 0: binding0,
5336 } => {
5337 FetchDirection::ForwardCount {
5338 0: binding0,
5339 }
5340 }
5341 }
5342}
5343impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchOption<T> {
5344 type Folded = FetchOption<T2>;
5345 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5346 folder.fold_fetch_option(self)
5347 }
5348}
5349#[allow(clippy::needless_pass_by_ref_mut)]
5350pub fn fold_fetch_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchOption<T>) -> FetchOption<T2>
5351where
5352 F: Fold<T, T2, > + ?Sized,
5353{
5354 FetchOption {
5355 name: folder.fold_fetch_option_name(node.name),
5356 value: node.value.map(|v| folder.fold_with_option_value(v)),
5357 }
5358}
5359impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchOptionName {
5360 type Folded = FetchOptionName;
5361 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5362 folder.fold_fetch_option_name(self)
5363 }
5364}
5365#[allow(clippy::needless_pass_by_ref_mut)]
5366pub fn fold_fetch_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchOptionName) -> FetchOptionName
5367where
5368 F: Fold<T, T2, > + ?Sized,
5369{
5370 match node {
5371 FetchOptionName::Timeout {
5372 } => {
5373 FetchOptionName::Timeout {
5374 }
5375 }
5376 }
5377}
5378impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FetchStatement<T> {
5379 type Folded = FetchStatement<T2>;
5380 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5381 folder.fold_fetch_statement(self)
5382 }
5383}
5384#[allow(clippy::needless_pass_by_ref_mut)]
5385pub fn fold_fetch_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchStatement<T>) -> FetchStatement<T2>
5386where
5387 F: Fold<T, T2, > + ?Sized,
5388{
5389 FetchStatement {
5390 name: folder.fold_ident(node.name),
5391 count: node.count.map(|v| folder.fold_fetch_direction(v)),
5392 options: node.options.into_iter().map(|v| folder.fold_fetch_option(v)).collect(),
5393 }
5394}
5395impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Format<T> {
5396 type Folded = Format<T2>;
5397 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5398 folder.fold_format(self)
5399 }
5400}
5401#[allow(clippy::needless_pass_by_ref_mut)]
5402pub fn fold_format<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Format<T>) -> Format<T2>
5403where
5404 F: Fold<T, T2, > + ?Sized,
5405{
5406 match node {
5407 Format::Bytes {
5408 } => {
5409 Format::Bytes {
5410 }
5411 }
5412 Format::Avro {
5413 0: binding0,
5414 } => {
5415 Format::Avro {
5416 0: folder.fold_avro_schema(binding0),
5417 }
5418 }
5419 Format::Protobuf {
5420 0: binding0,
5421 } => {
5422 Format::Protobuf {
5423 0: folder.fold_protobuf_schema(binding0),
5424 }
5425 }
5426 Format::Regex {
5427 0: binding0,
5428 } => {
5429 Format::Regex {
5430 0: binding0,
5431 }
5432 }
5433 Format::Csv {
5434 columns: binding0,
5435 delimiter: binding1,
5436 } => {
5437 Format::Csv {
5438 columns: folder.fold_csv_columns(binding0),
5439 delimiter: binding1,
5440 }
5441 }
5442 Format::Json {
5443 array: binding0,
5444 } => {
5445 Format::Json {
5446 array: binding0,
5447 }
5448 }
5449 Format::Text {
5450 } => {
5451 Format::Text {
5452 }
5453 }
5454 }
5455}
5456impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FormatSpecifier<T> {
5457 type Folded = FormatSpecifier<T2>;
5458 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5459 folder.fold_format_specifier(self)
5460 }
5461}
5462#[allow(clippy::needless_pass_by_ref_mut)]
5463pub fn fold_format_specifier<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FormatSpecifier<T>) -> FormatSpecifier<T2>
5464where
5465 F: Fold<T, T2, > + ?Sized,
5466{
5467 match node {
5468 FormatSpecifier::Bare {
5469 0: binding0,
5470 } => {
5471 FormatSpecifier::Bare {
5472 0: folder.fold_format(binding0),
5473 }
5474 }
5475 FormatSpecifier::KeyValue {
5476 key: binding0,
5477 value: binding1,
5478 } => {
5479 FormatSpecifier::KeyValue {
5480 key: folder.fold_format(binding0),
5481 value: folder.fold_format(binding1),
5482 }
5483 }
5484 }
5485}
5486impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Function<T> {
5487 type Folded = Function<T2>;
5488 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5489 folder.fold_function(self)
5490 }
5491}
5492#[allow(clippy::needless_pass_by_ref_mut)]
5493pub fn fold_function<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Function<T>) -> Function<T2>
5494where
5495 F: Fold<T, T2, > + ?Sized,
5496{
5497 Function {
5498 name: folder.fold_item_name(node.name),
5499 args: folder.fold_function_args(node.args),
5500 filter: node.filter.map(|v| Box::new(folder.fold_expr(*v))),
5501 over: node.over.map(|v| folder.fold_window_spec(v)),
5502 distinct: node.distinct,
5503 }
5504}
5505impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for FunctionArgs<T> {
5506 type Folded = FunctionArgs<T2>;
5507 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5508 folder.fold_function_args(self)
5509 }
5510}
5511#[allow(clippy::needless_pass_by_ref_mut)]
5512pub fn fold_function_args<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FunctionArgs<T>) -> FunctionArgs<T2>
5513where
5514 F: Fold<T, T2, > + ?Sized,
5515{
5516 match node {
5517 FunctionArgs::Star {
5518 } => {
5519 FunctionArgs::Star {
5520 }
5521 }
5522 FunctionArgs::Args {
5523 args: binding0,
5524 order_by: binding1,
5525 } => {
5526 FunctionArgs::Args {
5527 args: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(),
5528 order_by: binding1.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
5529 }
5530 }
5531 }
5532}
5533impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantPrivilegesStatement<T> {
5534 type Folded = GrantPrivilegesStatement<T2>;
5535 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5536 folder.fold_grant_privileges_statement(self)
5537 }
5538}
5539#[allow(clippy::needless_pass_by_ref_mut)]
5540pub fn fold_grant_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantPrivilegesStatement<T>) -> GrantPrivilegesStatement<T2>
5541where
5542 F: Fold<T, T2, > + ?Sized,
5543{
5544 GrantPrivilegesStatement {
5545 privileges: folder.fold_privilege_specification(node.privileges),
5546 target: folder.fold_grant_target_specification(node.target),
5547 roles: node.roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
5548 }
5549}
5550impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantRoleStatement<T> {
5551 type Folded = GrantRoleStatement<T2>;
5552 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5553 folder.fold_grant_role_statement(self)
5554 }
5555}
5556#[allow(clippy::needless_pass_by_ref_mut)]
5557pub fn fold_grant_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantRoleStatement<T>) -> GrantRoleStatement<T2>
5558where
5559 F: Fold<T, T2, > + ?Sized,
5560{
5561 GrantRoleStatement {
5562 role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
5563 member_names: node.member_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
5564 }
5565}
5566impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetAllSpecification<T> {
5567 type Folded = GrantTargetAllSpecification<T2>;
5568 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5569 folder.fold_grant_target_all_specification(self)
5570 }
5571}
5572#[allow(clippy::needless_pass_by_ref_mut)]
5573pub fn fold_grant_target_all_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetAllSpecification<T>) -> GrantTargetAllSpecification<T2>
5574where
5575 F: Fold<T, T2, > + ?Sized,
5576{
5577 match node {
5578 GrantTargetAllSpecification::All {
5579 } => {
5580 GrantTargetAllSpecification::All {
5581 }
5582 }
5583 GrantTargetAllSpecification::AllDatabases {
5584 databases: binding0,
5585 } => {
5586 GrantTargetAllSpecification::AllDatabases {
5587 databases: binding0.into_iter().map(|v| folder.fold_database_name(v)).collect(),
5588 }
5589 }
5590 GrantTargetAllSpecification::AllSchemas {
5591 schemas: binding0,
5592 } => {
5593 GrantTargetAllSpecification::AllSchemas {
5594 schemas: binding0.into_iter().map(|v| folder.fold_schema_name(v)).collect(),
5595 }
5596 }
5597 }
5598}
5599impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetSpecification<T> {
5600 type Folded = GrantTargetSpecification<T2>;
5601 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5602 folder.fold_grant_target_specification(self)
5603 }
5604}
5605#[allow(clippy::needless_pass_by_ref_mut)]
5606pub fn fold_grant_target_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetSpecification<T>) -> GrantTargetSpecification<T2>
5607where
5608 F: Fold<T, T2, > + ?Sized,
5609{
5610 match node {
5611 GrantTargetSpecification::Object {
5612 object_type: binding0,
5613 object_spec_inner: binding1,
5614 } => {
5615 GrantTargetSpecification::Object {
5616 object_type: folder.fold_object_type(binding0),
5617 object_spec_inner: folder.fold_grant_target_specification_inner(binding1),
5618 }
5619 }
5620 GrantTargetSpecification::System {
5621 } => {
5622 GrantTargetSpecification::System {
5623 }
5624 }
5625 }
5626}
5627impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for GrantTargetSpecificationInner<T> {
5628 type Folded = GrantTargetSpecificationInner<T2>;
5629 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5630 folder.fold_grant_target_specification_inner(self)
5631 }
5632}
5633#[allow(clippy::needless_pass_by_ref_mut)]
5634pub fn fold_grant_target_specification_inner<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: GrantTargetSpecificationInner<T>) -> GrantTargetSpecificationInner<T2>
5635where
5636 F: Fold<T, T2, > + ?Sized,
5637{
5638 match node {
5639 GrantTargetSpecificationInner::All {
5640 0: binding0,
5641 } => {
5642 GrantTargetSpecificationInner::All {
5643 0: folder.fold_grant_target_all_specification(binding0),
5644 }
5645 }
5646 GrantTargetSpecificationInner::Objects {
5647 names: binding0,
5648 } => {
5649 GrantTargetSpecificationInner::Objects {
5650 names: binding0.into_iter().map(|v| folder.fold_object_name(v)).collect(),
5651 }
5652 }
5653 }
5654}
5655impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for HomogenizingFunction {
5656 type Folded = HomogenizingFunction;
5657 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5658 folder.fold_homogenizing_function(self)
5659 }
5660}
5661#[allow(clippy::needless_pass_by_ref_mut)]
5662pub fn fold_homogenizing_function<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: HomogenizingFunction) -> HomogenizingFunction
5663where
5664 F: Fold<T, T2, > + ?Sized,
5665{
5666 match node {
5667 HomogenizingFunction::Coalesce {
5668 } => {
5669 HomogenizingFunction::Coalesce {
5670 }
5671 }
5672 HomogenizingFunction::Greatest {
5673 } => {
5674 HomogenizingFunction::Greatest {
5675 }
5676 }
5677 HomogenizingFunction::Least {
5678 } => {
5679 HomogenizingFunction::Least {
5680 }
5681 }
5682 }
5683}
5684impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IcebergSinkConfigOption<T> {
5685 type Folded = IcebergSinkConfigOption<T2>;
5686 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5687 folder.fold_iceberg_sink_config_option(self)
5688 }
5689}
5690#[allow(clippy::needless_pass_by_ref_mut)]
5691pub fn fold_iceberg_sink_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IcebergSinkConfigOption<T>) -> IcebergSinkConfigOption<T2>
5692where
5693 F: Fold<T, T2, > + ?Sized,
5694{
5695 IcebergSinkConfigOption {
5696 name: folder.fold_iceberg_sink_config_option_name(node.name),
5697 value: node.value.map(|v| folder.fold_with_option_value(v)),
5698 }
5699}
5700impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IcebergSinkConfigOptionName {
5701 type Folded = IcebergSinkConfigOptionName;
5702 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5703 folder.fold_iceberg_sink_config_option_name(self)
5704 }
5705}
5706#[allow(clippy::needless_pass_by_ref_mut)]
5707pub fn fold_iceberg_sink_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IcebergSinkConfigOptionName) -> IcebergSinkConfigOptionName
5708where
5709 F: Fold<T, T2, > + ?Sized,
5710{
5711 match node {
5712 IcebergSinkConfigOptionName::Namespace {
5713 } => {
5714 IcebergSinkConfigOptionName::Namespace {
5715 }
5716 }
5717 IcebergSinkConfigOptionName::Table {
5718 } => {
5719 IcebergSinkConfigOptionName::Table {
5720 }
5721 }
5722 }
5723}
5724impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Ident {
5725 type Folded = Ident;
5726 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5727 folder.fold_ident(self)
5728 }
5729}
5730#[allow(clippy::needless_pass_by_ref_mut)]
5731pub fn fold_ident<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Ident) -> Ident
5732where
5733 F: Fold<T, T2, > + ?Sized,
5734{
5735 Ident {
5736 0: node.0,
5737 }
5738}
5739impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IdentError {
5740 type Folded = IdentError;
5741 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5742 folder.fold_ident_error(self)
5743 }
5744}
5745#[allow(clippy::needless_pass_by_ref_mut)]
5746pub fn fold_ident_error<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IdentError) -> IdentError
5747where
5748 F: Fold<T, T2, > + ?Sized,
5749{
5750 match node {
5751 IdentError::TooLong {
5752 0: binding0,
5753 } => {
5754 IdentError::TooLong {
5755 0: binding0,
5756 }
5757 }
5758 IdentError::FailedToGenerate {
5759 prefix: binding0,
5760 suffix: binding1,
5761 attempts: binding2,
5762 } => {
5763 IdentError::FailedToGenerate {
5764 prefix: binding0,
5765 suffix: binding1,
5766 attempts: binding2,
5767 }
5768 }
5769 IdentError::Invalid {
5770 0: binding0,
5771 } => {
5772 IdentError::Invalid {
5773 0: binding0,
5774 }
5775 }
5776 }
5777}
5778impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IfExistsBehavior {
5779 type Folded = IfExistsBehavior;
5780 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5781 folder.fold_if_exists_behavior(self)
5782 }
5783}
5784#[allow(clippy::needless_pass_by_ref_mut)]
5785pub fn fold_if_exists_behavior<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IfExistsBehavior) -> IfExistsBehavior
5786where
5787 F: Fold<T, T2, > + ?Sized,
5788{
5789 match node {
5790 IfExistsBehavior::Error {
5791 } => {
5792 IfExistsBehavior::Error {
5793 }
5794 }
5795 IfExistsBehavior::Skip {
5796 } => {
5797 IfExistsBehavior::Skip {
5798 }
5799 }
5800 IfExistsBehavior::Replace {
5801 } => {
5802 IfExistsBehavior::Replace {
5803 }
5804 }
5805 }
5806}
5807impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IndexOption<T> {
5808 type Folded = IndexOption<T2>;
5809 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5810 folder.fold_index_option(self)
5811 }
5812}
5813#[allow(clippy::needless_pass_by_ref_mut)]
5814pub fn fold_index_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IndexOption<T>) -> IndexOption<T2>
5815where
5816 F: Fold<T, T2, > + ?Sized,
5817{
5818 IndexOption {
5819 name: folder.fold_index_option_name(node.name),
5820 value: node.value.map(|v| folder.fold_with_option_value(v)),
5821 }
5822}
5823impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IndexOptionName {
5824 type Folded = IndexOptionName;
5825 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5826 folder.fold_index_option_name(self)
5827 }
5828}
5829#[allow(clippy::needless_pass_by_ref_mut)]
5830pub fn fold_index_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IndexOptionName) -> IndexOptionName
5831where
5832 F: Fold<T, T2, > + ?Sized,
5833{
5834 match node {
5835 IndexOptionName::RetainHistory {
5836 } => {
5837 IndexOptionName::RetainHistory {
5838 }
5839 }
5840 }
5841}
5842impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InsertSource<T> {
5843 type Folded = InsertSource<T2>;
5844 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5845 folder.fold_insert_source(self)
5846 }
5847}
5848#[allow(clippy::needless_pass_by_ref_mut)]
5849pub fn fold_insert_source<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertSource<T>) -> InsertSource<T2>
5850where
5851 F: Fold<T, T2, > + ?Sized,
5852{
5853 match node {
5854 InsertSource::Query {
5855 0: binding0,
5856 } => {
5857 InsertSource::Query {
5858 0: folder.fold_query(binding0),
5859 }
5860 }
5861 InsertSource::DefaultValues {
5862 } => {
5863 InsertSource::DefaultValues {
5864 }
5865 }
5866 }
5867}
5868impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InsertStatement<T> {
5869 type Folded = InsertStatement<T2>;
5870 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5871 folder.fold_insert_statement(self)
5872 }
5873}
5874#[allow(clippy::needless_pass_by_ref_mut)]
5875pub fn fold_insert_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertStatement<T>) -> InsertStatement<T2>
5876where
5877 F: Fold<T, T2, > + ?Sized,
5878{
5879 InsertStatement {
5880 table_name: folder.fold_item_name(node.table_name),
5881 columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
5882 source: folder.fold_insert_source(node.source),
5883 returning: node.returning.into_iter().map(|v| folder.fold_select_item(v)).collect(),
5884 }
5885}
5886impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for InspectShardStatement {
5887 type Folded = InspectShardStatement;
5888 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5889 folder.fold_inspect_shard_statement(self)
5890 }
5891}
5892#[allow(clippy::needless_pass_by_ref_mut)]
5893pub fn fold_inspect_shard_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InspectShardStatement) -> InspectShardStatement
5894where
5895 F: Fold<T, T2, > + ?Sized,
5896{
5897 InspectShardStatement {
5898 id: node.id,
5899 }
5900}
5901impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IntervalValue {
5902 type Folded = IntervalValue;
5903 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5904 folder.fold_interval_value(self)
5905 }
5906}
5907#[allow(clippy::needless_pass_by_ref_mut)]
5908pub fn fold_interval_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IntervalValue) -> IntervalValue
5909where
5910 F: Fold<T, T2, > + ?Sized,
5911{
5912 IntervalValue {
5913 value: node.value,
5914 precision_high: folder.fold_date_time_field(node.precision_high),
5915 precision_low: folder.fold_date_time_field(node.precision_low),
5916 fsec_max_precision: node.fsec_max_precision.map(|v| v),
5917 }
5918}
5919impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for IsExprConstruct<T> {
5920 type Folded = IsExprConstruct<T2>;
5921 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5922 folder.fold_is_expr_construct(self)
5923 }
5924}
5925#[allow(clippy::needless_pass_by_ref_mut)]
5926pub fn fold_is_expr_construct<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IsExprConstruct<T>) -> IsExprConstruct<T2>
5927where
5928 F: Fold<T, T2, > + ?Sized,
5929{
5930 match node {
5931 IsExprConstruct::Null {
5932 } => {
5933 IsExprConstruct::Null {
5934 }
5935 }
5936 IsExprConstruct::True {
5937 } => {
5938 IsExprConstruct::True {
5939 }
5940 }
5941 IsExprConstruct::False {
5942 } => {
5943 IsExprConstruct::False {
5944 }
5945 }
5946 IsExprConstruct::Unknown {
5947 } => {
5948 IsExprConstruct::Unknown {
5949 }
5950 }
5951 IsExprConstruct::DistinctFrom {
5952 0: binding0,
5953 } => {
5954 IsExprConstruct::DistinctFrom {
5955 0: Box::new(folder.fold_expr(*binding0)),
5956 }
5957 }
5958 }
5959}
5960impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Join<T> {
5961 type Folded = Join<T2>;
5962 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5963 folder.fold_join(self)
5964 }
5965}
5966#[allow(clippy::needless_pass_by_ref_mut)]
5967pub fn fold_join<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Join<T>) -> Join<T2>
5968where
5969 F: Fold<T, T2, > + ?Sized,
5970{
5971 Join {
5972 relation: folder.fold_table_factor(node.relation),
5973 join_operator: folder.fold_join_operator(node.join_operator),
5974 }
5975}
5976impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for JoinConstraint<T> {
5977 type Folded = JoinConstraint<T2>;
5978 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
5979 folder.fold_join_constraint(self)
5980 }
5981}
5982#[allow(clippy::needless_pass_by_ref_mut)]
5983pub fn fold_join_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinConstraint<T>) -> JoinConstraint<T2>
5984where
5985 F: Fold<T, T2, > + ?Sized,
5986{
5987 match node {
5988 JoinConstraint::On {
5989 0: binding0,
5990 } => {
5991 JoinConstraint::On {
5992 0: folder.fold_expr(binding0),
5993 }
5994 }
5995 JoinConstraint::Using {
5996 columns: binding0,
5997 alias: binding1,
5998 } => {
5999 JoinConstraint::Using {
6000 columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
6001 alias: binding1.map(|v| folder.fold_ident(v)),
6002 }
6003 }
6004 JoinConstraint::Natural {
6005 } => {
6006 JoinConstraint::Natural {
6007 }
6008 }
6009 }
6010}
6011impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for JoinOperator<T> {
6012 type Folded = JoinOperator<T2>;
6013 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6014 folder.fold_join_operator(self)
6015 }
6016}
6017#[allow(clippy::needless_pass_by_ref_mut)]
6018pub fn fold_join_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinOperator<T>) -> JoinOperator<T2>
6019where
6020 F: Fold<T, T2, > + ?Sized,
6021{
6022 match node {
6023 JoinOperator::Inner {
6024 0: binding0,
6025 } => {
6026 JoinOperator::Inner {
6027 0: folder.fold_join_constraint(binding0),
6028 }
6029 }
6030 JoinOperator::LeftOuter {
6031 0: binding0,
6032 } => {
6033 JoinOperator::LeftOuter {
6034 0: folder.fold_join_constraint(binding0),
6035 }
6036 }
6037 JoinOperator::RightOuter {
6038 0: binding0,
6039 } => {
6040 JoinOperator::RightOuter {
6041 0: folder.fold_join_constraint(binding0),
6042 }
6043 }
6044 JoinOperator::FullOuter {
6045 0: binding0,
6046 } => {
6047 JoinOperator::FullOuter {
6048 0: folder.fold_join_constraint(binding0),
6049 }
6050 }
6051 JoinOperator::CrossJoin {
6052 } => {
6053 JoinOperator::CrossJoin {
6054 }
6055 }
6056 }
6057}
6058impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBroker<T> {
6059 type Folded = KafkaBroker<T2>;
6060 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6061 folder.fold_kafka_broker(self)
6062 }
6063}
6064#[allow(clippy::needless_pass_by_ref_mut)]
6065pub fn fold_kafka_broker<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBroker<T>) -> KafkaBroker<T2>
6066where
6067 F: Fold<T, T2, > + ?Sized,
6068{
6069 KafkaBroker {
6070 address: node.address,
6071 tunnel: folder.fold_kafka_broker_tunnel(node.tunnel),
6072 }
6073}
6074impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelink<T> {
6075 type Folded = KafkaBrokerAwsPrivatelink<T2>;
6076 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6077 folder.fold_kafka_broker_aws_privatelink(self)
6078 }
6079}
6080#[allow(clippy::needless_pass_by_ref_mut)]
6081pub fn fold_kafka_broker_aws_privatelink<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelink<T>) -> KafkaBrokerAwsPrivatelink<T2>
6082where
6083 F: Fold<T, T2, > + ?Sized,
6084{
6085 KafkaBrokerAwsPrivatelink {
6086 connection: folder.fold_item_name(node.connection),
6087 options: node.options.into_iter().map(|v| folder.fold_kafka_broker_aws_privatelink_option(v)).collect(),
6088 }
6089}
6090impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelinkOption<T> {
6091 type Folded = KafkaBrokerAwsPrivatelinkOption<T2>;
6092 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6093 folder.fold_kafka_broker_aws_privatelink_option(self)
6094 }
6095}
6096#[allow(clippy::needless_pass_by_ref_mut)]
6097pub fn fold_kafka_broker_aws_privatelink_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelinkOption<T>) -> KafkaBrokerAwsPrivatelinkOption<T2>
6098where
6099 F: Fold<T, T2, > + ?Sized,
6100{
6101 KafkaBrokerAwsPrivatelinkOption {
6102 name: folder.fold_kafka_broker_aws_privatelink_option_name(node.name),
6103 value: node.value.map(|v| folder.fold_with_option_value(v)),
6104 }
6105}
6106impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerAwsPrivatelinkOptionName {
6107 type Folded = KafkaBrokerAwsPrivatelinkOptionName;
6108 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6109 folder.fold_kafka_broker_aws_privatelink_option_name(self)
6110 }
6111}
6112#[allow(clippy::needless_pass_by_ref_mut)]
6113pub fn fold_kafka_broker_aws_privatelink_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerAwsPrivatelinkOptionName) -> KafkaBrokerAwsPrivatelinkOptionName
6114where
6115 F: Fold<T, T2, > + ?Sized,
6116{
6117 match node {
6118 KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
6119 } => {
6120 KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone {
6121 }
6122 }
6123 KafkaBrokerAwsPrivatelinkOptionName::Port {
6124 } => {
6125 KafkaBrokerAwsPrivatelinkOptionName::Port {
6126 }
6127 }
6128 }
6129}
6130impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaBrokerTunnel<T> {
6131 type Folded = KafkaBrokerTunnel<T2>;
6132 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6133 folder.fold_kafka_broker_tunnel(self)
6134 }
6135}
6136#[allow(clippy::needless_pass_by_ref_mut)]
6137pub fn fold_kafka_broker_tunnel<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaBrokerTunnel<T>) -> KafkaBrokerTunnel<T2>
6138where
6139 F: Fold<T, T2, > + ?Sized,
6140{
6141 match node {
6142 KafkaBrokerTunnel::Direct {
6143 } => {
6144 KafkaBrokerTunnel::Direct {
6145 }
6146 }
6147 KafkaBrokerTunnel::AwsPrivatelink {
6148 0: binding0,
6149 } => {
6150 KafkaBrokerTunnel::AwsPrivatelink {
6151 0: folder.fold_kafka_broker_aws_privatelink(binding0),
6152 }
6153 }
6154 KafkaBrokerTunnel::SshTunnel {
6155 0: binding0,
6156 } => {
6157 KafkaBrokerTunnel::SshTunnel {
6158 0: folder.fold_item_name(binding0),
6159 }
6160 }
6161 }
6162}
6163impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSinkConfigOption<T> {
6164 type Folded = KafkaSinkConfigOption<T2>;
6165 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6166 folder.fold_kafka_sink_config_option(self)
6167 }
6168}
6169#[allow(clippy::needless_pass_by_ref_mut)]
6170pub fn fold_kafka_sink_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSinkConfigOption<T>) -> KafkaSinkConfigOption<T2>
6171where
6172 F: Fold<T, T2, > + ?Sized,
6173{
6174 KafkaSinkConfigOption {
6175 name: folder.fold_kafka_sink_config_option_name(node.name),
6176 value: node.value.map(|v| folder.fold_with_option_value(v)),
6177 }
6178}
6179impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSinkConfigOptionName {
6180 type Folded = KafkaSinkConfigOptionName;
6181 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6182 folder.fold_kafka_sink_config_option_name(self)
6183 }
6184}
6185#[allow(clippy::needless_pass_by_ref_mut)]
6186pub fn fold_kafka_sink_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSinkConfigOptionName) -> KafkaSinkConfigOptionName
6187where
6188 F: Fold<T, T2, > + ?Sized,
6189{
6190 match node {
6191 KafkaSinkConfigOptionName::CompressionType {
6192 } => {
6193 KafkaSinkConfigOptionName::CompressionType {
6194 }
6195 }
6196 KafkaSinkConfigOptionName::PartitionBy {
6197 } => {
6198 KafkaSinkConfigOptionName::PartitionBy {
6199 }
6200 }
6201 KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
6202 } => {
6203 KafkaSinkConfigOptionName::ProgressGroupIdPrefix {
6204 }
6205 }
6206 KafkaSinkConfigOptionName::Topic {
6207 } => {
6208 KafkaSinkConfigOptionName::Topic {
6209 }
6210 }
6211 KafkaSinkConfigOptionName::TransactionalIdPrefix {
6212 } => {
6213 KafkaSinkConfigOptionName::TransactionalIdPrefix {
6214 }
6215 }
6216 KafkaSinkConfigOptionName::LegacyIds {
6217 } => {
6218 KafkaSinkConfigOptionName::LegacyIds {
6219 }
6220 }
6221 KafkaSinkConfigOptionName::TopicConfig {
6222 } => {
6223 KafkaSinkConfigOptionName::TopicConfig {
6224 }
6225 }
6226 KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
6227 } => {
6228 KafkaSinkConfigOptionName::TopicMetadataRefreshInterval {
6229 }
6230 }
6231 KafkaSinkConfigOptionName::TopicPartitionCount {
6232 } => {
6233 KafkaSinkConfigOptionName::TopicPartitionCount {
6234 }
6235 }
6236 KafkaSinkConfigOptionName::TopicReplicationFactor {
6237 } => {
6238 KafkaSinkConfigOptionName::TopicReplicationFactor {
6239 }
6240 }
6241 }
6242}
6243impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSourceConfigOption<T> {
6244 type Folded = KafkaSourceConfigOption<T2>;
6245 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6246 folder.fold_kafka_source_config_option(self)
6247 }
6248}
6249#[allow(clippy::needless_pass_by_ref_mut)]
6250pub fn fold_kafka_source_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSourceConfigOption<T>) -> KafkaSourceConfigOption<T2>
6251where
6252 F: Fold<T, T2, > + ?Sized,
6253{
6254 KafkaSourceConfigOption {
6255 name: folder.fold_kafka_source_config_option_name(node.name),
6256 value: node.value.map(|v| folder.fold_with_option_value(v)),
6257 }
6258}
6259impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KafkaSourceConfigOptionName {
6260 type Folded = KafkaSourceConfigOptionName;
6261 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6262 folder.fold_kafka_source_config_option_name(self)
6263 }
6264}
6265#[allow(clippy::needless_pass_by_ref_mut)]
6266pub fn fold_kafka_source_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KafkaSourceConfigOptionName) -> KafkaSourceConfigOptionName
6267where
6268 F: Fold<T, T2, > + ?Sized,
6269{
6270 match node {
6271 KafkaSourceConfigOptionName::GroupIdPrefix {
6272 } => {
6273 KafkaSourceConfigOptionName::GroupIdPrefix {
6274 }
6275 }
6276 KafkaSourceConfigOptionName::Topic {
6277 } => {
6278 KafkaSourceConfigOptionName::Topic {
6279 }
6280 }
6281 KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
6282 } => {
6283 KafkaSourceConfigOptionName::TopicMetadataRefreshInterval {
6284 }
6285 }
6286 KafkaSourceConfigOptionName::StartTimestamp {
6287 } => {
6288 KafkaSourceConfigOptionName::StartTimestamp {
6289 }
6290 }
6291 KafkaSourceConfigOptionName::StartOffset {
6292 } => {
6293 KafkaSourceConfigOptionName::StartOffset {
6294 }
6295 }
6296 }
6297}
6298impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for KeyConstraint {
6299 type Folded = KeyConstraint;
6300 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6301 folder.fold_key_constraint(self)
6302 }
6303}
6304#[allow(clippy::needless_pass_by_ref_mut)]
6305pub fn fold_key_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: KeyConstraint) -> KeyConstraint
6306where
6307 F: Fold<T, T2, > + ?Sized,
6308{
6309 match node {
6310 KeyConstraint::PrimaryKeyNotEnforced {
6311 columns: binding0,
6312 } => {
6313 KeyConstraint::PrimaryKeyNotEnforced {
6314 columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
6315 }
6316 }
6317 }
6318}
6319impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Limit<T> {
6320 type Folded = Limit<T2>;
6321 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6322 folder.fold_limit(self)
6323 }
6324}
6325#[allow(clippy::needless_pass_by_ref_mut)]
6326pub fn fold_limit<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Limit<T>) -> Limit<T2>
6327where
6328 F: Fold<T, T2, > + ?Sized,
6329{
6330 Limit {
6331 with_ties: node.with_ties,
6332 quantity: folder.fold_expr(node.quantity),
6333 }
6334}
6335impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGenerator {
6336 type Folded = LoadGenerator;
6337 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6338 folder.fold_load_generator(self)
6339 }
6340}
6341#[allow(clippy::needless_pass_by_ref_mut)]
6342pub fn fold_load_generator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGenerator) -> LoadGenerator
6343where
6344 F: Fold<T, T2, > + ?Sized,
6345{
6346 match node {
6347 LoadGenerator::Clock {
6348 } => {
6349 LoadGenerator::Clock {
6350 }
6351 }
6352 LoadGenerator::Counter {
6353 } => {
6354 LoadGenerator::Counter {
6355 }
6356 }
6357 LoadGenerator::Marketing {
6358 } => {
6359 LoadGenerator::Marketing {
6360 }
6361 }
6362 LoadGenerator::Auction {
6363 } => {
6364 LoadGenerator::Auction {
6365 }
6366 }
6367 LoadGenerator::Datums {
6368 } => {
6369 LoadGenerator::Datums {
6370 }
6371 }
6372 LoadGenerator::Tpch {
6373 } => {
6374 LoadGenerator::Tpch {
6375 }
6376 }
6377 LoadGenerator::KeyValue {
6378 } => {
6379 LoadGenerator::KeyValue {
6380 }
6381 }
6382 }
6383}
6384impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGeneratorOption<T> {
6385 type Folded = LoadGeneratorOption<T2>;
6386 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6387 folder.fold_load_generator_option(self)
6388 }
6389}
6390#[allow(clippy::needless_pass_by_ref_mut)]
6391pub fn fold_load_generator_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGeneratorOption<T>) -> LoadGeneratorOption<T2>
6392where
6393 F: Fold<T, T2, > + ?Sized,
6394{
6395 LoadGeneratorOption {
6396 name: folder.fold_load_generator_option_name(node.name),
6397 value: node.value.map(|v| folder.fold_with_option_value(v)),
6398 }
6399}
6400impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for LoadGeneratorOptionName {
6401 type Folded = LoadGeneratorOptionName;
6402 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6403 folder.fold_load_generator_option_name(self)
6404 }
6405}
6406#[allow(clippy::needless_pass_by_ref_mut)]
6407pub fn fold_load_generator_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: LoadGeneratorOptionName) -> LoadGeneratorOptionName
6408where
6409 F: Fold<T, T2, > + ?Sized,
6410{
6411 match node {
6412 LoadGeneratorOptionName::ScaleFactor {
6413 } => {
6414 LoadGeneratorOptionName::ScaleFactor {
6415 }
6416 }
6417 LoadGeneratorOptionName::TickInterval {
6418 } => {
6419 LoadGeneratorOptionName::TickInterval {
6420 }
6421 }
6422 LoadGeneratorOptionName::AsOf {
6423 } => {
6424 LoadGeneratorOptionName::AsOf {
6425 }
6426 }
6427 LoadGeneratorOptionName::UpTo {
6428 } => {
6429 LoadGeneratorOptionName::UpTo {
6430 }
6431 }
6432 LoadGeneratorOptionName::MaxCardinality {
6433 } => {
6434 LoadGeneratorOptionName::MaxCardinality {
6435 }
6436 }
6437 LoadGeneratorOptionName::Keys {
6438 } => {
6439 LoadGeneratorOptionName::Keys {
6440 }
6441 }
6442 LoadGeneratorOptionName::SnapshotRounds {
6443 } => {
6444 LoadGeneratorOptionName::SnapshotRounds {
6445 }
6446 }
6447 LoadGeneratorOptionName::TransactionalSnapshot {
6448 } => {
6449 LoadGeneratorOptionName::TransactionalSnapshot {
6450 }
6451 }
6452 LoadGeneratorOptionName::ValueSize {
6453 } => {
6454 LoadGeneratorOptionName::ValueSize {
6455 }
6456 }
6457 LoadGeneratorOptionName::Seed {
6458 } => {
6459 LoadGeneratorOptionName::Seed {
6460 }
6461 }
6462 LoadGeneratorOptionName::Partitions {
6463 } => {
6464 LoadGeneratorOptionName::Partitions {
6465 }
6466 }
6467 LoadGeneratorOptionName::BatchSize {
6468 } => {
6469 LoadGeneratorOptionName::BatchSize {
6470 }
6471 }
6472 }
6473}
6474impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MapEntry<T> {
6475 type Folded = MapEntry<T2>;
6476 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6477 folder.fold_map_entry(self)
6478 }
6479}
6480#[allow(clippy::needless_pass_by_ref_mut)]
6481pub fn fold_map_entry<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MapEntry<T>) -> MapEntry<T2>
6482where
6483 F: Fold<T, T2, > + ?Sized,
6484{
6485 MapEntry {
6486 key: folder.fold_expr(node.key),
6487 value: folder.fold_expr(node.value),
6488 }
6489}
6490impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MaterializedViewOption<T> {
6491 type Folded = MaterializedViewOption<T2>;
6492 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6493 folder.fold_materialized_view_option(self)
6494 }
6495}
6496#[allow(clippy::needless_pass_by_ref_mut)]
6497pub fn fold_materialized_view_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MaterializedViewOption<T>) -> MaterializedViewOption<T2>
6498where
6499 F: Fold<T, T2, > + ?Sized,
6500{
6501 MaterializedViewOption {
6502 name: folder.fold_materialized_view_option_name(node.name),
6503 value: node.value.map(|v| folder.fold_with_option_value(v)),
6504 }
6505}
6506impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MaterializedViewOptionName {
6507 type Folded = MaterializedViewOptionName;
6508 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6509 folder.fold_materialized_view_option_name(self)
6510 }
6511}
6512#[allow(clippy::needless_pass_by_ref_mut)]
6513pub fn fold_materialized_view_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MaterializedViewOptionName) -> MaterializedViewOptionName
6514where
6515 F: Fold<T, T2, > + ?Sized,
6516{
6517 match node {
6518 MaterializedViewOptionName::AssertNotNull {
6519 } => {
6520 MaterializedViewOptionName::AssertNotNull {
6521 }
6522 }
6523 MaterializedViewOptionName::PartitionBy {
6524 } => {
6525 MaterializedViewOptionName::PartitionBy {
6526 }
6527 }
6528 MaterializedViewOptionName::RetainHistory {
6529 } => {
6530 MaterializedViewOptionName::RetainHistory {
6531 }
6532 }
6533 MaterializedViewOptionName::Refresh {
6534 } => {
6535 MaterializedViewOptionName::Refresh {
6536 }
6537 }
6538 }
6539}
6540impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlock<T> {
6541 type Folded = MutRecBlock<T2>;
6542 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6543 folder.fold_mut_rec_block(self)
6544 }
6545}
6546#[allow(clippy::needless_pass_by_ref_mut)]
6547pub fn fold_mut_rec_block<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlock<T>) -> MutRecBlock<T2>
6548where
6549 F: Fold<T, T2, > + ?Sized,
6550{
6551 MutRecBlock {
6552 options: node.options.into_iter().map(|v| folder.fold_mut_rec_block_option(v)).collect(),
6553 ctes: node.ctes.into_iter().map(|v| folder.fold_cte_mut_rec(v)).collect(),
6554 }
6555}
6556impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlockOption<T> {
6557 type Folded = MutRecBlockOption<T2>;
6558 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6559 folder.fold_mut_rec_block_option(self)
6560 }
6561}
6562#[allow(clippy::needless_pass_by_ref_mut)]
6563pub fn fold_mut_rec_block_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlockOption<T>) -> MutRecBlockOption<T2>
6564where
6565 F: Fold<T, T2, > + ?Sized,
6566{
6567 MutRecBlockOption {
6568 name: folder.fold_mut_rec_block_option_name(node.name),
6569 value: node.value.map(|v| folder.fold_with_option_value(v)),
6570 }
6571}
6572impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MutRecBlockOptionName {
6573 type Folded = MutRecBlockOptionName;
6574 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6575 folder.fold_mut_rec_block_option_name(self)
6576 }
6577}
6578#[allow(clippy::needless_pass_by_ref_mut)]
6579pub fn fold_mut_rec_block_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MutRecBlockOptionName) -> MutRecBlockOptionName
6580where
6581 F: Fold<T, T2, > + ?Sized,
6582{
6583 match node {
6584 MutRecBlockOptionName::RecursionLimit {
6585 } => {
6586 MutRecBlockOptionName::RecursionLimit {
6587 }
6588 }
6589 MutRecBlockOptionName::ErrorAtRecursionLimit {
6590 } => {
6591 MutRecBlockOptionName::ErrorAtRecursionLimit {
6592 }
6593 }
6594 MutRecBlockOptionName::ReturnAtRecursionLimit {
6595 } => {
6596 MutRecBlockOptionName::ReturnAtRecursionLimit {
6597 }
6598 }
6599 }
6600}
6601impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MySqlConfigOption<T> {
6602 type Folded = MySqlConfigOption<T2>;
6603 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6604 folder.fold_my_sql_config_option(self)
6605 }
6606}
6607#[allow(clippy::needless_pass_by_ref_mut)]
6608pub fn fold_my_sql_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MySqlConfigOption<T>) -> MySqlConfigOption<T2>
6609where
6610 F: Fold<T, T2, > + ?Sized,
6611{
6612 MySqlConfigOption {
6613 name: folder.fold_my_sql_config_option_name(node.name),
6614 value: node.value.map(|v| folder.fold_with_option_value(v)),
6615 }
6616}
6617impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for MySqlConfigOptionName {
6618 type Folded = MySqlConfigOptionName;
6619 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6620 folder.fold_my_sql_config_option_name(self)
6621 }
6622}
6623#[allow(clippy::needless_pass_by_ref_mut)]
6624pub fn fold_my_sql_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: MySqlConfigOptionName) -> MySqlConfigOptionName
6625where
6626 F: Fold<T, T2, > + ?Sized,
6627{
6628 match node {
6629 MySqlConfigOptionName::Details {
6630 } => {
6631 MySqlConfigOptionName::Details {
6632 }
6633 }
6634 MySqlConfigOptionName::TextColumns {
6635 } => {
6636 MySqlConfigOptionName::TextColumns {
6637 }
6638 }
6639 MySqlConfigOptionName::ExcludeColumns {
6640 } => {
6641 MySqlConfigOptionName::ExcludeColumns {
6642 }
6643 }
6644 }
6645}
6646impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NamedPlan {
6647 type Folded = NamedPlan;
6648 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6649 folder.fold_named_plan(self)
6650 }
6651}
6652#[allow(clippy::needless_pass_by_ref_mut)]
6653pub fn fold_named_plan<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NamedPlan) -> NamedPlan
6654where
6655 F: Fold<T, T2, > + ?Sized,
6656{
6657 match node {
6658 NamedPlan::Raw {
6659 } => {
6660 NamedPlan::Raw {
6661 }
6662 }
6663 NamedPlan::Decorrelated {
6664 } => {
6665 NamedPlan::Decorrelated {
6666 }
6667 }
6668 NamedPlan::Local {
6669 } => {
6670 NamedPlan::Local {
6671 }
6672 }
6673 NamedPlan::Global {
6674 } => {
6675 NamedPlan::Global {
6676 }
6677 }
6678 NamedPlan::Physical {
6679 } => {
6680 NamedPlan::Physical {
6681 }
6682 }
6683 NamedPlan::FastPath {
6684 } => {
6685 NamedPlan::FastPath {
6686 }
6687 }
6688 }
6689}
6690impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NetworkPolicyOption<T> {
6691 type Folded = NetworkPolicyOption<T2>;
6692 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6693 folder.fold_network_policy_option(self)
6694 }
6695}
6696#[allow(clippy::needless_pass_by_ref_mut)]
6697pub fn fold_network_policy_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NetworkPolicyOption<T>) -> NetworkPolicyOption<T2>
6698where
6699 F: Fold<T, T2, > + ?Sized,
6700{
6701 NetworkPolicyOption {
6702 name: folder.fold_network_policy_option_name(node.name),
6703 value: node.value.map(|v| folder.fold_with_option_value(v)),
6704 }
6705}
6706impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NetworkPolicyOptionName {
6707 type Folded = NetworkPolicyOptionName;
6708 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6709 folder.fold_network_policy_option_name(self)
6710 }
6711}
6712#[allow(clippy::needless_pass_by_ref_mut)]
6713pub fn fold_network_policy_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NetworkPolicyOptionName) -> NetworkPolicyOptionName
6714where
6715 F: Fold<T, T2, > + ?Sized,
6716{
6717 match node {
6718 NetworkPolicyOptionName::Rules {
6719 } => {
6720 NetworkPolicyOptionName::Rules {
6721 }
6722 }
6723 }
6724}
6725impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NetworkPolicyRuleDefinition<T> {
6726 type Folded = NetworkPolicyRuleDefinition<T2>;
6727 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6728 folder.fold_network_policy_rule_definition(self)
6729 }
6730}
6731#[allow(clippy::needless_pass_by_ref_mut)]
6732pub fn fold_network_policy_rule_definition<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NetworkPolicyRuleDefinition<T>) -> NetworkPolicyRuleDefinition<T2>
6733where
6734 F: Fold<T, T2, > + ?Sized,
6735{
6736 NetworkPolicyRuleDefinition {
6737 name: folder.fold_ident(node.name),
6738 options: node.options.into_iter().map(|v| folder.fold_network_policy_rule_option(v)).collect(),
6739 }
6740}
6741impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NetworkPolicyRuleOption<T> {
6742 type Folded = NetworkPolicyRuleOption<T2>;
6743 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6744 folder.fold_network_policy_rule_option(self)
6745 }
6746}
6747#[allow(clippy::needless_pass_by_ref_mut)]
6748pub fn fold_network_policy_rule_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NetworkPolicyRuleOption<T>) -> NetworkPolicyRuleOption<T2>
6749where
6750 F: Fold<T, T2, > + ?Sized,
6751{
6752 NetworkPolicyRuleOption {
6753 name: folder.fold_network_policy_rule_option_name(node.name),
6754 value: node.value.map(|v| folder.fold_with_option_value(v)),
6755 }
6756}
6757impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NetworkPolicyRuleOptionName {
6758 type Folded = NetworkPolicyRuleOptionName;
6759 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6760 folder.fold_network_policy_rule_option_name(self)
6761 }
6762}
6763#[allow(clippy::needless_pass_by_ref_mut)]
6764pub fn fold_network_policy_rule_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NetworkPolicyRuleOptionName) -> NetworkPolicyRuleOptionName
6765where
6766 F: Fold<T, T2, > + ?Sized,
6767{
6768 match node {
6769 NetworkPolicyRuleOptionName::Direction {
6770 } => {
6771 NetworkPolicyRuleOptionName::Direction {
6772 }
6773 }
6774 NetworkPolicyRuleOptionName::Action {
6775 } => {
6776 NetworkPolicyRuleOptionName::Action {
6777 }
6778 }
6779 NetworkPolicyRuleOptionName::Address {
6780 } => {
6781 NetworkPolicyRuleOptionName::Address {
6782 }
6783 }
6784 }
6785}
6786impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for NoticeSeverity {
6787 type Folded = NoticeSeverity;
6788 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6789 folder.fold_notice_severity(self)
6790 }
6791}
6792#[allow(clippy::needless_pass_by_ref_mut)]
6793pub fn fold_notice_severity<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: NoticeSeverity) -> NoticeSeverity
6794where
6795 F: Fold<T, T2, > + ?Sized,
6796{
6797 match node {
6798 NoticeSeverity::Debug {
6799 } => {
6800 NoticeSeverity::Debug {
6801 }
6802 }
6803 NoticeSeverity::Info {
6804 } => {
6805 NoticeSeverity::Info {
6806 }
6807 }
6808 NoticeSeverity::Log {
6809 } => {
6810 NoticeSeverity::Log {
6811 }
6812 }
6813 NoticeSeverity::Notice {
6814 } => {
6815 NoticeSeverity::Notice {
6816 }
6817 }
6818 NoticeSeverity::Warning {
6819 } => {
6820 NoticeSeverity::Warning {
6821 }
6822 }
6823 }
6824}
6825impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ObjectType {
6826 type Folded = ObjectType;
6827 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6828 folder.fold_object_type(self)
6829 }
6830}
6831#[allow(clippy::needless_pass_by_ref_mut)]
6832pub fn fold_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ObjectType) -> ObjectType
6833where
6834 F: Fold<T, T2, > + ?Sized,
6835{
6836 match node {
6837 ObjectType::Table {
6838 } => {
6839 ObjectType::Table {
6840 }
6841 }
6842 ObjectType::View {
6843 } => {
6844 ObjectType::View {
6845 }
6846 }
6847 ObjectType::MaterializedView {
6848 } => {
6849 ObjectType::MaterializedView {
6850 }
6851 }
6852 ObjectType::Source {
6853 } => {
6854 ObjectType::Source {
6855 }
6856 }
6857 ObjectType::Sink {
6858 } => {
6859 ObjectType::Sink {
6860 }
6861 }
6862 ObjectType::Index {
6863 } => {
6864 ObjectType::Index {
6865 }
6866 }
6867 ObjectType::Type {
6868 } => {
6869 ObjectType::Type {
6870 }
6871 }
6872 ObjectType::Role {
6873 } => {
6874 ObjectType::Role {
6875 }
6876 }
6877 ObjectType::Cluster {
6878 } => {
6879 ObjectType::Cluster {
6880 }
6881 }
6882 ObjectType::ClusterReplica {
6883 } => {
6884 ObjectType::ClusterReplica {
6885 }
6886 }
6887 ObjectType::Secret {
6888 } => {
6889 ObjectType::Secret {
6890 }
6891 }
6892 ObjectType::Connection {
6893 } => {
6894 ObjectType::Connection {
6895 }
6896 }
6897 ObjectType::Database {
6898 } => {
6899 ObjectType::Database {
6900 }
6901 }
6902 ObjectType::Schema {
6903 } => {
6904 ObjectType::Schema {
6905 }
6906 }
6907 ObjectType::Func {
6908 } => {
6909 ObjectType::Func {
6910 }
6911 }
6912 ObjectType::Subsource {
6913 } => {
6914 ObjectType::Subsource {
6915 }
6916 }
6917 ObjectType::ContinualTask {
6918 } => {
6919 ObjectType::ContinualTask {
6920 }
6921 }
6922 ObjectType::NetworkPolicy {
6923 } => {
6924 ObjectType::NetworkPolicy {
6925 }
6926 }
6927 }
6928}
6929impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Op {
6930 type Folded = Op;
6931 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6932 folder.fold_op(self)
6933 }
6934}
6935#[allow(clippy::needless_pass_by_ref_mut)]
6936pub fn fold_op<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Op) -> Op
6937where
6938 F: Fold<T, T2, > + ?Sized,
6939{
6940 Op {
6941 namespace: node.namespace.map(|v| v.into_iter().map(|v| folder.fold_ident(v)).collect()),
6942 op: node.op,
6943 }
6944}
6945impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for OrderByExpr<T> {
6946 type Folded = OrderByExpr<T2>;
6947 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6948 folder.fold_order_by_expr(self)
6949 }
6950}
6951#[allow(clippy::needless_pass_by_ref_mut)]
6952pub fn fold_order_by_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: OrderByExpr<T>) -> OrderByExpr<T2>
6953where
6954 F: Fold<T, T2, > + ?Sized,
6955{
6956 OrderByExpr {
6957 expr: folder.fold_expr(node.expr),
6958 asc: node.asc.map(|v| v),
6959 nulls_last: node.nulls_last.map(|v| v),
6960 }
6961}
6962impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PgConfigOption<T> {
6963 type Folded = PgConfigOption<T2>;
6964 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6965 folder.fold_pg_config_option(self)
6966 }
6967}
6968#[allow(clippy::needless_pass_by_ref_mut)]
6969pub fn fold_pg_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PgConfigOption<T>) -> PgConfigOption<T2>
6970where
6971 F: Fold<T, T2, > + ?Sized,
6972{
6973 PgConfigOption {
6974 name: folder.fold_pg_config_option_name(node.name),
6975 value: node.value.map(|v| folder.fold_with_option_value(v)),
6976 }
6977}
6978impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PgConfigOptionName {
6979 type Folded = PgConfigOptionName;
6980 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
6981 folder.fold_pg_config_option_name(self)
6982 }
6983}
6984#[allow(clippy::needless_pass_by_ref_mut)]
6985pub fn fold_pg_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PgConfigOptionName) -> PgConfigOptionName
6986where
6987 F: Fold<T, T2, > + ?Sized,
6988{
6989 match node {
6990 PgConfigOptionName::Details {
6991 } => {
6992 PgConfigOptionName::Details {
6993 }
6994 }
6995 PgConfigOptionName::Publication {
6996 } => {
6997 PgConfigOptionName::Publication {
6998 }
6999 }
7000 PgConfigOptionName::TextColumns {
7001 } => {
7002 PgConfigOptionName::TextColumns {
7003 }
7004 }
7005 PgConfigOptionName::ExcludeColumns {
7006 } => {
7007 PgConfigOptionName::ExcludeColumns {
7008 }
7009 }
7010 }
7011}
7012impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PrepareStatement<T> {
7013 type Folded = PrepareStatement<T2>;
7014 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7015 folder.fold_prepare_statement(self)
7016 }
7017}
7018#[allow(clippy::needless_pass_by_ref_mut)]
7019pub fn fold_prepare_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PrepareStatement<T>) -> PrepareStatement<T2>
7020where
7021 F: Fold<T, T2, > + ?Sized,
7022{
7023 PrepareStatement {
7024 name: folder.fold_ident(node.name),
7025 stmt: Box::new(folder.fold_nested_statement(*node.stmt)),
7026 sql: node.sql,
7027 }
7028}
7029impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Privilege {
7030 type Folded = Privilege;
7031 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7032 folder.fold_privilege(self)
7033 }
7034}
7035#[allow(clippy::needless_pass_by_ref_mut)]
7036pub fn fold_privilege<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Privilege) -> Privilege
7037where
7038 F: Fold<T, T2, > + ?Sized,
7039{
7040 match node {
7041 Privilege::SELECT {
7042 } => {
7043 Privilege::SELECT {
7044 }
7045 }
7046 Privilege::INSERT {
7047 } => {
7048 Privilege::INSERT {
7049 }
7050 }
7051 Privilege::UPDATE {
7052 } => {
7053 Privilege::UPDATE {
7054 }
7055 }
7056 Privilege::DELETE {
7057 } => {
7058 Privilege::DELETE {
7059 }
7060 }
7061 Privilege::USAGE {
7062 } => {
7063 Privilege::USAGE {
7064 }
7065 }
7066 Privilege::CREATE {
7067 } => {
7068 Privilege::CREATE {
7069 }
7070 }
7071 Privilege::CREATEROLE {
7072 } => {
7073 Privilege::CREATEROLE {
7074 }
7075 }
7076 Privilege::CREATEDB {
7077 } => {
7078 Privilege::CREATEDB {
7079 }
7080 }
7081 Privilege::CREATECLUSTER {
7082 } => {
7083 Privilege::CREATECLUSTER {
7084 }
7085 }
7086 Privilege::CREATENETWORKPOLICY {
7087 } => {
7088 Privilege::CREATENETWORKPOLICY {
7089 }
7090 }
7091 }
7092}
7093impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for PrivilegeSpecification {
7094 type Folded = PrivilegeSpecification;
7095 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7096 folder.fold_privilege_specification(self)
7097 }
7098}
7099#[allow(clippy::needless_pass_by_ref_mut)]
7100pub fn fold_privilege_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: PrivilegeSpecification) -> PrivilegeSpecification
7101where
7102 F: Fold<T, T2, > + ?Sized,
7103{
7104 match node {
7105 PrivilegeSpecification::All {
7106 } => {
7107 PrivilegeSpecification::All {
7108 }
7109 }
7110 PrivilegeSpecification::Privileges {
7111 0: binding0,
7112 } => {
7113 PrivilegeSpecification::Privileges {
7114 0: binding0.into_iter().map(|v| folder.fold_privilege(v)).collect(),
7115 }
7116 }
7117 }
7118}
7119impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ProtobufSchema<T> {
7120 type Folded = ProtobufSchema<T2>;
7121 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7122 folder.fold_protobuf_schema(self)
7123 }
7124}
7125#[allow(clippy::needless_pass_by_ref_mut)]
7126pub fn fold_protobuf_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ProtobufSchema<T>) -> ProtobufSchema<T2>
7127where
7128 F: Fold<T, T2, > + ?Sized,
7129{
7130 match node {
7131 ProtobufSchema::Csr {
7132 csr_connection: binding0,
7133 } => {
7134 ProtobufSchema::Csr {
7135 csr_connection: folder.fold_csr_connection_protobuf(binding0),
7136 }
7137 }
7138 ProtobufSchema::InlineSchema {
7139 message_name: binding0,
7140 schema: binding1,
7141 } => {
7142 ProtobufSchema::InlineSchema {
7143 message_name: binding0,
7144 schema: folder.fold_schema(binding1),
7145 }
7146 }
7147 }
7148}
7149impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for QualifiedReplica {
7150 type Folded = QualifiedReplica;
7151 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7152 folder.fold_qualified_replica(self)
7153 }
7154}
7155#[allow(clippy::needless_pass_by_ref_mut)]
7156pub fn fold_qualified_replica<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: QualifiedReplica) -> QualifiedReplica
7157where
7158 F: Fold<T, T2, > + ?Sized,
7159{
7160 QualifiedReplica {
7161 cluster: folder.fold_ident(node.cluster),
7162 replica: folder.fold_ident(node.replica),
7163 }
7164}
7165impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Query<T> {
7166 type Folded = Query<T2>;
7167 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7168 folder.fold_query(self)
7169 }
7170}
7171#[allow(clippy::needless_pass_by_ref_mut)]
7172pub fn fold_query<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Query<T>) -> Query<T2>
7173where
7174 F: Fold<T, T2, > + ?Sized,
7175{
7176 Query {
7177 ctes: folder.fold_cte_block(node.ctes),
7178 body: folder.fold_set_expr(node.body),
7179 order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
7180 limit: node.limit.map(|v| folder.fold_limit(v)),
7181 offset: node.offset.map(|v| folder.fold_expr(v)),
7182 }
7183}
7184impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RaiseStatement {
7185 type Folded = RaiseStatement;
7186 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7187 folder.fold_raise_statement(self)
7188 }
7189}
7190#[allow(clippy::needless_pass_by_ref_mut)]
7191pub fn fold_raise_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RaiseStatement) -> RaiseStatement
7192where
7193 F: Fold<T, T2, > + ?Sized,
7194{
7195 RaiseStatement {
7196 severity: folder.fold_notice_severity(node.severity),
7197 }
7198}
7199impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReaderSchemaSelectionStrategy {
7200 type Folded = ReaderSchemaSelectionStrategy;
7201 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7202 folder.fold_reader_schema_selection_strategy(self)
7203 }
7204}
7205#[allow(clippy::needless_pass_by_ref_mut)]
7206pub fn fold_reader_schema_selection_strategy<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReaderSchemaSelectionStrategy) -> ReaderSchemaSelectionStrategy
7207where
7208 F: Fold<T, T2, > + ?Sized,
7209{
7210 match node {
7211 ReaderSchemaSelectionStrategy::Latest {
7212 } => {
7213 ReaderSchemaSelectionStrategy::Latest {
7214 }
7215 }
7216 ReaderSchemaSelectionStrategy::Inline {
7217 0: binding0,
7218 } => {
7219 ReaderSchemaSelectionStrategy::Inline {
7220 0: binding0,
7221 }
7222 }
7223 ReaderSchemaSelectionStrategy::ById {
7224 0: binding0,
7225 } => {
7226 ReaderSchemaSelectionStrategy::ById {
7227 0: binding0,
7228 }
7229 }
7230 }
7231}
7232impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReassignOwnedStatement<T> {
7233 type Folded = ReassignOwnedStatement<T2>;
7234 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7235 folder.fold_reassign_owned_statement(self)
7236 }
7237}
7238#[allow(clippy::needless_pass_by_ref_mut)]
7239pub fn fold_reassign_owned_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReassignOwnedStatement<T>) -> ReassignOwnedStatement<T2>
7240where
7241 F: Fold<T, T2, > + ?Sized,
7242{
7243 ReassignOwnedStatement {
7244 old_roles: node.old_roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
7245 new_role: folder.fold_role_name(node.new_role),
7246 }
7247}
7248impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshAtOptionValue<T> {
7249 type Folded = RefreshAtOptionValue<T2>;
7250 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7251 folder.fold_refresh_at_option_value(self)
7252 }
7253}
7254#[allow(clippy::needless_pass_by_ref_mut)]
7255pub fn fold_refresh_at_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshAtOptionValue<T>) -> RefreshAtOptionValue<T2>
7256where
7257 F: Fold<T, T2, > + ?Sized,
7258{
7259 RefreshAtOptionValue {
7260 time: folder.fold_expr(node.time),
7261 }
7262}
7263impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshEveryOptionValue<T> {
7264 type Folded = RefreshEveryOptionValue<T2>;
7265 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7266 folder.fold_refresh_every_option_value(self)
7267 }
7268}
7269#[allow(clippy::needless_pass_by_ref_mut)]
7270pub fn fold_refresh_every_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshEveryOptionValue<T>) -> RefreshEveryOptionValue<T2>
7271where
7272 F: Fold<T, T2, > + ?Sized,
7273{
7274 RefreshEveryOptionValue {
7275 interval: folder.fold_interval_value(node.interval),
7276 aligned_to: node.aligned_to.map(|v| folder.fold_expr(v)),
7277 }
7278}
7279impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RefreshOptionValue<T> {
7280 type Folded = RefreshOptionValue<T2>;
7281 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7282 folder.fold_refresh_option_value(self)
7283 }
7284}
7285#[allow(clippy::needless_pass_by_ref_mut)]
7286pub fn fold_refresh_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RefreshOptionValue<T>) -> RefreshOptionValue<T2>
7287where
7288 F: Fold<T, T2, > + ?Sized,
7289{
7290 match node {
7291 RefreshOptionValue::OnCommit {
7292 } => {
7293 RefreshOptionValue::OnCommit {
7294 }
7295 }
7296 RefreshOptionValue::AtCreation {
7297 } => {
7298 RefreshOptionValue::AtCreation {
7299 }
7300 }
7301 RefreshOptionValue::At {
7302 0: binding0,
7303 } => {
7304 RefreshOptionValue::At {
7305 0: folder.fold_refresh_at_option_value(binding0),
7306 }
7307 }
7308 RefreshOptionValue::Every {
7309 0: binding0,
7310 } => {
7311 RefreshOptionValue::Every {
7312 0: folder.fold_refresh_every_option_value(binding0),
7313 }
7314 }
7315 }
7316}
7317impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaDefinition<T> {
7318 type Folded = ReplicaDefinition<T2>;
7319 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7320 folder.fold_replica_definition(self)
7321 }
7322}
7323#[allow(clippy::needless_pass_by_ref_mut)]
7324pub fn fold_replica_definition<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaDefinition<T>) -> ReplicaDefinition<T2>
7325where
7326 F: Fold<T, T2, > + ?Sized,
7327{
7328 ReplicaDefinition {
7329 name: folder.fold_ident(node.name),
7330 options: node.options.into_iter().map(|v| folder.fold_replica_option(v)).collect(),
7331 }
7332}
7333impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaOption<T> {
7334 type Folded = ReplicaOption<T2>;
7335 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7336 folder.fold_replica_option(self)
7337 }
7338}
7339#[allow(clippy::needless_pass_by_ref_mut)]
7340pub fn fold_replica_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaOption<T>) -> ReplicaOption<T2>
7341where
7342 F: Fold<T, T2, > + ?Sized,
7343{
7344 ReplicaOption {
7345 name: folder.fold_replica_option_name(node.name),
7346 value: node.value.map(|v| folder.fold_with_option_value(v)),
7347 }
7348}
7349impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ReplicaOptionName {
7350 type Folded = ReplicaOptionName;
7351 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7352 folder.fold_replica_option_name(self)
7353 }
7354}
7355#[allow(clippy::needless_pass_by_ref_mut)]
7356pub fn fold_replica_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ReplicaOptionName) -> ReplicaOptionName
7357where
7358 F: Fold<T, T2, > + ?Sized,
7359{
7360 match node {
7361 ReplicaOptionName::BilledAs {
7362 } => {
7363 ReplicaOptionName::BilledAs {
7364 }
7365 }
7366 ReplicaOptionName::Size {
7367 } => {
7368 ReplicaOptionName::Size {
7369 }
7370 }
7371 ReplicaOptionName::AvailabilityZone {
7372 } => {
7373 ReplicaOptionName::AvailabilityZone {
7374 }
7375 }
7376 ReplicaOptionName::StorageAddresses {
7377 } => {
7378 ReplicaOptionName::StorageAddresses {
7379 }
7380 }
7381 ReplicaOptionName::StoragectlAddresses {
7382 } => {
7383 ReplicaOptionName::StoragectlAddresses {
7384 }
7385 }
7386 ReplicaOptionName::ComputectlAddresses {
7387 } => {
7388 ReplicaOptionName::ComputectlAddresses {
7389 }
7390 }
7391 ReplicaOptionName::ComputeAddresses {
7392 } => {
7393 ReplicaOptionName::ComputeAddresses {
7394 }
7395 }
7396 ReplicaOptionName::Workers {
7397 } => {
7398 ReplicaOptionName::Workers {
7399 }
7400 }
7401 ReplicaOptionName::Internal {
7402 } => {
7403 ReplicaOptionName::Internal {
7404 }
7405 }
7406 ReplicaOptionName::IntrospectionInterval {
7407 } => {
7408 ReplicaOptionName::IntrospectionInterval {
7409 }
7410 }
7411 ReplicaOptionName::IntrospectionDebugging {
7412 } => {
7413 ReplicaOptionName::IntrospectionDebugging {
7414 }
7415 }
7416 ReplicaOptionName::Disk {
7417 } => {
7418 ReplicaOptionName::Disk {
7419 }
7420 }
7421 }
7422}
7423impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ResetVariableStatement {
7424 type Folded = ResetVariableStatement;
7425 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7426 folder.fold_reset_variable_statement(self)
7427 }
7428}
7429#[allow(clippy::needless_pass_by_ref_mut)]
7430pub fn fold_reset_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ResetVariableStatement) -> ResetVariableStatement
7431where
7432 F: Fold<T, T2, > + ?Sized,
7433{
7434 ResetVariableStatement {
7435 variable: folder.fold_ident(node.variable),
7436 }
7437}
7438impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RevokePrivilegesStatement<T> {
7439 type Folded = RevokePrivilegesStatement<T2>;
7440 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7441 folder.fold_revoke_privileges_statement(self)
7442 }
7443}
7444#[allow(clippy::needless_pass_by_ref_mut)]
7445pub fn fold_revoke_privileges_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RevokePrivilegesStatement<T>) -> RevokePrivilegesStatement<T2>
7446where
7447 F: Fold<T, T2, > + ?Sized,
7448{
7449 RevokePrivilegesStatement {
7450 privileges: folder.fold_privilege_specification(node.privileges),
7451 target: folder.fold_grant_target_specification(node.target),
7452 roles: node.roles.into_iter().map(|v| folder.fold_role_name(v)).collect(),
7453 }
7454}
7455impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RevokeRoleStatement<T> {
7456 type Folded = RevokeRoleStatement<T2>;
7457 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7458 folder.fold_revoke_role_statement(self)
7459 }
7460}
7461#[allow(clippy::needless_pass_by_ref_mut)]
7462pub fn fold_revoke_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RevokeRoleStatement<T>) -> RevokeRoleStatement<T2>
7463where
7464 F: Fold<T, T2, > + ?Sized,
7465{
7466 RevokeRoleStatement {
7467 role_names: node.role_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
7468 member_names: node.member_names.into_iter().map(|v| folder.fold_role_name(v)).collect(),
7469 }
7470}
7471impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RoleAttribute {
7472 type Folded = RoleAttribute;
7473 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7474 folder.fold_role_attribute(self)
7475 }
7476}
7477#[allow(clippy::needless_pass_by_ref_mut)]
7478pub fn fold_role_attribute<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RoleAttribute) -> RoleAttribute
7479where
7480 F: Fold<T, T2, > + ?Sized,
7481{
7482 match node {
7483 RoleAttribute::Inherit {
7484 } => {
7485 RoleAttribute::Inherit {
7486 }
7487 }
7488 RoleAttribute::NoInherit {
7489 } => {
7490 RoleAttribute::NoInherit {
7491 }
7492 }
7493 RoleAttribute::Password {
7494 0: binding0,
7495 } => {
7496 RoleAttribute::Password {
7497 0: binding0.map(|v| v),
7498 }
7499 }
7500 RoleAttribute::Login {
7501 } => {
7502 RoleAttribute::Login {
7503 }
7504 }
7505 RoleAttribute::NoLogin {
7506 } => {
7507 RoleAttribute::NoLogin {
7508 }
7509 }
7510 RoleAttribute::SuperUser {
7511 } => {
7512 RoleAttribute::SuperUser {
7513 }
7514 }
7515 RoleAttribute::NoSuperUser {
7516 } => {
7517 RoleAttribute::NoSuperUser {
7518 }
7519 }
7520 RoleAttribute::CreateCluster {
7521 } => {
7522 RoleAttribute::CreateCluster {
7523 }
7524 }
7525 RoleAttribute::NoCreateCluster {
7526 } => {
7527 RoleAttribute::NoCreateCluster {
7528 }
7529 }
7530 RoleAttribute::CreateDB {
7531 } => {
7532 RoleAttribute::CreateDB {
7533 }
7534 }
7535 RoleAttribute::NoCreateDB {
7536 } => {
7537 RoleAttribute::NoCreateDB {
7538 }
7539 }
7540 RoleAttribute::CreateRole {
7541 } => {
7542 RoleAttribute::CreateRole {
7543 }
7544 }
7545 RoleAttribute::NoCreateRole {
7546 } => {
7547 RoleAttribute::NoCreateRole {
7548 }
7549 }
7550 }
7551}
7552impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for RollbackStatement {
7553 type Folded = RollbackStatement;
7554 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7555 folder.fold_rollback_statement(self)
7556 }
7557}
7558#[allow(clippy::needless_pass_by_ref_mut)]
7559pub fn fold_rollback_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RollbackStatement) -> RollbackStatement
7560where
7561 F: Fold<T, T2, > + ?Sized,
7562{
7563 RollbackStatement {
7564 chain: node.chain,
7565 }
7566}
7567impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Schema {
7568 type Folded = Schema;
7569 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7570 folder.fold_schema(self)
7571 }
7572}
7573#[allow(clippy::needless_pass_by_ref_mut)]
7574pub fn fold_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Schema) -> Schema
7575where
7576 F: Fold<T, T2, > + ?Sized,
7577{
7578 Schema {
7579 schema: node.schema,
7580 }
7581}
7582impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Select<T> {
7583 type Folded = Select<T2>;
7584 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7585 folder.fold_select(self)
7586 }
7587}
7588#[allow(clippy::needless_pass_by_ref_mut)]
7589pub fn fold_select<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Select<T>) -> Select<T2>
7590where
7591 F: Fold<T, T2, > + ?Sized,
7592{
7593 Select {
7594 distinct: node.distinct.map(|v| folder.fold_distinct(v)),
7595 projection: node.projection.into_iter().map(|v| folder.fold_select_item(v)).collect(),
7596 from: node.from.into_iter().map(|v| folder.fold_table_with_joins(v)).collect(),
7597 selection: node.selection.map(|v| folder.fold_expr(v)),
7598 group_by: node.group_by.into_iter().map(|v| folder.fold_expr(v)).collect(),
7599 having: node.having.map(|v| folder.fold_expr(v)),
7600 qualify: node.qualify.map(|v| folder.fold_expr(v)),
7601 options: node.options.into_iter().map(|v| folder.fold_select_option(v)).collect(),
7602 }
7603}
7604impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectItem<T> {
7605 type Folded = SelectItem<T2>;
7606 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7607 folder.fold_select_item(self)
7608 }
7609}
7610#[allow(clippy::needless_pass_by_ref_mut)]
7611pub fn fold_select_item<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectItem<T>) -> SelectItem<T2>
7612where
7613 F: Fold<T, T2, > + ?Sized,
7614{
7615 match node {
7616 SelectItem::Expr {
7617 expr: binding0,
7618 alias: binding1,
7619 } => {
7620 SelectItem::Expr {
7621 expr: folder.fold_expr(binding0),
7622 alias: binding1.map(|v| folder.fold_ident(v)),
7623 }
7624 }
7625 SelectItem::Wildcard {
7626 } => {
7627 SelectItem::Wildcard {
7628 }
7629 }
7630 }
7631}
7632impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectOption<T> {
7633 type Folded = SelectOption<T2>;
7634 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7635 folder.fold_select_option(self)
7636 }
7637}
7638#[allow(clippy::needless_pass_by_ref_mut)]
7639pub fn fold_select_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectOption<T>) -> SelectOption<T2>
7640where
7641 F: Fold<T, T2, > + ?Sized,
7642{
7643 SelectOption {
7644 name: folder.fold_select_option_name(node.name),
7645 value: node.value.map(|v| folder.fold_with_option_value(v)),
7646 }
7647}
7648impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectOptionName {
7649 type Folded = SelectOptionName;
7650 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7651 folder.fold_select_option_name(self)
7652 }
7653}
7654#[allow(clippy::needless_pass_by_ref_mut)]
7655pub fn fold_select_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectOptionName) -> SelectOptionName
7656where
7657 F: Fold<T, T2, > + ?Sized,
7658{
7659 match node {
7660 SelectOptionName::ExpectedGroupSize {
7661 } => {
7662 SelectOptionName::ExpectedGroupSize {
7663 }
7664 }
7665 SelectOptionName::AggregateInputGroupSize {
7666 } => {
7667 SelectOptionName::AggregateInputGroupSize {
7668 }
7669 }
7670 SelectOptionName::DistinctOnInputGroupSize {
7671 } => {
7672 SelectOptionName::DistinctOnInputGroupSize {
7673 }
7674 }
7675 SelectOptionName::LimitInputGroupSize {
7676 } => {
7677 SelectOptionName::LimitInputGroupSize {
7678 }
7679 }
7680 }
7681}
7682impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SelectStatement<T> {
7683 type Folded = SelectStatement<T2>;
7684 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7685 folder.fold_select_statement(self)
7686 }
7687}
7688#[allow(clippy::needless_pass_by_ref_mut)]
7689pub fn fold_select_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectStatement<T>) -> SelectStatement<T2>
7690where
7691 F: Fold<T, T2, > + ?Sized,
7692{
7693 SelectStatement {
7694 query: folder.fold_query(node.query),
7695 as_of: node.as_of.map(|v| folder.fold_as_of(v)),
7696 }
7697}
7698impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetExpr<T> {
7699 type Folded = SetExpr<T2>;
7700 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7701 folder.fold_set_expr(self)
7702 }
7703}
7704#[allow(clippy::needless_pass_by_ref_mut)]
7705pub fn fold_set_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetExpr<T>) -> SetExpr<T2>
7706where
7707 F: Fold<T, T2, > + ?Sized,
7708{
7709 match node {
7710 SetExpr::Select {
7711 0: binding0,
7712 } => {
7713 SetExpr::Select {
7714 0: Box::new(folder.fold_select(*binding0)),
7715 }
7716 }
7717 SetExpr::Query {
7718 0: binding0,
7719 } => {
7720 SetExpr::Query {
7721 0: Box::new(folder.fold_query(*binding0)),
7722 }
7723 }
7724 SetExpr::SetOperation {
7725 op: binding0,
7726 all: binding1,
7727 left: binding2,
7728 right: binding3,
7729 } => {
7730 SetExpr::SetOperation {
7731 op: folder.fold_set_operator(binding0),
7732 all: binding1,
7733 left: Box::new(folder.fold_set_expr(*binding2)),
7734 right: Box::new(folder.fold_set_expr(*binding3)),
7735 }
7736 }
7737 SetExpr::Values {
7738 0: binding0,
7739 } => {
7740 SetExpr::Values {
7741 0: folder.fold_values(binding0),
7742 }
7743 }
7744 SetExpr::Show {
7745 0: binding0,
7746 } => {
7747 SetExpr::Show {
7748 0: folder.fold_show_statement(binding0),
7749 }
7750 }
7751 SetExpr::Table {
7752 0: binding0,
7753 } => {
7754 SetExpr::Table {
7755 0: folder.fold_item_name(binding0),
7756 }
7757 }
7758 }
7759}
7760impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetOperator {
7761 type Folded = SetOperator;
7762 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7763 folder.fold_set_operator(self)
7764 }
7765}
7766#[allow(clippy::needless_pass_by_ref_mut)]
7767pub fn fold_set_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetOperator) -> SetOperator
7768where
7769 F: Fold<T, T2, > + ?Sized,
7770{
7771 match node {
7772 SetOperator::Union {
7773 } => {
7774 SetOperator::Union {
7775 }
7776 }
7777 SetOperator::Except {
7778 } => {
7779 SetOperator::Except {
7780 }
7781 }
7782 SetOperator::Intersect {
7783 } => {
7784 SetOperator::Intersect {
7785 }
7786 }
7787 }
7788}
7789impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetRoleVar {
7790 type Folded = SetRoleVar;
7791 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7792 folder.fold_set_role_var(self)
7793 }
7794}
7795#[allow(clippy::needless_pass_by_ref_mut)]
7796pub fn fold_set_role_var<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetRoleVar) -> SetRoleVar
7797where
7798 F: Fold<T, T2, > + ?Sized,
7799{
7800 match node {
7801 SetRoleVar::Set {
7802 name: binding0,
7803 value: binding1,
7804 } => {
7805 SetRoleVar::Set {
7806 name: folder.fold_ident(binding0),
7807 value: folder.fold_set_variable_to(binding1),
7808 }
7809 }
7810 SetRoleVar::Reset {
7811 name: binding0,
7812 } => {
7813 SetRoleVar::Reset {
7814 name: folder.fold_ident(binding0),
7815 }
7816 }
7817 }
7818}
7819impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetTransactionStatement {
7820 type Folded = SetTransactionStatement;
7821 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7822 folder.fold_set_transaction_statement(self)
7823 }
7824}
7825#[allow(clippy::needless_pass_by_ref_mut)]
7826pub fn fold_set_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetTransactionStatement) -> SetTransactionStatement
7827where
7828 F: Fold<T, T2, > + ?Sized,
7829{
7830 SetTransactionStatement {
7831 local: node.local,
7832 modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(),
7833 }
7834}
7835impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableStatement {
7836 type Folded = SetVariableStatement;
7837 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7838 folder.fold_set_variable_statement(self)
7839 }
7840}
7841#[allow(clippy::needless_pass_by_ref_mut)]
7842pub fn fold_set_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableStatement) -> SetVariableStatement
7843where
7844 F: Fold<T, T2, > + ?Sized,
7845{
7846 SetVariableStatement {
7847 local: node.local,
7848 variable: folder.fold_ident(node.variable),
7849 to: folder.fold_set_variable_to(node.to),
7850 }
7851}
7852impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableTo {
7853 type Folded = SetVariableTo;
7854 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7855 folder.fold_set_variable_to(self)
7856 }
7857}
7858#[allow(clippy::needless_pass_by_ref_mut)]
7859pub fn fold_set_variable_to<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableTo) -> SetVariableTo
7860where
7861 F: Fold<T, T2, > + ?Sized,
7862{
7863 match node {
7864 SetVariableTo::Default {
7865 } => {
7866 SetVariableTo::Default {
7867 }
7868 }
7869 SetVariableTo::Values {
7870 0: binding0,
7871 } => {
7872 SetVariableTo::Values {
7873 0: binding0.into_iter().map(|v| folder.fold_set_variable_value(v)).collect(),
7874 }
7875 }
7876 }
7877}
7878impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SetVariableValue {
7879 type Folded = SetVariableValue;
7880 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7881 folder.fold_set_variable_value(self)
7882 }
7883}
7884#[allow(clippy::needless_pass_by_ref_mut)]
7885pub fn fold_set_variable_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableValue) -> SetVariableValue
7886where
7887 F: Fold<T, T2, > + ?Sized,
7888{
7889 match node {
7890 SetVariableValue::Ident {
7891 0: binding0,
7892 } => {
7893 SetVariableValue::Ident {
7894 0: folder.fold_ident(binding0),
7895 }
7896 }
7897 SetVariableValue::Literal {
7898 0: binding0,
7899 } => {
7900 SetVariableValue::Literal {
7901 0: folder.fold_value(binding0),
7902 }
7903 }
7904 }
7905}
7906impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowColumnsStatement<T> {
7907 type Folded = ShowColumnsStatement<T2>;
7908 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7909 folder.fold_show_columns_statement(self)
7910 }
7911}
7912#[allow(clippy::needless_pass_by_ref_mut)]
7913pub fn fold_show_columns_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2>
7914where
7915 F: Fold<T, T2, > + ?Sized,
7916{
7917 ShowColumnsStatement {
7918 table_name: folder.fold_item_name(node.table_name),
7919 filter: node.filter.map(|v| folder.fold_show_statement_filter(v)),
7920 }
7921}
7922impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateClusterStatement<T> {
7923 type Folded = ShowCreateClusterStatement<T2>;
7924 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7925 folder.fold_show_create_cluster_statement(self)
7926 }
7927}
7928#[allow(clippy::needless_pass_by_ref_mut)]
7929pub fn fold_show_create_cluster_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateClusterStatement<T>) -> ShowCreateClusterStatement<T2>
7930where
7931 F: Fold<T, T2, > + ?Sized,
7932{
7933 ShowCreateClusterStatement {
7934 cluster_name: folder.fold_cluster_name(node.cluster_name),
7935 }
7936}
7937impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateConnectionStatement<T> {
7938 type Folded = ShowCreateConnectionStatement<T2>;
7939 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7940 folder.fold_show_create_connection_statement(self)
7941 }
7942}
7943#[allow(clippy::needless_pass_by_ref_mut)]
7944pub fn fold_show_create_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateConnectionStatement<T>) -> ShowCreateConnectionStatement<T2>
7945where
7946 F: Fold<T, T2, > + ?Sized,
7947{
7948 ShowCreateConnectionStatement {
7949 connection_name: folder.fold_item_name(node.connection_name),
7950 redacted: node.redacted,
7951 }
7952}
7953impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateIndexStatement<T> {
7954 type Folded = ShowCreateIndexStatement<T2>;
7955 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7956 folder.fold_show_create_index_statement(self)
7957 }
7958}
7959#[allow(clippy::needless_pass_by_ref_mut)]
7960pub fn fold_show_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateIndexStatement<T>) -> ShowCreateIndexStatement<T2>
7961where
7962 F: Fold<T, T2, > + ?Sized,
7963{
7964 ShowCreateIndexStatement {
7965 index_name: folder.fold_item_name(node.index_name),
7966 redacted: node.redacted,
7967 }
7968}
7969impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateMaterializedViewStatement<T> {
7970 type Folded = ShowCreateMaterializedViewStatement<T2>;
7971 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7972 folder.fold_show_create_materialized_view_statement(self)
7973 }
7974}
7975#[allow(clippy::needless_pass_by_ref_mut)]
7976pub fn fold_show_create_materialized_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateMaterializedViewStatement<T>) -> ShowCreateMaterializedViewStatement<T2>
7977where
7978 F: Fold<T, T2, > + ?Sized,
7979{
7980 ShowCreateMaterializedViewStatement {
7981 materialized_view_name: folder.fold_item_name(node.materialized_view_name),
7982 redacted: node.redacted,
7983 }
7984}
7985impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateSinkStatement<T> {
7986 type Folded = ShowCreateSinkStatement<T2>;
7987 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
7988 folder.fold_show_create_sink_statement(self)
7989 }
7990}
7991#[allow(clippy::needless_pass_by_ref_mut)]
7992pub fn fold_show_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSinkStatement<T>) -> ShowCreateSinkStatement<T2>
7993where
7994 F: Fold<T, T2, > + ?Sized,
7995{
7996 ShowCreateSinkStatement {
7997 sink_name: folder.fold_item_name(node.sink_name),
7998 redacted: node.redacted,
7999 }
8000}
8001impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateSourceStatement<T> {
8002 type Folded = ShowCreateSourceStatement<T2>;
8003 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8004 folder.fold_show_create_source_statement(self)
8005 }
8006}
8007#[allow(clippy::needless_pass_by_ref_mut)]
8008pub fn fold_show_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSourceStatement<T>) -> ShowCreateSourceStatement<T2>
8009where
8010 F: Fold<T, T2, > + ?Sized,
8011{
8012 ShowCreateSourceStatement {
8013 source_name: folder.fold_item_name(node.source_name),
8014 redacted: node.redacted,
8015 }
8016}
8017impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateTableStatement<T> {
8018 type Folded = ShowCreateTableStatement<T2>;
8019 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8020 folder.fold_show_create_table_statement(self)
8021 }
8022}
8023#[allow(clippy::needless_pass_by_ref_mut)]
8024pub fn fold_show_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateTableStatement<T>) -> ShowCreateTableStatement<T2>
8025where
8026 F: Fold<T, T2, > + ?Sized,
8027{
8028 ShowCreateTableStatement {
8029 table_name: folder.fold_item_name(node.table_name),
8030 redacted: node.redacted,
8031 }
8032}
8033impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateTypeStatement<T> {
8034 type Folded = ShowCreateTypeStatement<T2>;
8035 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8036 folder.fold_show_create_type_statement(self)
8037 }
8038}
8039#[allow(clippy::needless_pass_by_ref_mut)]
8040pub fn fold_show_create_type_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateTypeStatement<T>) -> ShowCreateTypeStatement<T2>
8041where
8042 F: Fold<T, T2, > + ?Sized,
8043{
8044 ShowCreateTypeStatement {
8045 type_name: folder.fold_data_type(node.type_name),
8046 redacted: node.redacted,
8047 }
8048}
8049impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowCreateViewStatement<T> {
8050 type Folded = ShowCreateViewStatement<T2>;
8051 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8052 folder.fold_show_create_view_statement(self)
8053 }
8054}
8055#[allow(clippy::needless_pass_by_ref_mut)]
8056pub fn fold_show_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateViewStatement<T>) -> ShowCreateViewStatement<T2>
8057where
8058 F: Fold<T, T2, > + ?Sized,
8059{
8060 ShowCreateViewStatement {
8061 view_name: folder.fold_item_name(node.view_name),
8062 redacted: node.redacted,
8063 }
8064}
8065impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowObjectType<T> {
8066 type Folded = ShowObjectType<T2>;
8067 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8068 folder.fold_show_object_type(self)
8069 }
8070}
8071#[allow(clippy::needless_pass_by_ref_mut)]
8072pub fn fold_show_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowObjectType<T>) -> ShowObjectType<T2>
8073where
8074 F: Fold<T, T2, > + ?Sized,
8075{
8076 match node {
8077 ShowObjectType::MaterializedView {
8078 in_cluster: binding0,
8079 } => {
8080 ShowObjectType::MaterializedView {
8081 in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
8082 }
8083 }
8084 ShowObjectType::Index {
8085 in_cluster: binding0,
8086 on_object: binding1,
8087 } => {
8088 ShowObjectType::Index {
8089 in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
8090 on_object: binding1.map(|v| folder.fold_item_name(v)),
8091 }
8092 }
8093 ShowObjectType::Table {
8094 on_source: binding0,
8095 } => {
8096 ShowObjectType::Table {
8097 on_source: binding0.map(|v| folder.fold_item_name(v)),
8098 }
8099 }
8100 ShowObjectType::View {
8101 } => {
8102 ShowObjectType::View {
8103 }
8104 }
8105 ShowObjectType::Source {
8106 in_cluster: binding0,
8107 } => {
8108 ShowObjectType::Source {
8109 in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
8110 }
8111 }
8112 ShowObjectType::Sink {
8113 in_cluster: binding0,
8114 } => {
8115 ShowObjectType::Sink {
8116 in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
8117 }
8118 }
8119 ShowObjectType::Type {
8120 } => {
8121 ShowObjectType::Type {
8122 }
8123 }
8124 ShowObjectType::Role {
8125 } => {
8126 ShowObjectType::Role {
8127 }
8128 }
8129 ShowObjectType::Cluster {
8130 } => {
8131 ShowObjectType::Cluster {
8132 }
8133 }
8134 ShowObjectType::ClusterReplica {
8135 } => {
8136 ShowObjectType::ClusterReplica {
8137 }
8138 }
8139 ShowObjectType::Object {
8140 } => {
8141 ShowObjectType::Object {
8142 }
8143 }
8144 ShowObjectType::Secret {
8145 } => {
8146 ShowObjectType::Secret {
8147 }
8148 }
8149 ShowObjectType::Connection {
8150 } => {
8151 ShowObjectType::Connection {
8152 }
8153 }
8154 ShowObjectType::Database {
8155 } => {
8156 ShowObjectType::Database {
8157 }
8158 }
8159 ShowObjectType::Schema {
8160 from: binding0,
8161 } => {
8162 ShowObjectType::Schema {
8163 from: binding0.map(|v| folder.fold_database_name(v)),
8164 }
8165 }
8166 ShowObjectType::Subsource {
8167 on_source: binding0,
8168 } => {
8169 ShowObjectType::Subsource {
8170 on_source: binding0.map(|v| folder.fold_item_name(v)),
8171 }
8172 }
8173 ShowObjectType::Privileges {
8174 object_type: binding0,
8175 role: binding1,
8176 } => {
8177 ShowObjectType::Privileges {
8178 object_type: binding0.map(|v| folder.fold_system_object_type(v)),
8179 role: binding1.map(|v| folder.fold_role_name(v)),
8180 }
8181 }
8182 ShowObjectType::DefaultPrivileges {
8183 object_type: binding0,
8184 role: binding1,
8185 } => {
8186 ShowObjectType::DefaultPrivileges {
8187 object_type: binding0.map(|v| folder.fold_object_type(v)),
8188 role: binding1.map(|v| folder.fold_role_name(v)),
8189 }
8190 }
8191 ShowObjectType::RoleMembership {
8192 role: binding0,
8193 } => {
8194 ShowObjectType::RoleMembership {
8195 role: binding0.map(|v| folder.fold_role_name(v)),
8196 }
8197 }
8198 ShowObjectType::ContinualTask {
8199 in_cluster: binding0,
8200 } => {
8201 ShowObjectType::ContinualTask {
8202 in_cluster: binding0.map(|v| folder.fold_cluster_name(v)),
8203 }
8204 }
8205 ShowObjectType::NetworkPolicy {
8206 } => {
8207 ShowObjectType::NetworkPolicy {
8208 }
8209 }
8210 }
8211}
8212impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowObjectsStatement<T> {
8213 type Folded = ShowObjectsStatement<T2>;
8214 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8215 folder.fold_show_objects_statement(self)
8216 }
8217}
8218#[allow(clippy::needless_pass_by_ref_mut)]
8219pub fn fold_show_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2>
8220where
8221 F: Fold<T, T2, > + ?Sized,
8222{
8223 ShowObjectsStatement {
8224 object_type: folder.fold_show_object_type(node.object_type),
8225 from: node.from.map(|v| folder.fold_schema_name(v)),
8226 filter: node.filter.map(|v| folder.fold_show_statement_filter(v)),
8227 }
8228}
8229impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowStatement<T> {
8230 type Folded = ShowStatement<T2>;
8231 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8232 folder.fold_show_statement(self)
8233 }
8234}
8235#[allow(clippy::needless_pass_by_ref_mut)]
8236pub fn fold_show_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowStatement<T>) -> ShowStatement<T2>
8237where
8238 F: Fold<T, T2, > + ?Sized,
8239{
8240 match node {
8241 ShowStatement::ShowObjects {
8242 0: binding0,
8243 } => {
8244 ShowStatement::ShowObjects {
8245 0: folder.fold_show_objects_statement(binding0),
8246 }
8247 }
8248 ShowStatement::ShowColumns {
8249 0: binding0,
8250 } => {
8251 ShowStatement::ShowColumns {
8252 0: folder.fold_show_columns_statement(binding0),
8253 }
8254 }
8255 ShowStatement::ShowCreateView {
8256 0: binding0,
8257 } => {
8258 ShowStatement::ShowCreateView {
8259 0: folder.fold_show_create_view_statement(binding0),
8260 }
8261 }
8262 ShowStatement::ShowCreateMaterializedView {
8263 0: binding0,
8264 } => {
8265 ShowStatement::ShowCreateMaterializedView {
8266 0: folder.fold_show_create_materialized_view_statement(binding0),
8267 }
8268 }
8269 ShowStatement::ShowCreateSource {
8270 0: binding0,
8271 } => {
8272 ShowStatement::ShowCreateSource {
8273 0: folder.fold_show_create_source_statement(binding0),
8274 }
8275 }
8276 ShowStatement::ShowCreateTable {
8277 0: binding0,
8278 } => {
8279 ShowStatement::ShowCreateTable {
8280 0: folder.fold_show_create_table_statement(binding0),
8281 }
8282 }
8283 ShowStatement::ShowCreateSink {
8284 0: binding0,
8285 } => {
8286 ShowStatement::ShowCreateSink {
8287 0: folder.fold_show_create_sink_statement(binding0),
8288 }
8289 }
8290 ShowStatement::ShowCreateIndex {
8291 0: binding0,
8292 } => {
8293 ShowStatement::ShowCreateIndex {
8294 0: folder.fold_show_create_index_statement(binding0),
8295 }
8296 }
8297 ShowStatement::ShowCreateConnection {
8298 0: binding0,
8299 } => {
8300 ShowStatement::ShowCreateConnection {
8301 0: folder.fold_show_create_connection_statement(binding0),
8302 }
8303 }
8304 ShowStatement::ShowCreateCluster {
8305 0: binding0,
8306 } => {
8307 ShowStatement::ShowCreateCluster {
8308 0: folder.fold_show_create_cluster_statement(binding0),
8309 }
8310 }
8311 ShowStatement::ShowCreateType {
8312 0: binding0,
8313 } => {
8314 ShowStatement::ShowCreateType {
8315 0: folder.fold_show_create_type_statement(binding0),
8316 }
8317 }
8318 ShowStatement::ShowVariable {
8319 0: binding0,
8320 } => {
8321 ShowStatement::ShowVariable {
8322 0: folder.fold_show_variable_statement(binding0),
8323 }
8324 }
8325 ShowStatement::InspectShard {
8326 0: binding0,
8327 } => {
8328 ShowStatement::InspectShard {
8329 0: folder.fold_inspect_shard_statement(binding0),
8330 }
8331 }
8332 }
8333}
8334impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowStatementFilter<T> {
8335 type Folded = ShowStatementFilter<T2>;
8336 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8337 folder.fold_show_statement_filter(self)
8338 }
8339}
8340#[allow(clippy::needless_pass_by_ref_mut)]
8341pub fn fold_show_statement_filter<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2>
8342where
8343 F: Fold<T, T2, > + ?Sized,
8344{
8345 match node {
8346 ShowStatementFilter::Like {
8347 0: binding0,
8348 } => {
8349 ShowStatementFilter::Like {
8350 0: binding0,
8351 }
8352 }
8353 ShowStatementFilter::Where {
8354 0: binding0,
8355 } => {
8356 ShowStatementFilter::Where {
8357 0: folder.fold_expr(binding0),
8358 }
8359 }
8360 }
8361}
8362impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ShowVariableStatement {
8363 type Folded = ShowVariableStatement;
8364 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8365 folder.fold_show_variable_statement(self)
8366 }
8367}
8368#[allow(clippy::needless_pass_by_ref_mut)]
8369pub fn fold_show_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowVariableStatement) -> ShowVariableStatement
8370where
8371 F: Fold<T, T2, > + ?Sized,
8372{
8373 ShowVariableStatement {
8374 variable: folder.fold_ident(node.variable),
8375 }
8376}
8377impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SinkEnvelope {
8378 type Folded = SinkEnvelope;
8379 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8380 folder.fold_sink_envelope(self)
8381 }
8382}
8383#[allow(clippy::needless_pass_by_ref_mut)]
8384pub fn fold_sink_envelope<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SinkEnvelope) -> SinkEnvelope
8385where
8386 F: Fold<T, T2, > + ?Sized,
8387{
8388 match node {
8389 SinkEnvelope::Debezium {
8390 } => {
8391 SinkEnvelope::Debezium {
8392 }
8393 }
8394 SinkEnvelope::Upsert {
8395 } => {
8396 SinkEnvelope::Upsert {
8397 }
8398 }
8399 }
8400}
8401impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SinkKey {
8402 type Folded = SinkKey;
8403 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8404 folder.fold_sink_key(self)
8405 }
8406}
8407#[allow(clippy::needless_pass_by_ref_mut)]
8408pub fn fold_sink_key<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SinkKey) -> SinkKey
8409where
8410 F: Fold<T, T2, > + ?Sized,
8411{
8412 SinkKey {
8413 key_columns: node.key_columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
8414 not_enforced: node.not_enforced,
8415 }
8416}
8417impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceEnvelope {
8418 type Folded = SourceEnvelope;
8419 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8420 folder.fold_source_envelope(self)
8421 }
8422}
8423#[allow(clippy::needless_pass_by_ref_mut)]
8424pub fn fold_source_envelope<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceEnvelope) -> SourceEnvelope
8425where
8426 F: Fold<T, T2, > + ?Sized,
8427{
8428 match node {
8429 SourceEnvelope::None {
8430 } => {
8431 SourceEnvelope::None {
8432 }
8433 }
8434 SourceEnvelope::Debezium {
8435 } => {
8436 SourceEnvelope::Debezium {
8437 }
8438 }
8439 SourceEnvelope::Upsert {
8440 value_decode_err_policy: binding0,
8441 } => {
8442 SourceEnvelope::Upsert {
8443 value_decode_err_policy: binding0.into_iter().map(|v| folder.fold_source_error_policy(v)).collect(),
8444 }
8445 }
8446 SourceEnvelope::CdcV2 {
8447 } => {
8448 SourceEnvelope::CdcV2 {
8449 }
8450 }
8451 }
8452}
8453impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceErrorPolicy {
8454 type Folded = SourceErrorPolicy;
8455 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8456 folder.fold_source_error_policy(self)
8457 }
8458}
8459#[allow(clippy::needless_pass_by_ref_mut)]
8460pub fn fold_source_error_policy<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceErrorPolicy) -> SourceErrorPolicy
8461where
8462 F: Fold<T, T2, > + ?Sized,
8463{
8464 match node {
8465 SourceErrorPolicy::Inline {
8466 alias: binding0,
8467 } => {
8468 SourceErrorPolicy::Inline {
8469 alias: binding0.map(|v| folder.fold_ident(v)),
8470 }
8471 }
8472 }
8473}
8474impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SourceIncludeMetadata {
8475 type Folded = SourceIncludeMetadata;
8476 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8477 folder.fold_source_include_metadata(self)
8478 }
8479}
8480#[allow(clippy::needless_pass_by_ref_mut)]
8481pub fn fold_source_include_metadata<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SourceIncludeMetadata) -> SourceIncludeMetadata
8482where
8483 F: Fold<T, T2, > + ?Sized,
8484{
8485 match node {
8486 SourceIncludeMetadata::Key {
8487 alias: binding0,
8488 } => {
8489 SourceIncludeMetadata::Key {
8490 alias: binding0.map(|v| folder.fold_ident(v)),
8491 }
8492 }
8493 SourceIncludeMetadata::Timestamp {
8494 alias: binding0,
8495 } => {
8496 SourceIncludeMetadata::Timestamp {
8497 alias: binding0.map(|v| folder.fold_ident(v)),
8498 }
8499 }
8500 SourceIncludeMetadata::Partition {
8501 alias: binding0,
8502 } => {
8503 SourceIncludeMetadata::Partition {
8504 alias: binding0.map(|v| folder.fold_ident(v)),
8505 }
8506 }
8507 SourceIncludeMetadata::Offset {
8508 alias: binding0,
8509 } => {
8510 SourceIncludeMetadata::Offset {
8511 alias: binding0.map(|v| folder.fold_ident(v)),
8512 }
8513 }
8514 SourceIncludeMetadata::Headers {
8515 alias: binding0,
8516 } => {
8517 SourceIncludeMetadata::Headers {
8518 alias: binding0.map(|v| folder.fold_ident(v)),
8519 }
8520 }
8521 SourceIncludeMetadata::Header {
8522 key: binding0,
8523 alias: binding1,
8524 use_bytes: binding2,
8525 } => {
8526 SourceIncludeMetadata::Header {
8527 key: binding0,
8528 alias: folder.fold_ident(binding1),
8529 use_bytes: binding2,
8530 }
8531 }
8532 }
8533}
8534impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SqlServerConfigOption<T> {
8535 type Folded = SqlServerConfigOption<T2>;
8536 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8537 folder.fold_sql_server_config_option(self)
8538 }
8539}
8540#[allow(clippy::needless_pass_by_ref_mut)]
8541pub fn fold_sql_server_config_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SqlServerConfigOption<T>) -> SqlServerConfigOption<T2>
8542where
8543 F: Fold<T, T2, > + ?Sized,
8544{
8545 SqlServerConfigOption {
8546 name: folder.fold_sql_server_config_option_name(node.name),
8547 value: node.value.map(|v| folder.fold_with_option_value(v)),
8548 }
8549}
8550impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SqlServerConfigOptionName {
8551 type Folded = SqlServerConfigOptionName;
8552 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8553 folder.fold_sql_server_config_option_name(self)
8554 }
8555}
8556#[allow(clippy::needless_pass_by_ref_mut)]
8557pub fn fold_sql_server_config_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SqlServerConfigOptionName) -> SqlServerConfigOptionName
8558where
8559 F: Fold<T, T2, > + ?Sized,
8560{
8561 match node {
8562 SqlServerConfigOptionName::Details {
8563 } => {
8564 SqlServerConfigOptionName::Details {
8565 }
8566 }
8567 SqlServerConfigOptionName::TextColumns {
8568 } => {
8569 SqlServerConfigOptionName::TextColumns {
8570 }
8571 }
8572 SqlServerConfigOptionName::ExcludeColumns {
8573 } => {
8574 SqlServerConfigOptionName::ExcludeColumns {
8575 }
8576 }
8577 }
8578}
8579impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for StartTransactionStatement {
8580 type Folded = StartTransactionStatement;
8581 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8582 folder.fold_start_transaction_statement(self)
8583 }
8584}
8585#[allow(clippy::needless_pass_by_ref_mut)]
8586pub fn fold_start_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: StartTransactionStatement) -> StartTransactionStatement
8587where
8588 F: Fold<T, T2, > + ?Sized,
8589{
8590 StartTransactionStatement {
8591 modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(),
8592 }
8593}
8594impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Statement<T> {
8595 type Folded = Statement<T2>;
8596 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
8597 folder.fold_statement(self)
8598 }
8599}
8600#[allow(clippy::needless_pass_by_ref_mut)]
8601pub fn fold_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Statement<T>) -> Statement<T2>
8602where
8603 F: Fold<T, T2, > + ?Sized,
8604{
8605 match node {
8606 Statement::Select {
8607 0: binding0,
8608 } => {
8609 Statement::Select {
8610 0: folder.fold_select_statement(binding0),
8611 }
8612 }
8613 Statement::Insert {
8614 0: binding0,
8615 } => {
8616 Statement::Insert {
8617 0: folder.fold_insert_statement(binding0),
8618 }
8619 }
8620 Statement::Copy {
8621 0: binding0,
8622 } => {
8623 Statement::Copy {
8624 0: folder.fold_copy_statement(binding0),
8625 }
8626 }
8627 Statement::Update {
8628 0: binding0,
8629 } => {
8630 Statement::Update {
8631 0: folder.fold_update_statement(binding0),
8632 }
8633 }
8634 Statement::Delete {
8635 0: binding0,
8636 } => {
8637 Statement::Delete {
8638 0: folder.fold_delete_statement(binding0),
8639 }
8640 }
8641 Statement::CreateConnection {
8642 0: binding0,
8643 } => {
8644 Statement::CreateConnection {
8645 0: folder.fold_create_connection_statement(binding0),
8646 }
8647 }
8648 Statement::CreateDatabase {
8649 0: binding0,
8650 } => {
8651 Statement::CreateDatabase {
8652 0: folder.fold_create_database_statement(binding0),
8653 }
8654 }
8655 Statement::CreateSchema {
8656 0: binding0,
8657 } => {
8658 Statement::CreateSchema {
8659 0: folder.fold_create_schema_statement(binding0),
8660 }
8661 }
8662 Statement::CreateWebhookSource {
8663 0: binding0,
8664 } => {
8665 Statement::CreateWebhookSource {
8666 0: folder.fold_create_webhook_source_statement(binding0),
8667 }
8668 }
8669 Statement::CreateSource {
8670 0: binding0,
8671 } => {
8672 Statement::CreateSource {
8673 0: folder.fold_create_source_statement(binding0),
8674 }
8675 }
8676 Statement::CreateSubsource {
8677 0: binding0,
8678 } => {
8679 Statement::CreateSubsource {
8680 0: folder.fold_create_subsource_statement(binding0),
8681 }
8682 }
8683 Statement::CreateSink {
8684 0: binding0,
8685 } => {
8686 Statement::CreateSink {
8687 0: folder.fold_create_sink_statement(binding0),
8688 }
8689 }
8690 Statement::CreateView {
8691 0: binding0,
8692 } => {
8693 Statement::CreateView {
8694 0: folder.fold_create_view_statement(binding0),
8695 }
8696 }
8697 Statement::CreateMaterializedView {
8698 0: binding0,
8699 } => {
8700 Statement::CreateMaterializedView {
8701 0: folder.fold_create_materialized_view_statement(binding0),
8702 }
8703 }
8704 Statement::CreateContinualTask {
8705 0: binding0,
8706 } => {
8707 Statement::CreateContinualTask {
8708 0: folder.fold_create_continual_task_statement(binding0),
8709 }
8710 }
8711 Statement::CreateTable {
8712 0: binding0,
8713 } => {
8714 Statement::CreateTable {
8715 0: folder.fold_create_table_statement(binding0),
8716 }
8717 }
8718 Statement::CreateTableFromSource {
8719 0: binding0,
8720 } => {
8721 Statement::CreateTableFromSource {
8722 0: folder.fold_create_table_from_source_statement(binding0),
8723 }
8724 }
8725 Statement::CreateIndex {
8726 0: binding0,
8727 } => {
8728 Statement::CreateIndex {
8729 0: folder.fold_create_index_statement(binding0),
8730 }
8731 }
8732 Statement::CreateType {
8733 0: binding0,
8734 } => {
8735 Statement::CreateType {
8736 0: folder.fold_create_type_statement(binding0),
8737 }
8738 }
8739 Statement::CreateRole {
8740 0: binding0,
8741 } => {
8742 Statement::CreateRole {
8743 0: folder.fold_create_role_statement(binding0),
8744 }
8745 }
8746 Statement::CreateCluster {
8747 0: binding0,
8748 } => {
8749 Statement::CreateCluster {
8750 0: folder.fold_create_cluster_statement(binding0),
8751 }
8752 }
8753 Statement::CreateClusterReplica {
8754 0: binding0,
8755 } => {
8756 Statement::CreateClusterReplica {
8757 0: folder.fold_create_cluster_replica_statement(binding0),
8758 }
8759 }
8760 Statement::CreateSecret {
8761 0: binding0,
8762 } => {
8763 Statement::CreateSecret {
8764 0: folder.fold_create_secret_statement(binding0),
8765 }
8766 }
8767 Statement::CreateNetworkPolicy {
8768 0: binding0,
8769 } => {
8770 Statement::CreateNetworkPolicy {
8771 0: folder.fold_create_network_policy_statement(binding0),
8772 }
8773 }
8774 Statement::AlterCluster {
8775 0: binding0,
8776 } => {
8777 Statement::AlterCluster {
8778 0: folder.fold_alter_cluster_statement(binding0),
8779 }
8780 }
8781 Statement::AlterOwner {
8782 0: binding0,
8783 } => {
8784 Statement::AlterOwner {
8785 0: folder.fold_alter_owner_statement(binding0),
8786 }
8787 }
8788 Statement::AlterObjectRename {
8789 0: binding0,
8790 } => {
8791 Statement::AlterObjectRename {
8792 0: folder.fold_alter_object_rename_statement(binding0),
8793 }
8794 }
8795 Statement::AlterObjectSwap {
8796 0: binding0,
8797 } => {
8798 Statement::AlterObjectSwap {
8799 0: folder.fold_alter_object_swap_statement(binding0),
8800 }
8801 }
8802 Statement::AlterRetainHistory {
8803 0: binding0,
8804 } => {
8805 Statement::AlterRetainHistory {
8806 0: folder.fold_alter_retain_history_statement(binding0),
8807 }
8808 }
8809 Statement::AlterIndex {
8810 0: binding0,
8811 } => {
8812 Statement::AlterIndex {
8813 0: folder.fold_alter_index_statement(binding0),
8814 }
8815 }
8816 Statement::AlterSecret {
8817 0: binding0,
8818 } => {
8819 Statement::AlterSecret {
8820 0: folder.fold_alter_secret_statement(binding0),
8821 }
8822 }
8823 Statement::AlterSetCluster {
8824 0: binding0,
8825 } => {
8826 Statement::AlterSetCluster {
8827 0: folder.fold_alter_set_cluster_statement(binding0),
8828 }
8829 }
8830 Statement::AlterSink {
8831 0: binding0,
8832 } => {
8833 Statement::AlterSink {
8834 0: folder.fold_alter_sink_statement(binding0),
8835 }
8836 }
8837 Statement::AlterSource {
8838 0: binding0,
8839 } => {
8840 Statement::AlterSource {
8841 0: folder.fold_alter_source_statement(binding0),
8842 }
8843 }
8844 Statement::AlterSystemSet {
8845 0: binding0,
8846 } => {
8847 Statement::AlterSystemSet {
8848 0: folder.fold_alter_system_set_statement(binding0),
8849 }
8850 }
8851 Statement::AlterSystemReset {
8852 0: binding0,
8853 } => {
8854 Statement::AlterSystemReset {
8855 0: folder.fold_alter_system_reset_statement(binding0),
8856 }
8857 }
8858 Statement::AlterSystemResetAll {
8859 0: binding0,
8860 } => {
8861 Statement::AlterSystemResetAll {
8862 0: folder.fold_alter_system_reset_all_statement(binding0),
8863 }
8864 }
8865 Statement::AlterConnection {
8866 0: binding0,
8867 } => {
8868 Statement::AlterConnection {
8869 0: folder.fold_alter_connection_statement(binding0),
8870 }
8871 }
8872 Statement::AlterNetworkPolicy {
8873 0: binding0,
8874 } => {
8875 Statement::AlterNetworkPolicy {
8876 0: folder.fold_alter_network_policy_statement(binding0),
8877 }
8878 }
8879 Statement::AlterRole {
8880 0: binding0,
8881 } => {
8882 Statement::AlterRole {
8883 0: folder.fold_alter_role_statement(binding0),
8884 }
8885 }
8886 Statement::AlterTableAddColumn {
8887 0: binding0,
8888 } => {
8889 Statement::AlterTableAddColumn {
8890 0: folder.fold_alter_table_add_column_statement(binding0),
8891 }
8892 }
8893 Statement::Discard {
8894 0: binding0,
8895 } => {
8896 Statement::Discard {
8897 0: folder.fold_discard_statement(binding0),
8898 }
8899 }
8900 Statement::DropObjects {
8901 0: binding0,
8902 } => {
8903 Statement::DropObjects {
8904 0: folder.fold_drop_objects_statement(binding0),
8905 }
8906 }
8907 Statement::DropOwned {
8908 0: binding0,
8909 } => {
8910 Statement::DropOwned {
8911 0: folder.fold_drop_owned_statement(binding0),
8912 }
8913 }
8914 Statement::SetVariable {
8915 0: binding0,
8916 } => {
8917 Statement::SetVariable {
8918 0: folder.fold_set_variable_statement(binding0),
8919 }
8920 }
8921 Statement::ResetVariable {
8922 0: binding0,
8923 } => {
8924 Statement::ResetVariable {
8925 0: folder.fold_reset_variable_statement(binding0),
8926 }
8927 }
8928 Statement::Show {
8929 0: binding0,
8930 } => {
8931 Statement::Show {
8932 0: folder.fold_show_statement(binding0),
8933 }
8934 }
8935 Statement::StartTransaction {
8936 0: binding0,
8937 } => {
8938 Statement::StartTransaction {
8939 0: folder.fold_start_transaction_statement(binding0),
8940 }
8941 }
8942 Statement::SetTransaction {
8943 0: binding0,
8944 } => {
8945 Statement::SetTransaction {
8946 0: folder.fold_set_transaction_statement(binding0),
8947 }
8948 }
8949 Statement::Commit {
8950 0: binding0,
8951 } => {
8952 Statement::Commit {
8953 0: folder.fold_commit_statement(binding0),
8954 }
8955 }
8956 Statement::Rollback {
8957 0: binding0,
8958 } => {
8959 Statement::Rollback {
8960 0: folder.fold_rollback_statement(binding0),
8961 }
8962 }
8963 Statement::Subscribe {
8964 0: binding0,
8965 } => {
8966 Statement::Subscribe {
8967 0: folder.fold_subscribe_statement(binding0),
8968 }
8969 }
8970 Statement::ExplainPlan {
8971 0: binding0,
8972 } => {
8973 Statement::ExplainPlan {
8974 0: folder.fold_explain_plan_statement(binding0),
8975 }
8976 }
8977 Statement::ExplainPushdown {
8978 0: binding0,
8979 } => {
8980 Statement::ExplainPushdown {
8981 0: folder.fold_explain_pushdown_statement(binding0),
8982 }
8983 }
8984 Statement::ExplainTimestamp {
8985 0: binding0,
8986 } => {
8987 Statement::ExplainTimestamp {
8988 0: folder.fold_explain_timestamp_statement(binding0),
8989 }
8990 }
8991 Statement::ExplainSinkSchema {
8992 0: binding0,
8993 } => {
8994 Statement::ExplainSinkSchema {
8995 0: folder.fold_explain_sink_schema_statement(binding0),
8996 }
8997 }
8998 Statement::ExplainAnalyzeObject {
8999 0: binding0,
9000 } => {
9001 Statement::ExplainAnalyzeObject {
9002 0: folder.fold_explain_analyze_object_statement(binding0),
9003 }
9004 }
9005 Statement::ExplainAnalyzeCluster {
9006 0: binding0,
9007 } => {
9008 Statement::ExplainAnalyzeCluster {
9009 0: folder.fold_explain_analyze_cluster_statement(binding0),
9010 }
9011 }
9012 Statement::Declare {
9013 0: binding0,
9014 } => {
9015 Statement::Declare {
9016 0: folder.fold_declare_statement(binding0),
9017 }
9018 }
9019 Statement::Fetch {
9020 0: binding0,
9021 } => {
9022 Statement::Fetch {
9023 0: folder.fold_fetch_statement(binding0),
9024 }
9025 }
9026 Statement::Close {
9027 0: binding0,
9028 } => {
9029 Statement::Close {
9030 0: folder.fold_close_statement(binding0),
9031 }
9032 }
9033 Statement::Prepare {
9034 0: binding0,
9035 } => {
9036 Statement::Prepare {
9037 0: folder.fold_prepare_statement(binding0),
9038 }
9039 }
9040 Statement::Execute {
9041 0: binding0,
9042 } => {
9043 Statement::Execute {
9044 0: folder.fold_execute_statement(binding0),
9045 }
9046 }
9047 Statement::Deallocate {
9048 0: binding0,
9049 } => {
9050 Statement::Deallocate {
9051 0: folder.fold_deallocate_statement(binding0),
9052 }
9053 }
9054 Statement::Raise {
9055 0: binding0,
9056 } => {
9057 Statement::Raise {
9058 0: folder.fold_raise_statement(binding0),
9059 }
9060 }
9061 Statement::GrantRole {
9062 0: binding0,
9063 } => {
9064 Statement::GrantRole {
9065 0: folder.fold_grant_role_statement(binding0),
9066 }
9067 }
9068 Statement::RevokeRole {
9069 0: binding0,
9070 } => {
9071 Statement::RevokeRole {
9072 0: folder.fold_revoke_role_statement(binding0),
9073 }
9074 }
9075 Statement::GrantPrivileges {
9076 0: binding0,
9077 } => {
9078 Statement::GrantPrivileges {
9079 0: folder.fold_grant_privileges_statement(binding0),
9080 }
9081 }
9082 Statement::RevokePrivileges {
9083 0: binding0,
9084 } => {
9085 Statement::RevokePrivileges {
9086 0: folder.fold_revoke_privileges_statement(binding0),
9087 }
9088 }
9089 Statement::AlterDefaultPrivileges {
9090 0: binding0,
9091 } => {
9092 Statement::AlterDefaultPrivileges {
9093 0: folder.fold_alter_default_privileges_statement(binding0),
9094 }
9095 }
9096 Statement::ReassignOwned {
9097 0: binding0,
9098 } => {
9099 Statement::ReassignOwned {
9100 0: folder.fold_reassign_owned_statement(binding0),
9101 }
9102 }
9103 Statement::ValidateConnection {
9104 0: binding0,
9105 } => {
9106 Statement::ValidateConnection {
9107 0: folder.fold_validate_connection_statement(binding0),
9108 }
9109 }
9110 Statement::Comment {
9111 0: binding0,
9112 } => {
9113 Statement::Comment {
9114 0: folder.fold_comment_statement(binding0),
9115 }
9116 }
9117 }
9118}
9119impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOption<T> {
9120 type Folded = SubscribeOption<T2>;
9121 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9122 folder.fold_subscribe_option(self)
9123 }
9124}
9125#[allow(clippy::needless_pass_by_ref_mut)]
9126pub fn fold_subscribe_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOption<T>) -> SubscribeOption<T2>
9127where
9128 F: Fold<T, T2, > + ?Sized,
9129{
9130 SubscribeOption {
9131 name: folder.fold_subscribe_option_name(node.name),
9132 value: node.value.map(|v| folder.fold_with_option_value(v)),
9133 }
9134}
9135impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOptionName {
9136 type Folded = SubscribeOptionName;
9137 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9138 folder.fold_subscribe_option_name(self)
9139 }
9140}
9141#[allow(clippy::needless_pass_by_ref_mut)]
9142pub fn fold_subscribe_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOptionName) -> SubscribeOptionName
9143where
9144 F: Fold<T, T2, > + ?Sized,
9145{
9146 match node {
9147 SubscribeOptionName::Snapshot {
9148 } => {
9149 SubscribeOptionName::Snapshot {
9150 }
9151 }
9152 SubscribeOptionName::Progress {
9153 } => {
9154 SubscribeOptionName::Progress {
9155 }
9156 }
9157 }
9158}
9159impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeOutput<T> {
9160 type Folded = SubscribeOutput<T2>;
9161 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9162 folder.fold_subscribe_output(self)
9163 }
9164}
9165#[allow(clippy::needless_pass_by_ref_mut)]
9166pub fn fold_subscribe_output<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeOutput<T>) -> SubscribeOutput<T2>
9167where
9168 F: Fold<T, T2, > + ?Sized,
9169{
9170 match node {
9171 SubscribeOutput::Diffs {
9172 } => {
9173 SubscribeOutput::Diffs {
9174 }
9175 }
9176 SubscribeOutput::WithinTimestampOrderBy {
9177 order_by: binding0,
9178 } => {
9179 SubscribeOutput::WithinTimestampOrderBy {
9180 order_by: binding0.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
9181 }
9182 }
9183 SubscribeOutput::EnvelopeUpsert {
9184 key_columns: binding0,
9185 } => {
9186 SubscribeOutput::EnvelopeUpsert {
9187 key_columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
9188 }
9189 }
9190 SubscribeOutput::EnvelopeDebezium {
9191 key_columns: binding0,
9192 } => {
9193 SubscribeOutput::EnvelopeDebezium {
9194 key_columns: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
9195 }
9196 }
9197 }
9198}
9199impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeRelation<T> {
9200 type Folded = SubscribeRelation<T2>;
9201 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9202 folder.fold_subscribe_relation(self)
9203 }
9204}
9205#[allow(clippy::needless_pass_by_ref_mut)]
9206pub fn fold_subscribe_relation<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeRelation<T>) -> SubscribeRelation<T2>
9207where
9208 F: Fold<T, T2, > + ?Sized,
9209{
9210 match node {
9211 SubscribeRelation::Name {
9212 0: binding0,
9213 } => {
9214 SubscribeRelation::Name {
9215 0: folder.fold_item_name(binding0),
9216 }
9217 }
9218 SubscribeRelation::Query {
9219 0: binding0,
9220 } => {
9221 SubscribeRelation::Query {
9222 0: folder.fold_query(binding0),
9223 }
9224 }
9225 }
9226}
9227impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscribeStatement<T> {
9228 type Folded = SubscribeStatement<T2>;
9229 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9230 folder.fold_subscribe_statement(self)
9231 }
9232}
9233#[allow(clippy::needless_pass_by_ref_mut)]
9234pub fn fold_subscribe_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscribeStatement<T>) -> SubscribeStatement<T2>
9235where
9236 F: Fold<T, T2, > + ?Sized,
9237{
9238 SubscribeStatement {
9239 relation: folder.fold_subscribe_relation(node.relation),
9240 options: node.options.into_iter().map(|v| folder.fold_subscribe_option(v)).collect(),
9241 as_of: node.as_of.map(|v| folder.fold_as_of(v)),
9242 up_to: node.up_to.map(|v| folder.fold_expr(v)),
9243 output: folder.fold_subscribe_output(node.output),
9244 }
9245}
9246impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SubscriptPosition<T> {
9247 type Folded = SubscriptPosition<T2>;
9248 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9249 folder.fold_subscript_position(self)
9250 }
9251}
9252#[allow(clippy::needless_pass_by_ref_mut)]
9253pub fn fold_subscript_position<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscriptPosition<T>) -> SubscriptPosition<T2>
9254where
9255 F: Fold<T, T2, > + ?Sized,
9256{
9257 SubscriptPosition {
9258 start: node.start.map(|v| folder.fold_expr(v)),
9259 end: node.end.map(|v| folder.fold_expr(v)),
9260 explicit_slice: node.explicit_slice,
9261 }
9262}
9263impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for SystemObjectType {
9264 type Folded = SystemObjectType;
9265 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9266 folder.fold_system_object_type(self)
9267 }
9268}
9269#[allow(clippy::needless_pass_by_ref_mut)]
9270pub fn fold_system_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SystemObjectType) -> SystemObjectType
9271where
9272 F: Fold<T, T2, > + ?Sized,
9273{
9274 match node {
9275 SystemObjectType::System {
9276 } => {
9277 SystemObjectType::System {
9278 }
9279 }
9280 SystemObjectType::Object {
9281 0: binding0,
9282 } => {
9283 SystemObjectType::Object {
9284 0: folder.fold_object_type(binding0),
9285 }
9286 }
9287 }
9288}
9289impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableAlias {
9290 type Folded = TableAlias;
9291 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9292 folder.fold_table_alias(self)
9293 }
9294}
9295#[allow(clippy::needless_pass_by_ref_mut)]
9296pub fn fold_table_alias<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableAlias) -> TableAlias
9297where
9298 F: Fold<T, T2, > + ?Sized,
9299{
9300 TableAlias {
9301 name: folder.fold_ident(node.name),
9302 columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
9303 strict: node.strict,
9304 }
9305}
9306impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableConstraint<T> {
9307 type Folded = TableConstraint<T2>;
9308 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9309 folder.fold_table_constraint(self)
9310 }
9311}
9312#[allow(clippy::needless_pass_by_ref_mut)]
9313pub fn fold_table_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableConstraint<T>) -> TableConstraint<T2>
9314where
9315 F: Fold<T, T2, > + ?Sized,
9316{
9317 match node {
9318 TableConstraint::Unique {
9319 name: binding0,
9320 columns: binding1,
9321 is_primary: binding2,
9322 nulls_not_distinct: binding3,
9323 } => {
9324 TableConstraint::Unique {
9325 name: binding0.map(|v| folder.fold_ident(v)),
9326 columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
9327 is_primary: binding2,
9328 nulls_not_distinct: binding3,
9329 }
9330 }
9331 TableConstraint::ForeignKey {
9332 name: binding0,
9333 columns: binding1,
9334 foreign_table: binding2,
9335 referred_columns: binding3,
9336 } => {
9337 TableConstraint::ForeignKey {
9338 name: binding0.map(|v| folder.fold_ident(v)),
9339 columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(),
9340 foreign_table: folder.fold_item_name(binding2),
9341 referred_columns: binding3.into_iter().map(|v| folder.fold_ident(v)).collect(),
9342 }
9343 }
9344 TableConstraint::Check {
9345 name: binding0,
9346 expr: binding1,
9347 } => {
9348 TableConstraint::Check {
9349 name: binding0.map(|v| folder.fold_ident(v)),
9350 expr: Box::new(folder.fold_expr(*binding1)),
9351 }
9352 }
9353 }
9354}
9355impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableFactor<T> {
9356 type Folded = TableFactor<T2>;
9357 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9358 folder.fold_table_factor(self)
9359 }
9360}
9361#[allow(clippy::needless_pass_by_ref_mut)]
9362pub fn fold_table_factor<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFactor<T>) -> TableFactor<T2>
9363where
9364 F: Fold<T, T2, > + ?Sized,
9365{
9366 match node {
9367 TableFactor::Table {
9368 name: binding0,
9369 alias: binding1,
9370 } => {
9371 TableFactor::Table {
9372 name: folder.fold_item_name(binding0),
9373 alias: binding1.map(|v| folder.fold_table_alias(v)),
9374 }
9375 }
9376 TableFactor::Function {
9377 function: binding0,
9378 alias: binding1,
9379 with_ordinality: binding2,
9380 } => {
9381 TableFactor::Function {
9382 function: folder.fold_function(binding0),
9383 alias: binding1.map(|v| folder.fold_table_alias(v)),
9384 with_ordinality: binding2,
9385 }
9386 }
9387 TableFactor::RowsFrom {
9388 functions: binding0,
9389 alias: binding1,
9390 with_ordinality: binding2,
9391 } => {
9392 TableFactor::RowsFrom {
9393 functions: binding0.into_iter().map(|v| folder.fold_function(v)).collect(),
9394 alias: binding1.map(|v| folder.fold_table_alias(v)),
9395 with_ordinality: binding2,
9396 }
9397 }
9398 TableFactor::Derived {
9399 lateral: binding0,
9400 subquery: binding1,
9401 alias: binding2,
9402 } => {
9403 TableFactor::Derived {
9404 lateral: binding0,
9405 subquery: Box::new(folder.fold_query(*binding1)),
9406 alias: binding2.map(|v| folder.fold_table_alias(v)),
9407 }
9408 }
9409 TableFactor::NestedJoin {
9410 join: binding0,
9411 alias: binding1,
9412 } => {
9413 TableFactor::NestedJoin {
9414 join: Box::new(folder.fold_table_with_joins(*binding0)),
9415 alias: binding1.map(|v| folder.fold_table_alias(v)),
9416 }
9417 }
9418 }
9419}
9420impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableFromSourceColumns<T> {
9421 type Folded = TableFromSourceColumns<T2>;
9422 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9423 folder.fold_table_from_source_columns(self)
9424 }
9425}
9426#[allow(clippy::needless_pass_by_ref_mut)]
9427pub fn fold_table_from_source_columns<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFromSourceColumns<T>) -> TableFromSourceColumns<T2>
9428where
9429 F: Fold<T, T2, > + ?Sized,
9430{
9431 match node {
9432 TableFromSourceColumns::NotSpecified {
9433 } => {
9434 TableFromSourceColumns::NotSpecified {
9435 }
9436 }
9437 TableFromSourceColumns::Named {
9438 0: binding0,
9439 } => {
9440 TableFromSourceColumns::Named {
9441 0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(),
9442 }
9443 }
9444 TableFromSourceColumns::Defined {
9445 0: binding0,
9446 } => {
9447 TableFromSourceColumns::Defined {
9448 0: binding0.into_iter().map(|v| folder.fold_column_def(v)).collect(),
9449 }
9450 }
9451 }
9452}
9453impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableFromSourceOption<T> {
9454 type Folded = TableFromSourceOption<T2>;
9455 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9456 folder.fold_table_from_source_option(self)
9457 }
9458}
9459#[allow(clippy::needless_pass_by_ref_mut)]
9460pub fn fold_table_from_source_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFromSourceOption<T>) -> TableFromSourceOption<T2>
9461where
9462 F: Fold<T, T2, > + ?Sized,
9463{
9464 TableFromSourceOption {
9465 name: folder.fold_table_from_source_option_name(node.name),
9466 value: node.value.map(|v| folder.fold_with_option_value(v)),
9467 }
9468}
9469impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableFromSourceOptionName {
9470 type Folded = TableFromSourceOptionName;
9471 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9472 folder.fold_table_from_source_option_name(self)
9473 }
9474}
9475#[allow(clippy::needless_pass_by_ref_mut)]
9476pub fn fold_table_from_source_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFromSourceOptionName) -> TableFromSourceOptionName
9477where
9478 F: Fold<T, T2, > + ?Sized,
9479{
9480 match node {
9481 TableFromSourceOptionName::TextColumns {
9482 } => {
9483 TableFromSourceOptionName::TextColumns {
9484 }
9485 }
9486 TableFromSourceOptionName::ExcludeColumns {
9487 } => {
9488 TableFromSourceOptionName::ExcludeColumns {
9489 }
9490 }
9491 TableFromSourceOptionName::Details {
9492 } => {
9493 TableFromSourceOptionName::Details {
9494 }
9495 }
9496 TableFromSourceOptionName::PartitionBy {
9497 } => {
9498 TableFromSourceOptionName::PartitionBy {
9499 }
9500 }
9501 TableFromSourceOptionName::RetainHistory {
9502 } => {
9503 TableFromSourceOptionName::RetainHistory {
9504 }
9505 }
9506 }
9507}
9508impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableOption<T> {
9509 type Folded = TableOption<T2>;
9510 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9511 folder.fold_table_option(self)
9512 }
9513}
9514#[allow(clippy::needless_pass_by_ref_mut)]
9515pub fn fold_table_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableOption<T>) -> TableOption<T2>
9516where
9517 F: Fold<T, T2, > + ?Sized,
9518{
9519 TableOption {
9520 name: folder.fold_table_option_name(node.name),
9521 value: node.value.map(|v| folder.fold_with_option_value(v)),
9522 }
9523}
9524impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableOptionName {
9525 type Folded = TableOptionName;
9526 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9527 folder.fold_table_option_name(self)
9528 }
9529}
9530#[allow(clippy::needless_pass_by_ref_mut)]
9531pub fn fold_table_option_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableOptionName) -> TableOptionName
9532where
9533 F: Fold<T, T2, > + ?Sized,
9534{
9535 match node {
9536 TableOptionName::PartitionBy {
9537 } => {
9538 TableOptionName::PartitionBy {
9539 }
9540 }
9541 TableOptionName::RetainHistory {
9542 } => {
9543 TableOptionName::RetainHistory {
9544 }
9545 }
9546 TableOptionName::RedactedTest {
9547 } => {
9548 TableOptionName::RedactedTest {
9549 }
9550 }
9551 }
9552}
9553impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TableWithJoins<T> {
9554 type Folded = TableWithJoins<T2>;
9555 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9556 folder.fold_table_with_joins(self)
9557 }
9558}
9559#[allow(clippy::needless_pass_by_ref_mut)]
9560pub fn fold_table_with_joins<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableWithJoins<T>) -> TableWithJoins<T2>
9561where
9562 F: Fold<T, T2, > + ?Sized,
9563{
9564 TableWithJoins {
9565 relation: folder.fold_table_factor(node.relation),
9566 joins: node.joins.into_iter().map(|v| folder.fold_join(v)).collect(),
9567 }
9568}
9569impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TargetRoleSpecification<T> {
9570 type Folded = TargetRoleSpecification<T2>;
9571 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9572 folder.fold_target_role_specification(self)
9573 }
9574}
9575#[allow(clippy::needless_pass_by_ref_mut)]
9576pub fn fold_target_role_specification<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TargetRoleSpecification<T>) -> TargetRoleSpecification<T2>
9577where
9578 F: Fold<T, T2, > + ?Sized,
9579{
9580 match node {
9581 TargetRoleSpecification::Roles {
9582 0: binding0,
9583 } => {
9584 TargetRoleSpecification::Roles {
9585 0: binding0.into_iter().map(|v| folder.fold_role_name(v)).collect(),
9586 }
9587 }
9588 TargetRoleSpecification::AllRoles {
9589 } => {
9590 TargetRoleSpecification::AllRoles {
9591 }
9592 }
9593 }
9594}
9595impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionAccessMode {
9596 type Folded = TransactionAccessMode;
9597 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9598 folder.fold_transaction_access_mode(self)
9599 }
9600}
9601#[allow(clippy::needless_pass_by_ref_mut)]
9602pub fn fold_transaction_access_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionAccessMode) -> TransactionAccessMode
9603where
9604 F: Fold<T, T2, > + ?Sized,
9605{
9606 match node {
9607 TransactionAccessMode::ReadOnly {
9608 } => {
9609 TransactionAccessMode::ReadOnly {
9610 }
9611 }
9612 TransactionAccessMode::ReadWrite {
9613 } => {
9614 TransactionAccessMode::ReadWrite {
9615 }
9616 }
9617 }
9618}
9619impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionIsolationLevel {
9620 type Folded = TransactionIsolationLevel;
9621 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9622 folder.fold_transaction_isolation_level(self)
9623 }
9624}
9625#[allow(clippy::needless_pass_by_ref_mut)]
9626pub fn fold_transaction_isolation_level<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionIsolationLevel) -> TransactionIsolationLevel
9627where
9628 F: Fold<T, T2, > + ?Sized,
9629{
9630 match node {
9631 TransactionIsolationLevel::ReadUncommitted {
9632 } => {
9633 TransactionIsolationLevel::ReadUncommitted {
9634 }
9635 }
9636 TransactionIsolationLevel::ReadCommitted {
9637 } => {
9638 TransactionIsolationLevel::ReadCommitted {
9639 }
9640 }
9641 TransactionIsolationLevel::RepeatableRead {
9642 } => {
9643 TransactionIsolationLevel::RepeatableRead {
9644 }
9645 }
9646 TransactionIsolationLevel::Serializable {
9647 } => {
9648 TransactionIsolationLevel::Serializable {
9649 }
9650 }
9651 TransactionIsolationLevel::StrongSessionSerializable {
9652 } => {
9653 TransactionIsolationLevel::StrongSessionSerializable {
9654 }
9655 }
9656 TransactionIsolationLevel::StrictSerializable {
9657 } => {
9658 TransactionIsolationLevel::StrictSerializable {
9659 }
9660 }
9661 }
9662}
9663impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for TransactionMode {
9664 type Folded = TransactionMode;
9665 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9666 folder.fold_transaction_mode(self)
9667 }
9668}
9669#[allow(clippy::needless_pass_by_ref_mut)]
9670pub fn fold_transaction_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionMode) -> TransactionMode
9671where
9672 F: Fold<T, T2, > + ?Sized,
9673{
9674 match node {
9675 TransactionMode::AccessMode {
9676 0: binding0,
9677 } => {
9678 TransactionMode::AccessMode {
9679 0: folder.fold_transaction_access_mode(binding0),
9680 }
9681 }
9682 TransactionMode::IsolationLevel {
9683 0: binding0,
9684 } => {
9685 TransactionMode::IsolationLevel {
9686 0: folder.fold_transaction_isolation_level(binding0),
9687 }
9688 }
9689 }
9690}
9691impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedDatabaseName {
9692 type Folded = UnresolvedDatabaseName;
9693 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9694 folder.fold_unresolved_database_name(self)
9695 }
9696}
9697#[allow(clippy::needless_pass_by_ref_mut)]
9698pub fn fold_unresolved_database_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedDatabaseName) -> UnresolvedDatabaseName
9699where
9700 F: Fold<T, T2, > + ?Sized,
9701{
9702 UnresolvedDatabaseName {
9703 0: folder.fold_ident(node.0),
9704 }
9705}
9706impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedItemName {
9707 type Folded = UnresolvedItemName;
9708 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9709 folder.fold_unresolved_item_name(self)
9710 }
9711}
9712#[allow(clippy::needless_pass_by_ref_mut)]
9713pub fn fold_unresolved_item_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedItemName) -> UnresolvedItemName
9714where
9715 F: Fold<T, T2, > + ?Sized,
9716{
9717 UnresolvedItemName {
9718 0: node.0.into_iter().map(|v| folder.fold_ident(v)).collect(),
9719 }
9720}
9721impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedObjectName {
9722 type Folded = UnresolvedObjectName;
9723 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9724 folder.fold_unresolved_object_name(self)
9725 }
9726}
9727#[allow(clippy::needless_pass_by_ref_mut)]
9728pub fn fold_unresolved_object_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedObjectName) -> UnresolvedObjectName
9729where
9730 F: Fold<T, T2, > + ?Sized,
9731{
9732 match node {
9733 UnresolvedObjectName::Cluster {
9734 0: binding0,
9735 } => {
9736 UnresolvedObjectName::Cluster {
9737 0: folder.fold_ident(binding0),
9738 }
9739 }
9740 UnresolvedObjectName::ClusterReplica {
9741 0: binding0,
9742 } => {
9743 UnresolvedObjectName::ClusterReplica {
9744 0: folder.fold_qualified_replica(binding0),
9745 }
9746 }
9747 UnresolvedObjectName::Database {
9748 0: binding0,
9749 } => {
9750 UnresolvedObjectName::Database {
9751 0: folder.fold_unresolved_database_name(binding0),
9752 }
9753 }
9754 UnresolvedObjectName::Schema {
9755 0: binding0,
9756 } => {
9757 UnresolvedObjectName::Schema {
9758 0: folder.fold_unresolved_schema_name(binding0),
9759 }
9760 }
9761 UnresolvedObjectName::Role {
9762 0: binding0,
9763 } => {
9764 UnresolvedObjectName::Role {
9765 0: folder.fold_ident(binding0),
9766 }
9767 }
9768 UnresolvedObjectName::Item {
9769 0: binding0,
9770 } => {
9771 UnresolvedObjectName::Item {
9772 0: folder.fold_unresolved_item_name(binding0),
9773 }
9774 }
9775 UnresolvedObjectName::NetworkPolicy {
9776 0: binding0,
9777 } => {
9778 UnresolvedObjectName::NetworkPolicy {
9779 0: folder.fold_ident(binding0),
9780 }
9781 }
9782 }
9783}
9784impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UnresolvedSchemaName {
9785 type Folded = UnresolvedSchemaName;
9786 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9787 folder.fold_unresolved_schema_name(self)
9788 }
9789}
9790#[allow(clippy::needless_pass_by_ref_mut)]
9791pub fn fold_unresolved_schema_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UnresolvedSchemaName) -> UnresolvedSchemaName
9792where
9793 F: Fold<T, T2, > + ?Sized,
9794{
9795 UnresolvedSchemaName {
9796 0: node.0.into_iter().map(|v| folder.fold_ident(v)).collect(),
9797 }
9798}
9799impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for UpdateStatement<T> {
9800 type Folded = UpdateStatement<T2>;
9801 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9802 folder.fold_update_statement(self)
9803 }
9804}
9805#[allow(clippy::needless_pass_by_ref_mut)]
9806pub fn fold_update_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UpdateStatement<T>) -> UpdateStatement<T2>
9807where
9808 F: Fold<T, T2, > + ?Sized,
9809{
9810 UpdateStatement {
9811 table_name: folder.fold_item_name(node.table_name),
9812 alias: node.alias.map(|v| folder.fold_table_alias(v)),
9813 assignments: node.assignments.into_iter().map(|v| folder.fold_assignment(v)).collect(),
9814 selection: node.selection.map(|v| folder.fold_expr(v)),
9815 }
9816}
9817impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ValidateConnectionStatement<T> {
9818 type Folded = ValidateConnectionStatement<T2>;
9819 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9820 folder.fold_validate_connection_statement(self)
9821 }
9822}
9823#[allow(clippy::needless_pass_by_ref_mut)]
9824pub fn fold_validate_connection_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ValidateConnectionStatement<T>) -> ValidateConnectionStatement<T2>
9825where
9826 F: Fold<T, T2, > + ?Sized,
9827{
9828 ValidateConnectionStatement {
9829 name: folder.fold_item_name(node.name),
9830 }
9831}
9832impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Value {
9833 type Folded = Value;
9834 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9835 folder.fold_value(self)
9836 }
9837}
9838#[allow(clippy::needless_pass_by_ref_mut)]
9839pub fn fold_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Value) -> Value
9840where
9841 F: Fold<T, T2, > + ?Sized,
9842{
9843 match node {
9844 Value::Number {
9845 0: binding0,
9846 } => {
9847 Value::Number {
9848 0: binding0,
9849 }
9850 }
9851 Value::String {
9852 0: binding0,
9853 } => {
9854 Value::String {
9855 0: binding0,
9856 }
9857 }
9858 Value::HexString {
9859 0: binding0,
9860 } => {
9861 Value::HexString {
9862 0: binding0,
9863 }
9864 }
9865 Value::Boolean {
9866 0: binding0,
9867 } => {
9868 Value::Boolean {
9869 0: binding0,
9870 }
9871 }
9872 Value::Interval {
9873 0: binding0,
9874 } => {
9875 Value::Interval {
9876 0: folder.fold_interval_value(binding0),
9877 }
9878 }
9879 Value::Null {
9880 } => {
9881 Value::Null {
9882 }
9883 }
9884 }
9885}
9886impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ValueError {
9887 type Folded = ValueError;
9888 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9889 folder.fold_value_error(self)
9890 }
9891}
9892#[allow(clippy::needless_pass_by_ref_mut)]
9893pub fn fold_value_error<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ValueError) -> ValueError
9894where
9895 F: Fold<T, T2, > + ?Sized,
9896{
9897 ValueError {
9898 0: node.0,
9899 }
9900}
9901impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Values<T> {
9902 type Folded = Values<T2>;
9903 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9904 folder.fold_values(self)
9905 }
9906}
9907#[allow(clippy::needless_pass_by_ref_mut)]
9908pub fn fold_values<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Values<T>) -> Values<T2>
9909where
9910 F: Fold<T, T2, > + ?Sized,
9911{
9912 Values {
9913 0: node.0.into_iter().map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()).collect(),
9914 }
9915}
9916impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for Version {
9917 type Folded = Version;
9918 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9919 folder.fold_version(self)
9920 }
9921}
9922#[allow(clippy::needless_pass_by_ref_mut)]
9923pub fn fold_version<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Version) -> Version
9924where
9925 F: Fold<T, T2, > + ?Sized,
9926{
9927 Version {
9928 0: node.0,
9929 }
9930}
9931impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for ViewDefinition<T> {
9932 type Folded = ViewDefinition<T2>;
9933 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9934 folder.fold_view_definition(self)
9935 }
9936}
9937#[allow(clippy::needless_pass_by_ref_mut)]
9938pub fn fold_view_definition<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ViewDefinition<T>) -> ViewDefinition<T2>
9939where
9940 F: Fold<T, T2, > + ?Sized,
9941{
9942 ViewDefinition {
9943 name: folder.fold_unresolved_item_name(node.name),
9944 columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(),
9945 query: folder.fold_query(node.query),
9946 }
9947}
9948impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrame {
9949 type Folded = WindowFrame;
9950 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9951 folder.fold_window_frame(self)
9952 }
9953}
9954#[allow(clippy::needless_pass_by_ref_mut)]
9955pub fn fold_window_frame<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrame) -> WindowFrame
9956where
9957 F: Fold<T, T2, > + ?Sized,
9958{
9959 WindowFrame {
9960 units: folder.fold_window_frame_units(node.units),
9961 start_bound: folder.fold_window_frame_bound(node.start_bound),
9962 end_bound: node.end_bound.map(|v| folder.fold_window_frame_bound(v)),
9963 }
9964}
9965impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrameBound {
9966 type Folded = WindowFrameBound;
9967 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
9968 folder.fold_window_frame_bound(self)
9969 }
9970}
9971#[allow(clippy::needless_pass_by_ref_mut)]
9972pub fn fold_window_frame_bound<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameBound) -> WindowFrameBound
9973where
9974 F: Fold<T, T2, > + ?Sized,
9975{
9976 match node {
9977 WindowFrameBound::CurrentRow {
9978 } => {
9979 WindowFrameBound::CurrentRow {
9980 }
9981 }
9982 WindowFrameBound::Preceding {
9983 0: binding0,
9984 } => {
9985 WindowFrameBound::Preceding {
9986 0: binding0.map(|v| v),
9987 }
9988 }
9989 WindowFrameBound::Following {
9990 0: binding0,
9991 } => {
9992 WindowFrameBound::Following {
9993 0: binding0.map(|v| v),
9994 }
9995 }
9996 }
9997}
9998impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowFrameUnits {
9999 type Folded = WindowFrameUnits;
10000 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
10001 folder.fold_window_frame_units(self)
10002 }
10003}
10004#[allow(clippy::needless_pass_by_ref_mut)]
10005pub fn fold_window_frame_units<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameUnits) -> WindowFrameUnits
10006where
10007 F: Fold<T, T2, > + ?Sized,
10008{
10009 match node {
10010 WindowFrameUnits::Rows {
10011 } => {
10012 WindowFrameUnits::Rows {
10013 }
10014 }
10015 WindowFrameUnits::Range {
10016 } => {
10017 WindowFrameUnits::Range {
10018 }
10019 }
10020 WindowFrameUnits::Groups {
10021 } => {
10022 WindowFrameUnits::Groups {
10023 }
10024 }
10025 }
10026}
10027impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WindowSpec<T> {
10028 type Folded = WindowSpec<T2>;
10029 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
10030 folder.fold_window_spec(self)
10031 }
10032}
10033#[allow(clippy::needless_pass_by_ref_mut)]
10034pub fn fold_window_spec<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowSpec<T>) -> WindowSpec<T2>
10035where
10036 F: Fold<T, T2, > + ?Sized,
10037{
10038 WindowSpec {
10039 partition_by: node.partition_by.into_iter().map(|v| folder.fold_expr(v)).collect(),
10040 order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(),
10041 window_frame: node.window_frame.map(|v| folder.fold_window_frame(v)),
10042 ignore_nulls: node.ignore_nulls,
10043 respect_nulls: node.respect_nulls,
10044 }
10045}
10046impl<T: AstInfo, T2: AstInfo, > FoldNode<T, T2, > for WithOptionValue<T> {
10047 type Folded = WithOptionValue<T2>;
10048 fn fold<F: Fold<T, T2, >>(self, folder: &mut F) -> Self::Folded {
10049 folder.fold_with_option_value(self)
10050 }
10051}
10052#[allow(clippy::needless_pass_by_ref_mut)]
10053pub fn fold_with_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WithOptionValue<T>) -> WithOptionValue<T2>
10054where
10055 F: Fold<T, T2, > + ?Sized,
10056{
10057 match node {
10058 WithOptionValue::Value {
10059 0: binding0,
10060 } => {
10061 WithOptionValue::Value {
10062 0: folder.fold_value(binding0),
10063 }
10064 }
10065 WithOptionValue::DataType {
10066 0: binding0,
10067 } => {
10068 WithOptionValue::DataType {
10069 0: folder.fold_data_type(binding0),
10070 }
10071 }
10072 WithOptionValue::Secret {
10073 0: binding0,
10074 } => {
10075 WithOptionValue::Secret {
10076 0: folder.fold_item_name(binding0),
10077 }
10078 }
10079 WithOptionValue::Item {
10080 0: binding0,
10081 } => {
10082 WithOptionValue::Item {
10083 0: folder.fold_item_name(binding0),
10084 }
10085 }
10086 WithOptionValue::UnresolvedItemName {
10087 0: binding0,
10088 } => {
10089 WithOptionValue::UnresolvedItemName {
10090 0: folder.fold_unresolved_item_name(binding0),
10091 }
10092 }
10093 WithOptionValue::Ident {
10094 0: binding0,
10095 } => {
10096 WithOptionValue::Ident {
10097 0: folder.fold_ident(binding0),
10098 }
10099 }
10100 WithOptionValue::Sequence {
10101 0: binding0,
10102 } => {
10103 WithOptionValue::Sequence {
10104 0: binding0.into_iter().map(|v| folder.fold_with_option_value(v)).collect(),
10105 }
10106 }
10107 WithOptionValue::Map {
10108 0: binding0,
10109 } => {
10110 WithOptionValue::Map {
10111 0: { std::collections::BTreeMap::from_iter(binding0.into_iter().map(|(k, v)| {(k.to_owned(), folder.fold_with_option_value(v).to_owned()) }) )},
10112 }
10113 }
10114 WithOptionValue::Expr {
10115 0: binding0,
10116 } => {
10117 WithOptionValue::Expr {
10118 0: folder.fold_expr(binding0),
10119 }
10120 }
10121 WithOptionValue::ClusterReplicas {
10122 0: binding0,
10123 } => {
10124 WithOptionValue::ClusterReplicas {
10125 0: binding0.into_iter().map(|v| folder.fold_replica_definition(v)).collect(),
10126 }
10127 }
10128 WithOptionValue::ConnectionKafkaBroker {
10129 0: binding0,
10130 } => {
10131 WithOptionValue::ConnectionKafkaBroker {
10132 0: folder.fold_kafka_broker(binding0),
10133 }
10134 }
10135 WithOptionValue::ConnectionAwsPrivatelink {
10136 0: binding0,
10137 } => {
10138 WithOptionValue::ConnectionAwsPrivatelink {
10139 0: folder.fold_connection_default_aws_privatelink(binding0),
10140 }
10141 }
10142 WithOptionValue::RetainHistoryFor {
10143 0: binding0,
10144 } => {
10145 WithOptionValue::RetainHistoryFor {
10146 0: folder.fold_value(binding0),
10147 }
10148 }
10149 WithOptionValue::Refresh {
10150 0: binding0,
10151 } => {
10152 WithOptionValue::Refresh {
10153 0: folder.fold_refresh_option_value(binding0),
10154 }
10155 }
10156 WithOptionValue::ClusterScheduleOptionValue {
10157 0: binding0,
10158 } => {
10159 WithOptionValue::ClusterScheduleOptionValue {
10160 0: folder.fold_cluster_schedule_option_value(binding0),
10161 }
10162 }
10163 WithOptionValue::ClusterAlterStrategy {
10164 0: binding0,
10165 } => {
10166 WithOptionValue::ClusterAlterStrategy {
10167 0: folder.fold_cluster_alter_option_value(binding0),
10168 }
10169 }
10170 WithOptionValue::NetworkPolicyRules {
10171 0: binding0,
10172 } => {
10173 WithOptionValue::NetworkPolicyRules {
10174 0: binding0.into_iter().map(|v| folder.fold_network_policy_rule_definition(v)).collect(),
10175 }
10176 }
10177 }
10178}