Rename KeyCode to Keycode

Author: erikgrinaker

docs/architecture.md

@@ -125,7 +125,7 @@ SQL table scans) and has a couple of important implications:
 * Keys should use an order-preserving byte encoding, to allow range scans.
 
 The engine itself does not care what keys contain, but the storage module offers
-an order-preserving key encoding called [KeyCode](https://github.com/erikgrinaker/toydb/blob/main/src/encoding/keycode.rs)
+an order-preserving key encoding called [Keycode](https://github.com/erikgrinaker/toydb/blob/main/src/encoding/keycode.rs)
 for use by higher layers. These storage layers often use composite keys made up
 of several possibly variable-length values (e.g. an index key consists of table,
 column, and value), and the natural ordering of each segment must be preserved,

src/encoding/keycode.rs

@@ -1,4 +1,4 @@
-//! KeyCode is a lexicographical order-preserving binary encoding for use with
+//! Keycode is a lexicographical order-preserving binary encoding for use with
 //! keys. It is designed for simplicity, not efficiency (i.e. it does not use
 //! varints or other compression methods).
 //!
@@ -10,7 +10,7 @@
 //! The encoding is not self-describing: the caller must provide a concrete type
 //! to decode into, and the binary key must conform to its structure.
 //!
-//! KeyCode supports a subset of primitive data types, encoded as follows:
+//! Keycode supports a subset of primitive data types, encoded as follows:
 //!
 //! * [`bool`]: `0x00` for `false`, `0x01` for `true`.
 //! * [`u64`]: big-endian binary representation.
@@ -48,7 +48,7 @@ use serde::ser::{Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeT
 use crate::errdata;
 use crate::error::{Error, Result};
 
-/// Serializes a key to a binary KeyCode representation.
+/// Serializes a key to a binary Keycode representation.
 ///
 /// In the common case, the encoded key is borrowed for a storage engine call
 /// and then thrown away. We could avoid a bunch of allocations by taking a
@@ -62,7 +62,7 @@ pub fn serialize<T: Serialize>(key: &T) -> Vec<u8> {
     serializer.output
 }
 
-/// Deserializes a key from a binary KeyCode representation.
+/// Deserializes a key from a binary Keycode representation.
 pub fn deserialize<'a, T: Deserialize<'a>>(input: &'a [u8]) -> Result<T> {
     let mut deserializer = Deserializer::from_bytes(input);
     let t = T::deserialize(&mut deserializer)?;
@@ -381,7 +381,7 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V: Visitor<'de>>(self, _: V) -> Result<V::Value> {
-        panic!("must provide type, KeyCode is not self-describing")
+        panic!("must provide type, Keycode is not self-describing")
     }
 
     fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {

src/sql/engine/local.rs

@@ -382,7 +382,7 @@ impl<E: storage::Engine> Catalog for Transaction<E> {
     }
 }
 
-/// SQL engine keys, using the KeyCode order-preserving encoding. For
+/// SQL engine keys, using the Keycode order-preserving encoding. For
 /// simplicity, table and column names are used directly as identifiers in
 /// keys, instead of e.g. numberic IDs. It is not possible to change
 /// table/column names, so this is fine.

src/storage/engine.rs

@@ -11,7 +11,7 @@ use crate::error::Result;
 /// have a common key prefix), or to scan the tail of the Raft log (after a
 /// given log entry index).
 ///
-/// Keys should use the KeyCode order-preserving encoding, see
+/// Keys should use the Keycode order-preserving encoding, see
 /// [`crate::encoding::keycode`].
 ///
 /// Writes are only guaranteed durable after calling [`Engine::flush()`].

src/storage/mvcc.rs

@@ -159,7 +159,7 @@ pub type Version = u64;
 
 impl encoding::Value for Version {}
 
-/// MVCC keys, using the KeyCode encoding which preserves the ordering and
+/// MVCC keys, using the Keycode encoding which preserves the ordering and
 /// grouping of keys.
 ///
 /// Cow byte slices allow encoding borrowed values and decoding owned values.
@@ -600,7 +600,7 @@ impl<E: Engine> Transaction<E> {
     pub fn scan_prefix(&self, prefix: &[u8]) -> ScanIterator<E> {
         // Normally, KeyPrefix::Version will only match all versions of the
         // exact given key. We want all keys maching the prefix, so we chop off
-        // the KeyCode byte slice terminator 0x0000 at the end.
+        // the Keycode byte slice terminator 0x0000 at the end.
         let mut prefix = KeyPrefix::Version(prefix.into()).encode();
         prefix.truncate(prefix.len() - 2);
         let range = keycode::prefix_range(&prefix);