or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

connection-pooling.mddatabase-configuration.mddatabase-management.mddatabase-operations.mddependency-injection.mdindex.md
tile.json

tessl/maven-com-typesafe-play--play-jdbc-2-11

Play Framework JDBC support library providing database access, connection pooling, and database configuration management for Play applications.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.typesafe.play/play-jdbc_2.11@2.7.x

To install, run

npx @tessl/cli install tessl/maven-com-typesafe-play--play-jdbc-2-11@2.7.0

index.mddocs/

Play JDBC

Play JDBC is the database access module for the Play Framework, providing comprehensive database connectivity through both Scala and Java APIs. It offers connection pooling via HikariCP, transaction management, database configuration support, and utilities for database operations in Play applications.

Package Information

  • Package Name: play-jdbc_2.11
  • Package Type: maven (Scala/SBT)
  • Language: Scala with Java interoperability
  • Installation: libraryDependencies += "com.typesafe.play" %% "play-jdbc" % "2.7.9"

Core Imports

Scala API:

import play.api.db._
import java.sql.Connection
import javax.sql.DataSource
import javax.inject.Inject

Java API:

import play.db.*;
import java.sql.Connection;
import javax.sql.DataSource;
import javax.inject.Inject;

Basic Usage

Scala API

import play.api.db._
import java.sql.Connection
import javax.inject.Inject

class UserController @Inject()(db: Database) {
  def getUser(id: Long) = {
    db.withConnection { implicit connection =>
      // Execute SQL queries
      val stmt = connection.prepareStatement("SELECT name FROM users WHERE id = ?")
      stmt.setLong(1, id)
      val rs = stmt.executeQuery()
      if (rs.next()) Some(rs.getString("name")) else None
    }
  }
  
  def createUser(name: String) = {
    db.withTransaction { implicit connection =>
      val stmt = connection.prepareStatement("INSERT INTO users (name) VALUES (?)")
      stmt.setString(1, name)
      stmt.executeUpdate()
    }
  }
}

Java API

import play.db.*;
import javax.inject.Inject;

public class UserController {
    private final Database db;
    
    @Inject
    public UserController(Database db) {
        this.db = db;
    }
    
    public Optional<String> getUser(long id) {
        return db.withConnection(connection -> {
            PreparedStatement stmt = connection.prepareStatement("SELECT name FROM users WHERE id = ?");
            stmt.setLong(1, id);
            ResultSet rs = stmt.executeQuery();
            return rs.next() ? Optional.of(rs.getString("name")) : Optional.empty();
        });
    }
    
    public void createUser(String name) {
        db.withTransaction(connection -> {
            PreparedStatement stmt = connection.prepareStatement("INSERT INTO users (name) VALUES (?)");
            stmt.setString(1, name);
            stmt.executeUpdate();
        });
    }
}

Architecture

Play JDBC is organized around several key components:

  • Database Trait/Interface: Core API for database operations, connection management, and transactions
  • DBApi Trait/Interface: Multi-database management API for applications with multiple data sources
  • Connection Pool: HikariCP-based connection pooling with configurable parameters
  • Configuration System: Type-safe database configuration with support for multiple environments
  • Dependency Injection: Full integration with Play's DI system for both runtime and compile-time injection
  • Transaction Management: Automatic transaction handling with isolation level support

Capabilities

Database Operations

Core database connectivity providing connection management, transaction support, and resource handling for both Scala and Java APIs.

trait Database {
  def name: String
  def dataSource: DataSource
  def getConnection(): Connection
  def withConnection[A](block: Connection => A): A
  def withTransaction[A](block: Connection => A): A
}
public interface Database {
  String getName();
  DataSource getDataSource();
  Connection getConnection();
  <A> A withConnection(ConnectionCallable<A> block);
  void withTransaction(ConnectionRunnable block);
}

Database Operations

Multi-Database Management

API for managing multiple database configurations in a single application, with named database support.

trait DBApi {
  def databases(): Seq[Database]
  def database(name: String): Database
  def shutdown(): Unit
}
public interface DBApi {
  List<Database> getDatabases();
  Database getDatabase(String name);
  void shutdown();
}

Multi-Database Management

Connection Pooling

HikariCP-based connection pool implementation with comprehensive configuration options and performance monitoring.

trait ConnectionPool {
  def create(name: String, dbConfig: DatabaseConfig, configuration: Config): DataSource
  def close(dataSource: DataSource): Unit
}

Connection Pooling

Database Configuration

Type-safe configuration system supporting multiple databases, JNDI, and environment-specific settings.

case class DatabaseConfig(
  driver: Option[String],
  url: Option[String], 
  username: Option[String],
  password: Option[String],
  jndiName: Option[String]
)

Database Configuration

Dependency Injection

Runtime and compile-time dependency injection modules with support for named databases and lifecycle management.

class DBModule extends SimpleModule
trait DBComponents {
  def dbApi: DBApi
}
@NamedDatabase("users")
@Inject
private Database userDb;

Dependency Injection

Types

Transaction Isolation Levels

sealed abstract class TransactionIsolationLevel(val id: Int)
object TransactionIsolationLevel {
  case object ReadUncommitted extends TransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED)
  case object ReadCommitted extends TransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED)
  case object RepeatedRead extends TransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ)
  case object Serializable extends TransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE)
}
public enum TransactionIsolationLevel {
  ReadUncommitted(Connection.TRANSACTION_READ_UNCOMMITTED),
  ReadCommitted(Connection.TRANSACTION_READ_COMMITTED),
  RepeatedRead(Connection.TRANSACTION_REPEATABLE_READ),
  Serializable(Connection.TRANSACTION_SERIALIZABLE);
}

@FunctionalInterface
public interface ConnectionCallable<A> {
  A call(Connection connection) throws SQLException;
}

@FunctionalInterface
public interface ConnectionRunnable {
  void run(Connection connection) throws SQLException;
}