featherdb_core/

error.rs

//! Error types for FeatherDB

use crate::PageId;
use std::fmt;
use thiserror::Error;

/// Result type alias using FeatherDB's Error
pub type Result<T> = std::result::Result<T, Error>;

/// Query context for tracking position in SQL
#[derive(Debug, Clone, Default)]
pub struct QueryContext {
    /// The original SQL query
    pub sql: String,
    /// Current line number (1-indexed)
    pub line: usize,
    /// Current column number (1-indexed)
    pub column: usize,
}

impl QueryContext {
    /// Create a new query context
    pub fn new(sql: impl Into<String>) -> Self {
        QueryContext {
            sql: sql.into(),
            line: 1,
            column: 1,
        }
    }

    /// Create a context with position
    pub fn with_position(sql: impl Into<String>, line: usize, column: usize) -> Self {
        QueryContext {
            sql: sql.into(),
            line,
            column,
        }
    }

    /// Get position from byte offset in the SQL string
    pub fn position_from_offset(&self, offset: usize) -> (usize, usize) {
        let mut line = 1;
        let mut column = 1;

        for (i, ch) in self.sql.char_indices() {
            if i >= offset {
                break;
            }
            if ch == '\n' {
                line += 1;
                column = 1;
            } else {
                column += 1;
            }
        }

        (line, column)
    }
}

/// Rich query error with context and suggestions
#[derive(Debug, Clone)]
pub struct QueryError {
    /// Error message
    pub message: String,
    /// The SQL query that caused the error
    pub sql: String,
    /// Line number where error occurred (1-indexed)
    pub line: usize,
    /// Column number where error occurred (1-indexed)
    pub column: usize,
    /// Suggested fix for the error
    pub suggestion: Option<String>,
    /// Additional help text
    pub help: Option<String>,
    /// Length of the error span (for underlining)
    pub span_length: usize,
}

impl QueryError {
    /// Create a new query error
    pub fn new(
        message: impl Into<String>,
        sql: impl Into<String>,
        line: usize,
        column: usize,
    ) -> Self {
        QueryError {
            message: message.into(),
            sql: sql.into(),
            line,
            column,
            suggestion: None,
            help: None,
            span_length: 1,
        }
    }

    /// Add a suggestion
    pub fn with_suggestion(mut self, suggestion: impl Into<String>) -> Self {
        self.suggestion = Some(suggestion.into());
        self
    }

    /// Add help text
    pub fn with_help(mut self, help: impl Into<String>) -> Self {
        self.help = Some(help.into());
        self
    }

    /// Set the span length for underlining
    pub fn with_span(mut self, length: usize) -> Self {
        self.span_length = length;
        self
    }

    /// Format the error with source context
    pub fn format_with_context(&self) -> String {
        let mut output = String::new();

        // Error header
        output.push_str(&format!("Error: {}\n", self.message));
        output.push_str(&format!("  --> query:{}:{}\n", self.line, self.column));
        output.push_str("  |\n");

        // Show the relevant line(s)
        let lines: Vec<&str> = self.sql.lines().collect();
        if self.line > 0 && self.line <= lines.len() {
            let line_content = lines[self.line - 1];
            output.push_str(&format!("{:3} | {}\n", self.line, line_content));

            // Add the error indicator
            let padding = " ".repeat(self.column.saturating_sub(1));
            let underline = "^".repeat(self.span_length.max(1));
            output.push_str(&format!("  | {}{}\n", padding, underline));
        }

        output.push_str("  |\n");

        // Add suggestion if present
        if let Some(ref suggestion) = self.suggestion {
            output.push_str(&format!("  = suggestion: {}\n", suggestion));
        }

        // Add help if present
        if let Some(ref help) = self.help {
            output.push_str(&format!("Help: {}\n", help));
        }

        output
    }
}

impl fmt::Display for QueryError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.format_with_context())
    }
}

impl std::error::Error for QueryError {}

