Method fold_column_name

src/sql/src/names.rs:1766–1840

(&mut self, column_name: ast::ColumnName<Raw>)

    }

    fn fold_column_name(&mut self, column_name: ast::ColumnName<Raw>) -> ast::ColumnName<Aug> {
        let item_name = self.resolve_item_name(
            column_name.relation,
            ItemResolutionConfig {
                functions: false,
                types: true,
                relations: true,
            },
        );

        match &item_name {
            ResolvedItemName::Item {
                id,
                full_name,
                version,
                qualifiers: _,
                print_id: _,
            } => {
                let item = self.catalog.get_item(id).at_version(*version);
                let name = normalize::column_name(column_name.column.clone());

                let maybe_desc = match item.type_details() {
                    Some(details) => match details.typ.desc(self.catalog) {
                        Ok(desc) => desc.map(Cow::Owned),
                        Err(e) => {
                            if self.status.is_ok() {
                                self.status = Err(e);
                            }
                            return ast::ColumnName {
                                relation: ResolvedItemName::Error,
                                column: ResolvedColumnReference::Error,
                            };
                        }
                    },
                    None => item.relation_desc(),
                };
                let Some(desc) = maybe_desc else {
                    if self.status.is_ok() {
                        self.status = Err(PlanError::ItemWithoutColumns {
                            name: full_name.to_string(),
                            item_type: item.item_type(),
                        });
                    }
                    return ast::ColumnName {
                        relation: ResolvedItemName::Error,
                        column: ResolvedColumnReference::Error,
                    };
                };

                let Some((index, _typ)) = desc.get_by_name(&name) else {
                    if self.status.is_ok() {
                        let similar = desc.iter_similar_names(&name).cloned().collect();
                        self.status = Err(PlanError::UnknownColumn {
                            table: Some(full_name.clone().into()),
                            column: name,
                            similar,
                        })
                    }