diff --git a/crates/sail-function/src/scalar/csv/mod.rs b/crates/sail-function/src/scalar/csv/mod.rs
index 08f5bc3100..2695b8de92 100644
--- a/crates/sail-function/src/scalar/csv/mod.rs
+++ b/crates/sail-function/src/scalar/csv/mod.rs
@@ -1,3 +1,4 @@
+mod options;
 mod schema_of_csv;
 pub mod spark_from_csv;
 pub mod spark_to_csv;
diff --git a/crates/sail-function/src/scalar/csv/options.rs b/crates/sail-function/src/scalar/csv/options.rs
new file mode 100644
index 0000000000..fc0773b6f8
--- /dev/null
+++ b/crates/sail-function/src/scalar/csv/options.rs
@@ -0,0 +1,330 @@
+use std::ops::Range;
+
+use datafusion::arrow::array::{Array, MapArray, StringArray};
+use datafusion::error::Result;
+use datafusion_common::exec_err;
+use sail_common::spec::{SAIL_MAP_KEY_FIELD_NAME, SAIL_MAP_VALUE_FIELD_NAME};
+
+/// Which CSV expression function is reading the options.
+///
+/// Spark validates almost every option identically in all three, but not quite: only the writer
+/// rejects an empty `lineSep`, and only `from_csv` rejects the `DROPMALFORMED` parse mode.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum CsvFunction {
+    From,
+    To,
+    SchemaOf,
+}
+
+impl CsvFunction {
+    fn name(self) -> &'static str {
+        match self {
+            Self::From => "from_csv",
+            Self::To => "to_csv",
+            Self::SchemaOf => "schema_of_csv",
+        }
+    }
+}
+
+/// The boolean options that Spark's `CSVOptions` parses with `getBool`, which reports
+/// `<option> flag can be true or false.` on a non-boolean value.
+const BOOL_OPTIONS: [&str; 9] = [
+    "header",
+    "inferSchema",
+    "ignoreLeadingWhiteSpace",
+    "ignoreTrailingWhiteSpace",
+    "escapeQuotes",
+    "quoteAll",
+    "enforceSchema",
+    "preferDate",
+    "columnPruning",
+];
+
+/// Boolean options Spark reads with Scala's `String.toBoolean` instead of `getBool`, so a bad
+/// value is reported as `For input string: "<value>"`. `multiLine` is one of these; the rest are
+/// inherited from the file-source options and validated just as eagerly.
+const TO_BOOLEAN_OPTIONS: [&str; 4] = [
+    "multiLine",
+    "enableDateTimeParsingFallback",
+    "ignoreCorruptFiles",
+    "ignoreMissingFiles",
+];
+
+/// Options Spark reads with `CSVOptions.getChar`. An empty value means "no character" and is
+/// accepted; anything longer than one character is rejected.
+const SINGLE_CHAR_OPTIONS: [&str; 4] = ["quote", "escape", "comment", "charToEscapeQuoteEscaping"];
+
+/// Integer options Spark reads with `getInt`, reporting `<option> should be an integer. Found <v>.`.
+const INT_OPTIONS: [&str; 2] = ["maxColumns", "maxCharsPerColumn"];
+/// Integer options Spark reads with a bare `.toInt`, reporting `For input string: "<value>"`.
+const TO_INT_OPTIONS: [&str; 1] = ["inputBufferSize"];
+const SAMPLING_RATIO_OPTION: &str = "samplingRatio";
+const UNESCAPED_QUOTE_HANDLING_OPTION: &str = "unescapedQuoteHandling";
+const UNESCAPED_QUOTE_HANDLING_VALUES: [&str; 5] = [
+    "STOP_AT_CLOSING_QUOTE",
+    "BACK_TO_DELIMITER",
+    "STOP_AT_DELIMITER",
+    "SKIP_VALUE",
+    "RAISE_ERROR",
+];
+const LINE_SEP_OPTION: &str = "lineSep";
+const MODE_OPTION: &str = "mode";
+const DROP_MALFORMED_MODE: &str = "DROPMALFORMED";
+
+/// The charset values Spark's `CSVOptions` accepts. Spark reads `encoding`, falling back to its
+/// alias `charset`, and validates only the effective value against this set (reporting
+/// `[INVALID_PARAMETER_VALUE.CHARSET]` otherwise) — narrower than Java's, e.g. `Shift_JIS` is
+/// rejected.
+const VALID_CHARSETS: [&str; 7] = [
+    "iso-8859-1",
+    "us-ascii",
+    "utf-16",
+    "utf-16be",
+    "utf-16le",
+    "utf-32",
+    "utf-8",
+];
+
+/// The codecs Spark accepts for `compression` (and its fallback alias `codec`), validating only
+/// the effective value and reporting `[CODEC_NOT_AVAILABLE]` otherwise. There is no `gz` alias and
+/// `zstd` is not among them.
+const VALID_CODECS: [&str; 7] = [
+    "bzip2",
+    "deflate",
+    "uncompressed",
+    "snappy",
+    "none",
+    "lz4",
+    "gzip",
+];
+
+/// The key and value columns of the options map, together with the entry range of its first row.
+///
+/// The options argument is one map for the whole batch, but `make_scalar_function` pads a scalar
+/// argument to one value per row, so the flattened entries repeat that map once per row. Only the
+/// first row is read: the rest are copies, and walking them would validate the same option once
+/// per row of the batch.
+fn first_row_entries(map: &MapArray) -> Option<(&StringArray, &StringArray, Range<usize>)> {
+    if map.is_empty() || map.is_null(0) {
+        return None;
+    }
+    let keys = map
+        .entries()
+        .column_by_name(SAIL_MAP_KEY_FIELD_NAME)?
+        .as_any()
+        .downcast_ref::<StringArray>()?;
+    let values = map
+        .entries()
+        .column_by_name(SAIL_MAP_VALUE_FIELD_NAME)?
+        .as_any()
+        .downcast_ref::<StringArray>()?;
+    let offsets = map.value_offsets();
+    let start = *offsets.first()? as usize;
+    let end = *offsets.get(1)? as usize;
+    Some((keys, values, start..end))
+}
+
+/// Returns the effective value of the `key` option, or `None` when the map does not carry it.
+///
+/// Spark reads CSV options through a `CaseInsensitiveMap`, so `SEP` selects the same option as
+/// `sep` and a later case-variant of a key SHADOWS an earlier one — the LAST match wins. A null
+/// value yields `None` rather than an empty string.
+pub(super) fn find_option<'a>(map: &'a MapArray, key: &str) -> Option<&'a str> {
+    let (keys, values, entries) = first_row_entries(map)?;
+    keys.iter()
+        .zip(values.iter())
+        .take(entries.end)
+        .skip(entries.start)
+        .filter_map(|(entry_key, entry_value)| match entry_key {
+            Some(entry_key) if entry_key.eq_ignore_ascii_case(key) => Some(entry_value),
+            _ => None,
+        })
+        .next_back()
+        .flatten()
+}
+
+/// Returns the effective value of an option that has a fallback alias.
+///
+/// Spark reads the `primary` key, falling back to `alias` (`parameters.get(primary).orElse(alias)`),
+/// and validates or uses ONLY that effective value — a shadowed invalid `alias` is ignored when
+/// `primary` is present. This is the single source of truth for the `sep`/`delimiter`,
+/// `encoding`/`charset`, and `compression`/`codec` precedence pairs.
+pub(super) fn find_option_with_alias<'a>(
+    map: &'a MapArray,
+    primary: &str,
+    alias: &str,
+) -> Option<&'a str> {
+    find_option(map, primary).or_else(|| find_option(map, alias))
+}
+
+/// Rejects a structurally invalid options map — a NULL key or value — the way Spark does during
+/// map conversion, before any input row is evaluated.
+///
+/// This is the ONLY part of option handling that is eager: Spark fails the call for a NULL entry
+/// even when the input is NULL and even under a key it does not know, because the failure happens
+/// while building the options, not while parsing a row. Value validation, by contrast, is lazy
+/// (see [`validate_options`]).
+pub(super) fn reject_null_entries(map: &MapArray, function: CsvFunction) -> Result<()> {
+    let Some((keys, values, entries)) = first_row_entries(map) else {
+        return Ok(());
+    };
+    for (key, value) in keys
+        .iter()
+        .zip(values.iter())
+        .take(entries.end)
+        .skip(entries.start)
+    {
+        if key.is_none() || value.is_none() {
+            return exec_err!(
+                "Failed preparing of the function `{}` for call. Please, double check function's arguments.",
+                function.name()
+            );
+        }
+    }
+    Ok(())
+}
+
+/// Rejects an invalid VALUE for any CSV option present in `map`.
+///
+/// Read-driven, matching Spark: each canonical option is validated by READING its effective value
+/// from the case-insensitive map (last case-variant wins, via [`find_option`]), NOT by scanning raw
+/// entries. A shadowed value — an earlier case-variant, or the losing side of an alias such as
+/// `delimiter` when `sep` is present — is never read and therefore never validated.
+///
+/// Spark builds `CSVOptions` eagerly relative to other options — so `from_csv` rejects a bad
+/// `quoteAll` and `to_csv` rejects a bad `header` — but LAZILY relative to the input: a bad value is
+/// not seen when every input row is NULL. Callers therefore invoke this only when the input has at
+/// least one non-null row; the structural NULL-entry check ([`reject_null_entries`]) runs
+/// unconditionally instead. Unknown keys are ignored, also matching Spark.
+pub(super) fn validate_options(map: &MapArray, function: CsvFunction) -> Result<()> {
+    for option in BOOL_OPTIONS {
+        if let Some(value) = find_option(map, option) {
+            parse_bool_option(Some(value), option, false)?;
+        }
+    }
+    // Read with Scala's `String.toBoolean`, which quotes the value instead of naming the option.
+    for option in TO_BOOLEAN_OPTIONS {
+        if let Some(value) = find_option(map, option)
+            && !fold_eq(value, "true")
+            && !fold_eq(value, "false")
+        {
+            return exec_err!("For input string: \"{value}\"");
+        }
+    }
+    // Spark measures the value with Java's `String.length`, which counts UTF-16 code units:
+    // an emoji is two units and is rejected, while `ñ` is one and is accepted.
+    for option in SINGLE_CHAR_OPTIONS {
+        if let Some(value) = find_option(map, option)
+            && value.encode_utf16().count() > 1
+        {
+            return exec_err!("{option} cannot be more than one character.");
+        }
+    }
+    // Spark reads `sep`, falling back to `delimiter`; only the value it would read is validated.
+    if let Some(value) = find_option_with_alias(map, "sep", "delimiter")
+        && value.is_empty()
+    {
+        return exec_err!("Delimiter cannot be empty");
+    }
+    for option in INT_OPTIONS {
+        if let Some(value) = find_option(map, option)
+            && value.parse::<i32>().is_err()
+        {
+            return exec_err!("{option} should be an integer. Found {value}.");
+        }
+    }
+    // `inputBufferSize` (`.toInt`) and `samplingRatio` (`.toDouble`) both report the raw value.
+    for option in TO_INT_OPTIONS {
+        if let Some(value) = find_option(map, option)
+            && value.parse::<i32>().is_err()
+        {
+            return exec_err!("For input string: \"{value}\"");
+        }
+    }
+    if let Some(value) = find_option(map, SAMPLING_RATIO_OPTION)
+        && value.parse::<f64>().is_err()
+    {
+        return exec_err!("For input string: \"{value}\"");
+    }
+    if let Some(value) = find_option(map, UNESCAPED_QUOTE_HANDLING_OPTION)
+        && !UNESCAPED_QUOTE_HANDLING_VALUES
+            .iter()
+            .any(|x| fold_eq(value, x))
+    {
+        // Spark upper-cases the value before the lookup, so it surfaces the failure of the
+        // underlying parser's `valueOf` with the upper-cased name.
+        let value = value.to_uppercase();
+        return exec_err!(
+            "No enum constant com.univocity.parsers.csv.UnescapedQuoteHandling.{value}"
+        );
+    }
+    // The writer requires at most one Unicode character, which Spark measures as at most two UTF-16
+    // code units — so `ab` (two units) is accepted but `abc` (three) is not. The reader ignores it.
+    if function == CsvFunction::To
+        && let Some(value) = find_option(map, LINE_SEP_OPTION)
+    {
+        if value.is_empty() {
+            return exec_err!("requirement failed: '{LINE_SEP_OPTION}' cannot be an empty string.");
+        }
+        if value.encode_utf16().count() > 2 {
+            return exec_err!(
+                "requirement failed: '{LINE_SEP_OPTION}' can contain only 1 character."
+            );
+        }
+    }
+    // An unrecognized mode is not an error: Spark warns and falls back to PERMISSIVE. Only
+    // `from_csv` rejects `DROPMALFORMED`.
+    if function == CsvFunction::From
+        && let Some(value) = find_option(map, MODE_OPTION)
+        && fold_eq(value, DROP_MALFORMED_MODE)
+    {
+        return exec_err!(
+            "The function `from_csv` doesn't support the {DROP_MALFORMED_MODE} mode. Acceptable modes are PERMISSIVE and FAILFAST."
+        );
+    }
+    // Spark reads `encoding`, falling back to its alias `charset`; only the value it would read is
+    // validated, so a bad `charset` is ignored when `encoding` is present. Matched
+    // case-insensitively (Spark lower-cases with `Locale.ROOT`) against a set narrower than Java's.
+    if let Some(value) = find_option_with_alias(map, "encoding", "charset")
+        && !VALID_CHARSETS.iter().any(|c| value.eq_ignore_ascii_case(c))
+    {
+        return exec_err!(
+            "[INVALID_PARAMETER_VALUE.CHARSET] The value of parameter(s) `charset` in `CSVOptions` is invalid: expects one of the iso-8859-1, us-ascii, utf-16, utf-16be, utf-16le, utf-32, utf-8, but got {value}."
+        );
+    }
+    // Spark reads `compression`, falling back to its alias `codec`; only the effective value is
+    // validated against the registered codecs, case-insensitively.
+    if let Some(value) = find_option_with_alias(map, "compression", "codec")
+        && !VALID_CODECS.iter().any(|c| value.eq_ignore_ascii_case(c))
+    {
+        return exec_err!(
+            "[CODEC_NOT_AVAILABLE.WITH_AVAILABLE_CODECS_SUGGESTION] The codec {value} is not available. Available codecs are bzip2, deflate, uncompressed, snappy, none, lz4, gzip."
+        );
+    }
+    Ok(())
+}
+
+/// Case-insensitive comparison matching Java's `String.equalsIgnoreCase`, which folds non-ASCII
+/// letters too — Spark accepts `multiLine='falſe'` because `ſ` (U+017F) upper-cases to `S`. The
+/// ASCII fast path keeps the common value allocation-free; only a non-ASCII value pays the fold.
+fn fold_eq(value: &str, target: &str) -> bool {
+    value.eq_ignore_ascii_case(target)
+        || (!value.is_ascii() && value.to_uppercase() == target.to_uppercase())
+}
+
+/// Parses a boolean CSV option the way Spark's `CSVOptions.getBool` does: it lower-cases with
+/// `Locale.ROOT` and compares to `true`/`false`. That is ASCII-only folding — `ſ` (U+017F) does
+/// NOT lower-case to `s`, so `header='falſe'` is rejected, unlike the `toBoolean` options, which
+/// upper-case-fold and accept it. `eq_ignore_ascii_case`, not [`fold_eq`], matches this.
+pub(super) fn parse_bool_option(
+    value: Option<&str>,
+    option_name: &str,
+    default: bool,
+) -> Result<bool> {
+    match value {
+        None => Ok(default),
+        Some(value) if value.eq_ignore_ascii_case("true") => Ok(true),
+        Some(value) if value.eq_ignore_ascii_case("false") => Ok(false),
+        Some(_) => exec_err!("{option_name} flag can be true or false."),
+    }
+}
diff --git a/crates/sail-function/src/scalar/csv/schema_of_csv.rs b/crates/sail-function/src/scalar/csv/schema_of_csv.rs
index 50f89ebaf5..51467c4a06 100644
--- a/crates/sail-function/src/scalar/csv/schema_of_csv.rs
+++ b/crates/sail-function/src/scalar/csv/schema_of_csv.rs
@@ -11,6 +11,9 @@ use datafusion_functions::downcast_arg;
 use datafusion_functions::utils::make_scalar_function;
 use sail_common::spec::{SAIL_MAP_KEY_FIELD_NAME, SAIL_MAP_VALUE_FIELD_NAME};
 
