Optimize bulk imports a bit more.

Author: baffles

codepulse/src/main/scala/com/secdec/codepulse/data/trace/slick/EncountersDao.scala

@@ -27,7 +27,7 @@ import com.secdec.codepulse.data.trace._
   *
   * @author robertf
   */
-private[slick] class EncountersDao(val driver: JdbcProfile, val recordingMetadata: RecordingMetadataDao, val treeNodeData: TreeNodeDataDao) {
+private[slick] class EncountersDao(val driver: JdbcProfile, val recordingMetadata: RecordingMetadataDao, val treeNodeData: TreeNodeDataDao) extends SlickHelpers {
 	import driver.simple._
 
 	class Encounters(tag: Tag) extends Table[(Option[Int], Int)](tag, "node_encounters") {
@@ -50,6 +50,6 @@ private[slick] class EncountersDao(val driver: JdbcProfile, val recordingMetadat
 	}
 
 	def store(entries: Iterable[(Option[Int], Int)])(implicit session: Session) {
-		encounters ++= entries
+		fastImport { encounters ++= entries }
 	}
 }

codepulse/src/main/scala/com/secdec/codepulse/data/trace/slick/SlickHelpers.scala

@@ -0,0 +1,44 @@
+/*
+ * Code Pulse: A real-time code coverage testing tool. For more information
+ * see http://code-pulse.com
+ *
+ * Copyright (C) 2014 Applied Visions - http://securedecisions.avi.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.secdec.codepulse.data.trace.slick
+
+import scala.slick.driver.JdbcProfile
+import scala.slick.jdbc.{ StaticQuery => Q }
+
+/** Some helpers for the Slick DAOs.
+  *
+  * @author robertf
+  */
+private[slick] trait SlickHelpers {
+	val driver: JdbcProfile
+	import driver.simple._
+
+	/** Wrap thunk in DB calls to speed up large imports.
+	  * Ideas here are from http://www.h2database.com/html/performance.html#fast_import
+	  */
+	def fastImport[T](thunk: => T)(implicit session: Session): T = {
+		try {
+			(Q updateNA "SET LOG 0; SET UNDO_LOG 0;").execute
+			thunk
+		} finally {
+			(Q updateNA "SET LOG 2; SET UNDO_LOG 1;").execute
+		}
+	}
+}

codepulse/src/main/scala/com/secdec/codepulse/data/trace/slick/TreeNodeDataDao.scala

@@ -28,7 +28,7 @@ import com.secdec.codepulse.data.trace.{ TreeNodeData => TreeNode, _ }
   *
   * @author robertf
   */
-private[slick] class TreeNodeDataDao(val driver: JdbcProfile) {
+private[slick] class TreeNodeDataDao(val driver: JdbcProfile) extends SlickHelpers {
 	import driver.simple._
 
 	class TreeNodeData(tag: Tag) extends Table[TreeNode](tag, "tree_node_data") {
@@ -123,31 +123,33 @@ private[slick] class TreeNodeDataDao(val driver: JdbcProfile) {
 	}
 
 	def storeMethodSignatures(signatures: Iterable[(String, Int)])(implicit session: Session) {
-		methodSignatureNodeMap ++= signatures
+		fastImport { methodSignatureNodeMap ++= signatures }
 	}
 
 	def storeJsp(jspPath: String, nodeId: Int)(implicit session: Session) {
 		jspNodeMap += jspPath -> nodeId
 	}
 
 	def storeJsps(jsps: Iterable[(String, Int)])(implicit session: Session) {
-		jspNodeMap ++= jsps
+		fastImport { jspNodeMap ++= jsps }
 	}
 
 	def storeNode(node: TreeNode)(implicit session: Session) {
 		treeNodeData += node
 	}
 
 	def storeNodes(nodes: Iterable[TreeNode])(implicit session: Session) {
-		treeNodeData ++= nodes
+		fastImport { treeNodeData ++= nodes }
 	}
 
 	def getTraced()(implicit session: Session) = tracedNodes.list
 
 	def storeTracedValues(values: Iterable[(Int, Option[Boolean])])(implicit session: Session) {
-		tracedNodes ++= values flatMap {
-			case (id, Some(traced)) => Some(id -> traced)
-			case _ => None
+		fastImport {
+			tracedNodes ++= values flatMap {
+				case (id, Some(traced)) => Some(id -> traced)
+				case _ => None
+			}
 		}
 	}