storage-kit 0.0.1

Portable database and transactional state-store Kit.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use crate::{DenseVector, StorageError, VectorCoercionPolicy};

pub(super) fn parse_f32_json_array(
    value: &serde_json::Value,
    dim: usize,
) -> Result<Vec<f32>, StorageError> {
    parse_json_array(value, dim, "f32")
        .map(|values| values.into_iter().map(|value| value as f32).collect())
}

pub(super) fn parse_f64_json_array(
    value: &serde_json::Value,
    dim: usize,
) -> Result<Vec<f64>, StorageError> {
    parse_json_array(value, dim, "f64")
}

pub(super) fn vector_as_f64(vector: &DenseVector) -> Result<Vec<f64>, StorageError> {
    match vector {
        DenseVector::F64(values) => Ok(values.clone()),
        DenseVector::F32(values) => Ok(values.iter().map(|value| f64::from(*value)).collect()),
        DenseVector::I16(values) => Ok(values.iter().map(|value| f64::from(*value)).collect()),
        DenseVector::I32(values) => Ok(values.iter().map(|value| f64::from(*value)).collect()),
        DenseVector::I64(values) => values
            .iter()
            .enumerate()
            .map(|(index, value)| {
                let converted = *value as f64;
                if converted as i128 == i128::from(*value) {
                    Ok(converted)
                } else {
                    Err(StorageError::InvalidRequest(format!(
                        "cannot convert i64 dense vector value at index {index} (`{value}`) to f64 without precision loss under {:?} policy",
                        VectorCoercionPolicy::Lossless
                    )))
                }
            })
            .collect(),
    }
}

pub(super) fn json_to_string(value: &serde_json::Value) -> Result<String, StorageError> {
    match value {
        serde_json::Value::String(value) => Ok(value.clone()),
        other => serde_json::to_string(other).map_err(StorageError::from),
    }
}

fn parse_json_array(
    value: &serde_json::Value,
    dim: usize,
    scalar: &str,
) -> Result<Vec<f64>, StorageError> {
    let values = value.as_array().ok_or_else(|| {
        StorageError::Serialization(format!(
            "expected JSON array for Lance {scalar} vector field, got {value}"
        ))
    })?;
    if values.len() != dim {
        return Err(StorageError::Serialization(format!(
            "expected Lance {scalar} vector length {dim}, got {}",
            values.len()
        )));
    }
    values
        .iter()
        .map(|value| {
            value.as_f64().ok_or_else(|| {
                StorageError::Serialization(format!(
                    "expected numeric Lance {scalar} vector entry, got {value}"
                ))
            })
        })
        .collect()
}