MB-65809 MB-71120 Return string representation of plan stability settings

When selecting from system:settings, for plan stability settings we
currently return the actual settings in metakv, which uses int64 to
represent the different settings for plan stability mode and plan
stability error policy. This can be confusing to end users since
these integers do not make sense.

Add a translation (remapping) step such that after getting the plan
stability settings, we map the integers to string representations.

Change-Id: I1788520b3c930a558a4bd6470f807a6fac42e01d
Reviewed-on: https://review.couchbase.org/c/query/+/242293
Reviewed-by: Sitaram Vemulapalli <sitaram.vemulapalli@couchbase.com>
Tested-by: Bingjie Miao <bingjie.miao@couchbase.com>

Author: miaobingjie

datastore/system/system_keyspace_settings.go

@@ -78,7 +78,7 @@ func (b *settingsKeyspace) Fetch(keys []string, keysMap map[string]value.Annotat
 			continue
 		}
 
-		val, err := settings.FetchSettings()
+		val, err := settings.FetchSettings(true)
 		if err != nil {
 			return errors.Errors{err}
 		}

settings/plan_stability_ce.go

@@ -21,3 +21,7 @@ func PlanStabilityAvailable() bool {
 func updatePlanStabilitySetting(requestId string, val interface{}) errors.Error {
 	return errors.NewSettingsEnterpriseOnly("Plan Stability")
 }
+
+func remapPlanStabilitySetting(psSetting interface{}) (map[string]interface{}, errors.Error) {
+	return nil, errors.NewSettingsEnterpriseOnly("Plan Stability")
+}

settings/plan_stability_ee.go

@@ -103,3 +103,60 @@ func updatePlanStabilitySetting(requestId string, val interface{}) errors.Error
 
 	return nil
 }
+
+// Given plan stability settings in integer form, remap to string form for easier understanding
+func remapPlanStabilitySetting(psSetting interface{}) (map[string]interface{}, errors.Error) {
+	planStability, ok := psSetting.(map[string]interface{})
+	if !ok {
+		return nil, errors.NewSettingsInvalidValue(PLAN_STABILITY, "map[string]interface{}", psSetting)
+	}
+	for kk, vv := range planStability {
+		if actual, ok := vv.(value.Value); ok {
+			vv = actual.Actual()
+		}
+
+		// When JSON is unmarshalled into an interface, numbers are unmarshalled into float.
+		if f, ok := vv.(float64); ok && value.IsInt(f) {
+			vv = int64(f)
+		}
+
+		switch kk {
+		case "mode":
+			switch vv := vv.(type) {
+			case string:
+				// when user sets the setting
+				// no-op
+			case int64:
+				// when setting comes from metakv
+				mode := PlanStabilityMode(vv)
+				if mode >= PS_MODE_OFF && mode <= PS_MODE_AD_HOC_READ_ONLY {
+					planStability[kk] = mode.String()
+				} else {
+					return nil, errors.NewSettingsInvalidValue(PLAN_STABILITY+".mode", "", vv)
+				}
+			default:
+				return nil, errors.NewSettingsInvalidType(PLAN_STABILITY+".mode", "string", vv)
+			}
+		case "error_policy":
+			switch vv := vv.(type) {
+			case string:
+				// when user sets the setting
+				// no-op
+			case int64:
+				// when setting comes from metakv
+				error_policy := PlanStabilityErrorPolicy(vv)
+				if error_policy >= PS_ERROR_FLEXIBLE && error_policy <= PS_ERROR_STRICT {
+					planStability[kk] = error_policy.String()
+				} else {
+					return nil, errors.NewSettingsInvalidValue(PLAN_STABILITY+".error_policy", "", vv)
+				}
+			default:
+				return nil, errors.NewSettingsInvalidType(PLAN_STABILITY+".error_policy", "string", vv)
+			}
+		default:
+			return nil, errors.NewSettingsInvalidValue(PLAN_STABILITY+"."+kk, "", nil)
+		}
+	}
+
+	return planStability, nil
+}

settings/settings.go

@@ -128,7 +128,7 @@ func defaultSettings() map[string]interface{} {
 	return rv
 }
 
-func FetchSettings() (map[string]interface{}, errors.Error) {
+func FetchSettings(remap bool) (map[string]interface{}, errors.Error) {
 	val, _, err := metakv.Get(_SETTINGS_SETTINGS)
 	if err != nil {
 		return nil, errors.NewSettingsMetaKVError(err, "Error getting global settings from metakv")
@@ -141,6 +141,16 @@ func FetchSettings() (map[string]interface{}, errors.Error) {
 	}
 	delete(vmap, "node")
 
+	if remap {
+		if planStability, ok := vmap[PLAN_STABILITY]; ok {
+			remapPlanStability, err := remapPlanStabilitySetting(planStability)
+			if err != nil {
+				return nil, err
+			}
+			vmap[PLAN_STABILITY] = remapPlanStability
+		}
+	}
+
 	return vmap, nil
 }