Skip to main content

nautilus_infrastructure/sql/models/
orders.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
16use std::str::FromStr;
17
18use indexmap::IndexMap;
19use nautilus_core::{UUID4, UnixNanos};
20use nautilus_model::{
21    enums::{
22        ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, TimeInForce, TriggerType,
23    },
24    events::{
25        OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled, OrderDenied,
26        OrderEmulated, OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized,
27        OrderModifyDenied, OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate,
28        OrderRejected, OrderReleased, OrderSnapshot, OrderSubmitted, OrderTriggered, OrderUpdated,
29    },
30    identifiers::{
31        AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
32        StrategyId, TradeId, TraderId, VenueOrderId,
33    },
34    types::{Currency, Price, Quantity},
35};
36use rust_decimal::Decimal;
37use sqlx::{FromRow, Row, postgres::PgRow};
38use ustr::Ustr;
39
40use crate::sql::models::{decode_money, enums::TrailingOffsetTypePg};
41
42#[derive(Debug)]
43pub struct OrderEventAnyRow(pub OrderEventAny);
44
45#[derive(Debug)]
46pub struct OrderAcceptedRow(pub OrderAccepted);
47
48#[derive(Debug)]
49pub struct OrderCancelDeniedRow(pub OrderCancelDenied);
50
51#[derive(Debug)]
52pub struct OrderCancelRejectedRow(pub OrderCancelRejected);
53
54#[derive(Debug)]
55pub struct OrderCanceledRow(pub OrderCanceled);
56
57#[derive(Debug)]
58pub struct OrderDeniedRow(pub OrderDenied);
59
60#[derive(Debug)]
61pub struct OrderEmulatedRow(pub OrderEmulated);
62
63#[derive(Debug)]
64pub struct OrderExpiredRow(pub OrderExpired);
65
66#[derive(Debug)]
67pub struct OrderFilledRow(pub OrderFilled);
68
69#[derive(Debug)]
70pub struct OrderFillVoidedRow(pub OrderFillVoided);
71
72#[derive(Debug)]
73pub struct OrderInitializedRow(pub OrderInitialized);
74
75#[derive(Debug)]
76pub struct OrderModifyDeniedRow(pub OrderModifyDenied);
77
78#[derive(Debug)]
79pub struct OrderModifyRejectedRow(pub OrderModifyRejected);
80
81#[derive(Debug)]
82pub struct OrderPendingCancelRow(pub OrderPendingCancel);
83
84#[derive(Debug)]
85pub struct OrderPendingUpdateRow(pub OrderPendingUpdate);
86
87#[derive(Debug)]
88pub struct OrderRejectedRow(pub OrderRejected);
89
90#[derive(Debug)]
91pub struct OrderReleasedRow(pub OrderReleased);
92
93#[derive(Debug)]
94pub struct OrderSubmittedRow(pub OrderSubmitted);
95
96#[derive(Debug)]
97pub struct OrderTriggeredRow(pub OrderTriggered);
98
99#[derive(Debug)]
100pub struct OrderUpdatedRow(pub OrderUpdated);
101
102#[derive(Debug)]
103pub struct OrderSnapshotRow(pub OrderSnapshot);
104
105impl<'r> FromRow<'r, PgRow> for OrderEventAnyRow {
106    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
107        let kind = row.get::<String, _>("kind");
108        match kind.as_str() {
109            "OrderAccepted" => {
110                let row = OrderAcceptedRow::from_row(row)?;
111                Ok(Self(OrderEventAny::Accepted(row.0)))
112            }
113            "OrderCancelDenied" => {
114                let row = OrderCancelDeniedRow::from_row(row)?;
115                Ok(Self(OrderEventAny::CancelDenied(row.0)))
116            }
117            "OrderCancelRejected" => {
118                let row = OrderCancelRejectedRow::from_row(row)?;
119                Ok(Self(OrderEventAny::CancelRejected(row.0)))
120            }
121            "OrderCanceled" => {
122                let row = OrderCanceledRow::from_row(row)?;
123                Ok(Self(OrderEventAny::Canceled(row.0)))
124            }
125            "OrderDenied" => {
126                let row = OrderDeniedRow::from_row(row)?;
127                Ok(Self(OrderEventAny::Denied(row.0)))
128            }
129            "OrderEmulated" => {
130                let row = OrderEmulatedRow::from_row(row)?;
131                Ok(Self(OrderEventAny::Emulated(row.0)))
132            }
133            "OrderExpired" => {
134                let row = OrderExpiredRow::from_row(row)?;
135                Ok(Self(OrderEventAny::Expired(row.0)))
136            }
137            "OrderFillVoided" => {
138                let row = OrderFillVoidedRow::from_row(row)?;
139                Ok(Self(OrderEventAny::FillVoided(row.0)))
140            }
141            "OrderFilled" => {
142                let row = OrderFilledRow::from_row(row)?;
143                Ok(Self(OrderEventAny::Filled(row.0)))
144            }
145            "OrderInitialized" => {
146                let row = OrderInitializedRow::from_row(row)?;
147                Ok(Self(OrderEventAny::Initialized(row.0)))
148            }
149            "OrderModifyDenied" => {
150                let row = OrderModifyDeniedRow::from_row(row)?;
151                Ok(Self(OrderEventAny::ModifyDenied(row.0)))
152            }
153            "OrderModifyRejected" => {
154                let row = OrderModifyRejectedRow::from_row(row)?;
155                Ok(Self(OrderEventAny::ModifyRejected(row.0)))
156            }
157            "OrderPendingCancel" => {
158                let row = OrderPendingCancelRow::from_row(row)?;
159                Ok(Self(OrderEventAny::PendingCancel(row.0)))
160            }
161            "OrderPendingUpdate" => {
162                let row = OrderPendingUpdateRow::from_row(row)?;
163                Ok(Self(OrderEventAny::PendingUpdate(row.0)))
164            }
165            "OrderRejected" => {
166                let row = OrderRejectedRow::from_row(row)?;
167                Ok(Self(OrderEventAny::Rejected(row.0)))
168            }
169            "OrderReleased" => {
170                let row = OrderReleasedRow::from_row(row)?;
171                Ok(Self(OrderEventAny::Released(row.0)))
172            }
173            "OrderSubmitted" => {
174                let row = OrderSubmittedRow::from_row(row)?;
175                Ok(Self(OrderEventAny::Submitted(row.0)))
176            }
177            "OrderTriggered" => {
178                let row = OrderTriggeredRow::from_row(row)?;
179                Ok(Self(OrderEventAny::Triggered(row.0)))
180            }
181            "OrderUpdated" => {
182                let row = OrderUpdatedRow::from_row(row)?;
183                Ok(Self(OrderEventAny::Updated(row.0)))
184            }
185            _ => Err(sqlx::Error::Decode(
186                format!("Unknown order event kind: {kind} in Postgres transformation").into(),
187            )),
188        }
189    }
190}
191
192impl<'r> FromRow<'r, PgRow> for OrderInitializedRow {
193    #[expect(
194        clippy::too_many_lines,
195        reason = "SQL row mapping mirrors the full order initialized event constructor"
196    )]
197    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
198        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
199        let client_order_id = row
200            .try_get::<&str, _>("client_order_id")
201            .map(ClientOrderId::from)?;
202        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
203        let strategy_id = row
204            .try_get::<&str, _>("strategy_id")
205            .map(StrategyId::from)?;
206        let instrument_id = row
207            .try_get::<&str, _>("instrument_id")
208            .map(InstrumentId::from)?;
209        let order_type = row
210            .try_get::<&str, _>("order_type")
211            .map(|x| OrderType::from_str(x).unwrap())?;
212        let order_side = row
213            .try_get::<&str, _>("order_side")
214            .map(|x| OrderSide::from_str(x).unwrap())?;
215        let quantity = row.try_get::<&str, _>("quantity").map(Quantity::from)?;
216        let time_in_force = row
217            .try_get::<&str, _>("time_in_force")
218            .map(|x| TimeInForce::from_str(x).unwrap())?;
219        let post_only = row.try_get::<bool, _>("post_only")?;
220        let reduce_only = row.try_get::<bool, _>("reduce_only")?;
221        let quote_quantity = row.try_get::<bool, _>("quote_quantity")?;
222        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
223        let ts_event = row.try_get::<String, _>("ts_event").map(UnixNanos::from)?;
224        let ts_init = row.try_get::<String, _>("ts_init").map(UnixNanos::from)?;
225        let price = row
226            .try_get::<Option<&str>, _>("price")
227            .ok()
228            .and_then(|x| x.map(Price::from));
229        let activation_price = row
230            .try_get::<Option<&str>, _>("activation_price")
231            .ok()
232            .and_then(|x| x.map(Price::from));
233        let trigger_price = row
234            .try_get::<Option<&str>, _>("trigger_price")
235            .ok()
236            .and_then(|x| x.map(Price::from));
237        let trigger_type = row
238            .try_get::<Option<&str>, _>("trigger_type")
239            .ok()
240            .and_then(parse_trigger_type);
241        let limit_offset = row
242            .try_get::<Option<&str>, _>("limit_offset")
243            .ok()
244            .and_then(|x| x.and_then(|s| Decimal::from_str(s).ok()));
245        let trailing_offset = row
246            .try_get::<Option<&str>, _>("trailing_offset")
247            .ok()
248            .and_then(|x| x.and_then(|s| Decimal::from_str(s).ok()));
249        let trailing_offset_type = row
250            .try_get::<Option<TrailingOffsetTypePg>, _>("trailing_offset_type")
251            .ok()
252            .flatten()
253            .and_then(|value| value.0);
254        let expire_time = row
255            .try_get::<Option<&str>, _>("expire_time")
256            .ok()
257            .and_then(|x| x.map(UnixNanos::from));
258        let display_qty = row
259            .try_get::<Option<&str>, _>("display_qty")
260            .ok()
261            .and_then(|x| x.map(Quantity::from));
262        let emulation_trigger = row
263            .try_get::<Option<&str>, _>("emulation_trigger")
264            .ok()
265            .and_then(parse_trigger_type);
266        let trigger_instrument_id = row
267            .try_get::<Option<&str>, _>("trigger_instrument_id")
268            .ok()
269            .and_then(|x| x.map(InstrumentId::from));
270        let contingency_type = row
271            .try_get::<Option<&str>, _>("contingency_type")
272            .ok()
273            .and_then(parse_contingency_type);
274        let order_list_id = row
275            .try_get::<Option<&str>, _>("order_list_id")
276            .ok()
277            .and_then(|x| x.map(OrderListId::from));
278        let linked_order_ids = row
279            .try_get::<Vec<String>, _>("linked_order_ids")
280            .ok()
281            .map(|x| x.iter().map(|x| ClientOrderId::from(x.as_str())).collect());
282        let parent_order_id = row
283            .try_get::<Option<&str>, _>("parent_order_id")
284            .ok()
285            .and_then(|x| x.map(ClientOrderId::from));
286        let exec_algorithm_id = row
287            .try_get::<Option<&str>, _>("exec_algorithm_id")
288            .ok()
289            .and_then(|x| x.map(ExecAlgorithmId::from));
290        let exec_algorithm_params: Option<IndexMap<Ustr, Ustr>> = row
291            .try_get::<Option<serde_json::Value>, _>("exec_algorithm_params")
292            .ok()
293            .and_then(|x| x.map(|x| serde_json::from_value::<IndexMap<String, String>>(x).unwrap()))
294            .map(|x| {
295                x.into_iter()
296                    .map(|(k, v)| (Ustr::from(k.as_str()), Ustr::from(v.as_str())))
297                    .collect()
298            });
299        let exec_spawn_id = row
300            .try_get::<Option<&str>, _>("exec_spawn_id")
301            .ok()
302            .and_then(|x| x.map(ClientOrderId::from));
303        let tags = tags_from_row(row);
304        let mut order_event = OrderInitialized::new_checked(
305            trader_id,
306            strategy_id,
307            instrument_id,
308            client_order_id,
309            order_side,
310            order_type,
311            quantity,
312            time_in_force,
313            post_only,
314            reduce_only,
315            quote_quantity,
316            reconciliation,
317            event_id,
318            ts_event,
319            ts_init,
320            price,
321            activation_price,
322            trigger_price,
323            trigger_type,
324            limit_offset,
325            trailing_offset,
326            trailing_offset_type,
327            expire_time,
328            display_qty,
329            emulation_trigger,
330            trigger_instrument_id,
331            contingency_type,
332            order_list_id,
333            linked_order_ids,
334            parent_order_id,
335            exec_algorithm_id,
336            exec_algorithm_params,
337            exec_spawn_id,
338            tags,
339        )
340        .map_err(|e| sqlx::Error::Decode(Box::new(e)))?;
341        order_event.causation_id = causation_id_from_row(row)?;
342        Ok(Self(order_event))
343    }
344}
345
346impl<'r> FromRow<'r, PgRow> for OrderAcceptedRow {
347    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
348        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
349        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
350        let strategy_id = row
351            .try_get::<&str, _>("strategy_id")
352            .map(StrategyId::from)?;
353        let instrument_id = row
354            .try_get::<&str, _>("instrument_id")
355            .map(InstrumentId::from)?;
356        let client_order_id = row
357            .try_get::<&str, _>("client_order_id")
358            .map(ClientOrderId::from)?;
359        let venue_order_id = row
360            .try_get::<&str, _>("venue_order_id")
361            .map(VenueOrderId::from)?;
362        let account_id = row.try_get::<&str, _>("account_id").map(AccountId::from)?;
363        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
364        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
365        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
366        let causation_id = causation_id_from_row(row)?;
367        let mut order_event = OrderAccepted::new(
368            trader_id,
369            strategy_id,
370            instrument_id,
371            client_order_id,
372            venue_order_id,
373            account_id,
374            event_id,
375            ts_event,
376            ts_init,
377            reconciliation,
378        );
379        order_event.causation_id = causation_id;
380        Ok(Self(order_event))
381    }
382}
383
384impl<'r> FromRow<'r, PgRow> for OrderCancelDeniedRow {
385    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
386        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
387        let strategy_id = row
388            .try_get::<&str, _>("strategy_id")
389            .map(StrategyId::from)?;
390        let instrument_id = row
391            .try_get::<&str, _>("instrument_id")
392            .map(InstrumentId::from)?;
393        let client_order_id = row
394            .try_get::<&str, _>("client_order_id")
395            .map(ClientOrderId::from)?;
396        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
397        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
398        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
399        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
400        let venue_order_id = row
401            .try_get::<Option<&str>, _>("venue_order_id")?
402            .map(Into::into);
403        let account_id = row
404            .try_get::<Option<&str>, _>("account_id")?
405            .map(Into::into);
406        let causation_id = causation_id_from_row(row)?;
407
408        let mut order_event = OrderCancelDenied::new(
409            trader_id,
410            strategy_id,
411            instrument_id,
412            client_order_id,
413            reason,
414            event_id,
415            ts_event,
416            ts_init,
417            venue_order_id,
418            account_id,
419        );
420        order_event.causation_id = causation_id;
421        Ok(Self(order_event))
422    }
423}
424
425impl<'r> FromRow<'r, PgRow> for OrderCancelRejectedRow {
426    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
427        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
428        let strategy_id = row
429            .try_get::<&str, _>("strategy_id")
430            .map(StrategyId::from)?;
431        let instrument_id = row
432            .try_get::<&str, _>("instrument_id")
433            .map(InstrumentId::from)?;
434        let client_order_id = row
435            .try_get::<&str, _>("client_order_id")
436            .map(ClientOrderId::from)?;
437        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
438        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
439        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
440        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
441        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
442        let venue_order_id = row
443            .try_get::<Option<&str>, _>("venue_order_id")?
444            .map(Into::into);
445        let account_id = row
446            .try_get::<Option<&str>, _>("account_id")?
447            .map(Into::into);
448        let causation_id = causation_id_from_row(row)?;
449        let mut order_event = OrderCancelRejected::new(
450            trader_id,
451            strategy_id,
452            instrument_id,
453            client_order_id,
454            reason,
455            event_id,
456            ts_event,
457            ts_init,
458            reconciliation,
459            venue_order_id,
460            account_id,
461        );
462        order_event.causation_id = causation_id;
463        Ok(Self(order_event))
464    }
465}
466
467impl<'r> FromRow<'r, PgRow> for OrderCanceledRow {
468    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
469        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
470        let strategy_id = row
471            .try_get::<&str, _>("strategy_id")
472            .map(StrategyId::from)?;
473        let instrument_id = row
474            .try_get::<&str, _>("instrument_id")
475            .map(InstrumentId::from)?;
476        let client_order_id = row
477            .try_get::<&str, _>("client_order_id")
478            .map(ClientOrderId::from)?;
479        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
480        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
481        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
482        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
483        let venue_order_id = row
484            .try_get::<Option<&str>, _>("venue_order_id")?
485            .map(Into::into);
486        let account_id = row
487            .try_get::<Option<&str>, _>("account_id")?
488            .map(Into::into);
489        let reason = row.try_get::<Option<&str>, _>("reason")?.map(Ustr::from);
490        let causation_id = causation_id_from_row(row)?;
491        let mut order_event = OrderCanceled::new(
492            trader_id,
493            strategy_id,
494            instrument_id,
495            client_order_id,
496            event_id,
497            ts_event,
498            ts_init,
499            reconciliation,
500            venue_order_id,
501            account_id,
502            reason,
503        );
504        order_event.causation_id = causation_id;
505        Ok(Self(order_event))
506    }
507}
508
509impl<'r> FromRow<'r, PgRow> for OrderDeniedRow {
510    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
511        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
512        let strategy_id = row
513            .try_get::<&str, _>("strategy_id")
514            .map(StrategyId::from)?;
515        let instrument_id = row
516            .try_get::<&str, _>("instrument_id")
517            .map(InstrumentId::from)?;
518        let client_order_id = row
519            .try_get::<&str, _>("client_order_id")
520            .map(ClientOrderId::from)?;
521        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
522        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
523        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
524        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
525        let causation_id = causation_id_from_row(row)?;
526        let mut order_event = OrderDenied::new(
527            trader_id,
528            strategy_id,
529            instrument_id,
530            client_order_id,
531            reason,
532            event_id,
533            ts_event,
534            ts_init,
535        );
536        order_event.causation_id = causation_id;
537        Ok(Self(order_event))
538    }
539}
540
541impl<'r> FromRow<'r, PgRow> for OrderEmulatedRow {
542    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
543        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
544        let strategy_id = row
545            .try_get::<&str, _>("strategy_id")
546            .map(StrategyId::from)?;
547        let instrument_id = row
548            .try_get::<&str, _>("instrument_id")
549            .map(InstrumentId::from)?;
550        let client_order_id = row
551            .try_get::<&str, _>("client_order_id")
552            .map(ClientOrderId::from)?;
553        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
554        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
555        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
556        let causation_id = causation_id_from_row(row)?;
557        let mut order_event = OrderEmulated::new(
558            trader_id,
559            strategy_id,
560            instrument_id,
561            client_order_id,
562            event_id,
563            ts_event,
564            ts_init,
565        );
566        order_event.causation_id = causation_id;
567        Ok(Self(order_event))
568    }
569}
570
571impl<'r> FromRow<'r, PgRow> for OrderExpiredRow {
572    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
573        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
574        let strategy_id = row
575            .try_get::<&str, _>("strategy_id")
576            .map(StrategyId::from)?;
577        let instrument_id = row
578            .try_get::<&str, _>("instrument_id")
579            .map(InstrumentId::from)?;
580        let client_order_id = row
581            .try_get::<&str, _>("client_order_id")
582            .map(ClientOrderId::from)?;
583        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
584        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
585        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
586        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
587        let venue_order_id = row
588            .try_get::<Option<&str>, _>("venue_order_id")?
589            .map(Into::into);
590        let account_id = row
591            .try_get::<Option<&str>, _>("account_id")?
592            .map(Into::into);
593        let causation_id = causation_id_from_row(row)?;
594        let mut order_event = OrderExpired::new(
595            trader_id,
596            strategy_id,
597            instrument_id,
598            client_order_id,
599            event_id,
600            ts_event,
601            ts_init,
602            reconciliation,
603            venue_order_id,
604            account_id,
605        );
606        order_event.causation_id = causation_id;
607        Ok(Self(order_event))
608    }
609}
610
611impl<'r> FromRow<'r, PgRow> for OrderFilledRow {
612    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
613        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
614        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
615        let strategy_id = row
616            .try_get::<&str, _>("strategy_id")
617            .map(StrategyId::from)?;
618        let instrument_id = row
619            .try_get::<&str, _>("instrument_id")
620            .map(InstrumentId::from)?;
621        let client_order_id = row
622            .try_get::<&str, _>("client_order_id")
623            .map(ClientOrderId::from)?;
624        let venue_order_id = row
625            .try_get::<&str, _>("venue_order_id")
626            .map(VenueOrderId::from)?;
627        let account_id = row.try_get::<&str, _>("account_id").map(AccountId::from)?;
628        let trade_id = row.try_get::<&str, _>("trade_id").map(TradeId::from)?;
629        let order_side = row
630            .try_get::<&str, _>("order_side")
631            .map(|x| OrderSide::from_str(x).unwrap())?;
632        let order_type = row
633            .try_get::<&str, _>("order_type")
634            .map(|x| OrderType::from_str(x).unwrap())?;
635        let last_px = row.try_get::<&str, _>("last_px").map(Price::from)?;
636        let last_qty = row.try_get::<&str, _>("last_qty").map(Quantity::from)?;
637        let currency = row.try_get::<&str, _>("currency").map(Currency::from)?;
638        let liquidity_side = row
639            .try_get::<&str, _>("liquidity_side")
640            .map(|x| LiquiditySide::from_str(x).unwrap())?;
641        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
642        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
643        let position_id = row
644            .try_get::<Option<&str>, _>("position_id")
645            .map(|x| x.map(PositionId::from))?;
646        let commission = row
647            .try_get::<Option<&str>, _>("commission")?
648            .map(|value| decode_money(value, "commission"))
649            .transpose()?;
650        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
651        let info = decode_info(row)?;
652        let causation_id = causation_id_from_row(row)?;
653        let mut order_event = OrderFilled::new(
654            trader_id,
655            strategy_id,
656            instrument_id,
657            client_order_id,
658            venue_order_id,
659            account_id,
660            trade_id,
661            order_side,
662            order_type,
663            last_qty,
664            last_px,
665            currency,
666            liquidity_side,
667            event_id,
668            ts_event,
669            ts_init,
670            reconciliation,
671            position_id,
672            commission,
673            info,
674        );
675        order_event.causation_id = causation_id;
676        Ok(Self(order_event))
677    }
678}
679
680impl<'r> FromRow<'r, PgRow> for OrderFillVoidedRow {
681    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
682        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
683        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
684        let strategy_id = row
685            .try_get::<&str, _>("strategy_id")
686            .map(StrategyId::from)?;
687        let instrument_id = row
688            .try_get::<&str, _>("instrument_id")
689            .map(InstrumentId::from)?;
690        let client_order_id = row
691            .try_get::<&str, _>("client_order_id")
692            .map(ClientOrderId::from)?;
693        let venue_order_id = row
694            .try_get::<&str, _>("venue_order_id")
695            .map(VenueOrderId::from)?;
696        let account_id = row.try_get::<&str, _>("account_id").map(AccountId::from)?;
697        let correction_id = row
698            .try_get::<Option<&str>, _>("correction_id")?
699            .map(Ustr::from)
700            .ok_or_else(|| {
701                sqlx::Error::Decode(
702                    "OrderFillVoided row has no correction_id; it predates the column and \
703                     the value cannot be recovered"
704                        .into(),
705                )
706            })?;
707        let trade_id = row.try_get::<&str, _>("trade_id").map(TradeId::from)?;
708        let voided_qty = row.try_get::<&str, _>("quantity").map(Quantity::from)?;
709        let commission_voided = row
710            .try_get::<Option<&str>, _>("commission")?
711            .map(|value| decode_money(value, "commission"))
712            .transpose()?;
713        let order_side = OrderSide::from_str(row.try_get::<&str, _>("order_side")?)
714            .map_err(|e| sqlx::Error::Decode(Box::new(e)))?;
715        let order_type = OrderType::from_str(row.try_get::<&str, _>("order_type")?)
716            .map_err(|e| sqlx::Error::Decode(Box::new(e)))?;
717        let last_px = row.try_get::<&str, _>("last_px").map(Price::from)?;
718        let currency = row.try_get::<&str, _>("currency").map(Currency::from)?;
719        let liquidity_side = LiquiditySide::from_str(row.try_get::<&str, _>("liquidity_side")?)
720            .map_err(|e| sqlx::Error::Decode(Box::new(e)))?;
721        let position_id = row
722            .try_get::<Option<&str>, _>("position_id")?
723            .map(PositionId::from);
724        let reason = row.try_get::<Option<&str>, _>("reason")?.map(Ustr::from);
725        let info = decode_info(row)?;
726        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
727        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
728        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
729        let is_reopened = row
730            .try_get::<Option<bool>, _>("is_reopened")?
731            .unwrap_or(false);
732        let causation_id = causation_id_from_row(row)?;
733        let mut order_event = OrderFillVoided::new(
734            trader_id,
735            strategy_id,
736            instrument_id,
737            client_order_id,
738            venue_order_id,
739            account_id,
740            correction_id,
741            trade_id,
742            voided_qty,
743            commission_voided,
744            order_side,
745            order_type,
746            last_px,
747            currency,
748            liquidity_side,
749            position_id,
750            reason,
751            info,
752            event_id,
753            ts_event,
754            ts_init,
755            reconciliation,
756            is_reopened,
757        );
758        order_event.causation_id = causation_id;
759        Ok(Self(order_event))
760    }
761}
762
763impl<'r> FromRow<'r, PgRow> for OrderModifyDeniedRow {
764    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
765        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
766        let strategy_id = row
767            .try_get::<&str, _>("strategy_id")
768            .map(StrategyId::from)?;
769        let instrument_id = row
770            .try_get::<&str, _>("instrument_id")
771            .map(InstrumentId::from)?;
772        let client_order_id = row
773            .try_get::<&str, _>("client_order_id")
774            .map(ClientOrderId::from)?;
775        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
776        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
777        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
778        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
779        let venue_order_id = row
780            .try_get::<Option<&str>, _>("venue_order_id")?
781            .map(Into::into);
782        let account_id = row
783            .try_get::<Option<&str>, _>("account_id")?
784            .map(Into::into);
785        let causation_id = causation_id_from_row(row)?;
786
787        let mut order_event = OrderModifyDenied::new(
788            trader_id,
789            strategy_id,
790            instrument_id,
791            client_order_id,
792            reason,
793            event_id,
794            ts_event,
795            ts_init,
796            venue_order_id,
797            account_id,
798        );
799        order_event.causation_id = causation_id;
800        Ok(Self(order_event))
801    }
802}
803
804impl<'r> FromRow<'r, PgRow> for OrderModifyRejectedRow {
805    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
806        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
807        let strategy_id = row
808            .try_get::<&str, _>("strategy_id")
809            .map(StrategyId::from)?;
810        let instrument_id = row
811            .try_get::<&str, _>("instrument_id")
812            .map(InstrumentId::from)?;
813        let client_order_id = row
814            .try_get::<&str, _>("client_order_id")
815            .map(ClientOrderId::from)?;
816        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
817        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
818        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
819        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
820        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
821        let venue_order_id = row
822            .try_get::<Option<&str>, _>("venue_order_id")?
823            .map(Into::into);
824        let account_id = row
825            .try_get::<Option<&str>, _>("account_id")?
826            .map(Into::into);
827        let causation_id = causation_id_from_row(row)?;
828        let mut order_event = OrderModifyRejected::new(
829            trader_id,
830            strategy_id,
831            instrument_id,
832            client_order_id,
833            reason,
834            event_id,
835            ts_event,
836            ts_init,
837            reconciliation,
838            venue_order_id,
839            account_id,
840        );
841        order_event.causation_id = causation_id;
842        Ok(Self(order_event))
843    }
844}
845
846impl<'r> FromRow<'r, PgRow> for OrderPendingCancelRow {
847    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
848        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
849        let strategy_id = row
850            .try_get::<&str, _>("strategy_id")
851            .map(StrategyId::from)?;
852        let instrument_id = row
853            .try_get::<&str, _>("instrument_id")
854            .map(InstrumentId::from)?;
855        let client_order_id = row
856            .try_get::<&str, _>("client_order_id")
857            .map(ClientOrderId::from)?;
858        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
859        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
860        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
861        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
862        let venue_order_id = row
863            .try_get::<Option<&str>, _>("venue_order_id")?
864            .map(Into::into);
865        let account_id = row
866            .try_get::<Option<&str>, _>("account_id")?
867            .map(Into::into);
868        let causation_id = causation_id_from_row(row)?;
869        let mut order_event = OrderPendingCancel::new(
870            trader_id,
871            strategy_id,
872            instrument_id,
873            client_order_id,
874            account_id,
875            event_id,
876            ts_event,
877            ts_init,
878            reconciliation,
879            venue_order_id,
880        );
881        order_event.causation_id = causation_id;
882        Ok(Self(order_event))
883    }
884}
885
886impl<'r> FromRow<'r, PgRow> for OrderPendingUpdateRow {
887    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
888        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
889        let strategy_id = row
890            .try_get::<&str, _>("strategy_id")
891            .map(StrategyId::from)?;
892        let instrument_id = row
893            .try_get::<&str, _>("instrument_id")
894            .map(InstrumentId::from)?;
895        let client_order_id = row
896            .try_get::<&str, _>("client_order_id")
897            .map(ClientOrderId::from)?;
898        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
899        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
900        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
901        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
902        let venue_order_id = row
903            .try_get::<Option<&str>, _>("venue_order_id")?
904            .map(Into::into);
905        let account_id = row
906            .try_get::<Option<&str>, _>("account_id")?
907            .map(Into::into);
908        let causation_id = causation_id_from_row(row)?;
909        let mut order_event = OrderPendingUpdate::new(
910            trader_id,
911            strategy_id,
912            instrument_id,
913            client_order_id,
914            account_id,
915            event_id,
916            ts_event,
917            ts_init,
918            reconciliation,
919            venue_order_id,
920        );
921        order_event.causation_id = causation_id;
922        Ok(Self(order_event))
923    }
924}
925
926impl<'r> FromRow<'r, PgRow> for OrderRejectedRow {
927    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
928        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
929        let strategy_id = row
930            .try_get::<&str, _>("strategy_id")
931            .map(StrategyId::from)?;
932        let instrument_id = row
933            .try_get::<&str, _>("instrument_id")
934            .map(InstrumentId::from)?;
935        let client_order_id = row
936            .try_get::<&str, _>("client_order_id")
937            .map(ClientOrderId::from)?;
938        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
939        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
940        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
941        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
942        let account_id = row.try_get::<&str, _>("account_id").map(AccountId::from)?;
943        let reason = row.try_get::<&str, _>("reason").map(Ustr::from)?;
944        // Rows written before this column existed decode as NULL; false is its meaning
945        let due_post_only = row
946            .try_get::<Option<bool>, _>("due_post_only")?
947            .unwrap_or(false);
948        let causation_id = causation_id_from_row(row)?;
949        let mut order_event = OrderRejected::new(
950            trader_id,
951            strategy_id,
952            instrument_id,
953            client_order_id,
954            account_id,
955            reason,
956            event_id,
957            ts_event,
958            ts_init,
959            reconciliation,
960            due_post_only,
961        );
962        order_event.causation_id = causation_id;
963        Ok(Self(order_event))
964    }
965}
966
967impl<'r> FromRow<'r, PgRow> for OrderReleasedRow {
968    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
969        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
970        let strategy_id = row
971            .try_get::<&str, _>("strategy_id")
972            .map(StrategyId::from)?;
973        let instrument_id = row
974            .try_get::<&str, _>("instrument_id")
975            .map(InstrumentId::from)?;
976        let client_order_id = row
977            .try_get::<&str, _>("client_order_id")
978            .map(ClientOrderId::from)?;
979        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
980        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
981        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
982        let released_price = row
983            .try_get::<Option<&str>, _>("released_price")?
984            .map(Price::from)
985            .ok_or_else(|| {
986                sqlx::Error::Decode(
987                    "OrderReleased row has no released_price; it predates the column and \
988                     the value cannot be recovered"
989                        .into(),
990                )
991            })?;
992        let causation_id = causation_id_from_row(row)?;
993        let mut order_event = OrderReleased::new(
994            trader_id,
995            strategy_id,
996            instrument_id,
997            client_order_id,
998            released_price,
999            event_id,
1000            ts_event,
1001            ts_init,
1002        );
1003        order_event.causation_id = causation_id;
1004        Ok(Self(order_event))
1005    }
1006}
1007
1008impl<'r> FromRow<'r, PgRow> for OrderSubmittedRow {
1009    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
1010        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
1011        let strategy_id = row
1012            .try_get::<&str, _>("strategy_id")
1013            .map(StrategyId::from)?;
1014        let instrument_id = row
1015            .try_get::<&str, _>("instrument_id")
1016            .map(InstrumentId::from)?;
1017        let client_order_id = row
1018            .try_get::<&str, _>("client_order_id")
1019            .map(ClientOrderId::from)?;
1020        let account_id = row.try_get::<&str, _>("account_id").map(AccountId::from)?;
1021        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
1022        let ts_event = row
1023            .try_get::<String, _>("ts_event")
1024            .map(|res| UnixNanos::from(res.as_str()))?;
1025        let ts_init = row
1026            .try_get::<String, _>("ts_init")
1027            .map(|res| UnixNanos::from(res.as_str()))?;
1028        let causation_id = causation_id_from_row(row)?;
1029        let mut order_event = OrderSubmitted::new(
1030            trader_id,
1031            strategy_id,
1032            instrument_id,
1033            client_order_id,
1034            account_id,
1035            event_id,
1036            ts_event,
1037            ts_init,
1038        );
1039        order_event.causation_id = causation_id;
1040        Ok(Self(order_event))
1041    }
1042}
1043
1044impl<'r> FromRow<'r, PgRow> for OrderTriggeredRow {
1045    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
1046        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
1047        let strategy_id = row
1048            .try_get::<&str, _>("strategy_id")
1049            .map(StrategyId::from)?;
1050        let instrument_id = row
1051            .try_get::<&str, _>("instrument_id")
1052            .map(InstrumentId::from)?;
1053        let client_order_id = row
1054            .try_get::<&str, _>("client_order_id")
1055            .map(ClientOrderId::from)?;
1056        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
1057        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
1058        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
1059        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
1060        let venue_order_id = row
1061            .try_get::<Option<&str>, _>("venue_order_id")?
1062            .map(Into::into);
1063        let account_id = row
1064            .try_get::<Option<&str>, _>("account_id")?
1065            .map(Into::into);
1066        let causation_id = causation_id_from_row(row)?;
1067        let mut order_event = OrderTriggered::new(
1068            trader_id,
1069            strategy_id,
1070            instrument_id,
1071            client_order_id,
1072            event_id,
1073            ts_event,
1074            ts_init,
1075            reconciliation,
1076            venue_order_id,
1077            account_id,
1078        );
1079        order_event.causation_id = causation_id;
1080        Ok(Self(order_event))
1081    }
1082}
1083
1084impl<'r> FromRow<'r, PgRow> for OrderUpdatedRow {
1085    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
1086        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
1087        let strategy_id = row
1088            .try_get::<&str, _>("strategy_id")
1089            .map(StrategyId::from)?;
1090        let instrument_id = row
1091            .try_get::<&str, _>("instrument_id")
1092            .map(InstrumentId::from)?;
1093        let client_order_id = row
1094            .try_get::<&str, _>("client_order_id")
1095            .map(ClientOrderId::from)?;
1096        let event_id = row.try_get::<&str, _>("id").map(UUID4::from)?;
1097        let ts_event = row.try_get::<&str, _>("ts_event").map(UnixNanos::from)?;
1098        let ts_init = row.try_get::<&str, _>("ts_init").map(UnixNanos::from)?;
1099        let reconciliation = row.try_get::<bool, _>("reconciliation")?;
1100        let venue_order_id = row
1101            .try_get::<Option<&str>, _>("venue_order_id")?
1102            .map(Into::into);
1103        let account_id = row
1104            .try_get::<Option<&str>, _>("account_id")?
1105            .map(Into::into);
1106        let quantity = row.try_get::<&str, _>("quantity").map(Quantity::from)?;
1107        let price = row.try_get::<Option<&str>, _>("price")?.map(Price::from);
1108        let trigger_price = row
1109            .try_get::<Option<&str>, _>("trigger_price")?
1110            .map(Price::from);
1111        let protection_price = row
1112            .try_get::<Option<&str>, _>("protection_price")?
1113            .map(Price::from);
1114        let is_quote_quantity = row.try_get::<bool, _>("quote_quantity")?;
1115        let causation_id = causation_id_from_row(row)?;
1116        let mut order_event = OrderUpdated::new(
1117            trader_id,
1118            strategy_id,
1119            instrument_id,
1120            client_order_id,
1121            quantity,
1122            event_id,
1123            ts_event,
1124            ts_init,
1125            reconciliation,
1126            venue_order_id,
1127            account_id,
1128            price,
1129            trigger_price,
1130            protection_price,
1131            is_quote_quantity,
1132        );
1133        order_event.causation_id = causation_id;
1134        Ok(Self(order_event))
1135    }
1136}
1137
1138impl<'r> FromRow<'r, PgRow> for OrderSnapshotRow {
1139    #[expect(
1140        clippy::too_many_lines,
1141        reason = "SQL row mapping mirrors the full order snapshot constructor"
1142    )]
1143    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
1144        let trader_id = row.try_get::<&str, _>("trader_id").map(TraderId::from)?;
1145        let strategy_id = row
1146            .try_get::<&str, _>("strategy_id")
1147            .map(StrategyId::from)?;
1148        let instrument_id = row
1149            .try_get::<&str, _>("instrument_id")
1150            .map(InstrumentId::from)?;
1151        let client_order_id = row
1152            .try_get::<&str, _>("client_order_id")
1153            .map(ClientOrderId::from)?;
1154        let venue_order_id = row
1155            .try_get::<Option<&str>, _>("venue_order_id")
1156            .ok()
1157            .and_then(|x| x.map(VenueOrderId::from));
1158        let position_id = row
1159            .try_get::<Option<&str>, _>("position_id")
1160            .ok()
1161            .and_then(|x| x.map(PositionId::from));
1162        let account_id = row
1163            .try_get::<Option<&str>, _>("account_id")
1164            .ok()
1165            .and_then(|x| x.map(AccountId::from));
1166        let last_trade_id = row
1167            .try_get::<Option<&str>, _>("last_trade_id")
1168            .ok()
1169            .and_then(|x| x.map(TradeId::from));
1170        let order_type = row
1171            .try_get::<&str, _>("order_type")
1172            .map(|x| OrderType::from_str(x).expect("Invalid `OrderType`"))?;
1173        let order_side = row
1174            .try_get::<&str, _>("order_side")
1175            .map(|x| OrderSide::from_str(x).expect("Invalid `OrderSide`"))?;
1176        let quantity = row.try_get::<&str, _>("quantity").map(Quantity::from)?;
1177        let price = row
1178            .try_get::<Option<&str>, _>("price")
1179            .ok()
1180            .and_then(|x| x.map(Price::from));
1181        let activation_price = row
1182            .try_get::<Option<&str>, _>("activation_price")
1183            .ok()
1184            .and_then(|x| x.map(Price::from));
1185        let trigger_price = row
1186            .try_get::<Option<&str>, _>("trigger_price")
1187            .ok()
1188            .and_then(|x| x.map(Price::from));
1189        let trigger_type = row
1190            .try_get::<Option<&str>, _>("trigger_type")
1191            .ok()
1192            .and_then(parse_trigger_type);
1193        let limit_offset = row
1194            .try_get::<Option<&str>, _>("limit_offset")
1195            .ok()
1196            .and_then(|x| x.and_then(|s| Decimal::from_str(s).ok()));
1197        let trailing_offset = row
1198            .try_get::<Option<&str>, _>("trailing_offset")
1199            .ok()
1200            .and_then(|x| x.and_then(|s| Decimal::from_str(s).ok()));
1201        let trailing_offset_type = row
1202            .try_get::<Option<TrailingOffsetTypePg>, _>("trailing_offset_type")
1203            .ok()
1204            .flatten()
1205            .and_then(|value| value.0);
1206        let time_in_force = row
1207            .try_get::<&str, _>("time_in_force")
1208            .map(|x| TimeInForce::from_str(x).expect("Invalid `TimeInForce`"))?;
1209        let expire_time = row
1210            .try_get::<Option<&str>, _>("expire_time")
1211            .ok()
1212            .and_then(|x| x.map(UnixNanos::from));
1213        let filled_qty = row.try_get::<&str, _>("filled_qty").map(Quantity::from)?;
1214        let liquidity_side = row
1215            .try_get::<Option<&str>, _>("liquidity_side")
1216            .ok()
1217            .and_then(|x| x.map(|x| LiquiditySide::from_str(x).expect("Invalid `LiquiditySide`")));
1218        let avg_px = row.try_get::<Option<Decimal>, _>("avg_px").ok().flatten();
1219        let slippage = row.try_get::<Option<Decimal>, _>("slippage").ok().flatten();
1220        let commissions = row
1221            .try_get::<Option<Vec<String>>, _>("commissions")?
1222            .unwrap_or_default()
1223            .into_iter()
1224            .map(|value| decode_money(&value, "commissions"))
1225            .collect::<Result<Vec<_>, _>>()?;
1226        let status = row
1227            .try_get::<&str, _>("status")
1228            .map(|x| OrderStatus::from_str(x).expect("Invalid `OrderStatus`"))?;
1229        let is_post_only = row.try_get::<bool, _>("is_post_only")?;
1230        let is_reduce_only = row.try_get::<bool, _>("is_reduce_only")?;
1231        let is_quote_quantity = row.try_get::<bool, _>("is_quote_quantity")?;
1232        let display_qty = row
1233            .try_get::<Option<&str>, _>("display_qty")
1234            .ok()
1235            .and_then(|x| x.map(Quantity::from));
1236        let emulation_trigger = row
1237            .try_get::<Option<&str>, _>("emulation_trigger")
1238            .ok()
1239            .and_then(parse_trigger_type);
1240        let trigger_instrument_id = row
1241            .try_get::<Option<&str>, _>("trigger_instrument_id")
1242            .ok()
1243            .and_then(|x| x.map(InstrumentId::from));
1244        let contingency_type = row
1245            .try_get::<Option<&str>, _>("contingency_type")
1246            .ok()
1247            .and_then(parse_contingency_type);
1248        let order_list_id = row
1249            .try_get::<Option<&str>, _>("order_list_id")
1250            .ok()
1251            .and_then(|x| x.map(OrderListId::from));
1252        let linked_order_ids = row
1253            .try_get::<Option<Vec<String>>, _>("linked_order_ids")
1254            .ok()
1255            .and_then(|ids| ids.map(|ids| ids.into_iter().map(ClientOrderId::from).collect()));
1256        let parent_order_id = row
1257            .try_get::<Option<&str>, _>("parent_order_id")
1258            .ok()
1259            .and_then(|x| x.map(ClientOrderId::from));
1260        let exec_algorithm_id = row
1261            .try_get::<Option<&str>, _>("exec_algorithm_id")
1262            .ok()
1263            .and_then(|x| x.map(ExecAlgorithmId::from));
1264        let exec_algorithm_params: Option<IndexMap<Ustr, Ustr>> = row
1265            .try_get::<Option<serde_json::Value>, _>("exec_algorithm_params")
1266            .ok()
1267            .and_then(|x| {
1268                x.map(|x| {
1269                    serde_json::from_value::<IndexMap<String, String>>(x)
1270                        .expect("Invalid exec algorithm params")
1271                })
1272            })
1273            .map(|x| {
1274                x.into_iter()
1275                    .map(|(k, v)| (Ustr::from(k.as_str()), Ustr::from(v.as_str())))
1276                    .collect()
1277            });
1278        let exec_spawn_id = row
1279            .try_get::<Option<&str>, _>("exec_spawn_id")
1280            .ok()
1281            .and_then(|x| x.map(ClientOrderId::from));
1282        let tags = tags_from_row(row);
1283        let init_id = row.try_get::<&str, _>("init_id").map(UUID4::from)?;
1284        let ts_init = row.try_get::<String, _>("ts_init").map(UnixNanos::from)?;
1285        let ts_last = row.try_get::<String, _>("ts_last").map(UnixNanos::from)?;
1286
1287        let snapshot = OrderSnapshot {
1288            trader_id,
1289            strategy_id,
1290            instrument_id,
1291            client_order_id,
1292            venue_order_id,
1293            position_id,
1294            account_id,
1295            last_trade_id,
1296            order_type,
1297            order_side,
1298            quantity,
1299            price,
1300            activation_price,
1301            trigger_price,
1302            trigger_type,
1303            limit_offset,
1304            trailing_offset,
1305            trailing_offset_type,
1306            time_in_force,
1307            expire_time,
1308            filled_qty,
1309            liquidity_side,
1310            avg_px,
1311            slippage,
1312            commissions,
1313            status,
1314            is_post_only,
1315            is_reduce_only,
1316            is_quote_quantity,
1317            display_qty,
1318            emulation_trigger,
1319            trigger_instrument_id,
1320            contingency_type,
1321            order_list_id,
1322            linked_order_ids,
1323            parent_order_id,
1324            exec_algorithm_id,
1325            exec_algorithm_params,
1326            exec_spawn_id,
1327            tags,
1328            init_id,
1329            ts_init,
1330            ts_last,
1331            causation_id: None,
1332        };
1333
1334        Ok(Self(snapshot))
1335    }
1336}
1337
1338fn causation_id_from_row(row: &PgRow) -> Result<Option<UUID4>, sqlx::Error> {
1339    row.try_get::<Option<&str>, _>("causation_id")?
1340        .map(|value| UUID4::from_str(value).map_err(|e| sqlx::Error::Decode(e.into())))
1341        .transpose()
1342}
1343
1344fn decode_info(row: &PgRow) -> Result<Option<IndexMap<Ustr, Ustr>>, sqlx::Error> {
1345    let value = row.try_get::<Option<serde_json::Value>, _>("info")?;
1346    let Some(value) = value else {
1347        return Ok(None);
1348    };
1349
1350    let decoded: IndexMap<String, String> =
1351        serde_json::from_value(value).map_err(|e| sqlx::Error::Decode(Box::new(e)))?;
1352
1353    Ok(Some(
1354        decoded
1355            .into_iter()
1356            .map(|(k, v)| (Ustr::from(k.as_str()), Ustr::from(v.as_str())))
1357            .collect(),
1358    ))
1359}
1360
1361fn tags_from_row(row: &PgRow) -> Option<Vec<Ustr>> {
1362    row.try_get::<Vec<String>, _>("tags")
1363        .ok()
1364        .map(|tags| tags.iter().map(|tag| Ustr::from(tag.as_str())).collect())
1365}
1366
1367fn parse_trigger_type(value: Option<&str>) -> Option<TriggerType> {
1368    value.and_then(|value| {
1369        if value.eq_ignore_ascii_case("NO_TRIGGER") {
1370            None
1371        } else {
1372            Some(TriggerType::from_str(value).expect("Invalid `TriggerType`"))
1373        }
1374    })
1375}
1376
1377fn parse_contingency_type(value: Option<&str>) -> Option<ContingencyType> {
1378    value.and_then(|value| {
1379        if value.eq_ignore_ascii_case("NO_CONTINGENCY") {
1380            None
1381        } else {
1382            Some(ContingencyType::from_str(value).expect("Invalid `ContingencyType`"))
1383        }
1384    })
1385}
1386
1387#[cfg(test)]
1388mod tests {
1389    use rstest::rstest;
1390
1391    use super::*;
1392
1393    #[rstest]
1394    #[case(None, None)]
1395    #[case(Some("NO_TRIGGER"), None)]
1396    #[case(Some("LAST_PRICE"), Some(TriggerType::LastPrice))]
1397    fn test_parse_trigger_type_accepts_legacy_absence(
1398        #[case] value: Option<&str>,
1399        #[case] expected: Option<TriggerType>,
1400    ) {
1401        assert_eq!(parse_trigger_type(value), expected);
1402    }
1403
1404    #[rstest]
1405    #[case(None, None)]
1406    #[case(Some("NO_CONTINGENCY"), None)]
1407    #[case(Some("OCO"), Some(ContingencyType::Oco))]
1408    fn test_parse_contingency_type_accepts_legacy_absence(
1409        #[case] value: Option<&str>,
1410        #[case] expected: Option<ContingencyType>,
1411    ) {
1412        assert_eq!(parse_contingency_type(value), expected);
1413    }
1414}