@lix-js/sdk 0.6.0-preview.4 → 0.6.0

package/dist-engine-src/src/sql2/udfs/common.rs

@@ -1,295 +0,0 @@
-use std::sync::Arc;
-
-use datafusion::arrow::array::{
-    Array, ArrayRef, BinaryArray, BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array,
-    Int64Array, Int8Array, LargeBinaryArray, LargeStringArray, StringArray, UInt16Array,
-    UInt32Array, UInt64Array, UInt8Array,
-};
-use datafusion::common::{plan_err, DataFusionError, Result};
-use datafusion::logical_expr::ColumnarValue;
-use serde_json::Value as JsonValue;
-
-pub(super) fn scalar_inputs(args: &[ColumnarValue]) -> bool {
-    args.iter()
-        .all(|value| matches!(value, ColumnarValue::Scalar(_)))
-}
-
-pub(super) fn json_value_to_serde(array: &dyn Array, row: usize) -> Result<Option<JsonValue>> {
-    let Some(raw) = text_like_value(array, row)? else {
-        return Ok(None);
-    };
-    serde_json::from_str::<JsonValue>(&raw)
-        .map(Some)
-        .map_err(|error| {
-            DataFusionError::Execution(format!(
-                "JSON function expected valid JSON text in its first argument, got error: {error}"
-            ))
-        })
-}
-
-pub(super) fn text_like_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(value) = numeric_value(array, row)? {
-        return Ok(Some(value));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BooleanArray>() {
-        return Ok((!array.is_null(row)).then(|| {
-            if array.value(row) {
-                "true".to_string()
-            } else {
-                "false".to_string()
-            }
-        }));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return Ok(
-            (!array.is_null(row)).then(|| String::from_utf8_lossy(array.value(row)).to_string())
-        );
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return Ok(
-            (!array.is_null(row)).then(|| String::from_utf8_lossy(array.value(row)).to_string())
-        );
-    }
-    Err(DataFusionError::Execution(format!(
-        "unsupported argument type for JSON/text function: {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn numeric_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    macro_rules! numeric_array {
-        ($ty:ty) => {
-            if let Some(array) = array.as_any().downcast_ref::<$ty>() {
-                return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-            }
-        };
-    }
-
-    numeric_array!(Int8Array);
-    numeric_array!(Int16Array);
-    numeric_array!(Int32Array);
-    numeric_array!(Int64Array);
-    numeric_array!(UInt8Array);
-    numeric_array!(UInt16Array);
-    numeric_array!(UInt32Array);
-    numeric_array!(UInt64Array);
-    numeric_array!(Float32Array);
-    numeric_array!(Float64Array);
-    Ok(None)
-}
-
-pub(super) fn decode_utf8_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return (!array.is_null(row))
-            .then(|| String::from_utf8(array.value(row).to_vec()))
-            .transpose()
-            .map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_text_decode() expected valid UTF8 bytes: {error}"
-                ))
-            });
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return (!array.is_null(row))
-            .then(|| String::from_utf8(array.value(row).to_vec()))
-            .transpose()
-            .map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_text_decode() expected valid UTF8 bytes: {error}"
-                ))
-            });
-    }
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    Err(DataFusionError::Execution(format!(
-        "lix_text_decode() expected Binary or Utf8, got {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn encode_utf8_value(array: &dyn Array, row: usize) -> Result<Option<Vec<u8>>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).as_bytes().to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).as_bytes().to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_vec()));
-    }
-    Err(DataFusionError::Execution(format!(
-        "lix_text_encode() expected Utf8 or Binary, got {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn validate_utf8_encoding_arg(
-    fn_name: &str,
-    encoding: Option<&ColumnarValue>,
-) -> Result<()> {
-    let Some(encoding) = encoding else {
-        return Ok(());
-    };
-    let arrays = ColumnarValue::values_to_arrays(std::slice::from_ref(encoding))?;
-    let array = &arrays[0];
-    if array.len() == 0 {
-        return Ok(());
-    }
-    let Some(value) = text_like_value(array.as_ref(), 0)? else {
-        return Ok(());
-    };
-    let normalized = value.trim().to_ascii_uppercase().replace('-', "");
-    if normalized == "UTF8" {
-        Ok(())
-    } else {
-        plan_err!("{fn_name}() only supports UTF8 encoding, got '{value}'")
-    }
-}
-
-pub(super) fn extract_json_path(
-    fn_name: &str,
-    arrays: &[ArrayRef],
-    row: usize,
-) -> Result<Option<JsonValue>> {
-    let Some(mut current) = json_value_to_serde(arrays[0].as_ref(), row)? else {
-        return Ok(None);
-    };
-
-    for path in &arrays[1..] {
-        let Some(segment) = json_path_segment(fn_name, path.as_ref(), row)? else {
-            return Ok(None);
-        };
-        let next = match segment {
-            JsonPathSegment::Key(key) => current.get(&key).cloned(),
-            JsonPathSegment::Index(index) => current
-                .as_array()
-                .and_then(|values| values.get(index))
-                .cloned(),
-        };
-        let Some(value) = next else {
-            return Ok(None);
-        };
-        current = value;
-    }
-
-    Ok(Some(current))
-}
-
-pub(super) fn json_text_value(value: &JsonValue) -> Result<String> {
-    match value {
-        JsonValue::String(text) => Ok(text.clone()),
-        JsonValue::Number(number) => Ok(number.to_string()),
-        JsonValue::Bool(boolean) => Ok(if *boolean {
-            "true".to_string()
-        } else {
-            "false".to_string()
-        }),
-        JsonValue::Array(_) | JsonValue::Object(_) => {
-            serde_json::to_string(value).map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_json_get_text() could not render JSON value: {error}"
-                ))
-            })
-        }
-        JsonValue::Null => Ok("null".to_string()),
-    }
-}
-
-pub(super) fn json_json_value(value: &JsonValue) -> Result<String> {
-    serde_json::to_string(value).map_err(|error| {
-        DataFusionError::Execution(format!(
-            "lix_json_get() could not render JSON value: {error}"
-        ))
-    })
-}
-
-enum JsonPathSegment {
-    Key(String),
-    Index(usize),
-}
-
-fn json_path_segment(
-    fn_name: &str,
-    array: &dyn Array,
-    row: usize,
-) -> Result<Option<JsonPathSegment>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        if array.is_null(row) {
-            return Ok(None);
-        }
-        let value = array.value(row).to_string();
-        validate_json_path_key_segment(fn_name, &value)?;
-        return Ok(Some(JsonPathSegment::Key(value)));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        if array.is_null(row) {
-            return Ok(None);
-        }
-        let value = array.value(row).to_string();
-        validate_json_path_key_segment(fn_name, &value)?;
-        return Ok(Some(JsonPathSegment::Key(value)));
-    }
-    macro_rules! index_array {
-        ($ty:ty) => {
-            if let Some(array) = array.as_any().downcast_ref::<$ty>() {
-                if array.is_null(row) {
-                    return Ok(None);
-                }
-                let value = array.value(row);
-                let index = usize::try_from(value).map_err(|_| {
-                    DataFusionError::Execution(format!(
-                        "{fn_name}() path indexes must be non-negative integers"
-                    ))
-                })?;
-                return Ok(Some(JsonPathSegment::Index(index)));
-            }
-        };
-    }
-    index_array!(UInt8Array);
-    index_array!(UInt16Array);
-    index_array!(UInt32Array);
-    index_array!(UInt64Array);
-    index_array!(Int8Array);
-    index_array!(Int16Array);
-    index_array!(Int32Array);
-    index_array!(Int64Array);
-    Err(DataFusionError::Execution(format!(
-        "{fn_name}() path arguments must be strings or non-negative integers, got {:?}",
-        array.data_type()
-    )))
-}
-
-fn validate_json_path_key_segment(fn_name: &str, value: &str) -> Result<()> {
-    if value == "$" || value.starts_with("$.") || value.starts_with("$[") || value.starts_with('/')
-    {
-        return Err(DataFusionError::Execution(format!(
-            "{fn_name}() uses variadic path segments, not JSONPath or JSON Pointer; got '{value}'"
-        )));
-    }
-    Ok(())
-}
-
-pub(super) fn binary_array_from_owned(values: &[Option<Vec<u8>>]) -> BinaryArray {
-    let refs = values
-        .iter()
-        .map(|value| value.as_deref())
-        .collect::<Vec<_>>();
-    BinaryArray::from(refs)
-}
-
-pub(super) fn array_ref<T: Array + 'static>(array: T) -> ArrayRef {
-    Arc::new(array)
-}