/// Calculate Levenshtein distance between two strings
pub fn levenshtein_distance(a: &str, b: &str) -> usize {
    let a_len = a.chars().count();
    let b_len = b.chars().count();

    if a_len == 0 {
        return b_len;
    }
    if b_len == 0 {
        return a_len;
    }

    let a_chars: Vec<char> = a.chars().collect();
    let b_chars: Vec<char> = b.chars().collect();

    let mut matrix = vec![vec![0usize; b_len + 1]; a_len + 1];

    for (i, row) in matrix.iter_mut().enumerate().take(a_len + 1) {
        row[0] = i;
    }
    for (j, val) in matrix[0].iter_mut().enumerate().take(b_len + 1) {
        *val = j;
    }

    for i in 1..=a_len {
        for j in 1..=b_len {
            let cost =
                if a_chars[i - 1].to_lowercase().next() == b_chars[j - 1].to_lowercase().next() {
                    0
                } else {
                    1
                };

            matrix[i][j] = (matrix[i - 1][j] + 1)
                .min(matrix[i][j - 1] + 1)
                .min(matrix[i - 1][j - 1] + cost);
        }
    }

    matrix[a_len][b_len]
}

/// Find the best match from a list of candidates
pub fn find_best_match<'a>(
    input: &str,
    candidates: &[&'a str],
    max_distance: usize,
) -> Option<&'a str> {
    let input_lower = input.to_lowercase();

    // First, check for case-insensitive exact match
    for &candidate in candidates {
        if candidate.to_lowercase() == input_lower {
            return Some(candidate);
        }
    }

    // Find the best fuzzy match
    let mut best_match = None;
    let mut best_distance = max_distance + 1;

    for &candidate in candidates {
        let distance = levenshtein_distance(input, candidate);
        if distance < best_distance {
            best_distance = distance;
            best_match = Some(candidate);
        }
    }

    if best_distance <= max_distance {
        best_match
    } else {
        None
    }
}

