Bab 3.

DataFrames
DataFrame adalah kumpulan data terdistribusi yang tidak dapat diubah yang diatur ke dalam kolom
bernama yang analog dengan tabel dalam database relasional. Diperkenalkan sebagai fitur eksperimental
dalam Apache Spark 1.0 sebagai SchemaRDD, mereka diubah namanya menjadi DataFrames sebagai
bagian dari rilis Apache Spark 1.3. Untuk pembaca yang terbiasa dengan Python Pandas DataFrame atau
R DataFrame, Spark DataFrame adalah konsep serupa karena memungkinkan pengguna untuk dengan
mudah bekerja dengan data terstruktur (misalnya, tabel data); Ada beberapa perbedaan juga, jadi tolong
redam harapan Anda.
Dengan memaksakan struktur ke kumpulan data terdistribusi, ini memungkinkan pengguna Spark untuk
mengkueri data terstruktur di Spark SQL atau menggunakan metode ekspresi (bukan lambda). Dalam bab
ini, kita akan menyertakan sampel kode menggunakan kedua metode tersebut. Dengan menyusun data
Anda, ini memungkinkan mesin Apache Spark – khususnya, Catalyst Optimizer – untuk meningkatkan
kinerja kueri Spark secara signifikan. Di API Spark sebelumnya (yaitu, RDD), mengeksekusi kueri di
Python bisa jauh lebih lambat karena overhead komunikasi antara Java JVM dan Py4J.
Note
Jika Anda terbiasa bekerja dengan DataFrame di versi Spark sebelumnya (yaitu Spark 1.x), Anda akan
melihat bahwa di Spark 2.0 kami menggunakan SparkSession alih-alih SQLContext. Berbagai konteks
Spark: HiveContext, SQLContext, StreamingContext, dan SparkContext telah digabungkan bersama di
SparkSession. Dengan cara ini Anda akan bekerja dengan sesi ini hanya sebagai titik masuk untuk
membaca data, bekerja dengan metadata, konfigurasi, dan manajemen sumber daya kluster.
Untuk informasi lebih lanjut, silakan lihat Cara menggunakan SparkSession di Apache Spark
2.0(http://bit.ly/2br0Fr1 ).
Dalam bab ini, Anda akan belajar tentang hal-hal berikut:
 Komunikasi Python ke RDD
 Penyegaran cepat dari Catalyst Optimizer Spark
 Mempercepat PySpark dengan DataFrame
 Membuat DataFrame
 Kueri DataFrame Sederhana
 Interoperasi dengan RDD
 Mengkueri dengan DataFrame API
 Mengkueri dengan Spark SQL
 Menggunakan DataFrame untuk kinerja penerbangan tepat waktu
Komunikasi Python ke RDD (Python to RDD communications)
Setiap kali program PySpark dijalankan menggunakan RDD, ada overhead yang berpotensi besar untuk
mengeksekusi pekerjaan. Seperti yang disebutkan dalam diagram berikut, dalam driver PySpark, Spark
Context menggunakan Py4j untuk meluncurkan JVM menggunakan JavaSparkContext. Setiap
transformasi RDD awalnya dipetakan ke objek PythonRDD di Java.
Setelah tugas-tugas ini didorong ke Spark Worker, objek PythonRDD meluncurkan subproses Python
menggunakan pipa untuk mengirim kode dan data yang akan diproses dalam Python:
Meskipun pendekatan ini memungkinkan PySpark untuk mendistribusikan pemrosesan data ke beberapa
subproses Python pada beberapa pekerja, seperti yang Anda lihat, ada banyak peralihan konteks dan
overhead komunikasi antara Python dan JVM.
Note
Sumber daya yang sangat baik tentang kinerja PySpark adalah Holden Karau Meningkatkan Kinerja
PySpark: Kinerja Spark di luar JVM: http://bit.ly/2bx89bn .
Catalyst Optimizer refresh
Seperti yang disebutkan dalam Bab 1, Memahami Spark, salah satu alasan utama mesin Spark SQL begitu
cepat adalah karena Catalyst Optimizer. Untuk pembaca dengan latar belakang basis data, diagram ini
terlihat mirip dengan perencana logis/fisik dan model biaya/optimalisasi berbasis biaya dari sistem
manajemen basis data relasional (RDBMS):
Pentingnya hal ini adalah, alih-alih segera memproses kueri, Catalyst Optimizer mesin Spark
mengkompilasi dan mengoptimalkan rencana logis dan memiliki pengoptimal biaya yang menentukan
rencana fisik paling efisien yang dihasilkan.
Note
Seperti yang disebutkan di bab-bab sebelumnya, sementara Spark SQL Engine memiliki pengoptimalan
berbasis aturan dan berbasis biaya yang mencakup (tetapi tidak terbatas pada) predikat push down dan
pemangkasan kolom. Ditargetkan untuk rilis Apache Spark 2.2, item jira [SPARK-16026] Kerangka Kerja
Pengoptimal Berbasis Biaya di https://issues.apache.org/jira/browse/SPARK-16026 adalah tiket payung
untuk mengimplementasikan kerangka kerja pengoptimal berbasis biaya di luar pemilihan gabungan
siaran. Untuk informasi lebih lanjut, silakan merujuk ke Spesifikasi Desain Pengoptimalan Berbasis Biaya
Spark di http://bit.ly/2li1t4T .
Sebagai bagian dari Project Tungsten, ada peningkatan lebih lanjut pada kinerja dengan menghasilkan
kode byte (pembuatan kode atau codegen) alih-alih menafsirkan setiap baris data. Temukan detail lebih
lanjut tentang Tungsten di bagian Proyek Tungsten di Bab 1, Memahami Spark.
Seperti yang disebutkan sebelumnya, pengoptimal didasarkan pada konstruksi pemrograman fungsional
dan dirancang dengan dua tujuan: untuk memudahkan penambahan teknik dan fitur pengoptimalan baru
ke Spark SQL, dan untuk memungkinkan pengembang eksternal memperluas pengoptimal (misalnya,
menambahkan aturan khusus sumber data, dukungan untuk tipe data baru, dan sebagainya).
Note
Untuk informasi lebih lanjut, silakan merujuk ke presentasi Michael Armbrust yang luar biasa, Structuring
Spark: SQL DataFrames, Datasets, and Streaming di http://bit.ly/2cJ508x .
Untuk pemahaman lebih lanjut tentang Catalyst Optimizer, silakan merujuk ke Deep Dive into Spark
SQL's Catalyst Optimizer di http://bit.ly/2bDVB1T .
Juga, untuk informasi lebih lanjut tentang Project Tungsten, silakan merujuk ke Project Tungsten:
Membawa Apache Spark Lebih Dekat ke Bare Metal di http://bit.ly/2bQIlKY , dan Apache Spark sebagai
Compiler: Bergabung dengan Miliar Baris per Detik di Laptop di http://bit.ly/2bDWtnc .
Mempercepat PySpark dengan DataFrame
Pentingnya DataFrames dan Catalyst Optimizer (dan Project Tungsten) adalah peningkatan kinerja kueri
PySpark jika dibandingkan dengan kueri RDD yang tidak dioptimalkan. Seperti yang ditunjukkan pada
gambar berikut, sebelum diperkenalkannya DataFrames, kecepatan kueri Python seringkali dua kali lebih
lambat daripada kueri Scala yang sama menggunakan RDD. Biasanya, perlambatan performa kueri ini
disebabkan oleh overhead komunikasi antara Python dan JVM:

Sumber: Memperkenalkan DataFrames di Apache-spark untuk Ilmu Data Skala Besar di

http://bit.ly/2blDBI1
Dengan DataFrames, tidak hanya ada peningkatan yang signifikan dalam kinerja Python, sekarang ada
paritas kinerja antara Python, Scala, SQL, dan R.
Tip
Penting untuk dicatat bahwa sementara, dengan DataFrames, PySpark seringkali jauh lebih cepat, ada
beberapa pengecualian. Yang paling menonjol adalah penggunaan UDF Python, yang menghasilkan
komunikasi bolak-balik antara Python dan JVM. Catatan, ini akan menjadi skenario terburuk yang akan
serupa jika komputasi dilakukan pada RDD.
Python dapat memanfaatkan pengoptimalan kinerja di Spark bahkan saat basis kode untuk Catalyst
Optimizer ditulis dalam Scala. Pada dasarnya, ini adalah pembungkus Python dari sekitar 2.000 baris kode
yang memungkinkan kueri PySpark DataFrame menjadi lebih cepat secara signifikan.
Secara keseluruhan, Python DataFrame (serta SQL, Scala DataFrames, dan R DataFrames) semuanya
dapat menggunakan Catalyst Optimizer (sesuai diagram yang diperbarui berikut):
Note
Untuk informasi lebih lanjut, silakan merujuk ke posting blog Memperkenalkan DataFrames di Apache
Spark untuk Ilmu Data Skala Besar di http://bit.ly/2blDBI1, serta presentasi Spark Summit 2015 Reynold
Xin, From DataFrames to Tungsten: A Peek into Spark's Future at http://bit.ly/2bQN92T
Membuat DataFrame
Biasanya, Anda akan membuat DataFrame dengan mengimpor data menggunakan SparkSession (atau
memanggil spark di shell PySpark).
Tip
Dalam versi Spark 1.x, Anda biasanya harus menggunakan sqlContext.
Di bab-bab mendatang, kita akan membahas cara mengimpor data ke sistem file lokal Anda, Hadoop
Distributed File System (HDFS), atau sistem penyimpanan cloud lainnya (misalnya, S3 atau WASB).
Untuk bab ini, kami akan fokus pada menghasilkan data DataFrame Anda sendiri langsung di dalam Spark
atau memanfaatkan sumber data yang sudah tersedia dalam Edisi Komunitas Databricks.
Note
Untuk petunjuk tentang cara mendaftar ke Databricks Edisi Komunitas, lihat bab bonus, Penawaran Spark
Cloud Gratis.
Pertama, alih-alih mengakses sistem file, kita akan membuat DataFrame dengan menghasilkan data.
Dalam hal ini, pertama-tama kita akan membuat string JSONRDD RDD dan kemudian mengubahnya
menjadi DataFrame. Cuplikan kode ini membuat RDD yang terdiri dari swimmers (ID, nama, usia, dan
warna mata mereka) dalam format JSON.
Menghasilkan data JSON kita sendiri
Di bawah ini, kita akan menghasilkan string JSONRDD RDD terlebih dahulu:
stringJSONRDD = sc.parallelize(("""
{ "id": "123",
"name": "Katie",
"age": 19,
"eyeColor": "brown"
}""", """{ "id": "234",
"name": "Michael",
"age": 22,
"eyeColor": "green" }
""",
"""{
"id": "345",
"name": "Simone",
"age": 23,
"eyeColor": "blue"
}""")
)

setelah kita membuat RDD, kita akan mengubahnya menjadi DataFrame dengan menggunakan metode
SparkSession read.json (yaitu, spark.read.json(...)). Kita juga akan membuat tabel sementara dengan
menggunakan metode .createOrReplaceTempView.

Note

Di Spark 1.x, metode ini adalah.registerTempTable, yang tidak digunakan lagi sebagai bagian dari Spark
2.x.

Membuat DataFrame

Berikut adalah kode untuk membuat DataFrame:

swimmersJSON = spark.read.json(stringJSONRDD)

Membuat tabel sementara

Berikut adalah kode untuk membuat tabel sementara:

swimmersJSON.createOrReplaceTempView("swimmersJSON")

Seperti disebutkan dalam bab sebelumnya, banyak operasi RDD adalah transformasi, yang tidak
dieksekusi sampai operasi tindakan dieksekusi. Misalnya, dalam cuplikan kode sebelumnya, sc.parallelize
adalah transformasi yang dijalankan saat mengonversi dari RDD ke DataFrame dengan menggunakan
spark.read.json. Perhatikan bahwa, dalam cuplikan layar buku catatan cuplikan kode ini (di dekat kiri
bawah), pekerjaan Spark tidak dijalankan hingga sel kedua yang berisi operasi spark.read.json.

Tip

Ini adalah cuplikan layar dari Databricks Community Edition, tetapi semua sampel kode dan cuplikan
layar UI Spark dapat dieksekusi/dilihat dalam raga apa pun dari Apache Spark 2.x.

Untuk lebih menekankan poin tersebut, di panel kanan gambar berikut, kami menyajikan grafik eksekusi
DAG.

Note
Sumber daya yang bagus untuk lebih memahami visualisasi DAG UI Spark adalah posting blog
Memahami Aplikasi Apache Spark Anda Melalui Visualisasi di http://bit.ly/2cSemkv .

Dalam cuplikan layar berikut, Anda dapat melihat operasi sparallelize pekerjaan Spark berasal dari sel
pertama yang menghasilkan string RDDJSONRDD, sedangkan operasi map dan mapPartitions adalah
operasi yang diperlukan untuk membuat DataFrame:

Spark UI visualisasi DAG dari pekerjaan spark.read.json(stringJSONRDD).

Dalam cuplikan layar berikut, Anda dapat melihat tahapan untuk operasi paralelisasi berasal dari sel
pertama yang menghasilkan string RDDJSONRDD, sedangkan operasi map dan mapPartitions adalah
operasi yang diperlukan untuk membuat DataFrame:
 Spark UI
dari visualisasi DAG dari tahapan dalam
spark.read.json(stringJSONRDD) pekerjaan.

Penting untuk dicatat bahwa parallelize, map, dan mapPartitions semuanya adalah transformasi RDD.
Dibungkus dalam operasi DataFrame, spark.read.json (dalam hal ini), tidak hanya transformasi RDD,
tetapi juga tindakan yang mengubah RDD menjadi DataFrame. Ini adalah panggilan penting, karena
meskipun Anda menjalankan operasi DataFrame, untuk men-debug operasi Anda, Anda perlu ingat bahwa
Anda akan memahami operasi RDD dalam UI Spark.

Perhatikan bahwa membuat tabel sementara adalah transformasi DataFrame dan tidak dijalankan hingga
tindakan DataFrame dijalankan (misalnya, dalam kueri SQL yang akan dijalankan di bagian berikut).

Note

Transformasi dan tindakan DataFrame mirip dengan transformasi dan tindakan RDD karena ada
serangkaian operasi yang malas (transformasi). Tapi, dibandingkan dengan RDD, operasi DataFrames
tidak malas, terutama karena Catalyst Optimizer. Untuk informasi lebih lanjut, silakan merujuk ke buku
Holden Karau dan Rachel Warren High Performance Spark, http://highperformancespark.com/ .

Kueri DataFrame Sederhana

Sekarang setelah Anda membuat swimmersJSON DataFrame, kita akan dapat menjalankan DataFrame
API, serta kueri SQL terhadapnya. Mari kita mulai dengan kueri sederhana yang menunjukkan semua
baris dalam DataFrame.

Kueri DataFrame API

Untuk melakukan ini menggunakan DataFrame API, Anda dapat menggunakan metode show(), yang
mencetak n baris pertama ke konsol:

Tip

Menjalankan metode .show() akan secara default menyajikan 10 baris pertama.

# API Bingkai Data
swimmersJSON.show()

Ini memberikan output berikut:

Kueri SQL
Jika Anda lebih suka menulis pernyataan SQL, Anda dapat menulis kueri berikut:

spark.sql("pilih * dari swimmersJSON").collect()

Ini akan memberikan output berikut:

Kami menggunakan metode .collect(), yang mengembalikan semua catatan sebagai daftar objek Row.
Perhatikan bahwa Anda dapat menggunakan metode collect() atau show() untuk kueri DataFrame dan
SQL. Pastikan bahwa jika Anda menggunakan .collect(), ini untuk DataFrame kecil, karena akan
mengembalikan semua baris di DataFrame dan memindahkannya kembali dari eksekutor ke driver.
Sebagai gantinya, Anda dapat menggunakan take(<n>) atau show(<n>), yang memungkinkan Anda
membatasi jumlah baris yang dikembalikan dengan menentukan <n> :

Tip

Perhatikan bahwa, jika Anda menggunakan Databricks, Anda dapat menggunakan perintah %sql dan
menjalankan pernyataan SQL Anda langsung di dalam sel notebook, seperti yang disebutkan.

Interoperasi dengan RDD

Ada dua metode berbeda untuk mengonversi RDD yang ada menjadi DataFrame (atau Datasets[T]):
menyimpulkan skema menggunakan refleksi, atau menentukan skema secara terprogram. Yang pertama
memungkinkan Anda untuk menulis kode yang lebih ringkas (ketika aplikasi Spark Anda sudah
mengetahui skema), sedangkan yang terakhir memungkinkan Anda membuat DataFrame ketika kolom
dan jenis datanya hanya terungkap pada waktu proses. Catatan, refleksi mengacu pada refleksi skema
sebagai lawan dari refleksi Python.

Menyimpulkan skema menggunakan refleksi

Dalam proses membangun DataFrame dan menjalankan kueri, kami melewatkan fakta bahwa skema
untuk DataFrame ini ditentukan secara otomatis. Awalnya, objek baris dibangun dengan meneruskan
daftar pasangan kunci/nilai sebagai **kwargs ke kelas baris. Kemudian, Spark SQL mengonversi RDD
objek baris ini menjadi DataFrame, di mana kuncinya adalah kolom dan jenis data disimpulkan dengan
mengambil sampel data.

Tip

Konstruksi **kwargs memungkinkan Anda untuk meneruskan sejumlah parameter variabel ke metode
saat runtime.

Kembali ke kode, setelah awalnya membuat swimmersJSON DataFrame, tanpa menentukan skema, Anda
akan melihat definisi skema dengan menggunakan metode printSchema():
# Cetak skema
swimmersJSON.printSchema()

Ini memberikan output berikut:

Tetapi bagaimana jika kita ingin menentukan skema karena, dalam contoh ini, kita tahu bahwa id
sebenarnya adalah long alih-alih string?

Menentukan skema secara terprogram

Dalam hal ini, mari kita tentukan skema secara terprogram dengan memasukkan tipe data Spark SQL
(pyspark.sql.types) dan menghasilkan beberapa data .csv untuk contoh ini:
# Import types
from pyspark.sql.types import *

# Generate comma delimited data

stringCSVRDD = sc.parallelize([
(123, 'Katie', 19, 'brown'),
(234, 'Michael', 22, 'green'),
(345, 'Simone', 23, 'blue')
])

Pertama, kita akan mengkodekan skema sebagai string, sesuai variabel [skema] di bawah ini. Kemudian
kita akan mendefinisikan skema menggunakan StructType dan StructField:
# Specify schema
schema = StructType([
StructField("id", LongType(), True),
StructField("name", StringType(), True),
StructField("age", LongType(), True),
StructField("eyeColor", StringType(), True)
])

Catatan, kelas StructField dipecah dalam hal:

 name: Nama bidang ini

 dataType: Jenis data bidang ini
 nullable: Menunjukkan apakah nilai bidang ini dapat menjadi null

Terakhir, kita akan menerapkan skema (skema) yang kita buat ke stringCSVRDD RDD (yaitu, data
generated.csv) dan membuat tampilan sementara sehingga kita dapat menanyakannya menggunakan SQL:
# Apply the schema to the RDD and Create DataFrame
swimmers = spark.createDataFrame(stringCSVRDD, schema)

# Membuat tampilan sementara menggunakan DataFrame

swimmers.createOrReplaceTempView("swimmers")

Dengan contoh ini, kita memiliki kontrol yang lebih halus atas skema dan dapat menentukan bahwa id
adalah long (berlawanan dengan string di bagian sebelumnya):

swimmers.printSchema()

Ini memberikan output berikut:

Tip

Dalam banyak kasus, skema dapat disimpulkan (sesuai bagian sebelumnya) dan Anda tidak perlu
menentukan skema, seperti pada contoh sebelumnya ini.

Mengkueri dengan DataFrame API

Seperti yang disebutkan di bagian sebelumnya, Anda dapat memulai dengan menggunakan collect(),
show(), atau take() untuk melihat data dalam DataFrame Anda (dengan dua yang terakhir termasuk opsi
untuk membatasi jumlah baris yang dikembalikan).

Jumlah baris

Untuk mendapatkan jumlah baris dalam DataFrame, Anda dapat menggunakan metode count():

swimmers.count()

Ini memberikan output berikut:

Keluar[13]: 3

Menjalankan pernyataan filter

Untuk menjalankan pernyataan filter, Anda dapat menggunakan klausa filter; Dalam cuplikan kode
berikut, kita menggunakan klausa select untuk menentukan kolom yang akan dikembalikan juga:
# Get the id, age where age = 22
swimmers.select("id", "age").filter("age = 22").show()

# Another way to write the above query is below

swimmers.select(swimmers.id, swimmers.age).filter(swimmers.age == 22).show()

Output dari kueri ini adalah memilih hanya kolom id dan usia, di mana usia = 22:
Jika kita hanya ingin mendapatkan kembali nama swimmers yang memiliki warna mata yang diawali
dengan huruf b, kita dapat menggunakan sintaks seperti SQL, seperti, seperti yang ditunjukkan pada kode
berikut:

# Get the name, eyeColor where eyeColor like 'b%' swimmers.select("name", "eyeColor").filter("eyeColor
like 'b%'").show()

Hasilnya adalah sebagai berikut:

Mengkueri dengan SQL

Mari kita jalankan kueri yang sama, kecuali kali ini, kita akan melakukannya menggunakan kueri SQL
terhadap DataFrame yang sama. Ingatlah bahwa DataFrame ini dapat diakses karena kami menjalankan
metode .createOrReplaceTempView untuk swimmers.

Jumlah baris

Berikut ini adalah cuplikan kode untuk mendapatkan jumlah baris dalam DataFrame Anda menggunakan
SQL:

spark.sql("select count(1) from swimmers").show()

Hasilnya adalah sebagai berikut:

Menjalankan pernyataan filter menggunakan metode where

Klausul Untuk menjalankan pernyataan filter menggunakan SQL, Anda dapat menggunakan klausa
where, seperti yang disebutkan dalam cuplikan kode berikut:

# Get the id, age where age = 22 in SQL

spark.sql("select id, age from swimmers where age = 22").show()

Output dari kueri ini adalah memilih hanya kolom id dan usia di mana usia = 22:

Seperti halnya kueri DataFrame API, jika kita ingin mendapatkan kembali nama swimmers yang memiliki
warna mata yang dimulai dengan huruf b saja, kita juga dapat menggunakan sintaks serupa:

spark.sql( "pilih nama, eyeColor dari swimmers di mana eyeColor seperti 'b%'").show()

Hasilnya adalah sebagai berikut:

Tip

Untuk informasi selengkapnya, silakan lihat Panduan Spark SQL, DataFrames, dan Himpunan Data di
http://bit.ly/2cd1wyx

Note

Catatan penting saat bekerja dengan Spark SQL dan DataFrames adalah https://www.iteblog.com bahwa
meskipun mudah untuk bekerja dengan CSV, JSON, dan berbagai format data, format penyimpanan yang
paling umum untuk kueri analitik Spark SQL adalah format file Parquet. Ini adalah format kolom yang
didukung oleh banyak sistem pemrosesan data lainnya dan Spark SQL mendukung pembacaan dan
penulisan file Parquet yang secara otomatis mempertahankan skema data asli. Untuk informasi lebih
lanjut, silakan merujuk ke Panduan Pemrograman Spark SQL terbaru > Parquet Files di:
http://spark.apache.org/docs/latest/sql-programming guide.html#parquet-files . Selain itu, ada banyak
pengoptimalan performa yang berkaitan dengan Parquet, termasuk (namun tidak terbatas pada) Penemuan
Partisi Otomatis dan Migrasi Skema untuk Parquet di https://databricks.com/blog/2015/03/24/spark-sql-
graduates-from-alpha in-spark-1-3.html dan Bagaimana Apache Spark melakukan penghitungan cepat
menggunakan metadata parket di https://github.com/dennyglee/databricks/blob/master/misc/parquet
count-metadata-explanation.md

Skenario DataFrame – penerbangan tepat waktu

performa Untuk menampilkan jenis kueri yang dapat Anda lakukan dengan DataFrames, mari kita lihat
kasus penggunaan performa penerbangan tepat waktu. Kami akan menganalisis Kinerja Maskapai
Penerbangan Tepat Waktu dan Penyebab Keterlambatan Penerbangan: Data Tepat Waktu
(http://bit.ly/2ccJPPM), dan menggabungkannya dengan kumpulan data bandara, yang diperoleh dari
Bandara Penerbangan Terbuka, maskapai penerbangan, dan data rute (http://bit.ly/2ccK5hw), untuk lebih
memahami variabel yang terkait dengan penundaan penerbangan.

Tip

Untuk bagian ini, kami akan menggunakan Databricks Community Edition (penawaran gratis produk
Databricks), yang bisa Anda dapatkan di https://databricks.com/try-databricks . Kami akan menggunakan
visualisasi dan himpunan data yang dimuat sebelumnya dalam Databricks untuk memudahkan Anda fokus
menulis kode dan menganalisis hasilnya.

Jika Anda lebih suka menjalankannya di lingkungan Anda sendiri, Anda dapat menemukan kumpulan data
yang tersedia di repositori GitHub kami untuk buku ini di
https://github.com/drabastomek/learningPySpark

Menyiapkan himpunan data sumber

Pertama-tama kita akan memproses bandara sumber dan himpunan data kinerja penerbangan dengan
menentukan lokasi jalur filenya dan mengimpornya menggunakan SparkSession:

# Set File Paths

flightPerfFilePath = "/databricks-datasets/flights/departuredelays.csv"
airportsFilePath = "/databricks-datasets/flights/airport-codes-na.txt"

# Obtain Airports dataset

airports = spark.read.csv(airportsFilePath, header='true',
inferSchema='true', sep='\t')
airports.createOrReplaceTempView("airports")

# Obtain Departure Delays dataset

flightPerf = spark.read.csv(flightPerfFilePath, header='true')
flightPerf.createOrReplaceTempView("FlightPerformance")

# Cache the Departure Delays dataset

flightPerf.cache()

Perhatikan bahwa kami mengimpor data menggunakan pembaca CSV (com.databricks.spark.csv), yang
berfungsi untuk pemibus yang ditentukan (perhatikan bahwa data bandara dibatasi tab, sedangkan data
performa penerbangan dibatasi koma). Terakhir, kami menyimpan himpunan data penerbangan sehingga
kueri berikutnya akan lebih cepat.

Bergabung dengan kinerja penerbangan dan bandara

Salah satu tugas yang lebih umum dengan DataFrames/SQL adalah menggabungkan dua himpunan data
yang berbeda; Ini sering kali merupakan salah satu operasi yang lebih menuntut (dari perspektif kinerja).
Dengan DataFrames, banyak pengoptimalan performa untuk gabungan ini disertakan secara default:

# Query Sum of Flight Delays by City and Origin Code

# (for Washington State)
spark.sql("""
select a.City,
f.origin,
sum(f.delay) as Delays
from FlightPerformance f
join airports a
on a.IATA = f.origin
where a.State = 'WA'
group by a.City, f.origin
order by sum(f.delay) desc"""
).show()
Dalam skenario kami, kami menanyakan total penundaan berdasarkan kota dan kode asal untuk negara
bagian Washington. Ini akan mengharuskan penggabungan data kinerja penerbangan dengan data bandara
dengan kode Asosiasi Transportasi Udara Internasional (IATA). Output kueri adalah sebagai berikut:

Dengan menggunakan notebook (seperti Databricks, iPython, Jupyter, dan Apache Zeppelin), Anda dapat
lebih mudah menjalankan dan memvisualisasikan kueri Anda. Dalam contoh berikut, kita akan
menggunakan buku catatan Databricks. Dalam notebook Python kita, kita dapat menggunakan fungsi
%sql untuk mengeksekusi pernyataan SQL dalam sel notebook tersebut:
%sql
-- Query Sum of Flight Delays by City and Origin Code (for Washington State)
select a.City, f.origin, sum(f.delay) as Delays
from FlightPerformance f
join airports a
on a.IATA = f.origin
where a.State = 'WA'
group by a.City, f.origin
order by sum(f.delay) desc

Ini sama dengan kueri sebelumnya, tetapi karena pemformatan, lebih mudah dibaca. Dalam contoh buku
catatan Databricks kami, kami dapat dengan cepat memvisualisasikan data ini ke dalam bagan batang:
Memvisualisasikan data kinerja penerbangan kami

Mari kita lanjutkan memvisualisasikan data kita, tetapi dipecah berdasarkan semua negara bagian di benua
AS:
%sql
—Query Sum of Flight Delays by State (for the US)
select a.State, sum(f.delay) as Delays
from FlightPerformance f
join airports a
on a.IATA = f.origin
where a.Country = 'USA'
group by a.State

Bagan batang keluaran adalah sebagai berikut:

Tapi, akan lebih keren untuk melihat data ini sebagai peta; Klik ikon bagan batang di kiri bawah bagan,
dan Anda dapat memilih dari banyak navigasi asli yang berbeda, termasuk peta:
Salah satu manfaat utama DataFrame adalah bahwa informasi disusun mirip dengan tabel. Oleh karena itu,
apakah Anda menggunakan notebook atau alat BI favorit Anda, Anda akan dapat dengan cepat
memvisualisasikan data Anda.

Tip

Anda dapat menemukan daftar lengkap metode pyspark.sql.DataFrame di http://bit.ly/2bkUGnT .

Anda dapat menemukan daftar lengkap pyspark.sql.functions di http://bit.ly/2bTAzLT .

API Himpunan Data Spark

Setelah diskusi tentang Spark DataFrame ini, mari kita rekap singkat tentang Spark Dataset API.
Diperkenalkan di Apache Spark 1.6, tujuan Kumpulan Data Spark adalah untuk menyediakan API yang
memungkinkan pengguna mengekspresikan transformasi pada objek domain dengan mudah, sekaligus
memberikan kinerja dan manfaat mesin eksekusi Spark SQL yang kuat. Sebagai bagian dari rilis Spark 2.0
(dan seperti yang disebutkan dalam diagram di bawah), API DataFrame digabungkan ke dalam API
Himpunan Data sehingga menyatukan kemampuan pemrosesan data di semua pustaka. Karena penyatuan
ini, pengembang sekarang memiliki lebih sedikit konsep untuk dipelajari atau diingat, dan bekerja dengan
satu API tingkat tinggi dan aman jenis – yang disebut Dataset:
Secara konseptual, Spark DataFrame adalah alias untuk kumpulan objek generik Dataset[Row], di mana
Baris adalah objek JVM generik yang tidak diketik. Dataset, sebaliknya, adalah kumpulan objek JVM
yang diketik dengan kuat, ditentukan oleh kelas kasus yang Anda tentukan, di Scala atau Java. Poin
terakhir ini sangat penting karena ini berarti bahwa API Himpunan Data tidak didukung oleh PySpark
karena kurangnya manfaat dari peningkatan jenis. Catatan, untuk bagian API Himpunan Data yang tidak
tersedia di PySpark, mereka dapat diakses dengan mengonversi ke RDD atau dengan menggunakan UDF.
Untuk informasi lebih lanjut, silakan merujuk ke jira [SPARK 13233]: Kumpulan Data Python di
http://bit.ly/2dbfoFT .

Ringkasan

Dengan Spark DataFrames, pengembang Python dapat menggunakan lapisan abstraksi yang lebih
sederhana yang juga berpotensi lebih cepat secara signifikan. Salah satu alasan utama Python awalnya
lebih lambat dalam Spark adalah karena lapisan komunikasi antara sub-proses Python dan JVM. Untuk
pengguna Python DataFrame, kami memiliki pembungkus Python di sekitar Scala DataFrames yang
menghindari overhead komunikasi sub-proses Python/JVM. Spark DataFrames memiliki banyak
peningkatan kinerja melalui Catalyst Optimizer dan Project Tungsten yang telah kami ulas di bab ini.
Dalam bab ini, kami juga meninjau cara bekerja dengan Spark DataFrames dan mengerjakan skenario
performa penerbangan tepat waktu menggunakan DataFrames.

Dalam bab ini, kami membuat dan bekerja dengan DataFrame dengan menghasilkan data atau
memanfaatkan kumpulan data yang ada.

Pada bab selanjutnya, kita akan membahas cara mengubah dan memahami data Anda sendiri.