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