@lix-js/sdk 0.6.0-preview.1 → 0.6.0-preview.3

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

@@ -0,0 +1,295 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,99 @@
+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
+        );
+    }
+}