(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 = {
    lakeZones: 'https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/scenarios/cloud-scale-analytics/best-practices/data-lake-zones',
    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',
    synapseOpenrowset: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql/query-data-storage',
    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',
    adfCopy: 'https://learn.microsoft.com/en-us/azure/data-factory/copy-activity-overview',
    adfGetMetadata: 'https://learn.microsoft.com/en-us/azure/data-factory/control-flow-get-metadata-activity',
    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/',
    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',
    sqlCdc: 'https://learn.microsoft.com/en-us/azure/azure-sql/database/change-data-capture-overview',
    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',
    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',
    warehousing: 'https://learn.microsoft.com/en-us/azure/architecture/data-guide/relational-data/data-warehousing'
  };

  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-302', storage, 'hard', [`A serverless SQL pool queries sales files stored in ADLS Gen2 by folder path /sales/year=2025/month=03/day=DD/*.parquet. Analysts only need March 2025 data, and you must minimize the amount of data scanned.`, `Ein serverloser SQL-Pool fragt Verkaufsdateien in ADLS Gen2 über den Ordnerpfad /sales/year=2025/month=03/day=DD/*.parquet ab. Analysten benötigen nur Daten für März 2025, und Sie müssen die gescannte Datenmenge minimieren.`], [`Which approach should you use?`, `Welchen Ansatz sollten Sie verwenden?`], [['A', 'Read only the matching month path, such as sales/year=2025/month=03/*.parquet', 'Nur den passenden Monatspfad lesen, z. B. sales/year=2025/month=03/*.parquet'], ['B', 'Read all sales files and filter month after the scan finishes', 'Alle Verkaufsdateien lesen und nach Abschluss des Scans nach Monat filtern'], ['C', 'Convert the files to CSV before querying them', 'Die Dateien vor der Abfrage in CSV konvertieren'], ['D', 'Load the files into a replicated table first', 'Die Dateien zuerst in eine replizierte Tabelle laden']], ['A'], [`Reducing the path scope lets serverless SQL prune file sets before reading them. That lowers both latency and cost because fewer files are scanned.`, `Wenn der Pfadbereich eingeschränkt wird, kann serverloses SQL Dateimengen vor dem Lesen prunen. Das senkt sowohl die Latenz als auch die Kosten, weil weniger Dateien gescannt werden.`], [`Prune files before the query reads them, not afterward.`, `Prunen Sie Dateien, bevor die Abfrage sie liest, und nicht erst danach.`], refs.serverlessBest),
    q('single', 'dp203-303', storage, 'hard', [`A data engineer runs a serverless SQL query over Parquet files and wants to persist the result set as a new Parquet dataset in the lake for reuse by Power BI.`, `Ein Data Engineer führt eine serverlose SQL-Abfrage über Parquet-Dateien aus und möchte das Resultset als neuen Parquet-Datensatz im Data Lake für die Wiederverwendung durch Power BI speichern.`], [`Which T-SQL pattern should you choose?`, `Welches T-SQL-Muster sollten Sie wählen?`], [['A', 'CETAS', 'CETAS'], ['B', 'DBCC CHECKDB', 'DBCC CHECKDB'], ['C', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['D', 'A replicated table only', 'Nur eine replizierte Tabelle']], ['A'], [`CREATE EXTERNAL TABLE AS SELECT writes query results to external storage and registers the output as an external table. It is a common way to persist reusable serverless query results.`, `CREATE EXTERNAL TABLE AS SELECT schreibt Abfrageergebnisse in externen Speicher und registriert die Ausgabe als externe Tabelle. Dies ist ein gängiger Weg, wiederverwendbare Ergebnisse aus serverlosem SQL zu persistieren.`], [`The result must be written back to the lake as a dataset.`, `Das Ergebnis muss als Datensatz zurück in den Data Lake geschrieben werden.`], refs.synapseExternal),
    q('single', 'dp203-304', storage, 'medium', null, [`You need the fastest initial load into a staging table in a dedicated SQL pool before later transforming the data into optimized warehouse tables. Which design is usually best?`, `Sie benötigen den schnellsten initialen Ladevorgang in eine Staging-Tabelle in einem Dedicated SQL Pool, bevor die Daten später in optimierte Warehouse-Tabellen transformiert werden. Welches Design ist normalerweise am besten?`], [['A', 'ROUND_ROBIN distribution with a heap', 'ROUND_ROBIN-Verteilung mit einem Heap'], ['B', 'REPLICATE distribution with row-level security', 'REPLICATE-Verteilung mit Row-Level Security'], ['C', 'HASH distribution with deterministic encryption', 'HASH-Verteilung mit deterministischer Verschlüsselung'], ['D', 'An external table over CSV files only', 'Eine externe Tabelle nur über CSV-Dateien']], ['A'], [`Round-robin heaps are a common staging choice because they support fast loads with minimal design overhead. You can later transform the staged data into better distributed and indexed tables.`, `Round-Robin-Heaps sind eine gängige Wahl für Staging, weil sie schnelle Ladevorgänge mit minimalem Designaufwand unterstützen. Später können Sie die gestagten Daten in besser verteilte und indizierte Tabellen transformieren.`], [`Think landing speed first, optimization later.`, `Denken Sie zuerst an Landing-Geschwindigkeit und danach an Optimierung.`], refs.synapseOptimize),
    q('single', 'dp203-305', storage, 'medium', null, [`A product dimension has only a few million rows and is joined to very large fact tables in almost every report. Which dedicated SQL pool distribution is usually best?`, `Eine Produktdimension hat nur wenige Millionen Zeilen und wird in fast jedem Bericht mit sehr großen Faktentabellen verknüpft. Welche Verteilung im Dedicated SQL Pool ist normalerweise am besten?`], [['A', 'REPLICATE', 'REPLICATE'], ['B', 'ROUND_ROBIN', 'ROUND_ROBIN'], ['C', 'HASH on a random GUID', 'HASH auf einer zufälligen GUID'], ['D', 'No table distribution at all', 'Überhaupt keine Tabellenverteilung']], ['A'], [`Replicated tables copy the small table to each compute node, which can reduce data movement for joins with large fact tables.`, `Replizierte Tabellen kopieren die kleine Tabelle auf jeden Compute-Knoten, wodurch Datenbewegungen bei Joins mit großen Faktentabellen reduziert werden können.`], [`The table is small and used everywhere.`, `Die Tabelle ist klein und wird überall verwendet.`], refs.synapseDist),
    q('single', 'dp203-306', storage, 'hard', [`A warehouse engineer creates the table below:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(ProductKey), CLUSTERED COLUMNSTORE INDEX)
AS SELECT * FROM dbo.StageSales;`, `Ein Warehouse-Ingenieur erstellt die folgende Tabelle:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(ProductKey), CLUSTERED COLUMNSTORE INDEX)
AS SELECT * FROM dbo.StageSales;`], [`Why is HASH(ProductKey) a sensible choice when most large joins use ProductKey?`, `Warum ist HASH(ProductKey) eine sinnvolle Wahl, wenn die meisten großen Joins ProductKey verwenden?`], [['A', 'It can reduce data movement during joins on ProductKey', 'Es kann die Datenbewegung bei Joins über ProductKey reduzieren'], ['B', 'It automatically masks ProductKey values', 'Es maskiert ProductKey-Werte automatisch'], ['C', 'It converts the table to an external table', 'Es wandelt die Tabelle in eine externe Tabelle um'], ['D', 'It disables statistics updates', 'Es deaktiviert Statistikaktualisierungen']], ['A'], [`Hash distribution works well when the distribution key aligns with major join patterns. That can colocate related rows and lower shuffle costs.`, `Eine Hash-Verteilung funktioniert gut, wenn der Verteilungsschlüssel zu den wesentlichen Join-Mustern passt. Dadurch können zusammengehörige Zeilen gemeinsam platziert und Shuffle-Kosten gesenkt werden.`], [`Match the distribution key to the dominant join key.`, `Passen Sie den Verteilungsschlüssel an den dominanten Join-Schlüssel an.`], refs.synapseDist),
    q('single', 'dp203-307', storage, 'hard', [`A large fact table is hash-distributed on CountryRegion and query performance is poor because one region contains most of the rows.`, `Eine große Faktentabelle ist per Hash auf CountryRegion verteilt, und die Abfrageleistung ist schlecht, weil eine Region den Großteil der Zeilen enthält.`], [`What should you change first?`, `Was sollten Sie zuerst ändern?`], [['A', 'Choose a more evenly distributed, higher-cardinality hash key', 'Einen gleichmäßiger verteilten Hash-Schlüssel mit höherer Kardinalität wählen'], ['B', 'Convert all files to JSON', 'Alle Dateien in JSON konvertieren'], ['C', 'Disable the columnstore index', 'Den Columnstore-Index deaktivieren'], ['D', 'Use dynamic data masking', 'Dynamische Datenmaskierung verwenden']], ['A'], [`A skewed distribution key overloads some distributions while others stay light. Choosing a more even key reduces skew and improves parallelism.`, `Ein verzerrter Verteilungsschlüssel überlastet einige Verteilungen, während andere kaum ausgelastet sind. Die Wahl eines gleichmäßigeren Schlüssels reduziert Skew und verbessert die Parallelität.`], [`The problem is data skew, not security or file format.`, `Das Problem ist Datenskew und nicht Sicherheit oder Dateiformat.`], refs.synapseDist),
    q('single', 'dp203-308', storage, 'medium', null, [`Which file format is generally best for Synapse serverless SQL when you want efficient column projection and lower scan cost?`, `Welches Dateiformat ist für serverloses Synapse-SQL im Allgemeinen am besten, wenn Sie effiziente Spaltenprojektion und geringere Scan-Kosten möchten?`], [['A', 'Parquet', 'Parquet'], ['B', 'CSV', 'CSV'], ['C', 'Plain text', 'Einfacher Text'], ['D', 'Bitmap', 'Bitmap']], ['A'], [`Parquet is columnar, so serverless SQL can read only required columns more efficiently. That typically lowers both runtime and billed data processed.`, `Parquet ist spaltenorientiert, sodass serverloses SQL nur die benötigten Spalten effizienter lesen kann. Das senkt typischerweise sowohl die Laufzeit als auch die abgerechnete verarbeitete Datenmenge.`], [`Columnar storage is the clue.`, `Spaltenorientierte Speicherung ist der entscheidende Hinweis.`], refs.serverlessBest),
    q('single', 'dp203-309', storage, 'medium', null, [`Which table format is the best fit when you need ACID transactions, reliable upserts, and time travel over data lake files?`, `Welches Tabellenformat passt am besten, wenn Sie ACID-Transaktionen, zuverlässige Upserts und Time Travel über Data-Lake-Dateien benötigen?`], [['A', 'Delta Lake', 'Delta Lake'], ['B', 'Raw CSV folders', 'Rohe CSV-Ordner'], ['C', 'PNG', 'PNG'], ['D', 'Heap tables only', 'Nur Heap-Tabellen']], ['A'], [`Delta Lake adds a transaction log on top of data files. That enables ACID behavior, schema enforcement, version history, and efficient update patterns.`, `Delta Lake ergänzt Datendateien um ein Transaktionsprotokoll. Dadurch werden ACID-Verhalten, Schemaerzwingung, Versionshistorie und effiziente Update-Muster möglich.`], [`The requirement goes beyond a simple file format.`, `Die Anforderung geht über ein einfaches Dateiformat hinaus.`], refs.databricksDelta),
    q('single', 'dp203-310', storage, 'medium', [`You need to inspect a few Parquet files in ADLS Gen2 one time from a serverless SQL pool, and you do not want to create any permanent metadata objects.`, `Sie müssen einige Parquet-Dateien in ADLS Gen2 einmalig aus einem serverlosen SQL-Pool prüfen und möchten keine permanenten Metadatenobjekte erstellen.`], [`Which option should you use?`, `Welche Option sollten Sie verwenden?`], [['A', 'OPENROWSET', 'OPENROWSET'], ['B', 'A materialized view', 'Eine materialisierte Sicht'], ['C', 'RLS', 'RLS'], ['D', 'A replicated fact table', 'Eine replizierte Faktentabelle']], ['A'], [`OPENROWSET is ideal for ad hoc access to external files without defining permanent external tables first.`, `OPENROWSET ist ideal für den Ad-hoc-Zugriff auf externe Dateien, ohne zuerst permanente externe Tabellen zu definieren.`], [`This is a one-time exploratory read.`, `Dies ist ein einmaliger explorativer Lesezugriff.`], refs.synapseOpenrowset),
    q('single', 'dp203-311', storage, 'medium', [`Many analysts query the same external Parquet dataset every day. The schema is stable and you want a reusable SQL object instead of repeating the file path in each query.`, `Viele Analysten fragen denselben externen Parquet-Datensatz jeden Tag ab. Das Schema ist stabil, und Sie möchten ein wiederverwendbares SQL-Objekt, anstatt in jeder Abfrage den Dateipfad zu wiederholen.`], [`What should you create?`, `Was sollten Sie erstellen?`], [['A', 'An external table', 'Eine externe Tabelle'], ['B', 'A consumer group', 'Eine Consumer Group'], ['C', 'A tumbling window', 'Ein Tumbling Window'], ['D', 'A Spark cache only', 'Nur einen Spark-Cache']], ['A'], [`External tables provide reusable metadata over external data. They simplify access for repeated queries and standardize schema definitions.`, `Externe Tabellen stellen wiederverwendbare Metadaten über externe Daten bereit. Sie vereinfachen den Zugriff für wiederholte Abfragen und standardisieren Schemadefinitionen.`], [`The need is shared metadata over the same files.`, `Benötigt werden gemeinsam genutzte Metadaten über dieselben Dateien.`], refs.synapseExternal),
    q('single', 'dp203-312', storage, 'hard', [`A CSV file in Azure Storage has a header row. You want to load it into a dedicated SQL pool with COPY INTO and skip the header during load.`, `Eine CSV-Datei in Azure Storage enthält eine Kopfzeile. Sie möchten sie mit COPY INTO in einen Dedicated SQL Pool laden und die Kopfzeile beim Laden überspringen.`], [`Which option should you set?`, `Welche Option sollten Sie setzen?`], [['A', 'FIRSTROW = 2', 'FIRSTROW = 2'], ['B', 'MAXERRORS = 0', 'MAXERRORS = 0'], ['C', 'HEAP = OFF', 'HEAP = OFF'], ['D', 'DISTRIBUTION = REPLICATE', 'DISTRIBUTION = REPLICATE']], ['A'], [`FIRSTROW = 2 tells COPY INTO to begin reading data on the second row, which skips a single header row.`, `FIRSTROW = 2 weist COPY INTO an, die Daten ab der zweiten Zeile zu lesen und damit eine einzelne Kopfzeile zu überspringen.`], [`The issue is the starting row, not the table design.`, `Das Problem ist die Startzeile und nicht das Tabellendesign.`], refs.synapseCopy),
    q('single', 'dp203-313', storage, 'medium', null, [`A Delta table is queried mostly by sales date. Which partition column is usually the best choice?`, `Eine Delta-Tabelle wird überwiegend nach Verkaufsdatum abgefragt. Welche Partitionierungsspalte ist normalerweise die beste Wahl?`], [['A', 'SalesDate', 'SalesDate'], ['B', 'OrderLineId', 'OrderLineId'], ['C', 'CustomerEmail', 'CustomerEmail'], ['D', 'RandomGuid', 'RandomGuid']], ['A'], [`A date column commonly supports pruning well and usually has manageable cardinality. High-cardinality values such as GUIDs or line IDs create too many partitions.`, `Eine Datumsspalte unterstützt Pruning in der Regel gut und hat normalerweise eine beherrschbare Kardinalität. Werte mit hoher Kardinalität wie GUIDs oder Zeilen-IDs erzeugen zu viele Partitionen.`], [`Pick the common filter column with sensible cardinality.`, `Wählen Sie die häufige Filterspalte mit sinnvoller Kardinalität.`], refs.databricksDelta),
    q('single', 'dp203-314', storage, 'medium', null, [`Why is partitioning a lake table by a GUID usually a bad idea?`, `Warum ist die Partitionierung einer Lake-Tabelle nach einer GUID normalerweise eine schlechte Idee?`], [['A', 'It creates too many tiny partitions and metadata overhead', 'Sie erzeugt zu viele winzige Partitionen und Metadaten-Overhead'], ['B', 'It disables ACID transactions', 'Sie deaktiviert ACID-Transaktionen'], ['C', 'It forces dedicated SQL pool usage', 'Sie erzwingt die Nutzung eines Dedicated SQL Pools'], ['D', 'It removes the hierarchical namespace', 'Sie entfernt den hierarchischen Namespace']], ['A'], [`GUID values are extremely high cardinality. That leads to excessive partition counts, tiny files, and poor query efficiency.`, `GUID-Werte besitzen eine extrem hohe Kardinalität. Das führt zu einer übermäßigen Anzahl von Partitionen, winzigen Dateien und schlechter Abfrageeffizienz.`], [`High cardinality is the key warning sign.`, `Hohe Kardinalität ist das entscheidende Warnsignal.`], refs.serverlessBest),
    q('single', 'dp203-315', storage, 'hard', [`A dimension table contains CustomerSK, CustomerId, Segment, ValidFrom, ValidTo, and IsCurrent.`, `Eine Dimensionstabelle enthält CustomerSK, CustomerId, Segment, ValidFrom, ValidTo und IsCurrent.`], [`Which modeling pattern does this indicate?`, `Welches Modellierungsmuster deutet dies an?`], [['A', 'Slowly changing dimension Type 2', 'Slowly Changing Dimension Typ 2'], ['B', 'Round-robin staging', 'Round-Robin-Staging'], ['C', 'Dynamic masking', 'Dynamische Maskierung'], ['D', 'Result set caching', 'Resultset-Caching']], ['A'], [`Effective date columns and a current-row flag are classic indicators of Type 2 dimensions that preserve history by versioning rows.`, `Gültigkeitsdaten und ein Kennzeichen für die aktuelle Zeile sind klassische Merkmale von Typ-2-Dimensionen, die die Historie durch versionierte Zeilen bewahren.`], [`The table tracks versions over time.`, `Die Tabelle verfolgt Versionen über die Zeit.`], refs.warehousing),
    q('single', 'dp203-316', storage, 'medium', null, [`A dimension must keep the current sales region and one previous sales region in the same row, but not the full history. Which slowly changing dimension type fits best?`, `Eine Dimension muss die aktuelle Vertriebsregion und eine vorherige Vertriebsregion in derselben Zeile speichern, aber nicht die 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 0', 'Typ 0']], ['C'], [`Type 3 is intended for limited history, often storing the current and previous value side by side.`, `Typ 3 ist für begrenzte Historie gedacht und speichert häufig den aktuellen und den vorherigen Wert nebeneinander.`], [`Only one previous value is required.`, `Es wird nur ein vorheriger Wert benötigt.`], refs.warehousing),
    q('single', 'dp203-317', storage, 'medium', null, [`Why are surrogate keys commonly used in dimension tables?`, `Warum werden in Dimensionstabellen häufig Surrogatschlüssel verwendet?`], [['A', 'They provide stable warehouse keys and support multiple historical versions of one business key', 'Sie liefern stabile Warehouse-Schlüssel und unterstützen mehrere historische Versionen eines Geschäftsschlüssels'], ['B', 'They replace fact tables completely', 'Sie ersetzen Faktentabellen vollständig'], ['C', 'They automatically encrypt the dimension', 'Sie verschlüsseln die Dimension automatisch'], ['D', 'They remove the need for partitions', 'Sie machen Partitionen überflüssig']], ['A'], [`Surrogate keys are warehouse-generated identifiers that make joins stable and allow several historical rows for the same business entity.`, `Surrogatschlüssel sind im Warehouse erzeugte Kennungen, die stabile Joins ermöglichen und mehrere historische Zeilen für dieselbe Geschäftseinheit zulassen.`], [`Think about historical versions of the same business key.`, `Denken Sie an historische Versionen desselben Geschäftsschlüssels.`], refs.warehousing),
    q('single', 'dp203-318', storage, 'hard', [`A serverless SQL engineer needs to expose partition values from folder names because the Parquet files do not contain year and month columns.`, `Ein Ingenieur für serverloses SQL muss Partitionierungswerte aus Ordnernamen bereitstellen, weil die Parquet-Dateien keine Spalten für Jahr und Monat enthalten.`], [`Which function is designed for this purpose in OPENROWSET queries?`, `Welche Funktion ist in OPENROWSET-Abfragen für diesen Zweck vorgesehen?`], [['A', 'filepath()', 'filepath()'], ['B', 'row_number()', 'row_number()'], ['C', 'checksum()', 'checksum()'], ['D', 'string_split()', 'string_split()']], ['A'], [`filepath() can expose path segments from matched files, which is useful when partition values live in folder names instead of file columns.`, `filepath() kann Pfadsegmente aus passenden Dateien bereitstellen. Das ist nützlich, wenn Partitionierungswerte in Ordnernamen statt in Dateispalten liegen.`], [`The values come from the path, not from the file body.`, `Die Werte kommen aus dem Pfad und nicht aus dem Dateiinhalt.`], refs.synapseOpenrowset),
    q('single', 'dp203-319', storage, 'medium', [`A Delta table receives thousands of tiny files every hour from micro-batches, and query performance is degrading.`, `Eine Delta-Tabelle erhält stündlich Tausende winzige Dateien aus Micro-Batches, und die Abfrageleistung verschlechtert sich.`], [`What should you do first?`, `Was sollten Sie zuerst tun?`], [['A', 'Compact the table into fewer larger files', 'Die Tabelle in weniger größere Dateien verdichten'], ['B', 'Convert the table to CSV', 'Die Tabelle in CSV umwandeln'], ['C', 'Disable partitioning forever', 'Die Partitionierung dauerhaft deaktivieren'], ['D', 'Create a consumer group', 'Eine Consumer Group erstellen']], ['A'], [`Too many small files increase metadata overhead and reduce read efficiency. Compaction improves layout and query performance.`, `Zu viele kleine Dateien erhöhen den Metadaten-Overhead und verringern die Leseeffizienz. Verdichtung verbessert das Layout und die Abfrageleistung.`], [`This is the classic small-files problem.`, `Dies ist das klassische Problem zu vieler kleiner Dateien.`], refs.deltaOptimize),
    q('single', 'dp203-320', storage, 'easy', null, [`Which data lake zone should keep source data as received so it can be replayed or reprocessed later?`, `Welche Data-Lake-Zone sollte Quelldaten so behalten, wie sie eingegangen sind, damit sie später erneut abgespielt oder verarbeitet werden können?`], [['A', 'Raw or landing zone', 'Raw- oder Landing-Zone'], ['B', 'Curated zone', 'Curated-Zone'], ['C', 'Serving index zone', 'Serving-Index-Zone'], ['D', 'Consumer group zone', 'Consumer-Group-Zone']], ['A'], [`The raw or landing zone preserves source fidelity. It is the right place for immutable source-oriented copies used for recovery or reprocessing.`, `Die Raw- oder Landing-Zone bewahrt die Originaltreue der Quelle. Sie ist der richtige Ort für unveränderliche, quellorientierte Kopien zur Wiederherstellung oder Neuverarbeitung.`], [`Keep the original before applying business rules.`, `Bewahren Sie das Original auf, bevor Fachregeln angewendet werden.`], refs.lakeZones),
    q('single', 'dp203-321', storage, 'medium', null, [`Your team exchanges event payloads between producers and consumers and needs compact serialization with good schema evolution support. Which format is the best fit?`, `Ihr Team tauscht Event-Payloads zwischen Produzenten und Konsumenten aus und benötigt eine kompakte Serialisierung mit guter Unterstützung für Schemaentwicklung. Welches Format passt am besten?`], [['A', 'Avro', 'Avro'], ['B', 'BMP', 'BMP'], ['C', 'CSV', 'CSV'], ['D', 'JPEG', 'JPEG']], ['A'], [`Avro is widely used for serialized event data because it is compact and works well with evolving schemas.`, `Avro wird häufig für serialisierte Ereignisdaten verwendet, weil es kompakt ist und gut mit sich entwickelnden Schemas funktioniert.`], [`Think producer-consumer serialization rather than analytics scans.`, `Denken Sie an die Serialisierung zwischen Produzenten und Konsumenten und nicht an analytische Scans.`],     refs.eventHubs),
    q('single', 'dp203-322', processing, 'hard', [`A Databricks notebook contains the following statement:
MERGE INTO silver_orders AS t
USING updates AS s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *`, `Ein Databricks-Notebook enthält die folgende Anweisung:
MERGE INTO silver_orders AS t
USING updates AS s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *`], [`What is this command primarily implementing?`, `Was implementiert dieser Befehl primär?`], [['A', 'An upsert into a Delta table', 'Ein Upsert in eine Delta-Tabelle'], ['B', 'A full table backup to archive storage', 'Ein vollständiges Tabellenbackup in Archivspeicher'], ['C', 'A row-level security policy', 'Eine Row-Level-Security-Richtlinie'], ['D', 'An Event Hubs consumer group', 'Eine Event-Hubs-Consumer-Group']], ['A'], [`MERGE is the standard Delta Lake pattern for matching existing keys, updating changed rows, and inserting new rows in one transaction.`, `MERGE ist das Standardmuster in Delta Lake, um vorhandene Schlüssel abzugleichen, geänderte Zeilen zu aktualisieren und neue Zeilen in einer Transaktion einzufügen.`], [`Matched rows update, unmatched rows insert.`, `Passende Zeilen werden aktualisiert, nicht passende eingefügt.`], refs.databricksMerge),
    q('single', 'dp203-323', processing, 'hard', [`A dimension in Delta Lake must preserve history whenever a customer segment changes.`, `Eine Dimension in Delta Lake muss die Historie bewahren, wenn sich ein Kundensegment ändert.`], [`Which approach is best?`, `Welcher Ansatz ist am besten?`], [['A', 'Use a Type 2 pattern that expires the old row and inserts a new current row', 'Ein Typ-2-Muster verwenden, das die alte Zeile auslaufen lässt und eine neue aktuelle Zeile einfügt'], ['B', 'Overwrite the table every time without tracking dates', 'Die Tabelle jedes Mal überschreiben, ohne Daten nachzuverfolgen'], ['C', 'Store the segment only in Event Hubs', 'Das Segment nur in Event Hubs speichern'], ['D', 'Use result set caching', 'Resultset-Caching verwenden']], ['A'], [`A Type 2 implementation keeps full history by closing the prior version and creating a new active version for the changed business key.`, `Eine Typ-2-Implementierung bewahrt die vollständige Historie, indem die vorherige Version geschlossen und eine neue aktive Version für den geänderten Geschäftsschlüssel erstellt wird.`], [`The key requirement is historical versioning.`, `Die zentrale Anforderung ist historische Versionierung.`], refs.databricksMerge),
    q('multiple', 'dp203-324', processing, 'medium', [`An Azure Data Factory pipeline should copy a file only when it exists in a landing container. If the file is missing, the pipeline should skip the load gracefully.`, `Eine Azure-Data-Factory-Pipeline soll eine Datei nur dann kopieren, wenn sie in einem Landing-Container vorhanden ist. Fehlt die Datei, soll die Pipeline den Ladevorgang sauber überspringen.`], [`Which two activities are the best fit?`, `Welche zwei Aktivitäten passen am besten?`], [['A', 'Get Metadata', 'Get Metadata'], ['B', 'If Condition', 'If Condition'], ['C', 'Consumer group', 'Consumer Group'], ['D', 'Materialized view', 'Materialisierte Sicht']], ['A', 'B'], [`Get Metadata can check whether the file exists, and If Condition can branch the pipeline based on that result.`, `Get Metadata kann prüfen, ob die Datei existiert, und If Condition kann die Pipeline auf Basis dieses Ergebnisses verzweigen.`], [`First detect file existence, then branch the control flow.`, `Prüfen Sie zuerst die Dateiexistenz und verzweigen Sie dann den Ablauf.`], refs.adfGetMetadata),
    q('single', 'dp203-325', processing, 'medium', [`A single pipeline loads country-specific files from paths such as /sales/us/, /sales/de/, and /sales/fr/. You want one reusable dataset definition instead of a separate dataset per country.`, `Eine einzelne Pipeline lädt länderspezifische Dateien aus Pfaden wie /sales/us/, /sales/de/ und /sales/fr/. Sie möchten eine wiederverwendbare Datasetdefinition statt eines separaten Datasets pro Land.`], [`What should you use?`, `Was sollten Sie verwenden?`], [['A', 'Dataset parameters', 'Datasetparameter'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'TDE', 'TDE'], ['D', 'A clustered index', 'Einen geclusterten Index']], ['A'], [`Dataset parameters let you pass folder names, file names, or other values at runtime so one dataset can serve many sources.`, `Datasetparameter erlauben es, Ordnernamen, Dateinamen oder andere Werte zur Laufzeit zu übergeben, sodass ein Dataset viele Quellen bedienen kann.`], [`Reuse one definition by passing path values dynamically.`, `Verwenden Sie eine Definition mehrfach, indem Sie Pfadwerte dynamisch übergeben.`], refs.adfParameters),
    q('single', 'dp203-326', processing, 'medium', [`A nightly copy from an on-premises SQL Server to Azure keeps failing before the transfer starts. The pipeline uses a self-hosted integration runtime.`, `Eine nächtliche Kopie von einem lokalen SQL Server nach Azure schlägt immer fehl, bevor die Übertragung beginnt. Die Pipeline verwendet eine Self-Hosted Integration Runtime.`], [`What is the most likely area to check first?`, `Welchen Bereich sollten Sie zuerst prüfen?`], [['A', 'Whether the self-hosted integration runtime is online and healthy', 'Ob die Self-Hosted Integration Runtime online und fehlerfrei ist'], ['B', 'Whether a Spark cache was cleared', 'Ob ein Spark-Cache geleert wurde'], ['C', 'Whether a Delta table was vacuumed', 'Ob eine Delta-Tabelle vakuumiert wurde'], ['D', 'Whether a materialized view exists', 'Ob eine materialisierte Sicht existiert']], ['A'], [`On-premises connectivity depends on the self-hosted integration runtime. If it is offline or unhealthy, the copy cannot start.`, `Die lokale Konnektivität hängt von der Self-Hosted Integration Runtime ab. Ist sie offline oder fehlerhaft, kann der Kopiervorgang nicht starten.`], [`The pipeline never reaches the actual data move.`, `Die Pipeline erreicht nie den eigentlichen Datentransfer.`], refs.adfIR),
    q('single', 'dp203-327', processing, 'medium', [`You need an Azure Data Factory trigger that processes fixed hourly slices, supports dependency tracking between slices, and can rerun missed intervals.`, `Sie benötigen einen Azure-Data-Factory-Trigger, der feste stündliche Zeitfenster verarbeitet, Abhängigkeiten zwischen Fenstern unterstützt und verpasste Intervalle erneut ausführen kann.`], [`Which trigger should you choose?`, `Welchen Trigger sollten Sie wählen?`], [['A', 'Tumbling window trigger', 'Tumbling-Window-Trigger'], ['B', 'Manual trigger', 'Manueller Trigger'], ['C', 'Event trigger', 'Ereignistrigger'], ['D', 'Notebook activity', 'Notebook-Aktivität']], ['A'], [`Tumbling window triggers are built for contiguous time windows with retry and dependency semantics.`, `Tumbling-Window-Trigger sind für lückenlose Zeitfenster mit Wiederholungs- und Abhängigkeitssemantik ausgelegt.`], [`The requirement is about contiguous, managed windows.`, `Die Anforderung betrifft lückenlose, verwaltete Zeitfenster.`], refs.adfTriggers),
    q('single', 'dp203-328', processing, 'medium', [`A streaming job must calculate a 15-minute moving average every 5 minutes.`, `Ein Streaming-Job muss alle 5 Minuten einen gleitenden 15-Minuten-Durchschnitt berechnen.`], [`Which Stream Analytics window type should you use?`, `Welchen Fenstertyp in Stream Analytics sollten Sie verwenden?`], [['A', 'Hopping window', 'Hopping Window'], ['B', 'Tumbling window', 'Tumbling Window'], ['C', 'Session window', 'Session Window'], ['D', 'Reference window', 'Reference Window']], ['A'], [`A hopping window produces overlapping windows at a chosen hop size, which fits moving averages such as 15 minutes every 5 minutes.`, `Ein Hopping Window erzeugt überlappende Fenster mit einer gewählten Hop-Größe und passt damit zu gleitenden Durchschnitten wie 15 Minuten alle 5 Minuten.`], [`The windows must overlap.`, `Die Fenster müssen sich überlappen.`], refs.streamWindows),
    q('single', 'dp203-329', processing, 'medium', [`You analyze clickstream sessions and want a new window whenever a user has been inactive for several minutes.`, `Sie analysieren Clickstream-Sitzungen und möchten ein neues Fenster beginnen, sobald ein Benutzer mehrere Minuten inaktiv war.`], [`Which window type is the best fit?`, `Welcher Fenstertyp passt am besten?`], [['A', 'Session window', 'Session Window'], ['B', 'Tumbling window', 'Tumbling Window'], ['C', 'Snapshot window', 'Snapshot Window'], ['D', 'Archive window', 'Archivfenster']], ['A'], [`Session windows are based on periods of activity separated by gaps of inactivity, which matches user-session analysis.`, `Session Windows basieren auf Aktivitätsphasen, die durch Inaktivitätslücken getrennt sind. Das passt zur Analyse von Benutzersitzungen.`], [`The clue is inactivity timeout.`, `Der Hinweis ist das Timeout bei Inaktivität.`], refs.streamWindows),
    q('single', 'dp203-330', processing, 'hard', [`A Stream Analytics job receives events late and sometimes out of order from IoT devices.`, `Ein Stream-Analytics-Job erhält Ereignisse von IoT-Geräten verspätet und teilweise in falscher Reihenfolge.`], [`Which capability is designed to handle this situation?`, `Welche Funktion ist dafür vorgesehen, diese Situation zu handhaben?`], [['A', 'Late arrival and out-of-order event policies', 'Richtlinien für verspätete und falsch geordnete Ereignisse'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'A replicated table', 'Eine replizierte Tabelle'], ['D', 'A heap staging table', 'Eine Heap-Staging-Tabelle']], ['A'], [`Stream Analytics provides event-ordering controls so you can tolerate late and out-of-order data within configured limits.`, `Stream Analytics stellt Steuerelemente für die Ereignisreihenfolge bereit, sodass Sie verspätete und falsch geordnete Daten innerhalb konfigurierter Grenzen tolerieren können.`], [`This is about event-time handling, not storage.`, `Hier geht es um die Behandlung von Ereigniszeit und nicht um Speicherung.`], refs.streamOrdering),
    q('single', 'dp203-331', processing, 'medium', null, [`What is the main reason to increase the number of partitions in an Event Hub for a high-throughput stream?`, `Was ist der Hauptgrund, die Anzahl der Partitionen in einem Event Hub für einen Stream mit hohem Durchsatz zu erhöhen?`], [['A', 'To enable more parallel reading and writing', 'Um mehr paralleles Lesen und Schreiben zu ermöglichen'], ['B', 'To encrypt messages client side', 'Um Nachrichten clientseitig zu verschlüsseln'], ['C', 'To create row-level security', 'Um Row-Level Security zu erstellen'], ['D', 'To pause a dedicated SQL pool', 'Um einen Dedicated SQL Pool zu pausieren']], ['A'], [`Partitions are the unit of parallelism in Event Hubs. More partitions can support more concurrent producers and consumers.`, `Partitionen sind die Parallelitätseinheit in Event Hubs. Mehr Partitionen können mehr gleichzeitige Produzenten und Konsumenten unterstützen.`], [`Think throughput and parallelism.`, `Denken Sie an Durchsatz und Parallelität.`], refs.eventHubs),
    q('single', 'dp203-332', processing, 'medium', null, [`Two independent applications must read the same Event Hub stream at their own pace without interfering with each other. What should you configure?`, `Zwei unabhängige Anwendungen müssen denselben Event-Hub-Stream in ihrem eigenen Tempo lesen, ohne sich gegenseitig zu beeinflussen. Was sollten Sie konfigurieren?`], [['A', 'Separate consumer groups', 'Separate Consumer Groups'], ['B', 'A single shared checkpoint only', 'Nur einen gemeinsamen Checkpoint'], ['C', 'A clustered columnstore index', 'Einen geclusterten Columnstore-Index'], ['D', 'Dynamic masking', 'Dynamische Maskierung']], ['A'], [`Consumer groups allow independent views of the event stream so multiple applications can track their own offsets separately.`, `Consumer Groups ermöglichen unabhängige Sichten auf den Ereignisstrom, sodass mehrere Anwendungen ihre Offsets getrennt verfolgen können.`], [`Each application needs its own read position.`, `Jede Anwendung benötigt ihre eigene Leseposition.`], refs.eventHubs),
    q('single', 'dp203-333', processing, 'medium', [`You want Event Hubs to automatically persist the incoming event stream to Azure Storage for downstream batch processing.`, `Sie möchten, dass Event Hubs den eingehenden Ereignisstrom automatisch in Azure Storage persistiert, damit er nachgelagert per Batch verarbeitet werden kann.`], [`Which feature should you enable?`, `Welche Funktion sollten Sie aktivieren?`], [['A', 'Event Hubs Capture', 'Event Hubs Capture'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'Always Encrypted', 'Always Encrypted'], ['D', 'Result set caching', 'Resultset-Caching']], ['A'], [`Event Hubs Capture automatically writes the stream to Azure Storage, which is useful for archival and later batch analytics.`, `Event Hubs Capture schreibt den Stream automatisch in Azure Storage, was für Archivierung und spätere Batch-Analysen nützlich ist.`], [`The stream must be landed automatically for later use.`, `Der Stream soll automatisch für die spätere Nutzung abgelegt werden.`], refs.eventHubsCapture),
    q('single', 'dp203-334', processing, 'hard', [`A Structured Streaming job writes to Delta Lake with this setting:
.option('checkpointLocation', '/chk/orders')`, `Ein Structured-Streaming-Job schreibt mit dieser Einstellung in Delta Lake:
.option('checkpointLocation', '/chk/orders')`], [`Why is the checkpoint location important?`, `Warum ist der Checkpoint-Speicherort wichtig?`], [['A', 'It stores progress and state so the stream can recover after restarts', 'Er speichert Fortschritt und Zustand, damit der Stream nach Neustarts wiederhergestellt werden kann'], ['B', 'It encrypts the Delta table', 'Er verschlüsselt die Delta-Tabelle'], ['C', 'It creates a private endpoint', 'Er erstellt einen Private Endpoint'], ['D', 'It disables shuffles', 'Er deaktiviert Shuffles']], ['A'], [`Structured Streaming uses checkpoints to track offsets and state. Without them, restart behavior and exactly-once processing guarantees are weakened.`, `Structured Streaming verwendet Checkpoints, um Offsets und Zustand zu verfolgen. Ohne sie werden Neustartverhalten und Exactly-Once-Verarbeitungsgarantien geschwächt.`], [`Recovery metadata is the main purpose.`, `Wiederherstellungsmetadaten sind der Hauptzweck.`], refs.databricksStreaming),
    q('single', 'dp203-335', processing, 'hard', [`A streaming aggregation keeps growing in memory because the engine never knows when old keys are safe to evict.`, `Eine Streaming-Aggregation wächst ständig im Speicher, weil die Engine nie weiß, wann alte Schlüssel sicher verworfen werden können.`], [`What should you add?`, `Was sollten Sie hinzufügen?`], [['A', 'A watermark on the event-time column', 'Einen Watermark auf der Ereigniszeitspalte'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'A replicated table', 'Eine replizierte Tabelle'], ['D', 'Transparent Data Encryption', 'Transparent Data Encryption']], ['A'], [`A watermark tells the engine how much lateness to tolerate and when older state can be removed. That is critical for bounded state in streaming aggregations.`, `Ein Watermark teilt der Engine mit, wie viel Verspätung toleriert werden soll und wann älterer Zustand entfernt werden kann. Das ist entscheidend für begrenzten Zustand in Streaming-Aggregationen.`], [`The issue is unbounded state growth.`, `Das Problem ist unbegrenztes Zustandswachstum.`], refs.databricksStreaming),
    q('single', 'dp203-336', processing, 'hard', [`A Spark SQL query joins a 4 TB fact table with a 20 MB dimension:
SELECT /*+ BROADCAST(dim) */ *
FROM fact f
JOIN dim d ON f.CustomerKey = d.CustomerKey;`, `Eine Spark-SQL-Abfrage verknüpft eine 4-TB-Faktentabelle mit einer 20-MB-Dimension:
SELECT /*+ BROADCAST(dim) */ *
FROM fact f
JOIN dim d ON f.CustomerKey = d.CustomerKey;`], [`What is the benefit of the BROADCAST hint here?`, `Welchen Vorteil hat der BROADCAST-Hint hier?`], [['A', 'It sends the small table to executors and avoids shuffling the large table', 'Er sendet die kleine Tabelle an die Executors und vermeidet das Shuffling der großen Tabelle'], ['B', 'It enables row-level security on the dimension', 'Er aktiviert Row-Level Security auf der Dimension'], ['C', 'It writes the result to Event Hubs', 'Er schreibt das Ergebnis in Event Hubs'], ['D', 'It creates a serverless external table', 'Er erstellt eine serverlose externe Tabelle']], ['A'], [`Broadcast joins are efficient when one side is small enough to send to all executors, allowing the large side to stay in place.`, `Broadcast Joins sind effizient, wenn eine Seite klein genug ist, um an alle Executors gesendet zu werden, sodass die große Seite an Ort und Stelle bleiben kann.`], [`The dimension is tiny compared to the fact table.`, `Die Dimension ist im Vergleich zur Faktentabelle sehr klein.`], refs.sparkUI),
    q('single', 'dp203-337', processing, 'medium', [`A Spark job reads a very large table and then performs a wide transformation that suffers from task imbalance.`, `Ein Spark-Job liest eine sehr große Tabelle und führt danach eine breite Transformation aus, die unter unausgeglichenen Tasks leidet.`], [`Which action is most appropriate before the transformation?`, `Welche Maßnahme ist vor der Transformation am geeignetsten?`], [['A', 'Repartition the DataFrame', 'Das DataFrame repartitionieren'], ['B', 'Enable dynamic masking', 'Dynamische Maskierung aktivieren'], ['C', 'Create a consumer group', 'Eine Consumer Group erstellen'], ['D', 'Pause the SQL pool', 'Den SQL Pool pausieren']], ['A'], [`repartition() redistributes data across partitions and can improve parallelism for wide operations that would otherwise be unbalanced.`, `repartition() verteilt Daten über Partitionen neu und kann die Parallelität für breite Operationen verbessern, die sonst unausgewogen wären.`], [`You need better parallel distribution before a wide shuffle.`, `Sie benötigen eine bessere parallele Verteilung vor einem breiten Shuffle.`], refs.sparkUI),
    q('single', 'dp203-338', processing, 'medium', [`After a heavy filter, a DataFrame becomes much smaller and you want to reduce the number of output files before writing it.`, `Nach einem starken Filter wird ein DataFrame deutlich kleiner, und Sie möchten die Anzahl der Ausgabedateien vor dem Schreiben reduzieren.`], [`Which Spark operation is usually the best fit?`, `Welche Spark-Operation ist normalerweise am besten geeignet?`], [['A', 'coalesce()', 'coalesce()'], ['B', 'checkpoint()', 'checkpoint()'], ['C', 'mask()', 'mask()'], ['D', 'UNION ALL', 'UNION ALL']], ['A'], [`coalesce() reduces the number of partitions with less shuffle than repartition() in many shrink scenarios, which is useful before writing smaller datasets.`, `coalesce() reduziert die Anzahl der Partitionen in vielen Schrumpf-Szenarien mit weniger Shuffle als repartition(). Das ist nützlich, bevor kleinere Datensätze geschrieben werden.`], [`The data size has already been reduced.`, `Die Datengröße wurde bereits reduziert.`], refs.sparkUI),
    q('single', 'dp203-339', processing, 'medium', [`A notebook computes the same expensive base DataFrame several times in later steps.`, `Ein Notebook berechnet dasselbe teure Basis-DataFrame in späteren Schritten mehrfach.`], [`What should you do to avoid repeated recomputation?`, `Was sollten Sie tun, um wiederholte Neuberechnung zu vermeiden?`], [['A', 'Cache the DataFrame', 'Das DataFrame cachen'], ['B', 'Convert it to CSV immediately', 'Es sofort in CSV konvertieren'], ['C', 'Apply dynamic masking', 'Dynamische Maskierung anwenden'], ['D', 'Create an Event Hubs partition', 'Eine Event-Hubs-Partition erstellen']], ['A'], [`Caching keeps reused data in memory or on disk for the current session, which reduces repeated lineage execution.`, `Caching hält wiederverwendete Daten für die aktuelle Sitzung im Speicher oder auf Datenträger und reduziert so wiederholte Lineage-Ausführung.`], [`The issue is repeated reuse in the same workflow.`, `Das Problem ist die wiederholte Wiederverwendung im selben Ablauf.`],     refs.sparkUI),
    q('single', 'dp203-340', processing, 'medium', null, [`What is Adaptive Query Execution in Spark mainly designed to do?`, `Wofür ist Adaptive Query Execution in Spark hauptsächlich gedacht?`], [['A', 'Adjust the physical plan at runtime based on observed statistics', 'Den physischen Plan zur Laufzeit basierend auf beobachteten Statistiken anzupassen'], ['B', 'Create linked services in ADF', 'Linked Services in ADF zu erstellen'], ['C', 'Encrypt data at rest', 'Daten im Ruhezustand zu verschlüsseln'], ['D', 'Pause Synapse SQL pools', 'Synapse-SQL-Pools zu pausieren']], ['A'], [`AQE can switch join strategies, rebalance shuffle partitions, and handle skew using runtime information gathered during execution.`, `AQE kann Join-Strategien wechseln, Shuffle-Partitionen neu ausbalancieren und Skew anhand von Laufzeitinformationen behandeln, die während der Ausführung gesammelt werden.`], [`This feature adapts while the query is running.`, `Diese Funktion passt sich an, während die Abfrage läuft.`], refs.sparkUI),
    q('single', 'dp203-341', processing, 'medium', [`A Spark job is slow and you need to inspect stages, task times, shuffle size, and skew.`, `Ein Spark-Job ist langsam, und Sie müssen Stages, Task-Zeiten, Shuffle-Größe und Skew prüfen.`], [`Which tool should you open first?`, `Welches Tool sollten Sie zuerst öffnen?`], [['A', 'Spark UI', 'Spark UI'], ['B', 'Azure Key Vault', 'Azure Key Vault'], ['C', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['D', 'Consumer groups', 'Consumer Groups']], ['A'], [`The Spark UI exposes execution details at the job, stage, and task level, which makes it the primary troubleshooting surface for Spark performance.`, `Die Spark UI zeigt Ausführungsdetails auf Job-, Stage- und Task-Ebene an und ist damit die wichtigste Oberfläche für die Fehlerbehebung bei der Spark-Leistung.`], [`You need execution internals, not secret management.`, `Sie benötigen Ausführungsdetails und kein Geheimnismanagement.`], refs.sparkUI),
    q('single', 'dp203-342', processing, 'medium', [`An Azure Data Factory mapping data flow starts failing because new columns appear in the source unexpectedly and must flow through without hard-coding each column.`, `Ein Azure-Data-Factory-Mapping-Data-Flow beginnt zu scheitern, weil unerwartet neue Spalten in der Quelle auftauchen und ohne hart codierte Auflistung jeder Spalte weiterfließen müssen.`], [`Which feature should you enable?`, `Welche Funktion sollten Sie aktivieren?`], [['A', 'Schema drift', 'Schema Drift'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'Result set caching', 'Resultset-Caching'], ['D', 'Consumer groups', 'Consumer Groups']], ['A'], [`Schema drift allows data flows to handle evolving source columns without requiring strict predefined mappings for every new field.`, `Schema Drift erlaubt Data Flows, mit sich entwickelnden Quellspalten umzugehen, ohne für jedes neue Feld eine strikt vordefinierte Zuordnung zu verlangen.`], [`The challenge is evolving source structure.`, `Die Herausforderung ist eine sich entwickelnde Quellstruktur.`], refs.adfDataFlow),
    q('single', 'dp203-343', processing, 'medium', [`A SQL source must provide inserts, updates, and deletes incrementally to downstream pipelines with minimal custom logic.`, `Eine SQL-Quelle muss Einfügungen, Aktualisierungen und Löschungen inkrementell mit minimaler kundenspezifischer Logik an nachgelagerte Pipelines liefern.`], [`Which source capability should you enable if it is available?`, `Welche Quellfunktion sollten Sie aktivieren, falls verfügbar?`], [['A', 'Change Data Capture', 'Change Data Capture'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'A materialized view', 'Eine materialisierte Sicht'], ['D', 'A consumer group', 'Eine Consumer Group']], ['A'], [`CDC records data changes in change tables so downstream processes can read incremental inserts, updates, and deletes.`, `CDC protokolliert Datenänderungen in Änderungstabellen, sodass nachgelagerte Prozesse inkrementelle Einfügungen, Aktualisierungen und Löschungen lesen können.`], [`You want native change tracking of DML operations.`, `Sie möchten native Änderungsverfolgung von DML-Operationen.`], refs.sqlCdc),
    q('single', 'dp203-344', processing, 'medium', [`A source system does not support CDC, but every row has a LastModifiedDate column.`, `Ein Quellsystem unterstützt kein CDC, aber jede Zeile hat eine Spalte LastModifiedDate.`], [`Which incremental loading pattern should you use?`, `Welches Muster für inkrementelles Laden sollten Sie verwenden?`], [['A', 'A watermark based on the last successful LastModifiedDate value', 'Einen Watermark basierend auf dem letzten erfolgreichen LastModifiedDate-Wert'], ['B', 'A random sample each hour', 'Eine Zufallsstichprobe pro Stunde'], ['C', 'Dynamic masking of all columns', 'Dynamische Maskierung aller Spalten'], ['D', 'A clustered index rebuild every minute', 'Einen Neuaufbau des geclusterten Index jede Minute']], ['A'], [`A watermark pattern stores the last processed timestamp and uses it to request only newer or changed rows in the next run.`, `Ein Watermark-Muster speichert den zuletzt verarbeiteten Zeitstempel und verwendet ihn, um im nächsten Lauf nur neuere oder geänderte Zeilen anzufordern.`], [`Use the column that represents change time.`, `Verwenden Sie die Spalte, die den Änderungszeitpunkt repräsentiert.`], refs.adfParameters),
    q('multiple', 'dp203-345', processing, 'hard', [`An ADF pipeline copies hundreds of files in parallel, but the source system starts throttling and copy failures increase.`, `Eine ADF-Pipeline kopiert Hunderte von Dateien parallel, aber das Quellsystem beginnt zu drosseln, und die Anzahl der Copy-Fehler steigt.`], [`Which two actions are most likely to help first?`, `Welche zwei Maßnahmen helfen am ehesten zuerst?`], [['A', 'Reduce ForEach batch count or pipeline concurrency', 'Die Batch-Anzahl von ForEach oder die Pipeline-Parallelität reduzieren'], ['B', 'Lower Copy activity parallelism where appropriate', 'Die Parallelität der Copy-Aktivität passend reduzieren'], ['C', 'Enable dynamic data masking', 'Dynamische Datenmaskierung aktivieren'], ['D', 'Create a materialized view in the sink', 'Im Ziel eine materialisierte Sicht erstellen']], ['A', 'B'], [`When the source is overloaded, the first tuning step is usually to reduce request fan-out. Lower concurrency often stabilizes the pipeline.`, `Wenn die Quelle überlastet ist, besteht der erste Tuning-Schritt meist darin, die Anfragespreizung zu reduzieren. Geringere Parallelität stabilisiert die Pipeline oft.`], [`The symptom is source throttling, so reduce parallel pressure.`, `Das Symptom ist Quelldrosselung. Reduzieren Sie daher den parallelen Druck.`], refs.adfCopy),
    q('single', 'dp203-346', processing, 'medium', [`A pipeline must keep checking every few minutes whether a partner file has arrived, and continue only after the file appears.`, `Eine Pipeline muss alle paar Minuten weiter prüfen, ob eine Partnerdatei eingetroffen ist, und erst danach fortfahren.`], [`Which control-flow activity is the best fit around the check logic?`, `Welche Control-Flow-Aktivität passt am besten um diese Prüflogik herum?`], [['A', 'Until', 'Until'], ['B', 'Lookup only', 'Nur Lookup'], ['C', 'Notebook activity only', 'Nur Notebook-Aktivität'], ['D', 'Dynamic masking', 'Dynamische Maskierung']], ['A'], [`The Until activity repeats enclosed logic until a condition becomes true, which fits polling patterns such as waiting for file arrival.`, `Die Until-Aktivität wiederholt eingeschlossene Logik, bis eine Bedingung wahr wird. Das passt zu Polling-Mustern wie dem Warten auf Dateieingänge.`], [`You need looping control flow, not just a single check.`, `Sie benötigen eine Schleifensteuerung und nicht nur eine einzelne Prüfung.`], refs.adfControlFlow),
    q('single', 'dp203-347', processing, 'medium', [`A Stream Analytics query must produce exactly one result for each non-overlapping 1-hour period.`, `Eine Stream-Analytics-Abfrage muss genau ein Ergebnis für jeden nicht überlappenden Zeitraum von 1 Stunde liefern.`], [`Which window type should you use?`, `Welchen Fenstertyp sollten Sie verwenden?`], [['A', 'Tumbling window', 'Tumbling Window'], ['B', 'Hopping window', 'Hopping Window'], ['C', 'Session window', 'Session Window'], ['D', 'Sliding cache', 'Sliding Cache']], ['A'], [`Tumbling windows divide time into fixed, non-overlapping buckets. That matches one result per hour with no overlap.`, `Tumbling Windows teilen die Zeit in feste, nicht überlappende Intervalle. Das passt zu genau einem Ergebnis pro Stunde ohne Überlappung.`], [`No overlap is the critical clue.`, `Keine Überlappung ist der entscheidende Hinweis.`], refs.streamWindows),
    q('single', 'dp203-348', processing, 'medium', [`You need an orchestration step in Synapse or ADF that executes notebook code as part of a pipeline.`, `Sie benötigen einen Orchestrierungsschritt in Synapse oder ADF, der Notebook-Code als Teil einer Pipeline ausführt.`], [`Which activity type should you use?`, `Welchen Aktivitätstyp sollten Sie verwenden?`], [['A', 'Notebook activity', 'Notebook-Aktivität'], ['B', 'Get Metadata', 'Get Metadata'], ['C', 'Consumer group', 'Consumer Group'], ['D', 'Security policy', 'Sicherheitsrichtlinie']], ['A'], [`Notebook activities let pipelines invoke Spark-based notebook logic in orchestrated workflows.`, `Notebook-Aktivitäten erlauben Pipelines, Spark-basierten Notebook-Code in orchestrierten Workflows auszuführen.`], [`The requirement is code execution from orchestration.`, `Die Anforderung ist Codeausführung aus der Orchestrierung heraus.`], refs.synapseSpark),
    q('single', 'dp203-349', processing, 'medium', [`A team wants to transform raw files and write curated Delta tables back to the lake. They first tried serverless SQL but then realized the target operation requires writing files.`, `Ein Team möchte rohe Dateien transformieren und kuratierte Delta-Tabellen zurück in den Lake schreiben. Zuerst wurde serverloses SQL versucht, dann aber erkannt, dass der Zielvorgang das Schreiben von Dateien erfordert.`], [`Which compute option should they choose?`, `Welche Compute-Option sollten sie wählen?`], [['A', 'Spark, such as Synapse Spark or Azure Databricks', 'Spark, z. B. Synapse Spark oder Azure Databricks'], ['B', 'Serverless SQL only', 'Nur serverloses SQL'], ['C', 'Dynamic masking', 'Dynamische Maskierung'], ['D', 'A consumer group', 'Eine Consumer Group']], ['A'], [`Spark engines are designed to read, transform, and write lake files and Delta tables. Serverless SQL is mainly for querying external data.`, `Spark-Engines sind dafür ausgelegt, Lake-Dateien und Delta-Tabellen zu lesen, zu transformieren und zu schreiben. Serverloses SQL ist hauptsächlich für das Abfragen externer Daten gedacht.`], [`The missing capability is writing transformed lake data.`, `Die fehlende Fähigkeit ist das Schreiben transformierter Lake-Daten.`], refs.synapseSpark),
    q('single', 'dp203-350', security, 'hard', [`You need to restrict table rows dynamically so users see only the rows allowed for them.`, `Sie müssen Tabellenzeilen dynamisch einschränken, sodass Benutzer nur die für sie erlaubten Zeilen sehen.`], [`Which SQL Server feature should you implement?`, `Welche SQL-Server-Funktion sollten Sie implementieren?`], [['A', 'Row-level security with a security policy', 'Row-Level Security mit einer Sicherheitsrichtlinie'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'A tumbling window', 'Ein Tumbling Window'], ['D', 'Event Hubs Capture', 'Event Hubs Capture']], ['A'], [`Row-level security uses predicate functions and security policies to filter table rows transparently based on the caller context.`, `Row-Level Security verwendet Prädikatfunktionen und Sicherheitsrichtlinien, um Tabellenzeilen transparent basierend auf dem Aufruferkontext zu filtern.`], [`The requirement is per-row filtering.`, `Die Anforderung ist zeilenweises Filtern.`], refs.rowLevelSecurity),
    q('single', 'dp203-351', security, 'hard', [`A sales table contains RegionCode. Users should automatically see only rows for their own region based on their login context.`, `Eine Verkaufstabelle enthält RegionCode. Benutzer sollen basierend auf ihrem Anmeldekontext automatisch nur Zeilen ihrer eigenen Region sehen.`], [`What is the best design?`, `Welches Design ist am besten?`], [['A', 'An RLS predicate that filters rows by the current user context', 'Ein RLS-Prädikat, das Zeilen anhand des aktuellen Benutzerkontexts filtert'], ['B', 'A clustered index on RegionCode only', 'Ein geclusterter Index nur auf RegionCode'], ['C', 'A broadcast join', 'Ein Broadcast Join'], ['D', 'A consumer group per user', 'Eine Consumer Group pro Benutzer']], ['A'], [`RLS is designed for user-specific row filtering at query time. It is a better fit than physical layout changes such as indexing.`, `RLS ist für benutzerspezifisches Zeilenfiltern zur Abfragezeit ausgelegt. Es ist passender als physische Layoutänderungen wie Indexierung.`], [`The visibility rule depends on who is querying.`, `Die Sichtbarkeitsregel hängt davon ab, wer abfragt.`], refs.rowLevelSecurity),
    q('single', 'dp203-352', security, 'medium', [`You must block access to the Salary column while still allowing users to query the other columns of the same table.`, `Sie müssen den Zugriff auf die Spalte Salary blockieren, Benutzern aber weiterhin erlauben, die anderen Spalten derselben Tabelle abzufragen.`], [`Which approach is most precise?`, `Welcher Ansatz ist am präzisesten?`], [['A', 'Column-level permissions', 'Berechtigungen auf Spaltenebene'], ['B', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['C', 'A session window', 'Ein Session Window'], ['D', 'Heap staging', 'Heap-Staging']], ['A'], [`Column-level permissions let you allow or deny access to specific columns instead of the whole table.`, `Berechtigungen auf Spaltenebene ermöglichen es, den Zugriff auf bestimmte Spalten statt auf die gesamte Tabelle zu erlauben oder zu verweigern.`], [`The requirement targets one column only.`, `Die Anforderung betrifft nur eine Spalte.`], refs.columnSecurity),
    q('single', 'dp203-353', security, 'medium', null, [`Which statement about dynamic data masking is correct?`, `Welche Aussage über dynamische Datenmaskierung ist korrekt?`], [['A', 'It obfuscates results for some users, but it is not a replacement for encryption or strict authorization', 'Sie verschleiert Ergebnisse für einige Benutzer, ist aber kein Ersatz für Verschlüsselung oder strenge Autorisierung'], ['B', 'It keeps data encrypted so the server never sees plaintext', 'Sie hält Daten verschlüsselt, sodass der Server nie Klartext sieht'], ['C', 'It replaces row-level security predicates', 'Sie ersetzt Row-Level-Security-Prädikate'], ['D', 'It optimizes Spark shuffles automatically', 'Sie optimiert Spark-Shuffles automatisch']], ['A'], [`Dynamic data masking changes the presentation of sensitive values for certain users. It does not provide the same protection model as encryption or deny access to the underlying data by itself.`, `Die dynamische Datenmaskierung verändert die Darstellung sensibler Werte für bestimmte Benutzer. Sie bietet nicht dasselbe Schutzmodell wie Verschlüsselung und verweigert den Zugriff auf die zugrunde liegenden Daten nicht von selbst.`], [`Masking is presentation-oriented, not full protection.`, `Maskierung ist darstellungsorientiert und kein vollständiger Schutz.`], refs.ddm),
    q('single', 'dp203-354', security, 'medium', null, [`Which feature primarily protects database files, backups, and transaction logs by encrypting data at rest?`, `Welche Funktion schützt Datenbankdateien, Backups und Transaktionsprotokolle primär durch Verschlüsselung ruhender Daten?`], [['A', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'Broadcast joins', 'Broadcast Joins'], ['D', 'A tumbling window trigger', 'Ein Tumbling-Window-Trigger']], ['A'], [`TDE encrypts the database storage layer and is focused on protecting data at rest.`, `TDE verschlüsselt die Speicherebene der Datenbank und konzentriert sich auf den Schutz ruhender Daten.`], [`Think storage-layer encryption.`, `Denken Sie an Verschlüsselung auf Speicherebene.`], refs.tde),
    q('single', 'dp203-355', security, 'hard', [`A compliance team requires that highly sensitive column values stay encrypted in the database engine and are decrypted only by authorized client applications.`, `Ein Compliance-Team verlangt, dass hochsensible Spaltenwerte in der Datenbank-Engine verschlüsselt bleiben und nur von autorisierten Clientanwendungen entschlüsselt werden.`], [`Which feature best fits this requirement?`, `Welche Funktion passt am besten zu dieser Anforderung?`], [['A', 'Always Encrypted', 'Always Encrypted'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'A materialized view', 'Eine materialisierte Sicht'], ['D', 'Tumbling windows', 'Tumbling Windows']], ['A'], [`Always Encrypted keeps protected column values encrypted on the server side and performs decryption on authorized clients.`, `Always Encrypted hält geschützte Spaltenwerte serverseitig verschlüsselt und führt die Entschlüsselung auf autorisierten Clients durch.`], [`The key phrase is client-side decryption.`, `Die entscheidende Formulierung ist clientseitige Entschlüsselung.`], refs.alwaysEncrypted),
    q('single', 'dp203-356', security, 'hard', null, [`Which Always Encrypted mode supports equality comparisons on protected columns but reveals more repeating-value patterns than the other mode?`, `Welcher Modus von Always Encrypted unterstützt Gleichheitsvergleiche auf geschützten Spalten, offenbart aber mehr Muster wiederkehrender Werte als der andere Modus?`], [['A', 'Deterministic encryption', 'Deterministische Verschlüsselung'], ['B', 'Randomized encryption', 'Randomisierte Verschlüsselung'], ['C', 'Transparent encryption', 'Transparente Verschlüsselung'], ['D', 'Archive encryption', 'Archivverschlüsselung']], ['A'], [`Deterministic encryption always produces the same ciphertext for the same plaintext. That enables equality matching but leaks repetition patterns.`, `Deterministische Verschlüsselung erzeugt für denselben Klartext immer denselben Chiffretext. Das ermöglicht Gleichheitsvergleiche, gibt aber Wiederholungsmuster preis.`], [`The trade-off is queryability versus pattern leakage.`, `Der Trade-off besteht zwischen Abfragbarkeit und Preisgabe von Mustern.`], refs.alwaysEncrypted),
    q('single', 'dp203-357', security, 'medium', [`ADF or Synapse must connect to Azure SQL Database without storing usernames and passwords in the pipeline definition.`, `ADF oder Synapse muss sich mit Azure SQL Database verbinden, ohne Benutzernamen und Kennwörter in der Pipelinedefinition zu speichern.`], [`Which authentication approach should you prefer?`, `Welchen Authentifizierungsansatz sollten Sie bevorzugen?`], [['A', 'Managed identity', 'Verwaltete Identität'], ['B', 'Embedded SQL login credentials', 'Eingebettete SQL-Login-Anmeldedaten'], ['C', 'Anonymous access', 'Anonymer Zugriff'], ['D', 'A consumer group', 'Eine Consumer Group']], ['A'], [`Managed identities provide passwordless service authentication to supported Azure resources and reduce secret-management risk.`, `Verwaltete Identitäten ermöglichen passwortlose Dienstauthentifizierung gegenüber unterstützten Azure-Ressourcen und verringern das Risiko bei der Geheimnisverwaltung.`], [`The goal is to avoid storing secrets at all.`, `Das Ziel ist, überhaupt keine Geheimnisse zu speichern.`],     refs.managedIdentity),
    q('single', 'dp203-358', security, 'medium', [`A linked service still needs a secret such as a connection string or key. Where should you store it for better security and rotation management?`, `Ein Linked Service benötigt weiterhin ein Geheimnis wie eine Verbindungszeichenfolge oder einen Schlüssel. Wo sollten Sie es für bessere Sicherheit und Rotationsverwaltung speichern?`], [`Which option is best?`, `Welche Option ist am besten?`], [['A', 'Azure Key Vault', 'Azure Key Vault'], ['B', 'A comment in the pipeline JSON', 'Ein Kommentar im Pipeline-JSON'], ['C', 'A CSV file in the raw zone', 'Eine CSV-Datei in der Raw-Zone'], ['D', 'A consumer group description', 'Eine Consumer-Group-Beschreibung']], ['A'], [`Azure Key Vault is the recommended Azure service for storing secrets outside code and pipeline definitions.`, `Azure Key Vault ist der empfohlene Azure-Dienst, um Geheimnisse außerhalb von Code und Pipelinedefinitionen zu speichern.`], [`Use the dedicated secret store.`, `Verwenden Sie den dedizierten Geheimnisspeicher.`], refs.keyVault),
    q('single', 'dp203-359', security, 'medium', [`A Synapse workspace runs inside a managed virtual network and must access an Azure Storage account privately.`, `Ein Synapse-Workspace läuft in einem verwalteten virtuellen Netzwerk und muss privat auf ein Azure-Storage-Konto zugreifen.`], [`What should you create?`, `Was sollten Sie erstellen?`], [['A', 'A managed private endpoint', 'Einen Managed Private Endpoint'], ['B', 'A result set cache', 'Einen Resultset-Cache'], ['C', 'A tumbling window', 'Ein Tumbling Window'], ['D', 'A broadcast join', 'Einen Broadcast Join']], ['A'], [`Managed private endpoints allow Synapse managed VNet resources to reach supported Azure services over private connectivity.`, `Managed Private Endpoints ermöglichen es Synapse-Ressourcen im verwalteten VNet, unterstützte Azure-Dienste über private Konnektivität zu erreichen.`], [`The requirement is private network access.`, `Die Anforderung ist privater Netzwerkzugriff.`], refs.managedVnet),
    q('single', 'dp203-360', security, 'hard', [`A Synapse engineer runs:
SELECT request_id, status, total_elapsed_time, command
FROM sys.dm_pdw_exec_requests
ORDER BY submit_time DESC;`, `Ein Synapse-Ingenieur führt aus:
SELECT request_id, status, total_elapsed_time, command
FROM sys.dm_pdw_exec_requests
ORDER BY submit_time DESC;`], [`What is this DMV query mainly used for?`, `Wofür wird diese DMV-Abfrage hauptsächlich verwendet?`], [['A', 'Monitoring request execution status in a dedicated SQL pool', 'Zum Überwachen des Ausführungsstatus von Anforderungen in einem Dedicated SQL Pool'], ['B', 'Configuring Event Hubs partitions', 'Zum Konfigurieren von Event-Hubs-Partitionen'], ['C', 'Creating Spark checkpoints', 'Zum Erstellen von Spark-Checkpoints'], ['D', 'Applying dynamic masking rules', 'Zum Anwenden dynamischer Maskierungsregeln']], ['A'], [`sys.dm_pdw_exec_requests shows submitted requests and their status, runtime, and command text, which helps with operational monitoring and troubleshooting.`, `sys.dm_pdw_exec_requests zeigt eingereichte Anforderungen sowie deren Status, Laufzeit und Befehlstext an. Das hilft bei Überwachung und Fehlerbehebung im Betrieb.`], [`The DMV is about warehouse requests.`, `Die DMV betrifft Warehouse-Anforderungen.`], refs.synapseMonitor),
    q('single', 'dp203-361', security, 'hard', [`A query is slow in a dedicated SQL pool and you want to inspect shuffles or other movement operations between distributions.`, `Eine Abfrage ist in einem Dedicated SQL Pool langsam, und Sie möchten Shuffles oder andere Verschiebungsoperationen zwischen Verteilungen untersuchen.`], [`Which DMV should you query?`, `Welche DMV sollten Sie abfragen?`], [['A', 'sys.dm_pdw_request_steps', 'sys.dm_pdw_request_steps'], ['B', 'sys.database_principals', 'sys.database_principals'], ['C', 'sys.schemas', 'sys.schemas'], ['D', 'sys.views', 'sys.views']], ['A'], [`sys.dm_pdw_request_steps breaks a request into its execution steps, which helps identify data movement and expensive phases.`, `sys.dm_pdw_request_steps zerlegt eine Anforderung in ihre Ausführungsschritte und hilft dadurch, Datenbewegungen und teure Phasen zu erkennen.`], [`You need step-level execution details.`, `Sie benötigen Ausführungsdetails auf Schrittebene.`], refs.synapseMonitor),
    q('single', 'dp203-362', security, 'medium', [`A fact table receives a large nightly load, and query plans become poor afterward because the optimizer has stale distribution information.`, `Eine Faktentabelle erhält jede Nacht einen großen Ladevorgang, und danach werden die Abfragepläne schlechter, weil der Optimierer veraltete Verteilungsinformationen hat.`], [`What should you do?`, `Was sollten Sie tun?`], [['A', 'Update statistics', 'Statistiken aktualisieren'], ['B', 'Create a consumer group', 'Eine Consumer Group erstellen'], ['C', 'Turn the table into CSV', 'Die Tabelle in CSV umwandeln'], ['D', 'Apply dynamic masking', 'Dynamische Maskierung anwenden']], ['A'], [`Statistics guide the optimizer. After significant data changes, refreshing them can improve cardinality estimates and execution plans.`, `Statistiken steuern den Optimierer. Nach erheblichen Datenänderungen kann ihre Aktualisierung Kardinalitätsschätzungen und Ausführungspläne verbessern.`], [`The problem is stale optimizer metadata.`, `Das Problem sind veraltete Optimierer-Metadaten.`], refs.synapseOptimize),
    q('single', 'dp203-363', security, 'medium', [`A dashboard repeatedly executes the same expensive aggregation over billions of rows. You want the aggregation precomputed for faster reads.`, `Ein Dashboard führt wiederholt dieselbe teure Aggregation über Milliarden von Zeilen aus. Sie möchten die Aggregation für schnellere Lesezugriffe vorberechnen.`], [`Which feature should you consider?`, `Welche Funktion sollten Sie in Betracht ziehen?`], [['A', 'A materialized view', 'Eine materialisierte Sicht'], ['B', 'A consumer group', 'Eine Consumer Group'], ['C', 'A session window', 'Ein Session Window'], ['D', 'TDE', 'TDE']], ['A'], [`Materialized views store precomputed results and can greatly accelerate repeated aggregations and joins.`, `Materialisierte Sichten speichern vorberechnete Ergebnisse und können wiederholte Aggregationen und Joins stark beschleunigen.`], [`The goal is precomputation for repeated queries.`, `Das Ziel ist Vorberechnung für wiederholte Abfragen.`], refs.synapseOptimize),
    q('single', 'dp203-364', security, 'medium', [`Users often rerun the exact same read-only query against unchanged data in a dedicated SQL pool.`, `Benutzer führen häufig exakt dieselbe schreibgeschützte Abfrage gegen unveränderte Daten in einem Dedicated SQL Pool erneut aus.`], [`Which feature can help return results faster without recomputing them?`, `Welche Funktion kann helfen, Ergebnisse schneller zurückzugeben, ohne sie neu zu berechnen?`], [['A', 'Result set caching', 'Resultset-Caching'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'Managed private endpoints', 'Managed Private Endpoints'], ['D', 'Event Hubs Capture', 'Event Hubs Capture']], ['A'], [`Result set caching can serve identical query results from cache when the underlying data has not changed.`, `Resultset-Caching kann identische Abfrageergebnisse aus dem Cache liefern, wenn sich die zugrunde liegenden Daten nicht geändert haben.`], [`The query is identical and the data is unchanged.`, `Die Abfrage ist identisch und die Daten sind unverändert.`], refs.synapseOptimize),
    q('single', 'dp203-365', security, 'easy', null, [`A dedicated SQL pool is completely idle every night. Which action most directly lowers compute cost during that period?`, `Ein Dedicated SQL Pool ist jede Nacht vollständig untätig. Welche Aktion senkt 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 an Event Hubs partition', 'Eine Event-Hubs-Partition hinzufügen']], ['A'], [`Pausing a dedicated SQL pool stops compute billing until it is resumed.`, `Das Pausieren eines Dedicated SQL Pools stoppt die Compute-Abrechnung, bis er fortgesetzt wird.`], [`No workload means you should not keep compute running.`, `Ohne Workload sollte Compute nicht weiterlaufen.`], refs.costMgmt),
    q('single', 'dp203-366', security, 'medium', [`A warehouse needs maximum performance only during a nightly load window and much less compute during the day.`, `Ein Warehouse benötigt nur während eines nächtlichen Ladefensters maximale Leistung und tagsüber deutlich weniger Compute.`], [`What is the best cost-performance strategy?`, `Was ist die beste Kosten-Leistungs-Strategie?`], [['A', 'Scale up for the load window and scale down afterward', 'Für das Ladefenster hochskalieren und danach herunterskalieren'], ['B', 'Keep the highest DWU level all day', 'Die höchste DWU-Stufe den ganzen Tag beibehalten'], ['C', 'Convert all tables to CSV', 'Alle Tabellen in CSV umwandeln'], ['D', 'Disable statistics', 'Statistiken deaktivieren']], ['A'], [`Dedicated SQL pools can be resized to match workload demand. Using more compute only when needed helps balance cost and runtime.`, `Dedicated SQL Pools können passend zum Workload skaliert werden. Mehr Compute nur bei Bedarf zu nutzen hilft, Kosten und Laufzeit auszubalancieren.`], [`Match compute to the workload window.`, `Passen Sie Compute an das Workload-Fenster an.`], refs.costMgmt),
    q('multiple', 'dp203-367', security, 'medium', null, [`Which two actions usually reduce cost in Synapse serverless SQL?`, `Welche zwei Aktionen reduzieren in Synapse serverlosem SQL normalerweise die Kosten?`], [['A', 'Project only the columns you need', 'Nur die benötigten Spalten projizieren'], ['B', 'Filter on partition columns or narrow file paths', 'Auf Partitionierungsspalten filtern oder Dateipfade eingrenzen'], ['C', 'Use SELECT * for every query', 'Für jede Abfrage SELECT * verwenden'], ['D', 'Store the same dataset as many tiny text files', 'Denselben Datensatz als viele winzige Textdateien speichern']], ['A', 'B'], [`Serverless SQL pricing is driven largely by data processed. Reading fewer columns and fewer files reduces that scanned volume.`, `Die Preisgestaltung von serverlosem SQL wird weitgehend durch die verarbeitete Datenmenge bestimmt. Weniger Spalten und weniger Dateien zu lesen reduziert dieses Scan-Volumen.`], [`The pricing model rewards scan minimization.`, `Das Preismodell belohnt die Minimierung gescannter Daten.`], refs.serverlessBest),
    q('single', 'dp203-368', security, 'medium', null, [`Which index type is usually best for a very large fact table in a dedicated SQL pool?`, `Welcher Indextyp ist für eine sehr große Faktentabelle in einem Dedicated SQL Pool normalerweise am besten?`], [['A', 'Clustered columnstore index', 'Geclusterter Columnstore-Index'], ['B', 'XML index', 'XML-Index'], ['C', 'Spatial index', 'Räumlicher Index'], ['D', 'No index in any case', 'In keinem Fall ein Index']], ['A'], [`Clustered columnstore indexes are the standard design for large analytical tables because they compress well and speed up scan-heavy workloads.`, `Geclusterte Columnstore-Indizes sind das Standarddesign für große analytische Tabellen, weil sie gut komprimieren und scanlastige Workloads beschleunigen.`], [`Think compression and large analytical scans.`, `Denken Sie an Komprimierung und große analytische Scans.`], refs.synapseOptimize),
    q('single', 'dp203-369', security, 'medium', null, [`Which table structure is commonly used for fast bulk landing into a staging table before later optimization?`, `Welche Tabellenstruktur wird üblicherweise für schnelles Bulk-Landing in eine Staging-Tabelle vor der späteren Optimierung verwendet?`], [['A', 'Heap', 'Heap'], ['B', 'Materialized view', 'Materialisierte Sicht'], ['C', 'Security policy', 'Sicherheitsrichtlinie'], ['D', 'Consumer group', 'Consumer Group']], ['A'], [`Heaps are often used in staging because they can support fast initial loads before data is transformed into final warehouse structures.`, `Heaps werden im Staging oft verwendet, weil sie schnelle initiale Ladevorgänge unterstützen, bevor die Daten in endgültige Warehouse-Strukturen transformiert werden.`], [`Landing speed matters more than final query performance in staging.`, `Im Staging zählt Landing-Geschwindigkeit mehr als endgültige Abfrageleistung.`], refs.synapseOptimize),
    q('single', 'dp203-370', security, 'hard', [`A large load into a dedicated SQL pool produces poorly compressed columnstore rowgroups because the session does not get enough memory.`, `Ein großer Ladevorgang in einen Dedicated SQL Pool erzeugt schlecht komprimierte Columnstore-Rowgroups, weil die Sitzung nicht genügend Speicher erhält.`], [`What should you consider increasing for the loading user?`, `Was sollten Sie für den ladenden Benutzer in Betracht ziehen zu erhöhen?`], [['A', 'The resource class', 'Die Resource Class'], ['B', 'The number of consumer groups', 'Die Anzahl der Consumer Groups'], ['C', 'The number of masks', 'Die Anzahl der Masken'], ['D', 'The archive tier retention', 'Die Aufbewahrungszeit im Archive Tier']], ['A'], [`Resource classes control memory allocation for operations in dedicated SQL pools. Larger classes can help memory-intensive loads create better rowgroups.`, `Resource Classes steuern die Speicherzuweisung für Operationen in Dedicated SQL Pools. Größere Klassen können speicherintensiven Ladevorgängen helfen, bessere Rowgroups zu erzeugen.`], [`The symptom points to memory allocation during load.`, `Das Symptom deutet auf Speicherzuweisung während des Ladevorgangs hin.`], refs.synapseOptimize),
    q('single', 'dp203-371', security, 'hard', null, [`When choosing a hash distribution column for a large dedicated SQL pool table, which property is most desirable?`, `Welche Eigenschaft ist bei der Auswahl einer Hash-Verteilungsspalte für eine große Tabelle in einem Dedicated SQL Pool am wünschenswertesten?`], [['A', 'Values are evenly distributed across rows and commonly used in joins', 'Die Werte sind gleichmäßig über die Zeilen verteilt und werden häufig in Joins verwendet'], ['B', 'The column contains mostly NULL values', 'Die Spalte enthält überwiegend NULL-Werte'], ['C', 'The column has only two distinct values', 'Die Spalte hat nur zwei unterschiedliche Werte'], ['D', 'The column changes meaning every week', 'Die Spalte ändert jede Woche ihre Bedeutung']], ['A'], [`A good hash key reduces skew and often reduces join data movement when it also aligns with major join patterns.`, `Ein guter Hash-Schlüssel reduziert Skew und verringert oft auch die Datenbewegung bei Joins, wenn er zusätzlich zu wichtigen Join-Mustern passt.`], [`You want even distribution plus useful join alignment.`, `Sie möchten gleichmäßige Verteilung plus sinnvolle Join-Ausrichtung.`], refs.synapseDist)
  ];

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