Method resolve_type

src/sql/src/plan/statement.rs:845–881

(&self, mut ty: mz_pgrepr::Type)

    }

    pub fn resolve_type(&self, mut ty: mz_pgrepr::Type) -> Result<ResolvedDataType, PlanError> {
        // Ignore precision constraints on date/time types until we support
        // it. This should be safe enough because our types are wide enough
        // to support the maximum possible precision.
        //
        // See: https://github.com/MaterializeInc/database-issues/issues/3179
        match &mut ty {
            mz_pgrepr::Type::Interval { constraints } => *constraints = None,
            mz_pgrepr::Type::Time { precision } => *precision = None,
            mz_pgrepr::Type::TimeTz { precision } => *precision = None,
            mz_pgrepr::Type::Timestamp { precision } => *precision = None,
            mz_pgrepr::Type::TimestampTz { precision } => *precision = None,
            _ => (),
        }
        // NOTE(benesch): this *looks* gross, but it is
        // safe enough. The `fmt::Display`
        // representation on `pgrepr::Type` promises to
        // produce an unqualified type name that does
        // not require quoting.
        let mut ty = if ty.oid() >= FIRST_USER_OID {
            sql_bail!("internal error, unexpected user type: {ty:?} ");
        } else if ty.oid() < FIRST_MATERIALIZE_OID {
            format!("pg_catalog.{}", ty)
        } else {
            // This relies on all non-PG types existing in `mz_catalog`, which is annoying.
            format!("mz_catalog.{}", ty)
        };
        // TODO(benesch): converting `json` to `jsonb`
        // is wrong. We ought to support the `json` type
        // directly.
        if ty == "pg_catalog.json" {
            ty = "pg_catalog.jsonb".into();
        }
        let data_type = mz_sql_parser::parser::parse_data_type(&ty)?;
        let (data_type, _) = names::resolve(self.catalog, data_type)?;
        Ok(data_type)
    }

    pub fn get_object_type(&self, id: &ObjectId) -> ObjectType {
        self.catalog.get_object_type(id)