Parquet format and columnar storage in Apache Spark - Step-by-Step Execution

Concept Flow - Parquet format and columnar storage

Start: Data in rows

↓

Convert to columns

↓

Store each column separately

↓

Apply compression on columns

↓

Save as Parquet file

↓

Read Parquet file

↓

Load only needed columns

↓

Process data efficiently

↓

End

Data is transformed from row-based to column-based storage, compressed, saved as Parquet, and read efficiently by loading only needed columns.

Execution Sample

Apache Spark

df = spark.read.csv('data.csv', header=True)
df.write.parquet('data.parquet')
parquet_df = spark.read.parquet('data.parquet')
parquet_df = parquet_df.select('column1')
parquet_df.show()

Read CSV data, save it as Parquet, then read Parquet and select one column to show.

Execution Table

Step	Action	Input Data Shape	Storage Format	Output
1	Read CSV file	Rows with all columns	CSV (row-based)	DataFrame with rows
2	Write DataFrame as Parquet	Rows with all columns	Parquet (columnar)	Parquet file with columns stored separately
3	Read Parquet file	Parquet file	Parquet (columnar)	DataFrame with columns loaded
4	Select one column	DataFrame with all columns	In-memory column data	DataFrame with only selected column
5	Show data	Selected column data	In-memory	Printed column values
6	End	-	-	-

💡 Process ends after showing selected column data from Parquet file.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
df	None	DataFrame with all rows and columns	Same DataFrame	Same DataFrame	Same DataFrame	Same DataFrame
parquet_df	None	None	None	DataFrame loaded from Parquet	DataFrame with selected column	DataFrame with selected column

Key Moments - 3 Insights

Why does Parquet store data in columns instead of rows?

Because storing data by columns allows reading only the needed columns, which saves time and space. This is shown in execution_table step 4 where only one column is selected and loaded.

How does Parquet improve storage size?

Parquet applies compression on each column separately, which is more efficient because similar data types are stored together. This is implied in the concept_flow step 'Apply compression on columns'.

When reading Parquet, do we load all data or only what we need?

We load only the columns we need, as shown in execution_table step 4 where only 'column1' is selected and loaded, improving performance.

Visual Quiz - 3 Questions

Look at the execution_table, what is the storage format after writing the DataFrame?

A CSV (row-based)

B JSON

C Parquet (columnar)

D Text file

💡 Hint

Check step 2 in execution_table where the DataFrame is written as Parquet.

At which step do we select only one column from the DataFrame?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at execution_table step 4 where 'Select one column' action happens.

If we read the Parquet file without selecting columns, what happens?

A All columns are loaded into memory

B Only one column is loaded

C No data is loaded

D File is converted back to CSV

💡 Hint

Refer to execution_table step 3 where the Parquet file is read fully before column selection.

Concept Snapshot

Parquet format stores data by columns, not rows.
This allows reading only needed columns, saving time and space.
Each column is compressed separately for efficiency.
Use spark.read.parquet() to load Parquet files.
Select columns to load less data and speed up processing.

Full Transcript

This visual execution shows how data is read from a CSV file into a DataFrame, then saved as a Parquet file which stores data in a columnar format. The Parquet format stores each column separately and compresses it, making storage efficient. When reading the Parquet file, you can select only the columns you need, which loads less data and speeds up processing. The execution table traces each step: reading CSV, writing Parquet, reading Parquet, selecting columns, and showing data. Variable tracking shows how the DataFrame changes from all columns to selected columns. Key moments clarify why columnar storage is faster and smaller, and how Parquet reads only needed columns. The quiz tests understanding of storage format, selection step, and data loading behavior. The snapshot summarizes the main points about Parquet and columnar storage.

Practice

1. What is the main advantage of storing data in Parquet format in Apache Spark?

easy

A. It compresses data by converting it to images.

B. It stores data as plain text for easy reading.

C. It stores data only in memory without saving to disk.

D. It stores data column-wise, making queries faster and storage smaller.

Solution

1. Step 1: Understand Parquet storage method

   Parquet stores data in a columnar format, meaning data is saved column by column instead of row by row.

2. Step 2: Benefits of columnar storage

   This column-wise storage allows faster queries on specific columns and reduces storage size due to better compression.

