Free Databricks-Certified-Associate-Developer-for-Apache-Spark-3.5 Actual Exam Questions

B The key is avoiding shuffling the large DataFrame A, so broadcasting the smaller B is the move. Options involving broadcasting A don’t make sense given its size.

A vs B? Both push for broadcasting B since it’s smaller, but B is clearer about stopping the big DataFrame A from shuffling. That’s the key win here, so B’s explanation feels more on point.

It’s C because Spark caches whole partitions and spills those that don’t fit to disk, so it stores as much as possible in memory first and the rest on disk with some overhead. Partial partition splitting isn’t how it works.

Probably C here. Spark caches partitions, and when memory is full, it spills entire partitions to disk rather than splitting a partition between memory and disk. This means it stores as much as it can in memory, then moves the rest to disk. D sounds tempting but Spark doesn’t track row-level frequency for caching, it works at the partition level mostly. B is definitely off since Spark isn’t balancing storage evenly, and A isn’t quite right because Spark doesn’t duplicate data both in memory and disk simultaneously. So C fits with how MEMORY_AND_DISK typically behaves under memory pressure.

A Spark’s processingTime trigger is designed exactly for fixed-interval micro-batches, so A makes the most sense. B’s continuous trigger is for a different streaming mode, not fixed micro-batch intervals.

A/D? D lacks a trigger, so it won’t guarantee 5-second intervals. A explicitly sets micro-batch timing with processingTime, which fits the 5-second fixed interval best.

It’s D because using an iterator UDF means the model loads once per partition and stays loaded across all batches, cutting down repeated reloads unlike the other options.

It’s D because using an iterator UDF lets you initialize the model once per batch instead of on every single call, which really cuts down the loading overhead compared to the other options.

A/B? Append only adds new rows, so it can’t output the whole table. Complete mode outputs the full aggregation every trigger, which matches what the question asks. Options C and D don’t exist in standard Spark modes.

A, complete mode always outputs full aggregation results every trigger run.

A imo, no AQE means static plan so no broadcast despite small df2 size.

B. Since df2 is just 8 MB, it’s well under the default broadcast threshold (usually 10 MB), so Spark should automatically pick a broadcast join here without needing hints or AQE. The fact that df1 is huge doesn’t matter as much as this small side table being eligible for broadcast.

B and A, since both --remote options start a local server without code changes.

A imo, since --remote "https://localhost" can also trigger a local Spark Connect server for testing. D and E require code changes, so they don’t fit the "without changing code" part.

A imo. Since the cluster has 10 nodes with 16 CPUs each, that’s 160 CPUs total. Setting partitions equal to total CPUs ensures each core gets a task, maximizing parallelism without overwhelming the cluster with too many tiny tasks. Options B and C seem arbitrary without tying directly to CPU count. D is good in theory, but partition size can vary depending on file format and compression—just dividing by 128 MB might not perfectly match CPU availability or task length. The key here is matching tasks to cores for better resource use.

It’s D because calculating partitions from data size usually avoids too few or too many tasks.

C imo, wildcard should catch all year folders without depending on Spark version.

Option C makes sense too since using a wildcard like /path/events/data/* should grab all first-level directories (the year folders) and Spark will then read all files inside those folders. It doesn’t rely on recursiveFileLookup, so it works regardless of Spark version. A and D just read the base path without recursion, so they probably miss nested files. B is good if the Spark version supports recursiveFileLookup, but since that info’s missing, C feels like a safer bet.

D, checkpointLocation in writeStream saves offsets and state for recovery.

I think A can be ruled out since checkpointLocation in readStream doesn’t store progress info needed for recovery. But is there any config beyond checkpointLocation in writeStream for handling metadata or query state?

A imo, coalesce only increases partitions if shuffle=True, which isn’t mentioned here.

It’s A, coalesce can’t increase partitions without shuffle, so stays 10 here.

A vs D? A is off since cache() can’t set storage level; it just uses a default. D fits better because cache() defaults to MEMORY_AND_DISK and persist() lets you specify other levels. That flexibility is really the key difference here. B and C mix up which method lets you choose storage levels, so not those either.

I’m thinking A can be ruled out since cache() doesn’t let you change the storage level, it just uses MEMORY_AND_DISK by default. Also, B is off because persist() definitely lets you pick levels, not just DISK_ONLY. Does D cover all the bases?

B tbh, since it selects 'region_id' first then 'region', so when converted to dict it'll map region_id to region, which isn't what we want. A is better for region to region_id mapping after sorting ascending.

Option B also sorts by region_id ascending and selects columns in the right order for key-value pairs, so it fits the mapping. Just like with A, dict() might need tuples instead of Rows though.

D imo, B and C are clearly incorrect since the driver does way more than just UI or local computations. D is also wrong because the driver doesn’t store final results; it coordinates execution, so A fits best.

It’s A. The driver node is definitely the one that breaks down actions into tasks and schedules them on the workers. B’s just wrong because it’s more than monitoring. C is off since the driver doesn’t hold the data or run all computations itself. D’s not accurate either because the driver doesn’t store results after workers finish; it coordinates the whole thing. So yeah, “orchestrates” pretty much sums up scheduling plus sending tasks out.

It’s A for sure because Spark’s whole deal is spreading work across multiple machines, handling way bigger data than one computer can. I’d go with E too since normal scripts usually crash if a node fails, but Spark can retry tasks or reroute work so your job keeps running without losing progress. B and D are definitely out—Spark runs on regular hardware and you still write code. C’s not right either because Spark actually tries to keep data in memory to speed things up rather than just relying on disk.

A/C? Spark uses memory mostly but can spill to disk, so C partially fits.