Scala for Backend Engineering & Functional Programming · Lezione

Aggregazioni

Raggruppare e aggregare

Aggregazioni è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Perché aggregare?

Le aggregazioni riassumono molte righe in un numero minore: totali, medie e conteggi per gruppo. In Spark sono operazioni wide che possono eseguire lo shuffle dei dati nel cluster.

Aggregazioni globali

Calcoli un unico riepilogo sull'intero DataFrame con agg e funzioni come count, sum, avg, min, max.

import org.apache.spark.sql.functions._

df.agg(
  count("*").as("rows"),
  avg("age").as("avg_age")
).show()

groupBy

groupBy suddivide le righe in partizioni in base a una o più colonne, producendo un RelationalGroupedDataset pronto per l'aggregazione.

import org.apache.spark.sql.functions._

val byCity = df.groupBy("city").agg(count("*").as("people"))
byCity.show()

Aggregazioni multiple

Passi diverse espressioni di aggregazione a agg per calcolare più riepiloghi per gruppo in un'unica passata.

import org.apache.spark.sql.functions._

df.groupBy("department").agg(
  sum("salary").as("total"),
  avg("salary").as("avg"),
  max("salary").as("top")
).show()

Conteggio dei valori distinti

Usi countDistinct per contare i valori univoci e approx_count_distinct per un conteggio approssimato più rapido su dataset molto grandi.

import org.apache.spark.sql.functions._

df.agg(countDistinct("city").as("unique_cities")).show()

Filtraggio dei gruppi con having

In SQL, HAVING filtra i gruppi aggregati. Nella DSL, applichi un filter dopo agg sulla colonna calcolata.

import org.apache.spark.sql.functions._

df.groupBy("city")
  .agg(count("*").as("n"))
  .filter(col("n") > 100)
  .show()

Aggregazione in SQL

La stessa logica espressa come query SQL su una vista registrata, usando GROUP BY e HAVING.

df.createOrReplaceTempView("people")
spark.sql(
  "SELECT city, COUNT(*) AS n FROM people GROUP BY city HAVING COUNT(*) > 100"
).show()

Tabelle pivot

pivot trasforma i valori distinti di una colonna in colonne separate: è utile per tabelle a doppia entrata, ad esempio le vendite per area e trimestre.

import org.apache.spark.sql.functions._

sales.groupBy("region")
     .pivot("quarter")
     .agg(sum("amount"))
     .show()

Funzioni finestra

Le funzioni finestra aggregano i dati su un intervallo scorrevole senza accorpare le righe: sono ideali per totali progressivi o classifiche.

import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._

val w = Window.partitionBy("dept").orderBy(col("salary").desc)
df.withColumn("rank", rank().over(w)).show()

Aggregazioni degli RDD

Al livello degli RDD, aggregateByKey e reduceByKey combinano i valori per chiave con una logica personalizzata e una pre-combinazione locale per maggiore efficienza.

val pairs = sc.parallelize(Seq(("a", 10), ("a", 20), ("b", 5)))
val sums  = pairs.reduceByKey(_ + _)
// (a, 30), (b, 5)

groupBy in Scala semplice

Un analogo autosufficiente: groupBy delle raccolte Scala insieme a mapValues riproduce un'operazione Spark di raggruppamento e aggregazione.

object Main {
  def main(args: Array[String]): Unit = {
    val data = Seq(("a", 10), ("a", 20), ("b", 5))
    val sums = data.groupBy(_._1).map { case (k, v) => k -> v.map(_._2).sum }
    sums.toSeq.sortBy(_._1).foreach { case (k, s) => println(s"$k: $s") }
  }
}

Verifica rapida

Quale funzionalità aggrega i dati su un intervallo di righe senza accorparli in una sola riga per gruppo?

Riepilogo

Ha aggregato i dati in Spark:

agg con count, sum, avg, min, max
groupBy, aggregazioni multiple e filtri having
pivot e funzioni finestra
reduceByKey / aggregateByKey degli RDD

Ha completato il corso su Apache Spark.

Domande Frequenti

La lezione «Aggregazioni» è gratuita?

Sì — il testo completo di «Aggregazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Aggregazioni»?

Raggruppare e aggregare Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Aggregazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming