Conectando com um transator

O Doobie é uma camada JDBC puramente funcional para Scala. Um Transactor[F] é a ponte entre os programas puros do Doobie e uma conexão real com o banco de dados.

Um Transactor sabe como adquirir uma Connection JDBC, executar seu programa dentro de uma transação e liberar os recursos com segurança.

Ele é parametrizado por um tipo de efeito F[_], como cats.effect.IO.

As consultas do Doobie são valores do tipo ConnectionIO[A]. Elas descrevem uma computação que precisa de uma conexão JDBC, mas ainda não é executada.

Você constrói esses programas de forma pura e depois os entrega a um Transactor para executá-los. Nada acessa o banco de dados até que você os execute.

O Transactor mais simples é Transactor.fromDriverManager. Ele abre uma conexão completamente nova para cada transação usando o DriverManager do JDBC.

Ele precisa do nome da classe do driver, da URL JDBC, do nome de usuário e da senha. É adequado para testes e scripts, mas não possui um conjunto de conexões.

Para executar um ConnectionIO, você chama .transact(xa). Isso produz um F[A], neste caso, um IO[A].

O Transactor envolve o programa em uma transação: confirma em caso de sucesso e desfaz em caso de falha, liberando a conexão de qualquer forma.

Em produção, você precisa de um conjunto de conexões. O Doobie inclui o HikariTransactor, desenvolvido sobre o HikariCP.

Ele é criado como um Resource, para que o conjunto seja encerrado corretamente. Você também passa um contexto de execução para as operações JDBC bloqueantes.

Um Transactor com agrupamento possui estado de longa duração: conexões abertas e threads em segundo plano. Resource[F, A] garante que a aquisição e a liberação sejam pareadas, mesmo em caso de erros ou cancelamento.

Normalmente, você constrói o Transactor uma vez na inicialização e o reutiliza durante todo o ciclo de vida da aplicação.

O HikariCP precisa de um ExecutionContext para aguardar conexões do conjunto. O Doobie fornece ExecutionContexts.fixedThreadPool para isso, que por sua vez é um Resource.

Manter esse conjunto separado do conjunto de computação impede que a aquisição bloqueante de conexões prive de recursos o trabalho limitado pela CPU.

Se você já tiver um javax.sql.DataSource configurado, por exemplo, uma instância ajustada do Hikari, envolva-o diretamente com Transactor.fromDataSource.

Isso é comum quando uma estrutura gerencia o conjunto e você quer apenas que o Doobie o utilize.

Uma verificação de integridade simples consiste em executar select 1 por meio do Transactor. Se houver retorno, o driver, a URL e as credenciais estarão funcionando.

Este é um bom primeiro passo antes de configurar consultas reais.

Um Transactor é construído a partir de interpretadores e de uma Strategy. A Strategy controla o que acontece em torno de cada transação: before, after, oops (em caso de erro) e always.

A estratégia padrão desativa a confirmação automática, confirma após o sucesso, desfaz em caso de erro e sempre fecha a conexão.

O Doobie pode registrar cada instrução, seus argumentos e o tempo de execução. As versões modernas associam um LogHandler[F] a cada consulta, em vez de a cada Transactor.

Isso é extremamente útil para identificar consultas lentas e verificar a associação de parâmetros em produção.

Teste sua compreensão sobre Transactors.

Um Transactor[F] conecta programas puros ConnectionIO a um banco de dados real. fromDriverManager é adequado para testes; HikariTransactor e fromDataSource são adequados para produção por meio de agrupamento.

Construa Transactors agrupados como um Resource, execute programas com .transact(xa) e deixe a Strategy padrão cuidar da confirmação, do desfazimento e da limpeza.