Skip to content

Instantly share code, notes, and snippets.

@benesch

benesch/00-shell-session.txt

Last active February 10, 2021 18:57
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save benesch/0af1628ad590a4e7326d67e4ebd29a86 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save benesch/0af1628ad590a4e7326d67e4ebd29a86 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
00-shell-session.txt
[~/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
Raw
fold.rs
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