refactor(query): use default verify if the feature is not included in the license (#18517)

Author: zhang2014

src/common/license/src/license.rs

@@ -95,6 +95,12 @@ pub enum Feature {
     Unknown,
 }
 
+pub enum VerifyResult {
+    MissMatch,
+    Success,
+    Failure,
+}
+
 impl fmt::Display for Feature {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -159,34 +165,40 @@ impl Feature {
         }
     }
 
-    pub fn verify(&self, feature: &Feature) -> Result<bool, ErrorCode> {
+    pub fn verify(&self, feature: &Feature) -> Result<VerifyResult, ErrorCode> {
         match (self, feature) {
             (Feature::ComputeQuota(c), Feature::ComputeQuota(v)) => {
                 if let Some(thread_num) = c.threads_num {
                     if thread_num <= v.threads_num.unwrap_or(usize::MAX) {
-                        return Ok(false);
+                        return Ok(VerifyResult::Failure);
                     }
                 }
 
                 if let Some(max_memory_usage) = c.memory_usage {
                     if max_memory_usage <= v.memory_usage.unwrap_or(usize::MAX) {
-                        return Ok(false);
+                        return Ok(VerifyResult::Failure);
                     }
                 }
 
-                Ok(true)
+                Ok(VerifyResult::Success)
             }
             (Feature::StorageQuota(c), Feature::StorageQuota(v)) => {
                 if let Some(max_storage_usage) = c.storage_usage {
                     if max_storage_usage <= v.storage_usage.unwrap_or(usize::MAX) {
-                        return Ok(false);
+                        return Ok(VerifyResult::Failure);
                     }
                 }
 
-                Ok(true)
+                Ok(VerifyResult::Success)
             }
-            (Feature::MaxCpuQuota(c), Feature::MaxCpuQuota(v)) => Ok(c > v),
-            (Feature::MaxNodeQuota(c), Feature::MaxNodeQuota(v)) => Ok(c > v),
+            (Feature::MaxCpuQuota(c), Feature::MaxCpuQuota(v)) => match c > v {
+                true => Ok(VerifyResult::Success),
+                false => Ok(VerifyResult::Failure),
+            },
+            (Feature::MaxNodeQuota(c), Feature::MaxNodeQuota(v)) => match c > v {
+                true => Ok(VerifyResult::Success),
+                false => Ok(VerifyResult::Failure),
+            },
             (Feature::Test, Feature::Test)
             | (Feature::AggregateIndex, Feature::AggregateIndex)
             | (Feature::ComputedColumn, Feature::ComputedColumn)
@@ -201,8 +213,8 @@ impl Feature {
             | (Feature::StorageEncryption, Feature::StorageEncryption)
             | (Feature::HilbertClustering, Feature::HilbertClustering)
             | (Feature::NgramIndex, Feature::NgramIndex)
-            | (Feature::VectorIndex, Feature::VectorIndex) => Ok(true),
-            (_, _) => Ok(false),
+            | (Feature::VectorIndex, Feature::VectorIndex) => Ok(VerifyResult::Success),
+            (_, _) => Ok(VerifyResult::MissMatch),
         }
     }
 }

src/query/ee/src/license/license_mgr.rs

@@ -22,6 +22,7 @@ use databend_common_exception::ToErrorCode;
 use databend_common_license::license::Feature;
 use databend_common_license::license::LicenseInfo;
 use databend_common_license::license::StorageQuota;
+use databend_common_license::license::VerifyResult;
 use databend_common_license::license_manager::LicenseManager;
 use databend_common_license::license_manager::LicenseManagerSwitch;
 use databend_common_version::DATABEND_ENTERPRISE_LICENSE_PUBLIC_KEY;
@@ -216,17 +217,32 @@ impl RealLicenseManager {
         }
 
         let verify_features = l.custom.features.as_ref().unwrap();
+        let mut has_verify_failed = false;
         for verify_feature in verify_features {
-            if verify_feature.verify(&feature)? {
-                return Ok(());
+            match verify_feature.verify(&feature)? {
+                VerifyResult::MissMatch => {}
+                VerifyResult::Success => {
+                    return Ok(());
+                }
+                VerifyResult::Failure => {
+                    has_verify_failed = true;
+                }
             }
         }
 
-        Err(ErrorCode::LicenseKeyInvalid(format!(
-            "[LicenseManager] License does not support feature: {}. Supported features: {}",
-            feature,
-            l.custom.display_features()
-        )))
+        match has_verify_failed {
+            true => Err(ErrorCode::LicenseKeyInvalid(format!(
+                "[LicenseManager] License does not support feature: {}. Supported features: {}",
+                feature,
+                l.custom.display_features()
+            ))),
+            // If the feature is not included in the license, default verification is used.
+            false => feature.verify_default(format!(
+                "[LicenseManager] License does not support feature: {}. Supported features: {}",
+                feature,
+                l.custom.display_features()
+            )),
+        }
     }
 
     fn verify_if_expired(&self, feature: Feature) -> Result<()> {