Fred Hors's questions

因为这是一个高调用函数，如果我const QUERY在里面或外面声明有什么区别吗fn insert()？

impl Player {
    pub async fn insert(
        db: sqlx::PgConnection,
        input: &InputPlayer,
    ) -> Result<Self> {
        const QUERY: &str = r#"INSERT INTO "player" ("team_id", "id", "other_fields") VALUES ($1, $2, $3, $4, $5, $6, $7)"#;

        let result = sqlx::query_as::<_, Self>(QUERY)
            .bind(input.team_id())
            .bind(input.id())
            .bind(input.other())
            .bind(input.other())
            .bind(input.other())
            .bind(input.other())
            .fetch_one(db)
            .await?;

        Ok(result)
    }
}

我尝试过：

let searchText = $derived(debounce((typedText) => typedText, 2000)(typedText));

但searchText沒有分配！

1. $derived带有: 的复制品searchText未被指定。

2. 复现$effect()：searchText分配根本没有去抖动。

如果可以通过事务或直接连接来调用函数（因此它应该从那里启动一个新事务因为它需要一个新事务）您建议使用什么？

示例代码：

async fn find_player_id_and_assign_goal(
    &self,
    db: Option<&mut sqlx::PgConnection>,
    id: &str,
    team_id: &str,
) -> Result<String, Error> {
    let mut tx = None;

    let db = match db {
        Some(db) => {
            // I need to detect if `db` here is already a transaction or not, in which case I should start a new one:
            db
        },
        None => &mut *tx.insert(self.pool.begin().await?),
    };

    let _ = self.team_service.find_team_id(Some(db), team_id).await?;

    let player_id = self.repo.find_player_id(Some(db), id).await?;

    self.goal_service.assign_to_player(Some(db), id).await?;

    if let Some(tx) = tx {
        tx.commit().await?;
    }

    Ok(player_id)
}

这可行，但我只有一个问题：

如果Some(db) => db我需要检测我们是否已经处于交易中（如果db是的话）。如果没有，我应该开始一个新的。

您认为有没有更好的方法来实现这一目标？

在下面的代码中我收到此错误：

error[E0599]: no method named `commit` found for mutable reference `&mut sqlx::PgConnection` in the current scope
   --> src/main.rs:103:12
    |
103 |         db.commit().await?;
    |            ^^^^^^ method not found in `&mut PgConnection`

db如果是，我需要提交，None因为我正在开始一个新的交易：&mut self.pool.begin().await?。

可以用作db: Option<&mut sqlx::PgConnection>参数类型吗？还是我应该使用其他东西，例如Acquire特征？

Rust Playground 上的代码

pub async fn find_player_id(
    &self,
    db: Option<&mut sqlx::PgConnection>,
    id: &str,
    team_id: &str,
) -> Result<String, Error> {
    let db = match db {
        Some(db) => db,
        None => &mut self.pool.begin().await?,
    };

    let _ = self.team_service.find_team_id(Some(db), team_id).await?;

    let player_id = self.repo.find_player_id(Some(db), id).await?;

    db.commit().await?;

    Ok(player_id)
}

更新：

SO 上的某个人关闭了这个问题，因为他们认为这与“为什么我需要导入特征才能使用它为某种类型定义的方法？”重复。

我认为不是。请在采取行动之前先阅读问题。

这个错误是什么意思？

再生产

error[E0308]: mismatched types
  --> src/main.rs:50:35
   |
50 |           PaymentType::InvoiceIn => InvoiceIn {
   |  ___________________________________^
51 | |             name: "Invoice 1".to_string(),
52 | |             payed: false,
53 | |         },
   | |_________^ expected `dyn Payable`, found `InvoiceIn`
   |
   = note: expected trait object `dyn Payable`
                    found struct `InvoiceIn`
   = help: `InvoiceIn` implements `Payable` so you could box the found value and coerce it to the trait object `Box<dyn Payable>`, you will have to change the expected type as well

For more information about this error, try `rustc --explain E0308`.

代码：

trait Payable {
    fn toggle_payed(&mut self);
}

enum PaymentType {
    InvoiceOut,
    InvoiceIn,
}

struct Payment {
    r#type: PaymentType,
}

struct InvoiceOut {
    name: String,
    payed: bool,
}

impl Payable for InvoiceOut {
    fn toggle_payed(&mut self) {
        self.payed = !self.payed
    }
}

struct InvoiceIn {
    name: String,
    payed: bool,
}

impl Payable for InvoiceIn {
    fn toggle_payed(&mut self) {
        self.payed = !self.payed
    }
}

fn save_invoice_in(invoice: &InvoiceIn) {
    println!("{}", invoice.name)
}

fn save_invoice_out(invoice: &InvoiceOut) {
    println!("{}", invoice.name)
}

fn main() {
    let payment = Payment {
        r#type: PaymentType::InvoiceOut, // This comes from user!
    };

    let payable: dyn Payable = match payment.r#type {
        PaymentType::InvoiceIn => InvoiceIn {
            name: "Invoice 1".to_string(),
            payed: false,
        },
        PaymentType::InvoiceOut => InvoiceOut {
            name: "Invoice 2".to_string(),
            payed: false,
        },
    };

    // Do something else with payable here

    payable.toggle_payed();

    // Do something else with payable here

    match payment.r#type {
        PaymentType::InvoiceIn => save_invoice_in(&payable),
        PaymentType::InvoiceOut => save_invoice_out(&payable),
    };
}

我对此失去了理智（因为我不是一个非常有逻辑的人）。

铁锈游乐场

我无法更改数据部分。

从下面的代码返回的字符串A = 1 AND (B = 2 OR C = 3 OR D = 4 OR )不是我需要的（A = 1 AND (B = 2 OR C = 3 OR D = 4)）。

我不明白的是如何避免最后一个“OR”。

我该如何修复以下代码？

enum Token {
    Str(&'static str),
    Value(&'static str),
    StartGroup(&'static str),
    EndGroup,
}

fn main() {
    let data: Vec<Vec<Token>> = vec![
        vec![Token::Str("A = "), Token::Value("1")],
        vec![Token::Str(" AND ("), Token::StartGroup(" OR ")],
        vec![Token::Str("B = "), Token::Value("2")],
        vec![Token::Str("C = "), Token::Value("3")],
        vec![Token::Str("D = "), Token::Value("4")],
        vec![Token::EndGroup, Token::Str(")")],
    ];

    let result = construct_string(data);

    assert_eq!("A = 1 AND (B = 2 OR C = 3 OR D = 4)", result);
}

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();

    let mut current = String::new();
    let mut next = String::new();

    for token in tokens {
        for part in token {
            match part {
                Token::Str(str) => {
                    result.push_str(str);
                }
                Token::Value(val) => {
                    result.push_str(val);
                }
                Token::StartGroup(group) => {
                    next = group.to_string();
                }
                Token::EndGroup => {
                    current = String::new();
                    next = String::new();
                }
            }
        }

        if !current.is_empty() {
            result.push_str(&current);
        }

        current = next.to_string();
    }

    result
}

我们在 SvelteKit 应用程序的多个位置使用 EventSource，如下所示：

<script>
  import { onDestroy } from 'svelte';
  import { customEventSource } from '$lib/events';

  const callback = (event: MessageEvent) => {
    console.log('event:', event);
  };

  customEventSource.addEventListener('message', callback);

  onDestroy(() => {
    customEventSource.removeEventListener('message', callback);
  });
</script>

正如你所看到的，每次都有很多东西要写。

难道没有一种神奇的方法（正如 Svelte 教给我们的那样）来简化吗？

特别是这样我就不必每次都手动调用？onDestroy