Add aliases for PartiqlCatalog (#395)

- Adds aliases for `PartiqlCatalog`
- Also changes CatalogError to Vec

Author: am357

partiql-catalog/src/lib.rs

@@ -1,4 +1,5 @@
 use crate::call_defs::CallDef;
+
 use partiql_value::Value;
 use std::borrow::Cow;
 
@@ -66,19 +67,32 @@ impl TableFunction {
     }
 }
 
-/// Catalog Errors.
+/// Contains the errors that occur during Catalog related operations
+#[derive(Error, Debug, Clone, PartialEq)]
+#[error("Catalog error: encountered errors")]
+pub struct CatalogError {
+    pub errors: Vec<CatalogErrorKind>,
+}
+
+impl CatalogError {
+    pub fn new(errors: Vec<CatalogErrorKind>) -> Self {
+        CatalogError { errors }
+    }
+}
+
+/// Catalog Error kind
 ///
 /// ### Notes
 /// This is marked `#[non_exhaustive]`, to reserve the right to add more variants in the future.
 #[derive(Error, Debug, Clone, PartialEq)]
 #[non_exhaustive]
-pub enum CatalogError {
+pub enum CatalogErrorKind {
     /// Entry exists error.
-    #[error("Catalog error: entry already exists for `{}`", .0)]
+    #[error("Catalog error: entry already exists for `{0}`")]
     EntryExists(String),
 
     /// Entry error.
-    #[error("Catalog error: `{}`", .0)]
+    #[error("Catalog error: `{0}`")]
     EntryError(String),
 
     /// Any other catalog error.
@@ -93,7 +107,6 @@ pub trait Catalog: Debug {
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
 pub struct FunctionEntry<'a> {
     id: ObjectId,
     function: &'a FunctionEntryFunction,
@@ -127,15 +140,13 @@ impl<'a> FunctionEntry<'a> {
 #[derive(Debug)]
 pub struct PartiqlCatalog {
     functions: CatalogEntrySet<FunctionEntryFunction>,
-
     id: CatalogId,
 }
 
 impl Default for PartiqlCatalog {
     fn default() -> Self {
         PartiqlCatalog {
             functions: Default::default(),
-
             id: CatalogId(1),
         }
     }
@@ -156,9 +167,9 @@ impl Catalog for PartiqlCatalog {
                 entry_id: id,
             })
         } else {
-            Err(CatalogError::EntryError(
+            Err(CatalogError::new(vec![CatalogErrorKind::EntryError(
                 "Function definition has no name".into(),
-            ))
+            )]))
         }
     }
 
@@ -179,6 +190,7 @@ impl Catalog for PartiqlCatalog {
 struct CatalogEntrySet<T> {
     entries: HashMap<EntryId, T>,
     by_name: HashMap<UniCase<String>, EntryId>,
+    by_alias: HashMap<UniCase<String>, EntryId>,
 
     next_id: AtomicU64,
 }
@@ -188,26 +200,49 @@ impl<T> Default for CatalogEntrySet<T> {
         CatalogEntrySet {
             entries: Default::default(),
             by_name: Default::default(),
+            by_alias: Default::default(),
             next_id: 1.into(),
         }
     }
 }
 
 impl<T> CatalogEntrySet<T> {
-    fn add(&mut self, name: &str, _aliases: &[&str], info: T) -> Result<EntryId, CatalogError> {
+    fn add(&mut self, name: &str, aliases: &[&str], info: T) -> Result<EntryId, CatalogError> {
+        let mut errors = vec![];
         let name = UniCase::from(name);
+        let aliases: Vec<UniCase<String>> = aliases
+            .iter()
+            .map(|a| UniCase::from(a.to_string()))
+            .collect();
+
+        aliases.iter().for_each(|a| {
+            if self.by_alias.contains_key(a) {
+                errors.push(CatalogErrorKind::EntryExists(a.as_ref().to_string()))
+            }
+        });
+
         if self.by_name.contains_key(&name) {
-            return Err(CatalogError::EntryExists(name.to_string()));
+            errors.push(CatalogErrorKind::EntryExists(name.to_string()));
         }
 
         let id = self.next_id.fetch_add(1, Ordering::SeqCst).into();
+
         if let Some(_old_val) = self.entries.insert(id, info) {
-            return Err(CatalogError::Unknown);
+            errors.push(CatalogErrorKind::Unknown);
         }
 
-        self.by_name.insert(name, id);
+        match errors.is_empty() {
+            true => {
+                self.by_name.insert(name, id);
+
+                for a in aliases.into_iter() {
+                    self.by_alias.insert(a, id);
+                }
 
-        Ok(id)
+                Ok(id)
+            }
+            _ => Err(CatalogError::new(errors)),
+        }
     }
 
     fn find_by_name(&self, name: &str) -> Option<(EntryId, &T)> {

partiql-types/src/lib.rs

@@ -1,4 +1,5 @@
 use std::collections::HashSet;
+use std::fmt::Debug;
 
 pub trait Type {}
 
@@ -9,6 +10,30 @@ pub struct StaticType {
     kind: StaticTypeKind,
 }
 
+#[derive(Debug, Clone)]
+pub enum StaticTypeKind {
+    Any,
+    AnyOf(AnyOf),
+
+    // Absent Types
+    Null,
+    Missing,
+
+    // Scalar Types
+    Int,
+    Bool,
+    Decimal,
+
+    Float64,
+    String,
+
+    // Container Type
+    Struct(StructType),
+    Bag(BagType),
+    Array(ArrayType),
+    // TODO Add Sexp, TIMESTAMP
+}
+
 #[allow(dead_code)]
 impl StaticType {
     pub fn new(kind: StaticTypeKind) -> StaticType {
@@ -53,30 +78,6 @@ impl StaticType {
     }
 }
 
-#[derive(Debug, Clone)]
-pub enum StaticTypeKind {
-    Any,
-    AnyOf(AnyOf),
-
-    // Absent Types
-    Null,
-    Missing,
-
-    // Scalar Types
-    Int,
-    Bool,
-    Decimal,
-
-    Float64,
-    String,
-
-    // Container Type
-    Struct(StructType),
-    Bag(BagType),
-    Array(ArrayType),
-    // TODO Add Sexp, TIMESTAMP
-}
-
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 pub struct AnyOf {