/// Common SQL keyword typos and their corrections
pub fn suggest_keyword(typo: &str) -> Option<&'static str> {
    let typo_upper = typo.to_uppercase();
    match typo_upper.as_str() {
        // SELECT variants
        "SELCT" | "SELEC" | "SLECT" | "SELET" | "SEELCT" | "SELEKT" => Some("SELECT"),
        // FROM variants
        "FORM" | "FOMR" | "FRM" | "FRMO" | "FRON" => Some("FROM"),
        // WHERE variants
        "WHRE" | "WEHRE" | "WHER" | "WHEER" | "WAERE" => Some("WHERE"),
        // INSERT variants
        "INSRT" | "INSER" | "INSET" | "INSRET" | "ISERT" => Some("INSERT"),
        // INTO variants
        "ITNO" | "INOT" | "INT" | "INTO" => Some("INTO"),
        // UPDATE variants
        "UDPATE" | "UPDAE" | "UPDAT" | "UPDTE" | "UPADTE" => Some("UPDATE"),
        // DELETE variants
        "DELTE" | "DELEET" | "DELET" | "DELETEE" | "DELATE" => Some("DELETE"),
        // CREATE variants
        "CRAETE" | "CREAT" | "CRATE" | "CREAE" | "CRETAE" => Some("CREATE"),
        // TABLE variants
        "TABEL" | "TABL" | "TABLEE" | "TALBE" => Some("TABLE"),
        // VALUES variants
        "VALEUS" | "VLAUES" | "VALES" | "VALUESS" => Some("VALUES"),
        // ORDER variants
        "OREDR" | "ORDR" | "ODER" | "ORDEER" => Some("ORDER"),
        // GROUP variants
        "GRUOP" | "GOUP" | "GROPU" | "GROP" => Some("GROUP"),
        // JOIN variants
        "JION" | "JOUN" | "JON" | "JOINN" => Some("JOIN"),
        // LEFT variants
        "LFET" | "LETF" | "LEF" | "LEFTT" => Some("LEFT"),
        // RIGHT variants
        "RIGTH" | "RIGT" | "RIHGT" | "RIGHTT" => Some("RIGHT"),
        // INNER variants
        "INER" | "INNR" | "INEER" | "INNAR" => Some("INNER"),
        // OUTER variants
        "OTER" | "OUTR" | "OUUTER" | "OUTEER" => Some("OUTER"),
        // LIMIT variants
        "LIMT" | "LIMI" | "LIMTI" | "LMIT" => Some("LIMIT"),
        // OFFSET variants
        "OFFEST" | "OFFSE" | "OFSET" | "OFFET" => Some("OFFSET"),
        // HAVING variants
        "HAVNG" | "HAVIG" | "AHVING" | "HVAIN" => Some("HAVING"),
        // DISTINCT variants
        "DISTINT" | "DISTICT" | "DISTNCT" | "DISITINCT" => Some("DISTINCT"),
        // AND variants
        "AN" | "AD" | "ANN" | "ANDD" => Some("AND"),
        // OR variants (be careful, "OR" is very short)
        "OOR" | "ORR" => Some("OR"),
        // NOT variants
        "NOTT" | "NTO" | "NOO" => Some("NOT"),
        // NULL variants
        "NOLL" | "NULLL" | "NUL" | "NUUL" => Some("NULL"),
        // INDEX variants
        "INDX" | "IDNEX" | "INEDX" | "INDXE" => Some("INDEX"),
        // DROP variants
        "DRPO" | "DOP" | "DORP" | "DROOP" => Some("DROP"),
        // ALTER variants
        "ALTR" | "ALTRE" | "ATLER" | "ALETR" => Some("ALTER"),
        // SET variants
        "SE" | "SETT" | "STE" => Some("SET"),
        // AS variants
        "ASS" => Some("AS"),
        // BY variants
        "BYY" => Some("BY"),
        // PRIMARY variants
        "PRIMAY" | "PRIAMRY" | "PIRMARY" | "PRIMRY" => Some("PRIMARY"),
        // KEY variants
        "KYE" | "KEE" | "KEYY" => Some("KEY"),
        // UNIQUE variants
        "UNIQE" | "UNQUE" | "UINQUE" | "UNIQUEE" => Some("UNIQUE"),
        // DEFAULT variants
        "DEFUALT" | "DFAULT" | "DEAFULT" | "DEFALT" => Some("DEFAULT"),
        // CONSTRAINT variants
        "CONSTRAIN" | "CONSTRAING" | "CONSTRIANT" => Some("CONSTRAINT"),
        // FOREIGN variants
        "FORIEGN" | "FOREGIN" | "FORIGN" | "FOERIGN" => Some("FOREIGN"),
        // REFERENCES variants
        "REFERNCES" | "REFERECES" | "REFERNECE" | "REFRENCES" => Some("REFERENCES"),
        // CASCADE variants
        "CASCAD" | "CASCASE" | "CASCADEE" => Some("CASCADE"),
        // TRANSACTION variants
        "TRANACTION" | "TRASACTION" | "TRANSCATION" => Some("TRANSACTION"),
        // BEGIN variants
        "BEGINN" | "BGIN" | "BIGIN" | "BEGN" => Some("BEGIN"),
        // COMMIT variants
        "COMIT" | "COMMITT" | "COMMMIT" | "COMMTI" => Some("COMMIT"),
        // ROLLBACK variants
        "ROLBACK" | "ROLLBCK" | "ROOLBACK" | "ROLLBAK" => Some("ROLLBACK"),
        _ => None,
    }
}

/// Configuration error type
#[derive(Debug, Clone, Error)]
pub enum ConfigError {
    /// Value is too low for a configuration field
    #[error("Configuration error: {field} value {actual} is too low (minimum: {min})")]
    ValueTooLow {
        field: String,
        min: u64,
        actual: u64,
    },

    /// Value is too high for a configuration field
    #[error("Configuration error: {field} value {actual} is too high (maximum: {max})")]
    ValueTooHigh {
        field: String,
        max: u64,
        actual: u64,
    },

