Merge pull request #33 from hasura/kc/remove-composite-types-code

Remove all the composite types code

Cargo.toml

@@ -54,7 +54,7 @@ nonempty = "0.10"
 percent-encoding = "2"
 prometheus = "0.13"
 ref-cast = "1"
-reqwest = "0.11"
+reqwest = { version = "0.11", default-features = false }
 schemars = "0.8"
 serde = "1"
 serde_derive = "^1.0"

crates/configuration/src/to_runtime_configuration.rs

@@ -172,7 +172,6 @@ fn convert_nullable(nullable: &metadata::Nullable) -> query_engine_metadata::met
 fn convert_type(r#type: metadata::Type) -> query_engine_metadata::metadata::Type {
     match r#type {
         metadata::Type::ScalarType(t) => query_engine_metadata::metadata::Type::ScalarType(t),
-        metadata::Type::CompositeType(t) => query_engine_metadata::metadata::Type::CompositeType(t),
         metadata::Type::ArrayType(t) => {
             query_engine_metadata::metadata::Type::ArrayType(Box::new(convert_type(*t)))
         }

crates/connectors/ndc-bigquery/Cargo.toml

@@ -47,6 +47,6 @@ axum-test-helper = { workspace = true }
 insta = { workspace = true, features = ["json"] }
 env_logger = { workspace = true }
 hyper = { workspace = true, features = ["tcp"] }
-reqwest = { workspace = true, default-features = false, features = ["rustls-tls"] }
+reqwest = { workspace = true, features = ["rustls-tls"] }
 similar-asserts = { workspace = true }
 url = { workspace = true }

crates/connectors/ndc-bigquery/src/schema.rs

@@ -250,6 +250,5 @@ pub fn type_to_type(typ: &metadata::Type) -> models::Type {
         metadata::Type::ScalarType(scalar_type) => models::Type::Named {
             name: scalar_type.as_str().into(),
         },
-        metadata::Type::CompositeType(t) => models::Type::Named { name: t.clone() },
     }
 }

crates/query-engine/metadata/src/metadata/database.rs

@@ -16,7 +16,6 @@ pub struct ScalarTypeTypeName(pub String);
 #[serde(rename_all = "camelCase")]
 pub enum Type {
     ScalarType(models::ScalarTypeName),
-    CompositeType(models::TypeName),
     ArrayType(Box<Type>),
 }
 
@@ -44,27 +43,6 @@ pub struct ScalarType {
     pub type_representation: Option<TypeRepresentation>,
 }
 
-/// Map of all known composite types.
-#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CompositeTypes(pub BTreeMap<models::TypeName, CompositeType>);
-
-impl CompositeTypes {
-    pub fn empty() -> Self {
-        CompositeTypes(BTreeMap::new())
-    }
-}
-
-/// Information about a composite type. These are very similar to tables, but with the crucial
-/// difference that composite types do not support constraints (such as NOT NULL).
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-pub struct CompositeType {
-    pub type_name: String,
-    pub schema_name: Option<String>,
-    pub fields: BTreeMap<models::FieldName, FieldInfo>,
-    pub description: Option<String>,
-}
-
 /// The complete list of supported binary operators for scalar types.
 /// Not all of these are supported for every type.
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize, JsonSchema)]

crates/query-engine/sql/src/sql/ast.rs

@@ -107,8 +107,6 @@ pub enum SelectList {
     SelectStar,
     SelectStarFrom(TableReference),
     Select1,
-    SelectStarComposite(Expression),
-    SelectListComposite(Box<SelectList>, Box<SelectList>),
 }
 
 /// A FROM clause

crates/query-engine/sql/src/sql/convert.rs

@@ -99,19 +99,9 @@ impl SelectList {
                 table_reference.to_sql(sql);
                 sql.append_syntax(".*");
             }
-            SelectList::SelectStarComposite(expr) => {
-                sql.append_syntax("(");
-                expr.to_sql(sql);
-                sql.append_syntax(").*");
-            }
             SelectList::Select1 => {
                 sql.append_syntax("1");
             }
-            SelectList::SelectListComposite(select_list1, select_list2) => {
-                select_list1.to_sql(sql);
-                sql.append_syntax(", ");
-                select_list2.to_sql(sql);
-            }
         }
     }
 }

crates/query-engine/sql/src/sql/helpers.rs

