SYMBOL INDEX (962 symbols across 40 files)

FILE: docs/tools/update-links.py
  function get_latest_sha (line 10) | def get_latest_sha(owner, repo, path, token):
  function process_markdown (line 21) | def process_markdown(text, token):
  function main (line 41) | def main():

FILE: src/bin/toydb.rs
  function main (line 24) | fn main() {
  type Config (line 33) | struct Config {
    method load (line 63) | fn load(file: &str) -> Result<Self> {
  type Command (line 85) | struct Command {
    method run (line 93) | fn run(self) -> Result<()> {

FILE: src/bin/toydump.rs
  function main (line 13) | fn main() {
  type Command (line 22) | struct Command {
    method run (line 35) | fn run(self) -> Result<()> {

FILE: src/bin/toysql.rs
  function main (line 23) | fn main() {
  type Command (line 32) | struct Command {
    method run (line 46) | fn run(self) -> Result<()> {
  type Shell (line 56) | struct Shell {
    method new (line 69) | fn new(host: &str, port: u16) -> Result<Self> {
    method execute (line 84) | fn execute(&mut self, input: &str) -> Result<()> {
    method execute_command (line 95) | fn execute_command(&mut self, input: &str) -> Result<()> {
    method execute_sql (line 176) | fn execute_sql(&mut self, statement: &str) -> Result<()> {
    method prompt (line 207) | fn prompt(&mut self) -> rustyline::Result<String> {
    method run (line 217) | fn run(&mut self) -> Result<()> {
  type InputValidator (line 258) | struct InputValidator;
  method validate (line 261) | fn validate(&self, ctx: &mut ValidationContext) -> rustyline::Result<Val...
  method validate_while_typing (line 276) | fn validate_while_typing(&self) -> bool {

FILE: src/bin/workload.rs
  function main (line 28) | fn main() {
  type Command (line 43) | struct Command {
  type Subcommand (line 52) | enum Subcommand {
  type Runner (line 60) | struct Runner {
    method run (line 85) | fn run<W: Workload>(self, workload: W) -> Result<()> {
  type Workload (line 184) | trait Workload: std::fmt::Display {
    method prepare (line 189) | fn prepare(&self, client: &mut Client, rng: &mut StdRng) -> Result<()>;
    method generate (line 192) | fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::I...
    method execute (line 196) | fn execute(client: &mut Client, item: &Self::Item) -> Result<()>;
    method verify (line 199) | fn verify(&self, _client: &mut Client, _txns: usize) -> Result<()> {
    type Item (line 230) | type Item = HashSet<u64>;
    method prepare (line 232) | fn prepare(&self, client: &mut Client, rng: &mut StdRng) -> Result<()> {
    method generate (line 253) | fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::I...
    method execute (line 261) | fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {
    method verify (line 272) | fn verify(&self, client: &mut Client, _: usize) -> Result<()> {
    type Item (line 324) | type Item = Vec<(u64, String)>;
    method prepare (line 326) | fn prepare(&self, client: &mut Client, _: &mut StdRng) -> Result<()> {
    method generate (line 334) | fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::I...
    method execute (line 338) | fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {
    method verify (line 352) | fn verify(&self, client: &mut Client, txns: usize) -> Result<()> {
    type Item (line 415) | type Item = (u64, u64, u64);
    method prepare (line 417) | fn prepare(&self, client: &mut Client, rng: &mut StdRng) -> Result<()> {
    method generate (line 461) | fn generate(&self, rng: StdRng) -> Result<impl Iterator<Item = Self::I...
    method execute (line 473) | fn execute(client: &mut Client, item: &Self::Item) -> Result<()> {
    method verify (line 518) | fn verify(&self, client: &mut Client, _: usize) -> Result<()> {
  type Read (line 209) | struct Read {
    method fmt (line 224) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ReadGenerator (line 280) | struct ReadGenerator {
  type Item (line 287) | type Item = <Read as Workload>::Item;
  method next (line 289) | fn next(&mut self) -> Option<Self::Item> {
  type Write (line 307) | struct Write {
    method fmt (line 318) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type WriteGenerator (line 361) | struct WriteGenerator {
  type Item (line 369) | type Item = <Write as Workload>::Item;
  method next (line 371) | fn next(&mut self) -> Option<Self::Item> {
  type Bank (line 390) | struct Bank {
    method fmt (line 409) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: src/client.rs
  type Client (line 17) | pub struct Client {
    method connect (line 28) | pub fn connect(addr: impl ToSocketAddrs) -> Result<Self> {
    method request (line 36) | fn request(&mut self, request: Request) -> Result<Response> {
    method execute (line 43) | pub fn execute(&mut self, statement: &str) -> Result<StatementResult> {
    method get_table (line 59) | pub fn get_table(&mut self, table: &str) -> Result<Table> {
    method list_tables (line 67) | pub fn list_tables(&mut self) -> Result<Vec<String>> {
    method status (line 75) | pub fn status(&mut self) -> Result<Status> {
    method txn (line 83) | pub fn txn(&self) -> Option<&mvcc::TransactionState> {
    method with_retry (line 91) | pub fn with_retry<T>(&mut self, f: impl Fn(&mut Client) -> Result<T>) ...

FILE: src/encoding/bincode.rs
  constant CONFIG (line 16) | const CONFIG: bincode::config::Configuration = bincode::config::standard();
  function serialize (line 19) | pub fn serialize<T: Serialize>(value: &T) -> Vec<u8> {
  function deserialize (line 25) | pub fn deserialize<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> Result...
  function serialize_into (line 30) | pub fn serialize_into<W: Write, T: Serialize>(mut writer: W, value: &T) ...
  function deserialize_from (line 36) | pub fn deserialize_from<R: Read, T: DeserializeOwned>(mut reader: R) -> ...
  function maybe_deserialize_from (line 42) | pub fn maybe_deserialize_from<R: Read, T: DeserializeOwned>(mut reader: ...

FILE: src/encoding/format.rs
  type Formatter (line 16) | pub trait Formatter {
    method key (line 18) | fn key(key: &[u8]) -> String;
    method value (line 21) | fn value(key: &[u8], value: &[u8]) -> String;
    method key_value (line 24) | fn key_value(key: &[u8], value: &[u8]) -> String {
    method key_maybe_value (line 29) | fn key_maybe_value(key: &[u8], value: Option<&[u8]>) -> String {
    method key (line 48) | fn key(key: &[u8]) -> String {
    method value (line 52) | fn value(_key: &[u8], value: &[u8]) -> String {
    method key (line 69) | fn key(key: &[u8]) -> String {
    method value (line 76) | fn value(key: &[u8], value: &[u8]) -> String {
    method key (line 108) | fn key(key: &[u8]) -> String {
    method value (line 128) | fn value(key: &[u8], value: &[u8]) -> String {
    method key (line 174) | fn key(key: &[u8]) -> String {
    method value (line 193) | fn value(key: &[u8], value: &[u8]) -> String {
    method key (line 231) | fn key(_key: &[u8]) -> String {
    method value (line 236) | fn value(_key: &[u8], value: &[u8]) -> String {
  type Raw (line 37) | pub struct Raw;
    method bytes (line 41) | pub fn bytes(bytes: &[u8]) -> String {
  type Raft (line 58) | pub struct Raft<F: Formatter>(PhantomData<F>);
  function entry (line 62) | pub fn entry(entry: &raft::Entry) -> String {
  type MVCC (line 105) | pub struct MVCC<F: Formatter>(PhantomData<F>);
  type SQL (line 157) | pub struct SQL;
    method values (line 161) | fn values(values: impl IntoIterator<Item = sql::types::Value>) -> Stri...
    method schema (line 166) | fn schema(table: sql::types::Table) -> String {
  type SQLCommand (line 228) | pub struct SQLCommand;

FILE: src/encoding/keycode.rs
  function serialize (line 58) | pub fn serialize<T: Serialize>(key: &T) -> Vec<u8> {
  function deserialize (line 66) | pub fn deserialize<'a, T: Deserialize<'a>>(input: &'a [u8]) -> Result<T> {
  function prefix_range (line 85) | pub fn prefix_range(prefix: &[u8]) -> (Bound<Vec<u8>>, Bound<Vec<u8>>) {
  type Serializer (line 97) | struct Serializer {
  type Ok (line 102) | type Ok = ();
  type Error (line 103) | type Error = Error;
  type SerializeSeq (line 105) | type SerializeSeq = Self;
    type Ok (line 297) | type Ok = ();
    type Error (line 298) | type Error = Error;
    method serialize_element (line 300) | fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> R...
    method end (line 304) | fn end(self) -> Result<()> {
  type SerializeTuple (line 106) | type SerializeTuple = Self;
    type Ok (line 311) | type Ok = ();
    type Error (line 312) | type Error = Error;
    method serialize_element (line 314) | fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> R...
    method end (line 318) | fn end(self) -> Result<()> {
  type SerializeTupleVariant (line 107) | type SerializeTupleVariant = Self;
    type Ok (line 325) | type Ok = ();
    type Error (line 326) | type Error = Error;
    method serialize_field (line 328) | fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Res...
    method end (line 332) | fn end(self) -> Result<()> {
  type SerializeTupleStruct (line 108) | type SerializeTupleStruct = Impossible<(), Error>;
  type SerializeMap (line 109) | type SerializeMap = Impossible<(), Error>;
  type SerializeStruct (line 110) | type SerializeStruct = Impossible<(), Error>;
  type SerializeStructVariant (line 111) | type SerializeStructVariant = Impossible<(), Error>;
  function serialize_bool (line 114) | fn serialize_bool(self, v: bool) -> Result<()> {
  function serialize_i8 (line 119) | fn serialize_i8(self, _: i8) -> Result<()> {
  function serialize_i16 (line 123) | fn serialize_i16(self, _: i16) -> Result<()> {
  function serialize_i32 (line 127) | fn serialize_i32(self, _: i32) -> Result<()> {
  function serialize_i64 (line 138) | fn serialize_i64(self, v: i64) -> Result<()> {
  function serialize_u8 (line 145) | fn serialize_u8(self, _: u8) -> Result<()> {
  function serialize_u16 (line 149) | fn serialize_u16(self, _: u16) -> Result<()> {
  function serialize_u32 (line 153) | fn serialize_u32(self, _: u32) -> Result<()> {
  function serialize_u64 (line 158) | fn serialize_u64(self, v: u64) -> Result<()> {
  function serialize_f32 (line 163) | fn serialize_f32(self, _: f32) -> Result<()> {
  function serialize_f64 (line 171) | fn serialize_f64(self, v: f64) -> Result<()> {
  function serialize_char (line 181) | fn serialize_char(self, _: char) -> Result<()> {
  function serialize_str (line 186) | fn serialize_str(self, v: &str) -> Result<()> {
  function serialize_bytes (line 195) | fn serialize_bytes(self, v: &[u8]) -> Result<()> {
  function serialize_none (line 207) | fn serialize_none(self) -> Result<()> {
  function serialize_some (line 211) | fn serialize_some<T: Serialize + ?Sized>(self, _: &T) -> Result<()> {
  function serialize_unit (line 215) | fn serialize_unit(self) -> Result<()> {
  function serialize_unit_struct (line 219) | fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
  function serialize_unit_variant (line 224) | fn serialize_unit_variant(self, _: &'static str, index: u32, _: &'static...
  function serialize_newtype_struct (line 229) | fn serialize_newtype_struct<T: Serialize + ?Sized>(self, _: &'static str...
  function serialize_newtype_variant (line 234) | fn serialize_newtype_variant<T: Serialize + ?Sized>(
  function serialize_seq (line 246) | fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq> {
  function serialize_tuple (line 251) | fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple> {
  function serialize_tuple_struct (line 255) | fn serialize_tuple_struct(
  function serialize_tuple_variant (line 265) | fn serialize_tuple_variant(
  function serialize_map (line 276) | fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap> {
  function serialize_struct (line 280) | fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::Ser...
  function serialize_struct_variant (line 284) | fn serialize_struct_variant(
  type Deserializer (line 340) | pub struct Deserializer<'de> {
  function from_bytes (line 346) | pub fn from_bytes(input: &'de [u8]) -> Self {
  function take_bytes (line 352) | fn take_bytes(&mut self, len: usize) -> Result<&[u8]> {
  function decode_next_bytes (line 362) | fn decode_next_bytes(&mut self) -> Result<Vec<u8>> {
  type Error (line 383) | type Error = Error;
  function deserialize_any (line 385) | fn deserialize_any<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_bool (line 389) | fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Valu...
  function deserialize_i8 (line 397) | fn deserialize_i8<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_i16 (line 401) | fn deserialize_i16<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_i32 (line 405) | fn deserialize_i32<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_i64 (line 409) | fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  function deserialize_u8 (line 415) | fn deserialize_u8<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_u16 (line 419) | fn deserialize_u16<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_u32 (line 423) | fn deserialize_u32<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_u64 (line 427) | fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  function deserialize_f32 (line 431) | fn deserialize_f32<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_f64 (line 435) | fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  function deserialize_char (line 445) | fn deserialize_char<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_str (line 449) | fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  function deserialize_string (line 454) | fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Va...
  function deserialize_bytes (line 459) | fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Val...
  function deserialize_byte_buf (line 464) | fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::...
  function deserialize_option (line 469) | fn deserialize_option<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_unit (line 473) | fn deserialize_unit<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_unit_struct (line 477) | fn deserialize_unit_struct<V: Visitor<'de>>(self, _: &'static str, _: V)...
  function deserialize_newtype_struct (line 481) | fn deserialize_newtype_struct<V: Visitor<'de>>(
  function deserialize_seq (line 489) | fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  function deserialize_tuple (line 493) | fn deserialize_tuple<V: Visitor<'de>>(self, _: usize, visitor: V) -> Res...
  function deserialize_tuple_struct (line 497) | fn deserialize_tuple_struct<V: Visitor<'de>>(
  function deserialize_map (line 506) | fn deserialize_map<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
  function deserialize_struct (line 510) | fn deserialize_struct<V: Visitor<'de>>(
  function deserialize_enum (line 519) | fn deserialize_enum<V: Visitor<'de>>(
  function deserialize_identifier (line 528) | fn deserialize_identifier<V: Visitor<'de>>(self, _: V) -> Result<V::Valu...
  function deserialize_ignored_any (line 532) | fn deserialize_ignored_any<V: Visitor<'de>>(self, _: V) -> Result<V::Val...
  type Error (line 539) | type Error = Error;
  function next_element_seed (line 541) | fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Res...
  type Error (line 551) | type Error = Error;
  type Variant (line 552) | type Variant = Self;
  function variant_seed (line 554) | fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Va...
  type Error (line 563) | type Error = Error;
  function unit_variant (line 565) | fn unit_variant(self) -> Result<()> {
  function newtype_variant_seed (line 569) | fn newtype_variant_seed<T: DeserializeSeed<'de>>(self, seed: T) -> Resul...
  function tuple_variant (line 573) | fn tuple_variant<V: Visitor<'de>>(self, _: usize, visitor: V) -> Result<...
  function struct_variant (line 577) | fn struct_variant<V: Visitor<'de>>(self, _: &'static [&'static str], _: ...
  type Key (line 595) | enum Key<'a> {

FILE: src/encoding/mod.rs
  type Key (line 22) | pub trait Key<'de>: Serialize + Deserialize<'de> {
    method decode (line 24) | fn decode(bytes: &'de [u8]) -> Result<Self> {
    method encode (line 34) | fn encode(&self) -> Vec<u8> {
  type Value (line 42) | pub trait Value: Serialize + DeserializeOwned {
    method decode (line 44) | fn decode(bytes: &[u8]) -> Result<Self> {
    method decode_from (line 49) | fn decode_from<R: Read>(reader: R) -> Result<Self> {
    method maybe_decode_from (line 55) | fn maybe_decode_from<R: Read>(reader: R) -> Result<Option<Self>> {
    method encode (line 60) | fn encode(&self) -> Vec<u8> {
    method encode_into (line 65) | fn encode_into<W: Write>(&self, writer: W) -> Result<()> {

FILE: src/error.rs
  type Error (line 7) | pub enum Error {
    method is_deterministic (line 46) | pub fn is_deterministic(&self) -> bool {
    method custom (line 89) | fn custom<T: Display>(msg: T) -> Self {
    method custom (line 95) | fn custom<T: Display>(msg: T) -> Self {
    method from (line 101) | fn from(err: bincode::error::DecodeError) -> Self {
    method from (line 107) | fn from(err: bincode::error::EncodeError) -> Self {
    method from (line 113) | fn from(err: config::ConfigError) -> Self {
    method from (line 119) | fn from(err: crossbeam::channel::RecvError) -> Self {
    method from (line 125) | fn from(err: crossbeam::channel::SendError<T>) -> Self {
    method from (line 131) | fn from(err: crossbeam::channel::TryRecvError) -> Self {
    method from (line 137) | fn from(err: crossbeam::channel::TrySendError<T>) -> Self {
    method from (line 143) | fn from(err: hdrhistogram::CreationError) -> Self {
    method from (line 149) | fn from(err: hdrhistogram::RecordError) -> Self {
    method from (line 155) | fn from(err: log::ParseLevelError) -> Self {
    method from (line 161) | fn from(err: log::SetLoggerError) -> Self {
    method from (line 167) | fn from(err: rand::distr::uniform::Error) -> Self {
    method from (line 173) | fn from(err: regex::Error) -> Self {
    method from (line 179) | fn from(err: rustyline::error::ReadlineError) -> Self {
    method from (line 185) | fn from(err: std::array::TryFromSliceError) -> Self {
    method from (line 191) | fn from(err: std::io::Error) -> Self {
    method from (line 197) | fn from(err: std::num::ParseFloatError) -> Self {
    method from (line 203) | fn from(err: std::num::ParseIntError) -> Self {
    method from (line 209) | fn from(err: std::num::TryFromIntError) -> Self {
    method from (line 215) | fn from(err: std::string::FromUtf8Error) -> Self {
    method from (line 221) | fn from(err: std::sync::PoisonError<T>) -> Self {
  method fmt (line 28) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Result (line 80) | pub type Result<T> = std::result::Result<T, Error>;
  function from (line 83) | fn from(error: Error) -> Self {

FILE: src/raft/log.rs
  type Index (line 11) | pub type Index = u64;
  type Entry (line 15) | pub struct Entry {
  type Key (line 32) | pub enum Key {
  type Log (line 92) | pub struct Log {
    method new (line 120) | pub fn new(mut engine: Box<dyn storage::Engine>) -> Result<Self> {
    method enable_fsync (line 150) | pub fn enable_fsync(&mut self, fsync: bool) {
    method get_commit_index (line 155) | pub fn get_commit_index(&self) -> (Index, Term) {
    method get_last_index (line 160) | pub fn get_last_index(&self) -> (Index, Term) {
    method get_term_vote (line 165) | pub fn get_term_vote(&self) -> (Term, Option<NodeID>) {
    method set_term_vote (line 172) | pub fn set_term_vote(&mut self, term: Term, vote: Option<NodeID>) -> R...
    method append (line 193) | pub fn append(&mut self, command: Option<Vec<u8>>) -> Result<Index> {
    method commit (line 207) | pub fn commit(&mut self, index: Index) -> Result<Index> {
    method get (line 225) | pub fn get(&mut self, index: Index) -> Result<Option<Entry>> {
    method has (line 230) | pub fn has(&mut self, index: Index, term: Term) -> Result<bool> {
    method scan (line 243) | pub fn scan(&mut self, range: impl RangeBounds<Index>) -> Iterator<'_> {
    method scan_apply (line 259) | pub fn scan_apply(&mut self, applied_index: Index) -> Iterator<'_> {
    method splice (line 278) | pub fn splice(&mut self, entries: Vec<Entry>) -> Result<Index> {
    method status (line 346) | pub fn status(&mut self) -> Result<storage::Status> {
  type Iterator (line 352) | pub struct Iterator<'a> {
  function new (line 357) | fn new(inner: Box<dyn storage::ScanIterator + 'a>) -> Self {
  type Item (line 363) | type Item = Result<Entry>;
  function next (line 365) | fn next(&mut self) -> Option<Self::Item> {
  function test_goldenscript (line 390) | fn test_goldenscript(path: &std::path::Path) {
  type TestRunner (line 395) | struct TestRunner {
    method new (line 403) | fn new() -> Self {
    method parse_index_term (line 417) | fn parse_index_term(s: &str) -> Result<(Index, Term), Box<dyn Error>> {
    method parse_index_range (line 426) | fn parse_index_range(s: &str) -> Result<impl RangeBounds<Index>, Box<d...
    method run (line 447) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, B...
    method end_command (line 639) | fn end_command(&mut self, _: &goldenscript::Command) -> Result<String,...

FILE: src/raft/message.rs
  type Envelope (line 12) | pub struct Envelope {
  type Message (line 33) | pub enum Message {
  type RequestID (line 159) | pub type RequestID = uuid::Uuid;
  type ReadSequence (line 162) | pub type ReadSequence = u64;
  type Request (line 166) | pub enum Request {
  type Response (line 181) | pub enum Response {
  type Status (line 194) | pub struct Status {

FILE: src/raft/mod.rs
  constant TICK_INTERVAL (line 256) | pub const TICK_INTERVAL: Duration = Duration::from_millis(100);
  constant HEARTBEAT_INTERVAL (line 259) | const HEARTBEAT_INTERVAL: Ticks = 4;
  constant ELECTION_TIMEOUT_RANGE (line 263) | const ELECTION_TIMEOUT_RANGE: Range<Ticks> = 10..20;
  constant MAX_APPEND_ENTRIES (line 266) | const MAX_APPEND_ENTRIES: usize = 100;

FILE: src/raft/node.rs
  type NodeID (line 18) | pub type NodeID = u8;
  type Term (line 21) | pub type Term = u64;
  type Ticks (line 24) | pub type Ticks = u8;
  type Options (line 28) | pub struct Options {
  method default (line 38) | fn default() -> Self {
  type Node (line 59) | pub enum Node {
    method new (line 73) | pub fn new(
    method id (line 90) | pub fn id(&self) -> NodeID {
    method term (line 99) | pub fn term(&self) -> Term {
    method step (line 108) | pub fn step(self, msg: Envelope) -> Result<Self> {
    method tick (line 126) | pub fn tick(self) -> Result<Self> {
    method from (line 136) | fn from(node: RawNode<Candidate>) -> Self {
    method from (line 142) | fn from(node: RawNode<Follower>) -> Self {
    method from (line 148) | fn from(node: RawNode<Leader>) -> Self {
    method dismantle (line 1261) | fn dismantle(self) -> (Log, Box<dyn State>) {
    method get_applied_index (line 1265) | fn get_applied_index(&self) -> Index {
    method get_commit_index (line 1269) | fn get_commit_index(&self) -> (Index, Term) {
    method get_last_index (line 1273) | fn get_last_index(&self) -> (Index, Term) {
    method get_term_vote (line 1277) | fn get_term_vote(&self) -> (Term, Option<NodeID>) {
    method options (line 1281) | fn options(&self) -> Options {
    method peers (line 1285) | fn peers(&self) -> HashSet<NodeID> {
    method read (line 1289) | fn read(&self, command: Vec<u8>) -> crate::error::Result<Vec<u8>> {
    method scan_log (line 1293) | fn scan_log(&mut self) -> crate::error::Result<Vec<Entry>> {
  type Role (line 154) | pub trait Role {}
  type RawNode (line 160) | pub struct RawNode<R: Role> {
  function into_role (line 181) | fn into_role<T: Role>(self, role: T) -> RawNode<T> {
  function term (line 194) | fn term(&self) -> Term {
  function cluster_size (line 199) | fn cluster_size(&self) -> usize {
  function quorum_size (line 204) | fn quorum_size(&self) -> usize {
  function quorum_value (line 210) | fn quorum_value<T: Ord + Copy>(&self, mut values: Vec<T>) -> T {
  function random_election_timeout (line 216) | fn random_election_timeout(&self) -> Ticks {
  function send (line 221) | fn send(&self, to: NodeID, message: Message) -> Result<()> {
  function send_via (line 227) | fn send_via(tx: &Sender<Envelope>, msg: Envelope) -> Result<()> {
  function broadcast (line 233) | fn broadcast(&self, message: Message) -> Result<()> {
  type Follower (line 245) | pub struct Follower {
    method new (line 259) | fn new(leader: Option<NodeID>, election_timeout: Ticks) -> Self {
  function new (line 268) | fn new(
  function into_candidate (line 294) | fn into_candidate(mut self) -> Result<RawNode<Candidate>> {
  function into_follower (line 316) | fn into_follower(mut self, term: Term, leader: Option<NodeID>) -> Result...
  function step (line 341) | fn step(mut self, msg: Envelope) -> Result<Node> {
  function tick (line 490) | fn tick(mut self) -> Result<Node> {
  function abort_forwarded (line 500) | fn abort_forwarded(&mut self) -> Result<()> {
  function maybe_apply (line 510) | fn maybe_apply(&mut self) -> Result<()> {
  type Candidate (line 524) | pub struct Candidate {
    method new (line 535) | fn new(election_timeout: Ticks) -> Self {
  function into_follower (line 546) | fn into_follower(mut self, term: Term, leader: Option<NodeID>) -> Result...
  function into_leader (line 564) | fn into_leader(self) -> Result<RawNode<Leader>> {
  function step (line 586) | fn step(mut self, msg: Envelope) -> Result<Node> {
  function tick (line 638) | fn tick(mut self) -> Result<Node> {
  function campaign (line 649) | fn campaign(&mut self) -> Result<()> {
  type Leader (line 663) | pub struct Leader {
    method new (line 754) | fn new(peers: HashSet<NodeID>, last_index: Index) -> Self {
  type Progress (line 683) | struct Progress {
    method advance (line 703) | fn advance(&mut self, match_index: Index) -> bool {
    method advance_read (line 713) | fn advance_read(&mut self, read_seq: ReadSequence) -> bool {
    method regress_next (line 723) | fn regress_next(&mut self, next_index: Index) -> bool {
  type Write (line 733) | struct Write {
  type Read (line 741) | struct Read {
  function into_follower (line 776) | fn into_follower(mut self, term: Term) -> Result<RawNode<Follower>> {
  function step (line 797) | fn step(mut self, msg: Envelope) -> Result<Node> {
  function tick (line 946) | fn tick(mut self) -> Result<Node> {
  function heartbeat (line 956) | fn heartbeat(&mut self) -> Result<()> {
  function propose (line 969) | fn propose(&mut self, command: Option<Vec<u8>>) -> Result<Index> {
  function maybe_commit_and_apply (line 984) | fn maybe_commit_and_apply(&mut self) -> Result<Index> {
  function maybe_read (line 1036) | fn maybe_read(&mut self) -> Result<()> {
  function maybe_send_append (line 1081) | fn maybe_send_append(&mut self, peer: NodeID, mut probe: bool) -> Result...
  function status (line 1131) | fn status(&mut self) -> Result<Status> {
  function progress (line 1149) | fn progress(&mut self, id: NodeID) -> &mut Progress {
  function test_goldenscript (line 1179) | fn test_goldenscript(path: &Path) {
  function quorum_size (line 1192) | fn quorum_size(size: usize) -> usize {
  function quorum_value (line 1204) | fn quorum_value(values: Vec<i8>) -> i8 {
  function new_noop (line 1214) | fn new_noop(id: NodeID, peers: HashSet<NodeID>) -> Self {
  type TestRunner (line 1299) | struct TestRunner {
    method run (line 1323) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, B...
    method new (line 1497) | fn new() -> Self {
    method add_node (line 1512) | fn add_node(
    method add_node_with (line 1530) | fn add_node_with(
    method campaign (line 1550) | fn campaign(&mut self, ids: &[NodeID], output: &mut String) -> Result<...
    method cluster (line 1569) | fn cluster(
    method deliver (line 1613) | fn deliver(
    method heal (line 1643) | fn heal(&mut self, ids: &[NodeID], output: &mut String) -> Result<(), ...
    method heartbeat (line 1655) | fn heartbeat(&mut self, ids: &[NodeID], output: &mut String) -> Result...
    method log (line 1667) | fn log(&mut self, ids: &[NodeID], output: &mut String) -> Result<(), B...
    method partition (line 1688) | fn partition(&mut self, ids: &[NodeID], output: &mut String) -> Result...
    method receive (line 1702) | fn receive(&mut self, id: NodeID, output: &mut String) -> Result<u32, ...
    method request (line 1744) | fn request(
    method restart (line 1767) | fn restart(
    method stabilize (line 1825) | fn stabilize(
    method state (line 1850) | fn state(&mut self, ids: &[NodeID], output: &mut String) -> Result<(),...
    method status (line 1868) | fn status(&self, ids: &[NodeID], output: &mut String) -> Result<(), Bo...
    method transition (line 1896) | fn transition(
    method parse_ids (line 1945) | fn parse_ids<A>(&self, args: &[A]) -> Result<Vec<NodeID>, Box<dyn Error>>
    method parse_ids_or_all (line 1965) | fn parse_ids_or_all<A>(&self, args: &[A]) -> Result<Vec<NodeID>, Box<d...
    method parse_ids_or_error (line 1977) | fn parse_ids_or_error<A>(&self, args: &[A]) -> Result<Vec<NodeID>, Box...
    method format_disconnected (line 1989) | fn format_disconnected(disconnected: &HashMap<NodeID, HashSet<NodeID>>...
    method format_entry (line 2065) | fn format_entry(entry: &Entry) -> String {
    method format_message (line 2074) | fn format_message(msg: &Message) -> String {
    method format_node (line 2135) | fn format_node(node: &Node) -> String {
    method format_node_role (line 2140) | fn format_node_role(node: &Node) -> String {
    method format_request (line 2153) | fn format_request(request: &Request) -> String {
    method format_response (line 2161) | fn format_response(response: &crate::error::Result<Response>) -> String {
    method format_strikethrough (line 2172) | fn format_strikethrough(s: &str) -> String {

FILE: src/raft/state.rs
  type State (line 19) | pub trait State: Send {
    method get_applied_index (line 26) | fn get_applied_index(&self) -> Index;
    method apply (line 43) | fn apply(&mut self, entry: Entry) -> Result<Vec<u8>>;
    method read (line 50) | fn read(&self, command: Vec<u8>) -> Result<Vec<u8>>;
    method get_applied_index (line 79) | fn get_applied_index(&self) -> Index {
    method apply (line 83) | fn apply(&mut self, entry: Entry) -> Result<Vec<u8>> {
    method read (line 89) | fn read(&self, command: Vec<u8>) -> Result<Vec<u8>> {
    method get_applied_index (line 107) | fn get_applied_index(&self) -> Index {
    method apply (line 111) | fn apply(&mut self, entry: Entry) -> Result<Vec<u8>> {
    method read (line 127) | fn read(&self, command: Vec<u8>) -> Result<Vec<u8>> {
    method get_applied_index (line 199) | fn get_applied_index(&self) -> Index {
    method apply (line 203) | fn apply(&mut self, entry: Entry) -> Result<Vec<u8>> {
    method read (line 208) | fn read(&self, _: Vec<u8>) -> Result<Vec<u8>> {
  type Emit (line 67) | pub struct Emit {
    method new (line 73) | pub fn new(inner: Box<dyn State>, tx: Sender<Entry>) -> Box<Self> {
  type KV (line 95) | pub struct KV {
    method new (line 101) | pub fn new() -> Box<Self> {
  type KVCommand (line 140) | pub enum KVCommand {
  method fmt (line 152) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type KVResponse (line 163) | pub enum KVResponse {
  method fmt (line 175) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Noop (line 188) | pub struct Noop {
    method new (line 193) | pub fn new() -> Box<Self> {

FILE: src/server.rs
  constant RAFT_PEER_CHANNEL_CAPACITY (line 22) | const RAFT_PEER_CHANNEL_CAPACITY: usize = 1000;
  constant RAFT_PEER_RETRY_INTERVAL (line 25) | const RAFT_PEER_RETRY_INTERVAL: Duration = Duration::from_secs(1);
  type Server (line 37) | pub struct Server {
    method new (line 48) | pub fn new(
    method serve (line 67) | pub fn serve(self, raft_addr: impl ToSocketAddrs, sql_addr: impl ToSoc...
    method raft_accept (line 114) | fn raft_accept(listener: TcpListener, raft_step_tx: Sender<raft::Envel...
    method raft_receive_peer (line 138) | fn raft_receive_peer(socket: TcpStream, raft_step_tx: Sender<raft::Env...
    method raft_send_peer (line 148) | fn raft_send_peer(addr: String, raft_node_rx: Receiver<raft::Envelope>) {
    method raft_route (line 186) | fn raft_route(
    method sql_accept (line 252) | fn sql_accept(id: raft::NodeID, listener: TcpListener, sql_engine: sql...
    method sql_session (line 276) | fn sql_session(
  type Request (line 314) | pub enum Request {
  type Response (line 329) | pub enum Response {
  type Status (line 341) | pub struct Status {

FILE: src/sql/engine/engine.rs
  type Engine (line 13) | pub trait Engine<'a>: Sized {
    method begin (line 19) | fn begin(&'a self) -> Result<Self::Transaction>;
    method begin_read_only (line 21) | fn begin_read_only(&'a self) -> Result<Self::Transaction>;
    method begin_as_of (line 23) | fn begin_as_of(&'a self, version: mvcc::Version) -> Result<Self::Trans...
    method session (line 26) | fn session(&'a self) -> Session<'a, Self> {
  type Transaction (line 37) | pub trait Transaction: Catalog {
    method state (line 39) | fn state(&self) -> &mvcc::TransactionState;
    method commit (line 42) | fn commit(self) -> Result<()>;
    method rollback (line 44) | fn rollback(self) -> Result<()>;
    method delete (line 47) | fn delete(&self, table: &str, ids: &[Value]) -> Result<()>;
    method get (line 49) | fn get(&self, table: &str, ids: &[Value]) -> Result<Vec<Row>>;
    method insert (line 51) | fn insert(&self, table: &str, rows: Vec<Row>) -> Result<()>;
    method lookup_index (line 53) | fn lookup_index(&self, table: &str, column: &str, values: &[Value]) ->...
    method scan (line 55) | fn scan(&self, table: &str, filter: Option<Expression>) -> Result<Rows>;
    method update (line 57) | fn update(&self, table: &str, rows: BTreeMap<Value, Row>) -> Result<()>;
  type Catalog (line 64) | pub trait Catalog {
    method create_table (line 66) | fn create_table(&self, table: Table) -> Result<()>;
    method drop_table (line 69) | fn drop_table(&self, table: &str, if_exists: bool) -> Result<bool>;
    method get_table (line 71) | fn get_table(&self, table: &str) -> Result<Option<Table>>;
    method list_tables (line 73) | fn list_tables(&self) -> Result<Vec<Table>>;
    method must_get_table (line 76) | fn must_get_table(&self, table: &str) -> Result<Table> {

FILE: src/sql/engine/local.rs
  type Key (line 22) | pub enum Key<'a> {
  type KeyPrefix (line 39) | enum KeyPrefix<'a> {
  type Local (line 53) | pub struct Local<E: storage::Engine + 'static> {
  function new (line 60) | pub fn new(engine: E) -> Self {
  function resume (line 68) | pub fn resume(&self, state: mvcc::TransactionState) -> Result<Transactio...
  function get_unversioned (line 73) | pub fn get_unversioned(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  function set_unversioned (line 78) | pub fn set_unversioned(&self, key: &[u8], value: Vec<u8>) -> Result<()> {
  type Transaction (line 84) | type Transaction = Transaction<E>;
  function begin (line 86) | fn begin(&self) -> Result<Self::Transaction> {
  function begin_read_only (line 90) | fn begin_read_only(&self) -> Result<Self::Transaction> {
  function begin_as_of (line 94) | fn begin_as_of(&self, version: mvcc::Version) -> Result<Self::Transactio...
  type Transaction (line 100) | pub struct Transaction<E: storage::Engine + 'static> {
  function new (line 106) | fn new(txn: mvcc::Transaction<E>) -> Self {
  function state (line 111) | pub fn state(&self) -> &mvcc::TransactionState {
  function get_index (line 117) | fn get_index(&self, table: &str, column: &str, value: &Value) -> Result<...
  function get_row (line 128) | fn get_row(&self, table: &str, id: &Value) -> Result<Option<Row>> {
  function has_index (line 136) | fn has_index(&self, table: &str, column: &str) -> Result<bool> {
  function set_index (line 143) | fn set_index(
  function table_references (line 162) | fn table_references(&self, table: &str) -> Result<Vec<(Table, Vec<usize>...
  function state (line 182) | fn state(&self) -> &mvcc::TransactionState {
  function commit (line 186) | fn commit(self) -> Result<()> {
  function rollback (line 190) | fn rollback(self) -> Result<()> {
  function delete (line 194) | fn delete(&self, table: &str, ids: &[Value]) -> Result<()> {
  function get (line 248) | fn get(&self, table: &str, ids: &[Value]) -> Result<Vec<Row>> {
  function insert (line 252) | fn insert(&self, table: &str, rows: Vec<Row>) -> Result<()> {
  function lookup_index (line 270) | fn lookup_index(&self, table: &str, column: &str, values: &[Value]) -> R...
  function scan (line 275) | fn scan(&self, table: &str, filter: Option<Expression>) -> Result<Rows> {
  function update (line 296) | fn update(&self, table: &str, rows: BTreeMap<Value, Row>) -> Result<()> {
  method create_table (line 341) | fn create_table(&self, table: Table) -> Result<()> {
  method drop_table (line 349) | fn drop_table(&self, table: &str, if_exists: bool) -> Result<bool> {
  method get_table (line 390) | fn get_table(&self, table: &str) -> Result<Option<Table>> {
  method list_tables (line 394) | fn list_tables(&self) -> Result<Vec<Table>> {

FILE: src/sql/engine/raft.rs
  type Read (line 20) | pub enum Read<'a> {
  type Write (line 58) | pub enum Write<'a> {
  type Status (line 75) | pub struct Status {
  type Raft (line 92) | pub struct Raft {
    constant APPLIED_INDEX_KEY (line 100) | pub const APPLIED_INDEX_KEY: &'static [u8] = b"applied_index";
    method new (line 104) | pub fn new(tx: Sender<(raft::Request, Sender<Result<raft::Response>>)>...
    method new_state (line 110) | pub fn new_state<E: storage::Engine>(engine: E) -> Result<State<E>> {
    method request (line 115) | fn request(&self, request: raft::Request) -> Result<raft::Response> {
    method write (line 122) | fn write<V: DeserializeOwned>(&self, write: Write) -> Result<V> {
    method read (line 130) | fn read<V: DeserializeOwned>(&self, read: Read) -> Result<V> {
    method status (line 138) | pub fn status(&self) -> Result<Status> {
    type Transaction (line 149) | type Transaction = Transaction<'a>;
    method begin (line 151) | fn begin(&'a self) -> Result<Self::Transaction> {
    method begin_read_only (line 155) | fn begin_read_only(&'a self) -> Result<Self::Transaction> {
    method begin_as_of (line 159) | fn begin_as_of(&'a self, version: mvcc::Version) -> Result<Self::Trans...
  type Transaction (line 171) | pub struct Transaction<'a> {
  function begin (line 180) | fn begin(raft: &'a Raft, read_only: bool, as_of: Option<mvcc::Version>) ...
  function state (line 195) | fn state(&self) -> &mvcc::TransactionState {
  function commit (line 199) | fn commit(self) -> Result<()> {
  function rollback (line 206) | fn rollback(self) -> Result<()> {
  function delete (line 213) | fn delete(&self, table: &str, ids: &[Value]) -> Result<()> {
  function get (line 221) | fn get(&self, table: &str, ids: &[Value]) -> Result<Vec<Row>> {
  function insert (line 229) | fn insert(&self, table: &str, rows: Vec<Row>) -> Result<()> {
  function lookup_index (line 233) | fn lookup_index(&self, table: &str, column: &str, values: &[Value]) -> R...
  function scan (line 242) | fn scan(&self, table: &str, filter: Option<Expression>) -> Result<Rows> {
  function update (line 251) | fn update(&self, table: &str, rows: BTreeMap<Value, Row>) -> Result<()> {
  method create_table (line 257) | fn create_table(&self, schema: Table) -> Result<()> {
  method drop_table (line 261) | fn drop_table(&self, table: &str, if_exists: bool) -> Result<bool> {
  method get_table (line 269) | fn get_table(&self, table: &str) -> Result<Option<Table>> {
  method list_tables (line 273) | fn list_tables(&self) -> Result<Vec<Table>> {
  type State (line 286) | pub struct State<E: storage::Engine + 'static> {
  function new (line 296) | pub fn new(engine: E) -> Result<Self> {
  function write (line 311) | fn write(&self, command: Write) -> Result<Vec<u8>> {
  function get_applied_index (line 342) | fn get_applied_index(&self) -> raft::Index {
  function apply (line 346) | fn apply(&mut self, entry: raft::Entry) -> Result<Vec<u8>> {
  function read (line 369) | fn read(&self, command: Vec<u8>) -> Result<Vec<u8>> {

FILE: src/sql/execution/aggregator.rs
  type Aggregator (line 13) | pub struct Aggregator {
    method new (line 24) | pub fn new(group_by: Vec<Expression>, aggregates: Vec<Aggregate>) -> S...
    method add (line 29) | pub fn add(&mut self, row: &Row) -> Result<()> {
    method add_rows (line 51) | pub fn add_rows(&mut self, rows: Rows) -> Result<()> {
    method into_rows (line 59) | pub fn into_rows(self) -> Rows {
  type Accumulator (line 85) | enum Accumulator {
    method new (line 95) | fn new(aggregate: &Aggregate) -> Self {
    method add (line 106) | fn add(&mut self, value: Value) -> Result<()> {
    method value (line 127) | fn value(self) -> Result<Value> {

FILE: src/sql/execution/executor.rs
  type Executor (line 46) | pub struct Executor<'a, T: Transaction> {
  function new (line 53) | pub fn new(txn: &'a T) -> Self {
  function execute (line 58) | pub fn execute(&mut self, plan: Plan) -> Result<ExecutionResult> {
  function execute_node (line 104) | fn execute_node(&mut self, node: Node) -> Result<Rows> {
  function delete (line 216) | fn delete(&self, table: &str, primary_key: usize, source: Rows) -> Resul...
  function insert (line 230) | fn insert(
  function update (line 277) | fn update(
  function order (line 299) | fn order(source: Rows, order: Vec<(Expression, Direction)>) -> Result<Ro...
  type ExecutionResult (line 332) | pub enum ExecutionResult {

FILE: src/sql/execution/join.rs
  type NestedLoopJoiner (line 21) | pub struct NestedLoopJoiner {
    method new (line 41) | pub fn new(
    method try_next (line 54) | fn try_next(&mut self) -> Result<Option<Row>> {
  type Item (line 96) | type Item = Result<Row>;
  method next (line 98) | fn next(&mut self) -> Option<Self::Item> {
  type HashJoiner (line 112) | pub struct HashJoiner {
    method new (line 129) | pub fn new(
    method try_next (line 153) | fn try_next(&mut self) -> Result<Option<Row>> {
  type Item (line 186) | type Item = Result<Row>;
  method next (line 188) | fn next(&mut self) -> Option<Self::Item> {

FILE: src/sql/execution/session.rs
  type Session (line 16) | pub struct Session<'a, E: Engine<'a>> {
  function new (line 25) | pub fn new(engine: &'a E) -> Self {
  function execute (line 30) | pub fn execute(&mut self, statement: &str) -> Result<StatementResult> {
  function with_txn (line 90) | pub fn with_txn<F, T>(&mut self, read_only: bool, f: F) -> Result<T>
  function status (line 117) | pub fn status(&self) -> Result<Status> {
  method drop (line 124) | fn drop(&mut self) {
  type StatementResult (line 134) | pub enum StatementResult {
    type Error (line 152) | type Error = Error;
    method try_from (line 154) | fn try_from(result: ExecutionResult) -> Result<Self> {
  type Error (line 171) | type Error = Error;
  method try_from (line 173) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 183) | type Error = Error;
  method try_from (line 185) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 193) | type Error = Error;
  method try_from (line 195) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 203) | type Error = Error;
  function try_from (line 205) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 212) | type Error = Error;
  function try_from (line 214) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 221) | type Error = Error;
  function try_from (line 223) | fn try_from(result: StatementResult) -> Result<Self> {
  type Error (line 230) | type Error = Error;
  method try_from (line 232) | fn try_from(result: StatementResult) -> Result<Self> {

FILE: src/sql/mod.rs
  function test_goldenscript (line 108) | fn test_goldenscript(path: &Path) {
  function test_goldenscript_expr (line 125) | fn test_goldenscript_expr(path: &Path) {
  type SQLRunner (line 130) | struct SQLRunner<'a> {
  type TestEngine (line 136) | type TestEngine =
  function new (line 140) | fn new(engine: &'a TestEngine, op_rx: Receiver<testengine::Operation>) -...
  function run (line 146) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, Box...
  function end_command (line 273) | fn end_command(&mut self, _: &goldenscript::Command) -> Result<String, B...
  type ExpressionRunner (line 281) | struct ExpressionRunner;
    method run (line 286) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, B...
  type Catalog (line 283) | type Catalog<'a> = <Local<storage::Memory> as Engine<'a>>::Transaction;

FILE: src/sql/parser/ast.rs
  type Statement (line 12) | pub enum Statement {
  type From (line 85) | pub enum From {
  type Column (line 108) | pub struct Column {
  type JoinType (line 121) | pub enum JoinType {
    method is_outer (line 131) | pub fn is_outer(&self) -> bool {
  type Direction (line 141) | pub enum Direction {
  type Expression (line 149) | pub enum Expression {
    method walk (line 239) | pub fn walk(&self, visitor: &mut impl FnMut(&Expression) -> bool) -> b...
    method contains (line 277) | pub fn contains(&self, visitor: &impl Fn(&Expression) -> bool) -> bool {
    method collect (line 283) | pub fn collect(&self, visitor: &impl Fn(&Expression) -> bool, exprs: &...
    method from (line 324) | fn from(literal: Literal) -> Self {
    method from (line 330) | fn from(op: Operator) -> Self {
  type Literal (line 164) | pub enum Literal {
  method eq (line 177) | fn eq(&self, other: &Self) -> bool {
  method hash (line 192) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Operator (line 210) | pub enum Operator {
  function from (line 336) | fn from(value: Operator) -> Self {

FILE: src/sql/parser/lexer.rs
  type Token (line 17) | pub enum Token {
    method from (line 81) | fn from(keyword: Keyword) -> Self {
  method fmt (line 50) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Keyword (line 88) | pub enum Keyword {
    type Error (line 159) | type Error = &'static str;
    method try_from (line 161) | fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
  method fmt (line 238) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Lexer (line 315) | pub struct Lexer<'a> {
  type Item (line 321) | type Item = Result<Token>;
  method next (line 323) | fn next(&mut self) -> Option<Result<Token>> {
  function new (line 335) | pub fn new(input: &'a str) -> Lexer<'a> {
  function next_if (line 340) | fn next_if(&mut self, predicate: impl Fn(char) -> bool) -> Option<char> {
  function next_if_map (line 347) | fn next_if_map<T>(&mut self, map: impl Fn(char) -> Option<T>) -> Option<...
  function next_is (line 354) | fn next_is(&mut self, c: char) -> bool {
  function scan (line 359) | fn scan(&mut self) -> Result<Option<Token>> {
  function scan_ident_or_keyword (line 377) | fn scan_ident_or_keyword(&mut self) -> Option<Token> {
  function scan_ident_quoted (line 391) | fn scan_ident_quoted(&mut self) -> Result<Option<Token>> {
  function scan_number (line 409) | fn scan_number(&mut self) -> Option<Token> {
  function scan_string (line 436) | fn scan_string(&mut self) -> Result<Option<Token>> {
  function scan_symbol (line 454) | fn scan_symbol(&mut self) -> Option<Token> {
  function skip_whitespace (line 488) | fn skip_whitespace(&mut self) {
  function is_ident (line 494) | pub fn is_ident(ident: &str) -> bool {

FILE: src/sql/parser/parser.rs
  type Parser (line 17) | pub struct Parser<'a> {
  function parse (line 24) | pub fn parse(statement: &str) -> Result<ast::Statement> {
  function parse_expr (line 37) | pub fn parse_expr(expr: &str) -> Result<ast::Expression> {
  function new (line 47) | fn new(input: &str) -> Parser<'_> {
  function next (line 52) | fn next(&mut self) -> Result<Token> {
  function next_ident (line 57) | fn next_ident(&mut self) -> Result<String> {
  function next_if (line 65) | fn next_if(&mut self, predicate: impl Fn(&Token) -> bool) -> Option<Toke...
  function next_if_map (line 72) | fn next_if_map<T>(&mut self, f: impl Fn(&Token) -> Option<T>) -> Option<...
  function next_if_keyword (line 77) | fn next_if_keyword(&mut self) -> Option<Keyword> {
  function next_is (line 85) | fn next_is(&mut self, token: Token) -> bool {
  function expect (line 90) | fn expect(&mut self, expect: Token) -> Result<()> {
  function skip (line 100) | fn skip(&mut self, token: Token) {
  function peek (line 105) | fn peek(&mut self) -> Result<Option<&Token>> {
  function parse_statement (line 110) | fn parse_statement(&mut self) -> Result<ast::Statement> {
  function parse_begin (line 133) | fn parse_begin(&mut self) -> Result<ast::Statement> {
  function parse_commit (line 160) | fn parse_commit(&mut self) -> Result<ast::Statement> {
  function parse_rollback (line 166) | fn parse_rollback(&mut self) -> Result<ast::Statement> {
  function parse_explain (line 172) | fn parse_explain(&mut self) -> Result<ast::Statement> {
  function parse_create_table (line 181) | fn parse_create_table(&mut self) -> Result<ast::Statement> {
  function parse_create_table_column (line 198) | fn parse_create_table_column(&mut self) -> Result<ast::Column> {
  function parse_drop_table (line 247) | fn parse_drop_table(&mut self) -> Result<ast::Statement> {
  function parse_delete (line 260) | fn parse_delete(&mut self) -> Result<ast::Statement> {
  function parse_insert (line 268) | fn parse_insert(&mut self) -> Result<ast::Statement> {
  function parse_update (line 308) | fn parse_update(&mut self) -> Result<ast::Statement> {
  function parse_select (line 331) | fn parse_select(&mut self) -> Result<ast::Statement> {
  function parse_select_clause (line 345) | fn parse_select_clause(&mut self) -> Result<Vec<(ast::Expression, Option...
  function parse_from_clause (line 368) | fn parse_from_clause(&mut self) -> Result<Vec<ast::From>> {
  function parse_from_table (line 394) | fn parse_from_table(&mut self) -> Result<ast::From> {
  function parse_from_join (line 404) | fn parse_from_join(&mut self) -> Result<Option<ast::JoinType>> {
  function parse_where_clause (line 430) | fn parse_where_clause(&mut self) -> Result<Option<ast::Expression>> {
  function parse_group_by_clause (line 438) | fn parse_group_by_clause(&mut self) -> Result<Vec<ast::Expression>> {
  function parse_having_clause (line 454) | fn parse_having_clause(&mut self) -> Result<Option<ast::Expression>> {
  function parse_order_by_clause (line 462) | fn parse_order_by_clause(&mut self) -> Result<Vec<(ast::Expression, ast:...
  function parse_limit_clause (line 486) | fn parse_limit_clause(&mut self) -> Result<Option<ast::Expression>> {
  function parse_offset_clause (line 494) | fn parse_offset_clause(&mut self) -> Result<Option<ast::Expression>> {
  function parse_expression (line 603) | fn parse_expression(&mut self) -> Result<ast::Expression> {
  function parse_expression_at (line 608) | fn parse_expression_at(&mut self, min_precedence: Precedence) -> Result<...
  function parse_expression_atom (line 652) | fn parse_expression_atom(&mut self) -> Result<ast::Expression> {
  function parse_prefix_operator_at (line 700) | fn parse_prefix_operator_at(&mut self, min_precedence: Precedence) -> Op...
  function parse_infix_operator_at (line 714) | fn parse_infix_operator_at(&mut self, min_precedence: Precedence) -> Opt...
  function parse_postfix_operator_at (line 741) | fn parse_postfix_operator_at(
  type Precedence (line 777) | type Precedence = u8;
    type Output (line 786) | type Output = Self;
    method add (line 788) | fn add(self, rhs: Associativity) -> Self {
  type Associativity (line 780) | enum Associativity {
  type PrefixOperator (line 799) | enum PrefixOperator {
    method precedence (line 807) | fn precedence(&self) -> Precedence {
    method associativity (line 816) | fn associativity(&self) -> Associativity {
    method into_expression (line 821) | fn into_expression(self, rhs: ast::Expression) -> ast::Expression {
  type InfixOperator (line 832) | enum InfixOperator {
    method precedence (line 855) | fn precedence(&self) -> Precedence {
    method associativity (line 872) | fn associativity(&self) -> Associativity {
    method into_expression (line 880) | fn into_expression(self, lhs: ast::Expression, rhs: ast::Expression) -...
  type PostfixOperator (line 903) | enum PostfixOperator {
    method precedence (line 911) | fn precedence(&self) -> Precedence {
    method into_expression (line 919) | fn into_expression(self, lhs: ast::Expression) -> ast::Expression {

FILE: src/sql/planner/optimizer.rs
  type Optimizer (line 22) | pub trait Optimizer: Debug + Send + Sync {
    method optimize (line 24) | fn optimize(&self, node: Node) -> Result<Node>;
    method optimize (line 33) | fn optimize(&self, node: Node) -> Result<Node> {
    method optimize (line 98) | fn optimize(&self, node: Node) -> Result<Node> {
    method optimize (line 255) | fn optimize(&self, node: Node) -> Result<Node> {
    method optimize (line 310) | fn optimize(&self, node: Node) -> Result<Node> {
    method optimize (line 357) | fn optimize(&self, node: Node) -> Result<Node> {
  type ConstantFolding (line 30) | pub struct ConstantFolding;
    method fold (line 43) | pub fn fold(mut expr: Expression) -> Result<Expression> {
  type FilterPushdown (line 95) | pub struct FilterPushdown;
    method push_filters (line 106) | fn push_filters(mut node: Node) -> Node {
    method push_into (line 114) | fn push_into(expr: Expression, target: &mut Node) -> Option<Expression> {
    method maybe_push_filter (line 140) | fn maybe_push_filter(node: Node) -> Node {
    method maybe_push_join (line 157) | fn maybe_push_join(node: Node) -> Node {
  type IndexLookup (line 252) | pub struct IndexLookup;
    method index_lookup (line 265) | fn index_lookup(mut node: Node) -> Node {
  type HashJoin (line 307) | pub struct HashJoin;
    method hash_join (line 317) | pub fn hash_join(node: Node) -> Node {
  type ShortCircuit (line 354) | pub struct ShortCircuit;
    method short_circuit (line 366) | fn short_circuit(mut node: Node) -> Node {

FILE: src/sql/planner/plan.rs
  type Plan (line 44) | pub enum Plan {
    method build (line 77) | pub fn build(statement: ast::Statement, catalog: &impl Catalog) -> Res...
    method execute (line 82) | pub fn execute(self, txn: &impl Transaction) -> Result<ExecutionResult> {
    method optimize (line 88) | pub fn optimize(self) -> Result<Self> {
  type Node (line 108) | pub enum Node {
    method columns (line 179) | pub fn columns(&self) -> usize {
    method column_label (line 213) | pub fn column_label(&self, index: usize) -> Label {
    method transform (line 271) | pub fn transform(
    method transform_expressions (line 320) | pub fn transform_expressions(
    method format (line 469) | pub fn format(
  type Aggregate (line 376) | pub enum Aggregate {
    method format (line 385) | fn format(&self, node: &Node) -> String {
    method expr (line 396) | pub fn expr(&self) -> &Expression {
  type Direction (line 409) | pub enum Direction {
    method from (line 424) | fn from(dir: ast::Direction) -> Self {
  method fmt (line 415) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 434) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 460) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function invert_remap (line 649) | pub fn invert_remap(targets: &[Option<usize>]) -> Vec<Option<usize>> {

FILE: src/sql/planner/planner.rs
  type Planner (line 18) | pub struct Planner<'a, C: Catalog> {
  function new (line 24) | pub fn new(catalog: &'a C) -> Self {
  function build (line 29) | pub fn build(&mut self, statement: ast::Statement) -> Result<Plan> {
  function build_create_table (line 50) | fn build_create_table(&self, name: String, columns: Vec<ast::Column>) ->...
  function build_drop_table (line 81) | fn build_drop_table(&self, name: String, if_exists: bool) -> Result<Plan> {
  function build_delete (line 86) | fn build_delete(&self, table: String, r#where: Option<ast::Expression>) ...
  function build_insert (line 98) | fn build_insert(
  function build_update (line 128) | fn build_update(
  function build_select (line 159) | fn build_select(
  function build_from_clause (line 283) | fn build_from_clause(&self, from: Vec<ast::From>, scope: &mut Scope) -> ...
  function build_from (line 306) | fn build_from(&self, from: ast::From, parent_scope: &mut Scope) -> Resul...
  function build_aggregate (line 365) | fn build_aggregate(
  function build_aggregate_function (line 391) | fn build_aggregate_function(expr: ast::Expression, scope: &Scope) -> Res...
  function is_aggregate_function (line 417) | fn is_aggregate_function(expr: &ast::Expression) -> bool {
  function collect_aggregates (line 425) | fn collect_aggregates(
  function build_select_hidden (line 452) | fn build_select_hidden(
  function build_expression (line 495) | pub fn build_expression(expr: ast::Expression, scope: &Scope) -> Result<...
  function build_constant_value (line 572) | fn build_constant_value(expr: ast::Expression) -> Result<Value> {
  type Scope (line 589) | pub struct Scope {
    method new (line 614) | pub fn new() -> Self {
    method from_table (line 619) | fn from_table(table: &Table) -> Result<Self> {
    method spawn (line 626) | pub fn spawn(&self) -> Self {
    method add_table (line 634) | fn add_table(&mut self, table: &Table, alias: Option<&str>) -> Result<...
    method add_column (line 648) | fn add_column(&mut self, label: Label) -> usize {
    method lookup_column (line 661) | fn lookup_column(&self, table: Option<&str>, name: &str) -> Result<usi...
    method add_aggregate (line 692) | fn add_aggregate(&mut self, expr: &ast::Expression, parent: &Scope) ->...
    method lookup_aggregate (line 712) | fn lookup_aggregate(&self, expr: &ast::Expression) -> Option<usize> {
    method add_passthrough (line 718) | fn add_passthrough(&mut self, parent: &Scope, parent_index: usize, hid...
    method merge (line 732) | fn merge(&mut self, scope: Scope) -> Result<()> {
    method project (line 756) | fn project(&self, expressions: &[(ast::Expression, Option<String>)]) -...
    method remap (line 781) | fn remap(&self, targets: &[Option<usize>]) -> Self {
    method remove_hidden (line 791) | fn remove_hidden(&mut self) -> Option<HashSet<usize>> {
    method remap_hidden (line 813) | fn remap_hidden(&mut self) -> Option<Vec<Option<usize>>> {

FILE: src/sql/types/expression.rs
  type Expression (line 19) | pub enum Expression {
    method display (line 69) | pub fn display<'a>(&'a self, node: &'a Node) -> ExpressionDisplay<'a> {
    method evaluate (line 75) | pub fn evaluate(&self, row: Option<&Row>) -> Result<Value> {
    method walk (line 212) | pub fn walk(&self, visitor: &mut impl FnMut(&Expression) -> bool) -> b...
    method contains (line 244) | pub fn contains(&self, visitor: &impl Fn(&Expression) -> bool) -> bool {
    method transform (line 250) | pub fn transform(
    method into_cnf (line 292) | pub fn into_cnf(self) -> Self {
    method into_cnf_vec (line 314) | pub fn into_cnf_vec(self) -> Vec<Self> {
    method into_nnf (line 331) | pub fn into_nnf(self) -> Self {
    method and_vec (line 354) | pub fn and_vec(exprs: Vec<Expression>) -> Option<Self> {
    method is_column_lookup (line 365) | pub fn is_column_lookup(&self) -> Option<usize> {
    method into_column_values (line 393) | pub fn into_column_values(self, index: usize) -> Vec<Value> {
    method replace_column (line 424) | pub fn replace_column(self, from: usize, to: usize) -> Self {
    method shift_column (line 433) | pub fn shift_column(self, diff: isize) -> Self {
    method from (line 538) | fn from(value: Value) -> Self {
  method fmt (line 446) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ExpressionDisplay (line 453) | pub struct ExpressionDisplay<'a> {
  method fmt (line 460) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function new (line 514) | pub fn new(expr: &'a Expression, node: &'a Node, parent_precedence: u8) ...
  function precedence (line 519) | fn precedence(expr: &Expression) -> u8 {
  function from (line 544) | fn from(value: Value) -> Self {

FILE: src/sql/types/schema.rs
  type Table (line 17) | pub struct Table {
    method validate (line 100) | pub fn validate(&self, catalog: &impl Catalog) -> Result<()> {
    method validate_row (line 181) | pub fn validate_row(&self, row: &Row, update: bool, txn: &impl Transac...
  type Column (line 31) | pub struct Column {
  method fmt (line 57) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: src/sql/types/value.rs
  type DataType (line 18) | pub enum DataType {
  method fmt (line 30) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Value (line 42) | pub enum Value {
    method datatype (line 166) | pub fn datatype(&self) -> Option<DataType> {
    method is_undefined (line 177) | pub fn is_undefined(&self) -> bool {
    method checked_add (line 186) | pub fn checked_add(&self, other: &Self) -> Result<Self> {
    method checked_div (line 204) | pub fn checked_div(&self, other: &Self) -> Result<Self> {
    method checked_mul (line 220) | pub fn checked_mul(&self, other: &Self) -> Result<Self> {
    method checked_pow (line 238) | pub fn checked_pow(&self, other: &Self) -> Result<Self> {
    method checked_rem (line 264) | pub fn checked_rem(&self, other: &Self) -> Result<Self> {
    method checked_sub (line 280) | pub fn checked_sub(&self, other: &Self) -> Result<Self> {
    method from (line 299) | fn from(v: bool) -> Self {
    method from (line 305) | fn from(v: f64) -> Self {
    method from (line 311) | fn from(v: i64) -> Self {
    method from (line 317) | fn from(v: String) -> Self {
    method from (line 323) | fn from(v: &str) -> Self {
  method fmt (line 69) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function serialize_f64 (line 83) | fn serialize_f64<S: Serializer>(value: &f64, serializer: S) -> StdResult...
  method eq (line 93) | fn eq(&self, other: &Self) -> bool {
  method hash (line 111) | fn hash<H: Hasher>(&self, hasher: &mut H) {
  method cmp (line 135) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 159) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  type Error (line 329) | type Error = Error;
  function try_from (line 331) | fn try_from(value: Value) -> Result<Self> {
  type Error (line 340) | type Error = Error;
  function try_from (line 342) | fn try_from(value: Value) -> Result<Self> {
  type Error (line 351) | type Error = Error;
  function try_from (line 353) | fn try_from(value: Value) -> Result<Self> {
  type Error (line 362) | type Error = Error;
  method try_from (line 364) | fn try_from(value: Value) -> Result<Self> {
  function from (line 373) | fn from(v: &'a Value) -> Self {
  type Row (line 379) | pub type Row = Vec<Value>;
  type Rows (line 382) | pub type Rows = Box<dyn RowIterator>;
  type RowIterator (line 388) | pub trait RowIterator: Iterator<Item = Result<Row>> + DynClone {}
  type Label (line 396) | pub enum Label {
    method as_header (line 417) | pub fn as_header(&self) -> &str {
    method from (line 437) | fn from(name: Option<String>) -> Self {
  method fmt (line 406) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 427) | fn from(label: Label) -> Self {

FILE: src/storage/bitcask.rs
  type BitCask (line 50) | pub struct BitCask {
    method new (line 75) | pub fn new(path: PathBuf) -> Result<Self> {
    method new_maybe_compact (line 84) | pub fn new_maybe_compact(
    method compact (line 173) | pub fn compact(&mut self) -> Result<()> {
  type KeyDir (line 58) | type KeyDir = BTreeMap<Vec<u8>, ValueLocation>;
  type ValueLocation (line 62) | struct ValueLocation {
    method end (line 68) | fn end(&self) -> u64 {
  type ScanIterator (line 119) | type ScanIterator<'a> = ScanIterator<'a>;
  method delete (line 121) | fn delete(&mut self, key: &[u8]) -> Result<()> {
  method flush (line 127) | fn flush(&mut self) -> Result<()> {
  method get (line 136) | fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  method scan (line 143) | fn scan(&mut self, range: impl RangeBounds<Vec<u8>>) -> Self::ScanIterat...
  method scan_dyn (line 147) | fn scan_dyn(
  method set (line 154) | fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
  method status (line 160) | fn status(&mut self) -> Result<Status> {
  method drop (line 199) | fn drop(&mut self) {
  type ScanIterator (line 206) | pub struct ScanIterator<'a> {
  function map (line 212) | fn map(&mut self, item: (&Vec<u8>, &ValueLocation)) -> <Self as Iterator...
  type Item (line 219) | type Item = Result<(Vec<u8>, Vec<u8>)>;
  method next (line 221) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 227) | fn next_back(&mut self) -> Option<Self::Item> {
  type Log (line 239) | struct Log {
    method new (line 250) | fn new(path: PathBuf) -> Result<Self> {
    method build_keydir (line 269) | fn build_keydir(&mut self) -> Result<KeyDir> {
    method read_value (line 334) | fn read_value(&mut self, location: ValueLocation) -> Result<Vec<u8>> {
    method write_entry (line 344) | fn write_entry(&mut self, key: &[u8], value: Option<&[u8]>) -> Result<...
  function test_goldenscript (line 387) | fn test_goldenscript(path: &std::path::Path) {
  function lock (line 394) | fn lock() -> Result<()> {
  function recovery (line 410) | fn recovery() -> Result<()> {
  function point_ops_sizes (line 460) | fn point_ops_sizes() -> Result<()> {
  type BitCaskRunner (line 480) | struct BitCaskRunner {
    method run (line 486) | fn run(&mut self, command: &goldenscript::Command) -> StdResult<String...
    method new (line 531) | fn new() -> Self {
    method dump (line 539) | fn dump(&mut self, output: &mut String) -> StdResult<(), Box<dyn StdEr...

FILE: src/storage/engine.rs
  type Engine (line 22) | pub trait Engine: Send {
    method delete (line 29) | fn delete(&mut self, key: &[u8]) -> Result<()>;
    method flush (line 32) | fn flush(&mut self) -> Result<()>;
    method get (line 35) | fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>>;
    method scan (line 38) | fn scan(&mut self, range: impl RangeBounds<Vec<u8>>) -> Self::ScanIter...
    method scan_dyn (line 43) | fn scan_dyn(&mut self, range: (Bound<Vec<u8>>, Bound<Vec<u8>>)) -> Box...
    method scan_prefix (line 46) | fn scan_prefix(&mut self, prefix: &[u8]) -> Self::ScanIterator<'_>
    method set (line 54) | fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()>;
    method status (line 57) | fn status(&mut self) -> Result<Status>;
    type ScanIterator (line 258) | type ScanIterator<'a>
    method flush (line 263) | fn flush(&mut self) -> Result<()> {
    method delete (line 269) | fn delete(&mut self, key: &[u8]) -> Result<()> {
    method get (line 275) | fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
    method scan (line 279) | fn scan(&mut self, range: impl RangeBounds<Vec<u8>>) -> Self::ScanIter...
    method scan_dyn (line 283) | fn scan_dyn(
    method set (line 290) | fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
    method status (line 296) | fn status(&mut self) -> Result<Status> {
    type ScanIterator (line 316) | type ScanIterator<'a>
    method delete (line 323) | fn delete(&mut self, key: &[u8]) -> Result<()> {
    method flush (line 328) | fn flush(&mut self) -> Result<()> {
    method get (line 333) | fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
    method scan (line 340) | fn scan(&mut self, range: impl RangeBounds<Vec<u8>>) -> Self::ScanIter...
    method scan_dyn (line 349) | fn scan_dyn(
    method set (line 358) | fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
    method status (line 363) | fn status(&mut self) -> Result<Status> {
  type ScanIterator (line 61) | pub trait ScanIterator: DoubleEndedIterator<Item = Result<(Vec<u8>, Vec<...
  type Status (line 68) | pub struct Status {
    method garbage_disk_size (line 83) | pub fn garbage_disk_size(&self) -> u64 {
    method garbage_disk_percent (line 88) | pub fn garbage_disk_percent(&self) -> f64 {
  type Runner (line 114) | pub struct Runner<E: Engine> {
  function new (line 119) | pub fn new(engine: E) -> Self {
  function run (line 125) | fn run(&mut self, command: &goldenscript::Command) -> StdResult<String, ...
  function decode_binary (line 204) | pub fn decode_binary(s: &str) -> Vec<u8> {
  function parse_key_range (line 218) | pub fn parse_key_range(s: &str) -> StdResult<impl RangeBounds<Vec<u8>>, ...
  type Emit (line 237) | pub struct Emit<E: Engine> {
  type Operation (line 245) | pub enum Operation {
  function new (line 252) | pub fn new(inner: E, tx: Sender<Operation>) -> Self {
  type Mirror (line 304) | pub struct Mirror<A: Engine, B: Engine> {
  function new (line 310) | pub fn new(a: A, b: B) -> Self {
  type MirrorIterator (line 373) | pub struct MirrorIterator<'a, A: Engine + 'a, B: Engine + 'a> {
  type Item (line 379) | type Item = Result<(Vec<u8>, Vec<u8>)>;
  method next (line 381) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 390) | fn next_back(&mut self) -> Option<Self::Item> {

FILE: src/storage/memory.rs
  type Memory (line 11) | pub struct Memory(BTreeMap<Vec<u8>, Vec<u8>>);
    method new (line 15) | pub fn new() -> Self {
  type ScanIterator (line 21) | type ScanIterator<'a> = ScanIterator<'a>;
  method delete (line 23) | fn delete(&mut self, key: &[u8]) -> Result<()> {
  method flush (line 28) | fn flush(&mut self) -> Result<()> {
  method get (line 32) | fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  method scan (line 36) | fn scan(&mut self, range: impl RangeBounds<Vec<u8>>) -> Self::ScanIterat...
  method scan_dyn (line 40) | fn scan_dyn(
  method set (line 47) | fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
  method status (line 52) | fn status(&mut self) -> Result<Status> {
  type ScanIterator (line 63) | pub struct ScanIterator<'a>(Range<'a, Vec<u8>, Vec<u8>>);
  type Item (line 66) | type Item = Result<(Vec<u8>, Vec<u8>)>;
  method next (line 68) | fn next(&mut self) -> Option<Self::Item> {
  method next_back (line 74) | fn next_back(&mut self) -> Option<Self::Item> {
  function test_goldenscript (line 95) | fn test_goldenscript(path: &Path) {

FILE: src/storage/mvcc.rs
  type Version (line 158) | pub type Version = u64;
  type Key (line 167) | pub enum Key<'a> {
  type KeyPrefix (line 205) | enum KeyPrefix<'a> {
  type MVCC (line 229) | pub struct MVCC<E: Engine> {
  function new (line 235) | pub fn new(engine: E) -> Self {
  function begin (line 240) | pub fn begin(&self) -> Result<Transaction<E>> {
  function begin_read_only (line 245) | pub fn begin_read_only(&self) -> Result<Transaction<E>> {
  function begin_as_of (line 250) | pub fn begin_as_of(&self, version: Version) -> Result<Transaction<E>> {
  function resume (line 255) | pub fn resume(&self, state: TransactionState) -> Result<Transaction<E>> {
  function get_unversioned (line 260) | pub fn get_unversioned(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  function set_unversioned (line 265) | pub fn set_unversioned(&self, key: &[u8], value: Vec<u8>) -> Result<()> {
  function status (line 270) | pub fn status(&self) -> Result<Status> {
  type Status (line 283) | pub struct Status {
  type Transaction (line 295) | pub struct Transaction<E: Engine> {
  type TransactionState (line 315) | pub struct TransactionState {
    method is_visible (line 344) | fn is_visible(&self, version: Version) -> bool {
  function from (line 356) | fn from(txn: TransactionState) -> Self {
  function from (line 362) | fn from(txn: &'a TransactionState) -> Self {
  function begin (line 371) | fn begin(engine: Arc<Mutex<E>>) -> Result<Self> {
  function begin_read_only (line 397) | fn begin_read_only(engine: Arc<Mutex<E>>, as_of: Option<Version>) -> Res...
  function resume (line 428) | fn resume(engine: Arc<Mutex<E>>, s: TransactionState) -> Result<Self> {
  function scan_active (line 438) | fn scan_active(session: &mut MutexGuard<E>) -> Result<BTreeSet<Version>> {
  function version (line 451) | pub fn version(&self) -> Version {
  function read_only (line 456) | pub fn read_only(&self) -> bool {
  function state (line 462) | pub fn state(&self) -> &TransactionState {
  function commit (line 472) | pub fn commit(self) -> Result<()> {
  function rollback (line 490) | pub fn rollback(self) -> Result<()> {
  function delete (line 515) | pub fn delete(&self, key: &[u8]) -> Result<()> {
  function set (line 520) | pub fn set(&self, key: &[u8], value: Vec<u8>) -> Result<()> {
  function write_version (line 528) | fn write_version(&self, key: &[u8], value: Option<Vec<u8>>) -> Result<()> {
  function get (line 565) | pub fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
  function scan (line 585) | pub fn scan(&self, range: impl RangeBounds<Vec<u8>>) -> ScanIterator<E> {
  function scan_prefix (line 600) | pub fn scan_prefix(&self, prefix: &[u8]) -> ScanIterator<E> {
  type ScanIterator (line 620) | pub struct ScanIterator<E: Engine> {
  method clone (line 635) | fn clone(&self) -> Self {
  constant BUFFER_SIZE (line 648) | const BUFFER_SIZE: usize = if cfg!(test) { 2 } else { 32 };
  function new (line 651) | fn new(
  function fill_buffer (line 661) | fn fill_buffer(&mut self) -> Result<()> {
  type Item (line 702) | type Item = Result<(Vec<u8>, Vec<u8>)>;
  method next (line 704) | fn next(&mut self) -> Option<Self::Item> {
  type VersionIterator (line 716) | struct VersionIterator<'a, I: engine::ScanIterator> {
  function new (line 725) | fn new(txn: &'a TransactionState, inner: I) -> Self {
  function try_next (line 730) | fn try_next(&mut self) -> Result<Option<(Vec<u8>, Version, Vec<u8>)>> {
  type Item (line 745) | type Item = Result<(Vec<u8>, Version, Vec<u8>)>;
  method next (line 747) | fn next(&mut self) -> Option<Self::Item> {
  function test_goldenscript (line 774) | fn test_goldenscript(path: &Path) {
  function key_prefix (line 785) | fn key_prefix(prefix: KeyPrefix, key: Key) {
  type MVCCRunner (line 792) | pub struct MVCCRunner {
    method new (line 802) | fn new() -> Self {
    method get_txn (line 815) | fn get_txn(
    method txn_name (line 824) | fn txn_name(prefix: &Option<String>) -> Result<&str, Box<dyn Error>> {
    method no_txn (line 829) | fn no_txn(command: &goldenscript::Command) -> Result<(), Box<dyn Error...
    method run (line 838) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, B...
    method end_command (line 1067) | fn end_command(&mut self, _: &goldenscript::Command) -> Result<String,...
  type TestEngine (line 799) | type TestEngine = Emit<Mirror<BitCask, Memory>>;

FILE: tests/testcluster.rs
  constant TIMEOUT (line 13) | const TIMEOUT: Duration = Duration::from_secs(5);
  constant SQL_BASE_PORT (line 16) | const SQL_BASE_PORT: u16 = 19600;
  constant RAFT_BASE_PORT (line 19) | const RAFT_BASE_PORT: u16 = 19700;
  type TestCluster (line 29) | pub struct TestCluster {
    method run (line 39) | pub fn run(nodes: u8) -> Result<Self, Box<dyn Error>> {
    method connect (line 73) | pub fn connect(&self) -> Result<Client, Box<dyn Error>> {
  type NodePorts (line 35) | type NodePorts = BTreeMap<NodeID, (u16, u16)>;
  type TestServer (line 80) | pub struct TestServer {
    method run (line 88) | fn run(id: NodeID, dir: &Path, ports: &NodePorts) -> Result<Self, Box<...
    method build_config (line 112) | fn build_config(id: NodeID, dir: &Path, ports: &NodePorts) -> Result<S...
    method assert_alive (line 131) | fn assert_alive(&mut self) {
    method connect (line 138) | fn connect(&self) -> Result<Client, Box<dyn Error>> {
  method drop (line 145) | fn drop(&mut self) {

FILE: tests/tests.rs
  function test_goldenscript (line 27) | fn test_goldenscript(path: &Path) {
  type Runner (line 40) | struct Runner {
    method new (line 46) | fn new() -> Self {
    method get_client (line 51) | fn get_client(&mut self, prefix: &Option<String>) -> Result<&mut Clien...
    method client_name (line 64) | fn client_name(prefix: &Option<String>) -> &str {
    method run (line 71) | fn run(&mut self, command: &goldenscript::Command) -> Result<String, B...