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

//! Storage Engine trait and several implementations
//!
//!
mod engine;
mod meta;
pub mod types;
pub mod bstar;

mod data;

use bincode::rustc_serialize::{EncodingError, DecodingError};

pub use self::meta::Table;
pub use self::meta::Database;
pub use self::data::Rows;
pub use self::data::ResultSet;
pub use self::types::Column;
pub use self::types::SqlType;
pub use self::engine::FlatFile;

pub use parse::ast;
pub use parse::ast::CompType;



use std::io;
use std::io::Cursor;
use std::str::Utf8Error;
use std::ffi::NulError;
pub use std::string::FromUtf8Error;
/// A database table
///
/// Through this type, you can retreive certain meta information about the
/// table (like column names, column types, storage engine, ...). It's `access`
/// method locks the table globally and returns a storage engine to access
/// the table data.
#[derive(Debug)]
pub enum Error {
    Io(io::Error),
    BinEn(EncodingError),
    BinDe(DecodingError),
    Byteorder(::byteorder::Error),
    Utf8Error(FromUtf8Error),
    Utf8StrError(Utf8Error),
    NulError(NulError),
    WrongMagicNmbr,
    Engine, // cur not used
    LoadDataBase,
    RemoveColumn,
    AddColumn,
    InvalidType,
    InterruptedRead,
    OutOfBounds,
    MissingPrimaryKey,
    InvalidColumn,
    NotAPrimaryKey,
    NoImplementation,
    WrongLength,
    NoOperationPossible,
    InvalidState,
    EndOfFile,
    BeginningOfFile,
    PrimaryKeyValueExists,
    FoundNoPrimaryKey,
    PrimaryKeyNotAllowed,
}

impl From<NulError> for Error {
    fn from(err: NulError) -> Error {
        Error::NulError(err)
    }
}


impl From<Utf8Error> for Error {
    fn from(err: Utf8Error) -> Error {
        Error::Utf8StrError(err)
    }
}

impl From<FromUtf8Error> for Error {
    fn from(err: FromUtf8Error) -> Error {
        Error::Utf8Error(err)
    }
}


impl From<io::Error> for Error {
    fn from(err: io::Error) -> Error {
        Error::Io(err)
    }
}

impl  From<EncodingError> for Error {
    fn from(err: EncodingError) -> Error {
        Error::BinEn(err)
    }
}

impl From<DecodingError> for Error {
    fn from(err: DecodingError) -> Error {
        Error::BinDe(err)
    }
}

impl From<::byteorder::Error> for Error {
    fn from(err: ::byteorder::Error) -> Error {
        Error::Byteorder(err)
    }
}

//---------------------------------------------------------------
// Engine
//---------------------------------------------------------------

/// Storage Engine Interface.
///
/// A storage engine, like MyISAM and InnoDB, is responsible for reading and
/// writing data to disk, maintain and use indices, check for data corruption
/// and repair corrupt files.
///
/// Each table in a database may use a different storage engine.
pub trait Engine {
    /// writes the table.dat file
    fn create_table(&mut self) -> Result<(), Error>;
    /// returns the table
    fn table(&self) -> &Table;

    fn full_scan(&self) -> Result<Rows<Cursor<Vec<u8>>>, Error>;

    fn lookup(&self, column_index: usize, value: (&[u8], Option<usize>) , comp: CompType)
    -> Result<Rows<Cursor<Vec<u8>>>, Error>;

    fn insert_row(&mut self, row_data: &[u8]) -> Result<u64, Error>;

    fn delete(&self, column_index: usize, value: (&[u8], Option<usize>), comp: CompType)
    -> Result<u64, Error>;

    fn modify(&mut self, constraint_column_index: usize,
     constraint_value: (&[u8], Option<usize>), comp: CompType,
     values: &[(usize, &[u8])] )-> Result<u64, Error>;

    fn reorganize(&mut self) -> Result<(), Error>;

    fn reset(&mut self) -> Result<(), Error>;
}

#[repr(u8)]
#[derive(Clone,Copy,Debug,RustcDecodable, RustcEncodable)]
pub enum EngineID {
    FlatFile = 1,
    InvertedIndex,
    BStar,
}


// # Some information for the `storage` working group:
//
// You work at the very bottom of the database: The thing that actually
// writes the data disk. Everything in this module is used only by the
// query execution module.
//
// The file layout may look like this:
// We have some `db_dir` where everything lives. In that directory, there are
// subdirectories for every database. In each of those subdirs is optionally
// a file `db.meta` that contains information about the database (such as
// permissions). The tables of each database are saved in *.tbl files that
// live inside the database directory.
//
// Your task is to provide types and method to:
// - read a specific table from a specific
//   database from file
// - create a new table in a database
// - query meta information about a table (columns for example)
// - lock a table for reading/writing it's data through a storage engine
//
// The other main task is to:
// - specify the storage engine interface
// - implement a simple storage engine (heap/flatfiles)
//