src/Pure/Thy/sessions.scala

     val output_heap = SQL.Column.string("output_heap")
     val return_code = SQL.Column.int("return_code")
     val build_columns = List(sources, input_heaps, output_heap, return_code)
 
     val table = SQL.Table("isabelle_session_info", build_log_columns ::: build_columns)
-
-    def select_statement(db: SQL.Database, name: String, columns: List[SQL.Column])
-        : PreparedStatement =
-      db.select_statement(table, columns, session_name.sql_where_equal(name))
-
-    def delete_statement(db: SQL.Database, name: String): PreparedStatement =
-      db.delete_statement(table, session_name.sql_where_equal(name))
   }
 
   def store(system_mode: Boolean = false): Store = new Store(system_mode)
 
   class Store private[Sessions](system_mode: Boolean) extends Properties.Store

 
 
     /* SQL database content */
 
     def read_bytes(db: SQL.Database, name: String, column: SQL.Column): Bytes =
-      using(Session_Info.select_statement(db, name, List(column)))(stmt =>
+      using(db.select_statement(Session_Info.table, List(column),
+        Session_Info.session_name.sql_where_equal(name)))(stmt =>
       {
         val rs = stmt.executeQuery
         if (!rs.next) Bytes.empty else db.bytes(rs, column)
       })
 

       build_log: Build_Log.Session_Info,
       build: Build.Session_Info)
     {
       db.transaction {
         db.create_table(Session_Info.table)
-        using(Session_Info.delete_statement(db, name))(_.execute)
+        using(db.delete_statement(Session_Info.table,
+          Session_Info.session_name.sql_where_equal(name)))(_.execute)
         using(db.insert_statement(Session_Info.table))(stmt =>
         {
           db.set_string(stmt, 1, name)
           db.set_bytes(stmt, 2, encode_properties(build_log.session_timing))
           db.set_bytes(stmt, 3, compress_properties(build_log.command_timings))

         ml_statistics = if (ml_statistics) read_ml_statistics(db, name) else Nil,
         task_statistics = if (task_statistics) read_task_statistics(db, name) else Nil)
     }
 
     def read_build(db: SQL.Database, name: String): Option[Build.Session_Info] =
-      using(Session_Info.select_statement(db, name, Session_Info.build_columns))(stmt =>
+      using(db.select_statement(Session_Info.table, Session_Info.build_columns,
+        Session_Info.session_name.sql_where_equal(name)))(stmt =>
       {
         val rs = stmt.executeQuery
         if (!rs.next) None
         else {
           Some(