TiKV Contributors day5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[2023/12/27 04:41:51.140 +08:00] [WARN] [event_listener.rs:127] ["detected rocksdb background error"] [err="Corruption: block checksum mismatch: stored = 2981909476, computed = 324654415, type = 1  in /data1/data/db/38457359.sst offset 8497742 size 3971"] [sst=/38457359.sst]

[2023/12/27 04:41:52.381 +08:00] [WARN] [store.rs:243] ["detected damaged regions overlapping damaged file ranges"] [id="{592132084, 442186929, 607655650}"]

[2023/12/27 04:42:01.909 +08:00] [FATAL] [lib.rs:509] ["Failed to recover sst file: /38457359.sst, error: file still exists, it may belong L0, damaged_files:[name:\"/38457359.sst\", smallest_key:[122, 116, 128, 0, 
             at /home/jenkins/agent/workspace/build-common/go/src/github.com/pingcap/tikv/components/tikv_util/src/lib.rs:508:18
   1: <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call
             at /rust/toolchains/nightly-2022-11-15-x86_64-unknown-linux-
   4: rust_begin_unwind

1
2
3
4
5
6
7
8

这很容易理解。我很感激

在这个句子中，"to understand" 作为形容词短语，用来说明 "This" 的特点，即 "This" 是容易理解的。这种结构在英语中很常见，不定式短语可以用作形容词，用来修饰名词或代词，提供关于它们的额外信息。


在英语中，"I appreciate it." 这句话中的 "it" 是一个代词，它用来指代前面提到的某个行为、事物或情况。虽然在某些语境下 "it" 可能看起来是多余的，但实际上它起到了明确指代的作用，帮助听者或读者理解说话者是在感激什么。

例如，如果有人帮助了你，你可能会说 "Thank you for your help. I appreciate it." 在这个例子中，"it" 指代的是 "your help"，即你感激的是对方的帮助。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

What we want to end up with, for the sake of compile time, and also simply maintaining abstraction boundaries, is one crate that defines what an engine is (its traits), and for each implemented engine, 
another crate that implements those traits. 

我们希望最终实现的是  一个库定义接口，另外一个库实现这个接口。确保代码的模块化和抽象化


That way the common code will build very fast, from there all the engines will build in parallel, and the implementation details of the engines can't leak into the common code or each other.


In other words…what you put up with, you end up with.
换句话说……你所忍受的，你最终会得到什么。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

 tests/integrations/raftstore/test_update_region_size.rs
// 定义闭包 `batch_put`，它接受一个可变引用的 `Cluster` 实例
// `Cluster` 是一个泛型结构体，其引擎类型为 `RocksEngine`，泛型参数 `T` 未指定
let batch_put = |cluster: &mut Cluster<RocksEngine, T>, mut start, end| {
    // 使用 while 循环直到 `start` 大于或等于 `end`
    while start < end {
        // 计算下一次迭代的 `start` 位置，但不超过 `end`，且不超过 `start + 50`
        let next = std::cmp::min(end, start + 50);
        
        // 使用 range 创建从 `start` 到 `next`（不包括 `next`）的序列
        // 然后使用 `map` 方法转换序列中的每个索引 `i`：
        // - 格式化字符串 "k{}" 和 "value{}" 为字节串，作为键和值
        // - 创建一个新的 `PutCommand`（假设的 `new_put_cmd` 函数）
        // 最后，使用 `collect` 将转换后的序列收集为集合
        let requests = (start..next)
            .map(|i| {
                new_put_cmd(
                    &format!("k{}", i).into_bytes(),
                    &format!("value{}", i).into_bytes(),
                )
            })
            .collect();
        //https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect
        
        // 调用 `cluster` 的 `batch_put` 方法执行批量插入：
        // - 第一个参数是起始键 "k{}" 的字节串
        // - 第二个参数是收集到的请求集合 `requests`
        // 使用 `unwrap` 处理可能的 `Result` 错误，假设我们确定它总是 `Ok`
        cluster
            .batch_put(&format!("k{}", start).into_bytes(), requests)
            .unwrap();
        
        // 更新 `start` 的值为 `next`，准备下一次循环
        start = next;
    }
};
rust 闭包（closure） 参数 | | 是什么和c++lamber表达式语法区别

在 Rust 中，闭包（closure）是一种匿名函数，可以捕获并使用其创建环境中的变量。闭包的参数列表使用竖线 | 来定义，这与函数定义中的圆括号 () 不同。Rust 中的闭包语法如下：

rust
let closure = |parameter1, parameter2, ...| {
    // 闭包体
};
这里的竖线 | 是 Rust 特有的语法，用于定义闭包的参数
c++
[capture list] (parameter list) -> return type { function body }
c++

捕获环境：

Rust 的闭包可以捕获外部环境中的变量，并且可以有多种捕获模式（如：移动、复制、引用等）。
C++ 的 lambda 表达式也可以捕获外部变量，但捕获方式（如：值捕获、引用捕获等）需要在 lambda 表达式的捕获子句中明确指定。