1use super::*;
2
3#[derive(Debug, Clone)]
5pub struct StatisticalZone {
6 pub zone_id: String,
7 pub zone_type: StatisticalZoneType,
8 pub capacity: u64,
9 pub datasets: HashMap<String, DatasetMetadata>,
10 pub access_pattern: AccessPattern,
11}
12
13#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
15pub enum StatisticalZoneType {
16 TimeSeries,
18 CrossSectional,
20 Panel,
22 Experimental,
24 Survey,
26 Simulation,
28 Cached,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct DatasetMetadata {
35 pub dataset_id: String,
36 pub dataset_type: DatasetType,
37 pub dimensions: DatasetDimensions,
38 pub data_types: Vec<DataType>,
39 pub sample_size: usize,
40 pub created_at: u64,
41 pub last_updated: u64,
42 pub access_count: u64,
43 pub privacy_level: PrivacyLevel,
44}
45
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
48pub enum DatasetType {
49 Numerical,
50 Categorical,
51 TimeSeries,
52 Text,
53 Image,
54 Audio,
55 Video,
56 Mixed,
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct DatasetDimensions {
62 pub rows: usize,
63 pub columns: usize,
64 pub time_steps: Option<usize>,
65 pub features: Option<usize>,
66}
67
68#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
70pub enum DataType {
71 Float32,
72 Float64,
73 Integer32,
74 Integer64,
75 Boolean,
76 String,
77 DateTime,
78 Categorical,
79}
80
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
83pub enum PrivacyLevel {
84 Public,
85 Restricted,
86 Confidential,
87 Secret,
88 TopSecret,
89}
90
91#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
93pub enum AccessPattern {
94 Sequential,
95 Random,
96 TimeSeries,
97 Grouped,
98 Adaptive,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103pub struct Dataset {
104 pub dataset_id: String,
105 pub metadata: DatasetMetadata,
106 pub data: Vec<Vec<DataValue>>,
107 pub column_names: Vec<String>,
108 pub column_types: Vec<DataType>,
109}
110
111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
113pub enum DataValue {
114 Float(f64),
115 Integer(i64),
116 Boolean(bool),
117 String(String),
118 DateTime(u64),
119 Categorical(String),
120 Null,
121}
122
123#[derive(Debug, Clone)]
125pub struct StatisticalAnalysisResult<T> {
126 pub result: T,
127 pub execution_time: u64,
128 pub memory_usage: u64,
129 pub sample_size: usize,
130 pub confidence_level: f64,
131 pub privacy_preserved: bool,
132 pub privacy_cost: f64,
133}
134
135impl StatisticalDataStorage {
136 pub fn new() -> Self {
138 Self {
139 zones: HashMap::new(),
140 data_catalog: DataCatalog::new(),
141 compression_engine: DataCompressionEngine::new(),
142 indexing_engine: DataIndexingEngine::new(),
143 dataset_cache: HashMap::new(),
144 zns_manager: None,
145 }
146 }
147
148 pub fn initialize(&mut self) -> Result<(), StatisticalError> {
150 self.create_zones()?;
152
153 self.data_catalog.initialize()?;
155
156 self.compression_engine.initialize()?;
158
159 self.indexing_engine.initialize()?;
161
162 Ok(())
163 }
164
165 fn create_zones(&mut self) -> Result<(), StatisticalError> {
166 let zones = vec![
167 ("timeseries", StatisticalZoneType::TimeSeries),
168 ("crosssectional", StatisticalZoneType::CrossSectional),
169 ("panel", StatisticalZoneType::Panel),
170 ("experimental", StatisticalZoneType::Experimental),
171 ("survey", StatisticalZoneType::Survey),
172 ("simulation", StatisticalZoneType::Simulation),
173 ("cached", StatisticalZoneType::Cached),
174 ];
175
176 for (name, zone_type) in zones {
177 let zone = StatisticalZone {
178 zone_id: name.to_string(),
179 zone_type,
180 capacity: 1024 * 1024 * 1024, datasets: HashMap::new(),
182 access_pattern: AccessPattern::Adaptive,
183 };
184 self.zones.insert(name.to_string(), zone);
185 }
186
187 Ok(())
188 }
189
190 pub fn store_dataset(&mut self, dataset: Dataset) -> Result<(), StatisticalError> {
192 let zone_id = self.select_best_zone(&dataset)?;
194
195 let zone = self
197 .zones
198 .get_mut(&zone_id)
199 .ok_or_else(|| StatisticalError::StorageError("Zone not found".to_string()))?;
200
201 zone.datasets
202 .insert(dataset.dataset_id.clone(), dataset.metadata.clone());
203
204 self.store_dataset_data(&dataset)?;
208
209 Ok(())
210 }
211
212 pub fn get_dataset(&self, dataset_id: &str) -> Result<Dataset, StatisticalError> {
214 self.get_dataset_data(dataset_id)
216 }
217
218 pub fn get_dataset_metadata(&self, dataset_id: &str) -> Option<DatasetMetadata> {
220 for zone in self.zones.values() {
221 if let Some(metadata) = zone.datasets.get(dataset_id) {
222 return Some(metadata.clone());
223 }
224 }
225 None
226 }
227
228 pub fn list_datasets(&self) -> Vec<String> {
230 let mut datasets = Vec::new();
231 for zone in self.zones.values() {
232 datasets.extend(zone.datasets.keys().cloned());
233 }
234 datasets
235 }
236
237 fn select_best_zone(&self, dataset: &Dataset) -> Result<String, StatisticalError> {
238 match dataset.metadata.dataset_type {
240 DatasetType::TimeSeries => Ok("timeseries".to_string()),
241 DatasetType::Mixed => Ok("crosssectional".to_string()),
242 _ => Ok("experimental".to_string()),
243 }
244 }
245
246 pub fn store_dataset_data(&mut self, dataset: &Dataset) -> Result<(), StatisticalError> {
254 let serialised = serde_json::to_vec(dataset)
257 .map_err(|e| StatisticalError::StorageError(e.to_string()))?;
258
259 if let Some(zns) = &self.zns_manager {
262 let _ = zns;
267 }
272
273 self.dataset_cache
276 .insert(dataset.dataset_id.clone(), dataset.clone());
277
278 let _ = serialised;
281
282 Ok(())
283 }
284
285 pub fn retrieve_dataset_data(&self, dataset_id: &str) -> Option<&Dataset> {
287 self.dataset_cache.get(dataset_id)
288 }
289
290 pub fn store_dataset_to_zone(
297 &mut self,
298 dataset_id: &str,
299 zone_id: &str,
300 ) -> Result<(), StatisticalError> {
301 let dataset = self
302 .dataset_cache
303 .get(dataset_id)
304 .ok_or_else(|| StatisticalError::DataNotFound(dataset_id.to_string()))?
305 .clone();
306
307 let zone = self.zones.get_mut(zone_id).ok_or_else(|| {
308 StatisticalError::StorageError(format!("Zone '{}' not found", zone_id))
309 })?;
310
311 zone.datasets
312 .insert(dataset_id.to_string(), dataset.metadata);
313 Ok(())
314 }
315
316 pub fn attach_zns_manager(&mut self, manager: Arc<Mutex<ZnsZoneManager>>) {
319 self.zns_manager = Some(manager);
320 }
321
322 fn get_dataset_data(&self, dataset_id: &str) -> Result<Dataset, StatisticalError> {
323 if let Some(dataset) = self.dataset_cache.get(dataset_id) {
325 return Ok(dataset.clone());
326 }
327 Err(StatisticalError::DataNotFound(dataset_id.to_string()))
328 }
329
330 fn get_dataset_data_legacy(&self, dataset_id: &str) -> Result<Dataset, StatisticalError> {
331 Ok(Dataset {
332 dataset_id: dataset_id.to_string(),
333 metadata: DatasetMetadata {
334 dataset_id: dataset_id.to_string(),
335 dataset_type: DatasetType::Mixed,
336 dimensions: DatasetDimensions {
337 rows: 100,
338 columns: 5,
339 time_steps: None,
340 features: Some(5),
341 },
342 data_types: vec![
343 DataType::Float64,
344 DataType::Float64,
345 DataType::Float64,
346 DataType::Float64,
347 DataType::Float64,
348 ],
349 sample_size: 100,
350 created_at: 0,
351 last_updated: 0,
352 access_count: 0,
353 privacy_level: PrivacyLevel::Public,
354 },
355 data: vec![
356 vec![
357 DataValue::Float(1.0),
358 DataValue::Float(2.0),
359 DataValue::Float(3.0),
360 DataValue::Float(4.0),
361 DataValue::Float(5.0),
362 ],
363 vec![
364 DataValue::Float(2.0),
365 DataValue::Float(3.0),
366 DataValue::Float(4.0),
367 DataValue::Float(5.0),
368 DataValue::Float(6.0),
369 ],
370 vec![
371 DataValue::Float(3.0),
372 DataValue::Float(4.0),
373 DataValue::Float(5.0),
374 DataValue::Float(6.0),
375 DataValue::Float(7.0),
376 ],
377 ],
378 column_names: vec![
379 "col1".to_string(),
380 "col2".to_string(),
381 "col3".to_string(),
382 "col4".to_string(),
383 "col5".to_string(),
384 ],
385 column_types: vec![
386 DataType::Float64,
387 DataType::Float64,
388 DataType::Float64,
389 DataType::Float64,
390 DataType::Float64,
391 ],
392 })
393 }
394
395 pub fn sample_dataset(&self) -> Result<Dataset, StatisticalError> {
399 self.get_dataset_data_legacy("sample")
400 }
401}