or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/maven-com-typesafe-slick--slick-hikaricp

HikariCP integration for Slick (Scala Language-Integrated Connection Kit) - provides high-performance connection pooling for database access in Scala applications

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.typesafe.slick/slick-hikaricp_2.12@3.6.x

To install, run

npx @tessl/cli install tessl/maven-com-typesafe-slick--slick-hikaricp@3.6.0

index.mddocs/

Slick-HikariCP

Slick-HikariCP provides HikariCP connection pool integration for Slick, the Scala Language-Integrated Connection Kit. It enables high-performance database connection management with comprehensive configuration options, automatic pool lifecycle management, and seamless integration with Slick's asynchronous database access layer.

Package Information

  • Package Name: slick-hikaricp
  • Package Type: maven
  • Language: Scala
  • Installation: Add to your build.sbt: 
    libraryDependencies += "com.typesafe.slick" %% "slick-hikaricp" % "3.6.1"

Core Imports

import slick.jdbc.hikaricp.HikariCPJdbcDataSource

For using with Slick databases:

import slick.jdbc.JdbcBackend.Database

Basic Usage

import slick.jdbc.JdbcBackend.Database
import slick.jdbc.hikaricp.HikariCPJdbcDataSource
import com.typesafe.config.ConfigFactory

// Using Database.forConfig with HikariCP
val config = ConfigFactory.parseString("""
  mydb {
    profile = "slick.jdbc.H2Profile$"
    db {
      connectionPool = "slick.jdbc.hikaricp.HikariCPJdbcDataSource$"
      dataSourceClass = "slick.jdbc.DriverDataSource"
      properties = {
        driver = "org.h2.Driver"
        url = "jdbc:h2:mem:test"
      }
      numThreads = 10
      maximumPoolSize = 20
      minimumIdle = 5
      connectionTimeout = 30000
    }
  }
""")

val db = Database.forConfig("mydb.db", config)

// Use the database for queries
// db.run(...)

// Clean up when done
db.close()

Capabilities

HikariCP Data Source

A JdbcDataSource implementation that wraps HikariCP's connection pooling capabilities.

class HikariCPJdbcDataSource(
  val ds: com.zaxxer.hikari.HikariDataSource, 
  val hconf: com.zaxxer.hikari.HikariConfig
) extends JdbcDataSource {
  def createConnection(): java.sql.Connection
  def close(): Unit
  override val maxConnections: Option[Int]
}

Parameters:

  • ds: The underlying HikariCP data source instance
  • hconf: The HikariCP configuration used to create the data source

Methods:

  • createConnection(): Creates a new database connection from the pool
  • close(): Closes the data source and releases all connections in the pool
  • maxConnections: Returns Some(maximumPoolSize) from the HikariCP configuration

Data Source Factory

Factory object for creating HikariCPJdbcDataSource instances from Typesafe Config.

object HikariCPJdbcDataSource extends JdbcDataSourceFactory {
  def forConfig(
    c: com.typesafe.config.Config, 
    driver: java.sql.Driver, 
    name: String, 
    classLoader: ClassLoader
  ): HikariCPJdbcDataSource
}

Parameters:

  • c: Typesafe Config object containing HikariCP configuration
  • driver: JDBC driver instance (may be null if using dataSourceClassName)
  • name: Name for the connection pool
  • classLoader: ClassLoader for loading driver classes

Returns: A new HikariCPJdbcDataSource instance configured according to the provided config

Configuration Options

The forConfig method supports extensive HikariCP configuration through Typesafe Config:

Essential Connection Settings

// Data source configuration (choose one approach)
dataSourceClassName: String     // Preferred: HikariCP data source class name
dataSourceClass: String         // Alternative name for dataSourceClassName  
driverClassName: String         // Fallback: JDBC driver class name
driver: String                  // Alternative name for driverClassName

// Connection details
jdbcUrl: String                 // JDBC URL (use with old drivers)
url: String                     // Alternative name for jdbcUrl
username: String                // Database username
user: String                    // Alternative name for username  
password: String                // Database password
properties: Map[String, String] // Additional data source properties

Pool Sizing and Threading

numThreads: Int                 // Base thread count (default: 20)
maximumPoolSize: Int            // Maximum pool size (default: numThreads)
maxConnections: Int             // Alternative name for maximumPoolSize
minimumIdle: Int                // Minimum idle connections (default: numThreads)
minConnections: Int             // Alternative name for minimumIdle

Timeout Configuration

