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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
// Copyright 2016 Mozilla
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#![allow(dead_code)]

use failure::{
    Backtrace,
    Context,
    Fail,
};

use std::collections::{
    BTreeMap,
    BTreeSet,
};

use rusqlite;

use edn::entities::{
    TempId,
};

use core_traits::{
    Entid,
    KnownEntid,
    TypedValue,
    ValueType,
};

pub type Result<T> = ::std::result::Result<T, DbError>;

// TODO Error/ErrorKind pair
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CardinalityConflict {
    /// A cardinality one attribute has multiple assertions `[e a v1], [e a v2], ...`.
    CardinalityOneAddConflict {
        e: Entid,
        a: Entid,
        vs: BTreeSet<TypedValue>,
    },

    /// A datom has been both asserted and retracted, like `[:db/add e a v]` and `[:db/retract e a v]`.
    AddRetractConflict {
        e: Entid,
        a: Entid,
        vs: BTreeSet<TypedValue>,
    },
}

// TODO Error/ErrorKind pair
#[derive(Clone, Debug, Eq, PartialEq, Fail)]
pub enum SchemaConstraintViolation {
    /// A transaction tried to assert datoms where one tempid upserts to two (or more) distinct
    /// entids.
    ConflictingUpserts {
        /// A map from tempid to the entids it would upsert to.
        ///
        /// In the future, we might even be able to attribute the upserts to particular (reduced)
        /// datoms, i.e., to particular `[e a v]` triples that caused the constraint violation.
        /// Attributing constraint violations to input data is more difficult to the multiple
        /// rewriting passes the input undergoes.
        conflicting_upserts: BTreeMap<TempId, BTreeSet<KnownEntid>>,
    },

    /// A transaction tried to assert a datom or datoms with the wrong value `v` type(s).
    TypeDisagreements {
        /// The key (`[e a v]`) has an invalid value `v`: it is not of the expected value type.
        conflicting_datoms: BTreeMap<(Entid, Entid, TypedValue), ValueType>
    },

    /// A transaction tried to assert datoms that don't observe the schema's cardinality constraints.
    CardinalityConflicts {
        conflicts: Vec<CardinalityConflict>,
    },
}

impl ::std::fmt::Display for SchemaConstraintViolation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use self::SchemaConstraintViolation::*;
        match self {
            &ConflictingUpserts { ref conflicting_upserts } => {
                writeln!(f, "conflicting upserts:")?;
                for (tempid, entids) in conflicting_upserts {
                    writeln!(f, "  tempid {:?} upserts to {:?}", tempid, entids)?;
                }
                Ok(())
            },
            &TypeDisagreements { ref conflicting_datoms } => {
                writeln!(f, "type disagreements:")?;
                for (ref datom, expected_type) in conflicting_datoms {
                    writeln!(f, "  expected value of type {} but got datom [{} {} {:?}]", expected_type, datom.0, datom.1, datom.2)?;
                }
                Ok(())
            },
            &CardinalityConflicts { ref conflicts } => {
                writeln!(f, "cardinality conflicts:")?;
                for ref conflict in conflicts {
                    writeln!(f, "  {:?}", conflict)?;
                }
                Ok(())
            },
        }
    }
}

#[derive(Copy, Clone, Eq, PartialEq, Debug, Fail)]
pub enum InputError {
    /// Map notation included a bad `:db/id` value.
    BadDbId,

    /// A value place cannot be interpreted as an entity place (for example, in nested map
    /// notation).
    BadEntityPlace,
}

impl ::std::fmt::Display for InputError {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        use self::InputError::*;
        match self {
            &BadDbId => {
                writeln!(f, ":db/id in map notation must either not be present or be an entid, an ident, or a tempid")
            },
            &BadEntityPlace => {
                writeln!(f, "cannot convert value place into entity place")
            },
        }
    }
}

#[derive(Debug)]
pub struct DbError {
    inner: Context<DbErrorKind>,
}

impl ::std::fmt::Display for DbError {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        ::std::fmt::Display::fmt(&self.inner, f)
    }
}

impl Fail for DbError {
    fn cause(&self) -> Option<&Fail> {
        self.inner.cause()
    }

    fn backtrace(&self) -> Option<&Backtrace> {
        self.inner.backtrace()
    }
}

impl DbError {
    pub fn kind(&self) -> DbErrorKind {
        self.inner.get_context().clone()
    }
}

impl From<DbErrorKind> for DbError {
    fn from(kind: DbErrorKind) -> DbError {
        DbError { inner: Context::new(kind) }
    }
}

impl From<Context<DbErrorKind>> for DbError {
    fn from(inner: Context<DbErrorKind>) -> DbError {
        DbError { inner: inner }
    }
}

impl From<rusqlite::Error> for DbError {
    fn from(error: rusqlite::Error) -> DbError {
        DbError { inner: Context::new(DbErrorKind::RusqliteError(error.to_string())) }
    }
}

