Existe alguma maneira para especificar o tipo em scala dinamicamente

Question 1

Eu sou novo no Spark, Scala, então, desculpe pela pergunta estúpida. Então, eu tenho um número de mesas:

table_a, table_b, ...

e o número de correspondentes para estes tipos de tabelas

caso a classe classA(...), caso a classe classB(...), ...

Então, eu preciso escrever um métodos de leitura de dados a partir destas tabelas e criar o conjunto de dados:

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

O mesmo para outras tabelas e tipos. Existe alguma maneira de evitar a rotina de código - quero dizer, o indivíduo função para cada tabela e ficar com um? Por exemplo:

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

Em seguida, criar uma lista de pares (table_name, type_name):

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

Em seguida, chamá-lo usando o foreach:

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

Obrigado antecipadamente!

Question 2

Algo como isso deve 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)
}

Note que este é um caso de descartar um valor, que é um pouco de um código de cheiro. Desde Encoder é invariável, tableTypePairs não vai ter que útil de um tipo, e nem seria algo como

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

Question 3

Uma opção é passar o Class para o método, desta forma, o tipo genérico T vai ser inferida:

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

Mas, então, eu não tenho certeza de como você vai ser capaz de explorar essa lista de Dataset sem .asInstanceOf.

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

Algo como isso deve 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)
}

Note que este é um caso de descartar um valor, que é um pouco de um código de cheiro. Desde Encoder é invariável, tableTypePairs não vai ter que útil de um tipo, e nem seria algo como

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

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

Uma opção é passar o Class para o método, desta forma, o tipo genérico T vai ser inferida:

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

Mas, então, eu não tenho certeza de como você vai ser capaz de explorar essa lista de Dataset sem .asInstanceOf.

Existe alguma maneira para especificar o tipo em scala dinamicamente

Pergunta

Melhor resposta

Em outros idiomas

Esta página está em outros idiomas

Popular nesta categoria

Perguntas populares nesta categoria