Обработка набора результатов SQL как потока Scala

Я не проверял, но почему не работает?

new Iterator[String] {
  def hasNext = resultSet.next()
  def next() = resultSet.getString(1)
}.toStream

Вспомогательная функция для ответа @elbowich:

def results[T](resultSet: ResultSet)(f: ResultSet => T) = {
  new Iterator[T] {
    def hasNext = resultSet.next()
    def next() = f(resultSet)
  }
}

Позволяет использовать вывод типа. Например.:

stmt.execute("SELECT mystr, myint FROM mytable")

// Example 1:
val it = results(stmt.resultSet) {
  case rs => rs.getString(1) -> 100 * rs.getInt(2)
}
val m = it.toMap // Map[String, Int]

// Example 2:
val it = results(stmt.resultSet)(_.getString(1))

Это звучит как отличная возможность для неявного класса. Сначала определите неявный класс где-нибудь:

import java.sql.ResultSet

object Implicits {

    implicit class ResultSetStream(resultSet: ResultSet) {

        def toStream: Stream[ResultSet] = {
            new Iterator[ResultSet] {
                def hasNext = resultSet.next()

                def next() = resultSet
            }.toStream
        }
    }
}

Затем просто импортируйте этот неявный класс везде, где вы выполнили свой запрос и определили объект ResultSet:

import com.company.Implicits._

Наконец, получите данные, используя метод toStream. Например, получите все идентификаторы, как показано ниже:

val allIds = resultSet.toStream.map(result => result.getInt("id"))

мне нужно было нечто подобное. Основываясь на очень крутом ответе Лолича, я немного завернул его и вместо строки возвращаю результат (так что вы можете получить любой столбец)

def resultSetItr(resultSet: ResultSet): Stream[ResultSet] = {
    new Iterator[ResultSet] {
      def hasNext = resultSet.next()
      def next() = resultSet
    }.toStream
  }

Мне нужно было получить доступ к метаданным таблицы, но это будет работать для строк таблицы (можно сделать stmt.executeQuery(sql) вместо md.getColumns):

 val md = connection.getMetaData()
 val columnItr = resultSetItr( md.getColumns(null, null, "MyTable", null))
      val columns = columnItr.map(col => {
        val columnType = col.getString("TYPE_NAME")
        val columnName = col.getString("COLUMN_NAME")
        val columnSize = col.getString("COLUMN_SIZE")
        new Column(columnName, columnType, columnSize.toInt, false)
      })

Поскольку ResultSet — это всего лишь изменяемый объект, для навигации по которому используется next, нам нужно определить собственную концепцию следующей строки. Мы можем сделать это с помощью функции ввода следующим образом:

class ResultSetIterator[T](rs: ResultSet, nextRowFunc: ResultSet => T) 
extends Iterator[T] {

  private var nextVal: Option[T] = None

  override def hasNext: Boolean = {
    val ret = rs.next()
    if(ret) {
      nextVal = Some(nextRowFunc(rs))
    } else {
      nextVal = None
    }
    ret
  }

  override def next(): T = nextVal.getOrElse { 
    hasNext 
    nextVal.getOrElse( throw new ResultSetIteratorOutOfBoundsException 
  )}

  class ResultSetIteratorOutOfBoundsException extends Exception("ResultSetIterator reached end of list and next can no longer be called. hasNext should return false.")
}

РЕДАКТИРОВАТЬ: перевести в поток или что-то еще, как указано выше.

Вот альтернатива, аналогичная решениям Сергея Алаева и Тореджа, когда нам нужно решение, которое соблюдает контракт Iterator, где hasNext не имеет побочных эффектов.

Предполагая функцию f: ResultSet => T:

Iterator.unfold(resultSet.next()) { hasNext =>
  Option.when(hasNext)(f(resultSet), resultSet.next())
}

Я нашел полезным иметь в качестве map "метод расширения" на ResultSet.

implicit class ResultSetOps(resultSet: ResultSet) {
    def map[T](f: ResultSet => T): Iterator[T] = {
      Iterator.unfold(resultSet.next()) { hasNext =>
        Option.when(hasNext)(f(resultSet), resultSet.next())
      }
    }
  }

Эта реализация, хотя и длиннее и неуклюже, лучше соответствует контракту ResultSet. Побочный эффект был удален из hasNext(...) и перемещен в next().

new Iterator[String] {
  private var available = resultSet.next()
  override def hasNext: Boolean = available
  override def next(): String = {
    val string = resultSet.getString(1)
    available = resultSet.next()
    string
  }
}

Я думаю, что большинство из вышеперечисленных реализаций имеют недетерминированный метод hasNext. Вызов его два раза переместит курсор на вторую строку. Я бы посоветовал использовать что-то вроде этого:

  new Iterator[ResultSet] {
    def hasNext = {
      !resultSet.isLast
    }
    def next() = {
      resultSet.next()
      resultSet
    }
  }

Другой вариант вышеизложенного, который работает со Scala 2.12:

implicit class ResultSetOps(resultSet: ResultSet) {
 def map[T](f: ResultSet => T): Iterator[T] =
  Iterator.continually(resultSet).takeWhile(_.next()).map(f)
}