1use 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 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}