package/dist-engine-src/src/sql2/udfs/lix_active_version_commit_id.rs

@@ -1,53 +0,0 @@
-use std::any::Any;
-
-use datafusion::arrow::datatypes::DataType;
-use datafusion::common::{plan_err, Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixActiveVersionCommitId {
-    commit_id: Option<String>,
-}
-
-impl LixActiveVersionCommitId {
-    pub(super) fn new(commit_id: Option<String>) -> Self {
-        Self { commit_id }
-    }
-}
-
-impl std::fmt::Debug for LixActiveVersionCommitId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LixActiveVersionCommitId").finish()
-    }
-}
-
-impl ScalarUDFImpl for LixActiveVersionCommitId {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_active_version_commit_id"
-    }
-
-    fn signature(&self) -> &Signature {
-        static SIGNATURE: std::sync::LazyLock<Signature> =
-            std::sync::LazyLock::new(|| Signature::nullary(Volatility::Stable));
-        &SIGNATURE
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Utf8)
-    }
-
-    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        if !args.args.is_empty() {
-            return plan_err!("lix_active_version_commit_id requires no arguments");
-        }
-        Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
-            self.commit_id.clone(),
-        )))
-    }
-}

package/dist-engine-src/src/sql2/udfs/lix_empty_blob.rs

@@ -1,47 +0,0 @@
-use std::any::Any;
-
-use datafusion::arrow::datatypes::DataType;
-use datafusion::common::{Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixEmptyBlob;
-
-impl ScalarUDFImpl for LixEmptyBlob {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_empty_blob"
-    }
-
-    fn signature(&self) -> &Signature {
-        static SIGNATURE: std::sync::LazyLock<Signature> =
-            std::sync::LazyLock::new(|| Signature::nullary(Volatility::Immutable));
-        &SIGNATURE
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Binary)
-    }
-
-    fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        Ok(ColumnarValue::Scalar(ScalarValue::Binary(Some(Vec::new()))))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::single_binary;
-
-    #[tokio::test]
-    async fn returns_empty_binary_value() {
-        assert_eq!(
-            single_binary("SELECT lix_empty_blob()").await,
-            Some(Vec::new())
-        );
-    }
-}

