Hay alguna forma de especificar el tipo en la scala de forma dinámica

Question 1

Soy nuevo en la Chispa de la Scala, así que lo siento por la pregunta estúpida. Así que tengo un número de mesas:

table_a, table_b, ...

y el número de tipos correspondientes de estas tablas

el caso de la clase classA(...), el caso de la clase classB(...), ...

Entonces tengo que escribir un método que leer los datos de estas tablas y crear conjunto de datos:

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

Lo mismo para el resto de tablas y tipos. ¿Hay alguna forma de evitar que la rutina de código - me refiero a la función individual para cada tabla y conseguir uno? Por ejemplo:

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

A continuación, crear una lista de pares (table_name, nombre_tipo):

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

Luego llamarlo usando foreach:

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

Gracias de antemano!

Question 2

Algo como esto debería funcionar

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

Tenga en cuenta que este es un caso de descartar un valor, que es un poco de un código de olor. Desde Encoder es invariante, tableTypePairs no va a tener que útil de un tipo, y tampoco sería algo como

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

Question 3

Una opción es pasar el Class para el método, de esta manera el tipo genérico T se infiere:

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

Pero entonces no estoy seguro de cómo va a ser capaz de explotar esta lista de Dataset sin .asInstanceOf.

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

Algo como esto debería funcionar

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

Tenga en cuenta que este es un caso de descartar un valor, que es un poco de un código de olor. Desde Encoder es invariante, tableTypePairs no va a tener que útil de un tipo, y tampoco sería algo como

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

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

Una opción es pasar el Class para el método, de esta manera el tipo genérico T se infiere:

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

Pero entonces no estoy seguro de cómo va a ser capaz de explotar esta lista de Dataset sin .asInstanceOf.

Hay alguna forma de especificar el tipo en la scala de forma dinámica

Pregunta

Mejor respuesta

En otros idiomas

Esta página está en otros idiomas

Popular en esta categoría

Las preguntas más habituales en esta categoría