Merge pull request #1096 from slick/tmp/deprecate-withsession

Deprecate Database.withSession and remove usages of this method

slick-testkit/src/main/scala/com/typesafe/slick/testkit/util/StandardTestDBs.scala

@@ -3,15 +3,16 @@ package com.typesafe.slick.testkit.util
 import java.io.File
 import java.util.logging.{Level, Logger}
 import java.sql.SQLException
-import scala.concurrent.ExecutionContext
 import slick.dbio._
 import slick.driver._
 import slick.memory.MemoryDriver
-import slick.jdbc.{StaticQuery => Q, ResultSetAction, ResultSetInvoker}
+import slick.jdbc.{StaticQuery => Q, SimpleJdbcAction, ResultSetAction, ResultSetInvoker}
 import slick.jdbc.GetResult._
 import slick.jdbc.meta.MTable
 import org.junit.Assert
 
+import scala.concurrent.ExecutionContext
+
 object StandardTestDBs {
   lazy val H2Mem = new H2TestDB("h2mem", false) {
     val url = "jdbc:h2:mem:test1"
@@ -67,7 +68,7 @@ object StandardTestDBs {
     val url = "jdbc:derby:memory:"+dbName+";create=true"
     override def cleanUpBefore() = {
       val dropUrl = "jdbc:derby:memory:"+dbName+";drop=true"
-      try { profile.backend.Database.forURL(dropUrl, driver = jdbcDriver) withSession(_.conn) }
+      try { await(profile.backend.Database.forURL(dropUrl, driver = jdbcDriver).run(SimpleJdbcAction(_.connection))) }
       catch { case e: SQLException => }
     }
   }
@@ -77,7 +78,7 @@ object StandardTestDBs {
     val url = "jdbc:derby:"+TestkitConfig.testDBPath+"/"+dbName+";create=true"
     override def cleanUpBefore() = {
       val dropUrl = "jdbc:derby:"+TestkitConfig.testDBPath+"/"+dbName+";shutdown=true"
-      try { profile.backend.Database.forURL(dropUrl, driver = jdbcDriver) withSession(_.conn) }
+      try { await(profile.backend.Database.forURL(dropUrl, driver = jdbcDriver).run(SimpleJdbcAction(_.connection))) }
       catch { case e: SQLException => }
       TestDB.deleteDBFiles(dbName)
     }

slick-testkit/src/main/scala/com/typesafe/slick/testkit/util/TestDB.scala

@@ -4,9 +4,10 @@ import java.io._
 import java.net.{URL, URLClassLoader}
 import java.sql.{Connection, Driver}
 import java.util.Properties
+import java.util.concurrent.ExecutionException
 import java.util.zip.GZIPInputStream
 import scala.collection.mutable
-import scala.concurrent.ExecutionContext
+import scala.concurrent.{Await, Future, ExecutionContext}
 import slick.SlickException
 import slick.dbio.{NoStream, DBIOAction, DBIO}
 import slick.jdbc.{StaticQuery => Q, ResultSetAction, JdbcDataSource, SimpleJdbcAction, ResultSetInvoker}
@@ -201,6 +202,9 @@ abstract class JdbcTestDB(val confName: String) extends SqlTestDB {
     })
     db.run(f(ec)).value.get.get
   }
+  protected[this] def await[T](f: Future[T]): T =
+    try Await.result(f, TestkitConfig.asyncTimeout)
+    catch { case ex: ExecutionException => throw ex.getCause }
 }
 
 abstract class InternalJdbcTestDB(confName: String) extends JdbcTestDB(confName) { self =>
@@ -210,6 +214,8 @@ abstract class InternalJdbcTestDB(confName: String) extends JdbcTestDB(confName)
 }
 
 abstract class ExternalJdbcTestDB(confName: String) extends JdbcTestDB(confName) {
+  import driver.api.actionBasedSQLInterpolation
+
   val jdbcDriver = confString("driver")
   val testDB = confString("testDB")
 
@@ -233,24 +239,23 @@ abstract class ExternalJdbcTestDB(confName: String) extends JdbcTestDB(confName)
   override def cleanUpBefore() {
     if(!drop.isEmpty || !create.isEmpty) {
       println("[Creating test database "+this+"]")
-      databaseFor("adminConn") withSession { implicit session =>
-        for(s <- drop) (Q.u + s).execute
-        for(s <- create) (Q.u + s).execute
-      }
+      await(databaseFor("adminConn").run(
+        DBIO.seq((drop ++ create).map(s => sqlu"#$s"): _*).withPinnedSession
+      ))
     }
     if(!postCreate.isEmpty) {
-      createDB() withSession { implicit session  =>
-        for(s <- postCreate) (Q.u + s).execute
-      }
+      await(createDB().run(
+        DBIO.seq(postCreate.map(s => sqlu"#$s"): _*).withPinnedSession
+      ))
     }
   }
 
   override def cleanUpAfter() {
     if(!drop.isEmpty) {
       println("[Dropping test database "+this+"]")
-      databaseFor("adminConn") withSession { implicit session =>
-        for(s <- drop) (Q.u + s).execute
-      }
+      await(databaseFor("adminConn").run(
+        DBIO.seq(drop.map(s => sqlu"#$s"): _*).withPinnedSession
+      ))
     }
   }
 

slick/src/main/scala/slick/backend/DatabaseComponent.scala

@@ -312,6 +312,7 @@ trait DatabaseComponent { self =>
     /** Run the supplied function with a new session and automatically close the session at the end.
       * Exceptions thrown while closing the session are propagated, but only if the code block using the
       * session terminated normally. Otherwise the first exception wins. */
+    @deprecated("Use the new Action-based API instead", "3.0")
     def withSession[T](f: Session => T): T = {
       val s = createSession()
       var ok = false

slick/src/main/scala/slick/jdbc/StaticQuery.scala

@@ -4,6 +4,8 @@ import java.net.URI
 
 import com.typesafe.config.ConfigException
 
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
 import scala.language.experimental.macros
 import scala.language.implicitConversions
 import scala.reflect.ClassTag
@@ -163,8 +165,8 @@ object ActionBasedSQLInterpolation {
           ctxt.abort(ctxt.enclosingPosition, s"""Cannot load @StaticDatabaseConfig("$uri"): ${ex.getMessage}""")
       }
     val rTypes = try {
-      dc.db withSession {
-        _.withPreparedStatement(macroTreeBuilder.staticQueryString) {
+      val a = SimpleJdbcAction { ctx =>
+        ctx.session.withPreparedStatement(macroTreeBuilder.staticQueryString) {
           _.getMetaData match {
             case null => Vector()
             case resultMeta => Vector.tabulate(resultMeta.getColumnCount) { i =>
@@ -174,6 +176,7 @@ object ActionBasedSQLInterpolation {
           }
         }
       }
+      Await.result(dc.db.run(a), Duration.Inf)
     } finally dc.db.close()
 
     reify {