C'è un modo per specificare il tipo in scala in modo dinamico

Question 1

Sono nuovo in Scintilla, Scala, quindi vi chiedo scusa per la domanda stupida. Quindi ho un numero di tavole:

table_a, table_b, ...

e il numero di tipi corrispondenti per queste tabelle

caso di classe classA(...), case di classe classB(...), ...

Quindi ho bisogno di scrivere un metodi di leggere i dati di queste tabelle e creare set di dati:

def getDataFromSource: Dataset[classA] = {
       val df: DataFrame = spark.sql("SELECT * FROM table_a")
       df.as[classA]
}

Lo stesso per le altre tabelle e tipi. C'è un modo per evitare la routine di codice, parlo di singoli fucntion per ogni tabella e ottenere con uno? Per esempio:

def getDataFromSource[T: Encoder](table_name: String): Dataset[T] = {
       val df: DataFrame = spark.sql(s"SELECT * FROM $table_name")
       df.as[T]
}

Quindi creare una lista di coppie (table_name, nome_tipo):

val tableTypePairs = List(("table_a", classA), ("table_b", classB), ...)

Quindi per chiamare utilizzando foreach:

tableTypePairs.foreach(tupl => getDataFromSource[what should I put here?](tupl._1))

Grazie in anticipo!

Question 2

Qualcosa come questo dovrebbe funzionare

def getDataFromSource[T](table_name: String, encoder: Encoder[T]): Dataset[T] =
  spark.sql(s"SELECT * FROM $table_name").as(encoder)

val tableTypePairs = List(
  "table_a" -> implicitly[Encoder[classA]],
  "table_b" -> implicitly[Encoder[classB]]
)

tableTypePairs.foreach {
  case (table, enc) =>
    getDataFromSource(table, enc)
}

Nota che questo è un caso di scartare un valore, che è un po ' un codice di odore. Dal Encoder è invariante, tableTypePairs non è intenzione di avere che un utile di un tipo, e non sarebbe qualcosa di simile

tableTypePairs.map {
  case (table, enc) =>
    getDataFromSource(table, enc)
}

Question 3

Una possibilità è quella di passare il Class il metodo, in questo modo il tipo generico T sarà dedotto:

def getDataFromSource[T: Encoder](table_name: String, clazz: Class[T]): Dataset[T] = {
       val df: DataFrame = spark.sql(s"SELECT * FROM $table_name")
       df.as[T]
}

tableTypePairs.foreach { case (table name, clazz) => getDataFromSource(tableName, clazz) }

Ma poi io non sono sicuro di come sarete in grado di sfruttare questa lista di Dataset senza .asInstanceOf.

Levi Ramsey · Answer 1 · 2021-11-23T22:09:20

Qualcosa come questo dovrebbe funzionare

def getDataFromSource[T](table_name: String, encoder: Encoder[T]): Dataset[T] =
  spark.sql(s"SELECT * FROM $table_name").as(encoder)

val tableTypePairs = List(
  "table_a" -> implicitly[Encoder[classA]],
  "table_b" -> implicitly[Encoder[classB]]
)

tableTypePairs.foreach {
  case (table, enc) =>
    getDataFromSource(table, enc)
}

Nota che questo è un caso di scartare un valore, che è un po ' un codice di odore. Dal Encoder è invariante, tableTypePairs non è intenzione di avere che un utile di un tipo, e non sarebbe qualcosa di simile

tableTypePairs.map {
  case (table, enc) =>
    getDataFromSource(table, enc)
}

Gaël J · Answer 2 · 2021-11-23T22:02:48

Una possibilità è quella di passare il Class il metodo, in questo modo il tipo generico T sarà dedotto:

def getDataFromSource[T: Encoder](table_name: String, clazz: Class[T]): Dataset[T] = {
       val df: DataFrame = spark.sql(s"SELECT * FROM $table_name")
       df.as[T]
}

tableTypePairs.foreach { case (table name, clazz) => getDataFromSource(tableName, clazz) }

Ma poi io non sono sicuro di come sarete in grado di sfruttare questa lista di Dataset senza .asInstanceOf.

C'è un modo per specificare il tipo in scala in modo dinamico

Domanda

Migliore risposta

In altre lingue

Questa pagina è in altre lingue

Popolare in questa categoria

Domande popolari in questa categoria