增量查询

这个库原本不是库。它始于我想了解rustc的查询系统是如何工作的，然后我决定自己实现一个与之非常相似的系统。结果，我对它非常满意，并开始对其进行文档化，现在它就是这个库。

注意：这个crate使用了一个nightly特性：#![feature)]，因此它目前只能在nightly上运行。

这是什么？

这个库的核心是查询的概念。就像在rustc中一样。查询就像一个普通函数，你可以像调用普通函数一样调用它。只是函数的参数和返回类型有一些限制。然而，当你调用它们时，与普通函数相比会发生更多的事情。

第一次，查询中的代码按正常方式运行，但输入和输出被缓存并散列。此外，这个查询内部调用的任何其他查询（及其递归调用）都会被跟踪。在后续调用相同查询且具有相同输入的情况下，将返回缓存的查询结果。

这个解释可能让人觉得这只是执行记忆化。然而，记忆化的函数必须是纯函数！否则，我们无法仅通过查看输入来判断输出是否相同。

相反，使用查询，函数不必是纯函数。纯函数仍然非常好！我们不必那么频繁地重新运行它们。然而，如果一个不纯的查询改变了它的结果，系统会注意到这一点，并且在需要其结果时，任何（纯）依赖于它的查询都会自动重新运行。此外，当一个不纯的查询重新运行，并且依赖的查询链更新，但我们注意到在任何时候结果都没有改变，那么重新运行的链就会被停止，以尽可能节省计算时间。

您可能会发现增量编译对这种查询非常有用。一个查询读取一个文件，另一个解析AST，还有另一个进行部分类型检查。Rustc有数百个查询。如果一个文件没有更改，读取文件查询会注意到。那么我们就不必再次运行解析查询，真是太棒了！类型检查可能依赖于多个文件，但如果它所依赖的文件没有更改，我们也不必重新运行它。

目前，这个库还不支持将查询缓存序列化到文件。将来可能会。如果它做到了，缓存将更加有用。

以下部分专门介绍这个库。即使您只对它的工作原理感兴趣，阅读它也可能很有用，这样您就能理解示例中使用的符号。

如何使用它？

查询的定义几乎像正常函数一样。唯一的限制是它们必须用define_query!宏调用括起来。

use incremental_query::{Context, define_query};
# use rand::{thread_rng, Rng};

define_query! {
    /// This is a query that retuns a random number.
    #[rerun(always)]
    fn random<'cx>(_cx: &Context<'cx>) -> u64 {
        thread_rng().gen_range(0..u64::MAX)
    }
}

注意：查询的签名有一些限制：函数必须有一个生命周期参数。此外，第一个参数必须是Context的引用。任何输入必须是实现了QueryParameter的某些T的引用。

此外，尽管查询的输入是引用，但调用查询时必须提供相应的所有者值，而不是引用。所有者值存储在缓存中，而函数则获取现在在缓存中的这些值的引用。

要调用查询，现在您可以直接调用它

use incremental_query::{Context, Storage};
# use incremental_query::define_query;
# use rand::{thread_rng, Rng};
# 
# define_query! {
#     /// This is a query that retuns a random number.
#     #[rerun(always)]
#     fn random<'cx>(_cx: &Context<'cx>) -> u64 {
#         thread_rng().gen_range(0..u64::MAX)
#     }
# }
#
// instantiate a storage object that holds the cached data
let storage = Storage::new();
// create a context with it
let cx = Context::new(&storage);

// call the query
println!("{}", random(&cx));

调用查询时，您将获得声明返回类型的引用。这同样是因为实际的返回值现在存储在缓存中。您只是得到该缓存的一个引用。

函数纯度和代数

您可能已经注意到了在上述定义的查询上的#[rerun(always)]属性。

没有这个属性，查询被期望是纯的。这意味着没有属性，查询不应从文件中读取，或生成随机数，或调用可能执行这些操作的另一个函数。然而，它仍然可以调用标记为不纯的其他查询。

查询可以通过两种方式标记为不纯。一种是通过#[rerun(always)]，这将永远不假设其结果保持不变（实际上，库甚至不会缓存输出）。这些可能会对性能产生很大的影响，因此有一个替代方案：#[rerun(generation)]。

上下文有一个代计数器。它从0开始，您可以使用Context::next_generation来更改它。每个缓存的查询也会存储它是在哪个代被缓存的。代查询将像往常一样被缓存，但当代号更改时，它们将重新运行。

# use incremental_query::{Context, Storage, define_query};
define_query! {
    #[rerun(generation)]
    fn boolean_query<'cx>(_cx: &Context<'cx>) -> bool {
        // first return true, then in the 2nd generation false
#       true
    }

    fn one<'cx>(_cx: &Context<'cx>) -> u64 {
        1
    }
    fn two<'cx>(_cx: &Context<'cx>) -> u64 {
        2
    }

    fn conditional<'cx>(cx: &Context<'cx>, ) -> u64 {
        if *boolean_query(cx) {
            *one(cx)
        } else {
            *two(cx)
        }
    }
}

let storage = Storage::new();
let cx = Context::new(&storage);

conditional(&cx);
conditional(&cx);
conditional(&cx);
cx.next_generation();
conditional(&cx);
conditional(&cx);
conditional(&cx);

# use incremental_query::{Context, Storage, define_query};
define_query! {
    #[rerun(generation)]
    fn boolean_query<'cx>(_cx: &Context<'cx>) -> bool {
        // first return true, then in the 2nd generation false
#       true
    }

    fn one<'cx>(_cx: &Context<'cx>) -> u64 {
        1
    }
    fn two<'cx>(_cx: &Context<'cx>) -> u64 {
        2
    }

    fn conditional<'cx>(cx: &Context<'cx>, ) -> u64 {
        if *boolean_query(cx) {
            *one(cx)
        } else {
            *two(cx)
        }
    }
}

let storage = Storage::new();
let cx = Context::new(&storage);

conditional(&cx);
cx.next_generation();
conditional(&cx);