mmdts's questions

Quero escrever uma função com a assinatura:

fn delete_direct(pool: &Pool, q: T);

Essa função pode ser usada para uma tabela arbitrária:

use crate::schema::users::dsl::*;
delete_direct(&pool, users.filter(name.eq("Harry")))

Para substituir o uso:

use crate::schema::users::dsl::*;
let mut conn = &pool.get().expect("Failed to get database connection");
diesel::delete(users.filter(name.eq("Harry")))
    .execute(&mut conn)
    .expect("Failed to run the delete query you specified");

poolaqui é do tipo diesel::r2d2::Pool<ConnectionManager<PgConnection>>, que é apelidado de type Poolpor questões de brevidade.

Acabei ficando com essa função:

    fn delete_direct<T>(pool: &Pool, q: T) where
        T: diesel::query_builder::IntoUpdateTarget,
        <T as diesel::associations::HasTable>::Table: diesel::query_builder::QueryId + 'static,
        <T as diesel::query_builder::IntoUpdateTarget>::WhereClause: diesel::query_builder::QueryId + diesel::query_builder::QueryFragment<diesel::pg::Pg>,
        <<T as diesel::associations::HasTable>::Table as QuerySource>::FromClause: diesel::query_builder::QueryFragment<diesel::pg::Pg>,
    {
        let mut conn = pool.get().expect("Failed to get database connection");
        diesel::delete(q)
            .execute(&mut conn)
            .expect("Failed to run the delete query you specified");
    }

Com a ajuda do compilador para satisfazer todas as restrições de características que o diesel espera que estejam presentes.

Isso parece complexo e parece que estou esquecendo de algo óbvio. Estou esquecendo de algo óbvio ou essa é a maneira mais simples de implementar essa função?

Às vezes, preciso me encontrar truncando uma string para caber em um número específico de bytes. O problema de fazer isso em Go é que se você fizer isso s[:1_000_000], dado que sé uma string utf-8 válida , você pode acabar cortando bem no meio de um ponto de código utf-8 que pode ter de 1 a 4 bytes de comprimento, deixando você com uma runa inválida.

Algumas pessoas (e os LLMs treinados em suas ideias) tentariam usar utf8.ValidString, ou for i := range sfazer isso, pois ambos garantiriam uma runa válida. No entanto, essas pessoas estariam fazendo uma tarefa de tempo constante em tempo linear.

Eu escrevi uma função de truncamento seguro de tempo constante:

import "unicode/utf8"

// UTF8SafeTruncateNBytes Truncates a **valid** utf-8 string `s` to `n` bytes (not n UTF-8 characters),
// ensuring that the string is not truncated in the middle of a UTF-8 character.
func UTF8SafeTruncateNBytes(s string, n int) string {
    if n >= len(s) {
        return s
    }
    for i := n; i >= n-3 && i >= 0; i-- {
        if utf8.RuneStart(s[i]) {
            return s[:i]
            // Edit: This was:
            //if r, size := utf8.DecodeRuneInString(s[i:]); r != utf8.RuneError {
            //  return s[:i+size]
            //}
            // but got fixed because of the picked solution. This implementation is now correct,
            // and, in fact, equivalent, except that it only checks one byte instead of backing up forever.
        }
    }

    // Fallback in the case that the user lied, and passed a string that is not a valid utf-8 string.
    // It would be wise to return an error or "" here if this is a standard-library
    // function to allow the user to check for it.
    return s[:n]
}

As perguntas são as seguintes:

1. Isso vai funcionar ou há algum caso especial que deixei passar?
2. Existe uma maneira melhor e mais eloquente de fazer isso que eu esqueci, ou uma função de biblioteca padrão que já faz isso?
3. Por que isso não é uma função de biblioteca padrão em "unicode/utf8"? Parece que é o nível certo de frequência de uso e complexidade para garantir ter uma função de biblioteca padrão. Devo propor isso na página de problemas deles ?