Skip to main content

rustcmdpev_core/structure/data/
plan.rs

1//https://github.com/serde-rs/serde/pull/238
2use crate::structure::data::actuals::PlanActuals;
3use crate::structure::data::analysis_flags::PlanAnalysisFlags;
4use crate::structure::data::buffers::PlanBuffers;
5use crate::structure::data::estimates::PlanEstimates;
6use crate::structure::data::identity::PlanIdentity;
7use crate::structure::data::io_timing::PlanIoTiming;
8use crate::structure::data::predicates::PlanPredicates;
9use serde::{Deserialize, Serialize};
10use std::fmt;
11
12/// The Plan struct.
13///
14/// Storage is grouped into typed sub-structs (`identity`, `predicates`,
15/// `buffers`, `io_timing`, `estimates`, `actuals`, `analysis_flags`) so that
16/// related fields stay co-located and downstream code can pass cohesive
17/// slices of state instead of every field individually.
18#[derive(Serialize, Deserialize, Debug, Clone, Default)]
19pub struct Plan {
20    #[serde(flatten)]
21    pub actuals: PlanActuals,
22    #[serde(flatten)]
23    pub analysis_flags: PlanAnalysisFlags,
24    #[serde(flatten)]
25    pub identity: PlanIdentity,
26    #[serde(flatten)]
27    pub predicates: PlanPredicates,
28    #[serde(flatten)]
29    pub buffers: PlanBuffers,
30    #[serde(flatten)]
31    pub estimates: PlanEstimates,
32    #[serde(flatten)]
33    pub io_timing: PlanIoTiming,
34    #[serde(default, rename(deserialize = "Plans"))]
35    pub plans: Vec<Plan>,
36}
37
38impl fmt::Display for Plan {
39    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
40        f.write_str(&self.identity.node_type)
41    }
42}
43
44impl Plan {
45    pub fn child_count(&self) -> usize {
46        self.plans.len()
47    }
48
49    pub fn has_children(&self) -> bool {
50        !self.plans.is_empty()
51    }
52
53    pub fn is_leaf(&self) -> bool {
54        self.plans.is_empty()
55    }
56}
57
58#[cfg(test)]
59mod tests {
60    use super::*;
61
62    #[test]
63    fn deserializes_postgres_fields_into_grouped_substructs() {
64        let json = r#"{
65            "Node Type": "Index Scan",
66            "Schema": "public",
67            "Relation Name": "coaches",
68            "Index Name": "coaches_pkey",
69            "Index Cond": "(id = 1)",
70            "Filter": "active",
71            "Output": ["a", "b"],
72            "Heap Fetches": 7,
73            "Shared Hit Blocks": 3,
74            "I/O Read Time": 1.5,
75            "I/O Write Time": 2.5,
76            "Plan Rows": 9,
77            "Total Cost": 4.5,
78            "Actual Rows": 9,
79            "Actual Loops": 1
80        }"#;
81
82        let plan: Plan = serde_json::from_str(json).expect("deserialize");
83
84        assert_eq!(plan.identity.node_type, "Index Scan");
85        assert_eq!(plan.identity.schema, "public");
86        assert_eq!(plan.identity.relation_name, "coaches");
87        assert_eq!(plan.identity.index_name, "coaches_pkey");
88        assert_eq!(plan.predicates.index_condition, "(id = 1)");
89        assert_eq!(plan.predicates.filter, "active");
90        assert_eq!(plan.predicates.output, vec!["a", "b"]);
91        assert_eq!(plan.buffers.heap_fetches, 7);
92        assert_eq!(plan.buffers.shared_hit_blocks, 3);
93        assert_eq!(plan.io_timing.io_read_time, 1.5);
94        assert_eq!(plan.io_timing.io_write_time, 2.5);
95        assert_eq!(plan.estimates.plan_rows, 9);
96        assert_eq!(plan.estimates.total_cost, 4.5);
97        assert_eq!(plan.actuals.actual_rows, 9);
98    }
99
100    #[test]
101    fn display_uses_grouped_identity_node_type() {
102        let mut plan = Plan::default();
103        plan.identity.node_type = "Hash Join".to_string();
104        assert_eq!(format!("{plan}"), "Hash Join");
105    }
106}