Method fold_table_factor

src/sql/src/names.rs:2166–2224

(
        &mut self,
        node: mz_sql_parser::ast::TableFactor<Raw>,
    )

    }

    fn fold_table_factor(
        &mut self,
        node: mz_sql_parser::ast::TableFactor<Raw>,
    ) -> mz_sql_parser::ast::TableFactor<Aug> {
        use mz_sql_parser::ast::TableFactor::*;
        match node {
            Table { name, alias } => Table {
                name: self.fold_item_name(name),
                alias: alias.map(|alias| self.fold_table_alias(alias)),
            },
            Function {
                function,
                alias,
                with_ordinality,
            } => {
                match &function.name {
                    RawItemName::Name(name) => {
                        if *name == UnresolvedItemName::unqualified(ident!("values"))
                            && self.status.is_ok()
                        {
                            self.status = Err(PlanError::FromValueRequiresParen);
                        }
                    }
                    RawItemName::Id(..) => {}
                }

                Function {
                    function: self.fold_function(function),
                    alias: alias.map(|alias| self.fold_table_alias(alias)),
                    with_ordinality,
                }
            }
            RowsFrom {
                functions,
                alias,
                with_ordinality,
            } => RowsFrom {
                functions: functions
                    .into_iter()
                    .map(|f| self.fold_function(f))
                    .collect(),
                alias: alias.map(|alias| self.fold_table_alias(alias)),
                with_ordinality,
            },
            Derived {
                lateral,
                subquery,
                alias,
            } => Derived {
                lateral,
                subquery: Box::new(self.fold_query(*subquery)),
                alias: alias.map(|alias| self.fold_table_alias(alias)),
            },
            NestedJoin { join, alias } => NestedJoin {
                join: Box::new(self.fold_table_with_joins(*join)),
                alias: alias.map(|alias| self.fold_table_alias(alias)),
            },
        }