Início / coding / Perguntas / 79527176
Accepted
TeknoSenpai
Asked: 2025-03-22 17:08:20 +0800 CST

Erro na inserção com valores padrão no Exposed

  • 772

Sempre que tento criar e inserir um novo usuário na tabela Usuários (com o User.newmétodo DAO ou o Users.insertmétodo ), um campo de enumeração accountstatus que é descrito como não nulo, com um valor padrão, faz com que a inserção falhe a partir de null value in column "accountstatus" violates not-null constraint.

Aqui está o código para a definição da tabela e o DAO do usuário:

 object Users : UUIDTable() {
     val email = varchar("email", 255).uniqueIndex()
     val role = enumeration<Role>("role")
     val registrationDate =
         datetime("registrationDate").default(Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()))
     val disabledDate = datetime("disabledDate").nullable()
     val accountStatus = enumeration<AccountStatus>("accountStatus").default(AccountStatus.ACTIVE)
 
     enum class Role {
         PROFESSOR, STUDENT
     }
 
     enum class AccountStatus {
         ACTIVE, DISABLED
     }
 }

 class User(id: EntityID<UUID>) : UUIDEntity(id), UserData {
     companion object : UUIDEntityClass<User>(Users)
 
     override var email by Users.email
     override var role by Users.role
     override val registrationDate by Users.registrationDate
     override var disabledDate by Users.disabledDate
     override var accountStatus by Users.accountStatus
     val sessions by Session referrersOn Sessions.userId
 }

Aqui está o código que gera a exceção:

 // ...
 transaction {
     User.new {
         email = email /* logic omitted */
         role = role /* logic omitted */
     }
 }
database

1 respostas

  1. Best Answer

    Esse problema foi discutido no GitHub .

    Pergunta

    Para inserções, o Exposed preencherá (para colunas sem valor explícito) todas as inserções com padrões/nulos do objeto de tabela Exposed e não usará aquele definido na tabela real no banco de dados, deixando de fora a coluna na instrução de inserção.

    Isso tem alguns problemas:

    É impossível realmente executar um INSERT usando o valor padrão do banco de dados. Ou seja, ele pode não ser conhecido ou controlado por outra equipe. Tudo se resume a um requisito para manter o código sincronizado com o banco de dados, mas isso está em desacordo com serviços sempre ativos que, por definição, devem ter código novo e antigo em execução no banco de dados ao mesmo tempo.

    Um design mais flexível e menos opinativo envolveria:

    Use apenas .default() e .defaultExpression() para criação de tabelas. Abra para uso simultâneo de .clientDefault() (e .default()) que então serve como o padrão do aplicativo (é assim que eu sempre presumi que funcionava) em vez de ter .default() agindo como padrões de inserção de tabela e cliente. Não tenha um padrão implícito de NULL para colunas anuláveis. Este é um requisito para o primeiro marcador.

    Uma observação é que não estou falando sobre o Exposed Dao, mas sobre o plain query dsl. Olhando para o histórico do git, parece que esses padrões foram introduzidos como padrões opinativos para o dao, o que eu acho que faz muito mais sentido (além de ainda ser impossível optar por não usá-los). Eles se espalharam para o dsl, o que eu acho problemático, já que o dsl deve suportar todo (ou pelo menos o padrão) sql. Eu presumo que o comportamento atual pode ser movido uma camada acima no código dao para manter o comportamento do dao intacto.

    Talvez eu esteja disposto a fazer a maior parte do trabalho envolvido nisso, mas gostaria de confirmar se seria desejável ou não.

    Edição semelhante #345

    Responder

    Parece que o problema já foi resolvido, se entendi corretamente.

    Se o problema for que o Exposed exige agressivamente a definição de valores para todos os campos e não permite depender da geração de valores do lado do banco de dados, ele pode ser resolvido usando o método de coluna databaseGenerated() (e withDefinition() adicionalmente)

    Na verdade, no momento existem 3 maneiras (exemplos são feitos com PostgresDB):

    default()/defaultExpression() (personaliza a coluna DDL e é aplicado a instruções de inserção)

    object TestTable : IntIdTable("test") {
    val key = uuid("key")
        .default(UUID.fromString("a344698c-3c0d-46a7-9847-dc308665d9c8"))
}

TestTable.insert {  }

    SQL executado:

    CREATE TABLE IF NOT EXISTS test (
  id SERIAL PRIMARY KEY, 
  "key" uuid DEFAULT 'a344698c-3c0d-46a7-9847-dc308665d9c8' NOT NULL
)

INSERT INTO test ("key") VALUES ('a344698c-3c0d-46a7-9847-dc308665d9c8')

    clientDefault() (não afeta DDL):

    object TestTable : IntIdTable("test") {
  val key = uuid("key")
      .clientDefault { UUID.randomUUID() }
}

TestTable.insert {  }

    CREATE TABLE IF NOT EXISTS test (
  id SERIAL PRIMARY KEY, 
  "key" uuid NOT NULL
)

INSERT INTO test ("key") VALUES ('e69515f6-6bed-4c95-aa75-9c0ba7a0ac77')

    databaseGenerated().withDefinition() (esta variante modifica a coluna da tabela e o valor é ignorado para inserção)

    object TestTable : IntIdTable("test") {
    val key = uuid("key")
        .databaseGenerated()
        .withDefinition("DEFAULT gen_random_uuid()")
}

TestTable.insert {  }

    CREATE TABLE IF NOT EXISTS test (
  id SERIAL PRIMARY KEY, 
  "key" uuid DEFAULT gen_random_uuid() NOT NULL
)

INSERT INTO test  DEFAULT VALUES

    Olhando para essas variantes, é provável que os usuários fiquem confusos, porque há variantes para geração do lado do cliente, geração do lado do banco de dados e magic default() que se aplicam a ambos.

    Provavelmente não precisamos da variante default(), porque ela personalizou o DDL para gerar valores no lado do banco de dados, mas depois disso, de qualquer forma, coloca os mesmos valores nas consultas.

    Provavelmente seria melhor ter apenas duas opções (gerações do lado do cliente ou do lado do banco de dados) e métodos consistentes definidos como:

    • clienteGerado(valor)
    • clientGeneratedByExpression(expressão: )
    • banco de dados gerado()
    • databaseGeneratedByDefinition(definição)

    Acho que a pergunta mais interessante aqui: há algum caso de uso em que default() não pode ser substituído pelas opções clientDefault() / databaseGenerated()? Se não houver tais casos de uso, podemos marcar default() como obsoleto, pelo menos. @e5l @bog-walk o que você acha disso?

    De qualquer forma, são apenas algumas propostas de como torná-lo mais consistente. De acordo com a pergunta inicial do problema, parece-me que o problema desapareceu, se não, avise-me sobre isso.

    Resumo

    databaseGenerated().withDefinition()parece ser o que você está procurando.

    • 1

relate perguntas