{ "schemaVersion": 1, "pathSlug": "green-but-wrong", "items": [ { "questionId": "data_pipelines.orchestration__68296", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the purpose of task pools in orchestration?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Limiting concurrent task execution to prevent overwhelming shared resources" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "They pre-allocate compute resources for tasks" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Pools group related tasks for display purposes" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Pools store task output data" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.orchestration__68325", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the impact of DAG complexity on scheduler performance?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Deeply nested DAGs push the scheduler's parse step onto the worker that runs each task" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Highly complex DAGs with many tasks increase scheduling latency and memory consumption" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Task complexity is absorbed by the executor, so the scheduler's cost stays flat with size" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A DAG's task count sets how many scheduler replicas the deployment has to run at once" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__826394", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dev writes a custom sensor that polls an API every 30s for hours. The Airflow worker pool is exhausted and other DAGs queue. The sensor logic is fine. What sensor mode change avoids holding a worker slot the whole time?" } ] } ], "code": { "lang": "ts", "code": "wait = HttpSensor(task_id='wait', http_conn_id='api', endpoint='ready', poke_interval=30)", "label": "orchestration.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Set mode='persistent' so the sensor keeps state in XCom and only occupies a slot during state changes" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Set mode='reschedule' so the sensor releases its slot between pokes instead of sleeping while occupying a worker" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Set mode='soft_fail' so the sensor frees its slot after the first poke regardless of the result returned" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Set mode='deferred_legacy' so the sensor downgrades to a cron entry once it has run for over an hour" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__2010417", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Airflow's BranchPythonOperator semantics?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It runs every downstream task in parallel and afterwards prunes the outputs whose flag did not match" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It blocks the run until an operator user confirms which branch to take through the web UI dropdown" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It returns one or more downstream task ids to follow and the scheduler skips the unselected branches" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It writes a row to the metadata DB and a separate scheduler tick decides which branch is dispatched" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__68355", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the theoretical tradeoff between scheduling optimality and scheduling speed?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Finding the globally optimal schedule is undecidable, so a scheduler samples random orderings and keeps the best one it finds" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Finding the globally optimal schedule takes polynomial time once the DAG is acyclic, so a heuristic gives up optimality without buying speed" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Finding the globally optimal schedule is NP-hard; practical schedulers use heuristics that trade optimality for speed" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Finding the globally optimal schedule is linear in the task count; the cost sits in the metadata writes each decision needs" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__2010432", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which characterisation fits Airflow's deferrable operator pattern with the triggerer process?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Long waits release the worker slot and resume on a separate async loop once the trigger event fires" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Long waits are converted to schedule-only sleeps that pause the entire DAG run until the wake moment" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Long waits send a request to a sibling DAG that holds the wait condition and wakes the original run" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Long waits continue to occupy a worker slot but suspend their thread inside the executor heartbeat tick" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__200206", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How do Prefect flows differ from Airflow DAGs in how the dependency graph is expressed in user code?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Prefect derives dependencies from Python function calls and return values at runtime, no static DAG file" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Prefect requires a YAML DAG manifest at parse time and forbids using normal Python function call edges" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Prefect and Airflow both compile a static graph from decorators only and forbid runtime call inference" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Prefect rejects any function-call style and requires a static graph compiled before each scheduler run" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__7116842", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "In modern Airflow, what behavior does the deferrable=True flag enable on a sensor or operator?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The task suspends on a Trigger handled by the triggerer process, freeing its worker slot until the event fires" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The task is moved to the smart_sensor service so that one process can poll many sensor instances at once instead" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The task is rescheduled with mode='reschedule', releasing the slot but rerunning poke from scratch each time" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "The task is queued on a celery_kubernetes hybrid executor that allocates pods for long waits" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.orchestration__68294", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is idempotency in the context of orchestrated tasks?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A task that holds a lock so that two runs of it cannot overlap in time" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A task that the scheduler guarantees to launch exactly once per interval" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A task that writes its output before it acknowledges the upstream trigger" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A task that produces the same result regardless of how many times it runs" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.orchestration__68333", "topic": "data_pipelines", "subSkill": "orchestration", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does event-driven orchestration differ from traditional scheduling?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The consumer subscribes to the producer's graph, so the two run as one larger workflow" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "An event from the producer starts the work downstream, so no polling is needed" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A timer starts the work downstream, and each event from the producer waits until it fires" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "The scheduler reads the storage layer directly, so a file landing is what triggers a run" } ], "shape": "long" } ] } }, { "questionId": "postgresql.json_operations__52263", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How do you aggregate rows into a JSONB array in PostgreSQL?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Using the json_collect() aggregate function" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "Using the array_to_jsonb() function with ARRAY_AGG" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Using the jsonb_agg() aggregate function" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Using the GROUP BY ... INTO JSONB syntax" } ], "shape": "short" } ] } }, { "questionId": "postgresql.json_operations__100422", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which characterization correctly describes the json data type relative to its sibling binary type?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Enforces a schema registry similar to Avro and rejects payloads with unknown fields" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Normalizes incoming documents into a canonical ordering before storing them internally" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Rewrites numbers into arbitrary-precision decimals and strips surrounding whitespace" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Stores an exact copy of the input text including whitespace and duplicate key order" } ], "shape": "long" } ] } }, { "questionId": "postgresql.json_operations__824607", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which mutation helper returns the document unchanged when the target path does not exist, unless an explicit flag is passed to create missing keys?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "jsonb_insert with an implicit overwrite flag that replaces existing sibling values" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "jsonb_strip_nulls with an add_if_missing parameter defaulted to preserve the shape" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "jsonb_path_query_first with a mutate flag that commits updates inside the query" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "jsonb_set with create_if_missing defaulting to true but bypassable by passing false" } ], "shape": "long" } ] } }, { "questionId": "postgresql.json_operations__500811", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the guarantee jsonb makes about key ordering within an object when a document is retrieved?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Keys are returned in an order derived from length-then-byte comparison rather than input order" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Keys are returned in the exact original insertion order that the client submitted originally" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Keys are returned in alphabetical order using the database default collation for comparison" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Keys are returned in hashed order so iteration cost stays roughly bounded on huge objects" } ], "shape": "long" } ] } }, { "questionId": "sql.json_operations__2256842", "topic": "sql", "subSkill": "json_operations", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "You store data in a jsonb column. What does the abbreviation JSON itself stand for?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Java Standard Output Notation" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "JavaScript Object Notation" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Java Serialized Object Nodes" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Joined Structured Object Names" } ], "shape": "short" } ] } }, { "questionId": "postgresql.json_operations__60709", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does " }, { "t": "code", "v": "jsonb_array_elements()" }, { "t": "text", "v": " return?" } ] } ], "code": { "lang": "sql", "code": "SELECT jsonb_array_elements('[1, 2, 3]'::jsonb);\n-- Returns:\n-- 1\n-- 2\n-- 3", "label": "json-operations.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "An integer count of how many elements the JSONB array contains" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A text array containing every element converted into a plain string" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A two-element record containing the first and last array elements" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A set of JSONB values, one for each element in the JSON array" } ], "shape": "short" } ] } }, { "questionId": "sql.json_operations__2256846", "topic": "sql", "subSkill": "json_operations", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Within a JSON object, what sits between each key and its value?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "the equals character =" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "the colon character :" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "the comma character ," } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "the hyphen character -" } ], "shape": "short" } ] } }, { "questionId": "sql.json_operations__2256849", "topic": "sql", "subSkill": "json_operations", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How are the two JSON boolean values written?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "the integers 1 and 0" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "uppercase TRUE and FALSE" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "quoted \"true\" or \"false\"" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "lowercase true and false" } ], "shape": "short" } ] } }, { "questionId": "sql.json_operations__1282", "topic": "sql", "subSkill": "json_operations", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does the standard SQL/JSON " }, { "t": "code", "v": "JSON_TABLE" }, { "t": "text", "v": " operator in a " }, { "t": "code", "v": "FROM" }, { "t": "text", "v": " clause do, and why is it useful?" } ] } ], "code": { "lang": "sql", "code": "SELECT jt.*\nFROM orders,\n JSON_TABLE(order_items, '$[*]' COLUMNS (\n product_id INT PATH '$.product_id',\n quantity INT PATH '$.qty',\n price DECIMAL(10,2) PATH '$.price'\n )) AS jt;", "label": "json-operations.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Shreds a JSON document into a virtual relation with typed columns described by path expressions, joinable to ordinary tables" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Serializes a relational table into a single JSON document the caller can fetch in one round-trip instead of many rows" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Declares a physical table whose rows are persisted on disk in JSON format instead of the engine's normal row layout" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Builds an index whose leaves are JSON fragments so document-shaped lookups can avoid scanning the full table" } ], "shape": "long" } ] } }, { "questionId": "postgresql.json_operations__61166", "topic": "postgresql", "subSkill": "json_operations", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a jsonpath expression in PostgreSQL and what is its syntax?" } ] } ], "code": { "lang": "sql", "code": "-- Find items with price > 100:\nSELECT * FROM products\nWHERE data @? '$.items[*] ? (@.price > 100)';\n\n-- Extract matching values:\nSELECT jsonb_path_query(\n data, '$.items[*].name'\n) FROM products;", "label": "json-operations.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A column-traversal expression used by foreign-key constraints to navigate parent-child table joins" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A filesystem path to a JSON file on disk that the server can import via COPY or pg_read_file" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "An XPath-like syntax restricted to the legacy json text type and not usable against jsonb columns" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A query language for JSONB values using $ as the root element and dot/bracket notation for traversal" } ], "shape": "long" } ] } }, { "questionId": "sql.subqueries__1693415", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does a subquery consist of internally?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Its own SELECT with FROM and optional WHERE" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Just a table name wrapped inside parentheses" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A single column name and nothing more else" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Only a comparison operator and a plain value" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__10195", "topic": "sql", "subSkill": "subqueries", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What type of problem is recursive CTE designed to solve?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Detecting transaction deadlock cycles in real time" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Managing database connection pool sizes at runtime" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Performing bulk schema migration across databases" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Hierarchical or graph-like traversal within SQL queries" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__1693412", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which keyword returns true as soon as its subquery produces at least one row?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The HAVING keyword" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The EXISTS keyword" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The ANY comparison" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The UNION keyword" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__1693429", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What happens if a subquery compared with " }, { "t": "code", "v": "=" }, { "t": "text", "v": " returns more than one row?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The database returns all the rows" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The database ignores the compare" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The database keeps the first row" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The database raises an error" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__728", "topic": "sql", "subSkill": "subqueries", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does this CTE query compute?" } ] } ], "code": { "lang": "sql", "code": "WITH monthly AS (\n SELECT DATE_TRUNC('month', date) AS month,\n SUM(amount) AS revenue\n FROM sales\n GROUP BY 1\n)\nSELECT * FROM monthly\nWHERE revenue > 10000;", "label": "subqueries.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A stored procedure with two steps" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "An error because CTEs cannot use HAVING" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A two-step computation: first calculates monthly revenue, then selects only months with revenue over $10,000" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A single query that filters and aggregates simultaneously" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__100478", "topic": "sql", "subSkill": "subqueries", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "PG16 introduced a SQL/JSON construction function that builds an array of objects from a row source, avoiding the older array_agg/row_to_json pattern. Which function name was added?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "JSON_BUILD_FROM on rows" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "ARRAY_TO_JSONB on a query" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "TO_JSON_ARRAY on a result" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "JSON_ARRAYAGG over a query" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__1693425", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What role do the parentheses around a subquery play?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "They cache the nested query result for later reuse" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "They convert the nested query into a real index" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "They mark where the nested query starts and ends" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "They force the nested query to run in parallel" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__1693421", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A hard-coded list of values after a membership keyword can be replaced by a subquery. Which keyword is that?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The IN keyword" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The BY keyword" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The AS keyword" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The ON keyword" } ], "shape": "short" } ] } }, { "questionId": "sql.subqueries__500163", "topic": "sql", "subSkill": "subqueries", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the standard semantics of NULLs inside the left-hand row constructor of a row-subquery comparison?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Element-wise comparison treats NULL as a sentinel value, returning FALSE on any NULL" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Element-wise comparison short-circuits to TRUE if at least one non-NULL pair matched" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Element-wise three-valued logic yields UNKNOWN whenever any compared pair contains NULL" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Element-wise comparison promotes NULL to a default zero or empty string before testing" } ], "shape": "long" } ] } }, { "questionId": "sql.subqueries__1693433", "topic": "sql", "subSkill": "subqueries", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A subquery that returns exactly one value can be used anywhere you would otherwise write what?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A long list of many rows" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A fully joined extra table" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A single hard-coded literal" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A brand new column alias" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__702", "topic": "sql", "subSkill": "joins", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What performance technique helps speed up JOIN operations?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Using CROSS JOIN instead of INNER JOIN" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Joining tables in reverse alphabetical order" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Creating an index on the join column (typically the foreign key) to avoid full table scans" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Adding more columns to the SELECT clause" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__983613", "topic": "sql", "subSkill": "joins", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "In " }, { "t": "code", "v": "FROM authors a JOIN books b" }, { "t": "text", "v": ", what are the single letters " }, { "t": "code", "v": "a" }, { "t": "text", "v": " and " }, { "t": "code", "v": "b" }, { "t": "text", "v": "?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Sort keys for the output rows" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Short aliases for the two tables" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Names of two selected columns" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The two join types being used" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__10273", "topic": "sql", "subSkill": "joins", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does this query return?" } ] } ], "code": { "lang": "sql", "code": "SELECT u.name, o.total\nFROM users u\nINNER JOIN orders o ON u.id = o.user_id;", "label": "joins.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "All users with NULL totals for those without any orders" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Each user's name with their order total, only for users with orders" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Only users who have not yet placed any orders at all" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The total sum of all orders from every user combined" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__416943", "topic": "sql", "subSkill": "joins", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How many rows does the query produce?" } ] } ], "code": { "lang": "sql", "code": "-- cust(id): 1,2\n-- orders(cust_id,total):\n-- (1,9),(1,8),(1,7),(2,5),(2,4),(2,3)\nSELECT c.id, t.total\nFROM cust c\nCROSS JOIN LATERAL (SELECT total FROM orders\n WHERE cust_id = c.id\n ORDER BY total DESC\n FETCH FIRST 2 ROWS ONLY) t;", "label": "joins.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "8" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "2" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "6" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "4" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__709", "topic": "sql", "subSkill": "joins", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which physical join algorithm requires both inputs to arrive already ordered on the columns being joined, then advances two cursors through them in step?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A join algorithm that converts both inputs into a single materialized union beforehand" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A join algorithm that iterates the outer input once and rescans the inner input per row" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A join algorithm where both tables are sorted by the join key and then merged in a single pass, like merging two sorted lists" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A join algorithm that probes a hash table built from the smaller participating input first" } ], "shape": "long" } ] } }, { "questionId": "sql.joins__10274", "topic": "sql", "subSkill": "joins", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does a FULL OUTER JOIN return?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "All rows from both tables, NULLs where no match exists" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "All rows from the left table exclusively" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Rows that match in neither of the two tables" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Only rows that match in both joined tables" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__400564", "topic": "sql", "subSkill": "joins", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the correct characterization of a star-schema join in a typical analytic workload?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Multiple dimension tables are joined directly to one another, with the fact table appended afterward as a UNION." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The schema relies on self-joins of the fact table on temporal columns to compute dimension labels at query time." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A central staging table is joined to numerous fact tables via natural keys exposed by their declared constraints." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A central fact table is joined to several small dimension tables on surrogate keys, often via hash builds on dimensions." } ], "shape": "long" } ] } }, { "questionId": "sql.joins__983618", "topic": "sql", "subSkill": "joins", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "If you write just " }, { "t": "code", "v": "JOIN" }, { "t": "text", "v": " with no word in front of it, which join type do you get?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "INNER JOIN" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "OUTER JOIN" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "CROSS JOIN" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "FULL JOIN" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__10275", "topic": "sql", "subSkill": "joins", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the ON clause used for in a JOIN?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Setting the sort order of the joined results" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Creating a new table from the join operation" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Specifying how rows from two tables are matched" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Defining which columns to select from output" } ], "shape": "short" } ] } }, { "questionId": "sql.joins__10278", "topic": "sql", "subSkill": "joins", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does this query find?" } ] } ], "code": { "lang": "sql", "code": "SELECT u.name\nFROM users u\nLEFT JOIN orders o ON u.id = o.user_id\nWHERE o.id IS NULL;", "label": "joins.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The total number of orders per user" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Users who have never placed an order" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Users who have placed at least one order" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "All users with their latest order" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.change_data_capture__68437", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a CDC event envelope?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A structured message carrying the record as it now stands, with no history of that one change" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A structured message carrying the record before and after the change, plus metadata about it" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A schema registry entry describing the shape each change event on that topic will take" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A wrapper the connector adds so the broker can route the message to the right consumer" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__100232", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A trigger-based CDC pattern records row changes into a separate audit table. After running the snippet, what does the final SELECT print?" } ] } ], "code": { "lang": "ts", "code": "import sqlite3\nconn = sqlite3.connect(':memory:')\nc = conn.cursor()\nc.execute('CREATE TABLE t (id INT, v INT)')\nc.execute('CREATE TABLE t_audit (op TEXT)')\nc.execute(\"CREATE TRIGGER t_u AFTER UPDATE ON t BEGIN INSERT INTO t_audit VALUES('UPDATE'); END\")\nc.execute('INSERT INTO t VALUES (1, 10)')\nc.execute('UPDATE t SET v = 20 WHERE id = 1')\nprint(c.execute('SELECT op FROM t_audit').fetchall())", "label": "change-data-capture.ts" }, "widget": { "kind": "predict_output", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "[('INSERT',)]" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "[('CHANGE',)]" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "[('UPDATE',)]" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "[('MODIFY',)]" } ], "shape": "code" } ] } }, { "questionId": "data_pipelines.change_data_capture__68501", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does CDC handle changes to default value definitions on a source table?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The existing rows are rewritten with the new default, and the capture emits an update for each of them" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "New inserts take the new default, and the capture reports the value stored rather than the definition" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The capture pauses until the change is applied, then resumes with a fresh snapshot of the whole table" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "New inserts take the old default, and the capture reports the definition rather than the value stored" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__68487", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does CDC interact with database vacuum operations in PostgreSQL?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Vacuum has no bearing on the capture, since the slot reads a snapshot taken when it was created" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Vacuum blocks the replication slot altogether, so the capture pauses while it runs" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Vacuum reclaims space from dead tuples, and an aggressive one can fight the replication slot" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Vacuum rewrites the write-ahead log, so an aggressive one truncates what the reader has yet to see" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__68488", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the challenge of CDC in a multi-master database topology?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Changes from separate masters are already merged by the engine, so the capture sees one stream" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Changes from separate masters arrive with no primary key, so the consumer cannot match rows up" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Changes from separate masters cannot be read at once, since one slot serves the whole cluster" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Changes from separate masters have to be deduplicated and ordered, and conflicts captured too" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__68477", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the role of CDC in an ODS architecture?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It feeds live changes from the operational databases into a store that integrates several sources" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It reads the integrating store on a schedule and pushes the differences back to each source system" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It replaces the integrating store, since the change stream itself is the record other systems read" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It archives the integrating store into the lake, so the operational databases can be trimmed back" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__200001", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterizes the role of Kafka Connect in many CDC deployments?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It hosts source and sink connectors that move row events between databases and topics with managed offsets" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It orchestrates DAG retries and backfills across worker pools that materialize transformed analytics tables" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It schedules dbt models that read raw events and emit partitioned facts into a downstream lakehouse store" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It runs SQL transforms over staging tables and stores curated marts back into the originating warehouse engine" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__68498", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the challenge of implementing CDC for columnar databases?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Such a store rewrites the whole file on update, so each change event carries that whole file with it" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Such a store keeps no transaction log, so the changes have to be inferred by diffing files" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Such a store has no primary key, so the consumer cannot tell which row an event refers to" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Such a store is built for batch reads rather than row-level change tracking, so capture is awkward" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__100231", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A new ingestion pipeline polls a source table every 5 minutes with SELECT * WHERE updated_at > :last_seen. Operators report that hard-deleted rows in the source never disappear from the warehouse copy. What is the cause?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Polling on updated_at cannot observe DELETE events because the deleted row has no row to emit" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Warehouse MERGE statement is silently dropping NULL primary keys before applying tombstones" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Source clock skew prevents updated_at from advancing past the prior watermark column" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Polling interval is shorter than the warehouse commit latency so deletes get overwritten" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.change_data_capture__971465", "topic": "data_pipelines", "subSkill": "change_data_capture", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A platform wants Postgres logical replication slots to survive a planned switchover from primary to replica without manual recreation. Which Postgres 17 feature directly addresses this?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Two-phase commit decoding with prepared transactions" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Bidirectional logical replication via origin filters" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Failover-aware logical replication slot synchronization" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Slot retention policy via pg_replication_slot_advance" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.stream_processing__68224", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the role of offsets in stream processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "They order the events inside a partition, which the broker would not otherwise do" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "They record where a producer has got to in a partition, so it can resume" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "They record where a consumer has got to in a partition, so it can resume" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "They count the events a consumer has skipped, from which its lag can be computed" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.stream_processing__68251", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the tradeoff of small versus large checkpoint intervals?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Short intervals cut the replay after a failure but cost more overhead, long ones the other way round" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Short intervals suit a stateless job and long ones a stateful job, which decides the setting" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Short intervals need more storage and long ones need more memory, so the total cost is similar" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Long intervals cut the replay after a failure but cost more overhead, short ones the other way round" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__200336", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes a session window?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Window bounded by a configurable inactivity gap between consecutive keyed events" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Window scoped to one task slot that closes when the operator's checkpoint succeeds" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Window that emits a result every fixed slide interval over a longer fixed length" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Window keyed by a user-supplied label that closes on an explicit end-of-window event" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__68220", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is event sourcing's relationship to stream processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Event sourcing stores the current state and a change journal beside it, so a stream processor reads the state rather than the log" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Event sourcing stores all state changes as an immutable log that can be replayed, naturally aligning with stream processing" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Event sourcing compacts its log to the latest value per key, so stream processing replays the present rather than the history" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Event sourcing is the persistence layer a stream processor writes its checkpoints into, which is what makes replay possible" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__68256", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the challenge of scaling stateful stream processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Adding workers splits the input partitions, which the broker refuses while a consumer group is active" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Redistributing state across new workers requires consistent state migration without data loss or duplicates" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Adding workers raises the checkpoint interval, since more participants have to acknowledge each barrier" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Adding workers changes each key's hash bucket, so the running job has to be stopped and rebuilt from scratch" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__401361", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterizes the trigger semantics in Apache Beam's windowing model?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Triggers determine how the runtime shards keys across worker bundles for parallel aggregation tasks" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Triggers decide when to emit pane results for a window, separately from how data is grouped into windows" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Triggers are user-defined predicates evaluated per record to decide whether the record enters a window" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Triggers configure how lateness budgets are subtracted from the source watermark on each bundle commit" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__68214", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the difference between tumbling and sliding windows?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Tumbling windows close on a watermark and sliding ones close on a count of events" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Tumbling windows are fixed and do not overlap, sliding ones overlap by a set amount" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Tumbling windows are keyed and sliding ones are global, which is where they differ" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Sliding windows are fixed and do not overlap, tumbling ones overlap by a set amount" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__300456", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing Flink's checkpoint mechanism with Kafka Streams' changelog-topic-based state restoration, which framing best describes the difference?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Flink restores each task's local store by replaying a dedicated changelog topic while Kafka Streams coordinates aligned barriers across operators globally" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Flink stores all state directly in Kafka topics by design while Kafka Streams stores all state inside a centralized cluster-wide RocksDB volume per region" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Flink relies entirely on the source connector's offsets for recovery while Kafka Streams snapshots the entire JVM heap to a coordinated remote object store" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Flink coordinates aligned barriers across operators to snapshot global state while Kafka Streams restores each task's local store by replaying its dedicated changelog topic" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__200447", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterizes a KTable in Kafka Streams compared to a KStream?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Side-channel iterator that scans broker partition leaders for hot-key rebalance hints" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Wrapper around a remote SQL view that lazily resolves projections at query time" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Read-only handle on the producer's idempotent transaction id used for commit replay" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Changelog view of the latest value per key, materialized from a compacted source topic" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.stream_processing__68259", "topic": "data_pipelines", "subSkill": "stream_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the role of event-time processing in replay scenarios?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Working by processing time gives the same answer whatever pace the replay runs at" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Working by event time bounds the state a replay holds, since the windows close sooner" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Working by event time gives the same answer whatever pace the replay runs at" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Working by event time lets the replay skip the windows that were already emitted" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.etl_basics__100231", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "In a classic ETL pipeline, what distinguishes the Transform step from the Extract step?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Transform reshapes and cleans the rows; Extract pulls raw data out of source systems" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "Transform writes the final tables to the destination; Extract validates inbound payload schemas" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Transform partitions output files for query speed; Extract orders rows by the primary key value" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Transform handles auth to the source APIs; Extract aggregates rows for the reporting layer use" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.etl_basics__307829", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A team must reprocess two years of an incremental fact table because a transform bug under-counted refunds. They want zero downtime for current dashboards while the corrected history is rebuilt. Which deployment pattern fits the constraint?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Blue/green build of a shadow table, validated, then atomically swapped over the live table" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "TRUNCATE of the live table followed by a sequential reload of two years of partitions" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Drop-and-recreate of the live table inside the same DAG run as the corrected transform" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "In-place UPDATE of historical rows on the live table with a long-running merge statement" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.etl_basics__1052874", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes a full refresh load strategy?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Replaces the entire target table on every run by re-reading all source rows" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Merges new rows into target by primary key, leaving existing rows untouched on match" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Reads only rows whose updated_at exceeds the prior run's high watermark value" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Streams change events from a CDC log into the target with at-least-once delivery" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.etl_basics__101594", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does ELT differ from traditional ETL in where the transformation work executes?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "ELT loads raw data first and transforms inside the warehouse; ETL transforms before loading" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "ELT requires a streaming engine for transforms; ETL pushes its transforms to source databases" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "ELT depends on a separate staging server for joins; ETL writes directly to source tables in place" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "ELT skips the load phase entirely for speed; ETL skips extraction when the source is a CSV" } ], "shape": "code" } ] } }, { "questionId": "data_pipelines.etl_basics__13434", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does a service reliably emit an event for every row it commits when the broker lives outside the database?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The change commits first and the event is published straight after, inside a retry loop" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The event is published to the broker inside the transaction, which rolls back on failure" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The consumer polls the table on a timer, so no event has to be published by the service" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "The change and an outbox row commit together, and the row is published afterwards" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.etl_basics__12405", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a common reason ETL jobs fail in production?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Schema changes in the source system that break the extraction query" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The target database runs out of CPU cores" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "ETL tools automatically shut down after 24 hours" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Source systems block all read operations at night" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.etl_basics__13415", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How should ETL handle data from multiple time zones?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Store in the source system's local time zone" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Convert to the engineer's local time zone" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Normalize all timestamps to UTC during the transform phase" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Discard timezone information and store dates only" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.etl_basics__5067291", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterizes the lambda data architecture?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Decomposes each transform into pure stateless functions invoked by an event-driven gateway" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Routes all events through a single replayable log so batch and serving share one code path" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Stores raw bytes in object storage and lets the query engine infer schema at runtime per file" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Pairs a batch layer for accuracy with a speed layer for low-latency, merging at serve time" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.etl_basics__13401", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "When designing an ETL pipeline for late-arriving data, which approach is most robust?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Process as full load every time" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Delete all records older than 24 hours" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Reject any record before the last watermark" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Use an upsert strategy that updates existing records and inserts new ones" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.etl_basics__13414", "topic": "data_pipelines", "subSkill": "etl_basics", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is backfilling in ETL?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Loading a forecast of future periods into the target so a report can chart both" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Replacing the null values in a historical partition with the column's declared default" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Re-running a pipeline for historical date ranges to fill gaps or apply new logic" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Reversing the pipeline's steps so the target can be rebuilt from its output back" } ], "shape": "short" } ] } }, { "questionId": "event_driven.idempotent_consumers__210103", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the role of a stable per-message identifier in deduplicating handlers?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It carries a monotonic broker offset so the receiver compacts the log before each downstream materialised view." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It encodes a routing key so the receiver fans out the payload onto the correct topic partition shard." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It uniquely tags a payload so the receiver can recognise a redelivery and skip the second application." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It signs the envelope so the receiver can verify the producer claim before forwarding to a sibling queue." } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__200205", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Distinguishing 'commit offset then process' from 'process then commit offset' in a consumer loop, what is the correct comparison of failure modes?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Committing first cuts the broker memory footprint roughly in half during a hot run, committing after processing forces the consumer to lock the partition for the entire batch" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Committing first guarantees exactly-once semantics for free regardless of handler logic, committing after processing forces the broker into transactional producer mode" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Committing first risks message loss on crash because work was never done, committing after processing risks reprocessing the same message after a crash" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Committing first works only with a single broker family from a vendor, committing after processing works only with another due to how each stores consumer position offsets" } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__78138", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does a database UPSERT operation help achieve idempotent event processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It rolls back the previous write before applying the new one, keeping the record consistent" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It generates unique event IDs automatically to prevent duplicate processing" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "It writes the same final state whether it runs once or ten times, inserting then updating" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It blocks further writes to the row after the first successful insert lands" } ], "shape": "short" } ] } }, { "questionId": "event_driven.idempotent_consumers__78029", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What makes an event consumer 'idempotent'?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The consumer rejects any event it has seen before by checking the event timestamp" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The consumer processes events in strict order, never skipping or reprocessing any event" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The consumer acknowledges events before processing them to prevent redelivery" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Processing the same event multiple times produces the same result as processing it once" } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__53201", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A consumer team wants to decouple receiving an event from processing it, and use the same database that holds business state to dedup. Which arrangement realises that on the consumer side?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Insert each incoming envelope into an in-memory ring buffer sized to the broker batch, ack the broker, then let a worker drain the buffer in batches that flush every fixed interval to disk." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Insert each incoming envelope into a local inbox table with a unique constraint on the event id, ack the broker, then let a worker drain the inbox in order inside transactions that mark rows processed." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Insert each incoming envelope into a write-ahead log on local disk, ack the broker, then let a worker tail the log file and replay entries into the business write path on every restart cycle." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Insert each incoming envelope into a priority queue keyed by importance score, ack the broker, then let a worker drain entries in priority order inside transactions that mark entries shipped." } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__78149", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a 'poison message' and how should consumers handle it?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A message that consistently makes the consumer fail on malformed or unexpected data" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A message that exceeds the broker's maximum size limit and blocks the queue" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A message whose TTL has expired and which should be discarded in silence" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A malicious message an attacker injects in order to crash the consumer service process" } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__641857", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Set.add semantics drive the consumer's dedup decision. What does the script print?" } ] } ], "code": { "lang": "ts", "code": "const seen = new Set();\nfunction firstSeen(id) {\n const had = seen.has(id);\n seen.add(id);\n return !had;\n}\nconst a = firstSeen('e-1');\nconst b = firstSeen('e-1');\nconsole.log(`${a} ${b}`);", "label": "idempotent-consumers.ts" }, "widget": { "kind": "predict_output", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "false false" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "true true" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "false true" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "true false" } ], "shape": "short" } ] } }, { "questionId": "event_driven.idempotent_consumers__78274", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'token-based deduplication' pattern?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The producer puts a unique token in the event and the consumer dedupes on it" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A broker feature that generates a unique token for each message delivery attempt" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Consumers exchanging tokens to coordinate which of them processes which event" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Using JWT tokens to authenticate producers and consumers for secure deduplication" } ], "shape": "long" } ] } }, { "questionId": "event_driven.idempotent_consumers__78163", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the difference between 'idempotent' and 'safe' operations in the context of event processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "There is no difference: safe and idempotent mean the same thing in event processing" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Safe operations are the ones certain to succeed; idempotent operations can fail" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Idempotent means a repeat has the same effect; safe means state does not change" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Idempotent operations avoid writes; safe operations can modify state" } ], "shape": "code" } ] } }, { "questionId": "event_driven.idempotent_consumers__78305", "topic": "event_driven", "subSkill": "idempotent_consumers", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "In everyday terms, what is an 'idempotent' operation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "An operation that works once and fails on the attempts that follow it" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "An operation that reverses itself when it is performed too many times" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "One that gives the same result once or many times, like an elevator button" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "An operation that runs faster the second time because the result is cached" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__69971", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'event-based audit' pattern as a replacement for soft deletes?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Keeping the previous version in the same row, which the reader then ignores here" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Keeping a shadow copy of the table, written to by a trigger on each change" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Keeping a flag and a timestamp per row, which is what the other pattern did" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Keeping an immutable log of each change instead of leaving deleted rows behind" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__69828", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'status lifecycle' pattern as a more flexible alternative to boolean soft delete?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A flag per state, so a row can sit in more than one state at a time" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A second table per state, with the row moved as its state moves along" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A status column naming the state, so each state gets its own handling" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A timestamp per status change, from which the current state is derived" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__10214", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Among the column shapes teams pick to flag logically removed rows, which one is the most widely recommended in current style guides?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A reserved sentinel value packed into the primary key column itself to indicate removal status" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A nullable timestamp column whose value records when the row was marked removed" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A boolean column constrained to NOT NULL DEFAULT false, with the value true meaning removed" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A status code stored in a separate one-row metadata table that the application joins on read" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.soft_delete__69816", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a soft delete?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Temporarily hiding a record during a maintenance window" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Deleting a record only from the application cache but keeping it in the database" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Marking a record as deleted (e.g., setting a flag or timestamp) instead of physically removing it from the database" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Deleting a record and storing a copy in a recycle bin table" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__70134", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the impact of soft deletes on database backups and restore?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The flagged rows break a restore, since the constraint rejects them on load" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The flagged rows are written to a separate file, restored on their own later here" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The flagged rows stay in the table, so the backup grows and restores with them" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The flagged rows are skipped by the backup, so a restore comes back without" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__70175", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'row-level security' approach to implementing soft delete visibility?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A view per table filters the deleted rows, and the queries read the view" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Policies filter the deleted rows by role, leaving the queries untouched" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The client library rewrites each query, adding the filter as it goes out" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A trigger moves the deleted rows aside, so no filter is needed on read" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.soft_delete__10257", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "After a soft-delete column has been in production for a year on a high-write table, which cost shows up that wasn't visible in the design review?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Replication lag rises in proportion to the count of rows whose removal marker has been set to non-null" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The optimiser issues an implicit FOR UPDATE on rows still carrying NULL in their removal-marker column" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The planner switches to bitmap scans on every table that carries a removal-marker column, regardless of size" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Every read predicate now carries a deleted_at IS NULL check, and indexes must cover it or lose effectiveness" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.soft_delete__20884", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A system uses soft deletes for compliance: deleted records must be retained for 7 years. What additional concern arises beyond the deleted_at column?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "GDPR and similar regulations require permanent deletion of personal data on request, conflicting with soft-delete retention" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The 7-year retention requirement cannot be implemented with soft deletes and requires periodic hard delete cycles" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The deleted_at column must be indexed with a partial index to support compliance query performance at audit scale" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Soft-deleted records inflate database size over time to the point of exceeding provisioned storage quota limits" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.soft_delete__70022", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'immutable delete log' pattern that provides the benefits of soft delete without table bloat?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Physically remove the row from the main store, then insert a deletion record holding the original data into a separate, append-only log" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Keeping soft-deleted rows but compressing them using columnar storage" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Creating database-level snapshots before each batch deletion" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Using write-ahead log (WAL) as the deletion record without any application changes" } ], "shape": "code" } ] } }, { "questionId": "data_modeling.soft_delete__69923", "topic": "data_modeling", "subSkill": "soft_delete", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the performance impact of soft deletes on a large table?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Soft deletes speed up queries by reducing the effective table size" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Soft deletes have no performance impact because filtered rows are never loaded" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Soft-deleted rows bloat the table and indexes, slowing queries even though they're filtered out" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Soft deletes only impact write performance, not read performance" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__51136", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does Drizzle ORM's new drizzle-kit check command detect in a migration history?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Missing foreign key constraints in the schema" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Non-commutative migrations that conflict across branches" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Tables exceeding a configured row count threshold" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Unused indexes that waste storage space" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__10218", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing expand-and-contract against a single-statement DDL cutover, what specific risk does the multi-phase variant retire?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The dependency on a coordinated cluster restart so every node observes the new catalog version at the same instant" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The need to write any backfill SQL or migrate historical rows into the newly added structures during the transition" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The requirement to keep older application binaries online while the newer release rolls out across the fleet of replicas" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Brief windows where deployed application instances run against a schema shape they were not coded against" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.migration_strategies__100232", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the purpose of a 'down' or 'rollback' script that accompanies a forward migration?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It generates anonymised seed rows so lower environments mirror production volume after the structural change lands" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It reverses the structural change so the database can return to the previous schema version if the deploy fails" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It records timing metrics for the forward step so the platform team can budget future maintenance windows" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It compresses old transaction logs once the forward migration has been verified in production for at least a week" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.migration_strategies__69860", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the safest way to drop a column in a production database?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Use ALTER TABLE DROP COLUMN IF EXISTS to prevent errors" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Rename the column first, then drop it after verifying no errors" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "First remove all application code references to the column, deploy, then drop the column in a subsequent migration" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Drop the column and update the application code in the same deployment" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__10199", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A team plans to add a " }, { "t": "code", "v": "payment_status" }, { "t": "text", "v": " column to a 50M-row Postgres orders table and start using it in the next release. Which rollout shape minimises lock time and lets the running app survive a half-completed deploy?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Open a maintenance window, drop the table, recreate it with the new column, then COPY existing rows back from a temporary dump file" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Run ALTER TABLE ADD COLUMN payment_status text NOT NULL inside one transaction so the change either fully lands or fully rolls back" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Add the column nullable, deploy code that tolerates absence, backfill in batches, then enforce NOT NULL via a CHECK NOT VALID + VALIDATE pair" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Deploy the code that reads the new column first and let it backfill values on each read until every row eventually has been touched" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.migration_strategies__69892", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a 'baseline' migration in Flyway?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It writes the whole current schema as one migration a fresh database runs" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "It re-runs the history against a fresh database to confirm they still match here" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "It marks the current state as the starting point, so history is not replayed" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "It records a checksum per applied migration so a later edit is caught here" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__69858", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is 'schema drift' and how do migration tools detect it?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A migration was edited after it ran, caught by the checksum on each file" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The history has diverged between branches, caught by comparing checksums here" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The live schema has diverged from the history, caught by replaying it fresh" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The schema differs between environments, caught by diffing two databases" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__200502", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A backfill UPDATE on a 50M-row MySQL table runs " }, { "t": "code", "v": "UPDATE invoices SET region = lookup(country)" }, { "t": "text", "v": " in one statement. Replication lag balloons past 600s and the migration is killed. Which adjustment best addresses the lag symptom?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Raise innodb_buffer_pool_size for the duration so the update can complete inside one statement" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Wrap the entire update in a single transaction with REPEATABLE READ so replicas apply it as one event" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Process the rows in bounded batches by primary key with short pauses between each chunk committed" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Disable binary logging for the session so the replicas skip applying the update statement entirely" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.migration_strategies__70209", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is Atlas in the context of database schema management?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A declarative schema migration tool that computes diffs between desired and actual database state" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A NoSQL database designed for geographically distributed workloads" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A PostgreSQL extension for multi-tenant row-level security" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A cloud-hosted database monitoring dashboard by HashiCorp" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.migration_strategies__100501", "topic": "data_modeling", "subSkill": "migration_strategies", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A teammate adds " }, { "t": "code", "v": "email VARCHAR(255) NOT NULL" }, { "t": "text", "v": " to a populated " }, { "t": "code", "v": "users" }, { "t": "text", "v": " table in one migration step against production. Deploy fails: " }, { "t": "code", "v": "ERROR: column \"email\" contains null values" }, { "t": "text", "v": ". What part of the rollout did they skip?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Add the column with a UNIQUE constraint first so the engine validates each existing row up front" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Add the column as nullable first, populate values for existing rows, then promote it to NOT NULL" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Add the column inside a transaction with SERIALIZABLE isolation so concurrent writers cannot insert" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Add the column with an explicit DEFAULT clause whose value is computed by a trigger at insert" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__30753", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does statistical anomaly detection improve over rule-based checks?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Learns the rules an engineer would have written and emits them as SQL for review and reuse" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Runs the same rules against a sample rather than the full table, so a check finishes far sooner" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Automatically adapts to patterns and detects deviations without manually defined thresholds" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Reports a confidence score per row instead of a verdict, so a reviewer can triage the output" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__51252", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is formal verification's role in critical quality scenarios?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It runs the transformation twice with different engines and compares the two outputs" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It proves the invariants of a transformation mathematically, which testing cannot" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It generates the test cases from the schema, which covers more than a person would" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It checks each row against a rule set, so nothing gets through without a look at it" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__51222", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is quarantine's purpose for failed records?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Records can't be corrected once isolated" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Quarantine slows all records" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Isolating bad records for review while valid records continue processing" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Quarantined records auto-delete after 30 days" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.data_quality__51248", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is SPC's theoretical foundation in data quality?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Hypothesis tests whose thresholds come from a fixed significance level" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Rules whose thresholds are set by the owner of each table in question" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Machine learning whose thresholds are retrained on each day of data" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Control charts whose limits come from the process statistics" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.data_quality__30744", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the difference between validation and cleansing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Validation identifies issues; cleansing corrects or removes them" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "Validation fixes; cleansing identifies" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Cleansing is always done before validation" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "They are the same process" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.data_quality__30740", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a data quality SLA?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A report of the quality issues found in the previous month, ranked by the tables they affected" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A schedule stating when each quality check runs and which team receives the alerts it produces" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A formal agreement specifying minimum quality levels like completeness and timeliness thresholds" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A contract with the cloud provider covering the storage layer's uptime and its durability target" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__1100301", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does a dbt 'source freshness' check work?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It pings the upstream system's heartbeat endpoint and aborts when the response time exceeds budget" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It samples row counts at a fixed interval and raises when the rolling delta drops to zero" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It diffs schema fingerprints between two consecutive runs and flags any column-level changes" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It compares the max value of a configured loaded-at column against warn-after and error-after thresholds" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__100482", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dashboard tile shows 0 rows for today's signups. The Airflow log says 'source orders.signups is 9 hours stale (threshold 1 hour)'. Which check produced that log?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "relationship test against the users dimension" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "row-count anomaly check on yesterday's batch" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "source freshness check with a warn_after threshold" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "accepted_values test against the signup_status column" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.data_quality__1100506", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does a Dagster 'freshness policy' on an asset declare?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "How many retries the run-coordinator schedules when the materialization step raises a worker error" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "How recent the asset's data must be relative to its upstream sources to be considered current" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "How long the cached IO manager output stays valid before the executor recomputes a new artifact" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "How many partitions of the asset must be materialized before the downstream sensor will fire next" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_quality__30743", "topic": "data_pipelines", "subSkill": "data_quality", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is pattern validation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Checking values match expected formats like email addresses conforming to regex" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Checking values appear with the same frequency they did in the run before this one" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Checking values fall inside the minimum and the maximum that the schema declares" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Checking values repeat on a predictable cycle so that a gap flags a missing load" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__200318", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the correct characterization of an identifying relationship between two tables?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The child stores the parent's key as a nullable foreign-key column with cascade-delete enabled by default" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The child shares a generated sequence with its parent so both rows always receive the same numeric value" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The child's primary key includes the parent's key, so the child cannot exist without that parent" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "The child references the parent through a many-to-many join table populated by a deferred constraint" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_design__69766", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the main drawback of the EAV (Entity-Attribute-Value) pattern?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Writes need a lock on the parent row, which is what limits the throughput" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Rows grow wide as attributes are added, which is what slows the scans down here" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Queries turn complex and slow, types go unchecked and constraints cannot apply" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The schema has to change for each new attribute, which blocks a deployment" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__69756", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a surrogate key?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A composite key made up of two or more columns" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A natural key derived from business data like email or SSN" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A system-generated artificial key (like an auto-increment ID) with no business meaning" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "A foreign key that references a parent table" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__70012", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a 'NOT NULL' constraint?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A column default filling in a value where the insert supplies none" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A column constraint refusing a null, so each row carries a value" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A column constraint refusing a duplicate, so each row differs there" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A check the application runs, which the database then trusts on write" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__69985", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is UUIDv7 and why is it better suited for database primary keys than UUIDv4?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It drops the random part altogether, so two writes in a row cannot collide here" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "It puts a timestamp in the trailing bits, so the keys stay random at the front" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "It shortens the value to sixteen characters, which is what keeps the index small here" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It puts a timestamp in the leading bits, so the keys sort and the index stays tidy" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_design__10193", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Two engineers debate where to begin a schema design for a new SaaS billing module. Which starting point most reliably anchors the rest of the model?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Enumerate the business invariants and the queries the system must answer" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Choose a normalization target form (3NF vs BCNF) before any entities are listed" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Pick a primary-key strategy (UUIDv7 vs bigserial) before any tables are sketched" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Decide on physical storage parameters such as fillfactor and TOAST thresholds first" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_design__200342", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "When weighing a narrow normalized table against a wide denormalized one for an order_lines read path, what is the realistic trade-off the wide design accepts?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Update anomalies and storage duplication in exchange for fewer joins" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Loss of NOT NULL enforcement that only narrow tables can keep" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Slower single-row reads because the planner avoids covering indexes" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Inability to enforce foreign keys on duplicated values across rows" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__69928", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'polymorphic embeddings' pattern in MongoDB?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Embedding references to documents from multiple collections within a single document" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Creating multiple indexes for different document types in the same collection" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Storing documents of different types in the same collection, using a type field to determine the document structure" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Using MongoDB's $graphLookup to traverse polymorphic relationships" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__10230", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Three microservices each write to the same " }, { "t": "code", "v": "accounts" }, { "t": "text", "v": " table. A new invariant - " }, { "t": "code", "v": "balance >= 0" }, { "t": "text", "v": " - is being added. Where should it live?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "As a CHECK constraint on the column, so every service is bound by the same rule" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Only in the account-service codebase, since it owns the write path for balance changes" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "As a partial unique index that excludes rows where balance < 0 from the index" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "As a BEFORE INSERT trigger that calls a stored procedure to verify the predicate" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_design__69990", "topic": "data_modeling", "subSkill": "schema_design", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'recursive CTE' approach for querying tree hierarchies stored as adjacency lists?" } ] } ], "code": { "lang": "ts", "code": "WITH RECURSIVE tree AS (\n SELECT id, name, parent_id, 0 AS depth\n FROM categories WHERE parent_id IS NULL\n UNION ALL\n SELECT c.id, c.name, c.parent_id, t.depth + 1\n FROM categories c JOIN tree t ON c.parent_id = t.id\n)\nSELECT * FROM tree;", "label": "schema-design.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A self join repeated once per level, with the depth fixed when it is written" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A recursive query starting at a leaf and joining parents until the root shows" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A recursive query starting at the root and joining children until none remain" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A stored procedure looping in the application until the queue of rows empties" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_as_code__89030", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does " }, { "t": "code", "v": "prisma db pull" }, { "t": "text", "v": " (introspection) do?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Reads the existing database structure and generates a matching schema.prisma file" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Pulls remote migration files from a shared repository" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Downloads the latest database backup to local storage" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Fetches sample data from the database for development seeding" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.schema_as_code__100519", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Atlas's " }, { "t": "code", "v": "migrate diff" }, { "t": "text", "v": " workflow?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Compares query plans before and after a deploy and rejects migrations that regress costed plan estimates" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Compares git branches and merges migration files so concurrent feature branches share the same numbering" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Compares the current migrations directory to a desired schema and writes the SQL needed to converge them" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Compares two production databases and rewrites rows that disagree using the primary as the canonical source" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__100517", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Drizzle's " }, { "t": "code", "v": "drizzle-kit generate" }, { "t": "text", "v": " command?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Diffs the TypeScript schema against the prior snapshot and writes a new SQL migration plus snapshot artefacts" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Compiles the TypeScript schema to a single bundled JavaScript file the application loads at boot time directly" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Connects to the running database and rewrites the TypeScript schema from the live information_schema view" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Streams insert statements from a fixture directory so freshly built environments end up with seed rows present" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__100505", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterises an idempotent migration?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "One whose forward step and reverse step compile to byte-identical SQL on every supported dialect" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "One that produces the same end state whether it is applied a first time or re-run after a partial failure" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "One that locks the target tables for exclusive access so no concurrent writer can race the deploy" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "One that wraps every statement in a savepoint so the runner can resume from the last committed row" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__9472618", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Two devs merge their PRs an hour apart. Both added a file timestamped 20240220_*. Production deploys cleanly but the later author's relation never appears in the catalog. What does this scenario suggest?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Identical timestamps caused the runner to skip the second after recording the first" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The runner sorted alphabetically so the later filename ran before the first one" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Both migrations declared the same table name and one of them silently became a no-op" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "The deploy script ran migrations in parallel so one transaction overwrote the other" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__100523", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes 'autogenerate' as Alembic uses the term?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Generates Python class stubs from the live information_schema so models stay in sync with operator hotfixes" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Compares the SQLAlchemy model metadata to the connected database and drafts a candidate revision file" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Records every DDL statement issued during a development session and replays them as a new revision file" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Watches the filesystem for model changes and rewrites the most recent revision file in place each time" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__100527", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterises a 'lint' rule like Atlas's " }, { "t": "code", "v": "destructive" }, { "t": "text", "v": " analyzer for migrations?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Static analysis that flags operations such as dropping columns or shrinking types so reviewers approve them deliberately" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A storage check that rejects migrations whose total size on disk would exceed the configured tablespace quota" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A locking analyser that aborts migrations whose worst-case row contention exceeds an operator-set wait threshold" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A planner hint that warns when an upcoming migration will likely cause the optimiser to recompile cached plans" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__100510", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes 'drift' in the context of schema-as-code workflows?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Slow growth of an index leading to bloated pages that vacuum can no longer reclaim quickly" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Lag between when a write commits on the primary and when it appears on the read replica nodes" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Gradual loss of statistics accuracy after bulk loads until the planner re-samples the table data" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Divergence between the live database structure and the structure described by the checked-in source" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__89031", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does Convex's schema definition differ from traditional ORM approaches?" } ] } ], "code": { "lang": "ts", "code": "import { defineSchema, defineTable } from 'convex/server';\nimport { v } from 'convex/values';\n\nexport default defineSchema({\n users: defineTable({\n name: v.string(),\n email: v.string(),\n role: v.union(v.literal('admin'), v.literal('member')),\n }).index('by_email', ['email']),\n});", "label": "schema-as-code.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Convex requires hand-written raw SQL files for schema definitions and applies them through its CLI" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Convex schemas define validators (runtime type checks) that also generate TypeScript types: no SQL, no migrations" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Convex schemas are authored through a hosted web GUI only and exported as static type files on save" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Convex stores JSON Schema documents alongside the database and parses them at every function call" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.schema_as_code__89036", "topic": "data_modeling", "subSkill": "schema_as_code", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'expand and contract' pattern for zero-downtime schema migrations?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Deploy code that writes to both old and new columns (expand), migrate data, then remove old column usage (contract)" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Add new tables first (expand), move data with triggers, delete old tables (contract)" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Scale up database replicas before migration, then scale down after completion" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Run migrations in a transaction that expands lock scope, then contracts it on commit" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__200001", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes how Parquet enables predicate pushdown for queries?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Readers scan the dictionary page header and discard files whose dictionaries lack a value" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A global secondary index per file maps every value to the row offsets that contain it" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Each row group ships with a bloom filter on the primary key for direct row lookup" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Min/max statistics per column chunk let readers skip chunks whose ranges cannot match" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__614728", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A warehouse team has been told Iceberg now supports row-level deletes more efficiently than the original positional/equality delete files. The 2024 spec revision changes how a single row update is recorded. What is the new on-disk representation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Deletion vectors stored as Puffin file blobs per data file" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Row-group-level merge markers embedded in Parquet footers" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Positional delete files written alongside each touched data file" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Equality delete files keyed on the table's primary key columns" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.data_formats__400002", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best characterizes Delta Lake's deletion vector feature?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Soft deletes are encoded as bitmap files referencing row positions in unchanged data files" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Soft deletes append undo records to the commit log that readers must replay during scans" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Soft deletes mark whole partitions as tombstoned and require a vacuum before any reader sees them" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Soft deletes rewrite each affected file in place so consumers always see canonical row sets" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__30718", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does format choice affect time travel in table formats?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Time travel comes from the object store's own versioning, so the table format records nothing beyond the current file list for the table" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Parquet's immutability provides stable data files; the table format (Iceberg/Delta) maintains snapshots and manifest lists that enable time travel" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The table format rewrites the affected Parquet files on each commit and keeps the superseded copies in a separate history directory" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Parquet footers store a version vector for each row group, so a reader reconstructs an earlier state by replaying the footer's own version history" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__213887", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A pandas notebook hands a 12 GB DataFrame to a DuckDB process running on the same host. With pickle the round trip takes 41 seconds and balloons RSS to 38 GB. The team wants the handoff to avoid copies. Which interchange format addresses the symptom?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A row-based binary format that tags each value with a type code and length prefix" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A self-describing text encoding that streams one cell per line into the consumer" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A schema-driven RPC envelope that wraps each column as a length-prefixed payload" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "An in-memory columnar format that allows both processes to share buffers without serializing" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__30707", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is write ordering's role in Parquet optimization?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Sorting before the write lets the dictionary be shared, which halves the encoded size" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Sorting before the write fixes the row group boundaries, so a reader can seek to one" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Sorting before the write groups like values, which helps both compression and pruning" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Sorting before the write shrinks the footer, which is what speeds up a small scan" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__300007", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Parquet's approach to handling nested fields like structs and arrays?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Each parent struct is serialized as a single binary blob per row group with no per-leaf split" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Each nested record is flattened into a JSON string and stored in one wide column per row" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Each array entry is encoded as a separate row identified by its parent's surrogate row key" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Each leaf is stored as a column with definition and repetition levels recording structure" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__30712", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is Z-ordering in lakehouse table layouts?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Data is clustered along several dimensions, so a filter on either skips files" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Data is sorted on one column, so a filter on that column can skip most of the files" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Data is split by time, so a filter on the timestamp reads a single partition alone" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Data is hashed by key into buckets, so a join on that key needs no shuffle whatever" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.data_formats__200431", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A data engineer is comparing the columnar warehouse file format with the columnar format originally built for the Hive/Hortonworks stack. Which difference is the most useful framing for selecting between them today?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Both are columnar; Hive-native one ships richer ACID hooks for that ecosystem" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "Both formats are row-oriented; neither supports column projection at read time" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "Warehouse file uses LSM-tree storage; Hive-native one uses simple flat blocks" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Hive-native one is row-based; the warehouse file is the only columnar option" } ], "shape": "code" } ] } }, { "questionId": "data_pipelines.data_formats__13483", "topic": "data_pipelines", "subSkill": "data_formats", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What problem does Apache Arrow solve beyond Parquet?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A standard on-disk columnar layout, so tools that share it skip a conversion step" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A standard table format, so several writers can commit to one table without a clash" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A standard in-memory columnar layout, so tools that share it skip serialisation" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A standard compression codec, so the same bytes can be read by each of the engines" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.temporal_data__69789", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is Slowly Changing Dimension Type 2 (SCD Type 2)?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It keeps history in extra columns, one per attribute that has changed" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "It keeps history by adding a row and marking the old one inactive" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "It keeps no history, since the value is overwritten where it changes" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "It keeps history in a side table, the main one holding current values" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.temporal_data__405631", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the 'allen interval relations' set used in temporal predicates?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It enumerates the eleven primitive index access methods Postgres exposes for range type queries" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It enumerates the thirteen possible relative arrangements two intervals can have on a linear axis" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It enumerates the seven inclusive-versus-exclusive bound combinations a half-open period may take" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It enumerates the four canonical SCD strategies plus their nine documented hybrid variants" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.temporal_data__210512", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does SQL Server print for the SELECT against this system-versioned table?" } ] } ], "code": { "lang": "ts", "code": "SELECT *\nFROM Employee\nFOR SYSTEM_TIME AS OF '2026-02-01T00:00:00'\nWHERE EmployeeID = 7;", "label": "temporal-data.ts" }, "widget": { "kind": "predict_output", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "only rows currently live in the base table at query time" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "the row version that was current on 2026-02-01 in the history" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "rows where ValidFrom equals the supplied timestamp exactly" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "all base + history rows unioned with no temporal filtering" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.temporal_data__51220", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A team enforces non-overlapping validity periods with a Postgres EXCLUDE constraint and prefers it over a BEFORE INSERT trigger that re-queries the same table. What concurrency property is the EXCLUDE constraint giving them that the trigger cannot?" } ] } ], "code": { "lang": "ts", "code": "ALTER TABLE price_history\n ADD CONSTRAINT no_overlap\n EXCLUDE USING gist (\n product_id WITH =,\n period WITH &&\n );", "label": "temporal-data.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Automatic merging of two adjacent rows whose intervals share an endpoint into a single coalesced row" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Cross-database replication of the constraint to every logical subscriber without further configuration" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Atomic enforcement against concurrent inserts under MVCC, since the GiST exclusion is checked as part of the row write itself" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A guaranteed lower latency on the insert path because GiST index lookups skip the buffer cache layer" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.temporal_data__69795", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is SCD Type 3?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Adding a column for the previous value alongside the current value, preserving limited history" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Overwriting the value in place with no history" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Creating a new row for each change with start/end dates" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Storing all historical versions in a separate table" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.temporal_data__70030", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the difference between 'current value table' and 'history table' in temporal modeling?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The current value table holds only the latest version of each entity; the history table holds all previous versions with time ranges" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Both tables have identical schemas and data, differing only in access permissions" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The current value table is in memory; the history table is on disk" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "The current value table stores future changes; the history table stores past changes" } ], "shape": "code" } ] } }, { "questionId": "data_modeling.temporal_data__69969", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does PostgreSQL handle temporal queries without native system-versioned temporal tables?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The write-ahead log is read back, from which the old version is rebuilt here" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "An extension adds the temporal syntax, which rewrites the query for you" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Triggers copy the old version into a history table, queried by time range" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A system column records the write time: the query then filters on that" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.temporal_data__200121", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Modelling temporal periods inside the row vs in a child versions table linked by FK - which failure mode does the child-table layout dodge?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Wide rows triggering automatic table rewrites whenever the autovacuum process runs on the table" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Wide rows being unable to participate in foreign-key relationships from any other table at all" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Wide rows growing on every change because the parent must hold every period column" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Wide rows forcing the engine to upgrade every UPDATE to a serializable isolation level transaction" } ], "shape": "long" } ] } }, { "questionId": "data_modeling.temporal_data__70255", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What PostgreSQL data type represents a range of timestamps with time zone?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "timestamp_range" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "interval" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "tstzrange" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "daterange" } ], "shape": "short" } ] } }, { "questionId": "data_modeling.temporal_data__51162", "topic": "data_modeling", "subSkill": "temporal_data", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "On a PostgreSQL table that uses (valid_from, valid_to) columns of type tstzrange, which native construct most directly answers 'pick the row whose period contains :asof'?" } ] } ], "code": { "lang": "ts", "code": "SELECT *\n FROM price_history\n WHERE product_id = :id\n AND period @> '2026-04-01'::timestamptz;", "label": "temporal-data.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The range containment operator @> applied to the tstzrange column and the :asof timestamp" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "A BETWEEN predicate that compares :asof against the lower and upper bound scalar columns" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "An INTERVAL subtraction between :asof and a stored timestamptz to test sign of the result" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A pair of OVERLAPS predicates joining the row to a single-instant range built in the query" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__53764", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Why can tracking every noisy attribute with Type 2 be a modeling mistake?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Noisy attributes should always be moved into fact tables, because facts handle frequent updates better than dimensions do." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Any attribute that changes more than once per day must be modeled as Type 1, since Type 2 is defined only for infrequent dimension changes." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Frequent low-value changes can explode row counts and complicate joins without delivering meaningful analytical benefit, so only business-relevant history should version." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Type 2 changes are free in modern warehouses, so the only reason to avoid them is that BI tools do not support slowly changing dimensions." } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__200345", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing SCD Type 2 with valid_from/valid_to columns versus an is_current boolean flag, what is the practical difference?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "valid_from/valid_to enable filtering to the newest record only, while is_current alone supports any historical lookup" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "valid_from/valid_to enable point-in-time joins on any historical date, while is_current alone only supports filtering to the latest row" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "valid_from/valid_to enable hashed change detection, while is_current alone supports per-row attribute overwrites" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "valid_from/valid_to enable mini-dimension joins on demand, while is_current alone supports surrogate key reuse" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__875397", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dbt project has dim_account snapshotted with check strategy on 22 columns. Build times have crept from 2 minutes to 38 minutes over a year, and warehouse credits for the snapshot model dominate the daily run. The source has a reliable last_modified_at column. Inspecting plans, the bottleneck is the row-level hash compare across 12M rows. What is the highest-leverage refactor?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Drop snapshot and rebuild as an incremental model with merge strategy on dbt_scd_id" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Materialize the source as a view and rerun the check strategy against that wrapper view" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Switch to timestamp strategy and gate diff evaluation on last_modified_at advancing" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Partition the snapshot target by valid_from and re-run with a where filter per partition" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__53763", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "When is Type 3 a better fit than Type 2?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "When the business only ever needs a bounded amount of prior state (typically the previous value of a single attribute) and a full version-per-change history would impose row-count and join-complexity costs for analyses nobody runs." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "When the attribute changes very frequently, because adding more side-by-side prior-value columns to a single row is generally cheaper than inserting many fresh row versions during heavy-write windows on the dimension." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "When complete audit history is a regulatory requirement, because storing multiple prior values as additional columns inside one row scales gracefully for an unbounded number of change events." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "When fact tables must join on effective date ranges, because column-based prior-value storage represents time intervals more naturally than versioned row storage with valid-from / valid-to." } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__53552", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dimension table implemented with SCD Type 2 has grown to 500 million rows over 10 years. Query performance on the latest version of each entity has degraded. Which approach best addresses this without losing any prior version?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Add more clustering keys to the SCD Type 2 table to speed up scans" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Switch to SCD Type 1: overwrite old records to reduce table size" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Implement SCD Type 4: split into a current table (small, fast) and a history table (large, queried less often)" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Archive records older than 5 years to a separate database and delete them from the warehouse" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__104782", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "After enabling versioning on dim_product, a stakeholder reports that the 'current product catalog' dashboard now shows multiple rows per SKU. The query selects from dim_product and groups by sku. The dim has valid_from, valid_to, and is_current populated correctly. What is the simplest correct fix?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Join the dim to itself on sku and drop rows where valid_to is non-null entirely" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Add a window function picking the row with max valid_from per sku partition" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Add a predicate filtering to is_current = true to restrict to the active version per SKU" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Switch the dimension back to overwrite-style so only one row exists per SKU" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.slowly_changing__400562", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing SCD Type 2 implemented in a dbt snapshot versus a Snowflake stream + task pipeline for the same source, what is the key operational distinction?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Snapshots run within a transaction shared with downstream models for consistency, while streams skip transactions and emit raw change rows directly to the BI layer" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Snapshots run once and never re-detect changes after the initial load, while streams maintain a persistent change feed only when CDC is disabled in the source" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Snapshots run on dbt invocation cadence and re-read the source each run, while streams capture row-level changes continuously and tasks consume them on a schedule" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Snapshots run continuously by polling the source per second and writing versions, while streams batch changes nightly and tasks fan out the updates as bulk merges" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__400565", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing SCD Type 6 with SCD Type 2 plus a Type 1 'current_value' attribute denormalized on the fact, what is the practical equivalence and difference?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Type 6 colocates the current value on every dimension version, while denormalizing onto the fact requires updating every fact row when the attribute changes" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Type 6 splits volatile values into a separate history table, while denormalizing onto the fact keeps every prior value embedded as a JSON array per row" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Type 6 captures changes only on demand at query time, while denormalizing onto the fact prevents any change tracking unless an external CDC stream feeds it" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Type 6 freezes the dimension and forbids attribute updates, while denormalizing onto the fact requires running a snapshot job per change to keep facts in sync" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.slowly_changing__639175", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A teammate upgrades a dbt project to a recent version and notices that snapshots now write a small set of meta columns by default whose names start with dbt_ that mark when each version of a row was first and last seen. Per the current snapshots reference on docs.getdbt.com, which pair of column names should they expect to find on the snapshot table?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "dbt_effective_at and dbt_expired_at" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "dbt_inserted_at and dbt_deleted_at" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "dbt_loaded_from and dbt_loaded_to" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "dbt_valid_from and dbt_valid_to" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.slowly_changing__300454", "topic": "data_warehousing", "subSkill": "slowly_changing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Choosing SCD Type 2 versus SCD Type 4 when a dimension is queried mostly for current state, what should drive the decision?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Type 4 prevents updates to the natural key, keeping the dimension immutable so current-state queries stay deterministic" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Type 4 isolates current rows from history, keeping the main dimension small and current-state queries fast" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Type 4 hashes the attribute set per row, keeping current-state queries fast by skipping unchanged-attribute rewrites" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Type 4 inlines historical versions onto the same row, keeping current-state queries fast through column pruning" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.batch_processing__2018433", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the historical MapReduce framework's contribution to batch processing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Programming model splitting jobs into two functional stages run over distributed file system shards" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "RPC framework that wired microservices together using a shared schema registry over the wire" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Container scheduler that placed long-running services across a cluster using bin-packing heuristics" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Continuous query engine that emitted incremental updates whenever a source row changed in place" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.batch_processing__51295", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does bucketing optimize joins?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Replicating every bucket to all executors lets the join finish without a shuffle" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Pre-partitioning by join key during write eliminates shuffle during join" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Indexing the join key inside each file lets the reader skip unmatched rows" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Sorting each file by the join key at read time removes the comparison work" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.batch_processing__200343", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Polars and DuckDB are both proposed for medium-data analytics in place of distributed Spark - what's the key positioning difference between them?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Polars stores data only in Arrow IPC, while DuckDB refuses to read Arrow buffers natively at all" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Polars is a distributed cluster runtime, while DuckDB stays a single-thread interactive shell tool" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Polars is a DataFrame library with a lazy expression API; DuckDB is an embedded SQL query engine" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Polars is an embedded SQL query engine; DuckDB is a DataFrame library with a lazy expression API" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.batch_processing__51284", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a data catalog's role in batch workflows?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A searchable inventory of the datasets, their schemas, locations and owners" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A queue of the jobs waiting to run, from which a worker takes its next one" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "A record of each run a pipeline made, kept so a failure can be traced back later" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A store of the statistics each table carries, which the planner reads per query" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.batch_processing__51282", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Why is sort-merge join often preferred for large-to-large joins?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Broadcasts the smaller side to every executor, then hashes rows locally" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Loads both sides fully into the executor heap before joining them" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Hashes both sides into RAM first, which skips any ordering step" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Handles datasets larger than memory by sorting and merging from disk" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.batch_processing__2018435", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes idempotency for a scheduled batch task?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The task aborts itself the moment another worker on the cluster claims the same scheduling slot" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Each run appends a fresh row per source record so downstream consumers see a monotonic counter" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Repeating the run for the same logical date yields the same destination state as one clean run" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Two concurrent runs of the same task never block one another and both commit results to disk" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.batch_processing__51312", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is Z-ordering's purpose in batch optimization?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Assigning each file a sequence number so the reader processes them in write order" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Compressing correlated columns together so the codec finds longer repeating runs" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Sorting rows by a single leading column so range scans on that column prune files" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Multi-dimensional clustering so filters on any dimension skip irrelevant files" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.batch_processing__68204", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does vectorized execution improve performance?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Processes columns on the GPU, which is where the engine gets its batching and parallel speedup" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Processes columns in batches enabling SIMD, reducing interpretation overhead, improving cache utilization" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Processes the whole column set in one pass, so the engine reads each data file exactly once per query" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Processes a single row at a time through a compiled loop, which keeps that entire row inside the CPU cache" } ], "shape": "long" } ] } }, { "questionId": "data_pipelines.batch_processing__7102843", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does this PySpark broadcast-join snippet print as the count of joined rows?" } ] } ], "code": { "lang": "ts", "code": "from pyspark.sql import SparkSession, functions as F\nspark = SparkSession.builder.getOrCreate()\norders = spark.createDataFrame([(1,'US'),(2,'FR'),(3,'US'),(4,'JP')], ['id','country_code'])\ndims = spark.createDataFrame([('US','United States'),('FR','France')], ['country_code','name'])\nj = orders.join(F.broadcast(dims), 'country_code')\nprint(j.count())", "label": "batch-processing.ts" }, "widget": { "kind": "predict_output", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "3" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "2" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "0" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "4" } ], "shape": "short" } ] } }, { "questionId": "data_pipelines.batch_processing__300457", "topic": "data_pipelines", "subSkill": "batch_processing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does Spark's " }, { "t": "code", "v": "cache()" }, { "t": "text", "v": " differ in default storage level from " }, { "t": "code", "v": "persist(StorageLevel.MEMORY_AND_DISK_SER)" }, { "t": "text", "v": " for a large RDD that risks not fitting in memory?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Cache uses MEMORY_ONLY by default and may recompute partitions that evict from memory" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Cache always serialises to off-heap memory and replicates each partition to two cluster nodes" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Cache uses MEMORY_AND_DISK_SER by default and persists evicted partitions to local executor disk" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Cache forces partitions onto HDFS for durability and refuses to keep any block in JVM heap pages" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__200149", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Snowflake's multi-cluster warehouse scaling policy?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It resizes the existing warehouse to a larger tier when concurrent queries queue" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "It rejects extra concurrent queries above the configured maximum cluster count" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "It reroutes queued queries to a sibling warehouse owned by the same role grant" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "It adds clusters when concurrent queries queue and removes them as load drops" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.modern_warehouse__53604", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Your BigQuery on-demand costs are growing unpredictably. Several teams run ad-hoc queries scanning terabytes of unclustered tables. What combination of strategies would you implement to control costs?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Create materialized views for every table and disable direct table access" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Restrict BigQuery access to a single service account and review all queries manually" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Switch entirely to slot-based pricing and remove all on-demand access" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Partition and cluster high-scan tables, set per-user and per-project custom quota limits on bytes billed, and move predictable workloads to slot reservations while keeping exploratory queries on on-demand" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__53580", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does Snowflake's VARIANT data type allow you to store?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Multiple data types in a single column that change row by row" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Semi-structured data such as JSON, Avro, or Parquet objects: Snowflake automatically optimizes storage and allows querying nested fields without a predefined schema" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Only JSON data; Avro and Parquet require external tables" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "Binary large objects like images and PDFs" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.modern_warehouse__2058393", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A nightly dbt run accidentally truncated a Snowflake fact table 90 minutes ago. The warning Slack message reads 'rows: 0 (was 412M)'. Storage retention is set to the default for a permanent table. The team needs the rows back without restoring from backup. What recovery feature should they reach for?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Snowflake Time Travel lets them query or restore the table state from before the truncation within the retention window." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Snowflake Fail-safe lets them issue a self-service rewind command to bring the truncated rows back into the same table." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Snowflake Streams replay can re-emit the deleted rows from the change-tracking metadata still attached to the table." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Snowflake Result Cache rehydrates the lost rows because the prior SELECT result is held alongside the table's data." } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__2308751", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does INFORMATION_SCHEMA.QUERY_HISTORY report for the BYTES_SCANNED column on the second SELECT?" } ] } ], "code": { "lang": "sql", "code": "-- Snowflake\nSELECT MAX(amount) FROM payments;\nSELECT MAX(amount) FROM payments;\nSELECT bytes_scanned, query_text\nFROM TABLE(INFORMATION_SCHEMA.QUERY_HISTORY())\nORDER BY start_time DESC LIMIT 2;", "label": "modern-warehouse.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "NULL value because BYTES_SCANNED only logs CTAS and COPY operations" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Same byte count as the first run because cache was bypassed by force" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Zero bytes scanned because the rerun was served from cached result metadata" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Reduced scan from local cluster SSD warming on the running warehouse" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.modern_warehouse__53594", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a Snowflake external table and when would you use one instead of loading data?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "An external table stores data in Snowflake but makes it accessible to external tools via API" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "An external table is a table shared from another Snowflake account via Secure Data Sharing" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "An external table references files in cloud storage (S3/GCS/Azure) without ingesting them into Snowflake. Use it when data must remain in the lake, for cost savings on infrequently queried data, or for data sharing with non-Snowflake tools." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "An external table is a temporary table created by COPY INTO during data loading" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.modern_warehouse__301212", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes Snowflake's Time Travel feature on a permanent table at default retention?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Lets queries read the table state from up to one day in the past via AT or BEFORE clauses" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Lets queries replay each DML statement against the table from up to one week in the past" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Lets queries read every prior table state going back to the table's original creation moment" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Lets the database administrator rewind the entire account back to a previous billing cycle" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__1828573", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A developer creates a Databricks SQL Serverless warehouse with auto-stop = 10 minutes and expects DBU charges to drop to zero between queries. The bill shows continuous DBUs even during quiet hours. What is the documented behavior?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Serverless SQL warehouses charge for the underlying photon kernel as long as a session token is active, which only expires after explicit DISCONNECT calls." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Serverless SQL warehouses run a heartbeat probe on the metastore every 30 seconds, and that probe is invoiced as compute even after auto-stop has fired." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Idle warehouses keep accruing DBUs until they actually stop, and any activity such as BI dashboard polling or scheduled refreshes resets the 10-minute idle timer, so the warehouse may never reach auto-stop" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Serverless SQL warehouses bill at a 5-minute minimum per started cluster, so any 10-minute idle window will round up to two billed minimums regardless of true activity." } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__53587", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What are Snowflake stages used for?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Temporary tables used during ETL transformations within Snowflake" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Named locations (internal or external cloud storage) where data files are staged before being loaded into Snowflake tables using COPY INTO" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Intermediate compute nodes that process queries before returning results" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Logical environments for separating development, staging, and production databases" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.modern_warehouse__53599", "topic": "data_warehousing", "subSkill": "modern_warehouse", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A team runs the same expensive dashboard query hundreds of times per day. The underlying data refreshes every 4 hours. What Snowflake optimization should they leverage first?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Clone the table every 4 hours and point the dashboard at the clone" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Create a materialized view and schedule it to refresh every 4 hours" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The result cache: identical queries hitting unchanged data are served instantly from the Cloud Services layer without consuming any compute credits" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Increase the virtual warehouse size to XL so each execution runs faster" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__87051", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Why is cache invalidation considered one of the hardest problems in computer science?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Modern CPUs cannot efficiently detect stale cache entries" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Cache invalidation requires advanced cryptography" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "There is no programming language support for cache invalidation" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Knowing exactly when cached data becomes stale and keeping all copies consistent across a distributed system" } ], "shape": "long" } ] } }, { "questionId": "caching.cache_invalidation__87244", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Database triggers publish invalidations through a partitioned message bus. Out-of-order delivery is letting an earlier update arrive after a later one and clobber the fresh value. What writer-side discipline closes this hole?" } ] } ], "code": { "lang": "ts", "code": "async function handleInvalidation(key, newValue, version) {\n const cached = await redis.hgetall(key);\n if (!cached.version || Number(version) > Number(cached.version)) {\n await redis.hmset(key, { value: newValue, version });\n }\n}", "label": "cache-invalidation.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Stamp each event with a monotonic source-of-truth sequence and apply only when the incoming sequence exceeds the one already resident" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Hash the message payload and silently drop any event whose hash matches one seen within a rolling deduplication window" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Acquire a per-key advisory lock on the cache that serializes every incoming invalidation for that key end to end" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Move publication onto a single strict-FIFO queue so cross-partition reordering can no longer interleave events for the same key" } ], "shape": "long" } ] } }, { "questionId": "caching.cache_invalidation__87049", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is cache invalidation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Encrypting cached data to prevent unauthorized access" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Adding new entries to an empty cache" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The process of removing or updating stale data from a cache when the source data changes" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Validating that cached data matches a specific schema" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__310511", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What integer does the final DBSIZE return?" } ] } ], "code": { "lang": "ts", "code": "SET a 1\nSET b 2\nFLUSHDB ASYNC\nSET c 3\nDBSIZE", "label": "cache-invalidation.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "1" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "0" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "2" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "3" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__217593", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A read-heavy endpoint suffers a stampede every time the cache entry expires. Current cache-pattern guidance suggests probabilistic early expiration (XFetch). What does the technique do to the freshness boundary?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Holds a distributed lock so a single client recomputes after TTL has elapsed" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Recomputes the value before TTL with a probability rising as expiry approaches" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Serves the stale value forever once the first miss converts into a refresh attempt" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Doubles the TTL on every miss until the key reaches a hard ceiling threshold" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__87050", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is TTL-based cache invalidation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Using version numbers to mark cache entries as stale" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Invalidating all caches on every write operation" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Setting an expiration time on cache entries so they are automatically removed after a period" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Manually deleting cache entries when notified of changes" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__87237", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Your e-commerce app caches product pages. When a product price changes, you need to invalidate: the product page, category listings, search results, and the homepage featured section. What is this challenge called?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Write amplification" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Cache coherence protocol" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Distributed consensus" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Fan-out invalidation" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__465932", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A cache-aside service does GET; on miss, READ db; SET cache. A concurrent writer does UPDATE db; DEL cache. Under interleaving, a stale value can be re-cached. Current guidance for closing this race recommends which mitigation?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Pin cache writes behind an EXPIRE NX so SET only takes effect on cold misses" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Increase the cache TTL so any re-cached stale value ages out within tolerance" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Delay-double-delete: invalidate on write, then invalidate again after a small delay" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Switch reads to write-through so each read first persists into the source first" } ], "shape": "short" } ] } }, { "questionId": "caching.cache_invalidation__210505", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What integer does the last command return?" } ] } ], "widget": { "kind": "fill_gap", "code": { "lang": "ts", "code": "SET a 1\nSET b __GAP_g1__\nDEL a b c" }, "gaps": [ { "id": "g1", "choices": [ { "id": "c1", "label": "1" }, { "id": "c2", "label": "3" }, { "id": "c3", "label": "0" }, { "id": "c4", "label": "2" } ] } ] } }, { "questionId": "caching.cache_invalidation__87058", "topic": "caching", "subSkill": "cache_invalidation", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is a cache invalidation race condition?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "When a stale value is written to the cache after the invalidation" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "When TTL expiration and manual invalidation happen at the exact same time" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "When two cache nodes try to invalidate the same key simultaneously" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "When the cache fills up faster than entries can be evicted" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.integration_testing__537", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How do you handle external API dependencies in integration tests without making real network calls?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Turn off the network on the test machine so that the calls fail fast and get skipped" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Point every outbound call at a logging stub that records but never returns" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Run a local mock HTTP server that intercepts the calls and returns canned responses" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Restrict the suite to the features that never touch an external service" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.integration_testing__137829", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does Dodds relate integration tests to red-green-refactor discipline?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Writing the failing scenario first anchors a user-observable behavior, then implementation emerges to satisfy it" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Writing the failing scenario first opens a long-lived browser session so interactions persist across each step" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Writing the failing scenario first locks in serialized output so every subsequent change triggers a diff review" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Writing the failing scenario first forces a shallow render path so child components never mount during the cycle" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__348572", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "In the classical test double taxonomy, what is a dummy?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "An object that records every interaction so the suite can assert on argument lists after the scenario ends" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "An object passed only to satisfy a parameter slot, never actually consulted during the scenario's execution" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "An object whose canned responses drive a specific downstream code path under the module being exercised" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "An object that mimics the real collaborator with simplified internals so logic runs against lightweight state" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__704512", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How is supertest commonly employed inside an integration suite?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It launches a headless Chromium instance so user gestures fire against the production build artifact" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It drives the HTTP layer of an Express-style app in-process so route handlers respond without a live port" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It patches the fetch global inside the worker pool so that outbound requests return a cached response payload" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It intercepts calls to process.env so configuration changes propagate to every imported module at once" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__682017", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What property does mutation testing check alongside a serious integration suite?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Whether small alterations to production source still yield passing tests, signaling gaps in assertion strength" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Whether repeated runs of the same scenario produce identical ordering of log output across two separate attempts" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Whether the network tracer captures every outbound call made during the scenario's recorded interaction log" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Whether the coverage report hits a fixed branch ratio before the build artifact is promoted to staging" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__10186", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Why does deterministic seed data matter for integration tests?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It anchors assertions to a known starting state so test outcomes are reproducible across runs" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It lets the test framework reuse one connection across parallel workers without serialization" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It eliminates the need for the application schema to declare any explicit nullability constraints" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It allows the database to skip statistics collection and execute queries from cached plans alone" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__10188", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does 'testing the contract' mean in an integration context?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Verifying services exchange agreed request/response formats and shapes" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Ensuring all required environment variables are defined and populated" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Signing a legal agreement between the development team leads and managers" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Checking that the full codebase compiles without any errors or warnings" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.integration_testing__10187", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the 'Test Container' pattern in integration testing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A method for running all tests inside managed Kubernetes pods" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "A container component that wraps test UI elements during render" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Ephemeral Docker containers giving each run a clean instance" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A design pattern for grouping tests into separate test modules" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.integration_testing__523", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does an integration test differ from a unit test?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Integration tests exercise several modules together, while unit tests exercise one alone" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Unit tests exercise several modules together, while integration tests exercise one alone" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Integration tests replace every collaborator with a stub, while unit tests use real ones" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Integration tests and unit tests both exercise one module, but under different runners" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.integration_testing__635271", "topic": "testing_strategies", "subSkill": "integration_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dev's Vitest integration test uses " }, { "t": "code", "v": "vi.useFakeTimers()" }, { "t": "text", "v": " around a component that debounces a search input. " }, { "t": "code", "v": "userEvent.type" }, { "t": "text", "v": " hangs and the test times out. Why?" } ] } ], "code": { "lang": "ts", "code": "vi.useFakeTimers();\nconst user = userEvent.setup();\nawait user.type(input, 'hello');", "label": "integration-testing.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Vitest's fake timers need " }, { "t": "code", "v": "{ toFake: ['queueMicrotask'] }" }, { "t": "text", "v": " because Testing Library schedules its wait-for polling on the microtask loop under the hood" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Fake timers only stub " }, { "t": "code", "v": "setTimeout" }, { "t": "text", "v": ", not " }, { "t": "code", "v": "setInterval" }, { "t": "text", "v": ", and the debounce uses an interval-backed scheduler internally that still waits for wall clock" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "code", "v": "userEvent" }, { "t": "text", "v": " runs on the real clock; configure it with " }, { "t": "code", "v": "{ advanceTimers: vi.advanceTimersByTime }" }, { "t": "text", "v": " so its awaited delays advance the fake clock" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "code", "v": "userEvent.type" }, { "t": "text", "v": " batches keystrokes on a microtask queue that fake timers do not drain; call " }, { "t": "code", "v": "vi.runAllMicrotasks" }, { "t": "text", "v": " between each simulated keystroke" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.mutation_testing__100001", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is the fundamental premise of mutation testing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Randomize input values across a large property-generated space" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Compare recorded output snapshots against a stored baseline file" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Plant tiny code edits and verify the suite catches each one" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Measure which source lines were executed during a single test run" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__300027", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does a no-coverage outcome mean for a mutant in a mutation run?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "No test ran because the project's runner crashed on the framework load step" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "No test asserted on the mutated value, although the line was reached by tests" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "No test failed because the runner skipped the mutant for time-budget reasons" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "No test reached the mutated line, so no assertion ever covered it" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__635", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Why is mutation testing computationally expensive?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Each mutant compiles against a freshly made sandbox image to keep its workspace isolated" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Each mutant queues behind the slowest spec because workers cannot run in parallel" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Each mutant re-runs the affected tests, so cost scales with mutants times covering tests" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Each mutant runs through a static analyzer before the suite executes against it" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__713024", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Stryker applies the ArithmeticOperator mutator to the function body. What does the mutated function return when called with (4, 2)?" } ] } ], "code": { "lang": "ts", "code": "function add(a, b) {\n return a + b; // mutated: a - b\n}\nconsole.log(add(4, 2));", "label": "mutation-testing.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "8" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "6" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "2" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "0" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__1902736", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dev runs a mutation pass with " }, { "t": "code", "v": "coverageAnalysis: 'perTest'" }, { "t": "text", "v": " against a suite using " }, { "t": "code", "v": "jest.useFakeTimers()" }, { "t": "text", "v": ". Mutants survive that should have been killed by timer-dependent assertions. What is the root cause?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Fake timers change the observed execution graph so coverage data collected on originals does not match the mutant's real dependencies" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Fake timers disable per-test coverage instrumentation in Jest, so the instrumentation emits empty coverage for those tests" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Fake timers stub out Date.now at the runtime layer, which makes each worker's own internal timeout heuristics misclassify every mutant" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Fake timers are incompatible with worker parallelism, causing one worker to poison the clock for all other worker processes" } ], "shape": "long" } ] } }, { "questionId": "testing_strategies.mutation_testing__809", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is 'higher-order mutation testing'?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Apply two or more mutations to the test suite in sequence to model order-dependent bugs" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Apply two or more mutations across siblings in the call graph to model upstream faults" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Apply two or more mutations to higher-order functions to model callback-driven faults" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Apply two or more mutations to the same source variant to model compound faults" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__400031", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does the incremental-run feature in modern mutation tools reuse?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Reuse a prior coverage matrix so only the slowest tests re-run against each mutant" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Reuse a prior worker pool so only the warm processes pick up the next mutant batch" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Reuse a prior report so only changed files and their covering tests re-run" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Reuse a prior assertion log so only the assertions that previously failed re-run" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__104825", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dashboard reports the run completed with a score of 62% after the tool changed operators and boundary checks in the source tree. Which headline metric is this dashboard most likely showing?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Percentage of branches traversed by integration tests at least once" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Percentage of assertions with matchers that compare exact numeric values" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Percentage of production lines executed during the unit test run" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Percentage of injected faults detected by the existing test suite" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__418263", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A PR adds mutation testing to the whole monorepo. CI time jumps from 6 minutes to 48 minutes and the team starts merging without waiting. What is the right next move?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Enforce a policy that CI must always block merges regardless of wall-clock duration" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Run the full mutation suite twice per PR so flaky survivors do not skew the score" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Replace the unit test layer entirely with mutation runs to reclaim pipeline minutes" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Scope the run to critical packages and only changed files on PR builds" } ], "shape": "short" } ] } }, { "questionId": "testing_strategies.mutation_testing__1678294", "topic": "testing_strategies", "subSkill": "mutation_testing", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How does mutation testing differ from statement coverage at finding missing assertions?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It measures how frequently a test file is edited relative to the source module it guards" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It fails the build when a mutant survives, exposing tests that execute without checking" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It tracks time spent inside each assertion and reports any that fall under the threshold" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It marks every executed line green if any test file imported the module correctly" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__52158", "topic": "analytics", "subSkill": "dashboards", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is Databricks AI/BI Genie, which reached general availability in 2025?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A code generation tool that writes Spark jobs from natural-language pipeline descriptions" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A data cataloging service that automatically tags and classifies datasets using ML" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A natural-language interface that lets business users ask data questions conversationally and get instant visualized insights from their lakehouse" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A real-time alerting system that monitors data quality metrics across Delta tables" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__100234", "topic": "analytics", "subSkill": "dashboards", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Stakeholders complain a Mode dashboard 'lies' - a flat-looking chart actually represents a 0.4% change. The Y-axis starts at 98% and ends at 100%. What is the integrity issue?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Series uses log scale by default, compressing the visible variance below 1%" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Metric uses moving average smoothing, hiding the day-over-day variance entirely" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Colorblind palette inverted, misleading viewers about positive vs negative trend" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Y-axis is truncated, exaggerating small variation as visually dramatic movement" } ], "shape": "short" } ] } }, { "questionId": "analytics.dashboards__301638", "topic": "analytics", "subSkill": "dashboards", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the typical purpose of a dashboard 'as-of' date selector?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "It freezes the dashboard so it ignores all subsequent ingest events from the warehouse until the analyst clicks 'reset to live'" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "It scopes every tile to a chosen point in time so historical states can be reconstructed without re-authoring the underlying queries" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "It triggers a one-time export of the chosen date partition into a downloadable CSV without changing what is rendered on screen" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "It selects the warehouse compute warehouse used for the queries so older dates run on a colder, cheaper compute resource pool" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__50661", "topic": "analytics", "subSkill": "dashboards", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Natural-language query interfaces have spread across BI tools by 2026. What capability shift do they fundamentally enable for a non-technical dashboard user?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Guaranteeing the returned answer is correct because the model validates every metric definition" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Bypassing the semantic layer so each question runs against raw event tables for speed" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Editing the warehouse schema directly from the dashboard to add new event properties" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Asking a data question in plain language and getting a chart without writing SQL or filing a ticket" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__100481", "topic": "analytics", "subSkill": "dashboards", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes the role of a semantic layer in a BI dashboarding stack?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Caching tier that snapshots the latest dashboard render so refreshes serve from memory not the warehouse" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Connection pooler that shares warehouse JDBC sessions among concurrent dashboard viewers to limit cost" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Centralized metric definitions reused by multiple dashboards and tools so the same KPI returns the same value everywhere" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Visual styling layer that controls dashboard color palettes, fonts, and chart types across an organization" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__402714", "topic": "analytics", "subSkill": "dashboards", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which statement best describes a DAU/MAU ratio tile placed on a North Star dashboard?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A stickiness proxy showing the share of monthly active users who returned today, sensitive to definition choices for active" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A funnel conversion rate from the signup step to the activation step, computed across the trailing thirty-day rolling window" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A revenue-per-user figure derived by dividing daily gross revenue by the count of monthly active subscribers in the period" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A churn rate that captures the percentage of paying users who cancelled their subscription during the previous calendar month" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__13694058", "topic": "analytics", "subSkill": "dashboards", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "An analyst creates a Mode dashboard with a 'last_30_days' filter that uses CURRENT_DATE in a Jinja-templated SQL block. The dashboard is scheduled to email at 06:00 UTC, but recipients in PST see numbers that exclude the most recent partial day. Why?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "CURRENT_DATE evaluates in the dashboard owner's profile timezone at render, so the window boundary lags by the offset delta" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "CURRENT_DATE evaluates in the warehouse session timezone at render, so the window boundary lands earlier than the local viewer expects" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "CURRENT_DATE evaluates in the recipient's locale at render, so each viewer sees a different last-day cutoff in the email" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "CURRENT_DATE evaluates at the time the SQL is parsed, so the window freezes when the dashboard is first authored" } ], "shape": "long" } ] } }, { "questionId": "analytics.dashboards__300573", "topic": "analytics", "subSkill": "dashboards", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What does Metabase display for this question when the table has an unindexed " }, { "t": "code", "v": "event_ts" }, { "t": "text", "v": " column with 80M rows and the cache TTL is 0?" } ] } ], "code": { "lang": "ts", "code": "-- Metabase question SQL\nSELECT date_trunc('hour', event_ts) AS h,\n count(*) AS n\nFROM analytics_raw.events\nWHERE event_ts >= now() - interval '7 days'\nGROUP BY 1\nORDER BY 1;\n-- table: 80M rows, no index on event_ts; cache_ttl = 0", "label": "dashboards.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Returns approx via sketch alg" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Cached result from last refresh" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Query timeout after 10 minutes" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "Truncated preview of 2000 rows" } ], "shape": "short" } ] } }, { "questionId": "analytics.dashboards__200256", "topic": "analytics", "subSkill": "dashboards", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Which row count does the Cube REST query return given the schema and time range below?" } ] } ], "code": { "lang": "ts", "code": "// cube schema:\n// cube('Orders', { sql: 'SELECT * FROM orders', measures: { count: { type: 'count' } },\n// dimensions: { createdAt: { sql: 'created_at', type: 'time' } } })\nfetch('/cubejs-api/v1/load', { method: 'POST', body: JSON.stringify({ query: {\n measures: ['Orders.count'],\n timeDimensions: [{ dimension: 'Orders.createdAt', granularity: 'day',\n dateRange: ['2026-04-01','2026-04-07'] }]\n}})});", "label": "dashboards.ts" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "1 row per day across 7 days" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "7 rows summed into 1 row" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "1 row per hour across 7 days" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "1 row per week across 7 days" } ], "shape": "short" } ] } }, { "questionId": "analytics.dashboards__200202", "topic": "analytics", "subSkill": "dashboards", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "When choosing between Mode and Hex for an analyst-led notebook + dashboard workflow, what is the most concrete distinction?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Hex executes only against managed Postgres replicas; Mode runs SQL only against materialised cube extracts" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Hex stores notebook state in a managed object store; Mode stores notebook state inside a local SQLite file" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Hex blends Python cells with SQL in the same notebook; Mode separates SQL queries from Python report blocks" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Hex restricts charting to a server-side renderer; Mode produces purely client-side static SVG output now" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.data_governance__63048291", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A Snowflake masking policy uses a mapping table for tag-based RBAC. What does USER_A (in finance) see for the tagged salary column?" } ] } ], "code": { "lang": "sql", "code": "CREATE MASKING POLICY salary_mask AS (val NUMBER) RETURNS NUMBER ->\n CASE\n WHEN EXISTS (\n SELECT 1 FROM tag_role_map\n WHERE tag_name = 'pii_finance'\n AND role_name = CURRENT_ROLE()\n ) THEN val\n ELSE NULL\n END;\n\nALTER TAG pii_finance SET MASKING POLICY salary_mask;\nALTER TABLE hr.employees MODIFY COLUMN salary SET TAG pii_finance='true';\n\n-- USER_A active role: FINANCE_ANALYST (in tag_role_map)\nSELECT salary FROM hr.employees WHERE id=7;", "label": "data-governance.sql" }, "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Permission denied error from policy" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "Plain numeric salary value visible" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "Hashed SHA2 digest of salary" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "NULL because user is not admin" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.data_governance__2073481", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dev attaches a Snowflake masking policy to column SSN, then runs SELECT * FROM t WHERE SSN = '123-45-6789' from a role that only sees masked output. A row with that exact SSN exists, yet the query returns zero rows. Why?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Masking policies null out the column in predicates, and NULL never equals a string literal" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "The comparison literal is masked before evaluation, so both sides become the masked token" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "The masking expression is applied to the column in WHERE predicates too, so the comparison sees the masked value" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Attaching a masking policy adds an implicit row access policy that filters unauthorized rows" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.data_governance__53720", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How do you implement data contracts between a platform team producing shared dimension tables and 10 consuming analytics teams?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Define contracts in version-controlled YAML specifying schema (column names, types, nullability), freshness SLAs (updated by 6am daily), quality guarantees (uniqueness, completeness thresholds), and semantic definitions. Enforce via dbt contract enforcement, CI validation, and monitoring alerts. Breaking changes require a deprecation period and consumer notification." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Give all 10 teams write access to the shared dimension tables so they can fix issues themselves" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Create a separate copy of each dimension table for each consuming team to isolate changes" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Use Slack announcements to notify teams of upcoming schema changes" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.data_governance__85066424", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Given the macro emitting OpenLineage column-level lineage from dbt's manifest, what does " }, { "t": "code", "v": "outputFields[revenue].inputFields" }, { "t": "text", "v": " resolve to for the model below?" } ] } ], "code": { "lang": "sql", "code": "-- models/marts/fct_revenue.sql\n{{ config(materialized='table') }}\nselect\n order_date,\n amount + tax as revenue\nfrom {{ ref('stg_orders') }}\n\n# Run: dbt-ol run --select fct_revenue\n# Inspect: events[-1].outputs[0].facets.columnLineage", "label": "data-governance.sql" }, "widget": { "kind": "predict_output", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "[stg_orders.amount, stg_orders.tax]" } ], "shape": "code" }, { "id": "o2", "label": [ { "t": "text", "v": "[raw_orders.amount, raw_orders.tax]" } ], "shape": "code" }, { "id": "o3", "label": [ { "t": "text", "v": "[fct_revenue.amount, fct_revenue.tax]" } ], "shape": "code" }, { "id": "o4", "label": [ { "t": "text", "v": "[stg_orders.total, stg_orders.taxed]" } ], "shape": "code" } ] } }, { "questionId": "data_warehousing.data_governance__53702", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 3, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is data retention policy and why is it important in a governed warehouse?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A policy that defines the minimum amount of data that must be loaded into the warehouse daily" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A policy defining how long data is kept before archival or deletion, based on business needs, regulatory requirements, and cost considerations. It prevents indefinite data hoarding, reduces storage costs, and ensures compliance with regulations that mandate maximum retention periods." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A backup schedule that determines how often warehouse snapshots are created" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "A performance tuning guideline for how long query results should be cached" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.data_governance__53722", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 5, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "You are building a data governance program from scratch for a 500-person company with no existing policies, 3 data warehouses, and 50 data producers. How do you prioritize the rollout to deliver value quickly without boiling the ocean?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Implement a full governance tool suite (Collibra, Monte Carlo, dbt tests) on day one across all warehouses" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Document all 50 producers' data in a comprehensive catalog before implementing any technical controls" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Phase 1: Automated PII discovery and classification across all warehouses (highest risk). Phase 2: Catalog the top 20 most-queried tables with owners, descriptions, and lineage. Phase 3: Implement masking and access controls on classified PII. Phase 4: Establish data quality monitoring on critical pipelines. Phase 5: Roll out data contracts and stewardship program to all teams incrementally." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Focus exclusively on GDPR compliance first and ignore data quality until the compliance project is complete" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.data_governance__53717", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "How should you implement data quality checks that prevent bad data from entering production warehouse tables?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Run all quality checks after data is loaded into production tables and roll back if issues are found" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Put quality gates at each stage: freshness before ingest, schema at landing, tests after transform" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Implement quality checks only in the BI layer: the end users then see validated data" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Rely exclusively on warehouse constraints (NOT NULL, UNIQUE) to enforce the data quality here" } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.data_governance__1041203", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 1, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "What is data lineage, as captured by lineage-tracking tools?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "A graph that records which inputs produced which outputs across jobs, datasets, and runs over time." } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "A schema registry that pins the column types of every dataset and rejects any incompatible changes at write." } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "A scheduler that orders dbt model builds based on their declared refs and topological dependencies." } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "A tabular log that lists every SQL query executed against the warehouse during a fixed retention window." } ], "shape": "long" } ] } }, { "questionId": "data_warehousing.data_governance__200435", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 2, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "A dbt project shows 'database error: insufficient privileges on schema analytics_pii' for a downstream consumer team after a deploy. The producer team confirms their model materialized successfully and they can SELECT it. What is the most likely cause given a " }, { "t": "code", "v": "grants" }, { "t": "text", "v": " config exists on the model?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "The grants config did not include the warehouse compute role for OPERATE" } ], "shape": "short" }, { "id": "o2", "label": [ { "t": "text", "v": "The grants config did not include the consumer team's role for SELECT" } ], "shape": "short" }, { "id": "o3", "label": [ { "t": "text", "v": "The grants config did not include the producer team's role for USAGE" } ], "shape": "short" }, { "id": "o4", "label": [ { "t": "text", "v": "The grants config did not include the snapshot service role for OWNERSHIP" } ], "shape": "short" } ] } }, { "questionId": "data_warehousing.data_governance__400563", "topic": "data_warehousing", "subSkill": "data_governance", "difficulty": 4, "stem": [ { "type": "p", "runs": [ { "t": "text", "v": "Comparing OpenLineage's column-level facet against vendor-only column lineage from a single catalog, which strategic property does OpenLineage protect?" } ] } ], "widget": { "kind": "mcq", "options": [ { "id": "o1", "label": [ { "t": "text", "v": "Automatic translation of the source system's native masking policies into equivalent governance rules at the destination" } ], "shape": "long" }, { "id": "o2", "label": [ { "t": "text", "v": "Lineage portability across orchestrators and warehouses, since the spec-defined event format is producer-agnostic" } ], "shape": "long" }, { "id": "o3", "label": [ { "t": "text", "v": "Sub-millisecond latency between job completion and the lineage graph rendering inside the catalog's primary user interface" } ], "shape": "long" }, { "id": "o4", "label": [ { "t": "text", "v": "Built-in storage of the full row-level dataset alongside lineage so consumers can replay every transformation in place" } ], "shape": "long" } ] } } ] }