3. Final Answer:

   It stores data column-wise, making queries faster and storage smaller. -> Option D

4. Quick Check:

   Columnar storage = faster queries + smaller files [OK]

Hint: Remember: Parquet = column-wise storage for speed and size [OK]

Common Mistakes:

• Thinking Parquet stores data as plain text
• Confusing row-wise with column-wise storage
• Assuming Parquet only stores in memory

2. Which of the following is the correct way to save a Spark DataFrame named df as a Parquet file?

easy

A. df.saveAsParquet('path/to/file')

B. df.write.parquet('path/to/file')

C. df.write.save('path/to/file', format='csv')

D. df.save('path/to/file', format='parquet')

Solution

1. Step 1: Recall Spark DataFrame write syntax

   In Spark, to save a DataFrame as Parquet, use the write.parquet() method.

2. Step 2: Check each option

   df.write.parquet('path/to/file') uses df.write.parquet('path'), which is correct. Others use incorrect methods or formats.

3. Final Answer:

   df.write.parquet('path/to/file') -> Option B

4. Quick Check:

   Use write.parquet() to save DataFrame [OK]

Hint: Use df.write.parquet(path) to save DataFrame as Parquet [OK]

Common Mistakes:

• Using saveAsParquet which does not exist
• Saving with wrong format like CSV
• Using df.save() without write

3. Given the following Spark code, what will be the output schema of the loaded DataFrame?

df.write.parquet('data.parquet')
df2 = spark.read.parquet('data.parquet')
df2.printSchema()

medium

A. The schema will be the same as the original DataFrame df.

B. The schema will be empty because Parquet does not store schema.

C. The schema will only contain column names but no data types.

D. The schema will be reversed compared to df.

Solution

1. Step 1: Understand Parquet schema storage

   Parquet files store both data and schema (column names and types).

2. Step 2: Loading Parquet preserves schema

   When reading with spark.read.parquet(), the schema is restored exactly as saved.

3. Final Answer:

   The schema will be the same as the original DataFrame df. -> Option A

4. Quick Check:

   Parquet stores schema = schema preserved [OK]

Hint: Parquet files keep schema; reading restores it fully [OK]

Common Mistakes:

• Thinking Parquet files do not store schema
• Assuming schema is lost or incomplete
• Believing schema order changes on read

4. You try to read a Parquet file using spark.read.parquet('file_path') but get an error. Which of the following is the most likely cause?

medium

A. The file path is incorrect or the file does not exist.

B. Parquet files cannot be read by Spark.

C. You must use read.csv() to read Parquet files.

D. The DataFrame was not saved before reading.

Solution

1. Step 1: Check common read errors

   Errors reading Parquet usually happen if the file path is wrong or file is missing.

2. Step 2: Verify other options

   Parquet files are supported by Spark, so B and C are wrong. D is unrelated because reading does not depend on saving in the same session.

3. Final Answer:

   The file path is incorrect or the file does not exist. -> Option A

4. Quick Check:

   File not found = read error [OK]

Hint: Check file path and existence before reading Parquet [OK]

Common Mistakes:

• Assuming Spark cannot read Parquet
• Using wrong read method like read.csv
• Thinking saving is required in same session

5. You have a large Spark DataFrame with many columns but only need to query a few columns frequently. How does using Parquet format help improve performance?

hard

A. Parquet stores data row-wise, so all columns are always read together.

B. Parquet converts all columns to JSON strings for faster parsing.

C. Parquet stores data column-wise, so reading only needed columns is faster and uses less disk I/O.

D. Parquet compresses data by removing all null values automatically.

Solution

1. Step 1: Recall Parquet columnar storage benefits

   Parquet stores data column-wise, allowing queries to read only selected columns.

2. Step 2: Understand impact on performance

   Reading fewer columns reduces disk I/O and speeds up queries, especially on large datasets.

3. Final Answer:

   Parquet stores data column-wise, so reading only needed columns is faster and uses less disk I/O. -> Option C

4. Quick Check:

   Columnar storage = selective fast reads [OK]

Hint: Parquet reads only needed columns, saving time and I/O [OK]

Common Mistakes:

• Thinking Parquet stores data row-wise
• Believing Parquet converts data to JSON
• Assuming Parquet removes nulls automatically