Struct mz_sql::session::vars::definitions::VarDefinition

pub struct VarDefinition {
    pub name: &'static UncasedStr,
    pub description: &'static str,
    pub user_visible: bool,
    pub value: VarDefaultValue,
    pub constraint: Option<ValueConstraint>,
    pub feature_flag: Option<&'static FeatureFlag>,
    parse: fn(_: VarInput<'_>) -> Result<Box<dyn Value>, VarParseError>,
    type_name: fn() -> Cow<'static, str>,
}

Definition of a variable.

Fields

name: &'static UncasedStr

Name of the variable, case-insensitive matching.

description: &'static str

Description of the variable.

user_visible: bool

Is the variable visible to users, when false only visible to system users.

value: VarDefaultValue

Default compiled in value for this variable.

constraint: Option<ValueConstraint>

Constraint that must be upheld for this variable to be valid.

feature_flag: Option<&'static FeatureFlag>

Optionally hides this variable if it’s related to a feature flag being enabled.

parse: fn(_: VarInput<'_>) -> Result<Box<dyn Value>, VarParseError>

Method to parse VarInput into a type that implements Value.

The reason parse exists as a function pointer is because we want to achieve two things:

1. VarDefinition has no generic parameters.
2. Value::parse returns an instance of Self. VarDefinition holds a dyn Value, but Value::parse is not object safe because it returns Self, so we can’t call that method. We could change Value::parse to return a Box<dyn Value> making it object safe, but that creates a footgun where it’s possible for Value::parse to return a type that isn’t Self, e.g. <String as Value>::parse could return a usize!

So to prevent making VarDefinition generic over some type V: Value, but also defining Value::parse as returning Self, we store a static function pointer to the parse implementation of our default value.

type_name: fn() -> Cow<'static, str>

Returns a human readable name for the type of this variable. We store this as a static function pointer for the same reason as parse.

Implementations

impl VarDefinition

pub const fn new<V: Value>( name: &'static str, value: &'static V, description: &'static str, user_visible: bool, ) -> Self

Create a new VarDefinition in a const context with a value known at compile time.

pub const fn new_lazy<V: Value, L: LazyValueFn<V>>( name: &'static str, _value: L, description: &'static str, user_visible: bool, ) -> Self

Create a new VarDefinition in a const context with a lazily evaluated value.

pub fn new_runtime<V: Value>( name: &'static str, value: V, description: &'static str, user_visible: bool, ) -> Self

Create a new VarDefinition with a value known at runtime.

pub const fn with_constraint<V: Value, D: DomainConstraint<Value = V>>( self, constraint: &'static D, ) -> Self

TODO(parkmycar): Refactor this method onto a VarDefinitionBuilder that would allow us to constrain V here to be the same V used in VarDefinition::new.

pub const fn fixed(self) -> Self

pub const fn read_only(self) -> Self

pub const fn with_feature_flag(self, feature_flag: &'static FeatureFlag) -> Self

pub fn parse(&self, input: VarInput<'_>) -> Result<Box<dyn Value>, VarError>

pub fn default_value(&self) -> &dyn Value

Trait Implementations

impl Clone for VarDefinition

fn clone(&self) -> VarDefinition

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VarDefinition

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Var for VarDefinition

fn name(&self) -> &'static str

Returns the name of the configuration parameter.

fn value(&self) -> String

Constructs a flattened string representation of the current value of the configuration parameter.

fn description(&self) -> &'static str

Returns a short sentence describing the purpose of the configuration parameter.

fn type_name(&self) -> Cow<'static, str>

Returns the name of the type of this variable.

fn visible( &self, user: &User, system_vars: Option<&SystemVars>, ) -> Result<(), VarError>

Indicates wither the Var is visible as a function of the user and system_vars. “Invisible” parameters return VarErrors.

fn as_var(&self) -> &dyn Var

where Self: Sized,

Upcast self to a dyn Var, useful when working with multiple different implementors of Var.