Fred Hors's questions

Como esta é uma função de alta chamada, há alguma diferença se eu declarar const QUERYdentro ou fora dela 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)
    }
}

Eu tentei com:

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

Mas searchTextnão está atribuído!

1. A reprodução com$derived : searchTextnão está atribuída.

2. A reprodução com$effect() : searchTextatribuição não é rejeitada de forma alguma.

Se uma função pode ser chamada com uma transação ou uma conexão direta (e portanto deve iniciar uma nova transação a partir daí porque precisa de uma), o que você sugere usar?

Código de exemplo:

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)
}

Isso pode funcionar, mas só tenho um problema:

Se Some(db) => dbeu precisar detectar se já estamos em uma transação (se dbhouver). Se não, eu deveria começar um novo.

Você acha que existe uma maneira melhor de fazer isso?

No código abaixo estou recebendo este erro:

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`

Preciso confirmar se dbfor, Nonejá que estou iniciando uma nova transação com: &mut self.pool.begin().await?.

Não há problema em usar db: Option<&mut sqlx::PgConnection>como tipo de argumento ou devo usar outra coisa, como Acquiretrait?

Código no 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)
}

ATUALIZAR:

Alguém no SO fechou a questão porque acha que é uma duplicata de Por que preciso importar uma característica para usar os métodos que ela define para um tipo? .

Isso não é, eu acho. Por favor, leia a pergunta antes de agir.

O que esse erro significa?

Reprodução

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`.

Código:

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),
    };
}

Estou enlouquecendo com isso (porque não sou uma pessoa muito lógica).

Ferrugem Parque Infantil

Não consigo alterar a parte dos dados.

A string retornada do código abaixo é A = 1 AND (B = 2 OR C = 3 OR D = 4 OR )o que eu preciso ( A = 1 AND (B = 2 OR C = 3 OR D = 4)).

O que não entendo é como evitar o último “OU”.

Como posso corrigir o código abaixo?

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
}

Estamos usando o EventSource em vários lugares do aplicativo SvelteKit, assim:

<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>

Como você pode ver, há muito o que escrever a cada vez.

Não existe uma maneira mágica – como Svelte nos ensinou – de simplificar?

Principalmente para não precisar ligar manualmenteonDestroy todas as vezes?