@@ -79,20 +79,6 @@ pub fn make_column_alias(name: String) -> ColumnAlias {
 
 // SELECTs //
 
-/// Build a simple 'SELECT (exp).*'
-pub fn select_composite(exp: Expression) -> Select {
-    Select {
-        with: empty_with(),
-        select_list: SelectList::SelectStarComposite(exp),
-        from: None,
-        joins: vec![],
-        where_: Where(empty_where()),
-        group_by: empty_group_by(),
-        order_by: empty_order_by(),
-        limit: empty_limit(),
-    }
-}
-
 /// Build a simple select with a select list and the rest are empty.
 pub fn simple_select(select_list: Vec<(ColumnAlias, Expression)>) -> Select {
     Select {

crates/query-engine/sql/src/sql/rewrites/constant_folding.rs

@@ -40,18 +40,9 @@ pub fn normalize_select(mut select: Select) -> Select {
 /// Normalize all expressions in a select list.
 pub fn normalize_select_list(select_list: SelectList) -> SelectList {
     match select_list {
-        SelectList::SelectListComposite(select_list1, select_list2) => {
-            SelectList::SelectListComposite(
-                Box::new(normalize_select_list(*select_list1)),
-                Box::new(normalize_select_list(*select_list2)),
-            )
-        }
         SelectList::SelectStar => SelectList::SelectStar,
         SelectList::SelectStarFrom(table) => SelectList::SelectStarFrom(table),
         SelectList::Select1 => SelectList::Select1,
-        SelectList::SelectStarComposite(exp) => {
-            SelectList::SelectStarComposite(normalize_expr(exp))
-        }
         SelectList::SelectList(vec) => SelectList::SelectList(
             vec.into_iter()
                 .map(|(alias, expr)| (alias, normalize_expr(expr)))

crates/query-engine/translation/src/translation/helpers.rs

@@ -90,20 +90,6 @@ pub enum CollectionInfo<'env> {
     },
 }
 
-#[derive(Debug)]
-/// Metadata information about a composite type. This includes both tables (and views) and
-/// dedicated composite types.
-pub enum CompositeTypeInfo<'env> {
-    Table {
-        name: models::CollectionName,
-        info: &'env metadata::TableInfo,
-    },
-    CompositeType {
-        name: models::TypeName,
-        info: &'env metadata::CompositeType,
-    },
-}
-
 #[derive(Debug)]
 /// Metadata information about any object that can have fields
 pub enum FieldsInfo<'env> {
@@ -115,22 +101,6 @@ pub enum FieldsInfo<'env> {
         name: &'env models::CollectionName,
         info: &'env metadata::NativeQueryInfo,
     },
-    CompositeType {
-        name: models::TypeName,
-        info: &'env metadata::CompositeType,
-    },
-}
-
-impl<'a> From<&'a CompositeTypeInfo<'a>> for FieldsInfo<'a> {
-    fn from(value: &'a CompositeTypeInfo<'a>) -> Self {
-        match value {
-            CompositeTypeInfo::Table { name, info } => FieldsInfo::Table { name, info },
-            CompositeTypeInfo::CompositeType { name, info } => FieldsInfo::CompositeType {
-                name: name.clone(),
-                info,
-            },
-        }
-    }
 }
 
 impl<'a> From<&'a CollectionInfo<'a>> for FieldsInfo<'a> {
@@ -233,41 +203,6 @@ impl<'request> Env<'request> {
         info.ok_or(Error::CollectionNotFound(type_name.as_str().into()))
     }
 
-    /// Lookup a metadata object which can be described by a Composite Type. This can be any of
-    /// Tables and Composite Types themselves.
-    ///
-    /// This does not include Native Queries, since the fields of a Native Query is an ad-hoc
-    /// construct of the NDC, and not a named type that Postgres knows about.
-    ///
-    /// Therefore, being a `CompositeTypeInfo` is a stronger property than being a `FieldsInfo`.
-    ///
-    /// This is used in the elaboration of nested fields that are not fully specified, and in the
-    /// translation of input values and variables of composite type.
-    pub fn lookup_composite_type(
-        &self,
-        type_name: &'request models::TypeName,
-    ) -> Result<CompositeTypeInfo<'request>, Error> {
-        let info =
-            self.metadata
-                .tables
-                .0
-                .get(type_name.as_str())
-                .map(|t| CompositeTypeInfo::Table {
-                    name: type_name.as_str().into(),
-                    info: t,
-                });
-        // .or_else(|| {
-        //     self.metadata.composite_types.0.get(type_name).map(|t| {
-        //         CompositeTypeInfo::CompositeType {
-        //             name: t.type_name.as_str().into(),
-        //             info: t,
-        //         }
-        //     })
-        // });
-
-        info.ok_or(Error::CollectionNotFound(type_name.as_str().into()))
-    }
-
     /// Lookup a collection's information in the metadata.
     pub fn lookup_collection(
         &self,
@@ -411,16 +346,6 @@ impl FieldsInfo<'_> {
                 .ok_or_else(|| {
                     Error::ColumnNotFoundInCollection(column_name.clone(), name.as_str().into())
                 }),
-            FieldsInfo::CompositeType { name, info } => info
-                .fields
-                .get(column_name)
-                .map(|field_info| ColumnInfo {
-                    name: sql::ast::ColumnName(field_info.field_name.clone()),
-                    r#type: field_info.r#type.clone(),
-                })
-                .ok_or_else(|| {
-                    Error::ColumnNotFoundInCollection(column_name.clone(), name.as_str().into())
-                }),
         }
     }
 }
@@ -432,39 +357,6 @@ impl CollectionInfo<'_> {
     }
 }
 
-impl CompositeTypeInfo<'_> {
-    pub fn type_name(&self) -> &str {
-        match self {
-            CompositeTypeInfo::Table { name, .. } => name.as_str(),
-            CompositeTypeInfo::CompositeType { name, .. } => name.as_str(),
-        }
-    }
-
-    pub fn schema_name(&self) -> Option<&String> {
-        match self {
-            CompositeTypeInfo::Table { info, .. } => Some(&info.schema_name),
-            CompositeTypeInfo::CompositeType { info, .. } => info.schema_name.as_ref(),
-        }
-    }
-
-    /// Fetch all the field names (external, internal) of a composite type.
-    pub fn fields(&self) -> Vec<(String, &String)> {
-        match self {
-            CompositeTypeInfo::CompositeType { name: _, info } => info
-                .fields
-                .iter()
-                .map(|(name, field)| (name.clone().into(), &field.field_name))
-                .collect::<Vec<_>>(),
-
-            CompositeTypeInfo::Table { name: _, info } => info
-                .columns
-                .iter()
-                .map(|(name, column)| (name.clone().into(), &column.name))
-                .collect::<Vec<_>>(),
-        }
-    }
-}
-
 impl Default for State {
     fn default() -> State {
         State {