Last active
February 10, 2021 18:57
-
-
Save benesch/0af1628ad590a4e7326d67e4ebd29a86 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[~/Sites/materialize/materialize] (f32 *$%) | |
benesch@marmoset$ cd src/sql-parser | |
[~/Sites/materialize/materialize/src/sql-parser] (f32 *$%) | |
benesch@marmoset$ cargo out-dir | |
/home/benesch/Sites/materialize/materialize/target/debug/build/sql-parser-89e065596d8d4a8f/out | |
[~/Sites/materialize/materialize/src/sql-parser] (f32 *$%) | |
benesch@marmoset$ cat /home/benesch/Sites/materialize/materialize/target/debug/build/sql-parser-89e065596d8d4a8f/out/fold.rs |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pub trait Fold<T: AstInfo, T2: AstInfo, > { | |
fn fold_alter_index_options_list(&mut self, node: AlterIndexOptionsList) -> AlterIndexOptionsList { | |
fold_alter_index_options_list(self, node) | |
} | |
fn fold_alter_index_options_statement(&mut self, node: AlterIndexOptionsStatement) -> AlterIndexOptionsStatement { | |
fold_alter_index_options_statement(self, node) | |
} | |
fn fold_alter_object_rename_statement(&mut self, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement { | |
fold_alter_object_rename_statement(self, node) | |
} | |
fn fold_assignment(&mut self, node: Assignment<T>) -> Assignment<T2> { | |
fold_assignment(self, node) | |
} | |
fn fold_avro_schema(&mut self, node: AvroSchema) -> AvroSchema { | |
fold_avro_schema(self, node) | |
} | |
fn fold_catalog_name(&mut self, node: CatalogName) -> CatalogName { | |
fold_catalog_name(self, node) | |
} | |
fn fold_close_statement(&mut self, node: CloseStatement) -> CloseStatement { | |
fold_close_statement(self, node) | |
} | |
fn fold_column_def(&mut self, node: ColumnDef<T>) -> ColumnDef<T2> { | |
fold_column_def(self, node) | |
} | |
fn fold_column_option(&mut self, node: ColumnOption<T>) -> ColumnOption<T2> { | |
fold_column_option(self, node) | |
} | |
fn fold_column_option_def(&mut self, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2> { | |
fold_column_option_def(self, node) | |
} | |
fn fold_commit_statement(&mut self, node: CommitStatement) -> CommitStatement { | |
fold_commit_statement(self, node) | |
} | |
fn fold_compression(&mut self, node: Compression) -> Compression { | |
fold_compression(self, node) | |
} | |
fn fold_connector(&mut self, node: Connector) -> Connector { | |
fold_connector(self, node) | |
} | |
fn fold_copy_direction(&mut self, node: CopyDirection) -> CopyDirection { | |
fold_copy_direction(self, node) | |
} | |
fn fold_copy_relation(&mut self, node: CopyRelation<T>) -> CopyRelation<T2> { | |
fold_copy_relation(self, node) | |
} | |
fn fold_copy_statement(&mut self, node: CopyStatement<T>) -> CopyStatement<T2> { | |
fold_copy_statement(self, node) | |
} | |
fn fold_copy_target(&mut self, node: CopyTarget) -> CopyTarget { | |
fold_copy_target(self, node) | |
} | |
fn fold_create_database_statement(&mut self, node: CreateDatabaseStatement) -> CreateDatabaseStatement { | |
fold_create_database_statement(self, node) | |
} | |
fn fold_create_index_statement(&mut self, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2> { | |
fold_create_index_statement(self, node) | |
} | |
fn fold_create_role_option(&mut self, node: CreateRoleOption) -> CreateRoleOption { | |
fold_create_role_option(self, node) | |
} | |
fn fold_create_role_statement(&mut self, node: CreateRoleStatement) -> CreateRoleStatement { | |
fold_create_role_statement(self, node) | |
} | |
fn fold_create_schema_statement(&mut self, node: CreateSchemaStatement) -> CreateSchemaStatement { | |
fold_create_schema_statement(self, node) | |
} | |
fn fold_create_sink_statement(&mut self, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2> { | |
fold_create_sink_statement(self, node) | |
} | |
fn fold_create_source_statement(&mut self, node: CreateSourceStatement) -> CreateSourceStatement { | |
fold_create_source_statement(self, node) | |
} | |
fn fold_create_table_statement(&mut self, node: CreateTableStatement<T>) -> CreateTableStatement<T2> { | |
fold_create_table_statement(self, node) | |
} | |
fn fold_create_type_as(&mut self, node: CreateTypeAs) -> CreateTypeAs { | |
fold_create_type_as(self, node) | |
} | |
fn fold_create_type_statement(&mut self, node: CreateTypeStatement) -> CreateTypeStatement { | |
fold_create_type_statement(self, node) | |
} | |
fn fold_create_view_statement(&mut self, node: CreateViewStatement<T>) -> CreateViewStatement<T2> { | |
fold_create_view_statement(self, node) | |
} | |
fn fold_csr_seed(&mut self, node: CsrSeed) -> CsrSeed { | |
fold_csr_seed(self, node) | |
} | |
fn fold_cte(&mut self, node: Cte<T>) -> Cte<T2> { | |
fold_cte(self, node) | |
} | |
fn fold_data_type(&mut self, node: DataType) -> DataType { | |
fold_data_type(self, node) | |
} | |
fn fold_declare_statement(&mut self, node: DeclareStatement<T>) -> DeclareStatement<T2> { | |
fold_declare_statement(self, node) | |
} | |
fn fold_delete_statement(&mut self, node: DeleteStatement<T>) -> DeleteStatement<T2> { | |
fold_delete_statement(self, node) | |
} | |
fn fold_discard_statement(&mut self, node: DiscardStatement) -> DiscardStatement { | |
fold_discard_statement(self, node) | |
} | |
fn fold_discard_target(&mut self, node: DiscardTarget) -> DiscardTarget { | |
fold_discard_target(self, node) | |
} | |
fn fold_distinct(&mut self, node: Distinct<T>) -> Distinct<T2> { | |
fold_distinct(self, node) | |
} | |
fn fold_drop_database_statement(&mut self, node: DropDatabaseStatement) -> DropDatabaseStatement { | |
fold_drop_database_statement(self, node) | |
} | |
fn fold_drop_objects_statement(&mut self, node: DropObjectsStatement) -> DropObjectsStatement { | |
fold_drop_objects_statement(self, node) | |
} | |
fn fold_envelope(&mut self, node: Envelope) -> Envelope { | |
fold_envelope(self, node) | |
} | |
fn fold_explain_options(&mut self, node: ExplainOptions) -> ExplainOptions { | |
fold_explain_options(self, node) | |
} | |
fn fold_explain_stage(&mut self, node: ExplainStage) -> ExplainStage { | |
fold_explain_stage(self, node) | |
} | |
fn fold_explain_statement(&mut self, node: ExplainStatement<T>) -> ExplainStatement<T2> { | |
fold_explain_statement(self, node) | |
} | |
fn fold_explainee(&mut self, node: Explainee<T>) -> Explainee<T2> { | |
fold_explainee(self, node) | |
} | |
fn fold_expr(&mut self, node: Expr<T>) -> Expr<T2> { | |
fold_expr(self, node) | |
} | |
fn fold_fetch_direction(&mut self, node: FetchDirection) -> FetchDirection { | |
fold_fetch_direction(self, node) | |
} | |
fn fold_fetch_statement(&mut self, node: FetchStatement) -> FetchStatement { | |
fold_fetch_statement(self, node) | |
} | |
fn fold_format(&mut self, node: Format) -> Format { | |
fold_format(self, node) | |
} | |
fn fold_function(&mut self, node: Function<T>) -> Function<T2> { | |
fold_function(self, node) | |
} | |
fn fold_function_args(&mut self, node: FunctionArgs<T>) -> FunctionArgs<T2> { | |
fold_function_args(self, node) | |
} | |
fn fold_ident(&mut self, node: Ident) -> Ident { | |
fold_ident(self, node) | |
} | |
fn fold_if_exists_behavior(&mut self, node: IfExistsBehavior) -> IfExistsBehavior { | |
fold_if_exists_behavior(self, node) | |
} | |
fn fold_insert_source(&mut self, node: InsertSource<T>) -> InsertSource<T2> { | |
fold_insert_source(self, node) | |
} | |
fn fold_insert_statement(&mut self, node: InsertStatement<T>) -> InsertStatement<T2> { | |
fold_insert_statement(self, node) | |
} | |
fn fold_interval_value(&mut self, node: IntervalValue) -> IntervalValue { | |
fold_interval_value(self, node) | |
} | |
fn fold_join(&mut self, node: Join<T>) -> Join<T2> { | |
fold_join(self, node) | |
} | |
fn fold_join_constraint(&mut self, node: JoinConstraint<T>) -> JoinConstraint<T2> { | |
fold_join_constraint(self, node) | |
} | |
fn fold_join_operator(&mut self, node: JoinOperator<T>) -> JoinOperator<T2> { | |
fold_join_operator(self, node) | |
} | |
fn fold_limit(&mut self, node: Limit<T>) -> Limit<T2> { | |
fold_limit(self, node) | |
} | |
fn fold_object_name(&mut self, node: ObjectName) -> ObjectName { | |
fold_object_name(self, node) | |
} | |
fn fold_object_type(&mut self, node: ObjectType) -> ObjectType { | |
fold_object_type(self, node) | |
} | |
fn fold_order_by_expr(&mut self, node: OrderByExpr<T>) -> OrderByExpr<T2> { | |
fold_order_by_expr(self, node) | |
} | |
fn fold_query(&mut self, node: Query<T>) -> Query<T2> { | |
fold_query(self, node) | |
} | |
fn fold_raw(&mut self, node: Raw) -> Raw { | |
fold_raw(self, node) | |
} | |
fn fold_rollback_statement(&mut self, node: RollbackStatement) -> RollbackStatement { | |
fold_rollback_statement(self, node) | |
} | |
fn fold_s3_key_source(&mut self, node: S3KeySource) -> S3KeySource { | |
fold_s3_key_source(self, node) | |
} | |
fn fold_schema(&mut self, node: Schema) -> Schema { | |
fold_schema(self, node) | |
} | |
fn fold_select(&mut self, node: Select<T>) -> Select<T2> { | |
fold_select(self, node) | |
} | |
fn fold_select_item(&mut self, node: SelectItem<T>) -> SelectItem<T2> { | |
fold_select_item(self, node) | |
} | |
fn fold_select_statement(&mut self, node: SelectStatement<T>) -> SelectStatement<T2> { | |
fold_select_statement(self, node) | |
} | |
fn fold_set_expr(&mut self, node: SetExpr<T>) -> SetExpr<T2> { | |
fold_set_expr(self, node) | |
} | |
fn fold_set_operator(&mut self, node: SetOperator) -> SetOperator { | |
fold_set_operator(self, node) | |
} | |
fn fold_set_transaction_statement(&mut self, node: SetTransactionStatement) -> SetTransactionStatement { | |
fold_set_transaction_statement(self, node) | |
} | |
fn fold_set_variable_statement(&mut self, node: SetVariableStatement) -> SetVariableStatement { | |
fold_set_variable_statement(self, node) | |
} | |
fn fold_set_variable_value(&mut self, node: SetVariableValue) -> SetVariableValue { | |
fold_set_variable_value(self, node) | |
} | |
fn fold_show_columns_statement(&mut self, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2> { | |
fold_show_columns_statement(self, node) | |
} | |
fn fold_show_create_index_statement(&mut self, node: ShowCreateIndexStatement) -> ShowCreateIndexStatement { | |
fold_show_create_index_statement(self, node) | |
} | |
fn fold_show_create_sink_statement(&mut self, node: ShowCreateSinkStatement) -> ShowCreateSinkStatement { | |
fold_show_create_sink_statement(self, node) | |
} | |
fn fold_show_create_source_statement(&mut self, node: ShowCreateSourceStatement) -> ShowCreateSourceStatement { | |
fold_show_create_source_statement(self, node) | |
} | |
fn fold_show_create_table_statement(&mut self, node: ShowCreateTableStatement) -> ShowCreateTableStatement { | |
fold_show_create_table_statement(self, node) | |
} | |
fn fold_show_create_view_statement(&mut self, node: ShowCreateViewStatement) -> ShowCreateViewStatement { | |
fold_show_create_view_statement(self, node) | |
} | |
fn fold_show_databases_statement(&mut self, node: ShowDatabasesStatement<T>) -> ShowDatabasesStatement<T2> { | |
fold_show_databases_statement(self, node) | |
} | |
fn fold_show_indexes_statement(&mut self, node: ShowIndexesStatement<T>) -> ShowIndexesStatement<T2> { | |
fold_show_indexes_statement(self, node) | |
} | |
fn fold_show_objects_statement(&mut self, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2> { | |
fold_show_objects_statement(self, node) | |
} | |
fn fold_show_statement_filter(&mut self, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2> { | |
fold_show_statement_filter(self, node) | |
} | |
fn fold_show_variable_statement(&mut self, node: ShowVariableStatement) -> ShowVariableStatement { | |
fold_show_variable_statement(self, node) | |
} | |
fn fold_sql_option(&mut self, node: SqlOption) -> SqlOption { | |
fold_sql_option(self, node) | |
} | |
fn fold_start_transaction_statement(&mut self, node: StartTransactionStatement) -> StartTransactionStatement { | |
fold_start_transaction_statement(self, node) | |
} | |
fn fold_statement(&mut self, node: Statement<T>) -> Statement<T2> { | |
fold_statement(self, node) | |
} | |
fn fold_subscript_position(&mut self, node: SubscriptPosition<T>) -> SubscriptPosition<T2> { | |
fold_subscript_position(self, node) | |
} | |
fn fold_id(&mut self, node: T::Id) -> T2::Id; | |
fn fold_table(&mut self, node: T::Table) -> T2::Table; | |
fn fold_table_alias(&mut self, node: TableAlias) -> TableAlias { | |
fold_table_alias(self, node) | |
} | |
fn fold_table_constraint(&mut self, node: TableConstraint<T>) -> TableConstraint<T2> { | |
fold_table_constraint(self, node) | |
} | |
fn fold_table_factor(&mut self, node: TableFactor<T>) -> TableFactor<T2> { | |
fold_table_factor(self, node) | |
} | |
fn fold_table_with_joins(&mut self, node: TableWithJoins<T>) -> TableWithJoins<T2> { | |
fold_table_with_joins(self, node) | |
} | |
fn fold_tail_statement(&mut self, node: TailStatement<T>) -> TailStatement<T2> { | |
fold_tail_statement(self, node) | |
} | |
fn fold_transaction_access_mode(&mut self, node: TransactionAccessMode) -> TransactionAccessMode { | |
fold_transaction_access_mode(self, node) | |
} | |
fn fold_transaction_isolation_level(&mut self, node: TransactionIsolationLevel) -> TransactionIsolationLevel { | |
fold_transaction_isolation_level(self, node) | |
} | |
fn fold_transaction_mode(&mut self, node: TransactionMode) -> TransactionMode { | |
fold_transaction_mode(self, node) | |
} | |
fn fold_update_statement(&mut self, node: UpdateStatement<T>) -> UpdateStatement<T2> { | |
fold_update_statement(self, node) | |
} | |
fn fold_value(&mut self, node: Value) -> Value { | |
fold_value(self, node) | |
} | |
fn fold_value_error(&mut self, node: ValueError) -> ValueError { | |
fold_value_error(self, node) | |
} | |
fn fold_values(&mut self, node: Values<T>) -> Values<T2> { | |
fold_values(self, node) | |
} | |
fn fold_window_frame(&mut self, node: WindowFrame) -> WindowFrame { | |
fold_window_frame(self, node) | |
} | |
fn fold_window_frame_bound(&mut self, node: WindowFrameBound) -> WindowFrameBound { | |
fold_window_frame_bound(self, node) | |
} | |
fn fold_window_frame_units(&mut self, node: WindowFrameUnits) -> WindowFrameUnits { | |
fold_window_frame_units(self, node) | |
} | |
fn fold_window_spec(&mut self, node: WindowSpec<T>) -> WindowSpec<T2> { | |
fold_window_spec(self, node) | |
} | |
fn fold_with_option(&mut self, node: WithOption) -> WithOption { | |
fold_with_option(self, node) | |
} | |
fn fold_with_option_value(&mut self, node: WithOptionValue) -> WithOptionValue { | |
fold_with_option_value(self, node) | |
} | |
} | |
pub fn fold_alter_index_options_list<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexOptionsList) -> AlterIndexOptionsList | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
AlterIndexOptionsList::Set { | |
0: binding0, | |
} => { | |
AlterIndexOptionsList::Set { | |
0: binding0.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
} | |
} | |
AlterIndexOptionsList::Reset { | |
0: binding0, | |
} => { | |
AlterIndexOptionsList::Reset { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_alter_index_options_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterIndexOptionsStatement) -> AlterIndexOptionsStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
AlterIndexOptionsStatement { | |
index_name: folder.fold_object_name(node.index_name), | |
if_exists: node.if_exists, | |
options: folder.fold_alter_index_options_list(node.options), | |
} | |
} | |
pub fn fold_alter_object_rename_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AlterObjectRenameStatement) -> AlterObjectRenameStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
AlterObjectRenameStatement { | |
object_type: folder.fold_object_type(node.object_type), | |
if_exists: node.if_exists, | |
name: folder.fold_object_name(node.name), | |
to_item_name: folder.fold_ident(node.to_item_name), | |
} | |
} | |
pub fn fold_assignment<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Assignment<T>) -> Assignment<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Assignment { | |
id: folder.fold_ident(node.id), | |
value: folder.fold_expr(node.value), | |
} | |
} | |
pub fn fold_avro_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: AvroSchema) -> AvroSchema | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
AvroSchema::CsrUrl { | |
url: binding0, | |
seed: binding1, | |
with_options: binding2, | |
} => { | |
AvroSchema::CsrUrl { | |
url: binding0, | |
seed: binding1.map(|v| folder.fold_csr_seed(v)), | |
with_options: binding2.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
} | |
} | |
AvroSchema::Schema { | |
0: binding0, | |
} => { | |
AvroSchema::Schema { | |
0: folder.fold_schema(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_catalog_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CatalogName) -> CatalogName | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CatalogName::ObjectName { | |
0: binding0, | |
} => { | |
CatalogName::ObjectName { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
CatalogName::FuncName { | |
0: binding0, | |
} => { | |
CatalogName::FuncName { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_close_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CloseStatement) -> CloseStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CloseStatement { | |
name: folder.fold_ident(node.name), | |
} | |
} | |
pub fn fold_column_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnDef<T>) -> ColumnDef<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ColumnDef { | |
name: folder.fold_ident(node.name), | |
data_type: folder.fold_data_type(node.data_type), | |
collation: node.collation.map(|v| folder.fold_object_name(v)), | |
options: node.options.into_iter().map(|v| folder.fold_column_option_def(v)).collect(), | |
} | |
} | |
pub fn fold_column_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOption<T>) -> ColumnOption<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
ColumnOption::Null { | |
} => { | |
ColumnOption::Null { | |
} | |
} | |
ColumnOption::NotNull { | |
} => { | |
ColumnOption::NotNull { | |
} | |
} | |
ColumnOption::Default { | |
0: binding0, | |
} => { | |
ColumnOption::Default { | |
0: folder.fold_expr(binding0), | |
} | |
} | |
ColumnOption::Unique { | |
is_primary: binding0, | |
} => { | |
ColumnOption::Unique { | |
is_primary: binding0, | |
} | |
} | |
ColumnOption::ForeignKey { | |
foreign_table: binding0, | |
referred_columns: binding1, | |
} => { | |
ColumnOption::ForeignKey { | |
foreign_table: folder.fold_object_name(binding0), | |
referred_columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
ColumnOption::Check { | |
0: binding0, | |
} => { | |
ColumnOption::Check { | |
0: folder.fold_expr(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_column_option_def<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ColumnOptionDef<T>) -> ColumnOptionDef<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ColumnOptionDef { | |
name: node.name.map(|v| folder.fold_ident(v)), | |
option: folder.fold_column_option(node.option), | |
} | |
} | |
pub fn fold_commit_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CommitStatement) -> CommitStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CommitStatement { | |
chain: node.chain, | |
} | |
} | |
pub fn fold_compression<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Compression) -> Compression | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Compression::Gzip { | |
} => { | |
Compression::Gzip { | |
} | |
} | |
Compression::None { | |
} => { | |
Compression::None { | |
} | |
} | |
} | |
} | |
pub fn fold_connector<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Connector) -> Connector | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Connector::File { | |
path: binding0, | |
compression: binding1, | |
} => { | |
Connector::File { | |
path: binding0, | |
compression: folder.fold_compression(binding1), | |
} | |
} | |
Connector::Kafka { | |
broker: binding0, | |
topic: binding1, | |
key: binding2, | |
} => { | |
Connector::Kafka { | |
broker: binding0, | |
topic: binding1, | |
key: binding2.map(|v| v.into_iter().map(|v| folder.fold_ident(v)).collect()), | |
} | |
} | |
Connector::Kinesis { | |
arn: binding0, | |
} => { | |
Connector::Kinesis { | |
arn: binding0, | |
} | |
} | |
Connector::AvroOcf { | |
path: binding0, | |
} => { | |
Connector::AvroOcf { | |
path: binding0, | |
} | |
} | |
Connector::S3 { | |
key_sources: binding0, | |
pattern: binding1, | |
} => { | |
Connector::S3 { | |
key_sources: binding0.into_iter().map(|v| folder.fold_s3_key_source(v)).collect(), | |
pattern: binding1.map(|v| v), | |
} | |
} | |
} | |
} | |
pub fn fold_copy_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyDirection) -> CopyDirection | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CopyDirection::To { | |
} => { | |
CopyDirection::To { | |
} | |
} | |
CopyDirection::From { | |
} => { | |
CopyDirection::From { | |
} | |
} | |
} | |
} | |
pub fn fold_copy_relation<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyRelation<T>) -> CopyRelation<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CopyRelation::Table { | |
name: binding0, | |
columns: binding1, | |
} => { | |
CopyRelation::Table { | |
name: folder.fold_object_name(binding0), | |
columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
CopyRelation::Select { | |
0: binding0, | |
} => { | |
CopyRelation::Select { | |
0: folder.fold_select_statement(binding0), | |
} | |
} | |
CopyRelation::Tail { | |
0: binding0, | |
} => { | |
CopyRelation::Tail { | |
0: folder.fold_tail_statement(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_copy_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyStatement<T>) -> CopyStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CopyStatement { | |
relation: folder.fold_copy_relation(node.relation), | |
direction: folder.fold_copy_direction(node.direction), | |
target: folder.fold_copy_target(node.target), | |
options: node.options.into_iter().map(|v| folder.fold_with_option(v)).collect(), | |
} | |
} | |
pub fn fold_copy_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CopyTarget) -> CopyTarget | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CopyTarget::Stdin { | |
} => { | |
CopyTarget::Stdin { | |
} | |
} | |
CopyTarget::Stdout { | |
} => { | |
CopyTarget::Stdout { | |
} | |
} | |
} | |
} | |
pub fn fold_create_database_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateDatabaseStatement) -> CreateDatabaseStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateDatabaseStatement { | |
name: folder.fold_ident(node.name), | |
if_not_exists: node.if_not_exists, | |
} | |
} | |
pub fn fold_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateIndexStatement<T>) -> CreateIndexStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateIndexStatement { | |
name: node.name.map(|v| folder.fold_ident(v)), | |
on_name: folder.fold_object_name(node.on_name), | |
key_parts: node.key_parts.map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()), | |
if_not_exists: node.if_not_exists, | |
} | |
} | |
pub fn fold_create_role_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateRoleOption) -> CreateRoleOption | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CreateRoleOption::SuperUser { | |
} => { | |
CreateRoleOption::SuperUser { | |
} | |
} | |
CreateRoleOption::NoSuperUser { | |
} => { | |
CreateRoleOption::NoSuperUser { | |
} | |
} | |
CreateRoleOption::Login { | |
} => { | |
CreateRoleOption::Login { | |
} | |
} | |
CreateRoleOption::NoLogin { | |
} => { | |
CreateRoleOption::NoLogin { | |
} | |
} | |
} | |
} | |
pub fn fold_create_role_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateRoleStatement) -> CreateRoleStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateRoleStatement { | |
is_user: node.is_user, | |
name: folder.fold_ident(node.name), | |
options: node.options.into_iter().map(|v| folder.fold_create_role_option(v)).collect(), | |
} | |
} | |
pub fn fold_create_schema_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSchemaStatement) -> CreateSchemaStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateSchemaStatement { | |
name: folder.fold_object_name(node.name), | |
if_not_exists: node.if_not_exists, | |
} | |
} | |
pub fn fold_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSinkStatement<T>) -> CreateSinkStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateSinkStatement { | |
name: folder.fold_object_name(node.name), | |
from: folder.fold_object_name(node.from), | |
connector: folder.fold_connector(node.connector), | |
with_options: node.with_options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
format: node.format.map(|v| folder.fold_format(v)), | |
envelope: node.envelope.map(|v| folder.fold_envelope(v)), | |
with_snapshot: node.with_snapshot, | |
as_of: node.as_of.map(|v| folder.fold_expr(v)), | |
if_not_exists: node.if_not_exists, | |
} | |
} | |
pub fn fold_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateSourceStatement) -> CreateSourceStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateSourceStatement { | |
name: folder.fold_object_name(node.name), | |
col_names: node.col_names.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
connector: folder.fold_connector(node.connector), | |
with_options: node.with_options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
format: node.format.map(|v| folder.fold_format(v)), | |
envelope: folder.fold_envelope(node.envelope), | |
if_not_exists: node.if_not_exists, | |
materialized: node.materialized, | |
} | |
} | |
pub fn fold_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTableStatement<T>) -> CreateTableStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateTableStatement { | |
name: folder.fold_object_name(node.name), | |
columns: node.columns.into_iter().map(|v| folder.fold_column_def(v)).collect(), | |
constraints: node.constraints.into_iter().map(|v| folder.fold_table_constraint(v)).collect(), | |
with_options: node.with_options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
if_not_exists: node.if_not_exists, | |
temporary: node.temporary, | |
} | |
} | |
pub fn fold_create_type_as<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeAs) -> CreateTypeAs | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
CreateTypeAs::List { | |
} => { | |
CreateTypeAs::List { | |
} | |
} | |
CreateTypeAs::Map { | |
} => { | |
CreateTypeAs::Map { | |
} | |
} | |
} | |
} | |
pub fn fold_create_type_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateTypeStatement) -> CreateTypeStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateTypeStatement { | |
name: folder.fold_object_name(node.name), | |
as_type: folder.fold_create_type_as(node.as_type), | |
with_options: node.with_options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
} | |
} | |
pub fn fold_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CreateViewStatement<T>) -> CreateViewStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CreateViewStatement { | |
name: folder.fold_object_name(node.name), | |
columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
with_options: node.with_options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
query: folder.fold_query(node.query), | |
if_exists: folder.fold_if_exists_behavior(node.if_exists), | |
temporary: node.temporary, | |
materialized: node.materialized, | |
} | |
} | |
pub fn fold_csr_seed<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: CsrSeed) -> CsrSeed | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
CsrSeed { | |
key_schema: node.key_schema.map(|v| v), | |
value_schema: node.value_schema, | |
} | |
} | |
pub fn fold_cte<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Cte<T>) -> Cte<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Cte { | |
alias: folder.fold_table_alias(node.alias), | |
id: folder.fold_id(node.id), | |
query: folder.fold_query(node.query), | |
} | |
} | |
pub fn fold_data_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DataType) -> DataType | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
DataType::Array { | |
0: binding0, | |
} => { | |
DataType::Array { | |
0: Box::new(folder.fold_data_type(*binding0)), | |
} | |
} | |
DataType::List { | |
0: binding0, | |
} => { | |
DataType::List { | |
0: Box::new(folder.fold_data_type(*binding0)), | |
} | |
} | |
DataType::Map { | |
key_type: binding0, | |
value_type: binding1, | |
} => { | |
DataType::Map { | |
key_type: Box::new(folder.fold_data_type(*binding0)), | |
value_type: Box::new(folder.fold_data_type(*binding1)), | |
} | |
} | |
DataType::Other { | |
name: binding0, | |
typ_mod: binding1, | |
} => { | |
DataType::Other { | |
name: folder.fold_object_name(binding0), | |
typ_mod: binding1.into_iter().map(|v| v).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_declare_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeclareStatement<T>) -> DeclareStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
DeclareStatement { | |
name: folder.fold_ident(node.name), | |
stmt: Box::new(folder.fold_statement(*node.stmt)), | |
} | |
} | |
pub fn fold_delete_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DeleteStatement<T>) -> DeleteStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
DeleteStatement { | |
table_name: folder.fold_object_name(node.table_name), | |
selection: node.selection.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_discard_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardStatement) -> DiscardStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
DiscardStatement { | |
target: folder.fold_discard_target(node.target), | |
} | |
} | |
pub fn fold_discard_target<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DiscardTarget) -> DiscardTarget | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
DiscardTarget::Plans { | |
} => { | |
DiscardTarget::Plans { | |
} | |
} | |
DiscardTarget::Sequences { | |
} => { | |
DiscardTarget::Sequences { | |
} | |
} | |
DiscardTarget::Temp { | |
} => { | |
DiscardTarget::Temp { | |
} | |
} | |
DiscardTarget::All { | |
} => { | |
DiscardTarget::All { | |
} | |
} | |
} | |
} | |
pub fn fold_distinct<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Distinct<T>) -> Distinct<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Distinct::EntireRow { | |
} => { | |
Distinct::EntireRow { | |
} | |
} | |
Distinct::On { | |
0: binding0, | |
} => { | |
Distinct::On { | |
0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_drop_database_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropDatabaseStatement) -> DropDatabaseStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
DropDatabaseStatement { | |
name: folder.fold_ident(node.name), | |
if_exists: node.if_exists, | |
} | |
} | |
pub fn fold_drop_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: DropObjectsStatement) -> DropObjectsStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
DropObjectsStatement { | |
object_type: folder.fold_object_type(node.object_type), | |
if_exists: node.if_exists, | |
names: node.names.into_iter().map(|v| folder.fold_object_name(v)).collect(), | |
cascade: node.cascade, | |
} | |
} | |
pub fn fold_envelope<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Envelope) -> Envelope | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Envelope::None { | |
} => { | |
Envelope::None { | |
} | |
} | |
Envelope::Debezium { | |
} => { | |
Envelope::Debezium { | |
} | |
} | |
Envelope::Upsert { | |
0: binding0, | |
} => { | |
Envelope::Upsert { | |
0: binding0.map(|v| folder.fold_format(v)), | |
} | |
} | |
Envelope::CdcV2 { | |
} => { | |
Envelope::CdcV2 { | |
} | |
} | |
} | |
} | |
pub fn fold_explain_options<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainOptions) -> ExplainOptions | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ExplainOptions { | |
typed: node.typed, | |
} | |
} | |
pub fn fold_explain_stage<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainStage) -> ExplainStage | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
ExplainStage::RawPlan { | |
} => { | |
ExplainStage::RawPlan { | |
} | |
} | |
ExplainStage::DecorrelatedPlan { | |
} => { | |
ExplainStage::DecorrelatedPlan { | |
} | |
} | |
ExplainStage::OptimizedPlan { | |
} => { | |
ExplainStage::OptimizedPlan { | |
} | |
} | |
} | |
} | |
pub fn fold_explain_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ExplainStatement<T>) -> ExplainStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ExplainStatement { | |
stage: folder.fold_explain_stage(node.stage), | |
explainee: folder.fold_explainee(node.explainee), | |
options: folder.fold_explain_options(node.options), | |
} | |
} | |
pub fn fold_explainee<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Explainee<T>) -> Explainee<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Explainee::View { | |
0: binding0, | |
} => { | |
Explainee::View { | |
0: folder.fold_object_name(binding0), | |
} | |
} | |
Explainee::Query { | |
0: binding0, | |
} => { | |
Explainee::Query { | |
0: folder.fold_query(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Expr<T>) -> Expr<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Expr::Identifier { | |
0: binding0, | |
} => { | |
Expr::Identifier { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
Expr::QualifiedWildcard { | |
0: binding0, | |
} => { | |
Expr::QualifiedWildcard { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
Expr::FieldAccess { | |
expr: binding0, | |
field: binding1, | |
} => { | |
Expr::FieldAccess { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
field: folder.fold_ident(binding1), | |
} | |
} | |
Expr::WildcardAccess { | |
0: binding0, | |
} => { | |
Expr::WildcardAccess { | |
0: Box::new(folder.fold_expr(*binding0)), | |
} | |
} | |
Expr::Parameter { | |
0: binding0, | |
} => { | |
Expr::Parameter { | |
0: binding0, | |
} | |
} | |
Expr::Not { | |
expr: binding0, | |
} => { | |
Expr::Not { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
} | |
} | |
Expr::And { | |
left: binding0, | |
right: binding1, | |
} => { | |
Expr::And { | |
left: Box::new(folder.fold_expr(*binding0)), | |
right: Box::new(folder.fold_expr(*binding1)), | |
} | |
} | |
Expr::Or { | |
left: binding0, | |
right: binding1, | |
} => { | |
Expr::Or { | |
left: Box::new(folder.fold_expr(*binding0)), | |
right: Box::new(folder.fold_expr(*binding1)), | |
} | |
} | |
Expr::IsNull { | |
expr: binding0, | |
negated: binding1, | |
} => { | |
Expr::IsNull { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
negated: binding1, | |
} | |
} | |
Expr::InList { | |
expr: binding0, | |
list: binding1, | |
negated: binding2, | |
} => { | |
Expr::InList { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
list: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
negated: binding2, | |
} | |
} | |
Expr::InSubquery { | |
expr: binding0, | |
subquery: binding1, | |
negated: binding2, | |
} => { | |
Expr::InSubquery { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
subquery: Box::new(folder.fold_query(*binding1)), | |
negated: binding2, | |
} | |
} | |
Expr::Between { | |
expr: binding0, | |
negated: binding1, | |
low: binding2, | |
high: binding3, | |
} => { | |
Expr::Between { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
negated: binding1, | |
low: Box::new(folder.fold_expr(*binding2)), | |
high: Box::new(folder.fold_expr(*binding3)), | |
} | |
} | |
Expr::Op { | |
op: binding0, | |
expr1: binding1, | |
expr2: binding2, | |
} => { | |
Expr::Op { | |
op: binding0, | |
expr1: Box::new(folder.fold_expr(*binding1)), | |
expr2: binding2.map(|v| Box::new(folder.fold_expr(*v))), | |
} | |
} | |
Expr::Cast { | |
expr: binding0, | |
data_type: binding1, | |
} => { | |
Expr::Cast { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
data_type: folder.fold_data_type(binding1), | |
} | |
} | |
Expr::Collate { | |
expr: binding0, | |
collation: binding1, | |
} => { | |
Expr::Collate { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
collation: folder.fold_object_name(binding1), | |
} | |
} | |
Expr::Coalesce { | |
exprs: binding0, | |
} => { | |
Expr::Coalesce { | |
exprs: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
Expr::NullIf { | |
l_expr: binding0, | |
r_expr: binding1, | |
} => { | |
Expr::NullIf { | |
l_expr: Box::new(folder.fold_expr(*binding0)), | |
r_expr: Box::new(folder.fold_expr(*binding1)), | |
} | |
} | |
Expr::Nested { | |
0: binding0, | |
} => { | |
Expr::Nested { | |
0: Box::new(folder.fold_expr(*binding0)), | |
} | |
} | |
Expr::Row { | |
exprs: binding0, | |
} => { | |
Expr::Row { | |
exprs: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
Expr::Value { | |
0: binding0, | |
} => { | |
Expr::Value { | |
0: folder.fold_value(binding0), | |
} | |
} | |
Expr::Function { | |
0: binding0, | |
} => { | |
Expr::Function { | |
0: folder.fold_function(binding0), | |
} | |
} | |
Expr::Case { | |
operand: binding0, | |
conditions: binding1, | |
results: binding2, | |
else_result: binding3, | |
} => { | |
Expr::Case { | |
operand: binding0.map(|v| Box::new(folder.fold_expr(*v))), | |
conditions: binding1.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
results: binding2.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
else_result: binding3.map(|v| Box::new(folder.fold_expr(*v))), | |
} | |
} | |
Expr::Exists { | |
0: binding0, | |
} => { | |
Expr::Exists { | |
0: Box::new(folder.fold_query(*binding0)), | |
} | |
} | |
Expr::Subquery { | |
0: binding0, | |
} => { | |
Expr::Subquery { | |
0: Box::new(folder.fold_query(*binding0)), | |
} | |
} | |
Expr::AnySubquery { | |
left: binding0, | |
op: binding1, | |
right: binding2, | |
} => { | |
Expr::AnySubquery { | |
left: Box::new(folder.fold_expr(*binding0)), | |
op: binding1, | |
right: Box::new(folder.fold_query(*binding2)), | |
} | |
} | |
Expr::AnyExpr { | |
left: binding0, | |
op: binding1, | |
right: binding2, | |
} => { | |
Expr::AnyExpr { | |
left: Box::new(folder.fold_expr(*binding0)), | |
op: binding1, | |
right: Box::new(folder.fold_expr(*binding2)), | |
} | |
} | |
Expr::AllSubquery { | |
left: binding0, | |
op: binding1, | |
right: binding2, | |
} => { | |
Expr::AllSubquery { | |
left: Box::new(folder.fold_expr(*binding0)), | |
op: binding1, | |
right: Box::new(folder.fold_query(*binding2)), | |
} | |
} | |
Expr::AllExpr { | |
left: binding0, | |
op: binding1, | |
right: binding2, | |
} => { | |
Expr::AllExpr { | |
left: Box::new(folder.fold_expr(*binding0)), | |
op: binding1, | |
right: Box::new(folder.fold_expr(*binding2)), | |
} | |
} | |
Expr::Array { | |
0: binding0, | |
} => { | |
Expr::Array { | |
0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
Expr::List { | |
0: binding0, | |
} => { | |
Expr::List { | |
0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
Expr::SubscriptIndex { | |
expr: binding0, | |
subscript: binding1, | |
} => { | |
Expr::SubscriptIndex { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
subscript: Box::new(folder.fold_expr(*binding1)), | |
} | |
} | |
Expr::SubscriptSlice { | |
expr: binding0, | |
positions: binding1, | |
} => { | |
Expr::SubscriptSlice { | |
expr: Box::new(folder.fold_expr(*binding0)), | |
positions: binding1.into_iter().map(|v| folder.fold_subscript_position(v)).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_fetch_direction<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchDirection) -> FetchDirection | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
FetchDirection::ForwardAll { | |
} => { | |
FetchDirection::ForwardAll { | |
} | |
} | |
FetchDirection::ForwardCount { | |
0: binding0, | |
} => { | |
FetchDirection::ForwardCount { | |
0: binding0, | |
} | |
} | |
} | |
} | |
pub fn fold_fetch_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FetchStatement) -> FetchStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
FetchStatement { | |
name: folder.fold_ident(node.name), | |
count: node.count.map(|v| folder.fold_fetch_direction(v)), | |
options: node.options.into_iter().map(|v| folder.fold_with_option(v)).collect(), | |
} | |
} | |
pub fn fold_format<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Format) -> Format | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Format::Bytes { | |
} => { | |
Format::Bytes { | |
} | |
} | |
Format::Avro { | |
0: binding0, | |
} => { | |
Format::Avro { | |
0: folder.fold_avro_schema(binding0), | |
} | |
} | |
Format::Protobuf { | |
message_name: binding0, | |
schema: binding1, | |
} => { | |
Format::Protobuf { | |
message_name: binding0, | |
schema: folder.fold_schema(binding1), | |
} | |
} | |
Format::Regex { | |
0: binding0, | |
} => { | |
Format::Regex { | |
0: binding0, | |
} | |
} | |
Format::Csv { | |
header_row: binding0, | |
n_cols: binding1, | |
delimiter: binding2, | |
} => { | |
Format::Csv { | |
header_row: binding0, | |
n_cols: binding1.map(|v| v), | |
delimiter: binding2, | |
} | |
} | |
Format::Json { | |
} => { | |
Format::Json { | |
} | |
} | |
Format::Text { | |
} => { | |
Format::Text { | |
} | |
} | |
} | |
} | |
pub fn fold_function<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Function<T>) -> Function<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Function { | |
name: folder.fold_object_name(node.name), | |
args: folder.fold_function_args(node.args), | |
filter: node.filter.map(|v| Box::new(folder.fold_expr(*v))), | |
over: node.over.map(|v| folder.fold_window_spec(v)), | |
distinct: node.distinct, | |
} | |
} | |
pub fn fold_function_args<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: FunctionArgs<T>) -> FunctionArgs<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
FunctionArgs::Star { | |
} => { | |
FunctionArgs::Star { | |
} | |
} | |
FunctionArgs::Args { | |
0: binding0, | |
} => { | |
FunctionArgs::Args { | |
0: binding0.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
} | |
} | |
} | |
} | |
pub fn fold_ident<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Ident) -> Ident | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Ident { | |
0: node.0, | |
} | |
} | |
pub fn fold_if_exists_behavior<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IfExistsBehavior) -> IfExistsBehavior | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
IfExistsBehavior::Error { | |
} => { | |
IfExistsBehavior::Error { | |
} | |
} | |
IfExistsBehavior::Skip { | |
} => { | |
IfExistsBehavior::Skip { | |
} | |
} | |
IfExistsBehavior::Replace { | |
} => { | |
IfExistsBehavior::Replace { | |
} | |
} | |
} | |
} | |
pub fn fold_insert_source<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertSource<T>) -> InsertSource<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
InsertSource::Query { | |
0: binding0, | |
} => { | |
InsertSource::Query { | |
0: folder.fold_query(binding0), | |
} | |
} | |
InsertSource::DefaultValues { | |
} => { | |
InsertSource::DefaultValues { | |
} | |
} | |
} | |
} | |
pub fn fold_insert_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: InsertStatement<T>) -> InsertStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
InsertStatement { | |
table_name: folder.fold_object_name(node.table_name), | |
columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
source: folder.fold_insert_source(node.source), | |
} | |
} | |
pub fn fold_interval_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: IntervalValue) -> IntervalValue | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
IntervalValue { | |
value: node.value, | |
precision_high: node.precision_high, | |
precision_low: node.precision_low, | |
fsec_max_precision: node.fsec_max_precision.map(|v| v), | |
} | |
} | |
pub fn fold_join<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Join<T>) -> Join<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Join { | |
relation: folder.fold_table_factor(node.relation), | |
join_operator: folder.fold_join_operator(node.join_operator), | |
} | |
} | |
pub fn fold_join_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinConstraint<T>) -> JoinConstraint<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
JoinConstraint::On { | |
0: binding0, | |
} => { | |
JoinConstraint::On { | |
0: folder.fold_expr(binding0), | |
} | |
} | |
JoinConstraint::Using { | |
0: binding0, | |
} => { | |
JoinConstraint::Using { | |
0: binding0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
JoinConstraint::Natural { | |
} => { | |
JoinConstraint::Natural { | |
} | |
} | |
} | |
} | |
pub fn fold_join_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: JoinOperator<T>) -> JoinOperator<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
JoinOperator::Inner { | |
0: binding0, | |
} => { | |
JoinOperator::Inner { | |
0: folder.fold_join_constraint(binding0), | |
} | |
} | |
JoinOperator::LeftOuter { | |
0: binding0, | |
} => { | |
JoinOperator::LeftOuter { | |
0: folder.fold_join_constraint(binding0), | |
} | |
} | |
JoinOperator::RightOuter { | |
0: binding0, | |
} => { | |
JoinOperator::RightOuter { | |
0: folder.fold_join_constraint(binding0), | |
} | |
} | |
JoinOperator::FullOuter { | |
0: binding0, | |
} => { | |
JoinOperator::FullOuter { | |
0: folder.fold_join_constraint(binding0), | |
} | |
} | |
JoinOperator::CrossJoin { | |
} => { | |
JoinOperator::CrossJoin { | |
} | |
} | |
} | |
} | |
pub fn fold_limit<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Limit<T>) -> Limit<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Limit { | |
with_ties: node.with_ties, | |
quantity: folder.fold_expr(node.quantity), | |
} | |
} | |
pub fn fold_object_name<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ObjectName) -> ObjectName | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ObjectName { | |
0: node.0.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
pub fn fold_object_type<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ObjectType) -> ObjectType | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
ObjectType::Schema { | |
} => { | |
ObjectType::Schema { | |
} | |
} | |
ObjectType::Table { | |
} => { | |
ObjectType::Table { | |
} | |
} | |
ObjectType::View { | |
} => { | |
ObjectType::View { | |
} | |
} | |
ObjectType::Source { | |
} => { | |
ObjectType::Source { | |
} | |
} | |
ObjectType::Sink { | |
} => { | |
ObjectType::Sink { | |
} | |
} | |
ObjectType::Index { | |
} => { | |
ObjectType::Index { | |
} | |
} | |
ObjectType::Type { | |
} => { | |
ObjectType::Type { | |
} | |
} | |
ObjectType::Role { | |
} => { | |
ObjectType::Role { | |
} | |
} | |
ObjectType::Object { | |
} => { | |
ObjectType::Object { | |
} | |
} | |
} | |
} | |
pub fn fold_order_by_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: OrderByExpr<T>) -> OrderByExpr<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
OrderByExpr { | |
expr: folder.fold_expr(node.expr), | |
asc: node.asc.map(|v| v), | |
} | |
} | |
pub fn fold_query<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Query<T>) -> Query<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Query { | |
ctes: node.ctes.into_iter().map(|v| folder.fold_cte(v)).collect(), | |
body: folder.fold_set_expr(node.body), | |
order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(), | |
limit: node.limit.map(|v| folder.fold_limit(v)), | |
offset: node.offset.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_raw<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Raw) -> Raw | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Raw { | |
} | |
} | |
pub fn fold_rollback_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: RollbackStatement) -> RollbackStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
RollbackStatement { | |
chain: node.chain, | |
} | |
} | |
pub fn fold_s3_key_source<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: S3KeySource) -> S3KeySource | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
S3KeySource::Scan { | |
bucket: binding0, | |
} => { | |
S3KeySource::Scan { | |
bucket: binding0, | |
} | |
} | |
} | |
} | |
pub fn fold_schema<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Schema) -> Schema | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Schema::File { | |
0: binding0, | |
} => { | |
Schema::File { | |
0: binding0, | |
} | |
} | |
Schema::Inline { | |
0: binding0, | |
} => { | |
Schema::Inline { | |
0: binding0, | |
} | |
} | |
} | |
} | |
pub fn fold_select<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Select<T>) -> Select<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Select { | |
distinct: node.distinct.map(|v| folder.fold_distinct(v)), | |
projection: node.projection.into_iter().map(|v| folder.fold_select_item(v)).collect(), | |
from: node.from.into_iter().map(|v| folder.fold_table_with_joins(v)).collect(), | |
selection: node.selection.map(|v| folder.fold_expr(v)), | |
group_by: node.group_by.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
having: node.having.map(|v| folder.fold_expr(v)), | |
options: node.options.into_iter().map(|v| folder.fold_sql_option(v)).collect(), | |
} | |
} | |
pub fn fold_select_item<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectItem<T>) -> SelectItem<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
SelectItem::Expr { | |
expr: binding0, | |
alias: binding1, | |
} => { | |
SelectItem::Expr { | |
expr: folder.fold_expr(binding0), | |
alias: binding1.map(|v| folder.fold_ident(v)), | |
} | |
} | |
SelectItem::Wildcard { | |
} => { | |
SelectItem::Wildcard { | |
} | |
} | |
} | |
} | |
pub fn fold_select_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SelectStatement<T>) -> SelectStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
SelectStatement { | |
query: folder.fold_query(node.query), | |
as_of: node.as_of.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_set_expr<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetExpr<T>) -> SetExpr<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
SetExpr::Select { | |
0: binding0, | |
} => { | |
SetExpr::Select { | |
0: Box::new(folder.fold_select(*binding0)), | |
} | |
} | |
SetExpr::Query { | |
0: binding0, | |
} => { | |
SetExpr::Query { | |
0: Box::new(folder.fold_query(*binding0)), | |
} | |
} | |
SetExpr::SetOperation { | |
op: binding0, | |
all: binding1, | |
left: binding2, | |
right: binding3, | |
} => { | |
SetExpr::SetOperation { | |
op: folder.fold_set_operator(binding0), | |
all: binding1, | |
left: Box::new(folder.fold_set_expr(*binding2)), | |
right: Box::new(folder.fold_set_expr(*binding3)), | |
} | |
} | |
SetExpr::Values { | |
0: binding0, | |
} => { | |
SetExpr::Values { | |
0: folder.fold_values(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_set_operator<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetOperator) -> SetOperator | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
SetOperator::Union { | |
} => { | |
SetOperator::Union { | |
} | |
} | |
SetOperator::Except { | |
} => { | |
SetOperator::Except { | |
} | |
} | |
SetOperator::Intersect { | |
} => { | |
SetOperator::Intersect { | |
} | |
} | |
} | |
} | |
pub fn fold_set_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetTransactionStatement) -> SetTransactionStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
SetTransactionStatement { | |
modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(), | |
} | |
} | |
pub fn fold_set_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableStatement) -> SetVariableStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
SetVariableStatement { | |
local: node.local, | |
variable: folder.fold_ident(node.variable), | |
value: folder.fold_set_variable_value(node.value), | |
} | |
} | |
pub fn fold_set_variable_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SetVariableValue) -> SetVariableValue | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
SetVariableValue::Ident { | |
0: binding0, | |
} => { | |
SetVariableValue::Ident { | |
0: folder.fold_ident(binding0), | |
} | |
} | |
SetVariableValue::Literal { | |
0: binding0, | |
} => { | |
SetVariableValue::Literal { | |
0: folder.fold_value(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_show_columns_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowColumnsStatement<T>) -> ShowColumnsStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowColumnsStatement { | |
extended: node.extended, | |
full: node.full, | |
table_name: folder.fold_object_name(node.table_name), | |
filter: node.filter.map(|v| folder.fold_show_statement_filter(v)), | |
} | |
} | |
pub fn fold_show_create_index_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateIndexStatement) -> ShowCreateIndexStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowCreateIndexStatement { | |
index_name: folder.fold_object_name(node.index_name), | |
} | |
} | |
pub fn fold_show_create_sink_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSinkStatement) -> ShowCreateSinkStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowCreateSinkStatement { | |
sink_name: folder.fold_object_name(node.sink_name), | |
} | |
} | |
pub fn fold_show_create_source_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateSourceStatement) -> ShowCreateSourceStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowCreateSourceStatement { | |
source_name: folder.fold_object_name(node.source_name), | |
} | |
} | |
pub fn fold_show_create_table_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateTableStatement) -> ShowCreateTableStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowCreateTableStatement { | |
table_name: folder.fold_object_name(node.table_name), | |
} | |
} | |
pub fn fold_show_create_view_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowCreateViewStatement) -> ShowCreateViewStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowCreateViewStatement { | |
view_name: folder.fold_object_name(node.view_name), | |
} | |
} | |
pub fn fold_show_databases_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowDatabasesStatement<T>) -> ShowDatabasesStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowDatabasesStatement { | |
filter: node.filter.map(|v| folder.fold_show_statement_filter(v)), | |
} | |
} | |
pub fn fold_show_indexes_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowIndexesStatement<T>) -> ShowIndexesStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowIndexesStatement { | |
table_name: folder.fold_object_name(node.table_name), | |
extended: node.extended, | |
filter: node.filter.map(|v| folder.fold_show_statement_filter(v)), | |
} | |
} | |
pub fn fold_show_objects_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowObjectsStatement<T>) -> ShowObjectsStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowObjectsStatement { | |
object_type: folder.fold_object_type(node.object_type), | |
from: node.from.map(|v| folder.fold_object_name(v)), | |
extended: node.extended, | |
full: node.full, | |
materialized: node.materialized, | |
filter: node.filter.map(|v| folder.fold_show_statement_filter(v)), | |
} | |
} | |
pub fn fold_show_statement_filter<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowStatementFilter<T>) -> ShowStatementFilter<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
ShowStatementFilter::Like { | |
0: binding0, | |
} => { | |
ShowStatementFilter::Like { | |
0: binding0, | |
} | |
} | |
ShowStatementFilter::Where { | |
0: binding0, | |
} => { | |
ShowStatementFilter::Where { | |
0: folder.fold_expr(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_show_variable_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ShowVariableStatement) -> ShowVariableStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ShowVariableStatement { | |
variable: folder.fold_ident(node.variable), | |
} | |
} | |
pub fn fold_sql_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SqlOption) -> SqlOption | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
SqlOption::Value { | |
name: binding0, | |
value: binding1, | |
} => { | |
SqlOption::Value { | |
name: folder.fold_ident(binding0), | |
value: folder.fold_value(binding1), | |
} | |
} | |
SqlOption::ObjectName { | |
name: binding0, | |
object_name: binding1, | |
} => { | |
SqlOption::ObjectName { | |
name: folder.fold_ident(binding0), | |
object_name: folder.fold_object_name(binding1), | |
} | |
} | |
SqlOption::DataType { | |
name: binding0, | |
data_type: binding1, | |
} => { | |
SqlOption::DataType { | |
name: folder.fold_ident(binding0), | |
data_type: folder.fold_data_type(binding1), | |
} | |
} | |
} | |
} | |
pub fn fold_start_transaction_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: StartTransactionStatement) -> StartTransactionStatement | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
StartTransactionStatement { | |
modes: node.modes.into_iter().map(|v| folder.fold_transaction_mode(v)).collect(), | |
} | |
} | |
pub fn fold_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Statement<T>) -> Statement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Statement::Select { | |
0: binding0, | |
} => { | |
Statement::Select { | |
0: folder.fold_select_statement(binding0), | |
} | |
} | |
Statement::Insert { | |
0: binding0, | |
} => { | |
Statement::Insert { | |
0: folder.fold_insert_statement(binding0), | |
} | |
} | |
Statement::Copy { | |
0: binding0, | |
} => { | |
Statement::Copy { | |
0: folder.fold_copy_statement(binding0), | |
} | |
} | |
Statement::Update { | |
0: binding0, | |
} => { | |
Statement::Update { | |
0: folder.fold_update_statement(binding0), | |
} | |
} | |
Statement::Delete { | |
0: binding0, | |
} => { | |
Statement::Delete { | |
0: folder.fold_delete_statement(binding0), | |
} | |
} | |
Statement::CreateDatabase { | |
0: binding0, | |
} => { | |
Statement::CreateDatabase { | |
0: folder.fold_create_database_statement(binding0), | |
} | |
} | |
Statement::CreateSchema { | |
0: binding0, | |
} => { | |
Statement::CreateSchema { | |
0: folder.fold_create_schema_statement(binding0), | |
} | |
} | |
Statement::CreateSource { | |
0: binding0, | |
} => { | |
Statement::CreateSource { | |
0: folder.fold_create_source_statement(binding0), | |
} | |
} | |
Statement::CreateSink { | |
0: binding0, | |
} => { | |
Statement::CreateSink { | |
0: folder.fold_create_sink_statement(binding0), | |
} | |
} | |
Statement::CreateView { | |
0: binding0, | |
} => { | |
Statement::CreateView { | |
0: folder.fold_create_view_statement(binding0), | |
} | |
} | |
Statement::CreateTable { | |
0: binding0, | |
} => { | |
Statement::CreateTable { | |
0: folder.fold_create_table_statement(binding0), | |
} | |
} | |
Statement::CreateIndex { | |
0: binding0, | |
} => { | |
Statement::CreateIndex { | |
0: folder.fold_create_index_statement(binding0), | |
} | |
} | |
Statement::CreateType { | |
0: binding0, | |
} => { | |
Statement::CreateType { | |
0: folder.fold_create_type_statement(binding0), | |
} | |
} | |
Statement::CreateRole { | |
0: binding0, | |
} => { | |
Statement::CreateRole { | |
0: folder.fold_create_role_statement(binding0), | |
} | |
} | |
Statement::AlterObjectRename { | |
0: binding0, | |
} => { | |
Statement::AlterObjectRename { | |
0: folder.fold_alter_object_rename_statement(binding0), | |
} | |
} | |
Statement::AlterIndexOptions { | |
0: binding0, | |
} => { | |
Statement::AlterIndexOptions { | |
0: folder.fold_alter_index_options_statement(binding0), | |
} | |
} | |
Statement::Discard { | |
0: binding0, | |
} => { | |
Statement::Discard { | |
0: folder.fold_discard_statement(binding0), | |
} | |
} | |
Statement::DropDatabase { | |
0: binding0, | |
} => { | |
Statement::DropDatabase { | |
0: folder.fold_drop_database_statement(binding0), | |
} | |
} | |
Statement::DropObjects { | |
0: binding0, | |
} => { | |
Statement::DropObjects { | |
0: folder.fold_drop_objects_statement(binding0), | |
} | |
} | |
Statement::SetVariable { | |
0: binding0, | |
} => { | |
Statement::SetVariable { | |
0: folder.fold_set_variable_statement(binding0), | |
} | |
} | |
Statement::ShowDatabases { | |
0: binding0, | |
} => { | |
Statement::ShowDatabases { | |
0: folder.fold_show_databases_statement(binding0), | |
} | |
} | |
Statement::ShowObjects { | |
0: binding0, | |
} => { | |
Statement::ShowObjects { | |
0: folder.fold_show_objects_statement(binding0), | |
} | |
} | |
Statement::ShowIndexes { | |
0: binding0, | |
} => { | |
Statement::ShowIndexes { | |
0: folder.fold_show_indexes_statement(binding0), | |
} | |
} | |
Statement::ShowColumns { | |
0: binding0, | |
} => { | |
Statement::ShowColumns { | |
0: folder.fold_show_columns_statement(binding0), | |
} | |
} | |
Statement::ShowCreateView { | |
0: binding0, | |
} => { | |
Statement::ShowCreateView { | |
0: folder.fold_show_create_view_statement(binding0), | |
} | |
} | |
Statement::ShowCreateSource { | |
0: binding0, | |
} => { | |
Statement::ShowCreateSource { | |
0: folder.fold_show_create_source_statement(binding0), | |
} | |
} | |
Statement::ShowCreateTable { | |
0: binding0, | |
} => { | |
Statement::ShowCreateTable { | |
0: folder.fold_show_create_table_statement(binding0), | |
} | |
} | |
Statement::ShowCreateSink { | |
0: binding0, | |
} => { | |
Statement::ShowCreateSink { | |
0: folder.fold_show_create_sink_statement(binding0), | |
} | |
} | |
Statement::ShowCreateIndex { | |
0: binding0, | |
} => { | |
Statement::ShowCreateIndex { | |
0: folder.fold_show_create_index_statement(binding0), | |
} | |
} | |
Statement::ShowVariable { | |
0: binding0, | |
} => { | |
Statement::ShowVariable { | |
0: folder.fold_show_variable_statement(binding0), | |
} | |
} | |
Statement::StartTransaction { | |
0: binding0, | |
} => { | |
Statement::StartTransaction { | |
0: folder.fold_start_transaction_statement(binding0), | |
} | |
} | |
Statement::SetTransaction { | |
0: binding0, | |
} => { | |
Statement::SetTransaction { | |
0: folder.fold_set_transaction_statement(binding0), | |
} | |
} | |
Statement::Commit { | |
0: binding0, | |
} => { | |
Statement::Commit { | |
0: folder.fold_commit_statement(binding0), | |
} | |
} | |
Statement::Rollback { | |
0: binding0, | |
} => { | |
Statement::Rollback { | |
0: folder.fold_rollback_statement(binding0), | |
} | |
} | |
Statement::Tail { | |
0: binding0, | |
} => { | |
Statement::Tail { | |
0: folder.fold_tail_statement(binding0), | |
} | |
} | |
Statement::Explain { | |
0: binding0, | |
} => { | |
Statement::Explain { | |
0: folder.fold_explain_statement(binding0), | |
} | |
} | |
Statement::Declare { | |
0: binding0, | |
} => { | |
Statement::Declare { | |
0: folder.fold_declare_statement(binding0), | |
} | |
} | |
Statement::Fetch { | |
0: binding0, | |
} => { | |
Statement::Fetch { | |
0: folder.fold_fetch_statement(binding0), | |
} | |
} | |
Statement::Close { | |
0: binding0, | |
} => { | |
Statement::Close { | |
0: folder.fold_close_statement(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_subscript_position<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: SubscriptPosition<T>) -> SubscriptPosition<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
SubscriptPosition { | |
start: node.start.map(|v| folder.fold_expr(v)), | |
end: node.end.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_table_alias<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableAlias) -> TableAlias | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
TableAlias { | |
name: folder.fold_ident(node.name), | |
columns: node.columns.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
strict: node.strict, | |
} | |
} | |
pub fn fold_table_constraint<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableConstraint<T>) -> TableConstraint<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
TableConstraint::Unique { | |
name: binding0, | |
columns: binding1, | |
is_primary: binding2, | |
} => { | |
TableConstraint::Unique { | |
name: binding0.map(|v| folder.fold_ident(v)), | |
columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
is_primary: binding2, | |
} | |
} | |
TableConstraint::ForeignKey { | |
name: binding0, | |
columns: binding1, | |
foreign_table: binding2, | |
referred_columns: binding3, | |
} => { | |
TableConstraint::ForeignKey { | |
name: binding0.map(|v| folder.fold_ident(v)), | |
columns: binding1.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
foreign_table: folder.fold_object_name(binding2), | |
referred_columns: binding3.into_iter().map(|v| folder.fold_ident(v)).collect(), | |
} | |
} | |
TableConstraint::Check { | |
name: binding0, | |
expr: binding1, | |
} => { | |
TableConstraint::Check { | |
name: binding0.map(|v| folder.fold_ident(v)), | |
expr: Box::new(folder.fold_expr(*binding1)), | |
} | |
} | |
} | |
} | |
pub fn fold_table_factor<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableFactor<T>) -> TableFactor<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
TableFactor::Table { | |
name: binding0, | |
alias: binding1, | |
} => { | |
TableFactor::Table { | |
name: folder.fold_table(binding0), | |
alias: binding1.map(|v| folder.fold_table_alias(v)), | |
} | |
} | |
TableFactor::Function { | |
name: binding0, | |
args: binding1, | |
alias: binding2, | |
} => { | |
TableFactor::Function { | |
name: folder.fold_object_name(binding0), | |
args: folder.fold_function_args(binding1), | |
alias: binding2.map(|v| folder.fold_table_alias(v)), | |
} | |
} | |
TableFactor::Derived { | |
lateral: binding0, | |
subquery: binding1, | |
alias: binding2, | |
} => { | |
TableFactor::Derived { | |
lateral: binding0, | |
subquery: Box::new(folder.fold_query(*binding1)), | |
alias: binding2.map(|v| folder.fold_table_alias(v)), | |
} | |
} | |
TableFactor::NestedJoin { | |
join: binding0, | |
alias: binding1, | |
} => { | |
TableFactor::NestedJoin { | |
join: Box::new(folder.fold_table_with_joins(*binding0)), | |
alias: binding1.map(|v| folder.fold_table_alias(v)), | |
} | |
} | |
} | |
} | |
pub fn fold_table_with_joins<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TableWithJoins<T>) -> TableWithJoins<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
TableWithJoins { | |
relation: folder.fold_table_factor(node.relation), | |
joins: node.joins.into_iter().map(|v| folder.fold_join(v)).collect(), | |
} | |
} | |
pub fn fold_tail_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TailStatement<T>) -> TailStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
TailStatement { | |
name: folder.fold_object_name(node.name), | |
options: node.options.into_iter().map(|v| folder.fold_with_option(v)).collect(), | |
as_of: node.as_of.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_transaction_access_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionAccessMode) -> TransactionAccessMode | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
TransactionAccessMode::ReadOnly { | |
} => { | |
TransactionAccessMode::ReadOnly { | |
} | |
} | |
TransactionAccessMode::ReadWrite { | |
} => { | |
TransactionAccessMode::ReadWrite { | |
} | |
} | |
} | |
} | |
pub fn fold_transaction_isolation_level<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionIsolationLevel) -> TransactionIsolationLevel | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
TransactionIsolationLevel::ReadUncommitted { | |
} => { | |
TransactionIsolationLevel::ReadUncommitted { | |
} | |
} | |
TransactionIsolationLevel::ReadCommitted { | |
} => { | |
TransactionIsolationLevel::ReadCommitted { | |
} | |
} | |
TransactionIsolationLevel::RepeatableRead { | |
} => { | |
TransactionIsolationLevel::RepeatableRead { | |
} | |
} | |
TransactionIsolationLevel::Serializable { | |
} => { | |
TransactionIsolationLevel::Serializable { | |
} | |
} | |
} | |
} | |
pub fn fold_transaction_mode<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: TransactionMode) -> TransactionMode | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
TransactionMode::AccessMode { | |
0: binding0, | |
} => { | |
TransactionMode::AccessMode { | |
0: folder.fold_transaction_access_mode(binding0), | |
} | |
} | |
TransactionMode::IsolationLevel { | |
0: binding0, | |
} => { | |
TransactionMode::IsolationLevel { | |
0: folder.fold_transaction_isolation_level(binding0), | |
} | |
} | |
} | |
} | |
pub fn fold_update_statement<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: UpdateStatement<T>) -> UpdateStatement<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
UpdateStatement { | |
table_name: folder.fold_object_name(node.table_name), | |
assignments: node.assignments.into_iter().map(|v| folder.fold_assignment(v)).collect(), | |
selection: node.selection.map(|v| folder.fold_expr(v)), | |
} | |
} | |
pub fn fold_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Value) -> Value | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
Value::Number { | |
0: binding0, | |
} => { | |
Value::Number { | |
0: binding0, | |
} | |
} | |
Value::String { | |
0: binding0, | |
} => { | |
Value::String { | |
0: binding0, | |
} | |
} | |
Value::HexString { | |
0: binding0, | |
} => { | |
Value::HexString { | |
0: binding0, | |
} | |
} | |
Value::Boolean { | |
0: binding0, | |
} => { | |
Value::Boolean { | |
0: binding0, | |
} | |
} | |
Value::Interval { | |
0: binding0, | |
} => { | |
Value::Interval { | |
0: folder.fold_interval_value(binding0), | |
} | |
} | |
Value::Null { | |
} => { | |
Value::Null { | |
} | |
} | |
} | |
} | |
pub fn fold_value_error<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: ValueError) -> ValueError | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
ValueError { | |
0: node.0, | |
} | |
} | |
pub fn fold_values<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: Values<T>) -> Values<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
Values { | |
0: node.0.into_iter().map(|v| v.into_iter().map(|v| folder.fold_expr(v)).collect()).collect(), | |
} | |
} | |
pub fn fold_window_frame<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrame) -> WindowFrame | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
WindowFrame { | |
units: folder.fold_window_frame_units(node.units), | |
start_bound: folder.fold_window_frame_bound(node.start_bound), | |
end_bound: node.end_bound.map(|v| folder.fold_window_frame_bound(v)), | |
} | |
} | |
pub fn fold_window_frame_bound<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameBound) -> WindowFrameBound | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
WindowFrameBound::CurrentRow { | |
} => { | |
WindowFrameBound::CurrentRow { | |
} | |
} | |
WindowFrameBound::Preceding { | |
0: binding0, | |
} => { | |
WindowFrameBound::Preceding { | |
0: binding0.map(|v| v), | |
} | |
} | |
WindowFrameBound::Following { | |
0: binding0, | |
} => { | |
WindowFrameBound::Following { | |
0: binding0.map(|v| v), | |
} | |
} | |
} | |
} | |
pub fn fold_window_frame_units<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowFrameUnits) -> WindowFrameUnits | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
WindowFrameUnits::Rows { | |
} => { | |
WindowFrameUnits::Rows { | |
} | |
} | |
WindowFrameUnits::Range { | |
} => { | |
WindowFrameUnits::Range { | |
} | |
} | |
WindowFrameUnits::Groups { | |
} => { | |
WindowFrameUnits::Groups { | |
} | |
} | |
} | |
} | |
pub fn fold_window_spec<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WindowSpec<T>) -> WindowSpec<T2> | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
WindowSpec { | |
partition_by: node.partition_by.into_iter().map(|v| folder.fold_expr(v)).collect(), | |
order_by: node.order_by.into_iter().map(|v| folder.fold_order_by_expr(v)).collect(), | |
window_frame: node.window_frame.map(|v| folder.fold_window_frame(v)), | |
} | |
} | |
pub fn fold_with_option<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WithOption) -> WithOption | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
WithOption { | |
key: folder.fold_ident(node.key), | |
value: node.value.map(|v| folder.fold_with_option_value(v)), | |
} | |
} | |
pub fn fold_with_option_value<F, T: AstInfo, T2: AstInfo, >(folder: &mut F, node: WithOptionValue) -> WithOptionValue | |
where | |
F: Fold<T, T2, > + ?Sized, | |
{ | |
match node { | |
WithOptionValue::Value { | |
0: binding0, | |
} => { | |
WithOptionValue::Value { | |
0: folder.fold_value(binding0), | |
} | |
} | |
WithOptionValue::ObjectName { | |
0: binding0, | |
} => { | |
WithOptionValue::ObjectName { | |
0: folder.fold_object_name(binding0), | |
} | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment