Rust on roseduan

Rust 手写数据库的成就感！

Thu, 05 Dec 2024 16:51:56 +0800

前几天刚好完成了 rust 手写数据库课程的命令行工具，有一个交互式的客户端，瞬间成就感拉满了！

不枉我写这个项目接近一年的时间，觉得之前的努力都没有白费哈哈。

在这个客户端当中，可以创建表：

可以增删改查数据：

可以进行常见的 sql 查询，比如

Order By
Limit 和 Offset
Projection 投影
Join 语句
Agg 聚集函数
Group By 分组

并且还支持 ACID 的事务操作：

也可以查看当前表的信息：

《从零实现 SQL 数据库》是我今年开始搞的，最初也只是想着试试看能不能做，但是后来帮助了一些同学，他们都从中学习到了很多，这也让我一路坚持到了现在。

课程虽然实现的只是一个非常简单的数据库，但是麻雀虽小五脏俱全，数据库内核的各个模块基本都实现了。

相信通过这样一个项目，对编程基础、rust 上手、项目实战、系统设计等等能力都会上一个台阶！

现在课程项目接近尾声了，代码量（加注释）接近 6000 行，是非常不错的适合上手和实践 rust 的项目。

课程的详细目录如下：

感兴趣的同学可以进这个课程详情链接查看：

https://icnyamgobd0u.feishu.cn/docx/AbXZdEbY0obdcTxF0FKcx4Pqnyf

到明年，Rust 和 Go 都将稳居前十

Sat, 16 Nov 2024 16:51:56 +0800

平时不太关注 TIOBE INDEX 的排名，但是今天刚好看到了，发现 Go 语言都已经排在第七了。

几年前我刚开始学习的时候，Go 语言其实受关注和欢迎程度没有这么高，但是近些年来一路狂飙，稳坐前十，成为了主流编程语言之一。

Go 在云计算、容器化和微服务架构中的应用越来越广泛。

而且云原生的基础设施 Kubernetes 和 Docker 等技术的普及，Go 语言凭借其高效的执行性能和简洁的代码结构，成为开发者构建云原生系统的首选语言。

未来几年，Go 语言应该会继续向前，稳居前十应该没什么问题，看什么时候能够超过 JavaScript 了。

其实另一个值得关注的是 Rust，Rust 的上升速度也非常惊人，去年还在 20 名左右徘徊，今年这时候的排名已经来到第 14 位了。

我在这几年接触和使用 Rust 的经历中，也非常看好 Rust 的发展。

Rust 的内存安全性和高性能，其实也逐步成为开发高性能系统、嵌入式应用和区块链技术的理想选择。

主要是 Rust 语言避免了传统 C/C++ 中存在的许多内存管理问题，且在性能上几乎不输给这些底层语言，这使得它在需要高效并且稳定的应用中逐渐取代了传统的技术栈。

当然，C 和 C++ 的基本盘还是很大，Rust 作为一门相对较年轻的语言，其实能做到这种程度已经非常不错了。

到明年，Rust 或许能够超过前面的几个，首次进入到前十当中，拭目以待吧哈哈！

我自己的课程也是优先支持 Go 和 Rust 这两种语言，目前看来是挺正确的选择。

目前《从零实现 KV 存储》支持 Rust 和 Go 两种语言，手把手教学，只需要了解基础的语法知识，即可学会一个硬核实战项目！

课程详情链接：

https://w02agegxg3.feishu.cn/docx/Ktp3dBGl9oHdbOxbjUWcGdSnn3g

《从零实现 SQL 数据库》支持 Rust，使用 Rust 手写一个数据库系统，超级硬核，Rust 实战项目首选，并且还有 Rust 零基础的入门讲解，就算没有 Rust 基础也可以来学习。

课程详情链接：

https://w02agegxg3.feishu.cn/do

Rust 手写 SQL 数据库

Thu, 29 Aug 2024 10:51:56 +0800

继去年发布《从零实现 KV 存储》和《从零实现分布式 KV》两门课程之后，今天再次给大家带来一个全新的课程，使用 Rust，手写一个 SQL 数据库系统，超级硬核，前所未有！

课程详情，以及如何购买，都在飞书云文档中，复制下面的链接打开即可：

https://w02agegxg3.feishu.cn/docx/OxwGdeM30oss7vxEG5AcUn4unEc

下面是课程内容的详细介绍：

本课程将会使用 Rust 从零实现一个完整的 SQL 数据库系统，将会由浅到深、由易到难，循序渐进的带着大家去实现，从第一行代码开始，均有完整的代码实现演示。

无论你是后端研发，中间件开发，基础架构开发，甚至是 DBA，能够手写一个完整的 SQL 数据库系统，都是你突破技术发展瓶颈的有效途径。

本课程将会详细介绍架构设计，原理剖析，再到源码实现，让你深度掌握数据库底层，具备解决大量生产级数据库问题的能力，助力成为高端技术人才！

学习完本课程，你至少可以收获：

入门 Rust 语言，课程针对 Rust 零基础的同学上手，专门讲解了 Rust 中最常用的基础语法，能够应对大多数开发需求
巩固 Rust 语法基础，并且可以使用 Rust 搭建一个完整的、超级硬核的实战项目
锻炼编程基本功，数据库是基础软件领域最为复杂，工程细节极为考究的项目，可以从中学习到数据库内核构造，完全掌握一个数据库的整体执行流程
简历上的一个硬核项目，一个脱颖而出的亮点，和别人拉开差距，帮助你在职场上获得更大的突破

课程作者

我的网名叫 roseduan，是开源项目rosedb、lotusdb 的作者，目前总共超过 6k star，目前担任数据库内核研发的职位，主要研究 Postgres 数据库，在数据库内核开发方面有丰富的经验。

我的 Github 主页：https://github.com/roseduan

我也开源过一些 Rust 项目，并且上过 Github 全球 Trending 榜单，在 Rust 方面也有多年的开发经验。

同时，我也是**《从零实现 KV 存储》和《从零实现分布式 KV》**这两门课程的作者，在教学方面也有很多的心得，能够帮助大家梳理知识重点，理清前后脉络，用最快的速度，最稳的节奏帮助你学懂、学透全部知识点。

对这两门课程感兴趣的同学，也可以点这里查看对应的课程详情 0 从零实现 KV 存储—关于本课程 0. 从零实现分布式 KV—关于课程

课程形式

课程内容是文档+视频。

文档是一小节内容的概述，主要描述这一小节内容学什么。

视频是详细的理论讲解+代码实现。

课程目录

第一部分售价 400

第二部分售价 400

可以单独购买第一部分，觉得不错，再购买第二部分

也可以两部分一起购买，更快解锁全部内容，第二部分内容后面会陆续发布，敬请期待。

第一部分

第一部分售价 400，代码量在 3000 行左右，包含内容：

Rust 基础回顾，主要讲解 Rust 常用基础语法和最重要的所有权、引用等概念，Rust 零基础也可以上手！
使用最常见的 SQL 语句搭建项目的代码结构
磁盘存储引擎
MVCC 事务完整实现

完整目录如下：

第二部分

第二部分售价 400，陆续更新中，大致目录如下

适用人群

这个课程对以下同学应该都非常的合适，包括但不限于：

入门并巩固 Rust 基础，课程内容几乎涵盖了 Rust 大多数常用基础，例如数据类型，match 表达式匹配，函数，闭包，结构体，泛型，Trait，所有权，借用，生命周期，错误处理，智能指针等等
增加 Rust 项目经验的同学，如果学习了一些 Rust 的基础知识，但是苦于没有项目经验，想要进一步巩固自己的知识，自己写一个数据库是一个很合适的实战项目
想要巩固基本功的同学，基本功对一个程序员来说非常重要，数据库是任何开发者必学的基本技能之一。自己写一个数据库，更加深入理解一个复杂的系统，是你和别人拉开差距的关键
想要深入学习数据库的内部构造，彻底搞懂数据库系统基本原理，包括 SQL 解析、查询执行、存储引擎、事务等
突破职业瓶颈，理解一个复杂系统的设计与实现，提升自己的技术能力，架构设计能力

前置知识

学习本课程，不需要任何其他前置知识（当然了解一些 SQL 和 Rust 的基础更好）。

课程当中涉及到的一些内容，例如 Rust 零基础入门，数据库基础知识等，我将会详细的为大家讲解，前期先跟着视频中敲代码，是完全可以学会的。

是否可以试看

可以，课程的第四节和第七节内容可以试看

04 从零实现 SQL 数据库—数据库架构

07 从零实现 SQL 数据库—Planner 实现

如果没有完整上下文的话，试看的具体内容细节你可能并不会特别明白。试看主要是让同学们了解课程的大致结构，和我的讲课风格等等。

课程目前的进度

课程目前第一部分内容已经更新完毕，目前可单独购买第一部分！

第二部分预计 2024 年底更新完毕，准备好了我会发布。

课程评价

我之前已经发布过两门课程，课程受到了很多好评。

有的同学，根据课程内容，自己写开源项目，获得了上千 star！

有的同学在面试中使用课程项目，毕业即获得年薪 30w+ offer！

可以在这两篇文章中了解详情：

从零实现 KV 存储—捷报频传

课程学员故事—介绍两个开源项目

从零实现 SQL 数据库这个课程更加硬核，会比之前的项目更具含金量！

如何购买

https://w02agegxg3.feishu.cn/docx/OxwGdeM30oss7vxEG5AcUn4unEc

咨询服务

购买后，我会拉你进课程用户专属的飞书群，我会亲自为你解答学习过程中的疑难杂症，保证你肯定能够完全学会课程中的内容！

其他 Q&A

购买后在什么平台学习？

课程内容都在飞书云文档，购买成功后，为你开启对应的权限，然后可以在线观看

课程时长？代码量？

课程的视频总时长大概在 15 小时左右，代码量大概在 3000 行

只学了第一部分，能把项目写到简历上吗？

当然可以，其实到第十一节，就已经是能够独立运行，比较迷你的数据库了，只是功能比较单一，也可以写到简历上

如何获取项目中的代码？

购买成功后，可以到课程专属飞书用户群公告中下载

没有任何数据库或者 Rust 基础，能学会吗？

当然可以，本课程首先就针对 Rust 零基础的同学，讲解了 Rust 大多数基础语法。对数据库的内容也会在每一个小节进行讲解，并且有代码实现，完全可以学会。

购买后是否有有效期？

没有，购买后永久持有，无限次观看。

可以退款吗

虚拟内容服务，一经购买，概不退款，多谢支持与理解。

Rust 练手项目 3 - 实现 MVCC 多版本并发控制

Sun, 12 May 2024 10:51:56 +0800

完整代码：https://github.com/rosedblabs/rust-practice/tree/main/mvcc

事务及 MVCC

数据库的事务是一个经久不衰的话题，相信大家都已经耳熟能详了，事务是指数据库中单一逻辑工作单元的操作集合。这些操作要么全部成功执行，要么全部失败，从而确保数据库的一致性和完整性。

事务有 ACID 四个特性，分别是：

原子性（Atomicity）：事务应该被视为不可分割的最小执行单元。这意味着事务中的所有操作要么全部完成，要么全部失败回滚。如果事务中的任何一部分操作失败，整个事务将会被回滚到初始状态，不会留下部分执行的结果。
一致性（Consistency）：事务在执行前后，数据库应该保持一致性状态，不会破坏数据库的完整性。
隔离性（Isolation）：事务的执行应该相互隔离，使得每个事务感觉自己在操作数据库时是独立的。这意味着并发执行的事务之间不应该相互影响，即使它们同时访问相同的数据。这样可以防止并发执行时出现数据不一致或者丢失的问题。
持久性（Durability）：一旦事务被提交，其结果应该是永久性的。即使系统崩溃或发生故障，已经提交的事务所做的改变也应该被永久保存在数据库中，不会丢失。

其中原子性一般是通过预写日志来保证，持久性是通过预写日志和存储管理完成，隔离性常用的方式有多版本并发控制（MVCC）、两阶段锁等等。

隔离性是这其中稍微复杂的，其他的几个特性其实都不难理解，这篇文章将会使用 Rust 代码，实现一个最基础的 MVCC 事务，让一些重要概念不仅仅存在于理论层面，而是让大家上手实践，这样才能够加深理解并完全掌握。

我们知道数据库的隔离性其实又分为了四种，分别是

读未提交（Read Uncommitted）
读提交（Read Committed）
可重复读（Repeatable Read）
串行化（Serializable）

总体来说 MVCC 是实现事务隔离性的手段，通过 MVCC 可以很方便的实现可重复读。
MVCC 是建立在数据多版本的基础之上的，当写入一条数据的时候，会带上一个版本号，这个版本号一般是事务的唯一标识，修改数据的时候，不会直接原地去修改数据，而是新增一条新的数据，并且带上一个新的版本号。
这样一条数据实际上就会在物理存储上存在多个版本，当读取数据的时候，会找到第一个满足条件的数据并返回。
这样的好处是：读不会阻塞写，写也不会阻塞读，最大限度提升了数据库的并发性能。

如下所示，横轴表示数据库中的 key，竖轴表示事务开始的时间顺序。

1
2
3
4
5
6
7


Time
 5
 4 a4
 3 b3 x
 2
 1 a1 c1 d1
 a b c d Keys

事务 T2 启动的时候，它看到的值是 a=a1，c=c1，d=d1。
随后又有几个事务修改了 a（将 a1 改为 a4），新增了 b=b3，并且删除了 d。
这时候事务 T5 开始，它看到的值是 a=a4，b=b3，c=c1。
可以看到对数据的修改并不是原地的，而是新增加一个版本的数据，删除数据的时候，其实也不是真正的将其删除掉，而是通过标记的方式。

接下来通过具体的代码来进行更进一步的了解。

需要说明的是，出于演示的便利性，代码全部使用了基于内存的数据结构，所以严格意义上来说并不满足事务的原子性、持久性，但这并不妨碍我们去理解 MVCC 的精髓。

事务定义

事务的定义使用一个单独的结构体来表示，分别包含了存储数据的底层 KV，事务的版本号，以及活跃事务列表。
active_xid 是一个事务私有的数据结构，保存了在这个事务启动时，其他活跃的（未提交）事务集合，这是实现可重复读的关键，保证就算其他事务提交了，也不会影响到当前的事务。

1
2
3
4
5
6
7
8
9


// MVCC 事务
pub struct Transaction {
 // 底层 KV 存储引擎
 kv: Arc<Mutex<KVEngine>>,
 // 事务版本号
 version: u64,
 // 事务启动时的活跃事务列表
 active_xid: HashSet<u64>,
}

再来看一下事务的具体操作。

开启事务

首先是开启事务，这里是申请一个全局唯一的事务版本号，并且保存当前活跃事务列表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 开启事务
pub fn begin(kv: Arc<Mutex<KVEngine>>) -> Self {
 // 获取全局事务版本号
 let version = acquire_next_version();

 let mut active_txn = ACTIVE_TXN.lock().unwrap();
 // 这个 map 的 key 就是当前所有活跃的事务
 let active_xid = active_txn.keys().cloned().collect();

 // 添加到当前活跃事务 id 列表中
 active_txn.insert(version, vec![]);

 // 返回结果
 Self {
 kv,
 version,
 active_xid,
 }
}

写入数据

然后是写入数据，需要判断当前写入的 key 是否和其他的事务发生了冲突，如果是的话，则需要返回错误，通知调用者进行重试。
这里判断冲突主要的逻辑是扫描最后一个 key 及其对应的版本，并判断其可见性：

如果最后一个 key 可见，说明是当前事务自己写入的，或者是比自己更早的已经提交的事务的写入的，可见。
如果 key 的版本号存在于活跃事务列表中（其他事务修改了，并且没提交），或者版本号比自身大（有新的事务修改了数据并提交），说明存在并发写入冲突。

如果没有冲突，则写入数据，也分为了两个步骤，一是记录了当前 version 写入了哪些 key（主要保证回滚时可以将数据删除掉），二是实际向存储引擎写入对应的数据。

 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


fn write(&self, key: &[u8], value: Option<Vec<u8>>) {
 // 判断当前写入的 key 是否和其他的事务冲突
 // key 是按照 key-version 排序的，所以只需要判断最近的一个 key 即可
 let mut kvengine = self.kv.lock().unwrap();
 for (enc_key, _) in kvengine.iter().rev() {
 let key_version = decode_key(enc_key);
 if key_version.raw_key.eq(key) {
 if !self.is_visible(key_version.version) {
 panic!("serialization error, try again.");
 }
 break;
 }
 }

 // 写入 TxnWrite
 let mut active_txn = ACTIVE_TXN.lock().unwrap();
 active_txn
 .entry(self.version)
 .and_modify(|keys| keys.push(key.to_vec()))
 .or_insert_with(|| vec![key.to_vec()]);

 // 写入数据
 let enc_key = Key {
 raw_key: key.to_vec(),
 version: self.version,
 };
 kvengine.insert(enc_key.encode(), value);
}

可以看到写入数据的时候，需要将原始的 key 加上当前版本号。

提交事务

提交事务的逻辑比较简单，因为所有需要写入的数据实际上都已经写入完成了，这时候只需要将这个事务的版本号从全局的活跃事务列表中删除就可以了。

1
2
3
4
5
6


// 提交事务
pub fn commit(&self) {
 // 清除活跃事务列表中的数据
 let mut active_txn = ACTIVE_TXN.lock().unwrap();
 active_txn.remove(&self.version);
}

这样后续新开启的事务可以看到这个事务的修改，而其他未提交的事务，仍然看不到这个事务的修改。

回滚事务

回滚事务的逻辑和提交事务有些类似，唯一的区别是，需要将写入的数据重新删除掉。
这样做的目的是确保事务的一致性，因为事务回滚之后，原来已经写入的数据不能对后续的事务可见，所以需要全部删除掉。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// 回滚事务
pub fn rollback(&self) {
 // 清除写入的数据
 let mut active_txn = ACTIVE_TXN.lock().unwrap();
 if let Some(keys) = active_txn.get(&self.version) {
 let mut kvengine = self.kv.lock().unwrap();
 for k in keys {
 let enc_key = Key {
 raw_key: k.to_vec(),
 version: self.version,
 };
 let res = kvengine.remove(&enc_key.encode());
 assert!(res.is_some());
 }
 }

 // 清除活跃事务列表中的数据
 active_txn.remove(&self.version);
}

读取数据

读取数据的逻辑比较简单，因为数据 key 是按照 version 排序的，所以只需要从后往前遍历，找到第一个可见的记录，就是当前事务能够得到的对应 key 的结果。
需要说明的是，这里的处理逻辑稍微有点冗余，因为直接遍历了整个 map 去查找对应的 key，但实际上因为我们写入的 key 都是有序的，所以只需要前缀遍历即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 读取数据，从最后一条数据进行遍历，找到第一条可见的数据
pub fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
 let kvengine = self.kv.lock().unwrap();
 for (k, v) in kvengine.iter().rev() {
 let key_version = decode_key(k);
 if key_version.raw_key.eq(key) && self.is_visible(key_version.version) {
 return v.clone();
 }
 }
 None
}

总结

MVCC 的核心是“多版本”，即同一个 key 在写入、更新、查询的时候，都会和当前版本号相关，通过事务的版本号来判断数据的可见性。
并且存储的时候，同一个 key 在物理上会有多份，分别对应不同的版本，本质上是一种通过空间冗余的方式来提升并发性能，让每一个事务都“看起来像”是单独执行，不受其他并发事务的影响，做到了读写互不阻塞。

通过上面的理论知识讲解和代码实战，相信你能够对 MVCC 理论有了一个更加深入的理解了。

完整代码地址：https://github.com/rosedblabs/rust-practice/tree/main/mvcc

Rust 练手项目 2 - 表达式计算

Thu, 02 May 2024 10:51:56 +0800

本文完整代码：https://github.com/rosedblabs/rust-practice

表达式解析、计算是一种基本和常见的任务，例如最常见的算术表达式，计算的方法有很多，比如逆波兰表达式、LL、LR 算法等等。

这一次介绍一种最简单的、容易理解的基于运算符优先级的算法来完成这个任务。

基于运算符优先级的算法叫做 Precedence Climbing，它本质上是一种递归下降解析表达式的方法，通过递归地处理运算符和操作数来解析表达式，并根据运算符的优先级和结合性来确定表达式的计算顺序。

这种算法的核心思想是利用运算符的优先级进行“爬升”（Climbing），以决定表达式的结构和计算顺序。

首先我们做一些约束，由于运算符众多，我们可以支持几种最常用的：

+ 加
- 减
* 乘
/ 除
^ 幂

并且我们知道，幂运算的优先级是最高的，其次是 * 和 /，优先级最低的是 + 和 -。

所以约定其运算符的优先级分别为 3（^）、2（* /）、1（+ -）

1
2
3
4
5


2 + 3 ^ 2 * 3 + 4

|---------------| : prec 1
 |-------| : prec 2
 |---| : prec 3

约定优先级的主要作用是在计算的时候，需要根据优先级来确定计算的顺序。

确定了优先级的问题，第二个问题是结合性，运算符的结合性其实也是确定的，例如加法是左结合的，这意味着 2 + 3 + 4 等价于 (2 + 3) + 4，而幂运算是右结合的，这意味着 2 ^ 3 ^ 4 实际上等价于 2 ^ (3 ^ 4)。

最后还需要注意一个问题，那就是子表达式，也就是用括号包裹的部分，这部分实际上是需要单独进行计算的，并且比运算符的优先级更高。

其实也很容易理解，比如 2 * (3 + 5) * 7，尽管 * 的优先级比 + 高，但是需要先计算括号内的部分。

确定了这些需求，我们再来看如何用 Rust 代码来进行实现。

首先我们需要将表达式进行解析，也就是词法分析的阶段，将一个表达式解析为不同的 Token，下面是约定的几种 Token：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Token 表示，数字、运算符号、括号
#[derive(Debug, Clone, Copy)]
enum Token {
 Number(i32),
 Plus, // 加
 Minus, // 减
 Multiply, // 乘
 Divide, // 除
 Power, // 幂
 LeftParen, // 左括号
 RightParen, // 右括号
}

然后定义了一个 Tokenizer 结构体，主要是利用 Peekable 接口将表达式解析为不同的 Token：

1
2
3
4
5


// 将一个算术表达式解析成连续的 Token
// 并通过 Iterator 返回，也可以通过 Peekable 接口获取
struct Tokenizer<'a> {
 tokens: Peekable<Chars<'a>>,
}

然后自定义实现了一个 Iterator，让解析后的 Token 可以通过迭代器进行返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


impl<'a> Iterator for Tokenizer<'a> {
 type Item = Token;

 fn next(&mut self) -> Option<Self::Item> {
 // 消除前面的空格
 self.consume_whitespace();
 // 解析当前位置的 Token 类型
 match self.tokens.peek() {
 Some(c) if c.is_numeric() => self.scan_number(),
 Some(_) => self.scan_operator(),
 None => return None,
 }
 }
}

假如我们的表达式是 2 + 3 ^ 2 * 3 + 4，实际上解析后的 Token 就是：

