将SQLResultSet作为Scala流处理-HandlingSQLResultSetasaScalaStream

当从数据库查询返回一个（仅向前，只读）ResultSet时，ResultSet表现得像一个数据库行列表。为了能够对这些数据进行更灵活的操作，比如过滤、映射等，而不占用大量的内存资源，一种有效的方法是将ResultSet转换为Scala中的流（Stream）。

通过这种方式，可以在不一次性加载所有数据到内存的情况下，利用Scala强大的集合操作功能处理ResultSet中的数据。下面是一些实现这一目标的方法。

解决方案

#1 使用迭代器转换为流

可以通过创建一个自定义的迭代器来实现ResultSet到流的转换。这种方法简单且直接，如下所示：

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

#2 利用泛型和类型推断增强灵活性

为了提高代码的复用性和灵活性，可以定义一个通用的辅助函数，该函数接受ResultSet和一个处理函数，返回一个Iterator，从而可以轻松地处理不同类型的数据库字段。

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")

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

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

#3 隐式类提升易用性

使用Scala的隐式类特性，可以进一步简化ResultSet到Stream的转换过程。首先定义一个隐式类：

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
    }
  }
}

然后在需要的地方导入这个隐式类，即可直接调用toStream方法，例如：

import com.company.Implicits._

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

#4 自定义流处理函数

根据具体需求，可以进一步定制流处理函数，以适应不同的应用场景。例如，如果需要处理表的元数据，可以参考以下实现：

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

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)
})

#5 定制化的迭代器实现

为了更精确地控制ResultSet的遍历行为，可以定义一个定制化的迭代器类，明确区分hasNext和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.")
}

#6 进一步优化迭代器设计

对于更复杂的场景，可以进一步优化迭代器的设计，确保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
  }
}