Make dataset alias comparisons case-insensitive

Author: rmn-boiko

src/domain/opendatafabric/src/identity/dataset_identity.rs

@@ -8,6 +8,7 @@
 // by the Apache License, Version 2.0.
 
 use std::convert::{AsRef, TryFrom};
+use std::hash::Hash;
 use std::sync::Arc;
 use std::{cmp, fmt, ops};
 
@@ -104,7 +105,7 @@ macro_rules! impl_serde {
 }
 
 pub(crate) use impl_serde;
-use like::Like;
+use like::ILike;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -233,7 +234,7 @@ newtype_str!(
 
 impl DatasetNamePattern {
     pub fn matches(&self, dataset_name: &DatasetName) -> bool {
-        Like::<false>::like(dataset_name.as_str(), self).unwrap()
+        ILike::<false>::ilike(dataset_name.as_str(), self).unwrap()
     }
 }
 
@@ -311,7 +312,7 @@ newtype_str!(RepoName, Grammar::match_repo_name, RepoNameSerdeVisitor);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, Eq, PartialOrd, Ord)]
 pub struct DatasetAlias {
     pub account_name: Option<AccountName>,
     pub dataset_name: DatasetName,
@@ -358,6 +359,23 @@ impl DatasetAlias {
     }
 }
 
+impl PartialEq<Self> for DatasetAlias {
+    fn eq(&self, other: &Self) -> bool {
+        (self.account_name.is_some()
+            && other.account_name.is_some()
+            && self.account_name.as_ref().unwrap().to_lowercase()
+                == other.account_name.as_ref().unwrap().to_lowercase())
+            && self.dataset_name.to_lowercase() == other.dataset_name.to_lowercase()
+    }
+}
+
+impl Hash for DatasetAlias {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.account_name.hash(state);
+        self.dataset_name.hash(state);
+    }
+}
+
 impl std::str::FromStr for DatasetAlias {
     type Err = ParseError<Self>;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -388,7 +406,7 @@ impl_serde!(DatasetAlias, DatasetAliasSerdeVisitor);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, Eq, PartialOrd, Ord)]
 pub struct DatasetAliasRemote {
     pub repo_name: RepoName,
     pub account_name: Option<AccountName>,
@@ -437,6 +455,25 @@ impl DatasetAliasRemote {
     }
 }
 
+impl PartialEq<Self> for DatasetAliasRemote {
+    fn eq(&self, other: &Self) -> bool {
+        (self.repo_name.to_lowercase() == other.repo_name.to_lowercase())
+            && (self.account_name.is_some()
+                && other.account_name.is_some()
+                && self.account_name.as_ref().unwrap().to_lowercase()
+                    == other.account_name.as_ref().unwrap().to_lowercase())
+            && self.dataset_name.to_lowercase() == other.dataset_name.to_lowercase()
+    }
+}
+
+impl Hash for DatasetAliasRemote {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.repo_name.hash(state);
+        self.account_name.hash(state);
+        self.dataset_name.hash(state);
+    }
+}
+
 impl std::str::FromStr for DatasetAliasRemote {
     type Err = ParseError<Self>;
     fn from_str(s: &str) -> Result<Self, Self::Err> {

src/infra/core/src/repos/dataset_repository_local_fs.rs

@@ -516,7 +516,7 @@ impl DatasetStorageStrategy for DatasetSingleTenantStorageStrategy {
     }
 
     fn get_datasets_by_owner(&self, account_name: AccountName) -> DatasetHandleStream<'_> {
-        if account_name == DEFAULT_ACCOUNT_NAME {
+        if account_name.to_lowercase() == DEFAULT_ACCOUNT_NAME {
             self.get_all_datasets()
         } else {
             Box::pin(futures::stream::empty())
@@ -529,7 +529,8 @@ impl DatasetStorageStrategy for DatasetSingleTenantStorageStrategy {
     ) -> Result<DatasetHandle, ResolveDatasetError> {
         assert!(
             !dataset_alias.is_multi_tenant()
-                || dataset_alias.account_name.as_ref().unwrap() == DEFAULT_ACCOUNT_NAME,
+                || dataset_alias.account_name.as_ref().unwrap().to_lowercase()
+                    == DEFAULT_ACCOUNT_NAME,
             "Multi-tenant refs shouldn't have reached down to here with earlier validations"
         );
 
@@ -809,7 +810,9 @@ impl DatasetStorageStrategy for DatasetMultiTenantStorageStrategy {
                     )
                     .await?;
 
-                if candidate_dataset_alias.dataset_name == dataset_alias.dataset_name {
+                if candidate_dataset_alias.dataset_name.to_lowercase()
+                    == dataset_alias.dataset_name.to_lowercase()
+                {
                     return Ok(DatasetHandle::new(dataset_id, candidate_dataset_alias));
                 }
             }

src/infra/core/src/repos/dataset_repository_s3.rs

@@ -197,13 +197,13 @@ impl DatasetRepository for DatasetRepositoryS3 {
     }
 
     fn get_datasets_by_owner(&self, account_name: AccountName) -> DatasetHandleStream<'_> {
-        if !self.is_multi_tenant() && account_name != DEFAULT_ACCOUNT_NAME {
+        if !self.is_multi_tenant() && account_name.to_lowercase() != DEFAULT_ACCOUNT_NAME {
             return Box::pin(futures::stream::empty());
         }
 
         self.stream_datasets_if(move |dataset_alias| {
             if let Some(dataset_account_name) = &dataset_alias.account_name {
-                dataset_account_name == &account_name
+                dataset_account_name.to_lowercase() == account_name.to_lowercase()
             } else {
                 true
             }

src/infra/core/src/utils/datasets_filtering.rs

@@ -161,7 +161,12 @@ pub fn matches_remote_ref_pattern(
         DatasetRefAnyPattern::PatternRemote(repo_name, account_name, dataset_name_pattern) => {
             repo_name == &dataset_alias_remote.repo_name
                 && (dataset_alias_remote.account_name.is_some()
-                    && account_name == dataset_alias_remote.account_name.as_ref().unwrap())
+                    && account_name.to_lowercase()
+                        == dataset_alias_remote
+                            .account_name
+                            .as_ref()
+                            .unwrap()
+                            .to_lowercase())
                 && dataset_name_pattern.matches(&dataset_alias_remote.dataset_name)
         }
     }