1
2
3
4
5
6
7
8
9


Token::Number(2)
Token::Plus
Token::Number(3)
Token::Power
Token::Number(2)
Token::Multiply
Token::Number(3)
Token::Plus
Token::Number(4)

拿到 Token 之后，进入到了语法分析的阶段，需要根据每个表达式的含义，以及其优先级，计算对应的结果。

首先定义一个方法，计算单个 Token 以及子表达式，这只存在两种情况，分别是 Number 这个 Token，以及带括号的子表达式。

 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


fn compute_atom(&mut self) -> Result<i32> {
 match self.iter.peek() {
 // 如果是数字的话，直接返回
 Some(Token::Number(n)) => {
 let val = *n;
 self.iter.next();
 return Ok(val);
 }
 // 如果是左括号的话，递归计算括号内的值
 Some(Token::LeftParen) => {
 self.iter.next();
 let result = self.compute_expr(1)?;
 match self.iter.next() {
 Some(Token::RightParen) => (),
 _ => return Err(ExprError::Parse("Unexpected character".into())),
 }
 return Ok(result);
 }
 _ => {
 return Err(ExprError::Parse(
 "Expecting a number or left parenthesis".into(),
 ))
 }
 }
 }

这里其实比较好理解，如果是 Number 直接返回，如果是子表达式，则重新调用计算表达式的方法进行计算。

然后是另一个核心的方法计算表达式：

 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


fn compute_expr(&mut self, min_prec: i32) -> Result<i32> {
 // 计算第一个 Token
 let mut atom_lhs = self.compute_atom()?;

 loop {
 let cur_token = self.iter.peek();
 if cur_token.is_none() {
 break;
 }
 let token = *cur_token.unwrap();

 // 1. Token 一定是运算符
 // 2. Token 的优先级必须大于等于 min_prec
 if !token.is_operator() || token.precedence() < min_prec {
 break;
 }

 let mut next_prec = token.precedence();
 if token.assoc() == ASSOC_LEFT {
 next_prec += 1;
 }

 self.iter.next();

 // 递归计算右边的表达式
 let atom_rhs = self.compute_expr(next_prec)?;

 // 得到了两边的值，进行计算
 match token.compute(atom_lhs, atom_rhs) {
 Some(res) => atom_lhs = res,
 None => return Err(ExprError::Parse("Unexpected expr".into())),
 }
 }
 Ok(atom_lhs)
}

这个方法中核心的逻辑可以分几个步骤来理解：

一是使用了 min_prec 参数控制当前层级的优先级，如果表达式的优先级小于 min_prec 则直接跳出循环，返回当前的值。

比如 2 * 3 + 4，* 会先解析到，然后 + 运算符的优先级明显比 * 更低，会直接返回当前值 3。

二是如果运算符的结合性是左边的话，则下一次迭代的 min_prec 需要递增。

比如表达式是 2 * 3 * 4，解析到第二个 * 的时候，* 的优先级本来是 2，但它是左结合的，所以此时 min_prec 是 3，会直接跳出循环，所以实际上会先计算 2 * 3。

最后是得到了运算符两边的值，就可以进行计算了，这里是根据运算符的实际含义来进行的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 根据当前运算符进行计算
fn compute(&self, l: i32, r: i32) -> Option<i32> {
 match self {
 Token::Plus => Some(l + r),
 Token::Minus => Some(l - r),
 Token::Multiply => Some(l * r),
 Token::Divide => Some(l / r),
 Token::Power => Some(l.pow(r as u32)),
 _ => None,
 }
}

这就是根据运算符优先级来进行表达式计算的整体流程，这个算法看起来还是非常简洁优雅的，非常巧妙的利用优先级来解决运算的顺序和结合等问题。

完整的代码也只有 200 多行，比较适合用来练手，通过这个项目，可以学习到：

