小编Inc*_*ete的帖子

我使用 git-lfs 来跟踪大文件，设置是：

.
??? ...
??? ...
??? large-files
??? ...
??? ...
??? .git

外部存储安装在 上large-files，所有大文件都放在这里。

这个设置的问题是，有一个.git/lfs目录，它使用与 相同数量的磁盘空间large-files，因为我永远不会从 中删除large-files，而我的 SSD（工作树所在的位置）的容量小于外部存储，.git/lfs将超过我的SSD的容量。

有没有办法在.git/lfs不将其移动到外部存储的情况下减小它的大小？（将.git或整个工作树放到外部存储不是一种选择，因为外部存储并不总是可用的）

上下文：rust、sqlx 库

问题：如何在不丢失类型检查的情况下从较小的部分组成类似的查询？

macro_rules! select {
  () => {"select col from tab"}
}

macro_rules! guard1 {
  () => {"where col > 1"}
}

macro_rules! guard2 {
  () => {"where col > 2"}
}

let mut conn = get_pg_connection_from_somewhere();

if some_condition() {
  sqlx::query!(select!() + guard1!()).fetch_all(&mut conn).await?;
} else {
  sqlx::query!(select!() + guard2!()).fetch_all(&mut conn).await?;
}

文档说：

查询必须是字符串文字，或使用 + 连接字符串文字（对于宏生成的查询很有用），否则它无法进行内省（因此不能是动态的或另一个宏的结果）。

你可以看到它说“对于宏生成的查询有用”（尽管后来“不能是另一个宏的结果”）

我想解决的问题是，根据条件，我想运行不同但相似的（例如它们都具有相同的列）查询，并且我想从较小的可重用部分组成查询[

在python中，在两个s之间建立单向通信的惯用方法是什么threading.Thread，将它们称为 threada和 thread b。

a是生产者，它不断地产生价值以供b消费。

b是消费者，它读取 生成的一个值a，用协程处理该值，然后读取下一个值，依此类推。

插图：

q = very_magic_queue.Queue()


def worker_of_a(q):
    while True:
        q.put(1)
        time.sleep(1)

a = threading.Thread(worker_of_a, args=(q,))
a.start()


async def loop(q):
    while True:
        # v must be processed in the same order as they are produced
        v = await q.get()
        print(v)

async def foo():
    pass

async def b_main(q):
    loop_fut = asyncio.ensure_future(loop(q))
    foo_fut = asyncio.ensure_future(foo())
    _ = await asyncio.wait([loop_fut, foo_fut], ...)
    # blah blah blah

def …

在 TensorFlow Python API 中，activationkwarg的默认值tf.layers.dense是None，然后在文档中它说：

激活：要使用的激活函数。如果您未指定任何内容，则不会应用任何激活（即“线性”激活：a(x) = x）。

为什么在定义函数时不直接使用恒等函数作为默认值？像这样：

def dense(..., activation=lambda x: x, ...):
    pass

这样您就不必担心文档和代码之间的不一致。

这（使用 None 表示默认函数）只是一种编码风格，还是使用函数作为 kw 参数的默认值有一些警告？

它不是为了避免不必要的函数调用，因为仍然会创建和调用标识函数，甚至None将其传递给activation. 此外，由于这发生在图构建时，因此没有必要进行这样的优化 - 假设这确实是一种优化。

更正：

正如@y-luo 所指出的，该tf实现实际上并未创建标识函数。但tf.keras实施确实如此。

我有一个类型的函数

f: fn(x: SomeType, y: Arc<()>) -> ISupposeTheReturnTypeDoesNotMatter

编译时（有或没有优化），会y被优化掉吗？

的目的y是限制 的运行实例的数量f，如果y被引用太多次， 的调用者f将不会调用，f直到 的引用计数y变低。

编辑：澄清我的意图

目的是控制正在运行的http请求的数量（由上面表示f），伪代码如下所示：

let y = Arc::new(());
let all_jobs_to_be_done = vector_of_many_jobs;
loop {
    while y.strong_count() < some_predefined_limit {
        // we have some free slots, fill them up with instances of f,
        // f is passed with a clone of y,
        // so that the running of f would increase the ref count, …

我已经create materialized view运行了好几天了，有没有办法知道查询的进度？

任何指标都可以，例如完成百分比、剩余时间、剩余工作消耗的磁盘空间。我主要关心磁盘空间的使用情况，我可以从其他指标（例如完成百分比）中得到粗略的估计。

PG版本是12.2

消费者（手动ack模式）可以长时间保留ack消息吗？

用例是进程（消费者）处理来自队列的消息（ack 设置为手动），处理时间较长（几分钟到几小时），处理完成后发回 ack。

RabbitMQ 服务器/客户端是否旨在处理这种使用模式？

git commit哈希表示特定时间的项目，Perforce中的等效概念（表示特定时间整个仓库的快照的“事物”）是什么？

#[derive(Deserialize)]
struct S<'d, T>
  where T: Deserialize<'d>
{
  foo: T,
  other_field: String
}

上面的代码无法编译，抱怨未使用的生命周期参数，但如果我删除它，Deserialize就会丢失生命周期。

不使用幻像标记或 可以使上述代码正确吗DeserializeOwned？