    /// Invalid value for a configuration field
    #[error("Configuration error: {field} has invalid value: {reason}")]
    InvalidValue { field: String, reason: String },
}

/// Main error type for FeatherDB operations
#[derive(Debug, Error)]
pub enum Error {
    // ============ User-facing errors (actionable) ============
    /// Table not found
    #[error("Table '{table}' not found{}", suggestion.as_ref().map(|s| format!(". Did you mean '{}'?", s)).unwrap_or_default())]
    TableNotFound {
        table: String,
        suggestion: Option<String>,
    },

    /// Column not found in table
    #[error("Column '{column}' not found in table '{table}'{}", suggestion.as_ref().map(|s| format!(". Did you mean '{}'?", s)).unwrap_or_default())]
    ColumnNotFound {
        column: String,
        table: String,
        suggestion: Option<String>,
    },

    /// Ambiguous column reference
    #[error(
        "Ambiguous column '{column}'. Could be from: {tables}. Please qualify with table name."
    )]
    AmbiguousColumn { column: String, tables: String },

    /// Index not found
    #[error("Index '{index}' not found on table '{table}'")]
    IndexNotFound { index: String, table: String },

    /// SQL syntax error
    #[error("Syntax error at line {line}, column {column}: {message}")]
    SyntaxError {
        message: String,
        line: usize,
        column: usize,
    },

    /// Type mismatch error
    #[error("Type mismatch: expected {expected}, got {actual}")]
    TypeError { expected: String, actual: String },

    /// Unique constraint violation
    #[error("unique constraint violated: duplicate value in column '{column}' of table '{table}'")]
    UniqueViolation { table: String, column: String },

    /// Primary key violation
    #[error("Primary key violation: duplicate key in table '{table}'")]
    PrimaryKeyViolation { table: String },

    /// Not null constraint violation
    #[error("NOT NULL constraint failed: {table}.{column}")]
    NotNullViolation { table: String, column: String },

    /// Foreign key constraint violation
    #[error("Foreign key constraint failed: {details}")]
    ForeignKeyViolation { details: String },

    /// CHECK constraint violation
    #[error("CHECK constraint failed on {table}.{column}: constraint '{constraint}' violated by value {value}")]
    CheckViolation {
        table: String,
        column: String,
        constraint: String,
        value: String,
    },

    /// Transaction conflict (optimistic concurrency)
    #[error("Transaction conflict detected, please retry")]
    TransactionConflict,

    /// Write-write conflict (first-committer-wins)
    #[error("Write conflict on table '{table}': another transaction modified the same row and committed first")]
    WriteConflict { table: String },

    /// Transaction already committed or aborted
    #[error("Transaction already ended")]
    TransactionEnded,

    /// Transaction timeout
    #[error(
        "Transaction {transaction_id} exceeded timeout of {timeout_ms}ms (elapsed: {elapsed_ms}ms)"
    )]
    TransactionTimeout {
        transaction_id: u64,
        elapsed_ms: u64,
        timeout_ms: u64,
    },

    /// Deadlock detected
    #[error("Deadlock detected: cycle {cycle:?}, transaction {victim} selected as victim")]
    DeadlockDetected { cycle: Vec<u64>, victim: u64 },

    /// Savepoint not found
    #[error("Savepoint '{name}' not found")]
    SavepointNotFound { name: String },

    /// Table already exists
    #[error("Table '{table}' already exists")]
    TableAlreadyExists { table: String },

    /// Index already exists
    #[error("Index '{index}' already exists")]
    IndexAlreadyExists { index: String },

    /// Database is read-only
    #[error("Database is read-only")]
    ReadOnly,

    /// Database is locked by another process
    #[error("Database is locked by another process")]
    DatabaseLocked,

    /// Invalid SQL query
    #[error("Invalid query: {message}")]
    InvalidQuery { message: String },

    /// Rich query error with full context
    #[error("{0}")]
    Query(#[from] QueryError),

    /// Unsupported feature
    #[error("Unsupported feature: {feature}")]
    Unsupported { feature: String },

    /// Configuration error
    #[error("{0}")]
    Config(#[from] ConfigError),

    // ============ Internal errors ============
    /// Page is corrupted (checksum mismatch or invalid structure)
    #[error("Page {0:?} is corrupted")]
    CorruptedPage(PageId),

    /// WAL is corrupted
    #[error("Write-ahead log is corrupted: {message}")]
    CorruptedWal { message: String },

    /// Invalid page type
    #[error("Invalid page type {page_type} for page {page_id:?}")]
    InvalidPageType { page_id: PageId, page_type: u8 },

    /// Page not found in buffer pool
    #[error("Page {0:?} not found")]
    PageNotFound(PageId),

    /// Double free error
    #[error("Page {0:?} was already freed")]
    DoubleFree(PageId),

    /// Buffer pool is full and cannot evict any pages
    #[error("Buffer pool is full ({pinned} of {capacity} pages pinned)")]
    BufferPoolFull { capacity: usize, pinned: usize },

    /// Invalid database file
    #[error("Invalid database file: {message}")]
    InvalidDatabaseFile { message: String },

    /// Database version mismatch
    #[error("Database format version {file_version} is not supported (expected {expected})")]
    VersionMismatch { file_version: u32, expected: u32 },

    /// Internal error (should not happen in production)
    #[error("Internal error: {0}")]
    Internal(String),

    // ============ I/O errors ============
    /// I/O error
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    /// File not found
    #[error("Database file not found: {path}")]
    FileNotFound { path: String },

    /// Serialization error
    #[error("Serialization error: {0}")]
    Serialization(String),

    // ============ Compression errors ============
    /// Compression error
    #[error("Compression failed: {message}")]
    CompressionError { message: String },

    /// Decompression error
    #[error("Decompression failed: {message} (expected {expected_size} bytes)")]
    DecompressionError {
        message: String,
        expected_size: usize,
    },

    // ============ Storage limit errors ============
    /// Database size limit exceeded
    #[error("Database size limit exceeded: current size {current_bytes} bytes, limit {limit_bytes} bytes, attempted to add {operation_bytes} bytes")]
    StorageLimitExceeded {
        current_bytes: u64,
        limit_bytes: u64,
        operation_bytes: u64,
    },

    /// WAL size limit exceeded
    #[error(
        "WAL size limit exceeded: current size {current_bytes} bytes, limit {limit_bytes} bytes"
    )]
    WalLimitExceeded {
        current_bytes: u64,
        limit_bytes: u64,
    },

    /// Insufficient disk space
    #[error("Insufficient disk space: available {available_bytes} bytes, required {required_bytes} bytes")]
    InsufficientDiskSpace {
        available_bytes: u64,
        required_bytes: u64,
    },

    // ============ Authentication errors ============
    /// Authentication failed
    #[error("Authentication failed: {reason}")]
    AuthenticationFailed { reason: String },

    /// Database requires authentication but no key provided
    #[error("This database requires authentication. Provide an API key in config.")]
    AuthenticationRequired,

    /// API key not found
    #[error("API key '{key_id}' not found")]
    ApiKeyNotFound { key_id: String },

    /// API key has expired
    #[error("API key '{key_id}' has expired")]
    ApiKeyExpired { key_id: String },

    /// API key has been revoked
    #[error("API key '{key_id}' has been revoked")]
    ApiKeyRevoked { key_id: String },

    // ============ Authorization errors ============
    /// Permission denied for operation on table
    #[error("Permission denied: {operation} on table '{table}' for API key '{api_key_id}'")]
    PermissionDenied {
        table: String,
        operation: String,
        api_key_id: String,
    },

    // ============ Session errors (v0.4.5) ============
    /// Session not found
    #[error("Session '{session_id}' not found")]
    SessionNotFound { session_id: String },

    /// Session has expired due to inactivity
    #[error("Session '{session_id}' has expired (inactive for {inactive_secs}s, timeout: {timeout_secs}s)")]
    SessionExpired {
        session_id: String,
        inactive_secs: u64,
        timeout_secs: u64,
    },

    /// Session has been closed
    #[error("Session '{session_id}' has been closed")]
    SessionClosed { session_id: String },

    /// Maximum number of sessions exceeded
    #[error("Maximum number of sessions ({max}) exceeded")]
    MaxSessionsExceeded { max: usize },

    /// Cannot reopen an ephemeral session
    #[error("Session '{session_id}' is not persistent and cannot be reopened")]
    SessionNotPersistent { session_id: String },

    // ============ Reliability errors (v0.5.0) ============
    /// Database has been closed
    #[error("Database is closed")]
    DatabaseClosed,

    /// Recovery failed
    #[error("Recovery failed: {message}")]
    RecoveryFailed { message: String },
}