一个优雅、简洁的表达式计算的算法
解决类似写一个计算器的面试问题
Rust 基础数据类型、枚举、结构体基本用法
函数、递归
match 表达式
自定义 Result 错误处理
迭代器的常见用法 next、peekable 等
自定义迭代器
Option 使用

最后附上项目地址： https://github.com/rosedblabs/rust-practice 对你有帮助的话，欢迎给个 star ⭐️ 哦！

Rust 练手项目 1 - mini-bitcask

Mon, 29 Apr 2024 10:51:56 +0800

之前写过一个 Go 语言的 mini-bitcask，实现了一个基于 bitcask 存储模型的极简 KV 存储引擎。可以结合之前的文章食用：https://mp.weixin.qq.com/s/s8s6VtqwdyjthR6EtuhnUA

这次重新用 Rust 实现了一个版本，代码量和之前的差不多，包含了常用的方法，例如 Set、Get、Delete、Scan、PrefixScan、Merge。

项目地址：https://github.com/rosedblabs/rust-practice/tree/main/mini-bitcask-rs

Set

1
2
3
4
5
6
7
8
9


pub fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
 let (offset, len) = self.log.write_entry(key, Some(&value))?;
 let value_len = value.len() as u32;
 self.keydir.insert(
 key.to_vec(),
 (offset + len as u64 - value_len as u64, value_len),
 );
 Ok(())
}

Set 逻辑比较直观简洁，写入磁盘日志，并且更新内存索引结构。

Get

Get 则是先从内存中获取索引，再从磁盘中获取 Value。

1
2
3
4
5
6
7
8


pub fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
 if let Some((value_pos, value_len)) = self.keydir.get(key) {
 let val = self.log.read_value(*value_pos, *value_len)?;
 Ok(Some(val))
 } else {
 Ok(None)
 }
}

Delete

delete 的逻辑和 Set 类似，只是写入了一个空的值，并且从内存中对应的 key 移除。

1
2
3
4
5


pub fn delete(&mut self, key: &[u8]) -> Result<()> {
 self.log.write_entry(key, None)?;
 self.keydir.remove(key);
 Ok(())
}

Scan

scan 功能主要借助了 Rust 自带的内存数据结构 BTreeMap 的迭代器进行实现，非常简洁和方便。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


impl<'a> Iterator for ScanIterator<'a> {
 type Item = Result<(Vec<u8>, Vec<u8>)>;

 fn next(&mut self) -> Option<Self::Item> {
 self.inner.next().map(|item| self.map(item))
 }
}

impl<'a> DoubleEndedIterator for ScanIterator<'a> {
 fn next_back(&mut self) -> Option<Self::Item> {
 self.inner.next_back().map(|item| self.map(item))
 }
}

Merge

merge 的逻辑其实也比较简单，将内存中的数据全部重写，并且替换旧的文件即可。

 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


pub fn merge(&mut self) -> Result<()> {
 // 创建一个新的临时用于用于写入
 let mut merge_path = self.log.path.clone();
 merge_path.set_extension(MERGE_FILE_EXT);

 let mut new_log = Log::new(merge_path)?;
 let mut new_keydir = KeyDir::new();

 // 重写数据
 for (key, (value_pos, value_len)) in self.keydir.iter() {
 let value = self.log.read_value(*value_pos, *value_len)?;
 let (offset, len) = new_log.write_entry(key, Some(&value))?;
 new_keydir.insert(
 key.clone(),
 (offset + len as u64 - *value_len as u64, *value_len),
 );
 }

 // 重写完成，重命名文件
 std::fs::rename(new_log.path, self.log.path.clone())?;

 new_log.path = self.log.path.clone();
 // 替换现在的
 self.log = new_log;
 self.keydir = new_keydir;

 Ok(())
}

通过这个简单的项目，可以学习到 Rust 的大多数基础语法，例如：

数据类型，数组、整型等
match 表达式
函数
结构体
错误处理
迭代器 Iterator 和 DoubleEndedIterator
文件读写操作
BufWriter 和 BufReader
单元测试撰写