स्केल स्ट्रीम

Question

जैसे SQL परिणामसेट का इलाज करना जब मैं डेटाबेस से पूछता हूं और एक (केवल-पढ़ने के लिए, केवल-पढ़ने के लिए) परिणाम प्राप्त करता हूं, तो ResultSet डेटाबेस पंक्तियों की सूची की तरह कार्य करता है।

मैं इस परिणामसेट को स्केल Stream की तरह इलाज करने का कोई तरीका ढूंढने की कोशिश कर रहा हूं। यह रैम की बड़ी मात्रा में उपभोग नहीं करते समय filter, map, आदि जैसे परिचालनों की अनुमति देगा।

मैं अलग-अलग आइटम को निकालने के लिए एक पूंछ पुनरावर्ती पद्धति लागू है, लेकिन यह है कि सभी आइटम एक समस्या एक ही समय में स्मृति में हो, अगर ResultSet बहुत बड़ी है की आवश्यकता है:

// Iterate through the result set and gather all of the String values into a list 
// then return that list 
@tailrec 
def loop(resultSet: ResultSet, 
     accumulator: List[String] = List()): List[String] = { 
    if (!resultSet.next) accumulator.reverse 
    else { 
    val value = resultSet.getString(1) 
    loop(resultSet, value +: accumulator) 
    } 
} 

Answer 1

मैं नहीं था ' टी परीक्षण, लेकिन यह क्यों काम नहीं करेगा?

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

Answer 2

मुझे कुछ इसी तरह की आवश्यकता थी। elbowich के बहुत शांत जवाब पर बिल्डिंग, मैं यह थोड़ा लिपटे, और स्ट्रिंग के बजाय, मैं परिणाम (किसी भी स्तंभ ताकि आप प्राप्त कर सकते हैं) लौट

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

मैं मेज मेटाडाटा का उपयोग करने की जरूरत है, लेकिन इस के लिए काम करेंगे तालिका पंक्तियों (एक stmt.executeQuery (एसक्यूएल कर सकता है) md.getColumns के बजाय): @ elbowich के जवाब के लिए

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

Answer 3

उपयोगिता समारोह:

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

Answer 4

क्योंकि ResultSet सिर्फ एक परिवर्तनशील वस्तु अगले द्वारा संचालित किया जा रहा है, हम एक अगली पंक्ति की अपनी अवधारणा को परिभाषित करने की जरूरत है। इस प्रकार हम एक इनपुट समारोह के साथ ऐसा कर सकते हैं:

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

संपादित करें: स्ट्रीम या इसके बाद के संस्करण के अनुसार कुछ और करने के लिए अनुवाद।

Answer 5

यह एक निहित वर्ग के लिए एक शानदार अवसर की तरह लगता है। सबसे पहले कहीं निहित वर्ग को परिभाषित:

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