package/dist-engine-src/src/sql2/udfs/lix_json.rs

@@ -1,100 +0,0 @@
-use std::any::Any;
-use std::sync::Arc;
-
-use datafusion::arrow::array::{Array, StringArray};
-use datafusion::arrow::datatypes::{DataType, FieldRef};
-use datafusion::common::{plan_err, DataFusionError, Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-use serde_json::Value as JsonValue;
-
-use crate::sql2::result_metadata::json_field;
-
-use super::common::{scalar_inputs, text_like_value};
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixJson;
-
-impl ScalarUDFImpl for LixJson {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_json"
-    }
-
-    fn signature(&self) -> &Signature {
-        static SIGNATURE: std::sync::LazyLock<Signature> =
-            std::sync::LazyLock::new(|| Signature::any(1, Volatility::Immutable));
-        &SIGNATURE
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Utf8)
-    }
-
-    fn return_field_from_args(&self, _args: ReturnFieldArgs) -> Result<FieldRef> {
-        Ok(Arc::new(json_field(self.name(), true)))
-    }
-
-    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        if args.args.len() != 1 {
-            return plan_err!("lix_json requires exactly 1 argument");
-        }
-        let scalar_inputs = scalar_inputs(&args.args);
-        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
-        let input = &arrays[0];
-        let len = input.len();
-        let mut values = Vec::with_capacity(len);
-        for row in 0..len {
-            values.push(json_value(input.as_ref(), row)?);
-        }
-        if scalar_inputs {
-            Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
-                values.into_iter().next().flatten(),
-            )))
-        } else {
-            Ok(ColumnarValue::Array(Arc::new(StringArray::from(values))))
-        }
-    }
-}
-
-fn json_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    if matches!(array.data_type(), DataType::Null) {
-        return Ok(Some("null".to_string()));
-    }
-    let Some(raw) = text_like_value(array, row)? else {
-        return Ok(Some("null".to_string()));
-    };
-    let parsed = serde_json::from_str::<JsonValue>(&raw).map_err(|error| {
-        DataFusionError::Execution(format!(
-            "lix_json() expected valid JSON text, got error: {error}"
-        ))
-    })?;
-    Ok(Some(serde_json::to_string(&parsed).map_err(|error| {
-        DataFusionError::Execution(format!("lix_json() could not render JSON: {error}"))
-    })?))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::single_text;
-
-    #[tokio::test]
-    async fn canonicalizes_json_text() {
-        assert_eq!(
-            single_text("SELECT lix_json('{ \"name\" : \"Ada\" }')").await,
-            Some("{\"name\":\"Ada\"}".to_string())
-        );
-    }
-
-    #[tokio::test]
-    async fn null_input_returns_json_null() {
-        assert_eq!(
-            single_text("SELECT lix_json(NULL)").await,
-            Some("null".to_string())
-        );
-    }
-}

package/dist-engine-src/src/sql2/udfs/lix_json_get.rs

