chore: Enable Advanced Indexing Features for Community Edition (#18917)

* chore: Enable Advanced Indexing Features for Community Edition

* fix

* fix tests

Author: b41sh

Cargo.lock

@@ -75,11 +75,9 @@ members = [
     "src/query/users",
     "src/query/ee_features/attach_table",
     "src/query/ee_features/vacuum_handler",
-    "src/query/ee_features/aggregating_index",
     "src/query/ee_features/data_mask",
     "src/query/ee_features/storage_encryption",
     "src/query/ee_features/stream_handler",
-    "src/query/ee_features/table_index",
     "src/query/ee_features/virtual_column",
     "src/query/ee_features/resources_management",
     "src/query/service",
@@ -185,7 +183,6 @@ databend-common-tracing = { path = "src/common/tracing" }
 databend-common-users = { path = "src/query/users" }
 databend-common-vector = { path = "src/common/vector" }
 databend-common-version = { path = "src/common/version" }
-databend-enterprise-aggregating-index = { path = "src/query/ee_features/aggregating_index" }
 databend-enterprise-attach-table = { path = "src/query/ee_features/attach_table" }
 databend-enterprise-data-mask-feature = { path = "src/query/ee_features/data_mask" }
 databend-enterprise-fail-safe = { path = "src/query/ee_features/fail_safe" }
@@ -196,7 +193,6 @@ databend-enterprise-resources-management = { path = "src/query/ee_features/resou
 databend-enterprise-row-access-policy-feature = { path = "src/query/ee_features/row_access_policy" }
 databend-enterprise-storage-encryption = { path = "src/query/ee_features/storage_encryption" }
 databend-enterprise-stream-handler = { path = "src/query/ee_features/stream_handler" }
-databend-enterprise-table-index = { path = "src/query/ee_features/table_index" }
 databend-enterprise-vacuum-handler = { path = "src/query/ee_features/vacuum_handler" }
 databend-enterprise-virtual-column = { path = "src/query/ee_features/virtual_column" }
 databend-functions-scalar-arithmetic = { path = "src/query/functions/src/scalars/arithmetic" }

Cargo.toml

@@ -33,10 +33,6 @@ pub enum Feature {
     VirtualColumn,
     #[serde(alias = "data_mask", alias = "DATA_MASK")]
     DataMask,
-    #[serde(alias = "aggregate_index", alias = "AGGREGATE_INDEX")]
-    AggregateIndex,
-    #[serde(alias = "inverted_index", alias = "INVERTED_INDEX")]
-    InvertedIndex,
     #[serde(alias = "computed_column", alias = "COMPUTED_COLUMN")]
     ComputedColumn,
     #[serde(alias = "storage_encryption", alias = "STORAGE_ENCRYPTION")]
@@ -51,14 +47,10 @@ pub enum Feature {
     HilbertClustering,
     #[serde(alias = "system_management", alias = "SYSTEM_MANAGEMENT")]
     SystemManagement,
-    #[serde(alias = "ngram_index", alias = "NGRAM_INDEX")]
-    NgramIndex,
     #[serde(alias = "workload_group", alias = "WORKLOAD_GROUP")]
     WorkloadGroup,
     #[serde(alias = "system_history", alias = "SYSTEM_HISTORY")]
     SystemHistory,
-    #[serde(alias = "vector_index", alias = "VECTOR_INDEX")]
-    VectorIndex,
     #[serde(alias = "private_task", alias = "PRIVATE_TASK")]
     PrivateTask,
     #[serde(alias = "max_node_quota", alias = "MAX_NODE_QUOTA")]
@@ -85,19 +77,15 @@ impl fmt::Display for Feature {
             Feature::Test => write!(f, "test"),
             Feature::VirtualColumn => write!(f, "virtual_column"),
             Feature::DataMask => write!(f, "data_mask"),
-            Feature::AggregateIndex => write!(f, "aggregate_index"),
-            Feature::InvertedIndex => write!(f, "inverted_index"),
             Feature::ComputedColumn => write!(f, "computed_column"),
             Feature::StorageEncryption => write!(f, "storage_encryption"),
             Feature::Stream => write!(f, "stream"),
             Feature::AttacheTable => write!(f, "attach_table"),
             Feature::AmendTable => write!(f, "amend_table"),
             Feature::SystemManagement => write!(f, "system_management"),
             Feature::HilbertClustering => write!(f, "hilbert_clustering"),
-            Feature::NgramIndex => write!(f, "ngram_index"),
             Feature::WorkloadGroup => write!(f, "workload_group"),
             Feature::SystemHistory => write!(f, "system_history"),
-            Feature::VectorIndex => write!(f, "vector_index"),
             Feature::PrivateTask => write!(f, "private_task"),
             Feature::RowAccessPolicy => write!(f, "row_access_policy"),
             Feature::Unknown => write!(f, "unknown"),
@@ -126,20 +114,16 @@ impl Feature {
                 false => Ok(VerifyResult::Failure),
             },
             (Feature::Test, Feature::Test)
-            | (Feature::AggregateIndex, Feature::AggregateIndex)
             | (Feature::ComputedColumn, Feature::ComputedColumn)
             | (Feature::Vacuum, Feature::Vacuum)
             | (Feature::LicenseInfo, Feature::LicenseInfo)
             | (Feature::Stream, Feature::Stream)
             | (Feature::DataMask, Feature::DataMask)
             | (Feature::RowAccessPolicy, Feature::RowAccessPolicy)
-            | (Feature::InvertedIndex, Feature::InvertedIndex)
             | (Feature::VirtualColumn, Feature::VirtualColumn)
             | (Feature::AttacheTable, Feature::AttacheTable)
             | (Feature::StorageEncryption, Feature::StorageEncryption)
-            | (Feature::HilbertClustering, Feature::HilbertClustering)
-            | (Feature::NgramIndex, Feature::NgramIndex)
-            | (Feature::VectorIndex, Feature::VectorIndex) => Ok(VerifyResult::Success),
+            | (Feature::HilbertClustering, Feature::HilbertClustering) => Ok(VerifyResult::Success),
             (_, _) => Ok(VerifyResult::MissMatch),
         }
     }
@@ -230,14 +214,6 @@ mod tests {
             Feature::DataMask,
             serde_json::from_str::<Feature>("\"DataMask\"").unwrap()
         );
-        assert_eq!(
-            Feature::AggregateIndex,
-            serde_json::from_str::<Feature>("\"AggregateIndex\"").unwrap()
-        );
-        assert_eq!(
-            Feature::InvertedIndex,
-            serde_json::from_str::<Feature>("\"InvertedIndex\"").unwrap()
-        );
         assert_eq!(
             Feature::ComputedColumn,
             serde_json::from_str::<Feature>("\"ComputedColumn\"").unwrap()
@@ -265,11 +241,6 @@ mod tests {
             serde_json::from_str::<Feature>("\"hilbert_clustering\"").unwrap()
         );
 
-        assert_eq!(
-            Feature::NgramIndex,
-            serde_json::from_str::<Feature>("\"NgramIndex\"").unwrap()
-        );
-
         assert_eq!(
             Feature::WorkloadGroup,
             serde_json::from_str::<Feature>("\"workload_group\"").unwrap()
@@ -280,11 +251,6 @@ mod tests {
             serde_json::from_str::<Feature>("\"system_history\"").unwrap()
         );
 
-        assert_eq!(
-            Feature::VectorIndex,
-            serde_json::from_str::<Feature>("\"VectorIndex\"").unwrap()
-        );
-
         assert_eq!(
             Feature::PrivateTask,
             serde_json::from_str::<Feature>("\"private_task\"").unwrap()
@@ -318,15 +284,12 @@ mod tests {
                 Feature::Test,
                 Feature::VirtualColumn,
                 Feature::DataMask,
-                Feature::AggregateIndex,
-                Feature::InvertedIndex,
                 Feature::ComputedColumn,
                 Feature::StorageEncryption,
                 Feature::Stream,
                 Feature::AttacheTable,
                 Feature::AmendTable,
                 Feature::HilbertClustering,
-                Feature::NgramIndex,
                 Feature::WorkloadGroup,
                 Feature::SystemHistory,
                 Feature::PrivateTask,
@@ -335,7 +298,7 @@ mod tests {
         };
 
         assert_eq!(
-            "LicenseInfo{ type: enterprise, org: databend, tenants: [databend_tenant,foo], features: [aggregate_index,amend_table,attach_table,computed_column,data_mask,hilbert_clustering,inverted_index,license_info,ngram_index,private_task,row_access_policy,storage_encryption,stream,system_history,vacuum,virtual_column,workload_group] }",
+            "LicenseInfo{ type: enterprise, org: databend, tenants: [databend_tenant,foo], features: [amend_table,attach_table,computed_column,data_mask,hilbert_clustering,license_info,private_task,row_access_policy,storage_encryption,stream,system_history,vacuum,virtual_column,workload_group] }",
             license_info.to_string()
         );
     }

src/common/license/src/license.rs

@@ -13,7 +13,6 @@ async-trait = { workspace = true }
 base64 = { workspace = true }
 chrono = { workspace = true }
 dashmap = { workspace = true }
-databend-common-ast = { workspace = true }
 databend-common-base = { workspace = true }
 databend-common-catalog = { workspace = true }
 databend-common-config = { workspace = true }
@@ -36,7 +35,6 @@ databend-common-storages-fuse = { workspace = true }
 databend-common-storages-stream = { workspace = true }
 databend-common-tracing = { workspace = true }
 databend-common-version = { workspace = true }
-databend-enterprise-aggregating-index = { workspace = true }
 databend-enterprise-attach-table = { workspace = true }
 databend-enterprise-data-mask-feature = { workspace = true }
 databend-enterprise-fail-safe = { workspace = true }
@@ -45,15 +43,12 @@ databend-enterprise-resources-management = { workspace = true }
 databend-enterprise-row-access-policy-feature = { workspace = true }
 databend-enterprise-storage-encryption = { workspace = true }
 databend-enterprise-stream-handler = { workspace = true }
-databend-enterprise-table-index = { workspace = true }
 databend-enterprise-vacuum-handler = { workspace = true }
 databend-enterprise-virtual-column = { workspace = true }
 databend-query = { workspace = true }
 databend-storages-common-cache = { workspace = true }
 databend-storages-common-io = { workspace = true }
-databend-storages-common-pruner = { workspace = true }
 databend-storages-common-table-meta = { workspace = true }
-derive-visitor = { workspace = true }
 futures = { workspace = true }
 futures-util = { workspace = true }
 jwt-simple = { workspace = true }