Как преобразовать результаты jdbc в неизменяемую коллекцию

Короткий ответ: вы не можете добиться значительно большего успеха, чем то, что у вас есть. Под капотом функциональной хитрости Scala находится код, очень похожий на ваш. Кроме того, не забывайте, что у изменяемых Map есть метод toMap, который возвращает неизменяемый Map.

Длинный ответ: вы хотите создать интерфейс кода JDBC с кодом Scala. API JDBC не предназначен для использования с функциональными языками, поэтому вам обязательно понадобится какой-нибудь изменяемый/императивный код, чтобы заполнить пробел. На самом деле это просто вопрос пути наименьшего сопротивления.

Если бы вы просто строили карту один к одному, вам бы очень подошла карта MapBuilder. Scala включает Builder классов для большинства своих структур данных, которые используют временные, частные, изменяемые структуры для максимально эффективного построения неизменяемой структуры. Код будет выглядеть примерно так:

val builder = Map.newBuilder[Int, Int]
while(result.next()) {
  val SomeExtractor(one, two) = result
  builder += one -> two
}
return builder.result

Однако на самом деле вы создаете MultiMap — карту от ключей к нескольким значениям. В стандартной библиотеке Scala есть трейт MultiMap, но он не идеален для вашего варианта использования. Он изменчив и хранит значения в изменяемых Sets, а не Lists, поэтому мы пока его проигнорируем.

В стандартной библиотеке Scala есть метод groupBy для свойства Traversable, который делает более или менее то, что вы ищете. У нас есть ResultSet, а не Traversable, но в принципе мы могли бы написать какой-нибудь связующий код, чтобы обернуть ResultSet в Traversable, и воспользоваться этим существующим кодом. Что-то вроде следующего:

// strm has side effects, caused by rs.next - only ever call it once, and re-use result if needed.
def strm: Stream[(Int, Int)] = if (rs.next) SomeExtractor.unapply(rs).get #:: strm else Stream.empty
return strm.groupBy(_._1)

Это сработает, но мы получили пугающее предупреждение о побочных эффектах, и на самом деле мы не увеличили производительность. Если вы посмотрите на исходный код для Traversable.groupBy (см. код на GitHub), на самом деле он делает то же самое, что и вы - создаете изменяемый Map с нашими данными, а затем в конце преобразуете его в неизменяемый Map.

Я думаю, что подход, который у вас уже есть, близок к оптимальному - просто верните map.toMap.

О, и я предположил, что SomeExtractor извлекает пару Ints.

Возможно, что-то вроде Slick сделает именно то, что вам нужно.

В качестве альтернативы, вот код, который я когда-то написал. Он предоставляет поток документов и метаинформации JSON и основан на библиотеке Lift JSON, но вы можете легко изменить ее на другие реализации JSON. Это работает очень хорошо.

case class ColumnMeta(index: Int, label: String, datatype: String)

def runQuery(dbConnection: Connection, query: String): (List[ColumnMeta], Stream[JObject]) = {
    val rs = dbConnection.prepareStatement(query).executeQuery
    implicit val cols = getColumnMeta(rs.getMetaData)
    (cols, getStreamOfResults(rs))
  }

  /**
   * Returns a list of columns for specified ResultSet which describes column properties we are interested in.
   */
  def getColumnMeta(rsMeta: ResultSetMetaData): List[ColumnMeta] =
    (for {
      idx <- (1 to rsMeta.getColumnCount)
      colName = rsMeta.getColumnLabel(idx).toLowerCase
      colType = rsMeta.getColumnClassName(idx)
    } yield ColumnMeta(idx, colName, colType)).toList

  /**
   * Creates a stream of results on top of a ResultSet.
   */
  def getStreamOfResults(rs: ResultSet)(implicit cols: List[ColumnMeta]): Stream[JObject] =
    new Iterator[JObject] {
      def hasNext = rs.next
      def next() = rowToObj(rs)
    }.toStream

  /**
   * Given a row from a ResultSet produces a JSON document.
   */
  def rowToObj(rs: ResultSet)(implicit cols: List[ColumnMeta]): JObject = {
    val fields = for {
      ColumnMeta(index, label, datatype) <- cols
      clazz = Class.forName(datatype)
      value = columnValueGetter(datatype, index, rs)
    } yield (label -> value)
    JObject(fields map { case (n, v) => JField(n, v) })
  }

  /**
   * Takes a fully qualified Java type as String and returns one of the subtypes of JValue by fetching a value
   * from result set and converting it to proper type.
   * It supports only the most common types and everything else that does not match this conversion is converted
   * to String automatically. If you see that you results should contain more specific type instead of String
   * add conversion cases to {{{resultsetGetters}}} map.
   */
  def columnValueGetter(datatype: String, columnIdx: Int, rs: ResultSet): JValue = {
    val obj = rs.getObject(columnIdx)
    if (obj == null)
      JNull
    else {
      val converter = resultsetGetters getOrElse (datatype, (obj: Object) => JString(obj.toString))
      converter(obj)
    }
  }

  val resultsetGetters: Map[String, Object => JValue] = Map(
    "java.lang.Integer" -> ((obj: Object) => JInt(obj.asInstanceOf[Int])),
    "java.lang.Long" -> ((obj: Object) => JInt(obj.asInstanceOf[Long])),
    "java.lang.Double" -> ((obj: Object) => JDouble(obj.asInstanceOf[Double])),
    "java.lang.Float" -> ((obj: Object) => JDouble(obj.asInstanceOf[Float])),
    "java.lang.Boolean" -> ((obj: Object) => JBool(obj.asInstanceOf[Boolean])),
    "java.sql.Clob" -> ((obj: Object) => {
      val clob = obj.asInstanceOf[Clob]
      JString(clob.getSubString(1, clob.length.toInt))
    }),
    "java.lang.String" -> ((obj: Object) => JString(obj.asInstanceOf[String])))