impl Error {
    /// Create a new internal error
    pub fn internal(msg: impl Into<String>) -> Self {
        Error::Internal(msg.into())
    }

    /// Create a new invalid query error
    pub fn invalid_query(msg: impl Into<String>) -> Self {
        Error::InvalidQuery {
            message: msg.into(),
        }
    }

    /// Create a column not found error with optional suggestion
    pub fn column_not_found(
        column: impl Into<String>,
        table: impl Into<String>,
        suggestion: Option<String>,
    ) -> Self {
        Error::ColumnNotFound {
            column: column.into(),
            table: table.into(),
            suggestion,
        }
    }

    /// Create a rich query error
    pub fn query_error(
        message: impl Into<String>,
        sql: impl Into<String>,
        line: usize,
        column: usize,
    ) -> Self {
        Error::Query(QueryError::new(message, sql, line, column))
    }

    /// Create a query error with suggestion
    pub fn query_error_with_suggestion(
        message: impl Into<String>,
        sql: impl Into<String>,
        line: usize,
        column: usize,
        suggestion: impl Into<String>,
    ) -> Self {
        Error::Query(QueryError::new(message, sql, line, column).with_suggestion(suggestion))
    }

    /// Create a new unsupported feature error
    pub fn unsupported(feature: impl Into<String>) -> Self {
        Error::Unsupported {
            feature: feature.into(),
        }
    }

