MeiliSearch/meilisearch-core/src/error.rs

132 lines
3.9 KiB
Rust
Raw Normal View History

2019-10-18 13:05:28 +02:00
use crate::serde::{DeserializerError, SerializerError};
2019-10-11 16:16:21 +02:00
use serde_json::Error as SerdeJsonError;
2019-10-18 13:05:28 +02:00
use std::{error, fmt, io};
2019-10-03 15:04:11 +02:00
2020-02-02 22:59:19 +01:00
pub use heed::Error as HeedError;
pub use fst::Error as FstError;
pub use bincode::Error as BincodeError;
2019-10-03 17:33:15 +02:00
pub type MResult<T> = Result<T, Error>;
2019-10-03 15:04:11 +02:00
#[derive(Debug)]
pub enum Error {
Io(io::Error),
IndexAlreadyExists,
MissingPrimaryKey,
2019-10-03 15:04:11 +02:00
SchemaMissing,
WordIndexMissing,
MissingDocumentId,
2020-01-10 18:20:30 +01:00
MaxFieldsLimitExceeded,
2020-01-13 19:10:58 +01:00
Schema(meilisearch_schema::Error),
2019-10-21 12:05:53 +02:00
Zlmdb(heed::Error),
Fst(fst::Error),
2019-10-11 16:16:21 +02:00
SerdeJson(SerdeJsonError),
Bincode(bincode::Error),
Serializer(SerializerError),
Deserializer(DeserializerError),
UnsupportedOperation(UnsupportedOperation),
}
impl From<io::Error> for Error {
fn from(error: io::Error) -> Error {
Error::Io(error)
}
2019-10-03 15:04:11 +02:00
}
2020-01-13 19:10:58 +01:00
impl From<meilisearch_schema::Error> for Error {
fn from(error: meilisearch_schema::Error) -> Error {
Error::Schema(error)
}
}
2020-02-02 22:59:19 +01:00
impl From<HeedError> for Error {
fn from(error: HeedError) -> Error {
2019-10-16 17:05:24 +02:00
Error::Zlmdb(error)
2019-10-03 15:04:11 +02:00
}
}
2020-02-02 22:59:19 +01:00
impl From<FstError> for Error {
fn from(error: FstError) -> Error {
Error::Fst(error)
2019-10-03 15:04:11 +02:00
}
}
2019-10-11 16:16:21 +02:00
impl From<SerdeJsonError> for Error {
fn from(error: SerdeJsonError) -> Error {
Error::SerdeJson(error)
2019-10-03 15:04:11 +02:00
}
}
2020-02-02 22:59:19 +01:00
impl From<BincodeError> for Error {
fn from(error: BincodeError) -> Error {
Error::Bincode(error)
2019-10-03 15:04:11 +02:00
}
}
impl From<SerializerError> for Error {
fn from(error: SerializerError) -> Error {
Error::Serializer(error)
2019-10-03 15:04:11 +02:00
}
}
impl From<DeserializerError> for Error {
fn from(error: DeserializerError) -> Error {
Error::Deserializer(error)
}
}
impl From<UnsupportedOperation> for Error {
fn from(op: UnsupportedOperation) -> Error {
Error::UnsupportedOperation(op)
}
}
2019-10-03 15:04:11 +02:00
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use self::Error::*;
match self {
Io(e) => write!(f, "{}", e),
IndexAlreadyExists => write!(f, "index already exists"),
2020-03-10 15:35:19 +01:00
MissingPrimaryKey => write!(f, "schema cannot be built without a primary key"),
2019-10-03 15:04:11 +02:00
SchemaMissing => write!(f, "this index does not have a schema"),
WordIndexMissing => write!(f, "this index does not have a word index"),
MissingDocumentId => write!(f, "document id is missing"),
2020-02-11 15:16:02 +01:00
MaxFieldsLimitExceeded => write!(f, "maximum number of fields in a document exceeded"),
Schema(e) => write!(f, "schema error; {}", e),
2019-10-21 12:05:53 +02:00
Zlmdb(e) => write!(f, "heed error; {}", e),
Fst(e) => write!(f, "fst error; {}", e),
2019-10-11 16:16:21 +02:00
SerdeJson(e) => write!(f, "serde json error; {}", e),
Bincode(e) => write!(f, "bincode error; {}", e),
Serializer(e) => write!(f, "serializer error; {}", e),
Deserializer(e) => write!(f, "deserializer error; {}", e),
UnsupportedOperation(op) => write!(f, "unsupported operation; {}", op),
2019-10-03 15:04:11 +02:00
}
}
}
2019-10-18 13:05:28 +02:00
impl error::Error for Error {}
2019-10-03 15:04:11 +02:00
#[derive(Debug)]
pub enum UnsupportedOperation {
SchemaAlreadyExists,
CannotUpdateSchemaPrimaryKey,
CannotReorderSchemaAttribute,
CanOnlyIntroduceNewSchemaAttributesAtEnd,
CannotRemoveSchemaAttribute,
}
impl fmt::Display for UnsupportedOperation {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use self::UnsupportedOperation::*;
match self {
SchemaAlreadyExists => write!(f, "Cannot update index which already have a schema"),
CannotUpdateSchemaPrimaryKey => write!(f, "Cannot update the primary key of a schema"),
CannotReorderSchemaAttribute => write!(f, "Cannot reorder the attributes of a schema"),
CanOnlyIntroduceNewSchemaAttributesAtEnd => {
write!(f, "Can only introduce new attributes at end of a schema")
}
CannotRemoveSchemaAttribute => write!(f, "Cannot remove attributes from a schema"),
}
}
}