scalikejdbc

Active session implementation of scalikejdbc.DBSession.

This class provides readOnly/autoCommit/localTx/withinTx blocks and session objects.

import scalikejdbc._

val userIdList = DB autoCommit { session: DBSession =>
 session.list("select * from user") { rs => rs.int("id") }
}

All output decisions are unsupported by default.

Type unsafe ParameterBinder which holds any value and binds it as-is to PreparedStatement.

Connection Pool using external DataSource

Note: Commons-DBCP doesn't support this API.

Represents that already existing session will be used or a new session will be started.

Provides both of TypeBinder and ParameterBinderFactory for the specified type A.

Provides factories of Binders and built-in Binders.

BoneCP Connection Pool

Connection Pool Factory

Commons DBCP Connection Pool

Connection Pool Factory

Commons DBCP Connection Pool

Connection Pool Factory

Connection Pool

The default implementation uses Commons DBCP 2 internally.

Connection Pool

Connection pool context

Connection Pool Factory

ConnectionPoolFactoryRepository

Settings for ConnectionPool

Basic Database Accessor

Using DBSession:

 import scalikejdbc._
 case class User(id: Int, name: String)

 using(ConnectionPool(name).borrow()) { conn =>

   val users = DB(conn) readOnly { session =>
     session.list("select * from user") { rs =>
       User(rs.int("id"), rs.string("name"))
     }
   }

   DB(conn) autoCommit { session =>
     session.update("insert into user values (?,?)", 123, "Alice")
   }

   DB(conn) localTx { session =>
     session.update("insert into user values (?,?)", 123, "Alice")
   }

 }

Using SQL:

 import scalikejdbc._
 case class User(id: Int, name: String)

 using(ConnectionPool.borrow()) { conn =>

   val users = DB(conn) readOnly { implicit session =>
     SQL("select * from user").map { rs =>
       User(rs.int("id"), rs.string("name"))
     }.list.apply()
   }

   DB(conn) autoCommit { implicit session =>
     SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
   }

   DB(conn) localTx { implicit session =>
     SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
   }

 }

Basic Database Accessor

You can start with DB and blocks if using scalikejdbc.ConnectionPool.singleton.

Using DBSession:

 ConnectionPool.singleton("jdbc:...","user","password")
 case class User(id: Int, name: String)

 val users = DB readOnly { session =>
   session.list("select * from user") { rs =>
     User(rs.int("id"), rs.string("name"))
   }
 }

 DB autoCommit { session =>
   session.update("insert into user values (?,?)", 123, "Alice")
 }

 DB localTx { session =>
   session.update("insert into user values (?,?)", 123, "Alice")
 }

 using(DB(ConnectionPool.borrow())) { db =>
   db.begin()
   try {
     DB withTx { session =>
       session.update("update user set name = ? where id = ?", "Alice", 123)
     }
     db.commit()
   } catch { case e =>
     db.rollbackIfActive()
     throw e
   }
 }

Using SQL:

 ConnectionPool.singleton("jdbc:...","user","password")
 case class User(id: Int, name: String)

 val users = DB readOnly { implicit session =>
   SQL("select * from user").map { rs =>
     User(rs.int("id"), rs.string("name"))
   }.list.apply()
 }

 DB autoCommit { implicit session =>
   SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
 }

 DB localTx { implicit session =>
   SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
 }

 using(DB(ConnectionPool.borrow())) { db =>
   db.begin()
   try {
     DB withTx { implicit session =>
       SQL("update user set name = ? where id = ?").bind("Alice", 123).update.apply()
     }
     db.commit()
   } catch { case e =>
     db.rollbackIfActive()
     throw e
   }
 }

Basic Database Accessor which holds a JDBC connection.

Additional attributes for current JDBC connection.

DB Session

This class provides readOnly/autoCommit/localTx/withinTx blocks and session objects.

import scalikejdbc._

val userIdList = DB autoCommit { session: DBSession =>
 session.list("select * from user") { rs => rs.int("id") }
}

Resource manager which closes a DataSource.

Connection Pool using external DataSource

Settings for DataSourceConnectionPool

Default DataSourceCloser.

Entity identifier provider for equality (especially for scalikejdbc.RelationalSQL operation).

Notice: Inheritance is not supported.

Generalized type constraints for WithExtractor

GlobalSettings for this library

Represents that this SQL already has an extractor

Exception which represents that an illegal relationship is found.

Exception which represents invalid key is specified.

JDBC Settings

Companion object of JDBC URL

JDBC URL which contains host, port and database name

java.util.Date Converter to several types.

Implicit conversions for date time values.

Utility to escape like condition special characters.

Loan pattern implementation

Settings for logging SQL and timing

Multiple connection pool context

Settings for Name binding SQL validator

Represents that already existing session will be used or a new session which is retrieved from named connection pool will be started.

Named Basic DB Accessor

It's easier to use named ConnectionPool with this class.

ConnectionPool.add("named", "jdbc:...", "user", "password")
val users = NamedDB("named") readOnly { session =>
 session.list("select * from user")
}

Please note that a single NamedDB instance should be used only once, as the connection is closed after being used. To re-use an instance, use the .setAutoClose(false) method.

No Connection Pool Context

Represents that this SQL doesn't have an extractor yet

Represents that there is no active session.