Skip to main content

sheetkit_xml/
pivot_cache.rs

1//! Pivot cache XML schema structures.
2//!
3//! Represents `xl/pivotCache/pivotCacheDefinition{N}.xml` and
4//! `xl/pivotCache/pivotCacheRecords{N}.xml`.
5
6use serde::{Deserialize, Serialize};
7
8/// Root element for pivot cache definition.
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10#[serde(rename = "pivotCacheDefinition")]
11pub struct PivotCacheDefinition {
12    #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
13    pub xmlns: String,
14
15    #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
16    pub xmlns_r: String,
17
18    #[serde(
19        rename = "@r:id",
20        alias = "@id",
21        skip_serializing_if = "Option::is_none"
22    )]
23    pub r_id: Option<String>,
24
25    #[serde(rename = "@recordCount", skip_serializing_if = "Option::is_none")]
26    pub record_count: Option<u32>,
27
28    #[serde(rename = "@refreshOnLoad", skip_serializing_if = "Option::is_none")]
29    pub refresh_on_load: Option<bool>,
30
31    #[serde(rename = "cacheSource")]
32    pub cache_source: CacheSource,
33
34    #[serde(rename = "cacheFields")]
35    pub cache_fields: CacheFields,
36}
37
38/// Source of data for the pivot cache.
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
40pub struct CacheSource {
41    #[serde(rename = "@type")]
42    pub source_type: String,
43
44    #[serde(rename = "worksheetSource", skip_serializing_if = "Option::is_none")]
45    pub worksheet_source: Option<WorksheetSource>,
46}
47
48/// Worksheet-based data source.
49#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50pub struct WorksheetSource {
51    #[serde(rename = "@ref")]
52    pub reference: String,
53
54    #[serde(rename = "@sheet")]
55    pub sheet: String,
56}
57
58/// Container for cache field definitions.
59#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60pub struct CacheFields {
61    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
62    pub count: Option<u32>,
63
64    #[serde(rename = "cacheField", default)]
65    pub fields: Vec<CacheField>,
66}
67
68/// Individual cache field definition.
69#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
70pub struct CacheField {
71    #[serde(rename = "@name")]
72    pub name: String,
73
74    #[serde(rename = "@numFmtId", skip_serializing_if = "Option::is_none")]
75    pub num_fmt_id: Option<u32>,
76
77    #[serde(rename = "sharedItems", skip_serializing_if = "Option::is_none")]
78    pub shared_items: Option<SharedItems>,
79}
80
81/// Shared items within a cache field.
82#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
83pub struct SharedItems {
84    #[serde(
85        rename = "@containsSemiMixedTypes",
86        skip_serializing_if = "Option::is_none"
87    )]
88    pub contains_semi_mixed_types: Option<bool>,
89
90    #[serde(rename = "@containsString", skip_serializing_if = "Option::is_none")]
91    pub contains_string: Option<bool>,
92
93    #[serde(rename = "@containsNumber", skip_serializing_if = "Option::is_none")]
94    pub contains_number: Option<bool>,
95
96    #[serde(rename = "@containsBlank", skip_serializing_if = "Option::is_none")]
97    pub contains_blank: Option<bool>,
98
99    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
100    pub count: Option<u32>,
101
102    #[serde(rename = "s", default)]
103    pub string_items: Vec<StringItem>,
104
105    #[serde(rename = "n", default)]
106    pub number_items: Vec<NumberItem>,
107}
108
109/// String value in shared items.
110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub struct StringItem {
112    #[serde(rename = "@v")]
113    pub value: String,
114}
115
116/// Numeric value in shared items.
117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
118pub struct NumberItem {
119    #[serde(rename = "@v")]
120    pub value: f64,
121}
122
123/// Root element for pivot cache records.
124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
125#[serde(rename = "pivotCacheRecords")]
126pub struct PivotCacheRecords {
127    #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
128    pub xmlns: String,
129
130    #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
131    pub xmlns_r: String,
132
133    #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
134    pub count: Option<u32>,
135
136    #[serde(rename = "r", default)]
137    pub records: Vec<CacheRecord>,
138}
139
140/// Individual cache record containing field values.
141///
142/// Each record uses separate optional vectors for each value type because
143/// serde + quick-xml does not reliably roundtrip internally-tagged enums
144/// within a mixed-content element. This flat representation is simpler and
145/// still captures the data faithfully.
146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
147pub struct CacheRecord {
148    #[serde(rename = "x", default)]
149    pub index_fields: Vec<IndexField>,
150
151    #[serde(rename = "n", default)]
152    pub number_fields: Vec<NumberField>,
153
154    #[serde(rename = "s", default)]
155    pub string_fields: Vec<StringField>,
156
157    #[serde(rename = "b", default)]
158    pub bool_fields: Vec<BoolField>,
159}
160
161/// Index reference field in a cache record.
162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163pub struct IndexField {
164    #[serde(rename = "@v")]
165    pub v: u32,
166}
167
168/// Number field in a cache record.
169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
170pub struct NumberField {
171    #[serde(rename = "@v")]
172    pub v: f64,
173}
174
175/// String field in a cache record.
176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
177pub struct StringField {
178    #[serde(rename = "@v")]
179    pub v: String,
180}
181
182/// Boolean field in a cache record.
183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
184pub struct BoolField {
185    #[serde(rename = "@v")]
186    pub v: bool,
187}
188
189#[cfg(test)]
190mod tests {
191    use super::*;
192
193    #[test]
194    fn test_worksheet_source_roundtrip() {
195        let src = WorksheetSource {
196            reference: "A1:D10".to_string(),
197            sheet: "Sheet1".to_string(),
198        };
199        let xml = quick_xml::se::to_string(&src).unwrap();
200        let parsed: WorksheetSource = quick_xml::de::from_str(&xml).unwrap();
201        assert_eq!(src, parsed);
202    }
203
204    #[test]
205    fn test_cache_source_roundtrip() {
206        let src = CacheSource {
207            source_type: "worksheet".to_string(),
208            worksheet_source: Some(WorksheetSource {
209                reference: "A1:D10".to_string(),
210                sheet: "Data".to_string(),
211            }),
212        };
213        let xml = quick_xml::se::to_string(&src).unwrap();
214        let parsed: CacheSource = quick_xml::de::from_str(&xml).unwrap();
215        assert_eq!(src, parsed);
216    }
217
218    #[test]
219    fn test_cache_source_without_worksheet() {
220        let src = CacheSource {
221            source_type: "external".to_string(),
222            worksheet_source: None,
223        };
224        let xml = quick_xml::se::to_string(&src).unwrap();
225        assert!(!xml.contains("worksheetSource"));
226        let parsed: CacheSource = quick_xml::de::from_str(&xml).unwrap();
227        assert_eq!(src, parsed);
228    }
229
230    #[test]
231    fn test_string_item_roundtrip() {
232        let item = StringItem {
233            value: "North".to_string(),
234        };
235        let xml = quick_xml::se::to_string(&item).unwrap();
236        let parsed: StringItem = quick_xml::de::from_str(&xml).unwrap();
237        assert_eq!(item, parsed);
238    }
239
240    #[test]
241    fn test_number_item_roundtrip() {
242        let item = NumberItem { value: 42.5 };
243        let xml = quick_xml::se::to_string(&item).unwrap();
244        let parsed: NumberItem = quick_xml::de::from_str(&xml).unwrap();
245        assert_eq!(item, parsed);
246    }
247
248    #[test]
249    fn test_shared_items_with_strings_roundtrip() {
250        let items = SharedItems {
251            contains_semi_mixed_types: Some(false),
252            contains_string: Some(true),
253            contains_number: Some(false),
254            contains_blank: None,
255            count: Some(3),
256            string_items: vec![
257                StringItem {
258                    value: "North".to_string(),
259                },
260                StringItem {
261                    value: "South".to_string(),
262                },
263                StringItem {
264                    value: "East".to_string(),
265                },
266            ],
267            number_items: vec![],
268        };
269        let xml = quick_xml::se::to_string(&items).unwrap();
270        let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
271        assert_eq!(items, parsed);
272    }
273
274    #[test]
275    fn test_shared_items_with_numbers_roundtrip() {
276        let items = SharedItems {
277            contains_semi_mixed_types: None,
278            contains_string: Some(false),
279            contains_number: Some(true),
280            contains_blank: None,
281            count: Some(2),
282            string_items: vec![],
283            number_items: vec![NumberItem { value: 100.0 }, NumberItem { value: 200.0 }],
284        };
285        let xml = quick_xml::se::to_string(&items).unwrap();
286        let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
287        assert_eq!(items, parsed);
288    }
289
290    #[test]
291    fn test_shared_items_empty_roundtrip() {
292        let items = SharedItems {
293            contains_semi_mixed_types: None,
294            contains_string: None,
295            contains_number: None,
296            contains_blank: None,
297            count: Some(0),
298            string_items: vec![],
299            number_items: vec![],
300        };
301        let xml = quick_xml::se::to_string(&items).unwrap();
302        let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
303        assert_eq!(items, parsed);
304    }
305
306    #[test]
307    fn test_cache_field_roundtrip() {
308        let field = CacheField {
309            name: "Region".to_string(),
310            num_fmt_id: Some(0),
311            shared_items: Some(SharedItems {
312                contains_semi_mixed_types: None,
313                contains_string: Some(true),
314                contains_number: None,
315                contains_blank: None,
316                count: Some(2),
317                string_items: vec![
318                    StringItem {
319                        value: "North".to_string(),
320                    },
321                    StringItem {
322                        value: "South".to_string(),
323                    },
324                ],
325                number_items: vec![],
326            }),
327        };
328        let xml = quick_xml::se::to_string(&field).unwrap();
329        let parsed: CacheField = quick_xml::de::from_str(&xml).unwrap();
330        assert_eq!(field, parsed);
331    }
332
333    #[test]
334    fn test_cache_field_no_shared_items() {
335        let field = CacheField {
336            name: "Amount".to_string(),
337            num_fmt_id: None,
338            shared_items: None,
339        };
340        let xml = quick_xml::se::to_string(&field).unwrap();
341        assert!(!xml.contains("sharedItems"));
342        assert!(!xml.contains("numFmtId"));
343        let parsed: CacheField = quick_xml::de::from_str(&xml).unwrap();
344        assert_eq!(field, parsed);
345    }
346
347    #[test]
348    fn test_cache_fields_roundtrip() {
349        let fields = CacheFields {
350            count: Some(2),
351            fields: vec![
352                CacheField {
353                    name: "Region".to_string(),
354                    num_fmt_id: Some(0),
355                    shared_items: None,
356                },
357                CacheField {
358                    name: "Sales".to_string(),
359                    num_fmt_id: Some(0),
360                    shared_items: None,
361                },
362            ],
363        };
364        let xml = quick_xml::se::to_string(&fields).unwrap();
365        let parsed: CacheFields = quick_xml::de::from_str(&xml).unwrap();
366        assert_eq!(fields, parsed);
367    }
368
369    #[test]
370    fn test_pivot_cache_definition_roundtrip() {
371        let def = PivotCacheDefinition {
372            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
373            xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
374                .to_string(),
375            r_id: None,
376            record_count: Some(5),
377            refresh_on_load: Some(true),
378            cache_source: CacheSource {
379                source_type: "worksheet".to_string(),
380                worksheet_source: Some(WorksheetSource {
381                    reference: "A1:C6".to_string(),
382                    sheet: "Data".to_string(),
383                }),
384            },
385            cache_fields: CacheFields {
386                count: Some(3),
387                fields: vec![
388                    CacheField {
389                        name: "Name".to_string(),
390                        num_fmt_id: Some(0),
391                        shared_items: None,
392                    },
393                    CacheField {
394                        name: "Region".to_string(),
395                        num_fmt_id: Some(0),
396                        shared_items: None,
397                    },
398                    CacheField {
399                        name: "Sales".to_string(),
400                        num_fmt_id: Some(0),
401                        shared_items: None,
402                    },
403                ],
404            },
405        };
406        let xml = quick_xml::se::to_string(&def).unwrap();
407        let parsed: PivotCacheDefinition = quick_xml::de::from_str(&xml).unwrap();
408        assert_eq!(def, parsed);
409    }
410
411    #[test]
412    fn test_pivot_cache_definition_structure() {
413        let def = PivotCacheDefinition {
414            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
415            xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
416                .to_string(),
417            r_id: Some("rId1".to_string()),
418            record_count: Some(10),
419            refresh_on_load: Some(true),
420            cache_source: CacheSource {
421                source_type: "worksheet".to_string(),
422                worksheet_source: Some(WorksheetSource {
423                    reference: "A1:D11".to_string(),
424                    sheet: "Sheet1".to_string(),
425                }),
426            },
427            cache_fields: CacheFields {
428                count: Some(1),
429                fields: vec![CacheField {
430                    name: "Col1".to_string(),
431                    num_fmt_id: None,
432                    shared_items: None,
433                }],
434            },
435        };
436        let xml = quick_xml::se::to_string(&def).unwrap();
437        assert!(xml.contains("<pivotCacheDefinition"));
438        assert!(xml.contains("recordCount=\"10\""));
439        assert!(xml.contains("<cacheSource"));
440        assert!(xml.contains("type=\"worksheet\""));
441        assert!(xml.contains("<worksheetSource"));
442        assert!(xml.contains("<cacheFields"));
443    }
444
445    #[test]
446    fn test_index_field_roundtrip() {
447        let field = IndexField { v: 3 };
448        let xml = quick_xml::se::to_string(&field).unwrap();
449        let parsed: IndexField = quick_xml::de::from_str(&xml).unwrap();
450        assert_eq!(field, parsed);
451    }
452
453    #[test]
454    fn test_number_field_roundtrip() {
455        let field = NumberField { v: 99.5 };
456        let xml = quick_xml::se::to_string(&field).unwrap();
457        let parsed: NumberField = quick_xml::de::from_str(&xml).unwrap();
458        assert_eq!(field, parsed);
459    }
460
461    #[test]
462    fn test_string_field_roundtrip() {
463        let field = StringField {
464            v: "hello".to_string(),
465        };
466        let xml = quick_xml::se::to_string(&field).unwrap();
467        let parsed: StringField = quick_xml::de::from_str(&xml).unwrap();
468        assert_eq!(field, parsed);
469    }
470
471    #[test]
472    fn test_bool_field_roundtrip() {
473        let field = BoolField { v: true };
474        let xml = quick_xml::se::to_string(&field).unwrap();
475        let parsed: BoolField = quick_xml::de::from_str(&xml).unwrap();
476        assert_eq!(field, parsed);
477    }
478
479    #[test]
480    fn test_cache_record_roundtrip() {
481        let record = CacheRecord {
482            index_fields: vec![IndexField { v: 0 }, IndexField { v: 1 }],
483            number_fields: vec![NumberField { v: 150.0 }],
484            string_fields: vec![],
485            bool_fields: vec![],
486        };
487        let xml = quick_xml::se::to_string(&record).unwrap();
488        let parsed: CacheRecord = quick_xml::de::from_str(&xml).unwrap();
489        assert_eq!(record, parsed);
490    }
491
492    #[test]
493    fn test_cache_record_with_strings() {
494        let record = CacheRecord {
495            index_fields: vec![],
496            number_fields: vec![],
497            string_fields: vec![
498                StringField {
499                    v: "alpha".to_string(),
500                },
501                StringField {
502                    v: "beta".to_string(),
503                },
504            ],
505            bool_fields: vec![BoolField { v: false }],
506        };
507        let xml = quick_xml::se::to_string(&record).unwrap();
508        let parsed: CacheRecord = quick_xml::de::from_str(&xml).unwrap();
509        assert_eq!(record, parsed);
510    }
511
512    #[test]
513    fn test_pivot_cache_records_roundtrip() {
514        let records = PivotCacheRecords {
515            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
516            xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
517                .to_string(),
518            count: Some(2),
519            records: vec![
520                CacheRecord {
521                    index_fields: vec![IndexField { v: 0 }],
522                    number_fields: vec![NumberField { v: 100.0 }],
523                    string_fields: vec![],
524                    bool_fields: vec![],
525                },
526                CacheRecord {
527                    index_fields: vec![IndexField { v: 1 }],
528                    number_fields: vec![NumberField { v: 200.0 }],
529                    string_fields: vec![],
530                    bool_fields: vec![],
531                },
532            ],
533        };
534        let xml = quick_xml::se::to_string(&records).unwrap();
535        let parsed: PivotCacheRecords = quick_xml::de::from_str(&xml).unwrap();
536        assert_eq!(records, parsed);
537    }
538
539    #[test]
540    fn test_pivot_cache_records_empty() {
541        let records = PivotCacheRecords {
542            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
543            xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
544                .to_string(),
545            count: Some(0),
546            records: vec![],
547        };
548        let xml = quick_xml::se::to_string(&records).unwrap();
549        let parsed: PivotCacheRecords = quick_xml::de::from_str(&xml).unwrap();
550        assert_eq!(records, parsed);
551    }
552
553    #[test]
554    fn test_pivot_cache_records_structure() {
555        let records = PivotCacheRecords {
556            xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
557            xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
558                .to_string(),
559            count: Some(1),
560            records: vec![CacheRecord {
561                index_fields: vec![IndexField { v: 0 }],
562                number_fields: vec![],
563                string_fields: vec![],
564                bool_fields: vec![],
565            }],
566        };
567        let xml = quick_xml::se::to_string(&records).unwrap();
568        assert!(xml.contains("<pivotCacheRecords"));
569        assert!(xml.contains("count=\"1\""));
570    }
571}