Skip to main content

nautilus_serialization/arrow/
greeks.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Arrow schemas and codecs for calculated Greeks and yield curve custom data.
17
18use std::{borrow::Borrow, collections::HashMap, sync::Arc};
19
20use arrow::{
21    array::{
22        Array, ArrayRef, BooleanArray, Float64Array, Float64Builder, Int32Array, ListArray,
23        ListBuilder, StringArray, UInt64Array,
24    },
25    datatypes::{DataType, Field, Schema},
26    error::ArrowError,
27    record_batch::RecordBatch,
28};
29use nautilus_model::{
30    data::{
31        CustomData, CustomDataTrait, Data,
32        greeks::{GreeksData, OptionGreekValues, PortfolioGreeks, YieldCurve},
33    },
34    identifiers::InstrumentId,
35};
36
37use super::{
38    ArrowSchemaProvider, DecodeDataFromRecordBatch, DecodeTypedFromRecordBatch,
39    EncodeToRecordBatch, EncodingError, StringColumnRef, extract_column_by_name,
40    extract_column_string, identifier_array_from_display, metadata_with_type_name,
41    record_batch_with_timestamps, record_batch_with_u64_timestamps, timestamp_data_type,
42};
43
44impl ArrowSchemaProvider for GreeksData {
45    fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
46        let mut fields = vec![
47            Field::new("ts_init", timestamp_data_type(), false),
48            Field::new("ts_event", timestamp_data_type(), false),
49            Field::new("instrument_id", DataType::Utf8, false),
50            Field::new("is_call", DataType::Boolean, false),
51            Field::new("strike", DataType::Float64, false),
52            Field::new("expiry", DataType::Int32, false),
53            Field::new("expiry_in_days", DataType::Int32, false),
54            Field::new("expiry_in_years", DataType::Float64, false),
55            Field::new("multiplier", DataType::Float64, false),
56            Field::new("quantity", DataType::Float64, false),
57            Field::new("underlying_price", DataType::Float64, false),
58            Field::new("interest_rate", DataType::Float64, false),
59            Field::new("cost_of_carry", DataType::Float64, false),
60            Field::new("vol", DataType::Float64, false),
61            Field::new("pnl", DataType::Float64, false),
62            Field::new("price", DataType::Float64, false),
63        ];
64
65        fields.extend(greek_fields());
66        fields.push(Field::new("itm_prob", DataType::Float64, false));
67        Schema::new_with_metadata(fields, metadata_with_type_name("GreeksData", metadata))
68    }
69}
70
71impl EncodeToRecordBatch for GreeksData {
72    fn encode_batch<T: Borrow<Self>>(
73        metadata: &HashMap<String, String>,
74        data: &[T],
75    ) -> Result<RecordBatch, ArrowError> {
76        let mut columns: Vec<ArrayRef> = vec![
77            Arc::new(UInt64Array::from_iter_values(
78                data.iter().map(|value| value.borrow().ts_init.as_u64()),
79            )),
80            Arc::new(UInt64Array::from_iter_values(
81                data.iter().map(|value| value.borrow().ts_event.as_u64()),
82            )),
83            Arc::new(identifier_array_from_display(
84                data.iter().map(|value| value.borrow().instrument_id),
85            )),
86            Arc::new(BooleanArray::from(
87                data.iter()
88                    .map(|value| value.borrow().is_call)
89                    .collect::<Vec<_>>(),
90            )),
91            Arc::new(Float64Array::from_iter_values(
92                data.iter().map(|value| value.borrow().strike),
93            )),
94            Arc::new(Int32Array::from_iter_values(
95                data.iter().map(|value| value.borrow().expiry),
96            )),
97            Arc::new(Int32Array::from_iter_values(
98                data.iter().map(|value| value.borrow().expiry_in_days),
99            )),
100            Arc::new(Float64Array::from_iter_values(
101                data.iter().map(|value| value.borrow().expiry_in_years),
102            )),
103            Arc::new(Float64Array::from_iter_values(
104                data.iter().map(|value| value.borrow().multiplier),
105            )),
106            Arc::new(Float64Array::from_iter_values(
107                data.iter().map(|value| value.borrow().quantity),
108            )),
109            Arc::new(Float64Array::from_iter_values(
110                data.iter().map(|value| value.borrow().underlying_price),
111            )),
112            Arc::new(Float64Array::from_iter_values(
113                data.iter().map(|value| value.borrow().interest_rate),
114            )),
115            Arc::new(Float64Array::from_iter_values(
116                data.iter().map(|value| value.borrow().cost_of_carry),
117            )),
118            Arc::new(Float64Array::from_iter_values(
119                data.iter().map(|value| value.borrow().vol),
120            )),
121            Arc::new(Float64Array::from_iter_values(
122                data.iter().map(|value| value.borrow().pnl),
123            )),
124            Arc::new(Float64Array::from_iter_values(
125                data.iter().map(|value| value.borrow().price),
126            )),
127        ];
128
129        columns.extend(greek_columns(
130            data.iter().map(|value| value.borrow().greeks),
131        ));
132        columns.push(Arc::new(Float64Array::from_iter_values(
133            data.iter().map(|value| value.borrow().itm_prob),
134        )));
135        record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
136    }
137
138    fn metadata(&self) -> HashMap<String, String> {
139        metadata_with_type_name(Self::type_name_static(), None)
140    }
141}
142
143impl DecodeTypedFromRecordBatch for GreeksData {
144    fn decode_typed_batch(
145        _metadata: &HashMap<String, String>,
146        batch: RecordBatch,
147    ) -> Result<Vec<Self>, EncodingError> {
148        let batch = record_batch_with_u64_timestamps(&batch)?;
149        let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
150        let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
151        let instrument_id = required_string_column(&batch, "instrument_id")?;
152        let is_call = required_column::<BooleanArray>(&batch, "is_call", DataType::Boolean)?;
153        let strike = required_column::<Float64Array>(&batch, "strike", DataType::Float64)?;
154        let expiry = required_column::<Int32Array>(&batch, "expiry", DataType::Int32)?;
155        let expiry_in_days =
156            required_column::<Int32Array>(&batch, "expiry_in_days", DataType::Int32)?;
157        let expiry_in_years =
158            required_column::<Float64Array>(&batch, "expiry_in_years", DataType::Float64)?;
159        let multiplier = required_column::<Float64Array>(&batch, "multiplier", DataType::Float64)?;
160        let quantity = required_column::<Float64Array>(&batch, "quantity", DataType::Float64)?;
161        let underlying_price =
162            required_column::<Float64Array>(&batch, "underlying_price", DataType::Float64)?;
163        let interest_rate =
164            required_column::<Float64Array>(&batch, "interest_rate", DataType::Float64)?;
165        let cost_of_carry =
166            required_column::<Float64Array>(&batch, "cost_of_carry", DataType::Float64)?;
167        let vol = required_column::<Float64Array>(&batch, "vol", DataType::Float64)?;
168        let pnl = required_column::<Float64Array>(&batch, "pnl", DataType::Float64)?;
169        let price = required_column::<Float64Array>(&batch, "price", DataType::Float64)?;
170        let itm_prob = required_column::<Float64Array>(&batch, "itm_prob", DataType::Float64)?;
171        let greeks = decode_greeks(&batch)?;
172
173        (0..batch.num_rows())
174            .map(|row| {
175                Ok(Self {
176                    instrument_id: instrument_id
177                        .value(row)
178                        .parse::<InstrumentId>()
179                        .map_err(|e| EncodingError::ParseError("instrument_id", e.to_string()))?,
180                    is_call: is_call.value(row),
181                    strike: strike.value(row),
182                    expiry: expiry.value(row),
183                    expiry_in_days: expiry_in_days.value(row),
184                    expiry_in_years: expiry_in_years.value(row),
185                    multiplier: multiplier.value(row),
186                    quantity: quantity.value(row),
187                    underlying_price: underlying_price.value(row),
188                    interest_rate: interest_rate.value(row),
189                    cost_of_carry: cost_of_carry.value(row),
190                    vol: vol.value(row),
191                    pnl: pnl.value(row),
192                    price: price.value(row),
193                    greeks: greeks[row],
194                    itm_prob: itm_prob.value(row),
195                    ts_event: ts_event.value(row).into(),
196                    ts_init: ts_init.value(row).into(),
197                })
198            })
199            .collect()
200    }
201}
202
203impl ArrowSchemaProvider for PortfolioGreeks {
204    fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
205        let mut fields = vec![
206            Field::new("ts_init", timestamp_data_type(), false),
207            Field::new("ts_event", timestamp_data_type(), false),
208            Field::new("pnl", DataType::Float64, false),
209            Field::new("price", DataType::Float64, false),
210        ];
211
212        fields.extend(greek_fields());
213        Schema::new_with_metadata(fields, metadata_with_type_name("PortfolioGreeks", metadata))
214    }
215}
216
217impl EncodeToRecordBatch for PortfolioGreeks {
218    fn encode_batch<T: Borrow<Self>>(
219        metadata: &HashMap<String, String>,
220        data: &[T],
221    ) -> Result<RecordBatch, ArrowError> {
222        let mut columns: Vec<ArrayRef> = vec![
223            Arc::new(UInt64Array::from_iter_values(
224                data.iter().map(|value| value.borrow().ts_init.as_u64()),
225            )),
226            Arc::new(UInt64Array::from_iter_values(
227                data.iter().map(|value| value.borrow().ts_event.as_u64()),
228            )),
229            Arc::new(Float64Array::from_iter_values(
230                data.iter().map(|value| value.borrow().pnl),
231            )),
232            Arc::new(Float64Array::from_iter_values(
233                data.iter().map(|value| value.borrow().price),
234            )),
235        ];
236
237        columns.extend(greek_columns(
238            data.iter().map(|value| value.borrow().greeks),
239        ));
240        record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
241    }
242
243    fn metadata(&self) -> HashMap<String, String> {
244        metadata_with_type_name("PortfolioGreeks", None)
245    }
246}
247
248impl DecodeTypedFromRecordBatch for PortfolioGreeks {
249    fn decode_typed_batch(
250        _metadata: &HashMap<String, String>,
251        batch: RecordBatch,
252    ) -> Result<Vec<Self>, EncodingError> {
253        let batch = record_batch_with_u64_timestamps(&batch)?;
254        let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
255        let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
256        let pnl = required_column::<Float64Array>(&batch, "pnl", DataType::Float64)?;
257        let price = required_column::<Float64Array>(&batch, "price", DataType::Float64)?;
258        let greeks = decode_greeks(&batch)?;
259
260        (0..batch.num_rows())
261            .map(|row| {
262                Ok(Self {
263                    pnl: pnl.value(row),
264                    price: price.value(row),
265                    greeks: greeks[row],
266                    ts_event: ts_event.value(row).into(),
267                    ts_init: ts_init.value(row).into(),
268                })
269            })
270            .collect()
271    }
272}
273
274impl ArrowSchemaProvider for YieldCurve {
275    fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
276        let fields = vec![
277            Field::new("ts_init", timestamp_data_type(), false),
278            Field::new("ts_event", timestamp_data_type(), false),
279            Field::new("curve_name", DataType::Utf8, false),
280            Field::new("tenors", float_list_data_type(), false),
281            Field::new("interest_rates", float_list_data_type(), false),
282        ];
283        Schema::new_with_metadata(
284            fields,
285            metadata_with_type_name(Self::type_name_static(), metadata),
286        )
287    }
288}
289
290impl EncodeToRecordBatch for YieldCurve {
291    fn encode_batch<T: Borrow<Self>>(
292        metadata: &HashMap<String, String>,
293        data: &[T],
294    ) -> Result<RecordBatch, ArrowError> {
295        let columns: Vec<ArrayRef> = vec![
296            Arc::new(UInt64Array::from_iter_values(
297                data.iter().map(|value| value.borrow().ts_init.as_u64()),
298            )),
299            Arc::new(UInt64Array::from_iter_values(
300                data.iter().map(|value| value.borrow().ts_event.as_u64()),
301            )),
302            Arc::new(StringArray::from_iter_values(
303                data.iter().map(|value| value.borrow().curve_name.as_str()),
304            )),
305            Arc::new(float_lists(
306                data.iter().map(|value| value.borrow().tenors.as_slice()),
307            )),
308            Arc::new(float_lists(
309                data.iter()
310                    .map(|value| value.borrow().interest_rates.as_slice()),
311            )),
312        ];
313        record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
314    }
315
316    fn metadata(&self) -> HashMap<String, String> {
317        metadata_with_type_name(Self::type_name_static(), None)
318    }
319}
320
321impl DecodeTypedFromRecordBatch for YieldCurve {
322    fn decode_typed_batch(
323        _metadata: &HashMap<String, String>,
324        batch: RecordBatch,
325    ) -> Result<Vec<Self>, EncodingError> {
326        let batch = record_batch_with_u64_timestamps(&batch)?;
327        let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
328        let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
329        let curve_name = required_string_column(&batch, "curve_name")?;
330        let tenors = required_column::<ListArray>(&batch, "tenors", float_list_data_type())?;
331        let interest_rates =
332            required_column::<ListArray>(&batch, "interest_rates", float_list_data_type())?;
333        (0..batch.num_rows())
334            .map(|row| {
335                Ok(Self {
336                    curve_name: curve_name.value(row).to_string(),
337                    tenors: decode_float_list(tenors, "tenors", row)?,
338                    interest_rates: decode_float_list(interest_rates, "interest_rates", row)?,
339                    ts_event: ts_event.value(row).into(),
340                    ts_init: ts_init.value(row).into(),
341                })
342            })
343            .collect()
344    }
345}
346
347macro_rules! impl_greeks_custom_data_decode {
348    ($($type:ident),+ $(,)?) => {
349        $(
350            impl DecodeDataFromRecordBatch for $type {
351                fn decode_data_batch(
352                    metadata: &HashMap<String, String>,
353                    record_batch: RecordBatch,
354                ) -> Result<Vec<Data>, EncodingError> {
355                    Ok(Self::decode_typed_batch(metadata, record_batch)?
356                        .into_iter()
357                        .map(|data| Data::Custom(CustomData::from_arc(Arc::new(data))))
358                        .collect())
359                }
360            }
361        )+
362    };
363}
364impl_greeks_custom_data_decode!(GreeksData, PortfolioGreeks, YieldCurve);
365
366fn greek_fields() -> Vec<Field> {
367    ["delta", "gamma", "vega", "theta", "rho"]
368        .into_iter()
369        .map(|name| Field::new(name, DataType::Float64, false))
370        .collect()
371}
372
373fn greek_columns(values: impl Iterator<Item = OptionGreekValues> + Clone) -> Vec<ArrayRef> {
374    vec![
375        Arc::new(Float64Array::from_iter_values(
376            values.clone().map(|value| value.delta),
377        )),
378        Arc::new(Float64Array::from_iter_values(
379            values.clone().map(|value| value.gamma),
380        )),
381        Arc::new(Float64Array::from_iter_values(
382            values.clone().map(|value| value.vega),
383        )),
384        Arc::new(Float64Array::from_iter_values(
385            values.clone().map(|value| value.theta),
386        )),
387        Arc::new(Float64Array::from_iter_values(
388            values.map(|value| value.rho),
389        )),
390    ]
391}
392
393fn decode_greeks(batch: &RecordBatch) -> Result<Vec<OptionGreekValues>, EncodingError> {
394    let delta = required_column::<Float64Array>(batch, "delta", DataType::Float64)?;
395    let gamma = required_column::<Float64Array>(batch, "gamma", DataType::Float64)?;
396    let vega = required_column::<Float64Array>(batch, "vega", DataType::Float64)?;
397    let theta = required_column::<Float64Array>(batch, "theta", DataType::Float64)?;
398    let rho = required_column::<Float64Array>(batch, "rho", DataType::Float64)?;
399    Ok((0..batch.num_rows())
400        .map(|row| OptionGreekValues {
401            delta: delta.value(row),
402            gamma: gamma.value(row),
403            vega: vega.value(row),
404            theta: theta.value(row),
405            rho: rho.value(row),
406        })
407        .collect())
408}
409
410fn required_column<'a, A: Array + 'static>(
411    batch: &'a RecordBatch,
412    name: &'static str,
413    data_type: DataType,
414) -> Result<&'a A, EncodingError> {
415    let column = extract_column_by_name::<A>(batch, name, data_type)?;
416
417    if column.null_count() != 0 {
418        return Err(EncodingError::ParseError(
419            name,
420            "required column contains nulls".to_string(),
421        ));
422    }
423
424    Ok(column)
425}
426
427fn required_string_column<'a>(
428    batch: &'a RecordBatch,
429    name: &'static str,
430) -> Result<StringColumnRef<'a>, EncodingError> {
431    let index = batch.schema().index_of(name)?;
432    let column = extract_column_string(batch.columns(), name, index)?;
433
434    if batch.column(index).logical_null_count() != 0 {
435        return Err(EncodingError::ParseError(
436            name,
437            "required column contains nulls".to_string(),
438        ));
439    }
440
441    Ok(column)
442}
443
444fn float_list_data_type() -> DataType {
445    DataType::List(Arc::new(Field::new("item", DataType::Float64, true)))
446}
447
448fn float_lists<'a>(values: impl Iterator<Item = &'a [f64]>) -> ListArray {
449    let mut builder = ListBuilder::new(Float64Builder::new());
450    for values in values {
451        builder.values().append_slice(values);
452        builder.append(true);
453    }
454
455    builder.finish()
456}
457
458fn decode_float_list(
459    values: &ListArray,
460    name: &'static str,
461    row: usize,
462) -> Result<Vec<f64>, EncodingError> {
463    let values = values.value(row);
464
465    let values = values
466        .as_any()
467        .downcast_ref::<Float64Array>()
468        .ok_or_else(|| {
469            EncodingError::ParseError(name, "expected Float64 list values".to_string())
470        })?;
471
472    if values.null_count() != 0 {
473        return Err(EncodingError::ParseError(
474            name,
475            format!("row {row}: list contains nulls"),
476        ));
477    }
478
479    Ok(values.values().to_vec())
480}
481
482#[cfg(test)]
483mod tests {
484    use nautilus_model::data::{decode_custom_from_arrow, encode_custom_to_arrow};
485    use rstest::rstest;
486
487    use super::*;
488    use crate::arrow::KEY_TYPE_NAME;
489
490    fn sensitivities() -> OptionGreekValues {
491        OptionGreekValues {
492            delta: 0.41,
493            gamma: 0.0012,
494            vega: 11.2,
495            theta: -2.3,
496            rho: 1.7,
497        }
498    }
499
500    fn assert_sensitivities(actual: OptionGreekValues, expected: OptionGreekValues) {
501        assert_eq!(actual.delta.to_bits(), expected.delta.to_bits());
502        assert_eq!(actual.gamma.to_bits(), expected.gamma.to_bits());
503        assert_eq!(actual.vega.to_bits(), expected.vega.to_bits());
504        assert_eq!(actual.theta.to_bits(), expected.theta.to_bits());
505        assert_eq!(actual.rho.to_bits(), expected.rho.to_bits());
506    }
507
508    #[rstest]
509    fn test_greeks_data_round_trip() {
510        let first = GreeksData::new(
511            "ESZ26 C7000.XCME".parse().unwrap(),
512            false,
513            7000.5,
514            20_261_218,
515            -68,
516            0.186,
517            50.0,
518            -3.0,
519            6950.25,
520            0.0425,
521            0.0125,
522            0.175,
523            12.5,
524            98.75,
525            sensitivities(),
526            0.62,
527            11.into(),
528            13.into(),
529        );
530        let mut second = first.clone();
531        second.instrument_id = "ESZ26 P6900.XCME".parse().unwrap();
532        second.is_call = true;
533        second.ts_init = 31.into();
534        second.ts_event = 29.into();
535        second.greeks.rho = -0.0;
536        second.greeks.delta = f64::from_bits(0x3fe0_0000_0000_0001);
537        let values = [first, second];
538        let batch = GreeksData::encode_batch(&values[0].metadata(), &values).unwrap();
539        let decoded =
540            GreeksData::decode_typed_batch(batch.schema().metadata(), batch.clone()).unwrap();
541
542        assert_eq!(
543            batch
544                .schema()
545                .field_with_name("expiry")
546                .unwrap()
547                .data_type(),
548            &DataType::Int32
549        );
550        assert_eq!(
551            batch.schema().field_with_name("rho").unwrap().data_type(),
552            &DataType::Float64
553        );
554        assert_eq!(decoded.len(), values.len());
555
556        for (actual, expected) in decoded.iter().zip(&values) {
557            assert_eq!(actual.instrument_id, expected.instrument_id);
558            assert_eq!(actual.is_call, expected.is_call);
559            assert_eq!(actual.expiry, expected.expiry);
560            assert_eq!(actual.expiry_in_days, expected.expiry_in_days);
561            assert_eq!(actual.ts_init, expected.ts_init);
562            assert_eq!(actual.ts_event, expected.ts_event);
563            macro_rules! assert_float { ($($field:ident),+) => { $(assert_eq!(actual.$field.to_bits(), expected.$field.to_bits(), stringify!($field));)+ }; }
564            assert_float!(
565                strike,
566                expiry_in_years,
567                multiplier,
568                quantity,
569                underlying_price,
570                interest_rate,
571                cost_of_carry,
572                vol,
573                pnl,
574                price,
575                itm_prob
576            );
577            assert_sensitivities(actual.greeks, expected.greeks);
578        }
579    }
580
581    #[rstest]
582    fn test_portfolio_greeks_round_trip() {
583        let values = [PortfolioGreeks {
584            pnl: -125.5,
585            price: 4310.25,
586            greeks: sensitivities(),
587            ts_event: 19.into(),
588            ts_init: 17.into(),
589        }];
590
591        let batch = PortfolioGreeks::encode_batch(&values[0].metadata(), &values).unwrap();
592        let decoded =
593            PortfolioGreeks::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
594
595        assert_eq!(decoded.len(), values.len());
596        assert_eq!(decoded[0].ts_init, values[0].ts_init);
597        assert_eq!(decoded[0].ts_event, values[0].ts_event);
598        assert_eq!(decoded[0].pnl.to_bits(), values[0].pnl.to_bits());
599        assert_eq!(decoded[0].price.to_bits(), values[0].price.to_bits());
600        assert_sensitivities(decoded[0].greeks, values[0].greeks);
601    }
602
603    #[rstest]
604    #[case::instrument(Arc::new(GreeksData::from_delta(
605        "ES.GLBX".parse().unwrap(), 1.25, 8.0, 11.into(),
606    )))]
607    #[case::portfolio(Arc::new(PortfolioGreeks {
608        pnl: -125.5,
609        price: 4310.25,
610        greeks: sensitivities(),
611        ts_event: 19.into(),
612        ts_init: 17.into(),
613    }))]
614    #[case::yield_curve(Arc::new(YieldCurve::new(
615        "USD-SOFR".to_string(),
616        vec![0.25, 1.0, 5.0],
617        vec![0.043, 0.041, 0.038],
618        23.into(),
619        29.into(),
620    )))]
621    fn test_greeks_registered_custom_data_round_trip(#[case] item: Arc<dyn CustomDataTrait>) {
622        crate::ensure_custom_data_registered::<GreeksData>();
623        crate::ensure_custom_data_registered::<PortfolioGreeks>();
624        crate::ensure_custom_data_registered::<YieldCurve>();
625        let type_name = item.type_name();
626
627        let batch = encode_custom_to_arrow(type_name, std::slice::from_ref(&item))
628            .unwrap()
629            .unwrap();
630        let metadata = batch.schema().metadata().clone();
631        let decoded = decode_custom_from_arrow(type_name, &metadata, batch)
632            .unwrap()
633            .unwrap();
634
635        let [Data::Custom(custom)] = decoded.as_slice() else {
636            panic!("expected one custom data row, was {decoded:?}");
637        };
638
639        assert_eq!(custom.data_type.type_name(), type_name);
640        assert_eq!(
641            metadata,
642            HashMap::from([(KEY_TYPE_NAME.to_string(), type_name.to_string())]),
643        );
644        assert!(custom.data.eq_arc(item.as_ref()));
645    }
646
647    #[rstest]
648    #[case(vec![0.25, 1.0, 5.0], vec![0.043, 0.041, 0.038])]
649    #[case(vec![], vec![-0.0, f64::from_bits(0x3fe0_0000_0000_0001)])]
650    fn test_yield_curve_round_trip(#[case] tenors: Vec<f64>, #[case] interest_rates: Vec<f64>) {
651        let curve = YieldCurve::new(
652            "USD-SOFR".to_string(),
653            tenors,
654            interest_rates,
655            23.into(),
656            29.into(),
657        );
658        let batch =
659            YieldCurve::encode_batch(&curve.metadata(), std::slice::from_ref(&curve)).unwrap();
660        let decoded = YieldCurve::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
661
662        assert_eq!(decoded.len(), 1);
663        assert_eq!(decoded[0].ts_init, curve.ts_init);
664        assert_eq!(decoded[0].ts_event, curve.ts_event);
665        assert_eq!(decoded[0].curve_name, curve.curve_name);
666        assert_eq!(
667            decoded[0]
668                .tenors
669                .iter()
670                .map(|v| v.to_bits())
671                .collect::<Vec<_>>(),
672            curve.tenors.iter().map(|v| v.to_bits()).collect::<Vec<_>>()
673        );
674        assert_eq!(
675            decoded[0]
676                .interest_rates
677                .iter()
678                .map(|v| v.to_bits())
679                .collect::<Vec<_>>(),
680            curve
681                .interest_rates
682                .iter()
683                .map(|v| v.to_bits())
684                .collect::<Vec<_>>()
685        );
686    }
687
688    #[rstest]
689    fn test_native_greeks_empty_batches() {
690        macro_rules! assert_empty {
691            ($type:ty) => {{
692                let batch = <$type>::encode_batch(&HashMap::new(), &Vec::<$type>::new()).unwrap();
693                let decoded =
694                    <$type>::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
695                assert!(decoded.is_empty());
696            }};
697        }
698        assert_empty!(GreeksData);
699        assert_empty!(PortfolioGreeks);
700        assert_empty!(YieldCurve);
701    }
702
703    #[rstest]
704    #[case("pnl")]
705    #[case("rho")]
706    fn test_portfolio_greeks_rejects_null_values(#[case] name: &'static str) {
707        let value = PortfolioGreeks {
708            pnl: -125.5,
709            price: 4310.25,
710            greeks: sensitivities(),
711            ts_event: 19.into(),
712            ts_init: 17.into(),
713        };
714
715        let batch = PortfolioGreeks::encode_batch(&value.metadata(), &[value]).unwrap();
716        let index = batch.schema().index_of(name).unwrap();
717        let mut fields = batch.schema().fields().to_vec();
718        fields[index] = Arc::new(fields[index].as_ref().clone().with_nullable(true));
719        let mut columns = batch.columns().to_vec();
720        columns[index] = Arc::new(Float64Array::from(vec![None::<f64>]));
721        let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
722        let error = PortfolioGreeks::decode_typed_batch(&HashMap::new(), batch).unwrap_err();
723
724        assert!(
725            matches!(error, EncodingError::ParseError(field, ref message)
726            if field == name && message == "required column contains nulls")
727        );
728    }
729
730    #[rstest]
731    #[case(Some("USD-SOFR"))]
732    #[case(None)]
733    fn test_yield_curve_dictionary_name(#[case] name: Option<&str>) {
734        use arrow::{
735            array::{DictionaryArray, Int8Array},
736            datatypes::Int8Type,
737        };
738
739        let value = YieldCurve::new(
740            "USD-SOFR".to_string(),
741            vec![0.25],
742            vec![0.043],
743            23.into(),
744            29.into(),
745        );
746        let batch = YieldCurve::encode_batch(&value.metadata(), &[value]).unwrap();
747        let index = batch.schema().index_of("curve_name").unwrap();
748        let names = DictionaryArray::<Int8Type>::try_new(
749            Int8Array::from(vec![0]),
750            Arc::new(StringArray::from(vec![name])),
751        )
752        .unwrap();
753        let mut fields = batch.schema().fields().to_vec();
754        fields[index] = Arc::new(Field::new("curve_name", names.data_type().clone(), true));
755        let mut columns = batch.columns().to_vec();
756        columns[index] = Arc::new(names);
757        let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
758        let decoded = YieldCurve::decode_typed_batch(&HashMap::new(), batch);
759
760        match name {
761            Some(name) => assert_eq!(decoded.unwrap()[0].curve_name, name),
762            None => assert!(
763                matches!(decoded.unwrap_err(), EncodingError::ParseError("curve_name", ref message) if message == "required column contains nulls")
764            ),
765        }
766    }
767
768    #[rstest]
769    #[case("curve_name")]
770    #[case("tenors")]
771    #[case("interest_rates")]
772    fn test_yield_curve_rejects_null_values(#[case] name: &'static str) {
773        let value = YieldCurve::new(
774            "USD-SOFR".to_string(),
775            vec![0.25],
776            vec![0.043],
777            23.into(),
778            29.into(),
779        );
780        let batch = YieldCurve::encode_batch(&value.metadata(), &[value]).unwrap();
781        let index = batch.schema().index_of(name).unwrap();
782        let mut fields = batch.schema().fields().to_vec();
783        let mut columns = batch.columns().to_vec();
784
785        let expected = if name == "curve_name" {
786            fields[index] = Arc::new(fields[index].as_ref().clone().with_nullable(true));
787            columns[index] = Arc::new(StringArray::from(vec![None::<&str>]));
788            "required column contains nulls"
789        } else {
790            let mut builder = ListBuilder::new(Float64Builder::new());
791            builder.values().append_null();
792            builder.append(true);
793            columns[index] = Arc::new(builder.finish());
794            "row 0: list contains nulls"
795        };
796
797        let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
798        let error = YieldCurve::decode_typed_batch(&HashMap::new(), batch).unwrap_err();
799
800        assert!(
801            matches!(error, EncodingError::ParseError(field, ref message)
802            if field == name && message == expected)
803        );
804    }
805}