    /// Create a transaction timeout error
    pub fn transaction_timeout(transaction_id: u64, elapsed_ms: u64, timeout_ms: u64) -> Self {
        Error::TransactionTimeout {
            transaction_id,
            elapsed_ms,
            timeout_ms,
        }
    }

    /// Check if this error is retriable (e.g., transaction conflict)
    pub fn is_retriable(&self) -> bool {
        matches!(
            self,
            Error::TransactionConflict | Error::WriteConflict { .. } | Error::DatabaseLocked
        )
    }

    /// Check if this error is a user error (vs internal/system error)
    pub fn is_user_error(&self) -> bool {
        matches!(
            self,
            Error::TableNotFound { .. }
                | Error::ColumnNotFound { .. }
                | Error::SyntaxError { .. }
                | Error::TypeError { .. }
                | Error::UniqueViolation { .. }
                | Error::PrimaryKeyViolation { .. }
                | Error::NotNullViolation { .. }
                | Error::ForeignKeyViolation { .. }
                | Error::CheckViolation { .. }
                | Error::InvalidQuery { .. }
                | Error::Query(_)
        )
    }

    /// Try to get the QueryError if this is a query error
    pub fn as_query_error(&self) -> Option<&QueryError> {
        match self {
            Error::Query(e) => Some(e),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_levenshtein_distance() {
        assert_eq!(levenshtein_distance("", ""), 0);
        assert_eq!(levenshtein_distance("abc", "abc"), 0);
        assert_eq!(levenshtein_distance("abc", "abd"), 1);
        assert_eq!(levenshtein_distance("abc", "abcd"), 1);
        assert_eq!(levenshtein_distance("kitten", "sitting"), 3);
        assert_eq!(levenshtein_distance("FORM", "FROM"), 2);
        assert_eq!(levenshtein_distance("naem", "name"), 2);
    }

    #[test]
    fn test_find_best_match() {
        let candidates = vec!["name", "email", "age", "id"];

        assert_eq!(find_best_match("naem", &candidates, 2), Some("name"));
        assert_eq!(find_best_match("emai", &candidates, 2), Some("email"));
        assert_eq!(find_best_match("NAME", &candidates, 2), Some("name")); // case insensitive
        assert_eq!(find_best_match("xyz", &candidates, 2), None);
    }

    #[test]
    fn test_suggest_keyword() {
        assert_eq!(suggest_keyword("FORM"), Some("FROM"));
        assert_eq!(suggest_keyword("SELEKT"), Some("SELECT"));
        assert_eq!(suggest_keyword("WHRE"), Some("WHERE"));
        assert_eq!(suggest_keyword("SELECT"), None); // correct keyword
    }

    #[test]
    fn test_query_context_position() {
        let ctx = QueryContext::new("SELECT *\nFROM users\nWHERE id = 1");

        assert_eq!(ctx.position_from_offset(0), (1, 1)); // 'S'
        assert_eq!(ctx.position_from_offset(7), (1, 8)); // '*'
        assert_eq!(ctx.position_from_offset(9), (2, 1)); // 'F'
        assert_eq!(ctx.position_from_offset(14), (2, 6)); // 'u'
    }

    #[test]
    fn test_query_error_format() {
        let err = QueryError::new("Column 'naem' not found", "SELECT naem FROM users", 1, 8)
            .with_span(4)
            .with_suggestion("Did you mean 'name'?");

        let formatted = err.format_with_context();
        assert!(formatted.contains("Column 'naem' not found"));
        assert!(formatted.contains("query:1:8"));
        assert!(formatted.contains("SELECT naem FROM users"));
        assert!(formatted.contains("Did you mean 'name'?"));
    }

    #[test]
    fn test_transaction_timeout_error() {
        let err = Error::transaction_timeout(123, 6000, 5000);
        let msg = err.to_string();
        assert!(msg.contains("Transaction 123"));
        assert!(msg.contains("exceeded timeout of 5000ms"));
        assert!(msg.contains("elapsed: 6000ms"));
    }

    #[test]
    fn test_transaction_timeout_error_display() {
        let err = Error::TransactionTimeout {
            transaction_id: 456,
            elapsed_ms: 8000,
            timeout_ms: 7000,
        };
        let msg = format!("{}", err);
        assert!(msg.contains("456"));
        assert!(msg.contains("8000"));
        assert!(msg.contains("7000"));
    }

    #[test]
    fn test_storage_limit_exceeded_error() {
        let err = Error::StorageLimitExceeded {
            current_bytes: 95_000_000,
            limit_bytes: 100_000_000,
            operation_bytes: 10_000_000,
        };
        let msg = err.to_string();
        assert!(msg.contains("Database size limit exceeded"));
        assert!(msg.contains("95000000"));
        assert!(msg.contains("100000000"));
        assert!(msg.contains("10000000"));
    }

    #[test]
    fn test_wal_limit_exceeded_error() {
        let err = Error::WalLimitExceeded {
            current_bytes: 10_000_000,
            limit_bytes: 10_485_760,
        };
        let msg = err.to_string();
        assert!(msg.contains("WAL size limit exceeded"));
        assert!(msg.contains("10000000"));
        assert!(msg.contains("10485760"));
    }

    #[test]
    fn test_insufficient_disk_space_error() {
        let err = Error::InsufficientDiskSpace {
            available_bytes: 50_000_000,
            required_bytes: 100_000_000,
        };
        let msg = err.to_string();
        assert!(msg.contains("Insufficient disk space"));
        assert!(msg.contains("50000000"));
        assert!(msg.contains("100000000"));
    }
}