Czy istnieje jakiś sposób na dynamicznie określić rodzaj w scala

Question 1

Jestem nowy w Spark, Scala, więc przepraszam za głupie pytanie. Tak więc, mam kilka tabel:

table_a, table_b, ...

i liczba poszczególnych typów dla tych tabel

klasa sprawy ClassA(...), klasa sprawy klasa b(...), ...

Następnie trzeba napisać metody, które odczytują dane z tych tabel i tworzą zbiór danych:

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

To samo odnosi się do innych tabel i typów. Czy jest jakiś sposób, aby uniknąć rutynowego kodu-mam na myśli indywidualną pracę dla każdej tabeli i zrobić jeden? Na przykład:

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

Następnie utwórz listę par (nazwa tabeli nazwa typu):

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

Następnie wywołać go za pomocą foreach:

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

Z góry dziękuję!

Question 2

Coś takiego powinno zadziałać

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

Należy pamiętać, że to przypadek odrzucenia wartości, która trochę przypomina zapach kodu. Z Encoder jest инвариантным, tableTypePairs nie będzie takiego dobrego typu, a także nie będzie czegoś takiego

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

Question 3

Jedną z opcji wyślij Class do metody, w taki sposób, uniwersalny typ T będzie wnioskować:

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

Ale wtedy nie jestem pewien, jak można użyć tej listy Dataset bez .asInstanceOf.

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

Coś takiego powinno zadziałać

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

Należy pamiętać, że to przypadek odrzucenia wartości, która trochę przypomina zapach kodu. Z Encoder jest инвариантным, tableTypePairs nie będzie takiego dobrego typu, a także nie będzie czegoś takiego

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

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

Jedną z opcji wyślij Class do metody, w taki sposób, uniwersalny typ T będzie wnioskować:

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

Ale wtedy nie jestem pewien, jak można użyć tej listy Dataset bez .asInstanceOf.

Czy istnieje jakiś sposób na dynamicznie określić rodzaj w scala

Pytanie

Najlepsza odpowiedź

W innych językach

Ta strona jest w innych językach

Popularne w tej kategorii

Najczęściej zadawane pytania w tej kategorii