Scala PySpark Big Data en la práctica: el código y los comandos que realmente importan

// Escribe estos comandos uno por uno en el spark-shell:

scala> import spark.implicits._
// ya importado automáticamente, pero útil si creas tu propia SparkSession

scala> val data = Seq(("Java", "20000"), ("Python", "100000"), ("Scala", "3000"))
// data: Seq[(String, String)] = List((Java,20000), (Python,100000), (Scala,3000))

scala> val df = data.toDF()
// df: org.apache.spark.sql.DataFrame = [_1: string, _2: string]

scala> df.show()
// +------+------+
// |    _1|    _2|
// +------+------+
// |  Java| 20000|
// |Python|100000|
// | Scala|  3000|
// +------+------+

scala> val df = data.toDF("langage", "offres")
scala> df.show()
// +-------+------+
// |langage|offres|
// +-------+------+
// |   Java| 20000|
// | Python|100000|
// |  Scala|  3000|
// +-------+------+

// Mostrar la ayuda completa (lista de todos los comandos especiales)
scala> :help

// Paso 1: escribe :paste y pulsa Intro
scala> :paste
// Entering paste mode (ctrl-D to finish)

// Paso 2: pega tu código multilínea
val noms = Seq("Alice", "Bob", "Charlie")
val rdd = sc.parallelize(noms)
val majuscules = rdd.map(_.toUpperCase)
majuscules.collect()

// Paso 3: pulsa Ctrl+D para ejecutar
// Exiting paste mode, now interpreting.

// noms: Seq[String] = List(Alice, Bob, Charlie)
// rdd: org.apache.spark.rdd.RDD[String] = ...
// majuscules: org.apache.spark.rdd.RDD[String] = ...
// res0: Array[String] = Array(ALICE, BOB, CHARLIE)

val jour = "Mercredi"

val typeJour = jour match {
  case "Lundi" | "Mardi" | "Mercredi" | "Jeudi" | "Vendredi" =>
    "Jour ouvré"
  case "Samedi" | "Dimanche" =>
    "Week-end"
  case _ =>
    "Jour inconnu"  // _ = la casilla "Otros" del triaje postal
}

println(typeJour)  // "Jour ouvré"

val note = 15

val mention = note match {
  case 20                 => "Parfait"
  case 16 | 17 | 18 | 19 => "Très bien"
  case 14 | 15            => "Bien"
  case 12 | 13            => "Assez bien"
  case 10 | 11            => "Passable"
  case _                  => "Insuffisant"
}

println(mention)  // "Bien"

// Scala : match es una expresión, se puede asignar directamente
val categorie = age match {
  case a if a < 18  => "Mineur"
  case a if a < 65  => "Adulte"
  case _            => "Senior"
}

// También se puede usar como argumento de una función
println(age match {
  case a if a < 18 => "Mineur"
  case _           => "Adulte"
})

// O en una interpolación de cadena
val message = s"Statut : ${age match {
  case a if a < 18 => "Mineur"
  case _           => "Adulte"
}}"

// Java : el switch (antes de Java 14) no devuelve un valor
// Había que escribir :
String categorie;
switch (age) {
  case ...: categorie = "Mineur"; break;
  default:  categorie = "Adulte";
}
// Java 14+ añadió las switch expressions para cubrir esta carencia

# Python 3.10+ structural pattern matching
jour = "Mercredi"
match jour:
    case "Lundi" | "Mardi" | "Mercredi" | "Jeudi" | "Vendredi":
        type_jour = "Jour ouvre"
    case "Samedi" | "Dimanche":
        type_jour = "Week-end"
    case _:
        type_jour = "Jour inconnu"

# Diferencia : en Python, match es una instrucción (sin asignación directa)
# En Scala : val x = valor match { ... }  <-- expresión que devuelve un valor
# En Python : debes asignar en cada rama manualmente

# Python < 3.10 : sin match/case, se usa if/elif/else
jour = "Mercredi"

if jour in ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi"):
    type_jour = "Jour ouvre"
elif jour in ("Samedi", "Dimanche"):
    type_jour = "Week-end"
else:
    type_jour = "Jour inconnu"