+use crate::scalar::csv::options::{
+    CsvFunction, find_option, find_option_with_alias, reject_null_entries, validate_options,
+};
 use crate::scalar::datetime::format::DateTimeFormat;
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -175,52 +178,24 @@ impl Default for SparkSchemaOfCsvOptions {
 impl SparkSchemaOfCsvOptions {
     fn from_map(map_array: &MapArray) -> Result<Self> {
         let mut options = Self::default();
-        if map_array.is_empty() || map_array.is_null(0) {
-            return Ok(options);
+        // `schema_of_csv` takes only literal arguments, so it is always evaluated eagerly: both the
+        // structural NULL-entry check and the value validation run unconditionally here.
+        reject_null_entries(map_array, CsvFunction::SchemaOf)?;
+        validate_options(map_array, CsvFunction::SchemaOf)?;
+
+        // Read through the same case-insensitive, sep-before-delimiter path as `from_csv`/`to_csv`,
+        // so a duplicated key resolves to the last variant and `sep` wins over `delimiter`.
+        if let Some(sep) = find_option_with_alias(map_array, "sep", "delimiter") {
+            options.sep = sep.to_string();
         }
-        let entries = map_array.value(0);
-        let entries = entries
-            .as_any()
-            .downcast_ref::<datafusion::arrow::array::StructArray>()
-            .ok_or_else(|| {
-                DataFusionError::Execution("expected map entries to be a struct array".to_string())
-            })?;
-        let keys = entries
-            .column_by_name(SAIL_MAP_KEY_FIELD_NAME)
-            .and_then(|x| x.as_any().downcast_ref::<StringArray>())
-            .ok_or_else(|| {
-                DataFusionError::Execution("expected map keys to be a string array".to_string())
-            })?;
-        let values = entries
-            .column_by_name(SAIL_MAP_VALUE_FIELD_NAME)
-            .and_then(|x| x.as_any().downcast_ref::<StringArray>())
-            .ok_or_else(|| {
-                DataFusionError::Execution("expected map values to be a string array".to_string())
-            })?;
-        for (key, value) in keys.iter().zip(values.iter()) {
-            let (key, value) = match (key, value) {
-                (Some(key), Some(value)) => (key, value),
-                _ => {
-                    return plan_err!(
-                        "function `{}` does not support null option keys or values",
-                        SparkSchemaOfCsv::SCHEMA_OF_CSV_NAME
-                    );
-                }
-            };
-            match key {
-                "sep" | "delimiter" => options.sep = value.to_string(),
-                "timestampFormat" => {
-                    options.timestamp_format = DateTimeFormat::for_parsing(value)?;
-                }
-                "dateFormat" => {
-                    options.date_format = DateTimeFormat::for_parsing(value)?;
-                }
-                "timeZone" => {
-                    options.timezone = Some(value.to_string());
-                }
-                // Silently ignore unrecognised options, matching Spark's behaviour.
-                _ => {}
-            }
+        if let Some(format) = find_option(map_array, "timestampFormat") {
+            options.timestamp_format = DateTimeFormat::for_parsing(format)?;
+        }
+        if let Some(format) = find_option(map_array, "dateFormat") {
+            options.date_format = DateTimeFormat::for_parsing(format)?;
+        }
+        if let Some(timezone) = find_option(map_array, "timeZone") {
+            options.timezone = Some(timezone.to_string());
         }
         Ok(options)
     }
diff --git a/crates/sail-function/src/scalar/csv/spark_from_csv.rs b/crates/sail-function/src/scalar/csv/spark_from_csv.rs
index 5ca4f15f85..4f8a681d40 100644
--- a/crates/sail-function/src/scalar/csv/spark_from_csv.rs
+++ b/crates/sail-function/src/scalar/csv/spark_from_csv.rs
@@ -20,6 +20,9 @@ use sail_sql_analyzer::parser as sail_parser;
 
 use crate::functions_nested_utils::*;
 use crate::functions_utils::make_scalar_function;
+use crate::scalar::csv::options::{
+    CsvFunction, find_option, find_option_with_alias, reject_null_entries, validate_options,
+};
 use crate::scalar::datetime::format::DateTimeFormat;
 
 const DEFAULT_SESSION_TIMEZONE: &str = "UTC";
@@ -63,12 +66,14 @@ impl SparkFromCSVOptions {
 
     /// Build `SparkFromCSVOptions` from a DataFusion `MapArray` of key-value pairs.
     fn from_map(map: &MapArray) -> Result<Self> {
-        let sep = find_key_value(map, Self::SEP_OPTION)
-            .or(find_key_value(map, Self::DELIMITER_OPTION))
-            .unwrap_or(Self::SEP_DEFAULT.to_string());
+        validate_options(map, CsvFunction::From)?;
+
+        // Read through the case-insensitive, sep-before-delimiter path; `sep` wins over `delimiter`.
+        let sep = find_option_with_alias(map, Self::SEP_OPTION, Self::DELIMITER_OPTION)
+            .unwrap_or(Self::SEP_DEFAULT)
+            .to_string();
 
-        let timestamp_format = find_key_value(map, Self::TIMESTAMP_FORMAT_OPTION)
-            .as_deref()
+        let timestamp_format = find_option(map, Self::TIMESTAMP_FORMAT_OPTION)
             .map(DateTimeFormat::for_parsing)
             .transpose()?
             .unwrap_or_else(|| {
@@ -77,8 +82,7 @@ impl SparkFromCSVOptions {
                     .expect("default timestamp format should be valid")
             });
 
-        let date_format = find_key_value(map, Self::DATE_FORMAT_OPTION)
-            .as_deref()
+        let date_format = find_option(map, Self::DATE_FORMAT_OPTION)
             .map(DateTimeFormat::for_parsing)
             .transpose()?
             .unwrap_or_else(|| {
@@ -87,7 +91,7 @@ impl SparkFromCSVOptions {
                     .expect("default date format should be valid")
             });
 
-        let timezone = find_key_value(map, Self::TIMEZONE_OPTION);
+        let timezone = find_option(map, Self::TIMEZONE_OPTION).map(str::to_string);
 
         Ok(Self {
             sep,
@@ -253,8 +257,18 @@ fn spark_from_csv_inner(args: &[ArrayRef], session_timezone: &str) -> Result<Arr
         schema_str.value(0)
     };
 
+    // Spark validates option VALUES lazily, inside the non-null evaluation path, so a bad option
+    // is not seen when every input row is NULL. A structurally invalid map (a NULL key or value)
+    // is still rejected eagerly, because Spark fails that during map conversion. See F2 in the
+    // #2255 review.
     let options: SparkFromCSVOptions = if let Some(options) = args.get(2) {
-        SparkFromCSVOptions::from_map(downcast_arg!(options, MapArray))?
+        let map = downcast_arg!(options, MapArray);
+        reject_null_entries(map, CsvFunction::From)?;
+        if array.null_count() < array.len() {
+            SparkFromCSVOptions::from_map(map)?
+        } else {
+            SparkFromCSVOptions::default()
+        }
     } else {
         SparkFromCSVOptions::default()
     };
@@ -691,41 +705,6 @@ fn spec_to_arrow_data_type(dt: &spec::DataType, session_timezone: &str) -> Resul
     }
 }
 
-/// Finds the index of a specified key in a `MapArray`.
-///
-/// This helper function locates the index of a given key within a `MapArray`,
-/// where the keys are stored in a "key" column. It is useful for quickly identifying
-/// the position of an option or setting within structured options data.
-fn find_key_index(options: &MapArray, search_key: &str) -> Option<usize> {
-    options
-        .entries()
-        .column_by_name(SAIL_MAP_KEY_FIELD_NAME)
-        .and_then(|x| x.as_any().downcast_ref::<StringArray>())
-        .and_then(|x| {
-            x.iter()
-                .enumerate()
-                .find(|(_, x)| x.as_ref().is_some_and(|x| *x == search_key))
-        })
-        .map(|(i, _)| i)
-}
-
-/// Retrieves the value associated with a specified key from a `MapArray`.
-///
-/// This function extracts the string value assigned to a given key within a `MapArray`,
-/// leveraging the index found by `find_key_index`. It searches for the key in the "key"
-/// column and returns the corresponding value from the "value" column if found.
-fn find_key_value(options: &MapArray, search_key: &str) -> Option<String> {
-    if let Some(index) = find_key_index(options, search_key) {
-        options
-            .entries()
-            .column_by_name(SAIL_MAP_VALUE_FIELD_NAME)
-            .and_then(|x| x.as_any().downcast_ref::<StringArray>())
-            .map(|values| values.value(index).to_string())
-    } else {
-        None
-    }
-}
-
 #[cfg(test)]
 #[expect(clippy::unwrap_used)]
 mod tests {
diff --git a/crates/sail-function/src/scalar/csv/spark_to_csv.rs b/crates/sail-function/src/scalar/csv/spark_to_csv.rs
index fbe13f49a6..8bede0815b 100644
--- a/crates/sail-function/src/scalar/csv/spark_to_csv.rs
+++ b/crates/sail-function/src/scalar/csv/spark_to_csv.rs
@@ -9,9 +9,12 @@ use datafusion_common::{ScalarValue, exec_err, plan_err};
 use datafusion_expr::{ColumnarValue, Expr, ScalarFunctionArgs, ScalarUDFImpl, Signature};
 use datafusion_expr_common::signature::Volatility;
 use lazy_static::lazy_static;
-use sail_common::spec::{SAIL_MAP_KEY_FIELD_NAME, SAIL_MAP_VALUE_FIELD_NAME};
 
 use crate::functions_utils::make_scalar_function;
+use crate::scalar::csv::options::{
+    CsvFunction, find_option, find_option_with_alias, parse_bool_option, reject_null_entries,
+    validate_options,
+};
 use crate::scalar::datetime::format::{
     DateTimeFormat, DateTimeFormatInput, TimePrecision, TimeZoneDisplay, TimestampKind,
 };
@@ -96,54 +99,47 @@ impl SparkToCsvOptions {
 
     /// Build `SparkToCsvOptions` from a DataFusion `MapArray` of key-value pairs.
     fn from_map(map: &MapArray) -> Result<Self> {
-        let sep = find_key_value(map, Self::SEP_OPTION)
-            .or_else(|| find_key_value(map, Self::DELIMITER_OPTION))
-            .unwrap_or_else(|| Self::SEP_DEFAULT.to_string());
-
-        let quote = parse_char_option(
-            find_key_value(map, Self::QUOTE_OPTION).as_deref(),
-            Self::QUOTE_OPTION,
-            Self::QUOTE_DEFAULT,
-        )?;
-        let escape = parse_char_option(
-            find_key_value(map, Self::ESCAPE_OPTION).as_deref(),
-            Self::ESCAPE_OPTION,
-            Self::ESCAPE_DEFAULT,
-        )?;
+        validate_options(map, CsvFunction::To)?;
+
+        let sep = find_option_with_alias(map, Self::SEP_OPTION, Self::DELIMITER_OPTION)
+            .unwrap_or(Self::SEP_DEFAULT)
+            .to_string();
+
+        let quote = parse_char_option(find_option(map, Self::QUOTE_OPTION), Self::QUOTE_DEFAULT);
+        let escape = parse_char_option(find_option(map, Self::ESCAPE_OPTION), Self::ESCAPE_DEFAULT);
         let escape_quotes = parse_bool_option(
-            find_key_value(map, Self::ESCAPE_QUOTES_OPTION).as_deref(),
+            find_option(map, Self::ESCAPE_QUOTES_OPTION),
             Self::ESCAPE_QUOTES_OPTION,
             true,
         )?;
         let quote_all = parse_bool_option(
-            find_key_value(map, Self::QUOTE_ALL_OPTION).as_deref(),
+            find_option(map, Self::QUOTE_ALL_OPTION),
             Self::QUOTE_ALL_OPTION,
             false,
         )?;
-        let null_value = find_key_value(map, Self::NULL_VALUE_OPTION);
+        let null_value = find_option(map, Self::NULL_VALUE_OPTION);
         let null_value_set = null_value.is_some();
-        let null_value = null_value.unwrap_or_default();
-        let empty_value = find_key_value(map, Self::EMPTY_VALUE_OPTION)
-            .unwrap_or_else(|| Self::EMPTY_VALUE_DEFAULT.to_string());
+        let null_value = null_value.unwrap_or_default().to_string();
+        let empty_value = find_option(map, Self::EMPTY_VALUE_OPTION)
+            .unwrap_or(Self::EMPTY_VALUE_DEFAULT)
+            .to_string();
         let ignore_leading_whitespace = parse_bool_option(
-            find_key_value(map, Self::IGNORE_LEADING_WHITESPACE_OPTION).as_deref(),
+            find_option(map, Self::IGNORE_LEADING_WHITESPACE_OPTION),
             Self::IGNORE_LEADING_WHITESPACE_OPTION,
             true,
         )?;
         let ignore_trailing_whitespace = parse_bool_option(
-            find_key_value(map, Self::IGNORE_TRAILING_WHITESPACE_OPTION).as_deref(),
+            find_option(map, Self::IGNORE_TRAILING_WHITESPACE_OPTION),
             Self::IGNORE_TRAILING_WHITESPACE_OPTION,
             true,
         )?;
 
-        let timestamp_format = find_key_value(map, Self::TIMESTAMP_FORMAT_OPTION)
-            .as_deref()
+        let timestamp_format = find_option(map, Self::TIMESTAMP_FORMAT_OPTION)
             .map(DateTimeFormat::for_formatting)
             .transpose()?
             .unwrap_or_else(|| DEFAULT_TIMESTAMP_FORMAT.clone());
 
-        let date_format = find_key_value(map, Self::DATE_FORMAT_OPTION)
-            .as_deref()
+        let date_format = find_option(map, Self::DATE_FORMAT_OPTION)
             .map(DateTimeFormat::for_formatting)
             .transpose()?
             .unwrap_or_else(|| DEFAULT_DATE_FORMAT.clone());
@@ -286,6 +282,11 @@ fn spark_to_csv_inner(args: &[ArrayRef], session_timezone: &str) -> Result<Array
             ))
         })?;
 
+    let num_rows = struct_array.len();
+
+    // Option VALUES are validated lazily (inside `from_map`), so a bad option is not seen when
+    // every input struct is NULL; a structurally invalid map (NULL key/value) is rejected eagerly.
+    // See F2 in the #2255 review.
     let options: SparkToCsvOptions = if let Some(opts) = args.get(1) {
         let map = opts.as_any().downcast_ref::<MapArray>().ok_or_else(|| {
             DataFusionError::Execution(format!(
@@ -293,12 +294,16 @@ fn spark_to_csv_inner(args: &[ArrayRef], session_timezone: &str) -> Result<Array
                 SparkToCsv::TO_CSV_NAME
             ))
         })?;
-        SparkToCsvOptions::from_map(map)?
+        reject_null_entries(map, CsvFunction::To)?;
+        if struct_array.null_count() < num_rows {
+            SparkToCsvOptions::from_map(map)?
+        } else {
+            SparkToCsvOptions::default()
+        }
     } else {
         SparkToCsvOptions::default()
     };
 
-    let num_rows = struct_array.len();
     let fields = struct_array.fields();
     let columns = struct_array.columns();
 
@@ -785,55 +790,13 @@ fn format_float64(value: f64) -> String {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Helpers (same pattern as spark_from_csv.rs)
-// ---------------------------------------------------------------------------
-
-fn find_key_value(options: &MapArray, search_key: &str) -> Option<String> {
-    let entries = options.entries();
-    let keys = entries
-        .column_by_name(SAIL_MAP_KEY_FIELD_NAME)
-        .and_then(|c| c.as_any().downcast_ref::<StringArray>())?;
-    let values = entries
-        .column_by_name(SAIL_MAP_VALUE_FIELD_NAME)
-        .and_then(|c| c.as_any().downcast_ref::<StringArray>())?;
-
-    keys.iter()
-        .enumerate()
-        .find(|(_, k)| {
-            k.as_deref()
-                .is_some_and(|k| k.eq_ignore_ascii_case(search_key))
-        })
-        .and_then(|(i, _)| {
-            // Return None if the value is null
-            if values.is_null(i) {
-                None
-            } else {
-                Some(values.value(i).to_string())
-            }
-        })
-}
-
-fn parse_char_option(value: Option<&str>, option_name: &str, default: char) -> Result<char> {
-    match value {
-        None => Ok(default),
-        Some(value) => {
-            let mut chars = value.chars();
-            match (chars.next(), chars.next()) {
-                (None, _) => Ok('\0'),
-                (Some(ch), None) => Ok(ch),
-                _ => exec_err!("CSV option `{option_name}` must be a single character"),
-            }
-        }
-    }
-}
-
-fn parse_bool_option(value: Option<&str>, option_name: &str, default: bool) -> Result<bool> {
+/// Reads a single-character CSV option. `validate_options` already rejects a value longer than one
+/// character (with Spark's message), so an empty value maps to `'\0'` and anything else to its
+/// first character; this never has to error.
+fn parse_char_option(value: Option<&str>, default: char) -> char {
     match value {
-        None => Ok(default),
-        Some(value) if value.eq_ignore_ascii_case("true") => Ok(true),
-        Some(value) if value.eq_ignore_ascii_case("false") => Ok(false),
-        Some(_) => exec_err!("CSV option `{option_name}` must be `true` or `false`"),
+        None => default,
+        Some(value) => value.chars().next().unwrap_or('\0'),
     }
 }
 
diff --git a/python/pysail/tests/spark/function/features/csv/csv_options.feature b/python/pysail/tests/spark/function/features/csv/csv_options.feature
new file mode 100644
index 0000000000..c21ad5bd72
--- /dev/null
+++ b/python/pysail/tests/spark/function/features/csv/csv_options.feature
@@ -0,0 +1,1015 @@
+@csv
+Feature: CSV expression functions handle Spark's CSV options
+
+  Spark builds `CSVOptions` eagerly, so every option is parsed as soon as the options map is read,
+  even by a function that never uses the resulting value. A bad option is rejected by `from_csv`,
+  `to_csv`, and `schema_of_csv` alike, including for options that function ignores.
+
+  Rule: A non-boolean value is rejected by from_csv
+
+    Scenario Outline: from_csv rejects a non-boolean <option>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('<option>', 'garbage')) AS result
+        """
+      Then query error <option> flag can be true or false
+
+      Examples:
+        | option                   |
+        | header                   |
+        | inferSchema              |
+        | ignoreLeadingWhiteSpace  |
+        | ignoreTrailingWhiteSpace |
+        | escapeQuotes             |
+        | quoteAll                 |
+        | enforceSchema            |
+
+  Rule: A non-boolean value is rejected by to_csv
+
+    Scenario Outline: to_csv rejects a non-boolean <option>
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('<option>', 'garbage')) AS result
+        """
+      Then query error <option> flag can be true or false
+
+      Examples:
+        | option                   |
+        | header                   |
+        | inferSchema              |
+        | ignoreLeadingWhiteSpace  |
+        | ignoreTrailingWhiteSpace |
+        | escapeQuotes             |
+        | quoteAll                 |
+        | enforceSchema            |
+
+  Rule: A non-boolean value is rejected by schema_of_csv
+
+    Scenario Outline: schema_of_csv rejects a non-boolean <option>
+      When query
+        """
+        SELECT schema_of_csv('1', map('<option>', 'garbage')) AS result
+        """
+      Then query error <option> flag can be true or false
+
+      Examples:
+        | option                   |
+        | header                   |
+        | inferSchema              |
+        | ignoreLeadingWhiteSpace  |
+        | ignoreTrailingWhiteSpace |
+        | escapeQuotes             |
+        | quoteAll                 |
+        | enforceSchema            |
+
+  Rule: multiLine reports the offending value instead of the option name
+
+    # Spark reads `multiLine` with Scala's `String.toBoolean` rather than `CSVOptions.getBool`,
+    # so it accepts the same values as the other boolean options but reports a different error.
+
+    Scenario: from_csv rejects a non-boolean multiLine
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('multiLine', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+    Scenario: to_csv rejects a non-boolean multiLine
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('multiLine', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+    Scenario: schema_of_csv rejects a non-boolean multiLine
+      When query
+        """
+        SELECT schema_of_csv('1', map('multiLine', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+    Scenario: from_csv rejects an empty multiLine
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('multiLine', '')) AS result
+        """
+      Then query error For input string: ""
+
+    Scenario: from_csv accepts an uppercase multiLine
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('multiLine', 'TRUE')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+  Rule: Boolean values are case-insensitive
+
+    Scenario Outline: from_csv accepts the boolean value <value>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', '<value>')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+      Examples:
+        | value |
+        | true  |
+        | false |
+        | TRUE  |
+        | FALSE |
+        | True  |
+        | FaLsE |
+
+    Scenario: to_csv accepts an uppercase boolean value
+      When query
+        """
+        SELECT to_csv(named_struct('a', 'x'), map('quoteAll', 'TRUE')) AS result
+        """
+      Then query result
+        | result |
+        | "x"    |
+
+  Rule: Values that only look boolean are rejected
+
+    Scenario Outline: from_csv rejects the header value <value>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', '<value>')) AS result
+        """
+      Then query error header flag can be true or false
+
+      Examples:
+        | value |
+        | 1     |
+        | 0     |
+        | yes   |
+        | t     |
+        | f     |
+
+    # The whitespace and empty cases are spelled out because Gherkin trims table cells.
+    Scenario: from_csv rejects an empty header value
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', '')) AS result
+        """
+      Then query error header flag can be true or false
+
+    Scenario: from_csv rejects a header value with a leading space
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', ' true')) AS result
+        """
+      Then query error header flag can be true or false
+
+    Scenario: from_csv rejects a header value with a trailing space
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', 'true ')) AS result
+        """
+      Then query error header flag can be true or false
+
+    Scenario: from_csv rejects a boolean value spelled with a non-ASCII lookalike
+      # Spark folds option values with `toLowerCase(Locale.ROOT)`, which does not map U+017F to
+      # `s`, so this is not the word `false`.
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', 'falſe')) AS result
+        """
+      Then query error header flag can be true or false
+
+  Rule: Option keys are matched case-insensitively
+
+    # The error always names the canonical option, never the key the user wrote.
+
+    Scenario Outline: from_csv rejects a non-boolean value for the key <key>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('<key>', 'garbage')) AS result
+        """
+      Then query error header flag can be true or false
+
+      Examples:
+        | key    |
+        | HEADER |
+        | Header |
+        | hEaDeR |
+
+  Rule: Unknown options are ignored
+
+    Scenario: from_csv ignores an unknown option
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('unknownOption', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    Scenario: to_csv ignores an unknown option
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('unknownOption', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | 1      |
+
+  Rule: An option key is matched case-insensitively when the option applies
+
+    # Not just when it is rejected: the option must actually take effect under any spelling.
+
+    Scenario: to_csv honors an uppercase sep
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1, 'b', 'x'), map('SEP', '|')) AS result
+        """
+      Then query result
+        | result |
+        | 1\|x   |
+
+    Scenario: from_csv honors an uppercase sep
+      When query
+        """
+        SELECT from_csv('1|2', 'a INT, b INT', map('SEP', '|')) AS result
+        """
+      Then query result
+        | result |
+        | {1, 2} |
+
+    Scenario: from_csv honors a mixed-case delimiter
+      When query
+        """
+        SELECT from_csv('1|2', 'a INT, b INT', map('DeLiMiTeR', '|')) AS result
+        """
+      Then query result
+        | result |
+        | {1, 2} |
+
+    Scenario: schema_of_csv honors an uppercase sep
+      When query
+        """
+        SELECT schema_of_csv('1|abc', map('SEP', '|')) AS result
+        """
+      Then query result
+        | result                        |
+        | STRUCT<_c0: INT, _c1: STRING> |
+
+    Scenario: schema_of_csv gives sep precedence over delimiter
+      # sep wins over delimiter, matching from_csv/to_csv (and Spark's read order).
+      When query
+        """
+        SELECT schema_of_csv('1|2', map('sep', '|', 'delimiter', ';')) AS result
+        """
+      Then query result
+        | result                     |
+        | STRUCT<_c0: INT, _c1: INT> |
+
+    # Without a timestampFormat the value infers as STRING, so these three together prove the
+    # option is really applied under either spelling rather than silently dropped.
+    Scenario: schema_of_csv infers a string without a timestampFormat
+      When query
+        """
+        SELECT schema_of_csv('15/01/2024 12:00:00') AS result
+        """
+      Then query result
+        | result              |
+        | STRUCT<_c0: STRING> |
+
+    Scenario: schema_of_csv honors a canonical timestampFormat
+      When query
+        """
+        SELECT schema_of_csv('15/01/2024 12:00:00', map('timestampFormat', 'dd/MM/yyyy HH:mm:ss')) AS result
+        """
+      Then query result
+        | result                 |
+        | STRUCT<_c0: TIMESTAMP> |
+
+    Scenario: schema_of_csv honors an uppercase timestampFormat
+      When query
+        """
+        SELECT schema_of_csv('15/01/2024 12:00:00', map('TIMESTAMPFORMAT', 'dd/MM/yyyy HH:mm:ss')) AS result
+        """
+      Then query result
+        | result                 |
+        | STRUCT<_c0: TIMESTAMP> |
+
+    Scenario: schema_of_csv infers a date with the default format
+      When query
+        """
+        SELECT schema_of_csv('2024-01-15') AS result
+        """
+      Then query result
+        | result            |
+        | STRUCT<_c0: DATE> |
+
+    Scenario: schema_of_csv honors a dateFormat
+      # Sail hardcodes the DATE inference format to `%Y-%m-%d` and never reads `dateFormat`.
+      When query
+        """
+        SELECT schema_of_csv('15/01/2024', map('dateFormat', 'dd/MM/yyyy')) AS result
+        """
+      Then query result
+        | result            |
+        | STRUCT<_c0: DATE> |
+
+    Scenario: schema_of_csv honors a timestampFormat that carries no time
+      # Sail parses the value with a date-time parser that requires a time component, so a
+      # date-only format never matches and the field falls back to STRING.
+      When query
+        """
+        SELECT schema_of_csv('15/01/2024', map('timestampFormat', 'dd/MM/yyyy')) AS result
+        """
+      Then query result
+        | result                 |
+        | STRUCT<_c0: TIMESTAMP> |
+
+  Rule: A malformed record yields NULL instead of failing the query
+
+    # Spark's default parse mode is PERMISSIVE: a field that does not fit the schema becomes NULL
+    # and every field that parsed fine keeps its value. Sail reads no `mode` at all and aborts the
+    # query on the first bad field, so it always behaves as FAILFAST and one bad row kills an
+    # otherwise valid read.
+
+    @sail-bug
+    Scenario: from_csv nulls only the field that failed to parse
+      When query
+        """
+        SELECT from_csv('1,garbage', 'a INT, b INT') AS result
+        """
+      Then query result
+        | result    |
+        | {1, NULL} |
+
+    @sail-bug
+    Scenario: from_csv keeps a good field that follows a bad one
+      When query
+        """
+        SELECT from_csv('garbage,2', 'a INT, b INT') AS result
+        """
+      Then query result
+        | result    |
+        | {NULL, 2} |
+
+    @sail-bug
+    Scenario: from_csv nulls the fields missing from a short record
+      When query
+        """
+        SELECT from_csv('1', 'a INT, b INT') AS result
+        """
+      Then query result
+        | result    |
+        | {1, NULL} |
+
+    @sail-bug
+    Scenario: from_csv ignores the extra fields of a long record
+      When query
+        """
+        SELECT from_csv('1,2,3', 'a INT, b INT') AS result
+        """
+      Then query result
+        | result |
+        | {1, 2} |
+
+    @sail-bug
+    Scenario: from_csv fails the query under the FAILFAST mode
+      When query
+        """
+        SELECT from_csv('1,garbage', 'a INT, b INT', map('mode', 'FAILFAST')) AS result
+        """
+      Then query error Malformed records are detected in record parsing
+
+  Rule: The parse mode applies to every row of a column, not just to a literal
+
+    # An option argument is a literal map, but the input is a column. These cover all three modes
+    # over multiple rows with a DIFFERENT value per row, so a kernel that broadcast row 0 would
+    # show up instead of silently agreeing.
+
+    @sail-bug
+    Scenario: from_csv nulls the bad fields of each row independently
+      When query
+        """
+        SELECT from_csv(c, 'a INT, b INT') AS result
+        FROM VALUES ('1,2'), ('3,garbage'), ('garbage,6'), ('7,8'), (NULL) AS t(c)
+        """
+      Then query result
+        | result    |
+        | {1, 2}    |
+        | {3, NULL} |
+        | {NULL, 6} |
+        | {7, 8}    |
+        | NULL      |
+
+    @sail-bug
+    Scenario: from_csv nulls the bad fields of each row under an explicit PERMISSIVE mode
+      When query
+        """
+        SELECT from_csv(c, 'a INT, b INT', map('mode', 'PERMISSIVE')) AS result
+        FROM VALUES ('1,2'), ('3,garbage'), ('9,10') AS t(c)
+        """
+      Then query result
+        | result    |
+        | {1, 2}    |
+        | {3, NULL} |
+        | {9, 10}   |
+
+    Scenario: from_csv parses every row under the FAILFAST mode when all rows are well formed
+      When query
+        """
+        SELECT from_csv(c, 'a INT, b INT', map('mode', 'FAILFAST')) AS result
+        FROM VALUES ('1,2'), ('3,4'), ('5,6') AS t(c)
+        """
+      Then query result
+        | result |
+        | {1, 2} |
+        | {3, 4} |
+        | {5, 6} |
+
+    @sail-bug
+    Scenario: from_csv fails the whole column under the FAILFAST mode when one row is bad
+      When query
+        """
+        SELECT from_csv(c, 'a INT, b INT', map('mode', 'FAILFAST')) AS result
+        FROM VALUES ('1,2'), ('3,garbage'), ('5,6') AS t(c)
+        """
+      Then query error Malformed records are detected in record parsing
+
+    Scenario: from_csv rejects the DROPMALFORMED mode over a column too
+      When query
+        """
+        SELECT from_csv(c, 'a INT', map('mode', 'DROPMALFORMED')) AS result
+        FROM VALUES ('1'), ('2') AS t(c)
+        """
+      Then query error doesn't support the DROPMALFORMED mode
+
+    Scenario: from_csv applies a separator to every row of a column
+      When query
+        """
+        SELECT from_csv(c, 'a INT, b INT', map('sep', '|')) AS result
+        FROM VALUES ('1|2'), ('3|4'), ('5|6') AS t(c)
+        """
+      Then query result
+        | result |
+        | {1, 2} |
+        | {3, 4} |
+        | {5, 6} |
+
+    Scenario: to_csv applies an option to every row of a column
+      When query
+        """
+        SELECT to_csv(named_struct('a', c, 'b', 'x'), map('sep', ';', 'quoteAll', 'true')) AS result
+        FROM VALUES (1), (2), (3) AS t(c)
+        """
+      Then query result
+        | result  |
+        | "1";"x" |
+        | "2";"x" |
+        | "3";"x" |
+
+  # FOLLOW-UP: NULL option-value semantics diverge across Spark versions. Up to 4.1.x Spark
+  # rejects the whole call ("Failed preparing of the function ... for call"), which is what Sail's
+  # `reject_null_entries` matches. In 4.2.0 this changed: a NULL value is no longer a structural
+  # error (a known key reports "flag can be true or false", an unknown key is accepted). Sail has
+  # no target-version signal reaching the CSV UDF, so it cannot branch by version yet. These
+  # scenarios are parked (not deleted) until a dedicated PR decides the version story; enabling
+  # them now would fail the 4.2.0 CI leg while passing the 4.1.1 one.
+  #
+  # Rule: A NULL option value is rejected
+  #
+  #   # Spark rejects the call outright, even when the key is one it does not know, so this is not
+  #   # per-option validation but a property of the options map itself.
+  #
+  #   Scenario: from_csv rejects a NULL value for a known option
+  #     When query
+  #       """
+  #       SELECT from_csv('1', 'a INT', map('header', CAST(NULL AS STRING))) AS result
+  #       """
+  #     Then query error Failed preparing of the function .from_csv. for call
+  #
+  #   Scenario: from_csv rejects a NULL value for an unknown option
+  #     When query
+  #       """
+  #       SELECT from_csv('1', 'a INT', map('unknownOption', CAST(NULL AS STRING))) AS result
+  #       """
+  #     Then query error Failed preparing of the function .from_csv. for call
+  #
+  #   Scenario: to_csv rejects a NULL option value
+  #     When query
+  #       """
+  #       SELECT to_csv(named_struct('a', 1), map('sep', CAST(NULL AS STRING))) AS result
+  #       """
+  #     Then query error Failed preparing of the function .to_csv. for call
+  #
+  #   Scenario: schema_of_csv rejects a NULL option value
+  #     When query
+  #       """
+  #       SELECT schema_of_csv('1', map('sep', CAST(NULL AS STRING))) AS result
+  #       """
+  #     Then query error Failed preparing of the function .schema_of_csv. for call
+
+  Rule: A field is not trimmed before it is parsed
+
+    @sail-bug
+    Scenario: from_csv does not trim the whitespace around a field
+      # Spark keeps the surrounding whitespace, so ` 1 ` is not the number 1 and the field is
+      # malformed. Sail trims every token, which silently accepts it. Observing Spark's NULL
+      # here needs PERMISSIVE, which is why this travels with the parse-mode work.
+      When query
+        """
+        SELECT from_csv(' 1 , 2 ', 'a INT, b INT') AS result
+        """
+      Then query result
+        | result       |
+        | {NULL, NULL} |
+
+  Rule: Single-character options are validated
+
+    Scenario: from_csv rejects a multi-character quote
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('quote', 'ab')) AS result
+        """
+      Then query error quote cannot be more than one character
+
+    Scenario: to_csv rejects a multi-character quote with Spark's message
+      # Sail already rejects this, but says "CSV option `quote` must be a single character".
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('quote', 'ab')) AS result
+        """
+      Then query error quote cannot be more than one character
+
+    # Spark measures the value with Java's `String.length`, which counts UTF-16 code units, not
+    # characters: an emoji is two units and is rejected, but `ñ` is one and is accepted.
+    Scenario: to_csv accepts a single non-ASCII quote character
+      When query
+        """
+        SELECT to_csv(named_struct('a', 'x'), map('quote', 'ñ')) AS result
+        """
+      Then query result
+        | result |
+        | x      |
+
+    Scenario: to_csv rejects a quote that is one character but two UTF-16 units
+      When query
+        """
+        SELECT to_csv(named_struct('a', 'x'), map('quote', '😀')) AS result
+        """
+      Then query error quote cannot be more than one character
+
+    Scenario: from_csv rejects a multi-character comment
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('comment', 'ab')) AS result
+        """
+      Then query error comment cannot be more than one character
+
+    Scenario: to_csv rejects a multi-character comment
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('comment', 'ab')) AS result
+        """
+      Then query error comment cannot be more than one character
+
+  Rule: An empty separator is rejected
+
+    Scenario: from_csv rejects an empty sep
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('sep', '')) AS result
+        """
+      Then query error Delimiter cannot be empty
+
+    Scenario: to_csv rejects an empty sep
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('sep', '')) AS result
+        """
+      Then query error Delimiter cannot be empty
+
+    Scenario: to_csv rejects an empty lineSep
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('lineSep', '')) AS result
+        """
+      Then query error 'lineSep' cannot be an empty string
+
+  Rule: Numeric options are validated
+
+    Scenario: from_csv rejects a non-numeric maxColumns
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('maxColumns', 'garbage')) AS result
+        """
+      Then query error maxColumns should be an integer. Found garbage
+
+    Scenario: from_csv rejects a non-numeric samplingRatio
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('samplingRatio', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+  Rule: Enum options are validated
+
+    Scenario: from_csv rejects an unknown unescapedQuoteHandling
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('unescapedQuoteHandling', 'garbage')) AS result
+        """
+      Then query error No enum constant
+
+    Scenario: from_csv rejects the DROPMALFORMED mode
+      # Only PERMISSIVE and FAILFAST are supported by the expression, unlike the CSV reader.
+      When query
+        """
+        SELECT from_csv('1,2', 'a INT, b INT', map('mode', 'DROPMALFORMED')) AS result
+        """
+      Then query error doesn't support the DROPMALFORMED mode
+
+    Scenario: from_csv accepts an unknown mode
+      # Spark does not validate the mode: it warns and falls back to PERMISSIVE.
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('mode', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+  Rule: An option value is validated lazily, per Spark's null propagation
+
+    # Spark builds the parser inside the non-null evaluation path, so a bad option VALUE is not
+    # seen when every input row is NULL: it returns NULL rather than erroring. A structurally
+    # invalid map (a NULL key or value) stays eager — see the next Rule.
+
+    Scenario: from_csv returns NULL for a NULL input even with a bad option
+      When query
+        """
+        SELECT from_csv(CAST(NULL AS STRING), 'a INT', map('header', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | NULL   |
+
+    Scenario: to_csv returns NULL for a NULL input even with a bad option
+      When query
+        """
+        SELECT to_csv(CAST(NULL AS STRUCT<a: INT>), map('header', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | NULL   |
+
+    Scenario: from_csv does not validate options when every row is NULL
+      When query
+        """
+        SELECT from_csv(c, 'a INT', map('header', 'garbage')) AS result
+        FROM VALUES (CAST(NULL AS STRING)), (CAST(NULL AS STRING)) AS t(c)
+        """
+      Then query result
+        | result |
+        | NULL   |
+        | NULL   |
+
+    Scenario: from_csv still validates the option when a non-null row is present
+      When query
+        """
+        SELECT from_csv(c, 'a INT', map('header', 'garbage')) AS result
+        FROM VALUES ('1'), (CAST(NULL AS STRING)) AS t(c)
+        """
+      Then query error header flag can be true or false
+
+  Rule: Options inherited from the file-source options are validated too
+
+    # These are not in CSVOptions itself but in its parent, and Spark validates them eagerly all
+    # the same. `preferDate` and `columnPruning` go through getBool (naming the option); the rest
+    # through Scala's toBoolean / toInt (quoting the value).
+
+    Scenario Outline: from_csv rejects a non-boolean <option>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('<option>', 'garbage')) AS result
+        """
+      Then query error <option> flag can be true or false
+
+      Examples:
+        | option        |
+        | preferDate    |
+        | columnPruning |
+
+    Scenario Outline: from_csv rejects a non-boolean <option> quoting the value
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('<option>', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+      Examples:
+        | option                        |
+        | enableDateTimeParsingFallback |
+        | ignoreCorruptFiles            |
+        | ignoreMissingFiles            |
+
+    Scenario: from_csv rejects a non-integer inputBufferSize
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('inputBufferSize', 'garbage')) AS result
+        """
+      Then query error For input string: "garbage"
+
+    Scenario: from_csv accepts a valid preferDate
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('preferDate', 'true')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    @sail-bug
+    Scenario: from_csv skips preferDate validation under the legacy time-parser policy
+      # Spark reads preferDate only when the parser policy is CORRECTED
+      # (`if (legacy) false else getBool(PREFER_DATE)`), so under LEGACY a bad value is never read
+      # nor validated. Sail does not plumb the policy, so it validates it regardless.
+      Given config spark.sql.legacy.timeParserPolicy = LEGACY
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('preferDate', 'garbage')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+  Rule: Boolean folding follows the option's parser
+
+    # `multiLine` reads through Scala toBoolean, which upper-case-folds Unicode: `ſ` (U+017F)
+    # upper-cases to `S`, so `falſe` is accepted. `header` reads through getBool, which lower-cases
+    # with Locale.ROOT — `ſ` does not lower-case to `s`, so `falſe` is rejected.
+
+    Scenario: from_csv accepts a Unicode-folded multiLine value
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('multiLine', 'falſe')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    Scenario: from_csv rejects the same Unicode value for a getBool option
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', 'falſe')) AS result
+        """
+      Then query error header flag can be true or false
+
+  Rule: The writer rejects a lineSep over two UTF-16 code units
+
+    # Spark measures the length in UTF-16 code units, not characters: `ab` is two units and is
+    # accepted, while `abc` is three and is rejected.
+
+    Scenario: to_csv accepts a two-unit lineSep
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('lineSep', 'ab')) AS result
+        """
+      Then query result
+        | result |
+        | 1      |
+
+    Scenario: to_csv rejects a three-character lineSep
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1), map('lineSep', 'abc')) AS result
+        """
+      Then query error 'lineSep' can contain only 1 character
+
+  # ---------------------------------------------------------------------------
+  # Deferred findings from the #2255 review. Each passes against Spark and fails
+  # against Sail, so they are tagged @sail-bug and tracked until fixed in their
+  # own PR. They are NOT addressed here — see the PR description for scope.
+  # ---------------------------------------------------------------------------
+
+  Rule: Duplicate/aliased option keys follow Spark's effective-map precedence
+
+    # Spark collapses the options into a case-insensitive map before reading, so the LAST
+    # case-variant wins and a shadowed invalid value is never seen. Sail validates every raw entry
+    # and reads the first match, so it rejects the shadowed value or picks the wrong one.
+
+    Scenario: from_csv uses the last case-variant of a duplicated key
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', 'garbage', 'HEADER', 'true')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    Scenario: to_csv uses the last case-variant of a duplicated key
+      When query
+        """
+        SELECT to_csv(named_struct('a', 'x'), map('quoteAll', 'false', 'QUOTEALL', 'true')) AS result
+        """
+      Then query result
+        | result |
+        | "x"    |
+
+    Scenario: to_csv gives sep precedence over a shadowed invalid delimiter alias
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1, 'b', 'x'), map('sep', '|', 'delimiter', '')) AS result
+        """
+      Then query result
+        | result |
+        | 1\|x   |
+
+  Rule: The separator follows Spark's escape grammar (F4, deferred)
+
+    # Spark runs the separator through CSVExprUtils.toDelimiterStr: `\q` is an unsupported special
+    # character and is rejected, while `\t` means an actual tab. Sail keeps the raw string, so it
+    # accepts `\q` and treats `\t` as two literal characters.
+
+    @sail-bug
+    Scenario: to_csv rejects an unsupported special character in the separator
+      When query
+        """
+        SELECT to_csv(named_struct('a', 1, 'b', 'x'), map('sep', '\\q')) AS result
+        """
+      Then query error UNSUPPORTED_SPECIAL_CHARACTER
+
+    @sail-bug
+    Scenario: to_csv unescapes a tab separator
+      # Asserted through the length: Spark turns `\t` into one real tab, so `1<tab>x` is 3 chars;
+      # Sail keeps the two literal characters, so `1\tx` is 4. A raw tab cannot go in a table cell.
+      When query
+        """
+        SELECT length(to_csv(named_struct('a', 1, 'b', 'x'), map('sep', '\\t'))) AS result
+        """
+      Then query result
+        | result |
+        | 3      |
+
+  Rule: Numeric options follow Java's parsing (F5, deferred)
+
+    # Java's `Integer.parseInt` goes through `Character.digit`, which accepts any Unicode Nd digit
+    # (`٥` is Arabic-Indic five, `١٢` is twelve). Rust's `parse::<i32>()` is ASCII-only, so Sail
+    # rejects a value Spark reads fine. `maxCharsPerColumn` behaves identically.
+
+    @sail-only
+    Scenario: from_csv accepts a negative maxColumns
+      # Deliberate divergence, NOT a @sail-bug — do not "fix" this by matching Spark.
+      #
+      #   Spark: throws a raw `java.lang.NegativeArraySizeException: -5` from univocity, which
+      #          allocates the column array with that size. That is a crash, not a validation:
+      #          there is no error class and no message designed for a user.
+      #   Sail:  accepts it and ignores the option (Sail does not implement `maxColumns`), so the
+      #          row parses as if the option were absent.
+      #
+      # Matching Spark here would mean replicating a crash, so the scenario is `@sail-only`
+      # (skipped on the JVM) rather than `@sail-bug` (which would mean "fix this").
+      # For contrast, `maxCharsPerColumn=-1` IS valid in Spark, where a negative means "no limit".
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('maxColumns', '-5')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    @sail-only
+    Scenario: from_csv ignores the writer-only extension option
+      # Deliberate divergence, NOT a @sail-bug — do not "fix" this by validating `extension`.
+      #
+      # `extension` is a file-DataSource WRITER option (SPARK-50616, choosing `.tsv`/`.psv`), not an
+      # expression option. Passing a non-letter value to the EXPRESSION path behaves as:
+      #   Spark: `[INTERNAL_ERROR]` — the expression path does not handle a writer-only option and a
+      #          non-letter value trips an internal assertion. That is a crash, not a designed
+      #          validation (no stable error class/message). Note `ab`/`abcd` are ACCEPTED, so the
+      #          "extension must be exactly 3 letters" rule does not even apply to this path.
+      #   Sail:  ignores the unknown option (as it does every writer-only option), so the row parses.
+      #
+      # Matching Spark would mean replicating an INTERNAL_ERROR, so this is `@sail-only`.
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('extension', 'a1')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    @sail-bug
+    Scenario: from_csv accepts a Unicode decimal digit in an integer option
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('maxColumns', '٥')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+  Rule: samplingRatio uses Java's float grammar (F5, deferred)
+
+    # Spark parses it with Double.parseDouble, which accepts `1d` and rejects `inf`. Sail uses
+    # Rust's f64 parser, which does the opposite.
+
+    @sail-bug
+    Scenario: from_csv accepts a Java-style float samplingRatio
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('samplingRatio', '1d')) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+    @sail-bug
+    Scenario: from_csv rejects the Rust-only float value inf
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('samplingRatio', 'inf')) AS result
+        """
+      Then query error For input string: "inf"
+
+  Rule: The options map must be a foldable map<string,string> (F7, deferred)
+
+    # Spark rejects a non-literal or non-string options map during analysis. Sail reads row zero of
+    # whatever map it is given, so it accepts these instead of rejecting them.
+
+    @sail-bug
+    Scenario: from_csv rejects a non-literal options map
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map_from_arrays(array('header'), array('garbage'))) AS result
+        """
+      Then query error NON_MAP_FUNCTION
+
+    @sail-bug
+    Scenario: from_csv rejects a non-string options map
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('header', 1)) AS result
+        """
+      Then query error NON_STRING_TYPE
+
+  Rule: String options with a validated domain are checked
+
+    # Spark validates the charset (`encoding`, alias `charset`), codec (`compression`, alias
+    # `codec`), and time zone eagerly in the CSVOptions constructor, so a non-null input throws.
+    # Sail now validates the charset and codec against Spark's fixed sets. Each aliased option
+    # validates only its EFFECTIVE value: Spark reads the primary key, falling back to the alias,
+    # and a bad alias is ignored when the primary is valid. The error class diverges by Spark
+    # version (3.5 throws java.io.UnsupportedEncodingException / a plain "not available" message;
+    # 4.x uses INVALID_PARAMETER_VALUE.CHARSET / CODEC_NOT_AVAILABLE), so assert a value or message
+    # fragment common to every version and to Sail.
+
+    Scenario Outline: from_csv rejects a bad effective value of an aliased option: <case>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map(<opts>)) AS result
+        """
+      Then query error <error>
+
+      Examples:
+        | case                                     | opts                                      | error            |
+        | unknown encoding                         | 'encoding', 'utf-99'                      | utf-99           |
+        | unknown charset (encoding's alias)       | 'charset', 'utf-99'                       | utf-99           |
+        | charset ignored when encoding is invalid | 'encoding', 'utf-99', 'charset', 'utf-8'  | utf-99           |
+        | unknown compression codec                | 'compression', 'garbage'                  | is not available |
+        | unknown codec (compression's alias)      | 'codec', 'garbage'                        | is not available |
+        | codec ignored when compression invalid   | 'compression', 'garbage', 'codec', 'gzip' | is not available |
+
+    Scenario Outline: from_csv ignores a bad alias when the primary option is valid: <case>
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map(<opts>)) AS result
+        """
+      Then query result
+        | result |
+        | {1}    |
+
+      Examples:
+        | case                          | opts                                      |
+        | encoding shadows bad charset  | 'encoding', 'utf-8', 'charset', 'utf-99'  |
+        | compression shadows bad codec | 'compression', 'gzip', 'codec', 'garbage' |
+
+    @sail-bug
+    Scenario: from_csv rejects an unknown timeZone
+      When query
+        """
+        SELECT from_csv('1', 'a INT', map('timeZone', 'garbage')) AS result
+        """
+      Then query error INVALID_TIMEZONE
+
+    Scenario: from_csv skips charset validation when the input is NULL
+      # The domain check is lazy too: a NULL input never reaches the parser, so a bad charset is
+      # not seen. This must keep passing even once the divergences above are fixed.
+      When query
+        """
+        SELECT from_csv(CAST(NULL AS STRING), 'a INT', map('encoding', 'utf-99')) AS result
+        """
+      Then query result
+        | result |
+        | NULL   |
diff --git a/python/pysail/tests/spark/function/features/csv/from_csv.feature b/python/pysail/tests/spark/function/features/csv/from_csv.feature
index 6b6dd08d42..635f3f2411 100644
--- a/python/pysail/tests/spark/function/features/csv/from_csv.feature
+++ b/python/pysail/tests/spark/function/features/csv/from_csv.feature
@@ -1,4 +1,4 @@
-@from_csv
+@csv @from_csv
 Feature: from_csv column display name matches Spark
 
   Spark renders `from_csv` as a UnaryExpression: only the input column
diff --git a/python/pysail/tests/spark/function/features/csv/schema_of_csv.feature b/python/pysail/tests/spark/function/features/csv/schema_of_csv.feature
index 0047064295..050e39b27f 100644
--- a/python/pysail/tests/spark/function/features/csv/schema_of_csv.feature
+++ b/python/pysail/tests/spark/function/features/csv/schema_of_csv.feature
@@ -1,4 +1,4 @@
-@schema_of_csv
+@csv @schema_of_csv
 Feature: schema_of_csv infers a CSV schema from a literal row
 
     Scenario Outline: schema_of_csv infers <case>
diff --git a/python/pysail/tests/spark/function/features/csv/to_csv.feature b/python/pysail/tests/spark/function/features/csv/to_csv.feature
index 92a2ba1eb4..32935d5a1a 100644
--- a/python/pysail/tests/spark/function/features/csv/to_csv.feature
+++ b/python/pysail/tests/spark/function/features/csv/to_csv.feature
@@ -1,4 +1,4 @@
-@to_csv
+@csv @to_csv
 Feature: to_csv converts a struct value to a CSV string
 
   Rule: Basic serialization
@@ -32,14 +32,18 @@ Feature: to_csv converts a struct value to a CSV string
 
   Rule: NULL handling
 
+    @sail-bug
     Scenario: NULL struct returns NULL
+      # The value matches Spark, but Sail's column name diverges: Spark folds the NULL cast to
+      # `to_csv(NULL)` in the display name (verified against JVM 4.2), while Sail keeps the full
+      # `CAST(NULL AS STRUCT<...>)`.
       When query
         """
         SELECT to_csv(CAST(NULL AS STRUCT<a:INT, b:INT>))
         """
       Then query result
-        | to_csv(CAST(NULL AS STRUCT<A:INT,B:INT>)) |
-        | NULL                                      |
+        | to_csv(NULL) |
+        | NULL         |
 
     Scenario: Struct with NULL field serializes null field as empty string
       When query
@@ -110,6 +114,7 @@ Feature: to_csv converts a struct value to a CSV string
         | quoteAll quotes custom emptyValue fields                                  | 'a', '', 'b', 'x'                   | 'emptyValue', '_', 'quoteAll', 'true' | "_","x"      |
         | emptyValue containing separator is quoted                                 | 'a', '', 'b', 'x'                   | 'emptyValue', ','                     | ",",x        |
         | Literal escape characters are escaped in quoted fields                    | 'a', 'a#b,c'                        | 'escape', '#'                         | "a##b,c"     |
+        | Custom quote character is used                                            | 'a', 'x'                            | 'quote', '#', 'quoteAll', 'true'      | #x#          |
 
   Rule: Timestamp formatting
 
@@ -147,21 +152,26 @@ Feature: to_csv converts a struct value to a CSV string
 
   Rule: Decimal formatting
 
-    # The negative case needs a separate `name` slot: Spark derives the column
-    # name as `CAST((- 0.99) AS DECIMAL(5,2))`, not `CAST(-0.99 AS DECIMAL(5,2))`.
-    Scenario Outline: Decimal: <case>
+    Scenario: Decimal field is formatted as fixed-point string
       When query
         """
-        SELECT to_csv(named_struct(<args>))
+        SELECT to_csv(named_struct('price', CAST(9.99 AS DECIMAL(5,2))))
         """
       Then query result
-        | to_csv(named_struct(<name>)) |
-        | <result>                     |
+        | to_csv(named_struct(price, CAST(9.99 AS DECIMAL(5,2)))) |
+        | 9.99                                                    |
 
-      Examples:
-        | case                                                             | args                                 | name                                  | result |
-        | Decimal field is formatted as fixed-point string                 | 'price', CAST(9.99 AS DECIMAL(5,2))  | price, CAST(9.99 AS DECIMAL(5,2))     | 9.99   |
-        | Negative decimal preserves sign including fractional-only values | 'price', CAST(-0.99 AS DECIMAL(5,2)) | price, CAST((- 0.99) AS DECIMAL(5,2)) | -0.99  |
+    @sail-bug
+    Scenario: Negative decimal preserves sign including fractional-only values
+      # The value matches Spark; the column name diverges: Spark writes `-0.99` (verified against
+      # JVM 4.2) while Sail renders the negative literal as `(- 0.99)`.
+      When query
+        """
+        SELECT to_csv(named_struct('price', CAST(-0.99 AS DECIMAL(5,2))))
+        """
+      Then query result
+        | to_csv(named_struct(price, CAST(-0.99 AS DECIMAL(5,2)))) |
+        | -0.99                                                   |
 
   Rule: Complex and special values