#[derive(Clone, PartialEq, Debug, Fail)]
pub enum DbErrorKind {
    /// We're just not done yet.  Message that the feature is recognized but not yet
    /// implemented.
    #[fail(display = "not yet implemented: {}", _0)]
    NotYetImplemented(String),

    /// We've been given a value that isn't the correct Mentat type.
    #[fail(display = "value '{}' is not the expected Mentat value type {:?}", _0, _1)]
    BadValuePair(String, ValueType),

    /// We've got corrupt data in the SQL store: a value and value_type_tag don't line up.
    /// TODO _1.data_type()
    #[fail(display = "bad SQL (value_type_tag, value) pair: ({:?}, {:?})", _0, _1)]
    BadSQLValuePair(rusqlite::types::Value, i32),

    // /// The SQLite store user_version isn't recognized.  This could be an old version of Mentat
    // /// trying to open a newer version SQLite store; or it could be a corrupt file; or ...
    // #[fail(display = "bad SQL store user_version: {}", _0)]
    // BadSQLiteStoreVersion(i32),

    /// A bootstrap definition couldn't be parsed or installed.  This is a programmer error, not
    /// a runtime error.
    #[fail(display = "bad bootstrap definition: {}", _0)]
    BadBootstrapDefinition(String),

    /// A schema assertion couldn't be parsed.
    #[fail(display = "bad schema assertion: {}", _0)]
    BadSchemaAssertion(String),

    /// An ident->entid mapping failed.
    #[fail(display = "no entid found for ident: {}", _0)]
    UnrecognizedIdent(String),

    /// An entid->ident mapping failed.
    #[fail(display = "no ident found for entid: {}", _0)]
    UnrecognizedEntid(Entid),

    /// Tried to transact an entid that isn't allocated.
    #[fail(display = "entid not allocated: {}", _0)]
    UnallocatedEntid(Entid),

    #[fail(display = "unknown attribute for entid: {}", _0)]
    UnknownAttribute(Entid),

    #[fail(display = "cannot reverse-cache non-unique attribute: {}", _0)]
    CannotCacheNonUniqueAttributeInReverse(Entid),

    #[fail(display = "schema alteration failed: {}", _0)]
    SchemaAlterationFailed(String),

    /// A transaction tried to violate a constraint of the schema of the Mentat store.
    #[fail(display = "schema constraint violation: {}", _0)]
    SchemaConstraintViolation(SchemaConstraintViolation),

    /// The transaction was malformed in some way (that was not recognized at parse time; for
    /// example, in a way that is schema-dependent).
    #[fail(display = "transaction input error: {}", _0)]
    InputError(InputError),

    #[fail(display = "Cannot transact a fulltext assertion with a typed value that is not :db/valueType :db.type/string")]
    WrongTypeValueForFtsAssertion,

    // SQL errors.
    #[fail(display = "could not update a cache")]
    CacheUpdateFailed,

    #[fail(display = "Could not set_user_version")]
    CouldNotSetVersionPragma,

    #[fail(display = "Could not get_user_version")]
    CouldNotGetVersionPragma,

    #[fail(display = "Could not search!")]
    CouldNotSearch,

    #[fail(display = "Could not insert transaction: failed to add datoms not already present")]
    TxInsertFailedToAddMissingDatoms,

    #[fail(display = "Could not insert transaction: failed to retract datoms already present")]
    TxInsertFailedToRetractDatoms,

    #[fail(display = "Could not update datoms: failed to retract datoms already present")]
    DatomsUpdateFailedToRetract,

    #[fail(display = "Could not update datoms: failed to add datoms not already present")]
    DatomsUpdateFailedToAdd,

    #[fail(display = "Failed to create temporary tables")]
    FailedToCreateTempTables,

    #[fail(display = "Could not insert non-fts one statements into temporary search table!")]
    NonFtsInsertionIntoTempSearchTableFailed,

    #[fail(display = "Could not insert fts values into fts table!")]
    FtsInsertionFailed,

    #[fail(display = "Could not insert FTS statements into temporary search table!")]
    FtsInsertionIntoTempSearchTableFailed,

    #[fail(display = "Could not drop FTS search ids!")]
    FtsFailedToDropSearchIds,

    #[fail(display = "Could not update partition map")]
    FailedToUpdatePartitionMap,

    #[fail(display = "Can't operate over mixed timelines")]
    TimelinesMixed,

    #[fail(display = "Can't move transactions to a non-empty timeline")]
    TimelinesMoveToNonEmpty,

    #[fail(display = "Supplied an invalid transaction range")]
    TimelinesInvalidRange,

    // It would be better to capture the underlying `rusqlite::Error`, but that type doesn't
    // implement many useful traits, including `Clone`, `Eq`, and `PartialEq`.
    #[fail(display = "SQL error: {}", _0)]
    RusqliteError(String),
}