scalikejdbc-async

## ScalikeJDBC-Async

### ScalikeJDBC Extension: Non-blocking APIs in the JDBC way

ScalikeJDBC-Async provides non-blocking APIs to talk with PostgreSQL and MySQL in the JDBC way. 

This library is built with [jasync-sql](https://github.com/jasync-sql/jasync-sql).

![ScalikeJDBC Logo](https://scalikejdbc.org/img/logo.png)

ScalikeJDBC:

https://github.com/scalikejdbc/scalikejdbc

ScalikeJDBC is a tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs.


### Important Notice

ScalikeJDBC-Async is still in the beta stage. If you don't have motivation to investigate or fix issues by yourself, we recommend you waiting until stable version release someday.

### Supported RDBMS

- PostgreSQL
- MySQL

### Dependencies

Add `scalikejdbc-async` to your dependencies.

```scala
libraryDependencies ++= Seq(
  "org.scalikejdbc"       %% "scalikejdbc-async" % "0.19.+",
  "com.github.jasync-sql" %  "jasync-postgresql" % "2.2.+", // Add this if you go with PostgreSQL
  "com.github.jasync-sql" %  "jasync-mysql"      % "2.2.+", // Add this if you go with MySQL / MariaDB
  "org.slf4j"             %  "slf4j-simple"      % "1.7.+" // Add you preferred slf4j implementation
)
```

### Example

- [programmerlist/ExampleSpec.scala](https://github.com/scalikejdbc/scalikejdbc-async/blob/master/core/src/test/scala/programmerlist/ExampleSpec.scala)
- [programmerlist/Company.scala](https://github.com/scalikejdbc/scalikejdbc-async/blob/master/core/src/test/scala/programmerlist/Company.scala)
- [programmerlist/Programmer.scala](https://github.com/scalikejdbc/scalikejdbc-async/blob/master/core/src/test/scala/programmerlist/Programmer.scala)

```scala
import scalikejdbc._, async._
import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

// set up connection pool (that's all you need to do)
AsyncConnectionPool.singleton("jdbc:postgresql://localhost:5432/scalikejdbc", "sa", "sa")

// create a new record within a transaction
val created: Future[Company] = AsyncDB.localTx { implicit tx =>
  for {
    company <- Company.create("ScalikeJDBC, Inc.", Some("https://scalikejdbc.org/"))
    seratch <- Programmer.create("seratch", Some(company.id))
    gakuzzzz <- Programmer.create("gakuzzzz", Some(company.id))
    xuwei_k <- Programmer.create("xuwei-k", Some(company.id))
  } yield company
}

Await.result(created, 5.seconds)

created.foreach { (newCompany: Company) =>

  // delete a record and rollback
  val withinTx: Future[Unit] = AsyncDB.localTx { implicit tx =>
    for {
      restructuring <- Programmer.findAllBy(sqls.eq(p.companyId, newCompany.id)).map { 
        programmers => programmers.foreach(_.destroy()) 
      }
      dissolution <- newCompany.destroy()
      failure <- sql"Just joking!".update.future
    } yield ()
  }

  try Await.result(withinTx, 5.seconds)
  catch { case e: Exception => log.debug(e.getMessage, e) }

  // rollback expected