solidb 1.0.2

A lightweight, high-performance structured database server written in Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use super::*;
use crate::error::{DbError, DbResult};
use crate::storage::schema::CollectionSchema;
use seahash::SeaHasher;
use std::hash::Hasher;

impl Collection {
    // ==================== Schema Management ====================

    /// Compute hash of schema for cache invalidation
    fn compute_schema_hash(schema: &CollectionSchema) -> u64 {
        let serialized = serde_json::to_vec(schema).unwrap_or_default();
        let mut hasher = SeaHasher::new();
        hasher.write(&serialized);
        hasher.finish()
    }

    /// Get or create cached schema validator
    pub fn get_cached_schema_validator(&self) -> Result<Option<SchemaValidator>, DbError> {
        if let Some(schema) = self.get_json_schema() {
            let schema_hash = Self::compute_schema_hash(&schema);

            // Fast path: read guards only (parking_lot's RwLock never
            // poisons, so no .unwrap() is needed).
            {
                let cached_hash = self.schema_hash.read();
                let cached_validator = self.schema_validator.read();
                if let Some(ref current_hash) = *cached_hash {
                    if *current_hash == schema_hash {
                        if let Some(ref validator) = *cached_validator {
                            return Ok(Some(validator.clone()));
                        }
                    }
                }
            }

            let validator = SchemaValidator::new(schema).map_err(|e| {
                DbError::InvalidDocument(format!("Schema compilation error: {}", e))
            })?;

            // Hold BOTH write guards while setting the pair so the hash and
            // validator can never be observed (or written) mismatched when
            // two threads race with different schema versions. Lock order is
            // always hash -> validator.
            {
                let mut cached_hash = self.schema_hash.write();
                let mut cached_validator = self.schema_validator.write();
                *cached_hash = Some(schema_hash);
                *cached_validator = Some(validator.clone());
            }

            Ok(Some(validator))
        } else {
            Ok(None)
        }
    }

    /// Invalidate schema cache (called when schema changes).
    /// Same lock order as the setter (hash -> validator), both held together.
    fn invalidate_schema_cache(&self) {
        let mut cached_hash = self.schema_hash.write();
        let mut cached_validator = self.schema_validator.write();
        *cached_hash = None;
        *cached_validator = None;
    }

    /// Set JSON schema for collection validation
    /// Set JSON schema for collection validation
    pub fn set_json_schema(&self, schema: CollectionSchema) -> DbResult<()> {
        self.invalidate_schema_cache();

        // Validate the schema itself if enabled
        if schema.is_enabled() {
            jsonschema::validator_for(&schema.schema)
                .map_err(|e| DbError::InvalidDocument(format!("Invalid JSON Schema: {}", e)))?;
        }

        let db = &self.db;
        let cf = db
            .cf_handle(&self.name)
            .expect("Column family should exist");

        let schema_bytes = serde_json::to_vec(&schema)?;
        db.put_cf(&cf, SCHEMA_KEY.as_bytes(), &schema_bytes)
            .map_err(|e| DbError::InternalError(format!("Failed to set schema: {}", e)))?;

        Ok(())
    }

    /// Get JSON schema
    pub fn get_json_schema(&self) -> Option<CollectionSchema> {
        let db = &self.db;
        let cf = db.cf_handle(&self.name)?;

        db.get_cf(&cf, SCHEMA_KEY.as_bytes())
            .ok()
            .flatten()
            .and_then(|bytes| serde_json::from_slice(&bytes).ok())
    }

    /// Remove JSON schema
    pub fn remove_json_schema(&self) -> DbResult<()> {
        self.invalidate_schema_cache();

        let db = &self.db;
        let cf = db
            .cf_handle(&self.name)
            .expect("Column family should exist");

        db.delete_cf(&cf, SCHEMA_KEY.as_bytes())
            .map_err(|e| DbError::InternalError(format!("Failed to remove schema: {}", e)))?;

        Ok(())
    }
}