Enum MetadataValue 

pub enum MetadataValue {
    String(String),
    Integer(i64),
    Float(f64),
    Boolean(bool),
    StringArray(Vec<String>),
}

Supported metadata value types.

EdgeVec metadata supports 5 value types optimized for common RAG and vector search use cases.

Type Mapping

Rust Type	JSON Type	TypeScript Type
String	string	string
Integer	number	number
Float	number	number
Boolean	boolean	boolean
StringArray	string[]	string[]

Serialization

Uses adjacently-tagged representation for unambiguous type preservation:

use edgevec::metadata::MetadataValue;

let value = MetadataValue::Integer(42);
let json = serde_json::to_string(&value).unwrap();
assert_eq!(json, r#"{"type":"integer","value":42}"#);

Example

use edgevec::metadata::MetadataValue;

let title = MetadataValue::String("Document Title".to_string());
let page_count = MetadataValue::Integer(42);
let relevance = MetadataValue::Float(0.95);
let is_verified = MetadataValue::Boolean(true);
let tags = MetadataValue::StringArray(vec!["rust".to_string(), "wasm".to_string()]);

// Type checking
assert!(title.is_string());
assert!(page_count.is_integer());
assert!(relevance.is_float());
assert!(is_verified.is_boolean());
assert!(tags.is_string_array());

// Value extraction
assert_eq!(title.as_string(), Some("Document Title"));
assert_eq!(page_count.as_integer(), Some(42));

Variants

String(String)

UTF-8 string value (max 65,536 bytes).

Use for titles, descriptions, content, and any text data.

Integer(i64)

64-bit signed integer.

Use for counts, IDs, timestamps (Unix epoch), and numeric identifiers.

Float(f64)

64-bit IEEE 754 floating point.

Use for scores, weights, probabilities, and continuous values. Note: NaN and Infinity are rejected during validation.

Boolean(bool)

Boolean true/false.

Use for flags, binary filters, and on/off states.

StringArray(Vec<String>)

Array of UTF-8 strings (max 1,024 elements).

Use for tags, categories, labels, and multi-value fields.

Implementations

impl MetadataValue

pub fn type_name(&self) -> &'static str

Returns the type name as a static string.

This matches the JSON serialization type field.

Example

use edgevec::metadata::MetadataValue;

assert_eq!(MetadataValue::String("hi".into()).type_name(), "string");
assert_eq!(MetadataValue::Integer(42).type_name(), "integer");
assert_eq!(MetadataValue::Float(2.5).type_name(), "float");
assert_eq!(MetadataValue::Boolean(true).type_name(), "boolean");
assert_eq!(MetadataValue::StringArray(vec![]).type_name(), "string_array");

pub fn is_string(&self) -> bool

Returns true if this value is a String type.

pub fn is_integer(&self) -> bool

Returns true if this value is an Integer type.

pub fn is_float(&self) -> bool

Returns true if this value is a Float type.

pub fn is_boolean(&self) -> bool

Returns true if this value is a Boolean type.

pub fn is_string_array(&self) -> bool

Returns true if this value is a StringArray type.

pub fn as_string(&self) -> Option<&str>

Attempts to extract the String value.

Returns None if this is not a String variant.

Example

use edgevec::metadata::MetadataValue;

let value = MetadataValue::String("hello".to_string());
assert_eq!(value.as_string(), Some("hello"));

let value = MetadataValue::Integer(42);
assert_eq!(value.as_string(), None);

pub fn as_integer(&self) -> Option<i64>

Attempts to extract the Integer value.

Returns None if this is not an Integer variant.

Example

use edgevec::metadata::MetadataValue;

let value = MetadataValue::Integer(42);
assert_eq!(value.as_integer(), Some(42));

let value = MetadataValue::Float(2.5);
assert_eq!(value.as_integer(), None);

pub fn as_float(&self) -> Option<f64>

Attempts to extract the Float value.

Returns None if this is not a Float variant.

Example

use edgevec::metadata::MetadataValue;

let value = MetadataValue::Float(2.5);
assert_eq!(value.as_float(), Some(2.5));

let value = MetadataValue::Integer(42);
assert_eq!(value.as_float(), None);

pub fn as_boolean(&self) -> Option<bool>

Attempts to extract the Boolean value.

Returns None if this is not a Boolean variant.

Example

use edgevec::metadata::MetadataValue;

let value = MetadataValue::Boolean(true);
assert_eq!(value.as_boolean(), Some(true));

let value = MetadataValue::Integer(1);
assert_eq!(value.as_boolean(), None);

pub fn as_string_array(&self) -> Option<&[String]>

Attempts to extract the StringArray value.

Returns None if this is not a StringArray variant.

Example

use edgevec::metadata::MetadataValue;

let value = MetadataValue::StringArray(vec!["a".into(), "b".into()]);
assert_eq!(value.as_string_array(), Some(&["a".to_string(), "b".to_string()][..]));

let value = MetadataValue::String("not an array".to_string());
assert_eq!(value.as_string_array(), None);

Trait Implementations

impl Clone for MetadataValue

fn clone(&self) -> MetadataValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetadataValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MetadataValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MetadataValue

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

Formats the value using the given formatter.

impl From<&str> for MetadataValue

fn from(s: &str) -> Self

Converts to this type from the input type.

impl<const N: usize> From<[&str; N]> for MetadataValue

fn from(arr: [&str; N]) -> Self

Converts to this type from the input type.

impl From<String> for MetadataValue

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Vec<String>> for MetadataValue

fn from(arr: Vec<String>) -> Self

Converts to this type from the input type.

impl From<bool> for MetadataValue

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<f32> for MetadataValue

fn from(f: f32) -> Self

Converts to this type from the input type.

impl From<f64> for MetadataValue

fn from(f: f64) -> Self

Converts to this type from the input type.

impl From<i32> for MetadataValue

fn from(i: i32) -> Self

Converts to this type from the input type.

impl From<i64> for MetadataValue

fn from(i: i64) -> Self

Converts to this type from the input type.

impl PartialEq for MetadataValue

fn eq(&self, other: &MetadataValue) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MetadataValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MetadataValue