Every question on one page: open one, choose an answer, and see why at once. Signed in, your latest answer to each question counts, and you can answer again after 24 hours.
Curated: · Written: · Reviewed:
Reviewed 100Review pending 0
Answers to reviewed questions count toward this role and the overall leaderboard; your latest answer to each one is the one that counts.
MCQ-1A retail team's nightly pipeline ingests 2.4 TB of raw clickstream JSON into an S3 landing bucket that no analyst role is granted on. A Spark job on 48 executors then parses the 140 raw fields down to 11 columns, hashes the two PII columns `email` and `ip`, joins the 9 GB `dim_store` table, and writes 800 GB of Parquet back to S3. The warehouse loads that Parquet, joins the same `dim_store` a second time and aggregates the hourly mart. End to end the run is 6h58m, with 800 GB written and read back and the 9 GB dimension table read twice. Running the parse, the hash, the join and the aggregate as one warehouse SQL step over the landed raw JSON, writing only the 11-column mart into the `mart` schema, measured 41 minutes and produced no intermediate copy. Which change removes the most work?⌄
MCQ-2A nightly Spark 3.5 job lands 12 billion JSON rows as Parquet, then a Python UDF explodes an array column at 2,400 rows/s per core. On the 200-core cluster that is 480,000 rows/s, so the explode alone takes about 6.9 hours and the job misses its 2-hour SLA every night. The landed table is correct and the DAG is green. What should the team change?⌄
MCQ-33A nightly PySpark job on EMR (Spark 3.5) reads 250 million Parquet rows averaging about 2 KB each, joins them, and calls df.collect() at the end because the internal API downstream needs the whole result set. The driver is an m5.xlarge with spark.driver.memory=3g and spark.driver.maxResultSize=0; the 40 m5.2xlarge executors have 16 GB each. Every task in every stage finishes with no spill and no fetch failures, and 70 minutes in the driver dies with java.lang.OutOfMemoryError: Java heap space. Three Airflow retries fail at the same point. What should change?⌄
MCQ-34A nightly Postgres-to-Parquet extract runs in a Kubernetes pod capped at 32 GiB. `pd.read_sql` on the 9.2-million-row, 18-column table peaks at 41 GiB RSS and the pod is OOMKilled at 92 percent. The team switches to `pd.read_sql(..., chunksize=100000)` but still OOMs: the code appends every chunk to a Python list, then calls `pd.concat(frames)` and writes one Parquet file at the end. Profiling attributes 31 GiB of the peak to a single high-cardinality JSONB text column. The pod limit cannot be raised this quarter and the extract must land within two hours. Which change should be made first?⌄
MCQ-35A Spark 3.5 job parses `event_time` from a 6.8-billion-row Parquet table. 92% of the values are ISO-8601 (`2024-03-05T14:22:31.123+05:30`) and 8% are legacy `dd/MM/yyyy HH:mm:ss`. The current parser is a Python UDF wrapping `datetime.strptime`; on 40 executors (8 cores each) the parse stage takes 11 hours against a 2-hour SLA. The same cluster parses the ISO-8601 rows with `to_timestamp` in 17 minutes. Which change meets the SLA?⌄
MCQ-26The `events` table is Hive-partitioned by `dt` (one directory per day, 412 days retained, ~44 GB per day). This nightly job reads 18 TB and takes 74 minutes:
```sql
SELECT user_id, count(*) AS c
FROM events
WHERE event_ts >= '2026-03-01' AND event_ts < '2026-03-03'
GROUP BY user_id
```
`EXPLAIN` reports `PartitionFilters: []` and `PushedFilters: [IsNotNull(event_ts), GreaterThanOrEqual(event_ts, 2026-03-01 00:00:00), LessThan(event_ts, 2026-03-03 00:00:00)]`. Which change makes the job read only the two days it needs?⌄
MCQ-85A pull request changes a nightly job's filter from `dt = DATE '2026-03-02'` to `CAST(dt AS string) = '2026-03-02'` on a date-partitioned Parquet table. The job returns the same rows and the DAG run is green. Which statement should the review accept?⌄
MCQ-84A 500 GB Parquet table is written unsorted, in daily partitions, with 128 MB row groups. A dashboard query filtering on customer_id returns 12 rows and takes 40 s, opening 4,000 row groups. An engineer rewrites the table with 8 MB row groups, expecting the query to get faster. What happens?⌄
MCQ-29A nightly Spark 3.5 job joins a large fact table to a dimension, and the join stage writes 12 TB to shuffle. The shuffle tasks come out evenly sized. spark.sql.shuffle.partitions is left at its default of 200 and adaptive query execution is left on (the 3.5 default); that run spills 4.8 TB to disk and the stage takes 6.2 hours. Someone bumps the setting to 4,000 on the same 400-executor, 4-core cluster: spill falls to 110 GB and the stage to 48 minutes, and the team wants to ship that value. The team's standard is 128-256 MB per shuffle partition. Which review comment holds?⌄
MCQ-32A Spark 3.5 batch job shuffles 8 TB after a filter. `spark.sql.shuffle.partitions` is left at its default 200 and AQE is on with default settings. The shuffle-read stage runs 200 tasks of about 40 GB each on an 800-core cluster; the cluster sits at 25% utilization and the stage takes 3.4 hours. Which change cuts the stage's wall time?⌄
MCQ-59A nightly Spark 3.5 job runs `events.groupBy("user_id").agg(sum("amount"))` with `spark.sql.shuffle.partitions` left at its default 200. The shuffle writes 1.1 TB, and 22% of the event rows have `user_id` null. Stage metrics show 2.4 TB of shuffle spill, a max task of 41 min against a 3.2 min median, and the job finishing at 06:50 against a 06:00 SLA. Which change fixes the spill?⌄
MCQ-30A nightly Spark 3.5 job joins a 2.4-billion-row events table to a 40-million-row customer dimension on customer_id using 200 shuffle partitions, and normally finishes in 90 minutes. Tonight two tasks have run 11 hours while the other 198 finished in under 90 minutes. Stage metrics show the largest shuffle partition holds 190 million rows and the median holds 12 million, and one customer_id accounts for 8% of all events. Doubling the executor count left the two long tasks unchanged. What should the engineer do?⌄
MCQ-91A daily Spark 3.5 job reads `events` (200 million rows) and runs `events.withColumn("tag", explode(col("tags"))).join(tags_dim, "tag")`. `tags` is written by a client that appends instead of replacing: 99.9% of rows carry 1–5 tags (mean 3), and 200,000 rows carry 20,000-element arrays whose tags downstream consumers need. The stage writes 1.1 TB to shuffle and one task runs 3.5 hours, missing the SLA. Which change addresses the cause?⌄
MCQ-31A Spark 3.5 job joins a 9 TB fact table to a 2.1 GB dimension and runs a sort-merge join that shuffles both sides, taking 4 hours. The cluster has 200 executors with 16 GB heap each, about 12 GB free for join data. spark.sql.autoBroadcastJoinThreshold is at its 10 MB default, and the cluster is shared with a nightly job that joins a 40 GB table. What should the engineer do?⌄
MCQ-58A nightly job joins a 2 TB fact table to a 20 GB dimension table. The query carries a /*+ BROADCAST(dim) */ hint. Executors run with 4 GB heap and 4 cores; the driver has 64 GB. The join stage fails with executor OOM and retries three times while the driver stays up, and the physical plan shows BroadcastHashJoin with the 20 GB dimension as the build side. Which change fixes the failure?⌄
MCQ-94An hourly Spark batch joins a 3 GB dimension to a 40 GB fact table. The join carries a broadcast hint, so the dimension is broadcast even though spark.sql.autoBroadcastJoinThreshold is at its 10 MB default. spark.sql.broadcastTimeout is the default 300 s. One executor fetches the broadcast at 4 MB/s, so the 3 GB relation needs about 13 minutes to arrive; the job fails after roughly 25 minutes of repeated 300 s broadcast-timeout errors. The same query without the hint shuffle-joins in 6 minutes. The batch has a 10-minute SLA. Which change meets the SLA?⌄
MCQ-95A nightly Spark job joins a 3 GB dimension table to a 12 TB fact table. The cluster runs 200 executors, each with 8 GB of unified memory, and the join stage already peaks at 6.5 GB per executor for the fact-side scan and aggregation. The current sort-merge join shuffles the fact table and finishes in 26 minutes. A teammate proposes a broadcast join to remove the shuffle. Which call is right?⌄
MCQ-61A nightly load into `fct_orders` lost its idempotency key and appended the previous day's 1,000,000 rows a second time: byte-identical, no new orders. Before the bad load the table held 1,000,000 rows with SUM(amount) = $54,000,000 and AVG(amount) = $54.00, and a dashboard reads both aggregates straight from the table. What will the dashboard show after the bad load, and what is the correct remediation?⌄
MCQ-60A scheduled Spark SQL job loads one hour of clickstream events into the append-only table fact_events with INSERT INTO fact_events SELECT * FROM staging WHERE event_hour = '2024-06-11-14'; nothing else writes to that table. A scheduler bug ran the load three times on 2024-06-11, each run reading the same 3,000,000 staging rows and succeeding, and the bug is still enabled for next week's backfill. The hour now returns COUNT(*) = 9,000,000 and COUNT(DISTINCT user_id) = 2,100,000; the same hour loaded once on 2024-06-10 returned COUNT(*) = 3,000,000 and COUNT(DISTINCT user_id) = 2,100,000. The daily-active-user dashboard sums hourly COUNT(*) and this hour's bar is now three times its 2024-06-10 size. Which reading of these numbers and next step is right?⌄
MCQ-56A Spark 3.5 job writes to s3://lake/orders, partitioned by dt, with spark.sql.sources.partitionOverwriteMode=dynamic. The table holds 31 partitions, dt=2026-03-01 through dt=2026-03-31. A backfill runs with an input DataFrame containing rows for only dt=2026-03-02 and dt=2026-03-03; the job reports success. A finance query summing March now disagrees with the source system. What happened?⌄
MCQ-15A nightly Spark 3.5 job MERGEs a change feed into a Delta Lake 3.1 `orders` table (4.2M rows, one row per order_id). The feed carries every revision of an order, and a revision can arrive days late. The job runs:
```sql
MERGE INTO orders AS t
USING staging AS s
ON t.order_id = s.order_id
WHEN MATCHED THEN UPDATE SET t.revision = s.revision, t.refund_state = s.refund_state, t.updated_at = s.ingest_ts
WHEN NOT MATCHED THEN INSERT (order_id, revision, refund_state, updated_at) VALUES (s.order_id, s.revision, s.refund_state, s.ingest_ts)
```
Monday's feed delivers order 8814 rev 3, refund_state 'refunded'. Wednesday's backfill delivers order 8814 rev 2, refund_state 'pending', with Wednesday's ingest_ts. The Wednesday run completes green. Which change would have left exactly one row for order 8814, at rev 3, after Wednesday's run?⌄
MCQ-13A streaming job reads a Kafka topic, MERGEs each micro-batch into an Iceberg table keyed on payment_id, then commits the Kafka offsets. The MERGE is idempotent on payment_id and the sink has no transactional commit. To shrink checkpoints, an engineer proposes committing the offsets as soon as the batch is read, before the MERGE runs. A deploy restarts the job in the window between the offset commit and the MERGE. What does the review conclude?⌄
MCQ-36A nightly job rebuilds dim_user_current from events with: ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY event_ts DESC) AS rn, then WHERE rn = 1. 12% of users have two events with the same event_ts. After a rerun, 480,000 users' current row changed to a different event_id, but a unique test on user_id stayed green. Which change fixes the drift?⌄
MCQ-39A nightly job maintains dim_customer as a Type 2 dimension: 4.1M rows, one current row per natural key, prior versions retained. It runs a single MERGE that joins source to target on the natural key, with WHEN MATCHED AND attributes differ THEN UPDATE SET is_current=false, valid_to=now() and WHEN NOT MATCHED THEN INSERT. The source holds 18,000 changed customers and 210 new ones. After the run, 18,000 rows are expired, 210 rows are inserted, and none of the 18,000 changed customers has a current row, so downstream facts join them as unknown. What should the engineer do to make the changed customers current again?⌄
MCQ-62`fct_order_lines` is an incremental dbt model with `unique_key='order_id'` and the default merge strategy; its contract is one row per order line. The source `stg_order_lines` has one row per (order_id, line_id), and `line_id` restarts at 1 for each order. A backfill of 2,000 orders / 5,000 lines leaves 2,000 rows for those orders, with `sum(item_count)` at 48% of the source total. What is the correct fix?⌄
MCQ-54A lakehouse `orders` table is partitioned by `order_month`. A backfill DAG rewrites 14 monthly partitions (2024-01 through 2025-02) in one run, and its only quality task, a uniqueness check on `order_id`, runs after all 14 partition writes finish. The run went green. On Monday, months 2024-02 through 2024-07 hold duplicate `order_id`s (88M extra rows) from a dimension join that fanned out after a late-arriving SCD-2 row; `SUM(revenue)` doubled on those months, `AVG(revenue)` did not. Months 2024-08 through 2025-02 are clean. Which gate placement would have confined the failure to 2024-02 and left 2024-03 through 2025-02 serving their previous snapshots?⌄
MCQ-16`fact_events` is an Iceberg table partitioned by `days(event_ts)`; a normal day holds 19.4M rows across 24 hourly files. After an upstream extract failed at 04:00, the retry job for 2026-03-02 read only the 03:00 hour file (812,000 rows) and committed with `df.writeTo("fact_events").overwritePartitions()`. The job reported success. Which action restores day=2026-03-02 and prevents the recurrence?⌄
MCQ-17An Airflow DAG runs at 02:00: an export step writes the day's events to an export prefix, then a Spark task reads that prefix for one date and overwrites the warehouse partition events/dt=<date>. On 2 March 2026 the export prefix existed but held no files; Spark read zero rows, wrote zero rows and exited 0. Every task ended success, the DAG run is green, and the empty partition stood until an analyst saw a flat dashboard 14 hours later. On 14 March the export wrote files holding only 430,000 of the source's 2,100,000 rows for that date; Spark again exited 0 and the short partition landed. The team has room for one new check in this DAG. Which check fails the DAG on both runs?⌄
MCQ-55A daily-partitioned Delta Lake table (copy-on-write, deletion vectors disabled) holds 40 million rows and 1.2 TB per day partition, spread over 200 files of about 200 MB. A nightly correction applies 12,000 row updates to yesterday's partition. The update key is not clustered, so those 12,000 rows sit in 190 of the 200 files. Which plan is cheapest for this job?⌄
MCQ-57An Iceberg orders table is partitioned by order_date. A nightly batch job reads snapshot S1 at 08:00, computes per-day aggregates, and at 12:00 commits an INSERT OVERWRITE for order_date = '2024-06-01'. At 11:00 a streaming job committed a MERGE that added 140,000 midday orders for that date. The overwrite commits without error and the 140,000 rows are gone. Which change stops the batch job from destroying the streaming rows?⌄
MCQ-74A table is partitioned by event_date. A streaming job appends events to today's partition continuously. A batch job starts at 00:00 and at 00:04 commits an overwrite of today's partition, writing the 1,150,000 rows from a dump taken at 23:50. Between 00:00 and 00:04 the stream committed 90,000 rows; between 00:04 and 00:30 it committed a further 12,000. How many rows are in today's partition at 00:30?⌄
MCQ-76A Spark 3.5 batch job reads Iceberg table `orders` (4,000 data files, current snapshot 88). It runs two actions: `SELECT region, sum(amount) FROM orders GROUP BY region`, then `SELECT count(*) FROM orders`. A compaction job rewrites the 4,000 files into 40 and commits snapshot 89 between the two actions. On those nights the aggregate's grand total comes out 1.4× the count-implied total, and re-running the job gives a different number again. Which change fixes the mismatch?⌄
MCQ-64A nightly job writes each partition straight into the serving table events, then runs a 40-test dbt suite against it. Last Tuesday the suite failed 18 minutes after the write: a null-key bug in the transform had produced 2.2M bad rows, and three streaming consumers had already pulled them into 1-hour caches. The team wants a partition that fails the suite to never become visible in serving. Which change achieves that?⌄
MCQ-19`fct_orders` is rebuilt in place each night: `dbt run` truncates and reloads the serving table, then `dbt test` runs against it. The build takes 9 minutes, the test suite 14, and the BI extract polls the table every 5 minutes. On Tuesday the build wrote 1.8M rows with a null `customer_id`; the suite failed 14 minutes later, after three extracts had loaded the bad rows. Which change would have kept the three extracts from reading the bad rows?⌄
MCQ-18A dbt 1.7 project on Snowflake has `stg_orders` (ephemeral) and `fct_orders` (incremental with no `unique_key`, so every run appends). The only uniqueness test is `unique` on `stg_orders.order_id`. Last night a backfill re-ran three days of orders: the DAG went green and every test passed, but a finance dashboard now double-counts revenue, and `SELECT COUNT(*) - COUNT(DISTINCT order_id) FROM fct_orders` returns 44,000. Which change makes the next backfill fail instead of silently doubling?⌄
MCQ-53An Airflow 2.9 DAG `orders_daily` runs `extract` → `load` → `wait_for_partition` → `dbt_run`. `extract` writes raw JSON to `s3://raw/orders/dt={{ ds }}/`. `load` is a Spark job that reads raw, writes Parquet to `s3://lake/orders/dt={{ ds }}/`, then writes `_SUCCESS` unconditionally. `wait_for_partition` is an `S3KeySensor` on that `_SUCCESS`, and `dbt_run` builds `fct_orders` from the lake partition. On 2024-06-15 `extract` wrote 3.4M records, but a partition-column bug made `load` write 0 Parquet files and still write `_SUCCESS`; the sensor went green at 02:01, `fct_orders` had 0 rows, and the revenue dashboard read $0 until noon. 2024-06-16 is a Sunday with 0 orders: a legitimately empty day. Which change makes the DAG fail on 2024-06-15's failure without failing on 2024-06-16?⌄
MCQ-44An hourly pipeline writes one partition per event-time hour and publishes it by updating a serving pointer. The contract: the partition for hour H must be queryable by H+1 at :10, so hour 09 (which closes at 10:00) must be queryable by 10:10. For hour 09 the DAG started at 09:50, the last task succeeded at 10:05, and the serving pointer for partition 09 was updated at 10:31; Airflow marked the run green. Monitoring flagged 14 of the last 24 hours as late. Which conclusion is correct?⌄
MCQ-45An hourly revenue table flips its serving pointer to the new partition the moment the orchestrator marks the run successful. The completeness contract for the 09:00 partition is destination row count ≥ 99.9% of source; the freshness SLA is availability by 09:15. The 09:00 run finished at 09:08 with 198.4M of the source's 200M rows, the freshness tile went green, and the pointer flipped. Dashboards have read the partition since 09:08. Which action does the contract require?⌄
MCQ-96A nightly pipeline reads a source partition that normally lands at 07:00, transforms for 50 minutes, and advances the serving pointer. The table's freshness SLA is 09:15; the job's duration SLO is 60 minutes. For 11 straight weekdays the source partition landed at 08:45, the transform still took 50 minutes, and the serving pointer advanced at 09:40. The duration alert stayed green the whole time. Which change would have caught this failure?⌄
MCQ-68A nightly Kafka pipeline decodes records, MERGEs them into an orders table, and reports consumer lag. Last night the lag dashboard stayed at 0 for the whole hour, but the orders table ended $900,000 short of the produced total. A schema change had dropped 4% of records during decode, and no DLQ received them. The team must add one check before the next backfill. Which check is defensible?⌄
MCQ-100A daily batch job writes the partitioned table `events`, one partition per UTC day, and feeds two consumers: a dashboard query and a feature-store export. The change adds two columns and a late-arrival path. The team ran the new job on dt=2026-03-02 only: that partition has 0 rows on the old schema and the dashboard matched. dt=2026-03-01 still has 6,400,000 rows with NULL in both new columns; a late dt=2026-03-02 window was written by the old code path into the feature-store sink with the old schema; and the two consumers disagreed on row counts for 5 days. The backfill of dt=2026-03-01..03-05 is queued. Which check settles whether the change is done?⌄
MCQ-38A nightly Spark 3.5 job reads 500 Parquet files from a landing zone with `spark.read.parquet(landing)` and appends to a Delta table; `mergeSchema` is left at its default. Upstream added a nested field `payment.network` inside the existing `payment` struct, and 40 of the 500 files now carry it. The job has succeeded for six nights, the table's row count matches the expected nightly total, but the table has no `payment.network` column and the card-mix query fails with `UNRESOLVED_COLUMN`. What explains it?⌄
MCQ-50Nightly Spark 3.5 job reads slowly changing vendor extracts with `SELECT *` and appends to a Delta 3.2 table `margin_input` whose schema is fixed. In April the vendor added `discount_bps`. Because the write ran with `mergeSchema=false`, Spark dropped the column; margin reports ignored 9% discounts for 7 weeks, $6.4M. Which change best prevents a repeat while keeping unvetted vendor columns out of margin consumers?⌄
MCQ-20`orders-value` is Avro-encoded in Kafka. A hotfix six months ago set the subject's compatibility level to NONE. Version 12 added a required `channel` field (string, no default); versions 1–11 do not have it. The topic retains 30 days of data: 2.1M records written with v11 and 1.5M written with v12. A Flink job pins reader schema v12 in code and has no per-record error handling, so a decode exception fails the task. Downstream attribution needs `channel` populated on every record. What happens on the next run, and which fix is correct?⌄
MCQ-21A daily events pipeline writes Avro files with writer schema v1 = {event_id: long, amount: double}. A new reader schema v2 adds country: string. A replay of 11 days of history: 5.2 million files, all written with v1: must decode every file and populate country for a downstream job that groups by it; rewriting the historical files is not allowed. The replay currently fails with a deserialization error on every historical file. Which change makes the replay decode all 5.2 million files and populate country?⌄
MCQ-22A Kafka→Spark→Iceberg pipeline decodes Protobuf events using a descriptor pulled from the schema registry. A producer team republished the descriptor with field 4 changed from `int32 amount_cents` to `string sku`, keeping the number. Two days later the revenue table sums to $0.00 for every order, the row count is unchanged at 7.4M/day, the Spark job reports success, and its decode-error counter is 0. Events written before the change are still being replayed from the landing zone. What explains the $0?⌄
MCQ-65A retail pipeline appends orders to `landing.orders_raw` with no schema enforcement, then loads `curated.orders` with a typed contract. The curated load runs every 15 minutes and normally lags landing by 2 hours. A revenue dashboard queries `landing.orders_raw` directly. Last month the source changed `order_total` from decimal to string; landing accepted it, curated rejected the batch, and the dashboard rendered `$0` for 6 weeks. The team must stop this recurrence while keeping raw replay possible. Which change should they make?⌄
MCQ-70A Debezium CDC stream lands in a Bronze table, and a nightly MERGE into `silver.customers` already contains `WHEN MATCHED AND s.op = 'd' THEN DELETE`. After a GDPR request, 12,400 deleted customers are still present in silver. The Kafka topic holds an `op='d'` tombstone for each of those keys, but Bronze has zero rows with `op='d'`. The Bronze load runs `SELECT ... FROM kafka_events WHERE after IS NOT NULL`. Which change fixes the pipeline?⌄
MCQ-71A daily job keeps analytics.dim_customer current from raw.users. A soft delete is an in-place update: the app stamps deleted_at and bumps updated_at on the row the job already loaded.
```sql
-- extract
select user_id, email, plan, updated_at, deleted_at, deleted_at is null as is_current
from raw.users
where updated_at > (select max(updated_at) from analytics.dim_customer);
-- load
merge into analytics.dim_customer t
using incoming s on t.user_id = s.user_id
when matched and s.updated_at > t.updated_at
then update set email = s.email, plan = s.plan, updated_at = s.updated_at
when not matched
then insert (user_id, email, plan, updated_at, deleted_at, is_current)
values (s.user_id, s.email, s.plan, s.updated_at, s.deleted_at, s.is_current);
```
Right now the target holds cus_7 with is_current = true, deleted_at null and updated_at 2024-03-04 02:00, the value the last run wrote, and 2024-03-04 02:00 is max(updated_at) over the whole table (cus_1 sits at 2024-03-02 07:00, cus_9 at 2024-03-01 21:00). In raw.users, cus_7 carries deleted_at 2024-03-04 02:00 with that same updated_at, and a new signup cus_4 carries updated_at 2024-03-05 11:00. Which change makes tonight's run remove cus_7 from the live table?⌄
MCQ-5An hourly extract runs `SELECT id, updated_at FROM orders WHERE updated_at > :last_run` against a read replica and sets `last_run` to the largest `updated_at` it read, minus a 30-minute overlap. Four facts are measured in production: the replica lags the primary by 9 minutes at p99; one app host's clock runs 12 minutes behind the others; no transaction stays open longer than 2 seconds; and a nightly partner import inserts 18,400 rows whose `updated_at` is copied from the partner feed, where those values are 2 to 6 days old. With the 30-minute overlap in place, which rows does the extract still miss?⌄
MCQ-72An orders table is extracted to the warehouse every 5 minutes with `SELECT * FROM orders WHERE updated_at > :watermark`, where :watermark is the max updated_at loaded so far. The 02:00 run finishes and stores watermark 02:00:00. At that instant NTP steps the database host clock back 4 minutes, and it stays 4 minutes slow. Orders arrive at a steady rate; 6,200 are committed between 02:00:00 and the 02:05 run. What does the 02:05 run load?⌄
MCQ-47A nightly job extracts products with `SELECT * FROM products WHERE product_id > :last_max_id` and overwrites those rows in the warehouse. The source table holds 900 million rows and has no reliable `updated_at` column; `product_id` comes from a sequence, but a one-time backfill inserted 400 historical products with explicit ids below the current maximum. Merchants regularly change the price of existing products in place. After 11 weeks, the job still exits successfully with `last_max_id` equal to the source maximum, yet finance finds 16,200 SKUs at last year's price. The nightly maintenance window is 2 hours, while a full table scan takes about 9 hours. The source database has a logical replication slot available. Which change will capture the stale prices and keep future price edits from being missed?⌄
MCQ-46`fact_clickstream` is 4 years of history, 2.1 PB, one destination partition per event date. The nightly job today is a full refresh: it rescans all 2.1 PB, rewrites every partition, costs $18,400 per run at $8.76 per TB scanned, and holds the write lock from 01:00 to 04:40 - it overran the 05:00 downstream read twice in the last five nights. Events land as files keyed by event date, and the connector rewrites the file for a date when it receives a late row or a source delete; a deleted row vanishes from the file while its `updated_at` in the source stays as it was. Across 90 days of connector logs, 99.98% of those rewrites happened within 3 days of the file's date and the oldest was 9 days. The table absorbs about 40 M rows a day, billing reconciles per-day row counts against the source, and the platform caps this table at $2,000 a night. Which nightly job ships?⌄
MCQ-73`orders` holds 11,000,000 rows, one per `order_id`. A loader appends every file that lands in `s3://lake/orders/cdc/` to `orders`, and the directory is the only signal of what a file means. Last night a vendor's full snapshot export (11,000,000 rows, one per `order_id`, same columns as a change file) was copied into that directory and the loader appended it. `orders` now holds 22,000,000 rows with 11,000,000 distinct `order_id` values, and a uniqueness test that samples 800 rows passed. The night before, a legitimate backfill had loaded 11,000,000 rows. Which loader change would have stopped last night's file from being appended?⌄
MCQ-63An orders snapshot is configured with strategy='check' and check_cols=['amount']. Orders move paid -> shipped -> delivered, and a return flips status to returned after delivery. Last quarter 210,000 orders changed status with their amount untouched; the snapshot wrote no rows for those changes and the "status at ship date" SCD2 model now reports paid for every shipped order. The source holds 5.2M rows and its updated_at column is stamped by the loader with the run time of the batch, the same value on every row. The daily job has stayed green. Which change fixes the missing status history?⌄
MCQ-40`dim_customer` in the warehouse is SCD type 2 on `region` (valid_from, valid_to, is_current) and type 1 on `email`. Last night's job ran one statement:
```sql
UPDATE dim_customer d
SET email = s.email, region = s.region
FROM staging_corrections s
WHERE d.customer_id = s.customer_id AND d.is_current;
```
The feed held 812 rows: 800 email-only corrections and 12 region corrections. This morning each of those 812 customers has exactly one region version, valid_from = last night, and the prior 14 months of region versions are gone. `fact_bonus` joins `dim_customer` on `is_current = true` and recomputes region-based tiers; its next run moved $3.2M of bonus between regions, while the source system recorded region changes for only 12 customers. Which action fixes the damage and stops it recurring?⌄
MCQ-3orders_current is a Snowflake table whose customer_id is declared as a primary key; Snowflake records that declaration but does not enforce it, and the only writer that keeps one row per customer is the CDC applier, which MERGEs each change on customer_id. At 01:55 the table holds 9,400,000 rows and 9,400,000 distinct customer_ids. The nightly dump is cut from orders at 01:30, and between 01:30 and 01:55 the CDC stream carries 12,000 updates to existing customers, with no inserts and no deletes. At 02:00 the nightly job appends the dump's 9,400,000 rows to orders_current; the CDC applier is paused until 02:30. The 02:05 check prints the table's row count and COUNT(DISTINCT customer_id). Which pair does it print, and what should be done about it?⌄
MCQ-12An order-events topic delivers at least once. A consumer writes each event to an append-only warehouse table with columns event_id (a UUID generated by the consumer at write time), order_id, order_value, and offset. Each order can produce many events, so order_id is not unique per row. The consumer commits offsets only after every write in the batch succeeds; any write error fails the batch. A 3-hour broker outage caused the same 1.4M-event batch to be redelivered 9 times. The table now holds 12.6M rows; AVG(order_value) is unchanged, SUM(order_value) is 9× the source. The next backfill runs in two days. Which change should ship before it?⌄
MCQ-37An orders pipeline reads a JSON payload where each order carries an `items` array, explodes it into one row per item, and writes `fact_order_items`. The weekly revenue dashboard sums `order_total` from that table and reports $2.0M. Finance's ledger, built from the same source orders, reports $500K. The source has 10,000 orders averaging 4 items and $50 order_total each. What should the review conclude?⌄
MCQ-6A Flink job aggregates events into 10-minute tumbling event-time windows with `forBoundedOutOfOrderness(Duration.ofMinutes(3))`. The highest event timestamp the source has emitted so far is 10:12. Which windows have emitted results?⌄
MCQ-8A Flink 1.x DataStream job windows checkout events by merchant in 1-minute tumbling event-time windows. It runs a bounded-out-of-orderness watermark of 5 seconds, sets allowed lateness of 2 minutes on the windows, and configures no side output for late data. Results go to an upsert sink keyed on (merchant, window_start). At processing time 08:05:00 the watermark for merchant M is 08:03:00; the 08:01-08:02 window for M has already emitted its result. At 08:05:10 an event for merchant M with event time 08:01:30 arrives. What does the job do with it?⌄
MCQ-7A Flink 1.18 job aggregates hourly revenue with `WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofHours(2))` and emits an hour's total when the watermark passes that hour's end. In production the 09:00 hour closed at 12:07; the row read $412,000 at 11:50 and $432,576 at 12:10. The dashboard marks every emitted row 'final' and the team advertises a 15-minute freshness SLA. Finance requires that no more than 0.1% of events be dropped; measured event delay is p99 = 90 minutes and p99.9 = 3 hours. Which change makes the advertised SLA honest without dropping more than 0.1% of events?⌄
MCQ-9A Flink 1.18 job reads a 12-partition Kafka topic, timestamps records from the payload, and builds watermarks as the minimum across all partitions. At 07:14 the producer for partition 7 dies; the other 11 partitions keep producing. By 08:40 the 08:00–08:05 tumbling window has not emitted, the job's watermark metric is pinned at 07:14, and 3.1 million events are buffered in the 11 live partitions. Which change closes the window without dropping the buffered events?⌄
MCQ-10A daily revenue dashboard reads hourly windows keyed on processing time. A 14-minute consumer lag moved 620,000 orders out of the 09:00 bucket into 09:15; replaying the same Kafka offsets the next day moved them back, and two board packs for the same day differed by $6.1M. Every order event carries its own order timestamp, the stream can emit watermarks, and the ops team needs a last-5-minutes view within seconds. What should the team do?⌄
MCQ-69A Flink 1.18 job computes hourly revenue in event-time tumbling windows with a bounded-out-of-orderness watermark of 5 minutes, so the 09:00–10:00 window fires at 10:05. Mobile clients buffer events offline and flush on reconnect; 2.4M events with event times inside 09:00–10:00 arrive after 10:05 and are dropped as late. The published 09:00 table holds 1.8M rows; a recompute after all events arrive holds 4.2M. The SLA promises the 09:00 table by 10:10. What should the review require?⌄
MCQ-43A Spark 3.5 Structured Streaming job reads JSON events from Kafka, parses each with `from_json`, and writes to a Delta sink under a 10-minute watermark. About one record in 200,000 arrives truncated. With `from_json` set to FAILFAST, the micro-batch throws; the orchestrator restarts the job, it re-reads from the last committed offset, hits the same record, and fails again. After six hours the watermark has not advanced and consumer lag has grown from 2M to 61M. No valid event may be dropped, and the bad record must be reprocessable once the producer is fixed. What should the team change?⌄
MCQ-93A streaming job inner-joins an orders stream to a customer-dimension stream. The dimension is published by a batch job that runs every 5 minutes, so a new customer's dimension row can land up to 5 minutes after that customer's first order. The job uses a 1-minute event-time window on the dimension side and drops facts that find no match. It reports 0 errors and the orchestrator DAG is green. In the last hour it read 1,200,000 orders and the destination holds 1,173,000. What most likely explains the 27,000-row gap, and what change closes it?⌄
MCQ-89An events pipeline reads Kafka with Spark Structured Streaming and commits to an Apache Iceberg table; the query trigger is processingTime = "15 seconds". Over a steady 24 hour run at 16 MB/s the telemetry shows: p50 micro-batch duration 40 seconds, of which the Iceberg commit (snapshot plus manifest write) is 38 seconds; 2,160 micro-batches executed; the sink runs 128 tasks and writes one data file per task per commit, giving 276,480 files of about 5 MB for the day; offset lag held steady at 40 to 55 seconds and p99 end-to-end latency was 55 seconds. An engineer changes only the trigger to 30 seconds. What does the measurement predict for the next 24 hours?⌄
MCQ-90A team must keep an Iceberg table's upserts within a 5-second p99 end-to-end. Their Structured Streaming job reads Kafka and runs an Iceberg MERGE inside foreachBatch. To cut latency they set trigger(continuous='1 second'); the query now fails at start with an analysis error naming an unsupported operation. What should they do?⌄
MCQ-27An Apache Iceberg table is fed by a Spark Structured Streaming job with a 30-second trigger; each commit appends one Parquet file of about 2 MB, so a day holds 2,880 files and about 5.6 GB. The nightly query over the last 24 hours now takes 22 minutes, and profiling puts about 20 of those minutes in file planning and the per-file footer read before any row is scanned. A fraud-detection job reads the table every minute and must see events within 60 seconds of arrival, and the nightly query has to return in under 3 minutes. Which change should ship first?⌄
MCQ-11A Flink job reads a Kafka topic of 10,000,000 order events (offsets 0–9,999,999) and writes them to an append-only Iceberg table through the engine's two-phase-commit sink, checkpointing every 60 s. Checkpoint 41 completes: its data files are in S3 and its Iceberg snapshot is committed, covering offsets 0–5,999,999. The job then writes the data files for checkpoint 42 (offsets 6,000,000–7,199,999) to S3 but crashes before the Iceberg commit for checkpoint 42 runs. The job restarts from checkpoint 41 and runs to completion. What does the table hold?⌄
MCQ-14A Flink job reads the 12-partition topic `orders` with `isolation.level=read_committed` and writes to Iceberg. The producer is transactional, one transaction per 30-second micro-batch, and is configured with `transaction.timeout.ms=1200000`. At 02:14 a producer task hangs with its transaction still open, and the producer keeps sending records into that open transaction. From 02:14 to 02:34 the Flink job's consumer lag for the group stays pinned at the 02:14 offset and no new rows reach the lake, even though the producer's send rate is unchanged. At 02:34 the coordinator aborts the transaction and the pipeline resumes. Which explanation and fix is correct?⌄
MCQ-88A 12-partition orders topic feeds a Flink job at a steady 900 events/s; the job windows the records and a JDBC sink autocommits each insert into an append-only Postgres table with no unique key. Checkpointing runs in EXACTLY_ONCE mode every 60 s, and the last completed checkpoint snapshotted source offsets as of 10:00:00. At 10:00:47 the TaskManager running the sink is preempted - the spot pool does this roughly weekly - and the job restarts from that checkpoint, leaving 42,300 duplicate orders behind and failing the ledger team's nightly COUNT(*) reconciliation. The table's schema is frozen for the quarter: no unique index, no upsert, no DELETE. Which change makes the next restart write each order exactly once?⌄
MCQ-80An orders consumer reads topic orders.updated, parses each record and appends one row to the warehouse table events(event_id, payload, ingested_at), committing offsets after every 1,000-record micro-batch; a record that fails to parse is published to dlq_orders and the batch continues. events is append-only, has no unique constraint on event_id, and held 1,240,000 rows with 1,240,000 distinct event_ids, all written before the affected window. During a six-hour parser outage every one of the 180,000 records that arrived failed to parse, so all of them landed in dlq_orders and none was written to events; a consumer restart made Kafka redeliver one batch whose DLQ produce had already succeeded, so 12,000 of those event_ids appear exactly twice in dlq_orders, which now holds 180,000 rows and 168,000 distinct event_ids, no id more than twice. The parser is fixed and the team replays with INSERT INTO events SELECT event_id, payload, ingested_at FROM dlq_orders; nothing else writes to events. What does events hold when that INSERT commits?⌄
MCQ-82A nightly loader sends 48,000 batch requests of 50,000 rows each to an ingest API. The client retries timeouts with exponential backoff (5 attempts, 1s–16s). The API's p99 is 8s and the client timeout is 30s; last night 2,400 requests hit connection resets after the API had committed them, and the retries appended again. The table now holds 50,400 batches, SUM(revenue) is 5% high, AVG(revenue) is unchanged, and every row carries a load_ts set at insert. Which change prevents the next run from inflating the table the same way?⌄
MCQ-51A catch-up job runs 200 worker tasks against a vendor API with a documented cap of 50 requests/second; the vendor returns 429 above the cap. Each task pulls one page per attempt, and an attempt takes 100 ms whether it succeeds or returns 429. On a 429 the task retries the same page immediately, with no delay. The load appends each page's rows with INSERT, keyed on (order_id, load_date). The client timed out on every page after the vendor had already accepted the write, and each retry succeeded. The window should hold 4.2 million order rows. What request rate does the vendor see, and how many rows does the table hold?⌄
MCQ-52An hourly DAG (`schedule="@hourly"`, `catchup=True`, `max_active_runs=16`) merges CDC rows into `orders` with `MERGE ... WHEN MATCHED AND source.loaded_at > target.loaded_at THEN UPDATE`, and a separate writer job rewrites the current day's partition every hour. The DAG was paused for 9 days during a migration and re-enabled at 09:00. By 09:01 Airflow had queued 216 runs; by 11:00 the open day held 31% duplicate keys and rows whose `status` had reverted to values from before the migration. What should the team do?⌄
MCQ-81Airflow 2.7 runs three nightly DAGs (`load_orders`, `load_events`, `load_users`) each with 8 load tasks, all scheduled at 02:00. The warehouse accepts 4 concurrent bulk loads; beyond that, throughput collapses. No pool is configured, `parallelism` is 32, and each DAG has `max_active_tasks=8`. Last night all 24 load tasks started within 30 seconds, warehouse CPU pinned at 100%, each load took 4× its normal 10 minutes, and the 03:00 SLA pack missed by 2 hours. Which change makes the pack on time?⌄
MCQ-23A nightly Spark job appends to an Apache Iceberg table on S3. At 02:10 spot reclamation kills the driver after the executors have written 400 Parquet files under the table's data prefix but before the commit reaches the catalog. At 02:15 a SELECT count(*) through the catalog returns 41,208,000, the same as the previous night. A second pipeline appends to the same table every few minutes. At 02:40 the killed job is retried and commits successfully. Which statement about the 400 files from the killed attempt is correct?⌄
MCQ-24`fact_events` is partitioned by `event_date`. The 2024-03-14 partition holds 24 hourly files totalling 41,000,000 rows. A correction job overwrites that partition with a SELECT that returns only hour 14's 1,700,000 rows; snapshot 1904 is the pre-correction snapshot. What does the partition hold afterwards, and what is the correct repair?⌄
MCQ-25A nightly reconciliation job reads an orders Delta table in S3 with a plain prefix glob, spark.read.parquet("s3://lake/orders/date=2025-05-14/"), instead of reading through the table. For 2025-05-14 it reports 2,412,000 orders totalling 150,508,800. Reading the same day through Delta reports 1,206,000 orders totalling 75,254,400, and AVG(order_total) is 62.40 in both reads. The current Delta log version names 96 live files for that day; the S3 prefix holds 1,140 parquet files, the other 1,044 left by two aborted MERGE jobs or superseded by later commits and not yet VACUUMed - the table's retention is 7 days and the team wants it kept. The job has to be right for tonight's run and stay right while MERGE jobs are retried and VACUUM runs on that 7-day clock. Which action should the team take, and what will the job report for the day?⌄
MCQ-42An Iceberg table `events` keeps snapshots for 30 days, and a compaction job ran last week. After a user's erasure request, `DELETE FROM events WHERE email = 'a@b.com'` reports 1 row deleted. An auditor lists the bucket's object keys, sees the original data file still present, and marks the erasure incomplete. Which action completes the erasure and proves it?⌄
MCQ-78A 4 TB Apache Iceberg table on S3 has events appended by a Flink SQL job that commits on every checkpoint and is configured with write.delete.mode=merge-on-read, so a row that lands in a data file stays in that file. A GDPR erasure request covers user 8842, whose events arrived in three checkpoints and sit in three data files. The on-call engineer runs DELETE FROM events WHERE user_id = 8842 in Flink SQL; it commits in 9 seconds and every later query returns no row for 8842. Which statement about the address in storage is correct?⌄
MCQ-99An Apache Iceberg 1.4 table `events` runs the `expire_snapshots` procedure nightly with a 7-day retention (`older_than` = 7 days ago). On day 0 a backfill wrote 40M wrong rows into the table; the mistake is found on day 8. Those rows were never rewritten, so the current snapshot still references the backfill's data files. A GDPR erasure request also arrives for 12,000 user ids that appear only in those files. After the day-8 expiry run, which statement holds?⌄
MCQ-86Table `events` was partitioned by `days(event_ts)` until 2024-02-15 12:00, when the team evolved the spec to `hours(event_ts)`. Rows for 2024-02-15 hours 0–11 were written before the change into one day-spec file (8.4M rows); hours 12–23 were written after into twelve hour-spec files (700k rows each). A job runs `SELECT count(*) FROM events WHERE event_ts >= '2024-02-15 11:00:00' AND event_ts < '2024-02-15 13:00:00'`. Which files does the scan read?⌄
MCQ-87A Delta table is written continuously by a streaming job that appends new files into dt= partitions, and a weekly job runs OPTIMIZE ... Z-ORDER BY customer_id over the whole table. A one-customer lookup on dt=today opens 8,200 files and takes 16 minutes; the same lookup on last week's partition opens 6 files and takes 12 seconds. The weekly job reports success on every run. Which conclusion is sound?⌄
MCQ-28A Flink CDC job writes to an Iceberg merge-on-read table, committing every 3 seconds, and lands its last micro-batch at 06:20. Twice in the past week it landed at 06:29. A downstream pack job runs 64 slots, reads the last 24 hours, and must finish inside a 20-minute window starting at 06:40. Last night it scanned 3,900 delete files in the hot partition, burned 77 slot-hours against a 21 slot-hour compacted baseline, and was still running at 07:52; its heap peaked at 40% of the 8 GB it is given. Compaction of that partition takes 14 minutes and is scheduled at 07:30. Which change fixes the SLO?⌄
MCQ-75An hourly Spark job rebuilds one day of a plain Parquet dataset at s3://warehouse/events/dt=2026-03-01/, with no Hive table and no Iceberg or Delta metadata. A run writes 240 part files in full into _temporary/, deletes the previous run's 240 files from the partition prefix, then renames the staged files in one at a time; on S3 a rename is a copy plus a delete, so the loop takes about 60 s. The partition holds about 4.1 M rows, roughly 17 K rows per file, and any listing returns exactly the files that have landed when it runs. A Trino query on s3://warehouse/events/dt=2026-03-01/*.parquet starts 30 s after the first rename lands and exits 0. What does it return?⌄
MCQ-66An upstream service writes one Parquet part file per shard under s3://events/dt=2024-06-01/ and, after its last PUT, writes s3://events/dt=2024-06-01/_manifest.json listing every part file with its row count and MD5. The loader starts at 02:00, lists the prefix, and overwrites the destination partition with whatever it finds. Last night the 02:00 listing returned 34 files and the loader wrote 1,190,000 rows; the manifest, published at 02:07, lists 40 files and 1,400,000 rows (35,000 rows per part). Consumers join against the destination from 02:30, and a short partition silently drops their rows while an unrefreshed one leaves yesterday's data intact. When a shard is slow, the last PUT and the manifest can land hours after 02:00. What should the loader do?⌄
MCQ-67An hourly revenue rollup reads every object under s3://events/date=2025-03-04/. The Flink job that produces that partition commits part files from 00:00 and writes one manifest.json naming the generation's 2,600 keys at 00:18; a compaction job rewrites the same prefix every 30 minutes around the clock, deleting small parts and writing merged ones. The rollup starts at 00:05, walks the prefix with ListObjectsV2 at MaxKeys=1000, and ingests 2,480 distinct keys. Its revenue total is short by $186,000, which matches 120 unread part files at roughly $1,550 each; all 120 of those keys were committed before 00:05, and every key the run did read matches the audit checksums. Which change makes the next run's input set complete and consistent?⌄
MCQ-97A nightly Spark 3.5 job writes 1.4 million rows to `s3://bucket/events/` with `df.write.mode("append").partitionBy("dt").parquet(path)`: a plain path, no table format. One executor is lost mid-write; Spark retries the stage and the job exits 0. The next morning `SELECT count(*), sum(amount), avg(amount)` over the prefix returns 2.8 million rows, sum doubled, avg unchanged. What should the team do?⌄
MCQ-98An hourly Spark job writes Parquet to s3://lake/staging/orders/ and then commits partitions to the Hive metastore. When the commit fails the job retries up to three times over a 90-minute window, and 12% of failures succeed on a later attempt, reusing the files already written. Files from attempts that never commit stay in the staging prefix: 40 GB/hour, roughly 29 TB/month. The nightly erasure job walks metastore-registered partitions only, and a subject-erasure request must complete within 30 days. What should the team change?⌄
MCQ-83A nightly extract pulls orders from a REST endpoint that returns 500 records per page plus a `next_cursor`, and the loader stops once it has requested 40 pages. Monday's source held 20,000 orders and the run loaded 20,000. Tuesday's source held 20,010 and the run loaded 20,000 again, reporting success. Tuesday's log shows exactly 40 requests, each returning 500 records. What explains the Tuesday result?⌄
MCQ-79A payments platform ingests 8 million customer records per day into a Parquet landing zone in S3. Analysts debug failed records by joining on customer email; last quarter 140 ad-hoc queries read plaintext email from landing, and a contractor exported 2.4 million emails. The security team now requires no plaintext PII at rest in landing and an audit record for every reverse lookup, but analysts still need to resolve a token back to an email for the 3% of records that fail validation. The tokenisation service can tokenise on first write and supports reverse lookup through an audited break-glass API that adds 120 ms per call; a direct reverse-lookup API also exists but does not record the caller. Which design meets both requirements?⌄
MCQ-41An orders pipeline uploads one Parquet batch per night at 02:00 to s3://acme-landing/orders/. Each batch holds 12,000,000 rows, and 1,400,000 of those rows carry a non-null national_id that the writer copies from the source in plaintext. A lifecycle rule keeps the last 30 daily batches and expires anything older. On Wednesday at 09:00 the team deploys a change to the ingest writer that replaces national_id with a KMS-backed token before upload, and runs no backfill. At 10:00 that morning a classifier scans the whole prefix and counts every plaintext national_id value it reads, with no de-duplication. What count does it report?⌄
MCQ-48A daily orders pipeline stores event_ts as a UTC timestamp and derives the partition column dt with DATE(event_ts) under a UTC session. Finance closes on the US Eastern business date. A backfill put 1.1M orders into the wrong finance day, shifting $8.2M between closes; the test suite asserted only the 00:30 Eastern case and passed. Which change addresses the class of failure?⌄
MCQ-49A daily job partitions events by local date in America/New_York. Each partition is built with a window anchored at local midnight and exactly 24 hours long. On 2024-11-03 the job wrote 960,000 rows, but the source holds 1,000,000 events whose local date is 2024-11-03. On 2024-03-10 the job wrote 960,000 rows, but the source holds 920,000 events whose local date is 2024-03-10. Events arrive at a steady 40,000 per hour. Which change makes both partitions contain exactly the events of their local date?⌄
MCQ-4A 61M-row MySQL orders table feeds the warehouse. The connector's source user has SELECT and REPLICATION SLAVE but no DDL rights on the primary, and the DBA will not grant CREATE TABLE. The base table must match the source at one known binlog position, and the nightly MERGE must not run until that base table is complete. Which bootstrap design is defensible?⌄
MCQ-77`db.orders` is an Iceberg table fed by one Flink job that appends one row per CDC event from the 12-partition Kafka topic `cdc.orders`; the sink appends and never deduplicates. A deploy shipped a pricing bug: the job's first run read 1,440,000 events (120,000 per partition), multiplied every `unit_price` by 100, appended 1,440,000 rows, and committed them as snapshot 200 on top of the 12,000,000 rows snapshot 199 already held. The job was stopped, and on-call then ran `CALL catalog.system.rollback_to_snapshot('db.orders', 199)`, so the table is back to snapshot 199's 12,000,000 rows. Consumer group `orders-cdc` still holds the offsets it committed at the end of the bad run, and the topic retains 36,000,000 events over its 7-day window. All 1,440,000 events were real order updates; only the job's arithmetic was wrong. Which action leaves the table with one correctly priced row per event?⌄
MCQ-92Table orders(order_id, amount, updated_at) stores one row per change. Order 101 has exactly two rows: (101, 40, '2024-03-01') and (101, 0, '2024-03-05'). A later $0 row voids the order, and a voided order must not appear in the current-state view. Which query returns the correct current state, and what does it return for order 101?⌄