(function() {
  var storage = { en: 'Design and Implement Data Storage', de: 'Datenspeicherung entwerfen und implementieren' };
  var processing = { en: 'Develop Data Processing', de: 'Datenverarbeitung entwickeln' };
  var security = { en: 'Secure, Monitor, and Optimize Data Storage and Data Processing', de: 'Datenspeicherung und Datenverarbeitung sichern, überwachen und optimieren' };

  var refs = {
    adlsAcl: 'https://learn.microsoft.com/en-us/azure/storage/blobs/data-lake-storage-access-control',
    synapseDist: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/sql-data-warehouse-tables-distribute',
    synapseExternal: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql/develop-tables-external-tables',
    synapseCopy: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/quickstart-bulk-load-copy-tsql',
    synapseServerless: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql/on-demand-workspace-overview',
    synapseSpark: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/spark/apache-spark-overview',
    adfParameters: 'https://learn.microsoft.com/en-us/azure/data-factory/concepts-parameters-variables',
    adfIR: 'https://learn.microsoft.com/en-us/azure/data-factory/concepts-integration-runtime',
    adfTriggers: 'https://learn.microsoft.com/en-us/azure/data-factory/concepts-pipeline-execution-triggers',
    adfDataFlow: 'https://learn.microsoft.com/en-us/azure/data-factory/concepts-data-flow-overview',
    adfControlFlow: 'https://learn.microsoft.com/en-us/azure/data-factory/concepts-pipelines-activities',
    databricksDelta: 'https://learn.microsoft.com/en-us/azure/databricks/delta/',
    databricksMerge: 'https://learn.microsoft.com/en-us/azure/databricks/delta/merge',
    databricksStreaming: 'https://learn.microsoft.com/en-us/azure/databricks/structured-streaming/',
    databricksClusters: 'https://learn.microsoft.com/en-us/azure/databricks/compute/',
    unityCatalog: 'https://learn.microsoft.com/en-us/azure/databricks/data-governance/unity-catalog/',
    streamWindows: 'https://learn.microsoft.com/en-us/azure/stream-analytics/stream-analytics-window-functions',
    streamOrdering: 'https://learn.microsoft.com/en-us/azure/stream-analytics/event-ordering',
    eventHubs: 'https://learn.microsoft.com/en-us/azure/event-hubs/event-hubs-about',
    eventHubsCapture: 'https://learn.microsoft.com/en-us/azure/event-hubs/event-hubs-capture-overview',
    schemaRegistry: 'https://learn.microsoft.com/en-us/azure/event-hubs/schema-registry-overview',
    sqlCdc: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/change-data-capture-overview',
    debezium: 'https://debezium.io/documentation/reference/stable/',
    rowLevelSecurity: 'https://learn.microsoft.com/en-us/sql/relational-databases/security/row-level-security',
    columnSecurity: 'https://learn.microsoft.com/en-us/sql/relational-databases/security/permissions-database-engine#column-permissions',
    ddm: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/dynamic-data-masking-overview',
    alwaysEncrypted: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/always-encrypted-landing',
    tde: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/transparent-data-encryption-tde-overview',
    managedIdentity: 'https://learn.microsoft.com/en-us/azure/data-factory/data-factory-service-identity',
    keyVault: 'https://learn.microsoft.com/en-us/azure/data-factory/store-credentials-in-key-vault',
    managedVnet: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/security/synapse-workspace-managed-vnet',
    synapseMonitor: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/sql-data-warehouse-manage-monitor',
    queryStore: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/query-store',
    sparkUI: 'https://learn.microsoft.com/en-us/azure/databricks/optimizations/spark-ui-guide',
    pipelineMonitor: 'https://learn.microsoft.com/en-us/azure/data-factory/monitor-visually',
    synapseOptimize: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql/best-practices-dedicated-sql-pool',
    serverlessBest: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql/best-practices-serverless-sql-pool',
    deltaOptimize: 'https://learn.microsoft.com/en-us/azure/databricks/delta/optimize',
    costMgmt: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/sql-data-warehouse-manage-compute-overview'
  };

  function q(type, id, domain, difficulty, scenario, question, options, correct, explanation, hint, reference) {
    return {
      id: id,
      type: type,
      domain: domain,
      difficulty: difficulty,
      scenario: scenario ? { en: scenario[0], de: scenario[1] } : null,
      question: { en: question[0], de: question[1] },
      options: options.map(function(opt) {
        return { id: opt[0], text: { en: opt[1], de: opt[2] } };
      }),
      correct: correct,
      explanation: { en: explanation[0], de: explanation[1] },
      hint: { en: hint[0], de: hint[1] },
      reference: reference
    };
  }

  var extra = [
    q('single', 'dp203-102', storage, 'medium', null, [`A data engineer grants a user the Storage Blob Data Reader role on an Azure Data Lake Storage Gen2 account. The user still cannot open a file in /raw/2025/04/sales.csv when ACLs are enforced. Which additional permission is typically required on the folder path?`, `Ein Dateningenieur weist einem Benutzer auf einem Azure Data Lake Storage Gen2-Konto die Rolle Storage Blob Data Reader zu. Der Benutzer kann die Datei /raw/2025/04/sales.csv trotzdem nicht öffnen, wenn ACLs erzwungen werden. Welche zusätzliche Berechtigung wird auf dem Ordnerpfad typischerweise benötigt?`], [['A', 'The execute permission on each parent folder', 'Die Execute-Berechtigung auf jedem übergeordneten Ordner'], ['B', 'The Owner role on the subscription', 'Die Rolle Owner auf dem Abonnement'], ['C', 'The Contributor role on the Synapse workspace', 'Die Rolle Contributor im Synapse-Workspace'], ['D', 'A private endpoint approval', 'Eine Genehmigung für einen Private Endpoint']], ['A'], [`For ADLS Gen2, RBAC and ACLs work together. To traverse folders and reach a file, the principal usually needs execute on each parent folder and read on the file.`, `Bei ADLS Gen2 wirken RBAC und ACLs zusammen. Um Ordner zu durchlaufen und eine Datei zu erreichen, benötigt der Prinzipal in der Regel Execute auf jedem übergeordneten Ordner und Read auf der Datei.`], [`Think about what POSIX-style ACLs require for folder traversal.`, `Denken Sie daran, was ACLs im POSIX-Stil für das Durchqueren von Ordnern verlangen.`], refs.adlsAcl),
    q('multiple', 'dp203-103', storage, 'hard', null, [`A retail platform stores orders in a data lake and most queries filter by month and sales region. Which two partitioning choices best support pruning while keeping the folder layout understandable?`, `Eine Einzelhandelsplattform speichert Bestellungen in einem Data Lake, und die meisten Abfragen filtern nach Monat und Verkaufsregion. Welche zwei Partitionierungsentscheidungen unterstützen Pruning am besten und halten das Ordnerlayout verständlich?`], [['A', 'Partition by year and month', 'Nach Jahr und Monat partitionieren'], ['B', 'Partition by sales region under the date path', 'Nach Verkaufsregion unterhalb des Datumspfads partitionieren'], ['C', 'Partition by OrderId', 'Nach OrderId partitionieren'], ['D', 'Partition by random GUID', 'Nach einer zufälligen GUID partitionieren']], ['A', 'B'], [`Time-based partitions fit the common filter pattern, and adding region can further reduce scans. High-cardinality values such as OrderId or GUID create too many tiny partitions.`, `Zeitbasierte Partitionen passen zum typischen Filtermuster, und das Ergänzen der Region kann Scans weiter reduzieren. Werte mit hoher Kardinalität wie OrderId oder GUID erzeugen zu viele winzige Partitionen.`], [`Choose folders that align with common predicates and avoid extreme cardinality.`, `Wählen Sie Ordner, die zu häufigen Prädikaten passen, und vermeiden Sie extreme Kardinalität.`], refs.serverlessBest),
    q('single', 'dp203-104', storage, 'easy', null, [`Which file format is usually the best default for analytical queries because it is columnar and supports compression and predicate pushdown?`, `Welches Dateiformat ist normalerweise die beste Standardwahl für analytische Abfragen, weil es spaltenorientiert ist sowie Komprimierung und Predicate Pushdown unterstützt?`], [['A', 'CSV', 'CSV'], ['B', 'JSON', 'JSON'], ['C', 'Parquet', 'Parquet'], ['D', 'Plain text logs', 'Einfache Textprotokolle']], ['C'], [`Parquet is a columnar format that works very well for analytics. It reduces I/O by reading only needed columns and usually compresses better than row-oriented text formats.`, `Parquet ist ein spaltenorientiertes Format, das sich sehr gut für Analysen eignet. Es reduziert I/O, weil nur benötigte Spalten gelesen werden, und komprimiert meist besser als zeilenorientierte Textformate.`], [`Look for the format optimized for scan-heavy analytical workloads.`, `Suchen Sie nach dem Format, das für scanintensive analytische Workloads optimiert ist.`], refs.serverlessBest),
    q('single', 'dp203-105', storage, 'medium', null, [`Which capability does Delta Lake add on top of Parquet files?`, `Welche Fähigkeit fügt Delta Lake zusätzlich zu Parquet-Dateien hinzu?`], [['A', 'A transaction log with ACID semantics and time travel', 'Ein Transaktionsprotokoll mit ACID-Semantik und Time Travel'], ['B', 'Automatic creation of Synapse dedicated SQL pools', 'Automatische Erstellung von Synapse Dedicated SQL Pools'], ['C', 'Built-in row-level security in storage accounts', 'Integrierte Row-Level Security in Speicherkonten'], ['D', 'Exclusive support for CSV ingestion', 'Exklusive Unterstützung für CSV-Aufnahme']], ['A'], [`Delta Lake stores Parquet data plus a transaction log. That log enables ACID transactions, schema enforcement, and time travel for reliable lakehouse workloads.`, `Delta Lake speichert Parquet-Daten plus ein Transaktionsprotokoll. Dieses Protokoll ermöglicht ACID-Transaktionen, Schemaerzwingung und Time Travel für zuverlässige Lakehouse-Workloads.`], [`Think beyond file encoding and focus on transactional behavior.`, `Denken Sie über die Dateikodierung hinaus und konzentrieren Sie sich auf das transaktionale Verhalten.`], refs.databricksDelta),
    q('single', 'dp203-106', storage, 'medium', null, [`Your team publishes event messages and wants a compact row-oriented format with strong schema evolution support. Which format is the best fit?`, `Ihr Team veröffentlicht Ereignisnachrichten und möchte ein kompaktes zeilenorientiertes Format mit starker Unterstützung für Schemaentwicklung. Welches Format passt am besten?`], [['A', 'Avro', 'Avro'], ['B', 'ORC', 'ORC'], ['C', 'Parquet', 'Parquet'], ['D', 'XLSX', 'XLSX']], ['A'], [`Avro is a row-oriented serialization format commonly used for event streams and message exchange. It is well known for schema evolution support.`, `Avro ist ein zeilenorientiertes Serialisierungsformat, das häufig für Ereignisströme und Nachrichtenaustausch verwendet wird. Es ist für seine Unterstützung der Schemaentwicklung bekannt.`], [`Choose the format often paired with event streaming and schema registries.`, `Wählen Sie das Format, das oft mit Event Streaming und Schema Registries verwendet wird.`], refs.schemaRegistry),
    q('single', 'dp203-107', storage, 'medium', null, [`Which statement best describes ORC?`, `Welche Aussage beschreibt ORC am besten?`], [['A', 'It is a columnar format optimized for analytical reads in big data systems', 'Es ist ein spaltenorientiertes Format, das für analytische Lesevorgänge in Big-Data-Systemen optimiert ist'], ['B', 'It is a binary message bus protocol', 'Es ist ein binäres Message-Bus-Protokoll'], ['C', 'It is a SQL security feature', 'Es ist eine SQL-Sicherheitsfunktion'], ['D', 'It is a storage tier in Azure Blob Storage', 'Es ist eine Speicherebene in Azure Blob Storage']], ['A'], [`ORC is a columnar file format similar in goal to Parquet. It is designed for large analytical workloads and supports compression and pushdown optimizations.`, `ORC ist ein spaltenorientiertes Dateiformat mit ähnlicher Zielsetzung wie Parquet. Es ist für große analytische Workloads ausgelegt und unterstützt Komprimierung sowie Pushdown-Optimierungen.`], [`Think of Hive and other big data engines, not security or networking.`, `Denken Sie an Hive und andere Big-Data-Engines, nicht an Sicherheit oder Netzwerke.`], refs.serverlessBest),
    q('single', 'dp203-108', storage, 'easy', null, [`A dimension table should always show the latest customer phone number and does not need any history. Which slowly changing dimension pattern should you use?`, `Eine Dimensionstabelle soll immer nur die aktuelle Telefonnummer des Kunden zeigen und benötigt keine Historie. Welches Slowly-Changing-Dimension-Muster sollten Sie verwenden?`], [['A', 'Type 1', 'Typ 1'], ['B', 'Type 2', 'Typ 2'], ['C', 'Type 3', 'Typ 3'], ['D', 'Type 6', 'Typ 6']], ['A'], [`Type 1 overwrites the old value with the new one. It is appropriate when history is not required.`, `Typ 1 überschreibt den alten Wert mit dem neuen. Er ist geeignet, wenn keine Historie benötigt wird.`], [`No history means overwrite in place.`, `Keine Historie bedeutet Überschreiben an Ort und Stelle.`], refs.synapseOptimize),
    q('multiple', 'dp203-109', storage, 'medium', [`A Type 2 dimension often starts with a design like:
CREATE TABLE dbo.DimCustomer (
    CustomerSK int,
    CustomerId int,
    Segment nvarchar(50),
    EffectiveFrom date,
    EffectiveTo date,
    IsCurrent bit
);`, `Eine Typ-2-Dimension beginnt oft mit einem Design wie:
CREATE TABLE dbo.DimCustomer (
    CustomerSK int,
    CustomerId int,
    Segment nvarchar(50),
    EffectiveFrom date,
    EffectiveTo date,
    IsCurrent bit
);`], [`Which two attributes are commonly added to a slowly changing dimension Type 2 table?`, `Welche zwei Attribute werden einer Slowly-Changing-Dimension-Tabelle vom Typ 2 häufig hinzugefügt?`], [['A', 'Effective start and end dates', 'Gültigkeitsbeginn- und -endedaten'], ['B', 'A current-row flag', 'Ein Kennzeichen für die aktuelle Zeile'], ['C', 'A round-robin distribution hint', 'Ein Round-Robin-Verteilungshinweis'], ['D', 'An archive tier setting', 'Eine Archivstufen-Einstellung']], ['A', 'B'], [`Type 2 preserves history by versioning rows. Effective dates and a current-row indicator help identify which version was valid at a given time.`, `Typ 2 bewahrt Historie durch versionierte Zeilen. Gültigkeitsdaten und ein Kennzeichen für die aktuelle Zeile helfen dabei zu erkennen, welche Version zu einem bestimmten Zeitpunkt gültig war.`], [`Think about how you track historical validity.`, `Denken Sie daran, wie historische Gültigkeit nachverfolgt wird.`], refs.synapseOptimize),
    q('single', 'dp203-110', storage, 'medium', null, [`A business user wants to compare the current product category with the previous category in the same row, but does not require full history. Which slowly changing dimension type is the best match?`, `Ein Fachanwender möchte die aktuelle Produktkategorie mit der vorherigen Kategorie in derselben Zeile vergleichen, benötigt aber keine vollständige Historie. Welcher Slowly-Changing-Dimension-Typ passt am besten?`], [['A', 'Type 1', 'Typ 1'], ['B', 'Type 2', 'Typ 2'], ['C', 'Type 3', 'Typ 3'], ['D', 'Type 6', 'Typ 6']], ['C'], [`Type 3 stores limited history, often by adding one or more previous-value columns. It is useful when comparing current and prior values without keeping every historical version.`, `Typ 3 speichert begrenzte Historie, oft durch eine oder mehrere Spalten für frühere Werte. Er ist nützlich, wenn aktuelle und vorherige Werte verglichen werden sollen, ohne jede historische Version zu speichern.`], [`Only the previous value is needed, not the full timeline.`, `Es wird nur der vorherige Wert benötigt, nicht die vollständige Zeitleiste.`], refs.synapseOptimize),
    q('single', 'dp203-111', storage, 'hard', null, [`Which slowly changing dimension type combines overwrite behavior, full history, and previous-value columns in one design?`, `Welcher Slowly-Changing-Dimension-Typ kombiniert Überschreibverhalten, vollständige Historie und Spalten für vorherige Werte in einem Design?`], [['A', 'Type 2', 'Typ 2'], ['B', 'Type 3', 'Typ 3'], ['C', 'Type 6', 'Typ 6'], ['D', 'Type 0', 'Typ 0']], ['C'], [`Type 6 is a hybrid approach that blends characteristics of Types 1, 2, and 3. It can support current values, history, and previous values together.`, `Typ 6 ist ein hybrider Ansatz, der Merkmale von Typ 1, 2 und 3 verbindet. Er kann aktuelle Werte, Historie und frühere Werte gleichzeitig unterstützen.`], [`This is the hybrid SCD pattern.`, `Dies ist das hybride SCD-Muster.`], refs.synapseOptimize),
    q('single', 'dp203-112', storage, 'medium', [`A warehouse engineer is considering:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(CustomerKey))
AS SELECT * FROM dbo.StageSales;`, `Ein Warehouse-Ingenieur erwägt:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(CustomerKey))
AS SELECT * FROM dbo.StageSales;`], [`A 6 TB fact table is frequently joined on CustomerKey in a Synapse dedicated SQL pool. Which distribution type usually minimizes data movement for that fact table?`, `Eine 6-TB-Faktentabelle wird in einem Synapse Dedicated SQL Pool häufig über CustomerKey verknüpft. Welcher Verteilungstyp minimiert die Datenbewegung für diese Faktentabelle normalerweise?`], [['A', 'Hash distribution on CustomerKey', 'Hash-Verteilung auf CustomerKey'], ['B', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['C', 'Replicated distribution', 'Replizierte Verteilung'], ['D', 'Archive distribution', 'Archivverteilung']], ['A'], [`For very large fact tables, hash distribution on a common join key often reduces data movement during joins. Round-robin is easier to load but less optimal for repeated joins.`, `Für sehr große Faktentabellen reduziert eine Hash-Verteilung auf einem gemeinsamen Join-Schlüssel häufig die Datenbewegung bei Joins. Round-Robin ist einfacher zu laden, aber für wiederholte Joins weniger optimal.`], [`Pick the option aligned to the main join column.`, `Wählen Sie die Option, die auf die Haupt-Join-Spalte abgestimmt ist.`], refs.synapseDist),
    q('single', 'dp203-113', storage, 'easy', null, [`Which distribution type is often used for transient staging tables when you want fast loading and there is no clear distribution key yet?`, `Welcher Verteilungstyp wird häufig für temporäre Staging-Tabellen verwendet, wenn Sie schnelles Laden möchten und noch kein klarer Verteilungsschlüssel feststeht?`], [['A', 'Round-robin', 'Round-Robin'], ['B', 'Hash', 'Hash'], ['C', 'Replicated', 'Repliziert'], ['D', 'Clustered', 'Geclustert']], ['A'], [`Round-robin tables are quick to create and load. They are common for staging when query patterns are not yet optimized.`, `Round-Robin-Tabellen lassen sich schnell erstellen und laden. Sie werden häufig für Staging verwendet, wenn Abfragemuster noch nicht optimiert sind.`], [`Think of the simplest distribution for landing data quickly.`, `Denken Sie an die einfachste Verteilung, um Daten schnell zu landen.`], refs.synapseDist),
    q('single', 'dp203-114', storage, 'medium', [`A dimension table is tiny, and the team considers:
CREATE TABLE dbo.DimDate
WITH (DISTRIBUTION = REPLICATE)
AS SELECT * FROM dbo.StageDimDate;`, `Eine Dimensionstabelle ist sehr klein, und das Team erwägt:
CREATE TABLE dbo.DimDate
WITH (DISTRIBUTION = REPLICATE)
AS SELECT * FROM dbo.StageDimDate;`], [`Which distribution type is usually best for a small dimension table that is joined frequently to large fact tables?`, `Welcher Verteilungstyp ist normalerweise am besten für eine kleine Dimensionstabelle geeignet, die häufig mit großen Faktentabellen verknüpft wird?`], [['A', 'Replicated', 'Repliziert'], ['B', 'Round-robin', 'Round-Robin'], ['C', 'Hash on a random column', 'Hash auf einer zufälligen Spalte'], ['D', 'Archive', 'Archiv']], ['A'], [`Replicated tables copy the table to each compute node, which can reduce data movement when a small dimension is joined to large distributed facts.`, `Replizierte Tabellen kopieren die Tabelle auf jeden Computeknoten, was die Datenbewegung reduzieren kann, wenn eine kleine Dimension mit großen verteilten Fakten verknüpft wird.`], [`The table is small enough to copy everywhere.`, `Die Tabelle ist klein genug, um sie überall zu kopieren.`], refs.synapseDist),
    q('single', 'dp203-115', storage, 'medium', [`You run the following T-SQL in a Synapse serverless SQL pool:
SELECT TOP 20 *
FROM OPENROWSET(
    BULK 'https://contoso.dfs.core.windows.net/raw/sales/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`, `Sie führen folgendes T-SQL in einem serverlosen SQL-Pool von Synapse aus:
SELECT TOP 20 *
FROM OPENROWSET(
    BULK 'https://contoso.dfs.core.windows.net/raw/sales/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`], [`What is the main advantage of this pattern?`, `Was ist der Hauptvorteil dieses Musters?`], [['A', 'It queries files directly without first loading them into internal tables', 'Es fragt Dateien direkt ab, ohne sie zuerst in interne Tabellen zu laden'], ['B', 'It automatically creates a dedicated SQL pool', 'Es erstellt automatisch einen Dedicated SQL Pool'], ['C', 'It bypasses all storage permissions', 'Es umgeht alle Speicherberechtigungen'], ['D', 'It converts Parquet to CSV automatically', 'Es konvertiert Parquet automatisch in CSV']], ['A'], [`OPENROWSET in serverless SQL lets you analyze external files on demand. This is useful for exploration and virtualized access patterns.`, `OPENROWSET in serverlosem SQL ermöglicht die bedarfsgesteuerte Analyse externer Dateien. Das ist nützlich für Exploration und virtualisierte Zugriffsmuster.`], [`No table load step appears in the query.`, `In der Abfrage erscheint kein Schritt zum Laden in eine Tabelle.`], refs.synapseServerless),
    q('single', 'dp203-116', storage, 'easy', null, [`In a medallion-style data lake, which zone should store data exactly as it arrived from the source with minimal transformation?`, `Welche Zone sollte in einem Data Lake im Medallion-Stil Daten genau so speichern, wie sie aus der Quelle angekommen sind, also mit minimaler Transformation?`], [['A', 'Raw or bronze zone', 'Raw- oder Bronze-Zone'], ['B', 'Curated or gold zone', 'Curated- oder Gold-Zone'], ['C', 'Semantic model zone', 'Semantic-Model-Zone'], ['D', 'Presentation cache zone', 'Präsentations-Cache-Zone']], ['A'], [`The raw or bronze zone is intended for landed source data. It preserves the original shape for lineage, replay, and auditing.`, `Die Raw- oder Bronze-Zone ist für gelandete Quelldaten vorgesehen. Sie bewahrt die ursprüngliche Form für Lineage, Replay und Auditing.`], [`This is the landing area, not the business-ready area.`, `Dies ist der Landing-Bereich und nicht der fachlich aufbereitete Bereich.`], refs.databricksDelta),
    q('single', 'dp203-117', storage, 'easy', null, [`Which data lake zone is typically used for business-ready, conformed data sets that feed BI models and downstream consumers?`, `Welche Data-Lake-Zone wird typischerweise für fachlich aufbereitete, konforme Datensätze verwendet, die BI-Modelle und nachgelagerte Verbraucher versorgen?`], [['A', 'Raw or bronze', 'Raw oder Bronze'], ['B', 'Enriched or silver', 'Enriched oder Silver'], ['C', 'Curated or gold', 'Curated oder Gold'], ['D', 'Archive', 'Archiv']], ['C'], [`Curated or gold data is modeled for downstream analytics and reporting. It is typically cleansed, conformed, and easier for consumers to use.`, `Curated- oder Gold-Daten sind für nachgelagerte Analysen und Berichte modelliert. Sie sind typischerweise bereinigt, harmonisiert und für Verbraucher leichter nutzbar.`], [`Choose the zone closest to consumption.`, `Wählen Sie die Zone, die der Nutzung am nächsten ist.`], refs.databricksDelta),
    q('single', 'dp203-118', storage, 'medium', null, [`Which Azure Blob Storage access tier is usually appropriate for data that is accessed infrequently but still must remain immediately available online?`, `Welche Azure-Blob-Storage-Zugriffsebene ist normalerweise für Daten geeignet, auf die selten zugegriffen wird, die aber weiterhin sofort online verfügbar bleiben müssen?`], [['A', 'Hot', 'Hot'], ['B', 'Cool', 'Cool'], ['C', 'Archive', 'Archive'], ['D', 'Premium SSD', 'Premium SSD']], ['B'], [`The cool tier is for infrequently accessed data that still needs low-latency online access. Archive is cheaper but requires rehydration before reads.`, `Die Cool-Stufe ist für selten genutzte Daten gedacht, die weiterhin mit niedriger Latenz online verfügbar sein müssen. Archive ist günstiger, erfordert vor dem Lesen jedoch eine Rehydrierung.`], [`The data stays online, so archive is too cold.`, `Die Daten bleiben online, daher ist Archive zu kalt.`], refs.adlsAcl),
    q('single', 'dp203-119', storage, 'medium', null, [`Which statement about the archive tier is correct?`, `Welche Aussage über die Archive-Stufe ist korrekt?`], [['A', 'Data can be queried in place with Synapse serverless SQL', 'Daten können direkt mit Synapse Serverless SQL abgefragt werden'], ['B', 'It is the cheapest tier but data must be rehydrated before normal access', 'Es ist die günstigste Stufe, aber die Daten müssen vor dem normalen Zugriff rehydriert werden'], ['C', 'It is designed for high-frequency dashboard workloads', 'Sie ist für hochfrequente Dashboard-Workloads ausgelegt'], ['D', 'It enables POSIX ACLs automatically', 'Sie aktiviert automatisch POSIX-ACLs']], ['B'], [`Archive minimizes storage cost for rarely needed data, but read access is not immediate because the data must first be rehydrated.`, `Archive minimiert die Speicherkosten für selten benötigte Daten, aber der Lesezugriff ist nicht sofort möglich, weil die Daten zunächst rehydriert werden müssen.`], [`Cheapest storage usually comes with slower retrieval.`, `Die günstigste Speicherung geht normalerweise mit langsamerem Abruf einher.`], refs.adlsAcl),
    q('multiple', 'dp203-120', storage, 'hard', null, [`A user must read a file at /curated/finance/2025/report.parquet in ADLS Gen2 by using ACLs. Which two permissions are typically required if no default ACL shortcuts already cover access?`, `Ein Benutzer muss in ADLS Gen2 per ACLs eine Datei unter /curated/finance/2025/report.parquet lesen. Welche zwei Berechtigungen sind typischerweise erforderlich, wenn keine Default-ACL-Vererbung den Zugriff bereits abdeckt?`], [['A', 'Read on the file', 'Read auf der Datei'], ['B', 'Write on the storage account', 'Write auf dem Speicherkonto'], ['C', 'Execute on the parent folders', 'Execute auf den übergeordneten Ordnern'], ['D', 'Owner on the subscription', 'Owner auf dem Abonnement']], ['A', 'C'], [`Reading the file usually requires read permission on the file itself and execute permission on the folder path so the principal can traverse the hierarchy.`, `Das Lesen der Datei erfordert typischerweise Read auf der Datei selbst und Execute auf dem Ordnerpfad, damit der Prinzipal die Hierarchie durchlaufen kann.`], [`One permission is for the file, and one is for traversal.`, `Eine Berechtigung gilt für die Datei, die andere für das Durchlaufen des Pfads.`], refs.adlsAcl),
    q('single', 'dp203-121', storage, 'hard', [`A telemetry lake currently uses folders partitioned only by eventDate. One customer generates 70 percent of the volume and causes very uneven file sizes. You consider changing the layout to:
eventDate=2025-05-01/hashBucket=07/
Which design goal does the hashBucket folder help address?`, `Ein Telemetrie-Lake verwendet derzeit Ordner, die nur nach eventDate partitioniert sind. Ein Kunde erzeugt 70 Prozent des Volumens und verursacht sehr ungleichmäßige Dateigrößen. Sie erwägen, das Layout in Folgendes zu ändern:
eventDate=2025-05-01/hashBucket=07/
Welches Entwurfsziel unterstützt der Ordner hashBucket?`], [`What is the best answer?`, `Was ist die beste Antwort?`], [['A', 'It helps distribute data more evenly and can reduce skew', 'Er hilft, Daten gleichmäßiger zu verteilen und kann Skew reduzieren'], ['B', 'It enables row-level security automatically', 'Er aktiviert automatisch Row-Level Security'], ['C', 'It converts JSON to Delta', 'Er konvertiert JSON in Delta'], ['D', 'It replaces the need for eventDate partitioning', 'Er ersetzt die Notwendigkeit der Partitionierung nach eventDate']], ['A'], [`Adding a hash bucket under a time partition can spread heavy tenants or keys across multiple paths. This can reduce skew and improve parallelism while keeping date-based pruning.`, `Das Hinzufügen eines Hash-Buckets unterhalb einer Zeitpartition kann schwere Mandanten oder Schlüssel auf mehrere Pfade verteilen. Dadurch lassen sich Skew verringern und Parallelität verbessern, während datumsbasiertes Pruning erhalten bleibt.`], [`The date still matters, but you also need a balancing mechanism.`, `Das Datum bleibt wichtig, aber Sie benötigen zusätzlich einen Ausgleichsmechanismus.`], refs.serverlessBest),
    q('single', 'dp203-122', processing, 'medium', [`You run the following statement in a Synapse dedicated SQL pool:
CREATE TABLE dbo.SalesByMonth
WITH (DISTRIBUTION = HASH(CustomerKey), CLUSTERED COLUMNSTORE INDEX)
AS
SELECT OrderMonth, CustomerKey, SUM(Amount) AS TotalAmount
FROM dbo.StageSales
GROUP BY OrderMonth, CustomerKey;`, `Sie führen folgende Anweisung in einem Synapse Dedicated SQL Pool aus:
CREATE TABLE dbo.SalesByMonth
WITH (DISTRIBUTION = HASH(CustomerKey), CLUSTERED COLUMNSTORE INDEX)
AS
SELECT OrderMonth, CustomerKey, SUM(Amount) AS TotalAmount
FROM dbo.StageSales
GROUP BY OrderMonth, CustomerKey;`], [`Which Synapse pattern does this statement use?`, `Welches Synapse-Muster verwendet diese Anweisung?`], [['A', 'CTAS', 'CTAS'], ['B', 'CETAS', 'CETAS'], ['C', 'COPY INTO', 'COPY INTO'], ['D', 'OPENROWSET', 'OPENROWSET']], ['A'], [`CTAS stands for CREATE TABLE AS SELECT. In a dedicated SQL pool it is a common pattern for creating a new internal table from query output efficiently.`, `CTAS steht für CREATE TABLE AS SELECT. In einem Dedicated SQL Pool ist dies ein gängiges Muster, um effizient eine neue interne Tabelle aus Abfrageergebnissen zu erstellen.`], [`The output is an internal table, not a lake file.`, `Die Ausgabe ist eine interne Tabelle und keine Lake-Datei.`], refs.synapseOptimize),
    q('single', 'dp203-123', processing, 'medium', [`You run this statement in a Synapse serverless SQL pool:
CREATE EXTERNAL TABLE curated.SalesExport
WITH (
    LOCATION = 'exports/sales/',
    DATA_SOURCE = LakeDs,
    FILE_FORMAT = ParquetFormat
)
AS
SELECT Region, SUM(Amount) AS TotalAmount
FROM OPENROWSET(
    BULK 'curated/sales/*.parquet',
    DATA_SOURCE = 'LakeDs',
    FORMAT = 'PARQUET'
) AS rows
GROUP BY Region;`, `Sie führen diese Anweisung in einem serverlosen SQL-Pool von Synapse aus:
CREATE EXTERNAL TABLE curated.SalesExport
WITH (
    LOCATION = 'exports/sales/',
    DATA_SOURCE = LakeDs,
    FILE_FORMAT = ParquetFormat
)
AS
SELECT Region, SUM(Amount) AS TotalAmount
FROM OPENROWSET(
    BULK 'curated/sales/*.parquet',
    DATA_SOURCE = 'LakeDs',
    FORMAT = 'PARQUET'
) AS rows
GROUP BY Region;`], [`What is this pattern called?`, `Wie heißt dieses Muster?`], [['A', 'CETAS', 'CETAS'], ['B', 'MERGE', 'MERGE'], ['C', 'COPY INTO', 'COPY INTO'], ['D', 'TRUNCATE LOAD', 'TRUNCATE LOAD']], ['A'], [`In serverless SQL, CREATE EXTERNAL TABLE AS SELECT writes query output back to the lake. That pattern is called CETAS.`, `In serverlosem SQL schreibt CREATE EXTERNAL TABLE AS SELECT Abfrageausgaben zurück in den Lake. Dieses Muster heißt CETAS.`], [`The result is written as files through an external table definition.`, `Das Ergebnis wird über eine Definition einer externen Tabelle als Dateien geschrieben.`], refs.synapseServerless),
    q('single', 'dp203-124', processing, 'easy', [`A notebook starts with:
%%pyspark
df = spark.read.parquet('abfss://raw@contoso.dfs.core.windows.net/orders/')
df.count()`, `Ein Notebook beginnt mit:
%%pyspark
df = spark.read.parquet('abfss://raw@contoso.dfs.core.windows.net/orders/')
df.count()`], [`You need to run Spark notebooks and distributed DataFrame transformations inside Azure Synapse. Which compute resource should you choose?`, `Sie müssen Spark-Notebooks und verteilte DataFrame-Transformationen innerhalb von Azure Synapse ausführen. Welche Computeressource sollten Sie wählen?`], [['A', 'Serverless SQL pool', 'Serverloser SQL-Pool'], ['B', 'Dedicated SQL pool', 'Dedicated SQL Pool'], ['C', 'Spark pool', 'Spark-Pool'], ['D', 'Managed private endpoint', 'Managed Private Endpoint']], ['C'], [`Spark pools are the Synapse compute option for Spark notebooks, jobs, and distributed transformations. SQL pools target SQL workloads instead.`, `Spark-Pools sind die Synapse-Computeoption für Spark-Notebooks, Jobs und verteilte Transformationen. SQL-Pools sind stattdessen auf SQL-Workloads ausgerichtet.`], [`The requirement explicitly mentions Spark execution.`, `Die Anforderung nennt ausdrücklich die Ausführung von Spark.`], refs.synapseSpark),
    q('single', 'dp203-125', processing, 'hard', [`An ADF dataset contains the following path expression:
@concat('raw/', dataset().EntityName, '/dt=', pipeline().parameters.LoadDate, '/')`, `Ein ADF-Dataset enthält folgenden Pfadausdruck:
@concat('raw/', dataset().EntityName, '/dt=', pipeline().parameters.LoadDate, '/')`], [`What is the main benefit of this approach?`, `Was ist der Hauptvorteil dieses Ansatzes?`], [['A', 'It parameterizes the dataset path so one dataset can be reused for many entities and dates', 'Er parametrisiert den Dataset-Pfad, sodass ein Dataset für viele Entitäten und Datumswerte wiederverwendet werden kann'], ['B', 'It turns the dataset into a managed private endpoint', 'Er verwandelt das Dataset in einen Managed Private Endpoint'], ['C', 'It encrypts the folder automatically with TDE', 'Er verschlüsselt den Ordner automatisch mit TDE'], ['D', 'It creates a Spark checkpoint automatically', 'Er erstellt automatisch einen Spark-Checkpoint']], ['A'], [`ADF expressions allow datasets and activities to be parameterized. That reduces duplication and makes pipelines reusable across many sources or partitions.`, `ADF-Ausdrücke ermöglichen die Parametrisierung von Datasets und Aktivitäten. Das reduziert Duplizierung und macht Pipelines für viele Quellen oder Partitionen wiederverwendbar.`], [`Look for reuse and configurability, not security.`, `Achten Sie auf Wiederverwendbarkeit und Konfigurierbarkeit, nicht auf Sicherheit.`], refs.adfParameters),
    q('single', 'dp203-126', processing, 'medium', null, [`You need a value such as the corporate data lake URL to be reused by many pipelines in one Azure Data Factory without passing it through each pipeline call. What should you use?`, `Sie müssen einen Wert wie die URL des unternehmensweiten Data Lakes in vielen Pipelines derselben Azure Data Factory wiederverwenden, ohne ihn bei jedem Pipelineaufruf zu übergeben. Was sollten Sie verwenden?`], [['A', 'A global parameter', 'Einen globalen Parameter'], ['B', 'A session window', 'Ein Session Window'], ['C', 'A tumbling trigger', 'Einen Tumbling-Trigger'], ['D', 'A Spark cache', 'Einen Spark-Cache']], ['A'], [`Global parameters store factory-wide values that many pipelines can reference. They are useful for shared configuration.`, `Globale Parameter speichern factoryweite Werte, auf die viele Pipelines verweisen können. Sie sind nützlich für gemeinsam genutzte Konfigurationen.`], [`The setting belongs to the factory, not to a single pipeline run.`, `Die Einstellung gehört zur Factory und nicht zu einem einzelnen Pipelinelauf.`], refs.adfParameters),
    q('single', 'dp203-127', processing, 'easy', null, [`You copy data from Azure SQL Database to Azure Data Lake Storage Gen2. Both services are publicly reachable Azure services. Which integration runtime is usually sufficient?`, `Sie kopieren Daten aus Azure SQL Database nach Azure Data Lake Storage Gen2. Beide Dienste sind öffentlich erreichbare Azure-Dienste. Welche Integration Runtime ist normalerweise ausreichend?`], [['A', 'Azure integration runtime', 'Azure Integration Runtime'], ['B', 'Self-hosted integration runtime', 'Selbstgehostete Integration Runtime'], ['C', 'Spark integration runtime', 'Spark Integration Runtime'], ['D', 'Managed private endpoint runtime', 'Managed-Private-Endpoint-Runtime']], ['A'], [`For cloud-to-cloud movement between supported Azure services, the Azure integration runtime is usually the simplest and correct choice.`, `Für Cloud-zu-Cloud-Datenbewegung zwischen unterstützten Azure-Diensten ist die Azure Integration Runtime normalerweise die einfachste und richtige Wahl.`], [`Nothing in the scenario requires on-premises connectivity.`, `Nichts im Szenario erfordert Konnektivität zu lokalen Systemen.`], refs.adfIR),
    q('single', 'dp203-128', processing, 'easy', null, [`You must connect Azure Data Factory to an on-premises SQL Server that has no public endpoint. Which integration runtime should you deploy?`, `Sie müssen Azure Data Factory mit einem lokalen SQL Server verbinden, der keinen öffentlichen Endpunkt hat. Welche Integration Runtime sollten Sie bereitstellen?`], [['A', 'Azure integration runtime', 'Azure Integration Runtime'], ['B', 'Self-hosted integration runtime', 'Selbstgehostete Integration Runtime'], ['C', 'Serverless SQL runtime', 'Serverless-SQL-Runtime'], ['D', 'Stream Analytics runtime', 'Stream-Analytics-Runtime']], ['B'], [`A self-hosted integration runtime is designed for connectivity to private networks and on-premises data sources.`, `Eine selbstgehostete Integration Runtime ist für die Konnektivität zu privaten Netzwerken und lokalen Datenquellen vorgesehen.`], [`The service must reach a private on-premises endpoint.`, `Der Dienst muss einen privaten lokalen Endpunkt erreichen.`], refs.adfIR),
    q('single', 'dp203-129', processing, 'medium', null, [`You ingest hourly files and need contiguous, replayable time slices with dependency tracking between windows. Which trigger type is the best fit?`, `Sie laden stündliche Dateien und benötigen zusammenhängende, wiederholbare Zeitfenster mit Abhängigkeitsverfolgung zwischen den Fenstern. Welcher Triggertyp passt am besten?`], [['A', 'Schedule trigger', 'Zeitplantrigger'], ['B', 'Event trigger', 'Ereignistrigger'], ['C', 'Tumbling window trigger', 'Tumbling-Window-Trigger'], ['D', 'Manual trigger', 'Manueller Trigger']], ['C'], [`Tumbling window triggers are designed for continuous, contiguous time windows and support operational patterns such as retries and dependency handling.`, `Tumbling-Window-Trigger sind für kontinuierliche, zusammenhängende Zeitfenster ausgelegt und unterstützen Betriebsmodelle wie Wiederholungen und Abhängigkeitsbehandlung.`], [`The clue is replayable processing windows, not just a clock time.`, `Der Hinweis sind wiederholbare Verarbeitungsfenster und nicht nur eine Uhrzeit.`], refs.adfTriggers),
    q('single', 'dp203-130', processing, 'easy', null, [`A pipeline should start as soon as a new file lands in a specific storage container. Which trigger type should you choose?`, `Eine Pipeline soll starten, sobald eine neue Datei in einem bestimmten Storage-Container eingeht. Welchen Triggertyp sollten Sie wählen?`], [['A', 'Schedule trigger', 'Zeitplantrigger'], ['B', 'Tumbling window trigger', 'Tumbling-Window-Trigger'], ['C', 'Event trigger', 'Ereignistrigger'], ['D', 'Global parameter', 'Globalen Parameter']], ['C'], [`Event triggers react to storage events such as blob creation. They are better than polling on a fixed schedule when the goal is file-arrival automation.`, `Ereignistrigger reagieren auf Speicherereignisse wie die Erstellung von Blobs. Sie sind besser als Polling nach festem Zeitplan, wenn das Ziel die Automatisierung bei Dateieingang ist.`], [`The file arrival itself is the signal.`, `Der Dateieingang selbst ist das Signal.`], refs.adfTriggers),
    q('single', 'dp203-131', processing, 'medium', [`In a mapping data flow, a designer wants an expression like:
FullName = FirstName + ' ' + LastName`, `In einem Mapping Data Flow möchte ein Entwickler einen Ausdruck wie:
FullName = FirstName + ' ' + LastName`], [`In an ADF mapping data flow, which transformation should you use to create a new column such as FullName = FirstName + ' ' + LastName?`, `Welche Transformation sollten Sie in einem ADF Mapping Data Flow verwenden, um eine neue Spalte wie FullName = FirstName + ' ' + LastName zu erstellen?`], [['A', 'Derived Column', 'Derived Column'], ['B', 'Sink', 'Sink'], ['C', 'Lookup', 'Lookup'], ['D', 'Execute Pipeline', 'Execute Pipeline']], ['A'], [`Derived Column is the data flow transformation for creating or replacing column values with expressions.`, `Derived Column ist die Data-Flow-Transformation zum Erstellen oder Ersetzen von Spaltenwerten mit Ausdrücken.`], [`You are deriving a new value from existing columns.`, `Sie leiten einen neuen Wert aus vorhandenen Spalten ab.`], refs.adfDataFlow),
    q('single', 'dp203-132', processing, 'medium', [`A data flow contains rules such as:
ErrorCode == 0  -> validStream
ErrorCode != 0  -> rejectStream`, `Ein Data Flow enthält Regeln wie:
ErrorCode == 0  -> validStream
ErrorCode != 0  -> rejectStream`], [`You want to route valid rows to one sink and invalid rows to another sink in a mapping data flow. Which transformation is designed for this?`, `Sie möchten gültige Zeilen an einen Sink und ungültige Zeilen an einen anderen Sink weiterleiten. Welche Transformation ist dafür vorgesehen?`], [['A', 'Conditional Split', 'Conditional Split'], ['B', 'Surrogate Key', 'Surrogate Key'], ['C', 'Union', 'Union'], ['D', 'Window', 'Window']], ['A'], [`Conditional Split sends rows to different streams based on expressions. It is commonly used for good-record and bad-record routing.`, `Conditional Split sendet Zeilen abhängig von Ausdrücken an unterschiedliche Streams. Es wird häufig verwendet, um gute und fehlerhafte Datensätze zu trennen.`], [`One incoming stream becomes multiple output branches.`, `Ein eingehender Stream wird zu mehreren Ausgabeverzweigungen.`], refs.adfDataFlow),
    q('single', 'dp203-133', processing, 'easy', null, [`Which Synapse pipeline activity should you use to run a PySpark notebook?`, `Welche Synapse-Pipeline-Aktivität sollten Sie verwenden, um ein PySpark-Notebook auszuführen?`], [['A', 'Notebook activity', 'Notebook-Aktivität'], ['B', 'Delete activity', 'Delete-Aktivität'], ['C', 'Lookup activity', 'Lookup-Aktivität'], ['D', 'Validation activity', 'Validation-Aktivität']], ['A'], [`Notebook activity is the pipeline construct for executing Spark notebooks in Synapse.`, `Die Notebook-Aktivität ist das Pipelinekonstrukt zur Ausführung von Spark-Notebooks in Synapse.`], [`The task is notebook execution, not data movement.`, `Die Aufgabe ist die Ausführung eines Notebooks und nicht die Datenbewegung.`], refs.synapseSpark),
    q('single', 'dp203-134', processing, 'medium', null, [`A Databricks notebook runs every night as a production job and should use ephemeral compute that stops when the run finishes. Which cluster choice is best?`, `Ein Databricks-Notebook wird jede Nacht als Produktionsjob ausgeführt und soll kurzlebigen Compute verwenden, der nach Abschluss des Laufs stoppt. Welche Clusterwahl ist am besten?`], [['A', 'An all-purpose interactive cluster', 'Ein interaktiver All-Purpose-Cluster'], ['B', 'A job cluster', 'Ein Job-Cluster'], ['C', 'A serverless SQL pool', 'Ein serverloser SQL-Pool'], ['D', 'A self-hosted integration runtime', 'Eine selbstgehostete Integration Runtime']], ['B'], [`Job clusters are created for a run and terminated automatically when the job completes. That usually fits scheduled production workloads better than interactive clusters.`, `Job-Cluster werden für einen Lauf erstellt und nach Abschluss des Jobs automatisch beendet. Das passt normalerweise besser zu geplanten Produktionsworkloads als interaktive Cluster.`], [`Choose compute that exists only for the job run.`, `Wählen Sie Compute, das nur für den Joblauf existiert.`], refs.databricksClusters),
    q('single', 'dp203-135', processing, 'hard', [`A Delta Lake pipeline uses this command:
MERGE INTO target t
USING updates s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;`, `Eine Delta-Lake-Pipeline verwendet diesen Befehl:
MERGE INTO target t
USING updates s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;`], [`What is the primary purpose of this statement?`, `Was ist der Hauptzweck dieser Anweisung?`], [['A', 'Compact small files', 'Kleine Dateien verdichten'], ['B', 'Perform an atomic upsert', 'Ein atomares Upsert durchführen'], ['C', 'Drop duplicate columns', 'Doppelte Spalten entfernen'], ['D', 'Create a consumer group', 'Eine Consumer Group erstellen']], ['B'], [`MERGE INTO applies matched updates and unmatched inserts in one transactional operation. It is the standard Delta Lake upsert pattern.`, `MERGE INTO führt passende Updates und nicht passende Inserts in einer transaktionalen Operation aus. Es ist das Standardmuster für Upserts in Delta Lake.`], [`Look for update-plus-insert semantics.`, `Achten Sie auf die Semantik von Update plus Insert.`], refs.databricksMerge),
    q('single', 'dp203-136', processing, 'medium', [`A Structured Streaming job writes Delta output with the following option:
.writeStream
  .format('delta')
  .option('checkpointLocation', '/checkpoints/orders')`, `Ein Structured-Streaming-Job schreibt Delta-Ausgabe mit folgender Option:
.writeStream
  .format('delta')
  .option('checkpointLocation', '/checkpoints/orders')`], [`Why is the checkpoint location important?`, `Warum ist der Checkpoint-Speicherort wichtig?`], [['A', 'It stores streaming progress and state for recovery', 'Er speichert Streaming-Fortschritt und Zustand zur Wiederherstellung'], ['B', 'It encrypts the target table with TDE', 'Er verschlüsselt die Zieltabelle mit TDE'], ['C', 'It replaces the sink path', 'Er ersetzt den Sink-Pfad'], ['D', 'It creates a dedicated SQL pool', 'Er erstellt einen Dedicated SQL Pool']], ['A'], [`Structured Streaming checkpoints persist offsets and state so a query can resume correctly after restarts.`, `Checkpoints in Structured Streaming speichern Offsets und Zustand, sodass eine Abfrage nach Neustarts korrekt fortgesetzt werden kann.`], [`Streaming jobs need durable progress tracking.`, `Streaming-Jobs benötigen eine dauerhafte Nachverfolgung des Fortschritts.`], refs.databricksStreaming),
    q('single', 'dp203-137', processing, 'medium', null, [`You need one central governance layer for tables, permissions, and data discovery across Azure Databricks workspaces. Which feature should you use?`, `Sie benötigen eine zentrale Governance-Ebene für Tabellen, Berechtigungen und Datenermittlung über Azure-Databricks-Workspaces hinweg. Welche Funktion sollten Sie verwenden?`], [['A', 'Unity Catalog', 'Unity Catalog'], ['B', 'Consumer groups', 'Consumer Groups'], ['C', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['D', 'Always Encrypted', 'Always Encrypted']], ['A'], [`Unity Catalog provides centralized governance for data and AI assets in Databricks, including permissions and discovery.`, `Unity Catalog bietet zentrale Governance für Daten- und KI-Assets in Databricks, einschließlich Berechtigungen und Ermittlung.`], [`Think catalog and governance, not streaming.`, `Denken Sie an Katalog und Governance, nicht an Streaming.`], refs.unityCatalog),
    q('single', 'dp203-138', processing, 'medium', null, [`In Azure Databricks, which feature is designed to incrementally discover and ingest new files from cloud storage with minimal manual file listing logic?`, `Welche Funktion in Azure Databricks ist dafür vorgesehen, neue Dateien aus Cloud Storage inkrementell zu erkennen und mit minimaler manueller Dateilistungslogik aufzunehmen?`], [['A', 'Auto Loader', 'Auto Loader'], ['B', 'VACUUM', 'VACUUM'], ['C', 'Query Store', 'Query Store'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`Auto Loader is the Databricks pattern for scalable incremental file ingestion from cloud storage.`, `Auto Loader ist das Databricks-Muster für skalierbare inkrementelle Dateiaufnahme aus Cloud Storage.`], [`The goal is automated file discovery at scale.`, `Das Ziel ist die automatisierte Dateierkennung im großen Maßstab.`], refs.databricksStreaming),
    q('single', 'dp203-139', processing, 'hard', [`A Stream Analytics query contains:
SELECT DeviceId, AVG(Temperature) AS AvgTemp
INTO output
FROM input TIMESTAMP BY EventTime
GROUP BY DeviceId, TumblingWindow(minute, 5);`, `Eine Stream-Analytics-Abfrage enthält:
SELECT DeviceId, AVG(Temperature) AS AvgTemp
INTO output
FROM input TIMESTAMP BY EventTime
GROUP BY DeviceId, TumblingWindow(minute, 5);`], [`What kind of result windows does this query produce?`, `Welche Art von Ergebnisfenstern erzeugt diese Abfrage?`], [['A', 'Fixed non-overlapping 5-minute windows', 'Feste, sich nicht überlappende 5-Minuten-Fenster'], ['B', 'Overlapping windows every second', 'Sich überlappende Fenster jede Sekunde'], ['C', 'Windows based only on inactivity gaps', 'Fenster, die nur auf Inaktivitätslücken basieren'], ['D', 'A single global window for all time', 'Ein einzelnes globales Fenster für alle Zeiten']], ['A'], [`A tumbling window creates fixed-size, non-overlapping intervals. Each event belongs to exactly one 5-minute bucket.`, `Ein Tumbling Window erzeugt feste, sich nicht überlappende Intervalle. Jedes Ereignis gehört genau zu einem 5-Minuten-Bucket.`], [`Tumbling means no overlap.`, `Tumbling bedeutet keine Überlappung.`], refs.streamWindows),
    q('single', 'dp203-140', processing, 'hard', null, [`You need 10-minute windows that advance every 5 minutes so each event can contribute to more than one window. Which Stream Analytics window type should you use?`, `Sie benötigen 10-Minuten-Fenster, die sich alle 5 Minuten weiterbewegen, sodass jedes Ereignis zu mehr als einem Fenster beitragen kann. Welchen Fenstertyp in Stream Analytics sollten Sie verwenden?`], [['A', 'Tumbling', 'Tumbling'], ['B', 'Hopping', 'Hopping'], ['C', 'Session', 'Session'], ['D', 'Reference data', 'Referenzdaten']], ['B'], [`Hopping windows have a size and a hop step. When the hop is smaller than the window size, windows overlap.`, `Hopping Windows besitzen eine Größe und einen Hop-Schritt. Wenn der Hop kleiner ist als die Fenstergröße, überlappen sich die Fenster.`], [`You need overlap on a regular cadence.`, `Sie benötigen Überlappung in einem regelmäßigen Rhythmus.`], refs.streamWindows),
    q('single', 'dp203-141', processing, 'hard', null, [`You want a rolling 30-second calculation that emits updated results whenever events change the contents of that rolling period. Which Stream Analytics window type is the best match?`, `Sie möchten eine rollierende 30-Sekunden-Berechnung, die aktualisierte Ergebnisse ausgibt, sobald Ereignisse den Inhalt dieses rollierenden Zeitraums verändern. Welcher Fenstertyp in Stream Analytics passt am besten?`], [['A', 'Sliding', 'Sliding'], ['B', 'Tumbling', 'Tumbling'], ['C', 'Session', 'Session'], ['D', 'Snapshot', 'Snapshot']], ['A'], [`Sliding windows represent a moving interval and emit results as the window content changes.`, `Sliding Windows repräsentieren ein bewegliches Intervall und geben Ergebnisse aus, wenn sich der Fensterinhalt ändert.`], [`The requirement is a rolling window, not fixed buckets.`, `Die Anforderung ist ein rollierendes Fenster und keine festen Buckets.`], refs.streamWindows),
    q('single', 'dp203-142', processing, 'medium', null, [`You want to group clickstream events into sessions that end after 30 minutes of inactivity. Which window type should you use?`, `Sie möchten Clickstream-Ereignisse in Sitzungen gruppieren, die nach 30 Minuten Inaktivität enden. Welchen Fenstertyp sollten Sie verwenden?`], [['A', 'Session window', 'Session Window'], ['B', 'Hopping window', 'Hopping Window'], ['C', 'Tumbling window', 'Tumbling Window'], ['D', 'Archive window', 'Archive Window']], ['A'], [`Session windows are based on periods of activity separated by inactivity gaps.`, `Session Windows basieren auf Aktivitätsperioden, die durch Inaktivitätslücken getrennt sind.`], [`The boundary is inactivity, not the clock.`, `Die Grenze ist Inaktivität und nicht die Uhr.`], refs.streamWindows),
    q('single', 'dp203-143', processing, 'medium', null, [`A Stream Analytics job receives events that often arrive a few minutes late. Which configuration helps the job accept slightly delayed events instead of dropping them immediately?`, `Ein Stream-Analytics-Job empfängt Ereignisse, die oft einige Minuten zu spät ankommen. Welche Konfiguration hilft dem Job, leicht verspätete Ereignisse zu akzeptieren, statt sie sofort zu verwerfen?`], [['A', 'Late arrival tolerance', 'Toleranz für verspätetes Eintreffen'], ['B', 'Column-level security', 'Spaltenbezogene Sicherheit'], ['C', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['D', 'Archive rehydration', 'Archiv-Rehydrierung']], ['A'], [`Late arrival settings let Stream Analytics handle events that arrive after their event time. This is important for real-world streams with network delays.`, `Einstellungen für verspätetes Eintreffen erlauben Stream Analytics den Umgang mit Ereignissen, die nach ihrer Ereigniszeit eintreffen. Das ist für reale Streams mit Netzverzögerungen wichtig.`], [`Think event time versus arrival time.`, `Denken Sie an Ereigniszeit versus Ankunftszeit.`], refs.streamOrdering),
    q('single', 'dp203-144', processing, 'hard', [`A Spark Structured Streaming query uses:
.withWatermark('eventTime', '10 minutes')`, `Eine Spark-Structured-Streaming-Abfrage verwendet:
.withWatermark('eventTime', '10 minutes')`], [`What is the main purpose of the watermark?`, `Was ist der Hauptzweck des Watermarks?`], [['A', 'To bound how long the engine waits for late data in stateful operations', 'Zu begrenzen, wie lange die Engine bei zustandsbehafteten Operationen auf verspätete Daten wartet'], ['B', 'To replicate a table to all nodes', 'Eine Tabelle auf alle Knoten zu replizieren'], ['C', 'To encrypt streaming checkpoints', 'Streaming-Checkpoints zu verschlüsseln'], ['D', 'To create a consumer group', 'Eine Consumer Group zu erstellen']], ['A'], [`Watermarks help Structured Streaming manage state and lateness by defining how far behind event time data can arrive and still be considered.`, `Watermarks helfen Structured Streaming beim Zustand- und Verspätungsmanagement, indem sie definieren, wie weit hinter der Ereigniszeit Daten noch eintreffen dürfen und trotzdem berücksichtigt werden.`], [`This setting is about late data and state cleanup.`, `Diese Einstellung betrifft verspätete Daten und das Bereinigen des Zustands.`], refs.databricksStreaming),
    q('single', 'dp203-145', processing, 'easy', null, [`What do Event Hubs partitions primarily provide?`, `Was stellen Event-Hubs-Partitionen in erster Linie bereit?`], [['A', 'Parallelism and scale-out for event ingestion and reading', 'Parallelität und horizontale Skalierung für Ereignisaufnahme und -lesen'], ['B', 'Row-level security for consumers', 'Row-Level Security für Verbraucher'], ['C', 'Automatic Delta Lake compaction', 'Automatische Delta-Lake-Kompaktierung'], ['D', 'Transparent data encryption for SQL tables', 'Transparente Datenverschlüsselung für SQL-Tabellen']], ['A'], [`Partitions let Event Hubs spread events across multiple streams so producers and consumers can scale in parallel.`, `Partitionen ermöglichen es Event Hubs, Ereignisse auf mehrere Ströme zu verteilen, sodass Producer und Consumer parallel skalieren können.`], [`Think scale and parallel readers, not security.`, `Denken Sie an Skalierung und parallele Leser, nicht an Sicherheit.`], refs.eventHubs),
    q('single', 'dp203-146', processing, 'easy', null, [`Two downstream applications must read the same Event Hubs stream independently and maintain their own offsets. What should you configure?`, `Zwei nachgelagerte Anwendungen müssen denselben Event-Hubs-Stream unabhängig voneinander lesen und ihre eigenen Offsets verwalten. Was sollten Sie konfigurieren?`], [['A', 'Two consumer groups', 'Zwei Consumer Groups'], ['B', 'Two partitions with the same name', 'Zwei Partitionen mit demselben Namen'], ['C', 'A single watermark', 'Ein einzelnes Watermark'], ['D', 'A single linked service', 'Ein einzelnes Linked Service']], ['A'], [`Consumer groups give each application its own view of the stream and its own offset tracking.`, `Consumer Groups geben jeder Anwendung ihre eigene Sicht auf den Stream und ihre eigene Offsetverfolgung.`], [`Independent readers should not share the same offsets.`, `Unabhängige Leser sollten nicht dieselben Offsets teilen.`], refs.eventHubs),
    q('single', 'dp203-147', processing, 'medium', null, [`You want Event Hubs to automatically write a near-real-time archive of incoming events to Azure Data Lake Storage for batch replay. Which feature should you use?`, `Sie möchten, dass Event Hubs automatisch ein nahezu Echtzeitarchiv eingehender Ereignisse in Azure Data Lake Storage für Batch-Replay schreibt. Welche Funktion sollten Sie verwenden?`], [['A', 'Event Hubs Capture', 'Event Hubs Capture'], ['B', 'Query Store', 'Query Store'], ['C', 'Managed private endpoint', 'Managed Private Endpoint'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`Event Hubs Capture automatically lands events in storage for replay or downstream batch processing.`, `Event Hubs Capture schreibt Ereignisse automatisch in Storage für Replay oder nachgelagerte Batchverarbeitung.`], [`The clue is automatic archival to storage.`, `Der Hinweis ist die automatische Archivierung in Storage.`], refs.eventHubsCapture),
    q('single', 'dp203-148', processing, 'medium', null, [`You want producers and consumers to exchange Avro messages without embedding the full schema in every event. Which Event Hubs-related feature helps with this?`, `Sie möchten, dass Producer und Consumer Avro-Nachrichten austauschen, ohne in jedes Ereignis das vollständige Schema einzubetten. Welche zu Event Hubs gehörende Funktion hilft dabei?`], [['A', 'Schema Registry', 'Schema Registry'], ['B', 'Archive tier', 'Archive-Stufe'], ['C', 'Result-set caching', 'Result-Set-Caching'], ['D', 'Round-robin distribution', 'Round-Robin-Verteilung']], ['A'], [`Schema Registry stores schemas centrally and lets messages reference them efficiently, which is common with Avro serialization.`, `Schema Registry speichert Schemata zentral und lässt Nachrichten effizient darauf verweisen, was bei Avro-Serialisierung üblich ist.`], [`Think centralized schema management for event payloads.`, `Denken Sie an zentrales Schemamanagement für Ereignisnutzdaten.`], refs.schemaRegistry),
    q('single', 'dp203-149', processing, 'medium', [`A source database is configured with commands such as:
EXEC sys.sp_cdc_enable_db;
EXEC sys.sp_cdc_enable_table @source_schema = 'dbo', @source_name = 'Orders', @role_name = NULL;`, `Eine Quelldatenbank ist mit Befehlen wie diesen konfiguriert:
EXEC sys.sp_cdc_enable_db;
EXEC sys.sp_cdc_enable_table @source_schema = 'dbo', @source_name = 'Orders', @role_name = NULL;`], [`Which SQL feature reads changes from the transaction log and exposes inserts, updates, and deletes for downstream processing?`, `Welche SQL-Funktion liest Änderungen aus dem Transaktionsprotokoll und stellt Inserts, Updates und Deletes für die nachgelagerte Verarbeitung bereit?`], [['A', 'Change Data Capture', 'Change Data Capture'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Transparent data encryption', 'Transparente Datenverschlüsselung'], ['D', 'Columnstore indexing', 'Columnstore-Indizierung']], ['A'], [`CDC records data changes from the transaction log so pipelines can consume incremental inserts, updates, and deletes.`, `CDC erfasst Datenänderungen aus dem Transaktionsprotokoll, sodass Pipelines inkrementelle Inserts, Updates und Deletes verarbeiten können.`], [`This feature is about change streams, not security.`, `Diese Funktion betrifft Änderungsströme und nicht Sicherheit.`], refs.sqlCdc),
    q('single', 'dp203-150', processing, 'medium', null, [`What is Debezium primarily used for?`, `Wofür wird Debezium in erster Linie verwendet?`], [['A', 'Capturing database changes and publishing them as events', 'Datenbankänderungen erfassen und als Ereignisse veröffentlichen'], ['B', 'Encrypting data at rest in Azure SQL', 'Daten im Ruhezustand in Azure SQL verschlüsseln'], ['C', 'Creating Spark clusters in Synapse', 'Spark-Cluster in Synapse erstellen'], ['D', 'Applying dynamic data masking to lake files', 'Dynamische Datenmaskierung auf Lake-Dateien anwenden']], ['A'], [`Debezium is a CDC platform that reads database logs and publishes change events, often to Kafka.`, `Debezium ist eine CDC-Plattform, die Datenbankprotokolle liest und Änderungsereignisse veröffentlicht, oft nach Kafka.`], [`It turns database commits into event streams.`, `Es wandelt Datenbank-Commits in Ereignisströme um.`], refs.debezium),
    q('single', 'dp203-151', processing, 'medium', null, [`You load raw data into Synapse first and then use SQL and Spark in the target platform to perform most transformations. Which pattern does this describe?`, `Sie laden Rohdaten zuerst in Synapse und verwenden dann SQL und Spark in der Zielplattform für die meisten Transformationen. Welches Muster beschreibt dies?`], [['A', 'ELT', 'ELT'], ['B', 'ETL', 'ETL'], ['C', 'RLS', 'RLS'], ['D', 'TDE', 'TDE']], ['A'], [`ELT means extract, load, then transform in the target platform. It is common in cloud analytics systems with scalable engines.`, `ELT bedeutet Extract, Load, dann Transform in der Zielplattform. Es ist in Cloud-Analysesystemen mit skalierbaren Engines üblich.`], [`The data is loaded before major transformations happen.`, `Die Daten werden geladen, bevor wesentliche Transformationen stattfinden.`], refs.synapseSpark),
    q('single', 'dp203-152', processing, 'hard', [`A serverless SQL analyst runs:
SELECT COUNT(*)
FROM OPENROWSET(
    BULK 'https://contoso.dfs.core.windows.net/curated/orders/year=2025/month=05/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`, `Ein Analyst in serverlosem SQL führt aus:
SELECT COUNT(*)
FROM OPENROWSET(
    BULK 'https://contoso.dfs.core.windows.net/curated/orders/year=2025/month=05/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`], [`Which Synapse engine executes this without loading the data into dedicated tables first?`, `Welche Synapse-Engine führt dies aus, ohne die Daten zuerst in Dedicated-Tabellen zu laden?`], [['A', 'Serverless SQL pool', 'Serverloser SQL-Pool'], ['B', 'Dedicated SQL pool only', 'Nur Dedicated SQL Pool'], ['C', 'Spark pool only', 'Nur Spark-Pool'], ['D', 'Integration runtime', 'Integration Runtime']], ['A'], [`OPENROWSET over lake files is a core serverless SQL pattern. It provides on-demand querying without preloading into warehouse tables.`, `OPENROWSET über Lake-Dateien ist ein Kernmuster von serverlosem SQL. Es ermöglicht bedarfsgesteuerte Abfragen ohne Vorabladen in Warehousetabellen.`], [`No ingestion step appears before the query.`, `Vor der Abfrage ist kein Ingestionsschritt zu sehen.`], refs.synapseServerless),
    q('single', 'dp203-153', processing, 'medium', [`A dedicated SQL pool contains an empty target table dbo.StageSales. You need to load CSV files from ADLS Gen2 with minimal setup and without defining external tables. Which statement family is designed for this?`, `Ein Dedicated SQL Pool enthält die leere Zieltabelle dbo.StageSales. Sie müssen CSV-Dateien aus ADLS Gen2 mit minimalem Setup und ohne Definition externer Tabellen laden. Welche Anweisungsfamilie ist dafür vorgesehen?`], [`Choose the best answer.`, `Wählen Sie die beste Antwort.`], [['A', 'COPY INTO', 'COPY INTO'], ['B', 'CETAS', 'CETAS'], ['C', 'VACUUM', 'VACUUM'], ['D', 'Session window', 'Session Window']], ['A'], [`COPY INTO is intended for loading files directly into dedicated SQL pool tables with relatively little supporting setup compared to PolyBase-style external objects.`, `COPY INTO ist dafür vorgesehen, Dateien mit relativ wenig zusätzlichem Setup direkt in Tabellen eines Dedicated SQL Pools zu laden, verglichen mit PolyBase-ähnlichen externen Objekten.`], [`This option was designed to simplify file loading into dedicated tables.`, `Diese Option wurde entwickelt, um das Laden von Dateien in Dedicated-Tabellen zu vereinfachen.`], refs.synapseCopy),
    q('single', 'dp203-154', processing, 'medium', [`After loading staging rows, the pipeline must run SQL like:
EXEC dbo.usp_MergeSales;`, `Nach dem Laden von Staging-Zeilen muss die Pipeline SQL wie folgt ausführen:
EXEC dbo.usp_MergeSales;`], [`After a Copy activity loads rows into a staging table, you need to execute a stored procedure that merges them into the warehouse. Which pipeline activity is the best fit?`, `Nachdem eine Copy-Aktivität Zeilen in eine Staging-Tabelle geladen hat, müssen Sie eine Stored Procedure ausführen, die sie in das Warehouse merged. Welche Pipeline-Aktivität passt am besten?`], [['A', 'Stored Procedure or Script activity', 'Stored-Procedure- oder Script-Aktivität'], ['B', 'Delete activity', 'Delete-Aktivität'], ['C', 'Validation activity', 'Validation-Aktivität'], ['D', 'Event trigger', 'Ereignistrigger']], ['A'], [`A stored procedure or script activity is designed to execute SQL logic after a data movement step.`, `Eine Stored-Procedure- oder Script-Aktivität ist dafür vorgesehen, SQL-Logik nach einem Datenbewegungsschritt auszuführen.`], [`You need post-copy SQL execution.`, `Sie benötigen die Ausführung von SQL nach dem Kopieren.`], refs.adfControlFlow),
    q('single', 'dp203-155', processing, 'medium', null, [`You have a list of 200 files and want an ADF pipeline to process them in parallel. Which activity is typically used together with a batch count setting?`, `Sie haben eine Liste mit 200 Dateien und möchten, dass eine ADF-Pipeline sie parallel verarbeitet. Welche Aktivität wird typischerweise zusammen mit einer Batch-Count-Einstellung verwendet?`], [['A', 'ForEach', 'ForEach'], ['B', 'Until', 'Until'], ['C', 'Lookup', 'Lookup'], ['D', 'Validation', 'Validation']], ['A'], [`ForEach iterates over a collection, and its batch count controls parallel execution.`, `ForEach iteriert über eine Sammlung, und sein Batch Count steuert die parallele Ausführung.`], [`You already have a collection of items to iterate over.`, `Sie haben bereits eine Sammlung von Elementen, über die iteriert werden soll.`], refs.adfControlFlow),
    q('single', 'dp203-156', processing, 'medium', null, [`A REST API starts a long-running export job and returns a status URL that must be polled until the job finishes. Which ADF control-flow activity is best for this looping pattern?`, `Eine REST-API startet einen langlaufenden Exportjob und liefert eine Status-URL zurück, die bis zum Abschluss des Jobs abgefragt werden muss. Welche ADF-Control-Flow-Aktivität eignet sich am besten für dieses Schleifenmuster?`], [['A', 'Until', 'Until'], ['B', 'Delete', 'Delete'], ['C', 'Surrogate Key', 'Surrogate Key'], ['D', 'Conditional Split', 'Conditional Split']], ['A'], [`Until repeats child activities until a condition becomes true, which fits polling scenarios.`, `Until wiederholt untergeordnete Aktivitäten, bis eine Bedingung wahr wird, was gut zu Polling-Szenarien passt.`], [`You need a condition-based loop.`, `Sie benötigen eine bedingungsbasierte Schleife.`], refs.adfControlFlow),
    q('single', 'dp203-157', processing, 'easy', null, [`In ADF, what does a dataset primarily describe?`, `Was beschreibt ein Dataset in ADF in erster Linie?`], [['A', 'The structure and location of data to read or write', 'Die Struktur und den Speicherort von zu lesenden oder zu schreibenden Daten'], ['B', 'The RBAC roles for a storage account', 'Die RBAC-Rollen für ein Speicherkonto'], ['C', 'The Spark cluster size', 'Die Größe des Spark-Clusters'], ['D', 'The pricing tier of Event Hubs', 'Die Preisstufe von Event Hubs']], ['A'], [`A dataset defines what data looks like and where it is, while the linked service defines how to connect.`, `Ein Dataset definiert, wie Daten aussehen und wo sie liegen, während das Linked Service definiert, wie die Verbindung hergestellt wird.`], [`Dataset is data metadata, not connectivity metadata.`, `Dataset bedeutet Datenmetadaten und nicht Verbindungsmetadaten.`], refs.adfParameters),
    q('single', 'dp203-158', processing, 'hard', [`An ADF dynamic content expression contains:
@pipeline().parameters.TargetTable`, `Ein ADF-Dynamic-Content-Ausdruck enthält:
@pipeline().parameters.TargetTable`], [`What does this expression reference?`, `Worauf verweist dieser Ausdruck?`], [['A', 'A pipeline parameter named TargetTable', 'Auf einen Pipelineparameter namens TargetTable'], ['B', 'A dataset parameter named TargetTable', 'Auf einen Datasetparameter namens TargetTable'], ['C', 'A global parameter named TargetTable', 'Auf einen globalen Parameter namens TargetTable'], ['D', 'A Spark variable named TargetTable', 'Auf eine Spark-Variable namens TargetTable']], ['A'], [`The expression pipeline().parameters.X accesses a pipeline parameter. Dataset and global parameters use different expression scopes.`, `Der Ausdruck pipeline().parameters.X greift auf einen Pipelineparameter zu. Dataset- und globale Parameter verwenden andere Ausdrucksbereiche.`], [`Read the object path literally.`, `Lesen Sie den Objektpfad wörtlich.`], refs.adfParameters),
    q('single', 'dp203-159', processing, 'medium', null, [`You want a Synapse or ADF pipeline to pass values such as LoadDate and Region into a Databricks notebook at runtime. Which capability should you use?`, `Sie möchten, dass eine Synapse- oder ADF-Pipeline Werte wie LoadDate und Region zur Laufzeit an ein Databricks-Notebook übergibt. Welche Funktion sollten Sie verwenden?`], [['A', 'Notebook base parameters or widgets', 'Notebook-Basisparameter oder Widgets'], ['B', 'Archive rehydration', 'Archiv-Rehydrierung'], ['C', 'Consumer groups', 'Consumer Groups'], ['D', 'Column-level security', 'Spaltenbezogene Sicherheit']], ['A'], [`Pipelines can pass key-value parameters to notebooks, and notebook widgets are a common way to consume them.`, `Pipelines können Schlüssel-Wert-Parameter an Notebooks übergeben, und Notebook-Widgets sind ein gängiger Weg, diese zu verwenden.`], [`The notebook must receive runtime inputs from orchestration.`, `Das Notebook muss Laufzeitparameter aus der Orchestrierung erhalten.`], refs.databricksClusters),
    q('single', 'dp203-160', processing, 'hard', [`A Spark notebook executes:
CREATE TABLE sales_ext
USING PARQUET
LOCATION 'abfss://curated@contoso.dfs.core.windows.net/sales/';`, `Ein Spark-Notebook führt aus:
CREATE TABLE sales_ext
USING PARQUET
LOCATION 'abfss://curated@contoso.dfs.core.windows.net/sales/';`], [`What is the effect of this statement?`, `Welche Auswirkung hat diese Anweisung?`], [['A', 'It registers existing lake files as a table', 'Sie registriert vorhandene Lake-Dateien als Tabelle'], ['B', 'It copies the files into a dedicated SQL pool', 'Sie kopiert die Dateien in einen Dedicated SQL Pool'], ['C', 'It turns the files into an Event Hubs stream', 'Sie wandelt die Dateien in einen Event-Hubs-Stream um'], ['D', 'It enables TDE on storage', 'Sie aktiviert TDE für Storage']], ['A'], [`CREATE TABLE USING ... LOCATION in Spark registers data at an external path as a table that can be queried.`, `CREATE TABLE USING ... LOCATION in Spark registriert Daten an einem externen Pfad als Tabelle, die abgefragt werden kann.`], [`The data already exists in the lake path.`, `Die Daten liegen bereits im Lake-Pfad.`], refs.synapseSpark),
    q('single', 'dp203-161', processing, 'hard', [`A Delta table was created with Change Data Feed enabled. What does this feature allow downstream jobs to do?`, `Eine Delta-Tabelle wurde mit aktiviertem Change Data Feed erstellt. Was erlaubt diese Funktion nachgelagerten Jobs?`], [['A', 'Read row-level changes between table versions', 'Zeilenbezogene Änderungen zwischen Tabellenversionen lesen'], ['B', 'Encrypt columns with Always Encrypted', 'Spalten mit Always Encrypted verschlüsseln'], ['C', 'Create consumer groups', 'Consumer Groups erstellen'], ['D', 'Convert batch jobs into tumbling windows', 'Batchjobs in Tumbling Windows umwandeln']], ['A'], [`Delta Change Data Feed exposes inserts, updates, and deletes between versions, which is useful for incremental downstream processing.`, `Delta Change Data Feed stellt Inserts, Updates und Deletes zwischen Versionen bereit, was für inkrementelle nachgelagerte Verarbeitung nützlich ist.`], [`This is about incremental change consumption from Delta.`, `Es geht um den inkrementellen Konsum von Änderungen aus Delta.`], refs.databricksDelta),
    q('single', 'dp203-162', processing, 'medium', null, [`Why would you set a partition key such as DeviceId when publishing events to Event Hubs?`, `Warum würden Sie beim Veröffentlichen von Ereignissen in Event Hubs einen Partitionsschlüssel wie DeviceId setzen?`], [['A', 'To help preserve event order for the same key within a partition', 'Um die Ereignisreihenfolge für denselben Schlüssel innerhalb einer Partition zu erhalten'], ['B', 'To encrypt the event body', 'Um den Ereigniskörper zu verschlüsseln'], ['C', 'To create more consumer groups', 'Um mehr Consumer Groups zu erstellen'], ['D', 'To avoid the need for offsets', 'Um den Bedarf an Offsets zu vermeiden']], ['A'], [`Events with the same partition key are routed to the same partition, which helps preserve their order relative to each other.`, `Ereignisse mit demselben Partitionsschlüssel werden in dieselbe Partition geleitet, was hilft, ihre Reihenfolge zueinander zu erhalten.`], [`The goal is ordering, not security.`, `Das Ziel ist Reihenfolge und nicht Sicherheit.`], refs.eventHubs),
    q('single', 'dp203-163', processing, 'easy', null, [`In a bronze-silver-gold or raw-enriched-curated pattern, which layer usually contains cleaned, validated, and conformed data that is not yet fully presentation-ready?`, `Welche Schicht enthält in einem Bronze-Silver-Gold- oder Raw-Enriched-Curated-Muster normalerweise bereinigte, validierte und harmonisierte Daten, die noch nicht vollständig präsentationsbereit sind?`], [['A', 'Bronze or raw', 'Bronze oder Raw'], ['B', 'Silver or enriched', 'Silver oder Enriched'], ['C', 'Gold or curated', 'Gold oder Curated'], ['D', 'Archive', 'Archiv']], ['B'], [`The silver or enriched layer is commonly used for cleansed and standardized data before final business-oriented serving models are produced.`, `Die Silver- oder Enriched-Schicht wird üblicherweise für bereinigte und standardisierte Daten verwendet, bevor endgültige fachorientierte Bereitstellungsmodelle erzeugt werden.`], [`This layer sits between landing and business-ready serving.`, `Diese Schicht liegt zwischen Landing und fachlich aufbereiteter Bereitstellung.`], refs.databricksDelta),
    q('single', 'dp203-164', processing, 'hard', null, [`In an ADF mapping data flow, which transformation marks rows for insert, update, delete, or upsert behavior at the sink?`, `Welche Transformation markiert in einem ADF Mapping Data Flow Zeilen für Insert-, Update-, Delete- oder Upsert-Verhalten am Sink?`], [['A', 'Alter Row', 'Alter Row'], ['B', 'Window', 'Window'], ['C', 'Lookup', 'Lookup'], ['D', 'Derived Column', 'Derived Column']], ['A'], [`Alter Row defines row policies that the sink can apply as inserts, updates, deletes, or upserts.`, `Alter Row definiert Zeilenrichtlinien, die der Sink als Inserts, Updates, Deletes oder Upserts anwenden kann.`], [`The transformation decides the row action, not the column expression.`, `Die Transformation entscheidet über die Zeilenaktion und nicht über den Spaltenausdruck.`], refs.adfDataFlow),
    q('single', 'dp203-165', processing, 'medium', [`A dedicated SQL engineer wants to load daily CSV files from ADLS with a statement simpler than PolyBase and without defining external tables. The load target already exists. Which T-SQL command family best fits?`, `Ein Ingenieur für Dedicated SQL möchte tägliche CSV-Dateien aus ADLS mit einer einfacheren Anweisung als PolyBase und ohne Definition externer Tabellen laden. Das Ladeziel existiert bereits. Welche T-SQL-Befehlsfamilie passt am besten?`], [`Choose the best answer.`, `Wählen Sie die beste Antwort.`], [['A', 'COPY INTO', 'COPY INTO'], ['B', 'CETAS', 'CETAS'], ['C', 'OPENJSON', 'OPENJSON'], ['D', 'VACUUM', 'VACUUM']], ['A'], [`COPY INTO was introduced to simplify common loading scenarios into existing dedicated SQL pool tables.`, `COPY INTO wurde eingeführt, um gängige Ladeszenarien in vorhandene Tabellen eines Dedicated SQL Pools zu vereinfachen.`], [`You already have the target table and want minimal setup.`, `Sie haben die Zieltabelle bereits und möchten minimales Setup.`], refs.synapseCopy),
    q('single', 'dp203-166', processing, 'medium', null, [`When is ETL usually preferable to ELT?`, `Wann ist ETL normalerweise ELT vorzuziehen?`], [['A', 'When data must be heavily transformed or filtered before landing in the target platform', 'Wenn Daten stark transformiert oder gefiltert werden müssen, bevor sie in der Zielplattform landen'], ['B', 'When you want to use scalable cloud compute in the target', 'Wenn Sie skalierbaren Cloud-Compute in der Zielplattform nutzen möchten'], ['C', 'When the target system is ideal for large transformations', 'Wenn das Zielsystem ideal für große Transformationen ist'], ['D', 'When you specifically want raw data first for replay', 'Wenn Sie ausdrücklich zuerst Rohdaten für Replay möchten']], ['A'], [`ETL is often chosen when transformations must happen before data reaches the target, for example to reduce volume, enforce strict rules, or protect sensitive data earlier.`, `ETL wird häufig gewählt, wenn Transformationen stattfinden müssen, bevor Daten das Ziel erreichen, zum Beispiel um Volumen zu reduzieren, strikte Regeln durchzusetzen oder sensible Daten früher zu schützen.`], [`Transform before load is the defining clue.`, `Transform vor Load ist der entscheidende Hinweis.`], refs.synapseSpark),
    q('single', 'dp203-167', security, 'hard', [`A dedicated SQL pool contains this security predicate pattern:
CREATE FUNCTION sec.fn_regionPredicate(@Region AS nvarchar(50))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN SELECT 1 AS fn_result
WHERE @Region = USER_NAME();`, `Ein Dedicated SQL Pool enthält dieses Muster für ein Sicherheitsprädikat:
CREATE FUNCTION sec.fn_regionPredicate(@Region AS nvarchar(50))
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN SELECT 1 AS fn_result
WHERE @Region = USER_NAME();`], [`What is this function typically used for?`, `Wofür wird diese Funktion typischerweise verwendet?`], [['A', 'Row-level security filtering', 'Row-Level-Security-Filterung'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Transparent data encryption', 'Transparente Datenverschlüsselung'], ['D', 'Result-set caching', 'Result-Set-Caching']], ['A'], [`Inline table-valued predicate functions are a core building block of row-level security. They determine which rows a principal can see.`, `Inline-Tabellenwertfunktionen für Prädikate sind ein Kernbaustein von Row-Level Security. Sie bestimmen, welche Zeilen ein Prinzipal sehen kann.`], [`The function filters rows, not columns or files.`, `Die Funktion filtert Zeilen und nicht Spalten oder Dateien.`], refs.rowLevelSecurity),
    q('single', 'dp203-168', security, 'hard', [`A database administrator executes:
GRANT SELECT (CustomerId, CustomerName, City) ON dbo.Customers TO AnalystRole;
DENY SELECT ON dbo.Customers(SSN) TO AnalystRole;`, `Ein Datenbankadministrator führt aus:
GRANT SELECT (CustomerId, CustomerName, City) ON dbo.Customers TO AnalystRole;
DENY SELECT ON dbo.Customers(SSN) TO AnalystRole;`], [`What security technique is being applied?`, `Welche Sicherheitstechnik wird angewendet?`], [['A', 'Column-level security', 'Spaltenbezogene Sicherheit'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['D', 'Transparent data encryption', 'Transparente Datenverschlüsselung']], ['A'], [`Granting or denying access to specific columns is column-level security. It limits visibility at the column granularity.`, `Das Gewähren oder Verweigern des Zugriffs auf bestimmte Spalten ist spaltenbezogene Sicherheit. Sie begrenzt die Sichtbarkeit auf Spaltenebene.`], [`Permissions are being assigned to some columns and denied to another.`, `Berechtigungen werden einigen Spalten zugewiesen und einer anderen verweigert.`], refs.columnSecurity),
    q('single', 'dp203-169', security, 'medium', null, [`What is the main purpose of dynamic data masking?`, `Was ist der Hauptzweck der dynamischen Datenmaskierung?`], [['A', 'Obfuscate sensitive values in query results for non-privileged users', 'Sensible Werte in Abfrageergebnissen für nicht privilegierte Benutzer verschleiern'], ['B', 'Encrypt data at rest in storage', 'Daten im Ruhezustand im Speicher verschlüsseln'], ['C', 'Filter rows by region', 'Zeilen nach Region filtern'], ['D', 'Create a private endpoint', 'Einen Private Endpoint erstellen']], ['A'], [`Dynamic data masking hides sensitive data in result sets for certain users, but it is not a substitute for encryption or full access control.`, `Dynamische Datenmaskierung verbirgt sensible Daten in Resultsets für bestimmte Benutzer, ist aber kein Ersatz für Verschlüsselung oder vollständige Zugriffskontrolle.`], [`Masking changes how values appear, not how they are stored.`, `Maskierung ändert, wie Werte erscheinen, nicht wie sie gespeichert werden.`], refs.ddm),
    q('single', 'dp203-170', security, 'medium', null, [`Which statement best describes Always Encrypted?`, `Welche Aussage beschreibt Always Encrypted am besten?`], [['A', 'Sensitive data is encrypted so the database engine does not see plaintext values for protected columns', 'Sensible Daten werden so verschlüsselt, dass die Datenbank-Engine für geschützte Spalten keine Klartextwerte sieht'], ['B', 'It only masks values in query results', 'Es maskiert Werte nur in Abfrageergebnissen'], ['C', 'It only encrypts backups', 'Es verschlüsselt nur Backups'], ['D', 'It only works for Parquet files', 'Es funktioniert nur für Parquet-Dateien']], ['A'], [`Always Encrypted protects sensitive column values end to end. Encryption and decryption are handled by the client driver, not by the database engine.`, `Always Encrypted schützt sensible Spaltenwerte Ende zu Ende. Verschlüsselung und Entschlüsselung werden vom Clienttreiber und nicht von der Datenbank-Engine durchgeführt.`], [`The database should not see plaintext for those columns.`, `Die Datenbank soll für diese Spalten keinen Klartext sehen.`], refs.alwaysEncrypted),
    q('single', 'dp203-171', security, 'easy', null, [`Which feature encrypts Azure SQL database files at rest, including data files, log files, and backups?`, `Welche Funktion verschlüsselt Azure-SQL-Datenbankdateien im Ruhezustand, einschließlich Datendateien, Protokolldateien und Backups?`], [['A', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['B', 'Dynamic Data Masking', 'Dynamic Data Masking'], ['C', 'Consumer Groups', 'Consumer Groups'], ['D', 'Session Windows', 'Session Windows']], ['A'], [`TDE encrypts data at rest. It is different from Always Encrypted, which protects column values from the database engine itself.`, `TDE verschlüsselt Daten im Ruhezustand. Es unterscheidet sich von Always Encrypted, das Spaltenwerte vor der Datenbank-Engine selbst schützt.`], [`This control is about files at rest.`, `Diese Kontrolle betrifft Dateien im Ruhezustand.`], refs.tde),
    q('single', 'dp203-172', security, 'medium', null, [`An Azure Data Factory managed identity must write output files to Azure Data Lake Storage Gen2. Which RBAC role on the target container or account is typically required?`, `Eine verwaltete Identität von Azure Data Factory muss Ausgabedateien in Azure Data Lake Storage Gen2 schreiben. Welche RBAC-Rolle auf dem Zielcontainer oder -konto wird typischerweise benötigt?`], [['A', 'Storage Blob Data Reader', 'Storage Blob Data Reader'], ['B', 'Storage Blob Data Contributor', 'Storage Blob Data Contributor'], ['C', 'Reader', 'Reader'], ['D', 'Cost Management Contributor', 'Cost Management Contributor']], ['B'], [`Writing blobs requires a data-plane role that allows create and modify operations, such as Storage Blob Data Contributor.`, `Das Schreiben von Blobs erfordert eine Datenebenenrolle, die Erstellen- und Änderungsoperationen erlaubt, etwa Storage Blob Data Contributor.`], [`The identity must write, not just read.`, `Die Identität muss schreiben und nicht nur lesen.`], refs.managedIdentity),
    q('single', 'dp203-173', security, 'medium', null, [`You want linked services to reference secrets without storing plain credentials in ADF or Synapse JSON definitions. Which Azure service should hold those secrets?`, `Sie möchten, dass Linked Services auf Geheimnisse verweisen, ohne Klartextanmeldeinformationen in ADF- oder Synapse-JSON-Definitionen zu speichern. Welcher Azure-Dienst sollte diese Geheimnisse speichern?`], [['A', 'Azure Key Vault', 'Azure Key Vault'], ['B', 'Event Hubs', 'Event Hubs'], ['C', 'Azure Stream Analytics', 'Azure Stream Analytics'], ['D', 'Query Store', 'Query Store']], ['A'], [`Azure Key Vault is the standard place to store secrets, keys, and certificates for linked service integration.`, `Azure Key Vault ist der Standardort zum Speichern von Geheimnissen, Schlüsseln und Zertifikaten für die Integration von Linked Services.`], [`The goal is secret management outside the pipeline definition.`, `Das Ziel ist die Geheimnisverwaltung außerhalb der Pipeline-Definition.`], refs.keyVault),
    q('single', 'dp203-174', security, 'medium', null, [`What is the main benefit of enabling a Synapse workspace managed virtual network?`, `Was ist der Hauptvorteil des Aktivierens eines verwalteten virtuellen Netzwerks für einen Synapse-Workspace?`], [['A', 'It provides an isolated managed network boundary for Synapse resources and private connectivity patterns', 'Es stellt eine isolierte verwaltete Netzwerkgrenze für Synapse-Ressourcen und private Konnektivitätsmuster bereit'], ['B', 'It automatically creates Delta Lake tables', 'Es erstellt automatisch Delta-Lake-Tabellen'], ['C', 'It changes round-robin tables into hash tables', 'Es wandelt Round-Robin-Tabellen in Hash-Tabellen um'], ['D', 'It replaces RBAC', 'Es ersetzt RBAC']], ['A'], [`A managed VNet helps secure data movement and compute by placing Synapse-managed resources inside an isolated network boundary.`, `Ein verwaltetes VNet hilft, Datenbewegung und Compute zu sichern, indem Synapse-verwaltete Ressourcen innerhalb einer isolierten Netzwerkgrenze platziert werden.`], [`This feature is about network isolation, not SQL tuning.`, `Diese Funktion betrifft Netzwerktrennung und nicht SQL-Tuning.`], refs.managedVnet),
    q('single', 'dp203-175', security, 'medium', null, [`Your Synapse workspace must reach an Azure Storage account privately over the Microsoft backbone without exposing a public endpoint. Which feature should you create?`, `Ihr Synapse-Workspace muss ein Azure-Storage-Konto privat über das Microsoft-Backbone erreichen, ohne einen öffentlichen Endpunkt offenzulegen. Welche Funktion sollten Sie erstellen?`], [['A', 'A managed private endpoint', 'Einen Managed Private Endpoint'], ['B', 'A tumbling window trigger', 'Einen Tumbling-Window-Trigger'], ['C', 'A result-set cache', 'Einen Result-Set-Cache'], ['D', 'A columnstore index', 'Einen Columnstore-Index']], ['A'], [`Managed private endpoints provide private connectivity from Synapse managed networks to supported Azure services.`, `Managed Private Endpoints bieten private Konnektivität von verwalteten Synapse-Netzwerken zu unterstützten Azure-Diensten.`], [`You need private network access to a PaaS service.`, `Sie benötigen privaten Netzwerkzugriff auf einen PaaS-Dienst.`], refs.managedVnet),
    q('single', 'dp203-176', security, 'hard', [`You execute this query in a dedicated SQL pool:
SELECT request_id, status, command, total_elapsed_time
FROM sys.dm_pdw_exec_requests
ORDER BY submit_time DESC;`, `Sie führen diese Abfrage in einem Dedicated SQL Pool aus:
SELECT request_id, status, command, total_elapsed_time
FROM sys.dm_pdw_exec_requests
ORDER BY submit_time DESC;`], [`What are you monitoring?`, `Was überwachen Sie damit?`], [['A', 'Dedicated SQL query requests and their status', 'Abfrageanforderungen des Dedicated SQL Pools und deren Status'], ['B', 'ADF trigger definitions', 'ADF-Triggerdefinitionen'], ['C', 'Event Hubs consumer groups', 'Consumer Groups von Event Hubs'], ['D', 'Key Vault access policies', 'Key-Vault-Zugriffsrichtlinien']], ['A'], [`sys.dm_pdw_exec_requests shows request-level execution information for dedicated SQL pool queries and commands.`, `sys.dm_pdw_exec_requests zeigt Informationen auf Anforderungsebene für Abfragen und Befehle im Dedicated SQL Pool.`], [`The DMV name points to execution requests.`, `Der DMV-Name weist auf Ausführungsanforderungen hin.`], refs.synapseMonitor),
    q('single', 'dp203-177', security, 'hard', [`You run:
SELECT request_id, step_index, operation_type, location_type, status
FROM sys.dm_pdw_request_steps
WHERE request_id = 'QID123';`, `Sie führen aus:
SELECT request_id, step_index, operation_type, location_type, status
FROM sys.dm_pdw_request_steps
WHERE request_id = 'QID123';`], [`What insight does this DMV provide?`, `Welche Einsicht liefert dieser DMV?`], [['A', 'The detailed steps of a dedicated SQL request, including data movement operations', 'Die detaillierten Schritte einer Dedicated-SQL-Anforderung, einschließlich Datenbewegungsoperationen'], ['B', 'The list of masked columns in a table', 'Die Liste maskierter Spalten in einer Tabelle'], ['C', 'The list of consumer offsets', 'Die Liste von Consumer-Offets'], ['D', 'The Azure billing invoice', 'Die Azure-Abrechnung']], ['A'], [`sys.dm_pdw_request_steps shows the internal steps of a dedicated SQL request. It is useful for diagnosing shuffles and data movement.`, `sys.dm_pdw_request_steps zeigt die internen Schritte einer Dedicated-SQL-Anforderung. Er ist nützlich, um Shuffles und Datenbewegungen zu diagnostizieren.`], [`You want step-level details, not just request-level status.`, `Sie möchten Details auf Schrittebene und nicht nur Status auf Anforderungsebene.`], refs.synapseMonitor),
    q('single', 'dp203-178', security, 'medium', null, [`You want to identify regressed query plans and compare runtime statistics over time in Azure SQL Database. Which feature should you use?`, `Sie möchten regressierte Abfragepläne identifizieren und Laufzeitstatistiken im Zeitverlauf in Azure SQL Database vergleichen. Welche Funktion sollten Sie verwenden?`], [['A', 'Query Store', 'Query Store'], ['B', 'Archive tier', 'Archive-Stufe'], ['C', 'Session window', 'Session Window'], ['D', 'Schema Registry', 'Schema Registry']], ['A'], [`Query Store captures query texts, plans, and runtime statistics over time. It is designed for plan regression analysis and troubleshooting.`, `Query Store erfasst Abfragetexte, Pläne und Laufzeitstatistiken im Zeitverlauf. Er ist für die Analyse von Planregressionen und Fehlerbehebung vorgesehen.`], [`You need query history plus plan history.`, `Sie benötigen Abfragehistorie plus Planhistorie.`], refs.queryStore),
    q('single', 'dp203-179', security, 'medium', null, [`Which tool should you open first when you want to inspect stage-level execution details, skew, and shuffle behavior for a Spark job?`, `Welches Tool sollten Sie zuerst öffnen, wenn Sie ausführungsdetails auf Stage-Ebene, Skew und Shuffle-Verhalten für einen Spark-Job untersuchen möchten?`], [['A', 'Spark UI', 'Spark UI'], ['B', 'Azure Key Vault', 'Azure Key Vault'], ['C', 'Managed private endpoint', 'Managed Private Endpoint'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`The Spark UI exposes jobs, stages, tasks, shuffle metrics, and skew indicators that are essential for performance troubleshooting.`, `Die Spark UI zeigt Jobs, Stages, Tasks, Shuffle-Metriken und Skew-Indikatoren an, die für die Leistungsanalyse wesentlich sind.`], [`This is the execution-level troubleshooting tool for Spark.`, `Dies ist das Troubleshooting-Tool auf Ausführungsebene für Spark.`], refs.sparkUI),
    q('single', 'dp203-180', security, 'easy', null, [`Where should you look in Azure Data Factory or Synapse Studio to review failed pipeline runs and drill into activity output and duration?`, `Wo sollten Sie in Azure Data Factory oder Synapse Studio nachsehen, um fehlgeschlagene Pipelineläufe zu überprüfen und Details zu Aktivitätsausgaben und Dauer anzuzeigen?`], [['A', 'Monitor hub or pipeline monitoring view', 'Monitor-Hub oder Pipelineüberwachungsansicht'], ['B', 'Schema Registry', 'Schema Registry'], ['C', 'Storage access tier settings', 'Einstellungen für Speicherzugriffsebenen'], ['D', 'RLS predicate function', 'RLS-Prädikatfunktion']], ['A'], [`The monitoring experience shows pipeline runs, activity runs, durations, errors, and inputs and outputs for troubleshooting.`, `Die Überwachungsoberfläche zeigt Pipelineläufe, Aktivitätsläufe, Dauern, Fehler sowie Ein- und Ausgaben für das Troubleshooting.`], [`You need orchestration run history.`, `Sie benötigen die Historie der Orchestrierungsläufe.`], refs.pipelineMonitor),
    q('single', 'dp203-181', security, 'medium', [`A performance engineer considers:
CREATE MATERIALIZED VIEW dbo.mvSalesByMonth
AS
SELECT OrderMonth, SUM(Amount) AS TotalAmount
FROM dbo.FactSales
GROUP BY OrderMonth;`, `Ein Performance-Ingenieur erwägt:
CREATE MATERIALIZED VIEW dbo.mvSalesByMonth
AS
SELECT OrderMonth, SUM(Amount) AS TotalAmount
FROM dbo.FactSales
GROUP BY OrderMonth;`], [`Finance dashboards run the same stable aggregation repeatedly against a large dedicated SQL pool table. Which feature can precompute and store that aggregate for faster queries without changing the BI tool?`, `Finanz-Dashboards führen dieselbe stabile Aggregation wiederholt gegen eine große Tabelle im Dedicated SQL Pool aus. Welche Funktion kann diese Aggregation für schnellere Abfragen vorberechnen und speichern, ohne das BI-Tool zu ändern?`], [['A', 'Materialized view', 'Materialisierte Sicht'], ['B', 'Consumer group', 'Consumer Group'], ['C', 'Archive tier', 'Archive-Stufe'], ['D', 'Managed private endpoint', 'Managed Private Endpoint']], ['A'], [`Materialized views physically persist query results so repeated aggregations can be answered faster.`, `Materialisierte Sichten speichern Abfrageergebnisse physisch, sodass wiederholte Aggregationen schneller beantwortet werden können.`], [`The aggregate is stable and repeatedly queried.`, `Die Aggregation ist stabil und wird wiederholt abgefragt.`], refs.synapseOptimize),
    q('single', 'dp203-182', security, 'medium', null, [`What feature can return results immediately for repeated identical SELECT statements in a dedicated SQL pool when underlying data has not changed?`, `Welche Funktion kann Ergebnisse für wiederholte identische SELECT-Anweisungen in einem Dedicated SQL Pool sofort zurückgeben, wenn sich die zugrunde liegenden Daten nicht geändert haben?`], [['A', 'Result-set caching', 'Result-Set-Caching'], ['B', 'Session windowing', 'Session-Windowing'], ['C', 'Archive rehydration', 'Archive-Rehydrierung'], ['D', 'Schema drift', 'Schemadrift']], ['A'], [`Result-set caching stores the output of eligible queries so identical later executions can be served quickly.`, `Result-Set-Caching speichert die Ausgabe zulässiger Abfragen, sodass identische spätere Ausführungen schnell bedient werden können.`], [`The query text repeats exactly.`, `Der Abfragetext wiederholt sich exakt.`], refs.synapseOptimize),
    q('single', 'dp203-183', security, 'medium', [`After a large load, an engineer runs:
UPDATE STATISTICS dbo.FactSales;`, `Nach einem großen Ladevorgang führt ein Ingenieur Folgendes aus:
UPDATE STATISTICS dbo.FactSales;`], [`After loading millions of new rows into a dedicated SQL pool table, which maintenance action often helps the optimizer choose better plans?`, `Welche Wartungsmaßnahme hilft dem Optimierer nach dem Laden von Millionen neuer Zeilen in eine Tabelle eines Dedicated SQL Pools häufig dabei, bessere Pläne zu wählen?`], [['A', 'Update statistics', 'Statistiken aktualisieren'], ['B', 'Create a consumer group', 'Eine Consumer Group erstellen'], ['C', 'Move the files to archive tier', 'Die Dateien in die Archive-Stufe verschieben'], ['D', 'Enable dynamic masking', 'Dynamische Maskierung aktivieren']], ['A'], [`Statistics describe data distribution. Refreshing them after large changes helps the optimizer estimate cardinality more accurately.`, `Statistiken beschreiben die Datenverteilung. Ihre Aktualisierung nach großen Änderungen hilft dem Optimierer, Kardinalitäten genauer zu schätzen.`], [`The optimizer needs fresh distribution information.`, `Der Optimierer benötigt aktuelle Informationen über die Verteilung.`], refs.synapseOptimize),
    q('single', 'dp203-184', security, 'medium', null, [`Which index type is generally recommended for very large fact tables in a Synapse dedicated SQL pool?`, `Welcher Indextyp wird im Allgemeinen für sehr große Faktentabellen in einem Synapse Dedicated SQL Pool empfohlen?`], [['A', 'Clustered columnstore index', 'Clustered-Columnstore-Index'], ['B', 'XML index', 'XML-Index'], ['C', 'Spatial index', 'Spatial-Index'], ['D', 'No index in all cases', 'In allen Fällen kein Index']], ['A'], [`Clustered columnstore indexes are optimized for large analytical scans and compression, making them a common default for large fact tables.`, `Clustered-Columnstore-Indizes sind für große analytische Scans und Komprimierung optimiert und daher eine gängige Standardwahl für große Faktentabellen.`], [`Think compression plus scan efficiency.`, `Denken Sie an Komprimierung plus Scan-Effizienz.`], refs.synapseOptimize),
    q('single', 'dp203-185', security, 'medium', [`A staging design uses:
CREATE TABLE dbo.StageLoad (
    OrderId bigint,
    CustomerId int,
    Amount decimal(18,2)
)
WITH (HEAP);`, `Ein Staging-Design verwendet:
CREATE TABLE dbo.StageLoad (
    OrderId bigint,
    CustomerId int,
    Amount decimal(18,2)
)
WITH (HEAP);`], [`Which table structure is commonly used for transient staging loads when you want fast inserts and do not need analytical indexing yet?`, `Welche Tabellenstruktur wird häufig für transiente Staging-Ladevorgänge verwendet, wenn Sie schnelle Inserts möchten und noch keine analytische Indizierung benötigen?`], [['A', 'Heap', 'Heap'], ['B', 'Clustered columnstore index', 'Clustered-Columnstore-Index'], ['C', 'Replicated dimension', 'Replizierte Dimension'], ['D', 'Materialized view', 'Materialisierte Sicht']], ['A'], [`Heaps can be a practical choice for transient staging because they avoid the maintenance overhead of indexes during initial landing.`, `Heaps können für transientes Staging eine praktische Wahl sein, weil sie beim initialen Landing den Wartungsaufwand von Indizes vermeiden.`], [`The table is temporary and optimized for fast loading.`, `Die Tabelle ist temporär und auf schnelles Laden optimiert.`], refs.synapseOptimize),
    q('single', 'dp203-186', security, 'medium', [`A small lookup table is created as:
CREATE TABLE dbo.DimCountry (
    CountryKey int NOT NULL,
    CountryName nvarchar(100)
)
WITH (CLUSTERED INDEX (CountryKey));`, `Eine kleine Lookup-Tabelle wird wie folgt erstellt:
CREATE TABLE dbo.DimCountry (
    CountryKey int NOT NULL,
    CountryName nvarchar(100)
)
WITH (CLUSTERED INDEX (CountryKey));`], [`A small lookup table is queried mostly with singleton lookups on a key column rather than large scans. Which storage structure is often appropriate?`, `Eine kleine Lookup-Tabelle wird überwiegend mit punktuellen Nachschlagevorgängen auf einer Schlüsselspalte statt mit großen Scans abgefragt. Welche Speicherstruktur ist oft geeignet?`], [['A', 'A clustered index', 'Ein Clustered Index'], ['B', 'A clustered columnstore index', 'Ein Clustered-Columnstore-Index'], ['C', 'Archive tier', 'Archive-Stufe'], ['D', 'A session window', 'Ein Session Window']], ['A'], [`For small lookup-style tables, a clustered index can be more suitable than columnstore because access is often point-based rather than scan-heavy.`, `Für kleine Lookup-Tabellen kann ein Clustered Index besser geeignet sein als Columnstore, weil der Zugriff oft punktuell und nicht scanlastig ist.`], [`This table behaves more like an operational lookup.`, `Diese Tabelle verhält sich eher wie eine operative Nachschlagetabelle.`], refs.synapseOptimize),
    q('single', 'dp203-187', security, 'hard', [`A Spark SQL query joins a 4 TB fact table to a 20 MB dimension. Which hint can reduce shuffle by sending the small table to each executor?
SELECT /*+ BROADCAST(dim) */ *
FROM fact
JOIN dim ON fact.CustomerKey = dim.CustomerKey;`, `Eine Spark-SQL-Abfrage verknüpft eine 4-TB-Faktentabelle mit einer 20-MB-Dimension. Welcher Hint kann Shuffle reduzieren, indem die kleine Tabelle an jeden Executor gesendet wird?
SELECT /*+ BROADCAST(dim) */ *
FROM fact
JOIN dim ON fact.CustomerKey = dim.CustomerKey;`], [`Choose the best answer.`, `Wählen Sie die beste Antwort.`], [['A', 'Broadcast join', 'Broadcast Join'], ['B', 'Archive join', 'Archive Join'], ['C', 'Session join', 'Session Join'], ['D', 'Masked join', 'Masked Join']], ['A'], [`Broadcast joins avoid shuffling the large side by broadcasting the small table to executors.`, `Broadcast Joins vermeiden das Shuffle der großen Seite, indem die kleine Tabelle an die Executors gesendet wird.`], [`The small table is tiny compared to the fact table.`, `Die kleine Tabelle ist im Vergleich zur Faktentabelle sehr klein.`], refs.sparkUI),
    q('single', 'dp203-188', security, 'hard', [`A PySpark job does this before a large join:
df1 = df1.repartition('CustomerKey')
df2 = df2.repartition('CustomerKey')`, `Ein PySpark-Job macht Folgendes vor einem großen Join:
df1 = df1.repartition('CustomerKey')
df2 = df2.repartition('CustomerKey')`], [`Why can this help performance?`, `Warum kann dies die Leistung verbessern?`], [['A', 'It can align partitioning on the join key and reduce shuffle imbalance', 'Es kann die Partitionierung auf dem Join-Schlüssel ausrichten und Shuffle-Ungleichgewichte reduzieren'], ['B', 'It encrypts the DataFrames in memory', 'Es verschlüsselt die DataFrames im Speicher'], ['C', 'It enables Query Store', 'Es aktiviert Query Store'], ['D', 'It creates a consumer group', 'Es erstellt eine Consumer Group']], ['A'], [`Repartitioning by the join key can improve parallelism and reduce expensive reshuffling during the join.`, `Die Repartitionierung nach dem Join-Schlüssel kann die Parallelität verbessern und teures Reshuffling während des Joins reduzieren.`], [`The code prepares both sides for the same join distribution.`, `Der Code bereitet beide Seiten auf dieselbe Join-Verteilung vor.`], refs.sparkUI),
    q('single', 'dp203-189', security, 'medium', [`A notebook reads a DataFrame once and then uses it in several expensive actions:
baseDf.cache()`, `Ein Notebook liest ein DataFrame einmal ein und verwendet es dann in mehreren teuren Aktionen:
baseDf.cache()`], [`What is the main benefit of this command?`, `Was ist der Hauptvorteil dieses Befehls?`], [['A', 'It keeps reused data in memory to avoid repeated recomputation', 'Er hält wiederverwendete Daten im Speicher, um wiederholte Neuberechnungen zu vermeiden'], ['B', 'It encrypts the DataFrame', 'Er verschlüsselt das DataFrame'], ['C', 'It creates a Delta transaction log', 'Er erstellt ein Delta-Transaktionsprotokoll'], ['D', 'It pauses the Spark cluster', 'Er pausiert den Spark-Cluster']], ['A'], [`Caching is useful when the same DataFrame is used multiple times in one session and recomputation would be costly.`, `Caching ist nützlich, wenn dasselbe DataFrame in einer Sitzung mehrfach verwendet wird und die Neuberechnung teuer wäre.`], [`The key clue is repeated reuse in several actions.`, `Der entscheidende Hinweis ist die wiederholte Nutzung in mehreren Aktionen.`], refs.sparkUI),
    q('single', 'dp203-190', security, 'medium', null, [`What is Adaptive Query Execution in Spark primarily meant to do?`, `Wofür ist Adaptive Query Execution in Spark in erster Linie gedacht?`], [['A', 'Dynamically optimize the physical plan at runtime based on observed statistics', 'Den physischen Plan zur Laufzeit anhand beobachteter Statistiken dynamisch zu optimieren'], ['B', 'Mask sensitive columns in query output', 'Sensible Spalten in Abfrageausgaben zu maskieren'], ['C', 'Create private endpoints for Spark clusters', 'Private Endpoints für Spark-Cluster zu erstellen'], ['D', 'Load CSV files into Synapse dedicated SQL pools', 'CSV-Dateien in Synapse Dedicated SQL Pools zu laden']], ['A'], [`AQE can adjust shuffle partition counts, optimize join strategies, and mitigate skew using runtime information.`, `AQE kann die Anzahl der Shuffle-Partitionen anpassen, Join-Strategien optimieren und Skew mithilfe von Laufzeitinformationen verringern.`], [`This feature changes execution decisions while the job is running.`, `Diese Funktion ändert Ausführungsentscheidungen, während der Job läuft.`], refs.sparkUI),
    q('single', 'dp203-191', security, 'medium', [`A Delta Lake maintenance notebook runs:
OPTIMIZE sales_delta;`, `Ein Wartungsnotebook für Delta Lake führt aus:
OPTIMIZE sales_delta;`], [`What is the purpose of this command?`, `Was ist der Zweck dieses Befehls?`], [['A', 'Compact many small files into fewer larger files', 'Viele kleine Dateien zu weniger größeren Dateien zusammenzufassen'], ['B', 'Delete all historical versions immediately', 'Alle historischen Versionen sofort zu löschen'], ['C', 'Enable dynamic data masking', 'Dynamische Datenmaskierung zu aktivieren'], ['D', 'Rotate Event Hubs keys', 'Event-Hubs-Schlüssel zu rotieren']], ['A'], [`OPTIMIZE compacts small files and can improve read performance in Delta tables.`, `OPTIMIZE verdichtet kleine Dateien und kann die Leseleistung in Delta-Tabellen verbessern.`], [`This is a file layout optimization command.`, `Dies ist ein Befehl zur Optimierung des Dateilayouts.`], refs.deltaOptimize),
    q('single', 'dp203-192', security, 'medium', [`A Databricks engineer runs:
OPTIMIZE sales_delta ZORDER BY (CustomerId, OrderDate);`, `Ein Databricks-Ingenieur führt aus:
OPTIMIZE sales_delta ZORDER BY (CustomerId, OrderDate);`], [`What is the goal of ZORDER here?`, `Was ist hier das Ziel von ZORDER?`], [['A', 'Improve data skipping for queries filtering on those columns', 'Das Data Skipping für Abfragen auf diese Spalten zu verbessern'], ['B', 'Encrypt the columns with Always Encrypted', 'Die Spalten mit Always Encrypted zu verschlüsseln'], ['C', 'Convert the table to ORC', 'Die Tabelle in ORC zu konvertieren'], ['D', 'Create a managed private endpoint', 'Einen Managed Private Endpoint zu erstellen']], ['A'], [`ZORDER helps colocate related column values in files so filtering on those columns can skip more irrelevant data.`, `ZORDER hilft dabei, zusammengehörige Spaltenwerte in Dateien näher beieinander zu platzieren, sodass bei Filtern auf diese Spalten mehr irrelevante Daten übersprungen werden können.`], [`The target is read efficiency for selective queries.`, `Das Ziel ist Leseeffizienz für selektive Abfragen.`], refs.deltaOptimize),
    q('single', 'dp203-193', security, 'medium', [`A maintenance notebook runs:
VACUUM sales_delta RETAIN 168 HOURS;`, `Ein Wartungsnotebook führt aus:
VACUUM sales_delta RETAIN 168 HOURS;`], [`What does VACUUM do?`, `Was macht VACUUM?`], [['A', 'Removes obsolete files that are no longer needed after the retention period', 'Entfernt veraltete Dateien, die nach dem Aufbewahrungszeitraum nicht mehr benötigt werden'], ['B', 'Creates a new Event Hubs partition', 'Erstellt eine neue Event-Hubs-Partition'], ['C', 'Encrypts the table at rest', 'Verschlüsselt die Tabelle im Ruhezustand'], ['D', 'Builds a materialized view', 'Erstellt eine materialisierte Sicht']], ['A'], [`VACUUM cleans up old files that Delta no longer needs, subject to retention settings and time-travel requirements.`, `VACUUM bereinigt alte Dateien, die Delta nicht mehr benötigt, vorbehaltlich Aufbewahrungseinstellungen und Time-Travel-Anforderungen.`], [`This is cleanup, not compaction.`, `Dies ist Bereinigung und nicht Verdichtung.`], refs.databricksDelta),
    q('single', 'dp203-194', security, 'easy', null, [`A Synapse dedicated SQL pool is not needed overnight. Which action most directly reduces compute cost during that period?`, `Ein Synapse Dedicated SQL Pool wird nachts nicht benötigt. Welche Aktion reduziert die Compute-Kosten in diesem Zeitraum am direktesten?`], [['A', 'Pause the dedicated SQL pool', 'Den Dedicated SQL Pool pausieren'], ['B', 'Enable dynamic masking', 'Dynamische Maskierung aktivieren'], ['C', 'Create a materialized view', 'Eine materialisierte Sicht erstellen'], ['D', 'Add a consumer group', 'Eine Consumer Group hinzufügen']], ['A'], [`Pausing a dedicated SQL pool stops compute billing until the pool is resumed.`, `Das Pausieren eines Dedicated SQL Pools stoppt die Compute-Abrechnung, bis der Pool wieder fortgesetzt wird.`], [`The workload disappears completely during the idle window.`, `Der Workload entfällt im Leerlaufzeitraum vollständig.`], refs.costMgmt),
    q('single', 'dp203-195', security, 'medium', null, [`A warehouse needs high compute during the nightly load window and lower compute during the day. What is the best cost-performance approach?`, `Ein Warehouse benötigt während des nächtlichen Ladefensters hohe Compute-Leistung und tagsüber geringere Compute-Leistung. Was ist der beste Ansatz für Kosten und Leistung?`], [['A', 'Scale the dedicated SQL pool up for loads and down afterward', 'Den Dedicated SQL Pool für Ladevorgänge hoch- und danach herunterskalieren'], ['B', 'Move all data to archive every morning', 'Alle Daten jeden Morgen ins Archiv verschieben'], ['C', 'Replace SQL with Event Hubs', 'SQL durch Event Hubs ersetzen'], ['D', 'Use only round-robin tables', 'Nur Round-Robin-Tabellen verwenden']], ['A'], [`Dedicated SQL pool performance can be scaled by changing compute level. Matching scale to workload windows helps control cost.`, `Die Leistung eines Dedicated SQL Pools kann durch Ändern der Compute-Stufe skaliert werden. Das Anpassen der Skalierung an Workload-Fenster hilft, Kosten zu kontrollieren.`], [`You need elasticity across different workload periods.`, `Sie benötigen Elastizität über verschiedene Workload-Zeiträume hinweg.`], refs.costMgmt),
    q('single', 'dp203-196', security, 'medium', null, [`What is the most accurate description of Synapse serverless SQL pricing?`, `Welche Beschreibung der Preisgestaltung von Synapse serverlosem SQL ist am treffendsten?`], [['A', 'You pay mainly for the amount of data processed by queries', 'Sie zahlen hauptsächlich für die Datenmenge, die von Abfragen verarbeitet wird'], ['B', 'You pay for reserved DWUs 24x7', 'Sie zahlen für reservierte DWUs rund um die Uhr'], ['C', 'You pay per notebook cell execution', 'Sie zahlen pro Ausführung einer Notebook-Zelle'], ['D', 'You pay only when creating external tables', 'Sie zahlen nur beim Erstellen externer Tabellen']], ['A'], [`Serverless SQL is billed by data processed, so column projection, partition pruning, and efficient formats matter for cost.`, `Serverloses SQL wird nach verarbeiteten Datenmengen abgerechnet, daher sind Spaltenprojektion, Partition Pruning und effiziente Formate wichtig für die Kosten.`], [`This model is scan-based, not reserved-capacity based.`, `Dieses Modell basiert auf Scans und nicht auf reservierter Kapazität.`], refs.serverlessBest),
    q('single', 'dp203-197', security, 'medium', null, [`Which Databricks compute choice usually helps control cost for scheduled production pipelines better than leaving an interactive cluster running?`, `Welche Databricks-Compute-Wahl hilft normalerweise besser bei der Kostenkontrolle für geplante Produktionspipelines, als einen interaktiven Cluster laufen zu lassen?`], [['A', 'Job clusters', 'Job-Cluster'], ['B', 'Archive tier', 'Archive-Stufe'], ['C', 'Consumer groups', 'Consumer Groups'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`Job clusters start for the workload and terminate afterward, which reduces idle time cost compared to all-purpose clusters.`, `Job-Cluster starten für den Workload und beenden sich danach, was Leerlaufkosten im Vergleich zu All-Purpose-Clustern reduziert.`], [`Avoid paying for idle interactive compute.`, `Vermeiden Sie die Bezahlung von interaktivem Compute im Leerlauf.`], refs.databricksClusters),
    q('multiple', 'dp203-198', security, 'hard', [`A multi-region analytics platform has these requirements:
- Analysts must see only rows for their own region.
- Email addresses should appear obfuscated for most users.
Which two features should you implement?`, `Eine Analyseplattform für mehrere Regionen hat folgende Anforderungen:
- Analysten dürfen nur Zeilen ihrer eigenen Region sehen.
- E-Mail-Adressen sollen für die meisten Benutzer verschleiert erscheinen.
Welche zwei Funktionen sollten Sie implementieren?`], [['A', 'Row-level security', 'Row-Level Security'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Archive tier', 'Archive-Stufe'], ['D', 'Round-robin distribution', 'Round-Robin-Verteilung']], ['A', 'B'], [`RLS restricts which rows users can see, while dynamic data masking obfuscates sensitive values in result sets for non-privileged users.`, `RLS beschränkt, welche Zeilen Benutzer sehen können, während die dynamische Datenmaskierung sensible Werte in Resultsets für nicht privilegierte Benutzer verschleiert.`], [`One requirement is about rows, the other is about how values appear.`, `Eine Anforderung betrifft Zeilen, die andere das Erscheinungsbild von Werten.`], refs.rowLevelSecurity),
    q('single', 'dp203-199', security, 'hard', [`In an Always Encrypted design that integrates with Azure Key Vault, which key is typically stored in Key Vault?`, `Welcher Schlüssel wird in einem Always-Encrypted-Design mit Integration in Azure Key Vault typischerweise in Key Vault gespeichert?`], [['A', 'Column master key', 'Column Master Key'], ['B', 'Column encryption key plaintext', 'Klartext des Column Encryption Key'], ['C', 'Delta transaction log key', 'Schlüssel des Delta-Transaktionsprotokolls'], ['D', 'Event Hubs SAS key only', 'Nur Event-Hubs-SAS-Schlüssel']], ['A'], [`The column master key is the higher-level key that protects column encryption keys and is commonly backed by Azure Key Vault or another secure store.`, `Der Column Master Key ist der übergeordnete Schlüssel, der Column Encryption Keys schützt und häufig durch Azure Key Vault oder einen anderen sicheren Speicher abgesichert wird.`], [`Think of the root key in the key hierarchy.`, `Denken Sie an den Wurzelschlüssel in der Schlüsselhierarchie.`], refs.alwaysEncrypted),
    q('single', 'dp203-200', security, 'medium', null, [`You want Synapse or ADF to connect to Azure SQL Database without storing a SQL username and password in the pipeline. Which authentication approach should you prefer?`, `Sie möchten, dass Synapse oder ADF eine Verbindung zu Azure SQL Database herstellt, ohne einen SQL-Benutzernamen und ein Passwort in der Pipeline zu speichern. Welchen Authentifizierungsansatz sollten Sie bevorzugen?`], [['A', 'Managed identity authentication', 'Authentifizierung mit verwalteter Identität'], ['B', 'Hard-coded SQL login', 'Fest codierten SQL-Login'], ['C', 'Anonymous access', 'Anonymen Zugriff'], ['D', 'Archive rehydration', 'Archiv-Rehydrierung']], ['A'], [`Managed identities allow Azure services to authenticate to supported resources without embedding credentials in code or pipeline definitions.`, `Verwaltete Identitäten ermöglichen Azure-Diensten die Authentifizierung gegenüber unterstützten Ressourcen, ohne Anmeldeinformationen in Code oder Pipeline-Definitionen einzubetten.`], [`The goal is passwordless service-to-service authentication.`, `Das Ziel ist passwortlose Dienst-zu-Dienst-Authentifizierung.`], refs.managedIdentity),
    q('single', 'dp203-201', security, 'hard', null, [`In Always Encrypted, what is the role of the column encryption key (CEK)?`, `Welche Rolle hat in Always Encrypted der Column Encryption Key (CEK)?`], [['A', 'It encrypts the actual column data and is itself protected by the column master key', 'Er verschlüsselt die eigentlichen Spaltendaten und wird selbst durch den Column Master Key geschützt'], ['B', 'It defines row-level security predicates', 'Er definiert Row-Level-Security-Prädikate'], ['C', 'It stores Spark checkpoints', 'Er speichert Spark-Checkpoints'], ['D', 'It controls serverless SQL pricing', 'Er steuert die Preisgestaltung von serverlosem SQL']], ['A'], [`The CEK is the working key used to encrypt column values. The CMK protects the CEK in the key hierarchy.`, `Der CEK ist der operative Schlüssel, mit dem Spaltenwerte verschlüsselt werden. Der CMK schützt den CEK in der Schlüsselhierarchie.`], [`Differentiate the key that protects data from the key that protects keys.`, `Unterscheiden Sie zwischen dem Schlüssel, der Daten schützt, und dem Schlüssel, der Schlüssel schützt.`], refs.alwaysEncrypted),
  ];

  if (window.ExamData && window.ExamData['dp-203']) {
    window.ExamData['dp-203'].questions = window.ExamData['dp-203'].questions.concat(extra);
  }
})();
