mirror of
https://github.com/tursodatabase/limbo.git
synced 2025-08-04 10:08:20 +00:00
4ef3c1d04d
insert() fails if key exists (there shouldn't be two) and panics if it's different pages, and also fails if it can't make room for the page. Replaced the limited pop_if_not_dirty() function with make_room_for(). It tries to evict many pages as requested spare capacity. It should come handy later by resize() and Pager. make_room_for() tries to make room or fails if it can't evict enough entries. For make_room_for() I also tried with an all-or-nothing approach, so if say a query requests a lot more than possible to make room for, it doesn't evict a bunch of pages from the cache that might be useful. But implementing this approach got very complicated since it needs to keep exclusive PageRefs and collecting this caused segfaults. Might be worth trying again in the future. But beware the rabbit hole. Updated page cache test logic for new insert rules. Updated Pager.allocate_page() to handle failure logic but needs further work. This is to show new cache insert handling. There are many places to update. Left comments on callers of pager and page cache needing to update error handling, for now.
90 lines
2.6 KiB
Rust
90 lines
2.6 KiB
Rust
use thiserror::Error;
|
|
|
|
#[derive(Debug, Error, miette::Diagnostic)]
|
|
pub enum LimboError {
|
|
#[error("Corrupt database: {0}")]
|
|
Corrupt(String),
|
|
#[error("File is not a database")]
|
|
NotADB,
|
|
#[error("Internal error: {0}")]
|
|
InternalError(String),
|
|
#[error("Page cache is full")]
|
|
CacheFull,
|
|
#[error("Parse error: {0}")]
|
|
ParseError(String),
|
|
#[error(transparent)]
|
|
#[diagnostic(transparent)]
|
|
LexerError(#[from] limbo_sqlite3_parser::lexer::sql::Error),
|
|
#[error("Conversion error: {0}")]
|
|
ConversionError(String),
|
|
#[error("Env variable error: {0}")]
|
|
EnvVarError(#[from] std::env::VarError),
|
|
#[error("Transaction error: {0}")]
|
|
TxError(String),
|
|
#[error("I/O error: {0}")]
|
|
IOError(#[from] std::io::Error),
|
|
#[cfg(all(target_os = "linux", feature = "io_uring"))]
|
|
#[error("I/O error: {0}")]
|
|
UringIOError(String),
|
|
#[error("Locking error: {0}")]
|
|
LockingError(String),
|
|
#[cfg(target_family = "unix")]
|
|
#[error("I/O error: {0}")]
|
|
RustixIOError(#[from] rustix::io::Errno),
|
|
#[error("Parse error: {0}")]
|
|
ParseIntError(#[from] std::num::ParseIntError),
|
|
#[error("Parse error: {0}")]
|
|
ParseFloatError(#[from] std::num::ParseFloatError),
|
|
#[error("Parse error: {0}")]
|
|
InvalidDate(String),
|
|
#[error("Parse error: {0}")]
|
|
InvalidTime(String),
|
|
#[error("Modifier parsing error: {0}")]
|
|
InvalidModifier(String),
|
|
#[error("Invalid argument supplied: {0}")]
|
|
InvalidArgument(String),
|
|
#[error("Invalid formatter supplied: {0}")]
|
|
InvalidFormatter(String),
|
|
#[error("Runtime error: {0}")]
|
|
Constraint(String),
|
|
#[error("Extension error: {0}")]
|
|
ExtensionError(String),
|
|
#[error("Runtime error: integer overflow")]
|
|
IntegerOverflow,
|
|
#[error("Schema is locked for write")]
|
|
SchemaLocked,
|
|
#[error("Database Connection is read-only")]
|
|
ReadOnly,
|
|
#[error("Database is busy")]
|
|
Busy,
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! bail_parse_error {
|
|
($($arg:tt)*) => {
|
|
return Err($crate::error::LimboError::ParseError(format!($($arg)*)))
|
|
};
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! bail_corrupt_error {
|
|
($($arg:tt)*) => {
|
|
return Err($crate::error::LimboError::Corrupt(format!($($arg)*)))
|
|
};
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! bail_constraint_error {
|
|
($($arg:tt)*) => {
|
|
return Err($crate::error::LimboError::Constraint(format!($($arg)*)))
|
|
};
|
|
}
|
|
|
|
impl From<limbo_ext::ResultCode> for LimboError {
|
|
fn from(err: limbo_ext::ResultCode) -> Self {
|
|
LimboError::ExtensionError(err.to_string())
|
|
}
|
|
}
|
|
|
|
pub const SQLITE_CONSTRAINT: usize = 19;
|
|
pub const SQLITE_CONSTRAINT_PRIMARYKEY: usize = SQLITE_CONSTRAINT | (6 << 8);
|