chore(query): make user setting depend on a lightweight UserSettingValue instead of DataValue

Author: sundy-li

Cargo.lock

@@ -196,5 +196,6 @@ pub use user_privilege::UserPrivilegeSet;
 pub use user_privilege::UserPrivilegeType;
 pub use user_quota::UserQuota;
 pub use user_setting::UserSetting;
+pub use user_setting::UserSettingValue;
 pub use user_stage::*;
 pub use with::With;

src/meta/types/src/lib.rs

@@ -12,33 +12,52 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common_datavalues::DataValue;
 use common_exception::ErrorCode;
 use common_exception::Result;
 use serde::Deserialize;
 use serde::Serialize;
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-#[serde(default)]
 pub struct UserSetting {
     // The name of the setting.
     pub name: String,
     // The value of the setting.
-    pub value: DataValue,
+    pub value: UserSettingValue,
 }
-impl UserSetting {
-    pub fn create(name: &str, value: DataValue) -> UserSetting {
-        UserSetting {
-            name: name.to_string(),
-            value,
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub enum UserSettingValue {
+    UInt64(u64),
+    String(Vec<u8>),
+}
+
+impl UserSettingValue {
+    pub fn as_u64(&self) -> Result<u64> {
+        match self {
+            UserSettingValue::UInt64(v) => Ok(*v),
+            other => Result::Err(ErrorCode::BadDataValueType(format!(
+                "Unexpected type:{:?} to get u64 number",
+                other
+            ))),
+        }
+    }
+
+    pub fn as_string(&self) -> Result<Vec<u8>> {
+        match self {
+            UserSettingValue::String(v) => Ok(v.to_owned()),
+            other => Result::Err(ErrorCode::BadDataValueType(format!(
+                "Unexpected type:{:?} to get u64 number",
+                other
+            ))),
         }
     }
 }
-impl Default for UserSetting {
-    fn default() -> Self {
+
+impl UserSetting {
+    pub fn create(name: &str, value: UserSettingValue) -> UserSetting {
         UserSetting {
-            name: "".to_string(),
-            value: DataValue::Null,
+            name: name.to_string(),
+            value,
         }
     }
 }

src/meta/types/src/user_setting.rs

@@ -68,3 +68,12 @@ fn test_constant_viewer() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+ fn test_json() {
+
+    let value = DataValue::Int64(53);
+    let ss = serde_json::to_vec(&value).unwrap();
+    println!("{:?}", ss);
+    println!("{:?}", unsafe { std::str::from_utf8_unchecked(&ss) } );
+}

src/query/datavalues/tests/it/types/viewer.rs

@@ -15,20 +15,21 @@
 use std::sync::Arc;
 
 use common_base::base::tokio;
-use common_datavalues::DataValue;
 use common_exception::Result;
 use common_management::*;
 use common_meta_api::KVApi;
 use common_meta_embedded::MetaEmbedded;
 use common_meta_types::SeqV;
 use common_meta_types::UserSetting;
+use common_meta_types::UserSettingValue;
+use common_meta_types::Value;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_set_setting() -> Result<()> {
     let (kv_api, mgr) = new_setting_api().await?;
 
     {
-        let setting = UserSetting::create("max_threads", DataValue::UInt64(3));
+        let setting = UserSetting::create("max_threads", UserSettingValue::UInt64(3));
         mgr.set_setting(setting.clone()).await?;
         let value = kv_api
             .get_kv("__fd_settings/databend_query/max_threads")
@@ -48,7 +49,7 @@ async fn test_set_setting() -> Result<()> {
 
     // Set again.
     {
-        let setting = UserSetting::create("max_threads", DataValue::UInt64(1));
+        let setting = UserSetting::create("max_threads", UserSettingValue::UInt64(1));
         mgr.set_setting(setting.clone()).await?;
         let value = kv_api
             .get_kv("__fd_settings/databend_query/max_threads")
@@ -68,14 +69,14 @@ async fn test_set_setting() -> Result<()> {
 
     // Get settings.
     {
-        let expect = vec![UserSetting::create("max_threads", DataValue::UInt64(1))];
+        let expect = vec![UserSetting::create("max_threads", UserSettingValue::UInt64(1))];
         let actual = mgr.get_settings().await?;
         assert_eq!(actual, expect);
     }
 
     // Get setting.
     {
-        let expect = UserSetting::create("max_threads", DataValue::UInt64(1));
+        let expect = UserSetting::create("max_threads", UserSettingValue::UInt64(1));
         let actual = mgr.get_setting("max_threads", None).await?;
         assert_eq!(actual.data, expect);
     }

src/query/management/tests/it/setting.rs

@@ -11,7 +11,6 @@ test = false
 [dependencies]
 common-ast = { path = "../../query/ast" }
 common-config = { path = "../config" }
-common-datavalues = { path = "../datavalues" }
 common-exception = { path = "../../common/exception" }
 common-meta-types = { path = "../../meta/types" }
 common-users = { path = "../users" }