@@ -1,99 +0,0 @@
-use std::any::Any;
-use std::sync::Arc;
-
-use datafusion::arrow::array::StringArray;
-use datafusion::arrow::datatypes::{DataType, FieldRef};
-use datafusion::common::{plan_err, Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-use serde_json::Value as JsonValue;
-
-use crate::sql2::result_metadata::json_field;
-
-use super::common::{extract_json_path, json_json_value, scalar_inputs};
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixJsonGet {
-    signature: Signature,
-}
-
-impl LixJsonGet {
-    pub(super) fn new() -> Self {
-        Self {
-            signature: Signature::variadic_any(Volatility::Immutable),
-        }
-    }
-}
-
-impl ScalarUDFImpl for LixJsonGet {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_json_get"
-    }
-
-    fn signature(&self) -> &Signature {
-        &self.signature
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Utf8)
-    }
-
-    fn return_field_from_args(&self, _args: ReturnFieldArgs) -> Result<FieldRef> {
-        Ok(Arc::new(json_field(self.name(), true)))
-    }
-
-    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        if args.args.len() < 2 {
-            return plan_err!("lix_json_get requires at least 2 arguments");
-        }
-
-        let scalar_inputs = scalar_inputs(&args.args);
-        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
-        let len = arrays.first().map(|array| array.len()).unwrap_or(1);
-
-        let mut values = Vec::with_capacity(len);
-        for row in 0..len {
-            values.push(match extract_json_path(self.name(), &arrays, row)? {
-                None | Some(JsonValue::Null) => None,
-                Some(other) => Some(json_json_value(&other)?),
-            });
-        }
-        if scalar_inputs {
-            Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
-                values.into_iter().next().flatten(),
-            )))
-        } else {
-            Ok(ColumnarValue::Array(Arc::new(StringArray::from(values))))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::single_text;
-
-    #[tokio::test]
-    async fn returns_json_representation() {
-        assert_eq!(
-            single_text("SELECT lix_json_get('{\"name\":\"Ada\"}', 'name')").await,
-            Some("\"Ada\"".to_string())
-        );
-        assert_eq!(
-            single_text("SELECT lix_json_get('{\"tags\":[\"db\"]}', 'tags')").await,
-            Some("[\"db\"]".to_string())
-        );
-    }
-
-    #[tokio::test]
-    async fn missing_path_returns_null() {
-        assert_eq!(
-            single_text("SELECT lix_json_get('{\"name\":\"Ada\"}', 'missing')").await,
-            None
-        );
-    }
-}

package/dist-engine-src/src/sql2/udfs/lix_json_get_text.rs

@@ -1,99 +0,0 @@
-use std::any::Any;
-use std::sync::Arc;
-
-use datafusion::arrow::array::StringArray;
-use datafusion::arrow::datatypes::DataType;
-use datafusion::common::{plan_err, Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-use serde_json::Value as JsonValue;
-
-use super::common::{extract_json_path, json_text_value, scalar_inputs};
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixJsonGetText {
-    signature: Signature,
-}
-
-impl LixJsonGetText {
-    pub(super) fn new() -> Self {
-        Self {
-            signature: Signature::variadic_any(Volatility::Immutable),
-        }
-    }
-}
-
-impl ScalarUDFImpl for LixJsonGetText {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_json_get_text"
-    }
-
-    fn signature(&self) -> &Signature {
-        &self.signature
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Utf8)
-    }
-
-    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        if args.args.len() < 2 {
-            return plan_err!("lix_json_get_text requires at least 2 arguments");
-        }
-
-        let scalar_inputs = scalar_inputs(&args.args);
-        let arrays = ColumnarValue::values_to_arrays(&args.args)?;
-        let len = arrays.first().map(|array| array.len()).unwrap_or(1);
-
-        let mut values = Vec::with_capacity(len);
-        for row in 0..len {
-            values.push(match extract_json_path(self.name(), &arrays, row)? {
-                None | Some(JsonValue::Null) => None,
-                Some(JsonValue::Bool(value)) => Some(if value {
-                    "true".to_string()
-                } else {
-                    "false".to_string()
-                }),
-                Some(JsonValue::String(value)) => Some(value),
-                Some(other) => Some(json_text_value(&other)?),
-            });
-        }
-        if scalar_inputs {
-            Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
-                values.into_iter().next().flatten(),
-            )))
-        } else {
-            Ok(ColumnarValue::Array(Arc::new(StringArray::from(values))))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::single_text;
-
-    #[tokio::test]
-    async fn returns_unwrapped_text() {
-        assert_eq!(
-            single_text("SELECT lix_json_get_text('{\"name\":\"Ada\"}', 'name')").await,
-            Some("Ada".to_string())
-        );
-        assert_eq!(
-            single_text("SELECT lix_json_get_text('{\"active\":true}', 'active')").await,
-            Some("true".to_string())
-        );
-    }
-
-    #[tokio::test]
-    async fn missing_path_returns_null() {
-        assert_eq!(
-            single_text("SELECT lix_json_get_text('{\"name\":\"Ada\"}', 'missing')").await,
-            None
-        );
-    }
-}