connectionTimeout: Long         // Connection timeout in milliseconds (default: 30000)
idleTimeout: Long               // Idle timeout in milliseconds (default: 600000)
maxLifetime: Long               // Maximum connection lifetime in milliseconds (default: 1800000)
validationTimeout: Long         // Connection validation timeout in milliseconds (default: 5000)
initializationFailTimeout: Long // Pool initialization timeout in milliseconds (default: -1)
leakDetectionThreshold: Long    // Connection leak detection threshold in milliseconds (default: 0)
keepAliveTime: Long             // Connection keep-alive time in milliseconds

Connection Behavior

autoCommit: Boolean             // Auto-commit behavior
readOnly: Boolean               // Mark connections as read-only
isolateInternalQueries: Boolean // Isolate internal HikariCP queries
allowPoolSuspension: Boolean    // Allow pool suspension

Connection Testing and Initialization

connectionTestQuery: String     // Query to validate connections
connectionInitSql: String       // SQL to execute when creating connections
exceptionOverrideClassName: String // Custom exception override class name

Metadata and Monitoring

poolName: String                // Connection pool name (default: provided name)
catalog: String                 // Database catalog
schema: String                  // Database schema  
registerMbeans: Boolean         // Register JMX MBeans for monitoring

Transaction Configuration

transactionIsolation: String    // Transaction isolation level
isolation: String               // Alternative name for transactionIsolation

Transaction Isolation Levels:

  • "READ_UNCOMMITTED" → TRANSACTION_READ_UNCOMMITTED
  • "READ_COMMITTED" → TRANSACTION_READ_COMMITTED
  • "REPEATABLE_READ" → TRANSACTION_REPEATABLE_READ
  • "SERIALIZABLE" → TRANSACTION_SERIALIZABLE

Legacy Configuration

initializationFailFast: Boolean // Deprecated: Use initializationFailTimeout instead

Note: initializationFailFast is deprecated. Use initializationFailTimeout with -1 for no timeout, 0 for fail immediately, or positive milliseconds for timeout duration.

Types

// External dependencies
import com.zaxxer.hikari.{HikariConfig, HikariDataSource}
import com.typesafe.config.Config
import java.sql.{Connection, Driver}
import slick.jdbc.{JdbcDataSource, JdbcDataSourceFactory}

Usage Examples

Simple Database Configuration

// application.conf
myapp {
  db {
    connectionPool = "slick.jdbc.hikaricp.HikariCPJdbcDataSource$"
    dataSourceClass = "slick.jdbc.DriverDataSource"
    properties = {
      driver = "org.postgresql.Driver"
      url = "jdbc:postgresql://localhost/mydb"
      user = "dbuser"
      password = "dbpass"
    }
    numThreads = 10
    maximumPoolSize = 20
  }
}

Advanced HikariCP Configuration

// application.conf with advanced settings
production {
  db {
    connectionPool = "slick.jdbc.hikaricp.HikariCPJdbcDataSource$"
    dataSourceClassName = "org.postgresql.ds.PGSimpleDataSource"
    properties = {
      serverName = "localhost"
      portNumber = "5432"
      databaseName = "mydb"
      user = "dbuser"
      password = "dbpass"
    }
    
    # Pool sizing
    maximumPoolSize = 50
    minimumIdle = 10
    
    # Timeouts (in milliseconds)
    connectionTimeout = 30000
    idleTimeout = 600000
    maxLifetime = 1800000
    validationTimeout = 5000
    
    # Connection testing
    connectionTestQuery = "SELECT 1"
    
    # Monitoring
    poolName = "ProductionPool"
    registerMbeans = true
    leakDetectionThreshold = 60000
    
    # Connection behavior
    autoCommit = false
    transactionIsolation = "READ_COMMITTED"
  }
}

Direct API Usage

import com.zaxxer.hikari.{HikariConfig, HikariDataSource}
import slick.jdbc.hikaricp.HikariCPJdbcDataSource
import com.typesafe.config.ConfigFactory

// Create HikariCP configuration directly
val hconfig = new HikariConfig()
hconfig.setJdbcUrl("jdbc:h2:mem:test")
hconfig.setUsername("sa")
hconfig.setPassword("")
hconfig.setMaximumPoolSize(20)
hconfig.setMinimumIdle(5)

// Create HikariCP data source
val hikariDS = new HikariDataSource(hconfig)

// Wrap in Slick data source
val slickDS = new HikariCPJdbcDataSource(hikariDS, hconfig)

// Use with Slick database
val db = Database.forDataSource(slickDS, Some(20))

// Clean up
db.close()
slickDS.close()