Jack Deeth's questions

我对于如何优雅且轻松地解析消息感到非常印象serde深刻serde_json：

{"msg_type": "asauce", "aaa": 3, "bbb": 14}
{"msg_type": "csyrup", "ccc": 10, "ddd": 20}

// this works!
#[derive(serde::Deserialize, PartialEq, Debug)]
struct AppleSauce {
    aaa: u8,
    bbb: u8,
}

#[derive(serde::Deserialize, PartialEq, Debug)]
struct ChocolateSyrup {
    ccc: u8,
    ddd: u8,
}

#[derive(serde::Deserialize, PartialEq, Debug)]
#[serde(tag = "msg_type")]
enum Sauce {
    #[serde(rename = "asauce")]
    AppleSauce(AppleSauce),
    #[serde(rename = "csyrup")]
    ChocolateSyrup(ChocolateSyrup),
}

#[test]
fn deserialise_inner_applesauce() {
    let json = r#"{"msg_type": "asauce", "aaa": 3, "bbb": 14}"#;
    let expected = AppleSauce { aaa: 3, bbb: 14 };
    let sauce: Sauce = serde_json::from_str(json).unwrap();
    assert_eq!(sauce, Sauce::AppleSauce(expected));
}

但是我的消息有一个父键，我想摆脱它：

{"boilerplate": {"msg_type": "asauce", "aaa": 3, "bbb": 14}}
{"boilerplate": {"msg_type": "csyrup", "ccc": 10, "ddd": 20}}

目前我已经实现了一个from_str方法：

impl Sauce {
    pub fn from_str(msg: &str) -> Option<Sauce> {
        let outer: serde_json::Value = serde_json::from_str(msg).ok()?;
        let inner = &outer["boilerplate"];
        serde_json::from_value(inner.clone()).ok()
    }
}

#[test]
fn deserialise_boilerplate_applesauce_with_helper_method() {
    let json = r#"{"boilerplate": {"msg_type": "asauce", "aaa": 3, "bbb": 14}}"#;
    let expected = AppleSauce { aaa: 3, bbb: 14 };
    let sauce = Sauce::from_str(json).unwrap(); // not serde_json::from_str :(
    assert_eq!(sauce, Sauce::AppleSauce(expected));
}

有没有办法用 serde 属性来省略父键，并消除自定义from_str方法？

我只需要反序列化这些消息（但从我看到的 serde 来看，它可能也会免费序列化）。

如何获得特定类型的值SELECT INTO？NULL

例如，有选择地备份数据并合并一个DateFixed将NULL通过以下方式启动并稍后填充的列SysUtcDateTime()：

SELECT
    Thing.Id,
    Thing.SomeValue AS [BadValue],
    NULL AS [DateFixed]
INTO ThingValueFixBackup
FROM Thing
WHERE SomeValue IS WRONG SOMEHOW;

我如何编写一个语法来表达一组可以以任意顺序出现零次或一次的项目？

例如A B C有效、A C有效、C B A有效、A A B无效、A B A无效。

此规则强制每个元素为零个或一个，但也强制设置顺序：

rule_1: A? B? C?

这允许任何顺序，但也允许每个顺序多个：

rule_2: (A | B | C)*

这是使用 Python 的 Lark 解析器 - 我不确定这个问题是否应该被标记[lark-parser]？