(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',
    blobTiers: 'https://learn.microsoft.com/en-us/azure/storage/blobs/access-tiers-overview',
    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',
    synapseMaterialized: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/performance-tuning-materialized-views',
    synapseResultCache: 'https://learn.microsoft.com/en-us/azure/synapse-analytics/sql-data-warehouse/performance-tuning-result-set-caching',
    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',
    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/',
    databricksClusters: 'https://learn.microsoft.com/en-us/azure/databricks/compute/',
    medallion: 'https://learn.microsoft.com/en-us/azure/databricks/lakehouse/medallion',
    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',
    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',
    starSchema: 'https://learn.microsoft.com/en-us/power-bi/guidance/star-schema',
    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-202', storage, 'easy', null, [`Which data lake zone should contain source data in its original format before cleansing and standardization?`, `Welche Data-Lake-Zone sollte Quelldaten im Originalformat enthalten, bevor Bereinigung und Standardisierung erfolgen?`], [['A', 'Raw or landing zone', 'Raw- oder Landing-Zone'], ['B', 'Curated or serving zone', 'Curated- oder Serving-Zone'], ['C', 'Presentation cache zone', 'Präsentations-Cache-Zone'], ['D', 'Archive compute zone', 'Archiv-Compute-Zone']], ['A'], [`The raw or landing zone is used to preserve source fidelity. Data is typically stored as received so engineers can reprocess it if business rules change later.`, `Die Raw- oder Landing-Zone dient dazu, die Originaltreue der Quelldaten zu bewahren. Die Daten werden typischerweise so gespeichert, wie sie eingegangen sind, damit sie später bei geänderten Fachregeln erneut verarbeitet werden können.`], [`Look for the zone that keeps data closest to the source system.`, `Suchen Sie nach der Zone, die den Daten am nächsten am Quellsystem hält.`], refs.lakeZones),
    q('single', 'dp203-203', storage, 'easy', null, [`Business analysts need certified, consumer-ready datasets with agreed schemas and quality checks. Which data lake zone is the best fit?`, `Fachanalysten benötigen zertifizierte, konsumfertige Datensätze mit abgestimmten Schemas und Qualitätsprüfungen. Welche Data-Lake-Zone ist dafür am besten geeignet?`], [['A', 'Raw zone', 'Raw-Zone'], ['B', 'Curated zone', 'Curated-Zone'], ['C', 'Transient ingestion zone', 'Temporäre Ingestion-Zone'], ['D', 'Source control zone', 'Source-Control-Zone']], ['B'], [`The curated zone contains cleaned, modeled, and validated data intended for downstream analytics consumers. It is where business-friendly datasets are commonly published.`, `Die Curated-Zone enthält bereinigte, modellierte und validierte Daten für nachgelagerte Analysekonsumenten. Dort werden üblicherweise fachlich nutzbare Datensätze veröffentlicht.`], [`Think of the zone most suitable for trusted reporting and self-service analytics.`, `Denken Sie an die Zone, die sich am besten für vertrauenswürdiges Reporting und Self-Service-Analysen eignet.`], refs.lakeZones),
    q('single', 'dp203-204', storage, 'medium', null, [`Sales queries almost always filter by order date. Which folder layout is usually the best partitioning choice in a data lake?`, `Verkaufsabfragen filtern fast immer nach Bestelldatum. Welches Ordnerlayout ist in einem Data Lake normalerweise die beste Partitionierungswahl?`], [['A', 'year=YYYY/month=MM/day=DD', 'year=YYYY/month=MM/day=DD'], ['B', 'customerId=<value>', 'customerId=<value>'], ['C', 'orderId=<value>', 'orderId=<value>'], ['D', 'guid=<value>', 'guid=<value>']], ['A'], [`Date-based folders align to common predicates and support partition pruning. High-cardinality keys such as orderId or GUID create too many tiny partitions.`, `Datumsbasierte Ordner passen zu häufigen Prädikaten und unterstützen Partition Pruning. Schlüssel mit hoher Kardinalität wie orderId oder GUID erzeugen zu viele winzige Partitionen.`], [`Choose a layout that matches the most common filter column and stays manageable.`, `Wählen Sie ein Layout, das zur häufigsten Filterspalte passt und beherrschbar bleibt.`], refs.serverlessBest),
    q('single', 'dp203-205', storage, 'medium', null, [`Why is partitioning a lake table by TransactionId usually a poor design choice?`, `Warum ist die Partitionierung einer Lake-Tabelle nach TransactionId normalerweise eine schlechte Designentscheidung?`], [['A', 'It creates too many small partitions and metadata overhead', 'Sie erzeugt zu viele kleine Partitionen und Metadaten-Overhead'], ['B', 'It prevents compression entirely', 'Sie verhindert Komprimierung vollständig'], ['C', 'It disables Azure RBAC', 'Sie deaktiviert Azure RBAC'], ['D', 'It forces all files to be CSV', 'Sie erzwingt CSV für alle Dateien']], ['A'], [`TransactionId is usually extremely high cardinality. That leads to a huge number of partitions, poor maintenance characteristics, and inefficient file layouts.`, `TransactionId hat in der Regel eine extrem hohe Kardinalität. Das führt zu einer sehr großen Zahl an Partitionen, schlechten Wartungseigenschaften und ineffizienten Dateilayouts.`], [`High cardinality is the key clue.`, `Die hohe Kardinalität ist der entscheidende Hinweis.`], refs.serverlessBest),
    q('single', 'dp203-206', storage, 'easy', null, [`Which file format is generally the best default for analytical workloads because it is columnar and supports predicate pushdown?`, `Welches Dateiformat ist für analytische Workloads im Allgemeinen die beste Standardwahl, weil es spaltenorientiert ist und Predicate Pushdown unterstützt?`], [['A', 'CSV', 'CSV'], ['B', 'Parquet', 'Parquet'], ['C', 'Plain text', 'Einfacher Text'], ['D', 'Bitmap', 'Bitmap']], ['B'], [`Parquet is optimized for analytics. It stores data in a columnar layout, which reduces I/O when queries read only a subset of columns.`, `Parquet ist für Analysen optimiert. Es speichert Daten in einem spaltenorientierten Layout, wodurch I/O reduziert wird, wenn Abfragen nur einen Teil der Spalten lesen.`], [`Look for the columnar format used heavily in data lakes and serverless SQL.`, `Suchen Sie nach dem spaltenorientierten Format, das stark in Data Lakes und serverlosem SQL verwendet wird.`], refs.serverlessBest),
    q('single', 'dp203-207', storage, 'medium', null, [`What does Delta Lake add on top of Parquet files?`, `Was 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 row-level security in storage', 'Automatische Row-Level Security im Storage'], ['C', 'Mandatory serverless SQL pricing controls', 'Verpflichtende Preissteuerung für serverloses SQL'], ['D', 'An Event Hubs namespace', 'Einen Event-Hubs-Namespace']], ['A'], [`Delta Lake combines Parquet data files with a transaction log. That enables reliable updates, schema enforcement, and time-travel queries.`, `Delta Lake kombiniert Parquet-Datendateien mit einem Transaktionsprotokoll. Dadurch werden zuverlässige Updates, Schemaerzwingung und Time-Travel-Abfragen möglich.`], [`The answer is about transactional behavior, not basic file encoding.`, `Die Antwort bezieht sich auf transaktionales Verhalten, nicht auf die grundlegende Dateikodierung.`], refs.databricksDelta),
    q('single', 'dp203-208', storage, 'medium', null, [`Your team publishes event payloads and needs a compact row-oriented format with strong schema evolution support. Which format is the best fit?`, `Ihr Team veröffentlicht Event-Payloads und benötigt 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', 'PNG', 'PNG']], ['A'], [`Avro is widely used for event data and serialization scenarios. It is compact and well suited for schema evolution across producers and consumers.`, `Avro wird häufig für Ereignisdaten und Serialisierungsszenarien verwendet. Es ist kompakt und gut für Schemaentwicklung zwischen Produzenten und Konsumenten geeignet.`], [`Think about message schemas and producer-consumer compatibility.`, `Denken Sie an Nachrichtenschemas und die Kompatibilität zwischen Produzenten und Konsumenten.`], refs.schemaRegistry),
    q('single', 'dp203-209', storage, 'medium', null, [`Which statement best describes ORC?`, `Welche Aussage beschreibt ORC am besten?`], [['A', 'It is a columnar file format for analytical processing', 'Es ist ein spaltenorientiertes Dateiformat für analytische Verarbeitung'], ['B', 'It is a network protocol for Event Hubs', 'Es ist ein Netzwerkprotokoll für Event Hubs'], ['C', 'It is a SQL security feature', 'Es ist eine SQL-Sicherheitsfunktion'], ['D', 'It is an Azure subscription type', 'Es ist ein Azure-Abonnementtyp']], ['A'], [`ORC is a columnar big-data file format designed for analytical read efficiency. Like Parquet, it supports compression and read optimizations.`, `ORC ist ein spaltenorientiertes Big-Data-Dateiformat, das für effiziente analytische Lesevorgänge entwickelt wurde. Wie Parquet unterstützt es Komprimierung und Leseoptimierungen.`], [`This is another analytics-oriented storage format.`, `Dies ist ein weiteres speicherformat für analytische Workloads.`], refs.serverlessBest),
    q('single', 'dp203-210', storage, 'easy', null, [`A dimension should always show the latest customer status, and history is not required. Which slowly changing dimension type should you implement?`, `Eine Dimension soll immer den aktuellen Kundenstatus anzeigen, und Historie wird nicht benötigt. Welchen Slowly-Changing-Dimension-Typ sollten Sie implementieren?`], [['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 existing value. It is the standard choice when you need only the current state.`, `Typ 1 überschreibt den vorhandenen Wert. Er ist die Standardwahl, wenn nur der aktuelle Zustand benötigt wird.`], [`No history means overwrite in place.`, `Keine Historie bedeutet Überschreiben an Ort und Stelle.`], refs.warehousing),
    q('single', 'dp203-211', storage, 'medium', [`A warehouse table includes these columns:
CustomerSK, CustomerId, Segment, EffectiveFrom, EffectiveTo, IsCurrent
What pattern is this most likely implementing?`, `Eine Warehouse-Tabelle enthält diese Spalten:
CustomerSK, CustomerId, Segment, EffectiveFrom, EffectiveTo, IsCurrent
Welches Muster wird damit am wahrscheinlichsten implementiert?`], [`Choose the best answer.`, `Wählen Sie die beste Antwort.`], [['A', 'Slowly changing dimension Type 2', 'Slowly Changing Dimension Typ 2'], ['B', 'Heap staging table', 'Heap-Staging-Tabelle'], ['C', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`Effective date columns and a current-row flag are classic signs of a Type 2 dimension, which preserves full history by versioning rows.`, `Gültigkeitsdatums-Spalten und ein Kennzeichen für die aktuelle Zeile sind klassische Merkmale einer Typ-2-Dimension, die die vollständige Historie durch versionierte Zeilen bewahrt.`], [`Look for versioning metadata that tracks validity over time.`, `Achten Sie auf Versionsmetadaten, die die Gültigkeit über die Zeit nachverfolgen.`], refs.warehousing),
    q('single', 'dp203-212', storage, 'medium', null, [`A product dimension must keep the current value and one previous value in the same row, but not the full history. Which slowly changing dimension type is the best fit?`, `Eine Produktdimension muss den aktuellen Wert und einen vorherigen Wert in derselben Zeile behalten, 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 4', 'Typ 4']], ['C'], [`Type 3 stores limited history, often by adding a previous-value column. It is useful when only current and prior values need to be compared.`, `Typ 3 speichert begrenzte Historie, oft durch eine Spalte für den vorherigen Wert. Er ist nützlich, wenn nur aktuelle und vorherige Werte verglichen werden müssen.`], [`Only one earlier value is needed, not all versions.`, `Es wird nur ein früherer Wert benötigt, nicht alle Versionen.`], refs.warehousing),
    q('single', 'dp203-213', storage, 'medium', null, [`Why are surrogate keys commonly used in dimension tables instead of relying only on business keys?`, `Warum werden in Dimensionstabellen häufig Surrogatschlüssel verwendet, anstatt sich nur auf Geschäftsschlüssel zu verlassen?`], [['A', 'They support stable joins and multiple historical versions of the same business entity', 'Sie unterstützen stabile Joins und mehrere historische Versionen derselben Geschäftseinheit'], ['B', 'They automatically encrypt the dimension', 'Sie verschlüsseln die Dimension automatisch'], ['C', 'They reduce Event Hubs throughput', 'Sie reduzieren den Event-Hubs-Durchsatz'], ['D', 'They eliminate the need for fact tables', 'Sie machen Faktentabellen überflüssig']], ['A'], [`Surrogate keys are warehouse-generated identifiers. They are especially useful in Type 2 dimensions because one business key can have many historical rows over time.`, `Surrogatschlüssel sind im Warehouse erzeugte Kennungen. Sie sind besonders in Typ-2-Dimensionen nützlich, weil ein Geschäftsschlüssel über die Zeit viele historische Zeilen haben kann.`], [`Think about historical versions and join stability.`, `Denken Sie an historische Versionen und stabile Joins.`], refs.warehousing),
    q('single', 'dp203-214', storage, 'hard', [`A dedicated SQL pool table is created as follows:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(CustomerKey))
AS SELECT * FROM dbo.StageSales;`, `Eine Dedicated-SQL-Pool-Tabelle wird wie folgt erstellt:
CREATE TABLE dbo.FactSales
WITH (DISTRIBUTION = HASH(CustomerKey))
AS SELECT * FROM dbo.StageSales;`], [`Why is HASH(CustomerKey) often a good choice for a very large fact table joined frequently on CustomerKey?`, `Warum ist HASH(CustomerKey) häufig eine gute Wahl für eine sehr große Faktentabelle, die oft über CustomerKey verknüpft wird?`], [['A', 'It can reduce data movement during joins on that key', 'Es kann die Datenbewegung bei Joins über diesen Schlüssel reduzieren'], ['B', 'It automatically creates materialized views', 'Es erstellt automatisch materialisierte Sichten'], ['C', 'It turns the table into external storage', 'Es wandelt die Tabelle in externen Speicher um'], ['D', 'It enables row-level security', 'Es aktiviert Row-Level Security']], ['A'], [`Hash distribution on a common join key can colocate related rows and reduce shuffle between distributions during query execution.`, `Eine Hash-Verteilung auf einem häufigen Join-Schlüssel kann zusammengehörige Zeilen zusammen platzieren und Shuffle zwischen Verteilungen während der Abfrageausführung reduzieren.`], [`The main goal is minimizing data movement for joins.`, `Das Hauptziel ist die Minimierung der Datenbewegung bei Joins.`], refs.synapseDist),
    q('single', 'dp203-215', storage, 'easy', null, [`Which distribution type is commonly used for transient staging tables when you want simple and fast loading before later optimization?`, `Welcher Verteilungstyp wird häufig für temporäre Staging-Tabellen verwendet, wenn Sie einfaches und schnelles Laden vor einer späteren Optimierung wünschen?`], [['A', 'Round-robin', 'Round-Robin'], ['B', 'Hash', 'Hash'], ['C', 'Replicate', 'Repliziert'], ['D', 'Archive', 'Archiv']], ['A'], [`Round-robin tables are easy to load and are often used for staging when no strong query-driven distribution key has been chosen yet.`, `Round-Robin-Tabellen lassen sich leicht laden und werden oft für Staging verwendet, wenn noch kein stark abfragegetriebener Verteilungsschlüssel gewählt wurde.`], [`This is the simplest landing choice in dedicated SQL pools.`, `Dies ist die einfachste Landing-Wahl in Dedicated SQL Pools.`], refs.synapseDist),
    q('single', 'dp203-216', storage, 'medium', null, [`A dimension table is very small and joined frequently to large fact tables. Which distribution type is usually best in a dedicated SQL pool?`, `Eine Dimensionstabelle ist sehr klein und wird häufig mit großen Faktentabellen verknüpft. Welcher Verteilungstyp ist in einem Dedicated SQL Pool normalerweise am besten?`], [['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 small dimension to each compute node, which can eliminate data movement when joining to large distributed facts.`, `Replizierte Tabellen kopieren die kleine Dimension auf jeden Compute-Knoten, wodurch Datenbewegung bei Joins mit großen verteilten Fakten vermieden werden kann.`], [`The table is small enough to copy everywhere.`, `Die Tabelle ist klein genug, um überallhin kopiert zu werden.`], refs.synapseDist),
    q('single', 'dp203-217', storage, 'medium', [`A team runs the same serverless SQL query against Parquet files every day and wants a reusable object with named columns. What should they create?`, `Ein Team führt dieselbe serverlose SQL-Abfrage täglich gegen Parquet-Dateien aus und möchte ein wiederverwendbares Objekt mit benannten Spalten. Was sollte es erstellen?`], [`Choose the best answer.`, `Wählen Sie die beste Antwort.`], [['A', 'An external table', 'Eine externe Tabelle'], ['B', 'A clustered columnstore index', 'Einen geclusterten Columnstore-Index'], ['C', 'A consumer group', 'Eine Consumer Group'], ['D', 'A Spark broadcast hint', 'Einen Spark-Broadcast-Hint']], ['A'], [`An external table provides reusable schema metadata over lake files. It is a good fit when many users need the same logical definition repeatedly.`, `Eine externe Tabelle stellt wiederverwendbare Schemametadaten über Lake-Dateien bereit. Sie ist gut geeignet, wenn viele Benutzer dieselbe logische Definition wiederholt benötigen.`], [`The requirement is reuse and schema abstraction over files.`, `Die Anforderung lautet Wiederverwendung und Schemaabstraktion über Dateien.`], refs.synapseExternal),
    q('single', 'dp203-218', storage, 'medium', [`A serverless SQL analyst needs to inspect a few Parquet files quickly without first defining schema objects. Which T-SQL option should be used?`, `Ein Analyst für serverloses SQL muss einige Parquet-Dateien schnell prüfen, ohne zuerst Schemaobjekte zu definieren. Welche T-SQL-Option sollte verwendet werden?`], [['A', 'OPENROWSET', 'OPENROWSET'], ['B', 'CREATE MATERIALIZED VIEW', 'CREATE MATERIALIZED VIEW'], ['C', 'ALTER ROLE', 'ALTER ROLE'], ['D', 'DBCC CHECKDB', 'DBCC CHECKDB']], ['A'], [`OPENROWSET is ideal for ad hoc access to files in storage. It lets you query data directly without creating external tables first.`, `OPENROWSET ist ideal für den Ad-hoc-Zugriff auf Dateien im Speicher. Damit können Sie Daten direkt abfragen, ohne zuerst externe Tabellen zu erstellen.`], [`Choose the ad hoc file-querying feature.`, `Wählen Sie die Funktion für Ad-hoc-Dateiabfragen.`], refs.synapseServerless),
    q('single', 'dp203-219', storage, 'hard', [`A serverless SQL engineer runs:
CREATE EXTERNAL TABLE dbo.top_customers
WITH (
    LOCATION = 'gold/top_customers/',
    DATA_SOURCE = lake,
    FILE_FORMAT = parquet_format
)
AS
SELECT CustomerId, SUM(Amount) AS TotalAmount
FROM dbo.SalesExternal
GROUP BY CustomerId;`, `Ein Serverless-SQL-Ingenieur führt Folgendes aus:
CREATE EXTERNAL TABLE dbo.top_customers
WITH (
    LOCATION = 'gold/top_customers/',
    DATA_SOURCE = lake,
    FILE_FORMAT = parquet_format
)
AS
SELECT CustomerId, SUM(Amount) AS TotalAmount
FROM dbo.SalesExternal
GROUP BY CustomerId;`], [`What is this statement doing?`, `Was macht diese Anweisung?`], [['A', 'Persisting query results back to the data lake by using CETAS', 'Speichern von Abfrageergebnissen zurück in den Data Lake mithilfe von CETAS'], ['B', 'Creating a replicated table in dedicated SQL pool', 'Erstellen einer replizierten Tabelle im Dedicated SQL Pool'], ['C', 'Enabling dynamic data masking', 'Aktivieren dynamischer Datenmaskierung'], ['D', 'Defining a row-level security predicate', 'Definieren eines Row-Level-Security-Prädikats']], ['A'], [`CREATE EXTERNAL TABLE AS SELECT, or CETAS, writes the result set to external storage and creates metadata for it. It is commonly used in serverless SQL to materialize transformed outputs.`, `CREATE EXTERNAL TABLE AS SELECT, also CETAS, schreibt die Ergebnismenge in externen Speicher und erstellt Metadaten dafür. Es wird in serverlosem SQL häufig verwendet, um transformierte Ausgaben zu materialisieren.`], [`The key clue is AS SELECT writing to an external location.`, `Der entscheidende Hinweis ist AS SELECT, das in einen externen Speicherort schreibt.`], refs.synapseExternal),
    q('single', 'dp203-220', storage, 'medium', [`You need to load daily CSV files from Azure Data Lake Storage Gen2 into a dedicated SQL pool with minimal supporting objects. Which T-SQL statement should you prefer?`, `Sie müssen tägliche CSV-Dateien aus Azure Data Lake Storage Gen2 mit möglichst wenigen unterstützenden Objekten in einen Dedicated SQL Pool laden. Welche T-SQL-Anweisung sollten Sie bevorzugen?`], [['A', 'COPY INTO', 'COPY INTO'], ['B', 'ALTER LOGIN', 'ALTER LOGIN'], ['C', 'OPENJSON', 'OPENJSON'], ['D', 'DBCC DROPCLEANBUFFERS', 'DBCC DROPCLEANBUFFERS']], ['A'], [`COPY INTO is designed for straightforward ingestion from Azure storage into dedicated SQL pools. It usually requires less setup than a full PolyBase object model.`, `COPY INTO ist für die direkte Aufnahme aus Azure Storage in Dedicated SQL Pools vorgesehen. Es erfordert in der Regel weniger Einrichtung als ein vollständiges PolyBase-Objektmodell.`], [`Pick the loading option intentionally optimized for simple ingestion.`, `Wählen Sie die Ladeoption, die bewusst für einfache Aufnahme optimiert wurde.`], refs.synapseCopy),
    q('single', 'dp203-221', storage, 'medium', null, [`What does an external file format object define for external tables?`, `Was definiert ein External-File-Format-Objekt für externe Tabellen?`], [['A', 'How files should be interpreted, such as format type and parsing options', 'Wie Dateien interpretiert werden sollen, etwa Formattyp und Parsingoptionen'], ['B', 'How compute nodes are distributed', 'Wie Compute-Knoten verteilt werden'], ['C', 'Which users are in the db_owner role', 'Welche Benutzer in der Rolle db_owner sind'], ['D', 'How Spark executors cache DataFrames', 'Wie Spark-Executors DataFrames cachen']], ['A'], [`External file formats describe how SQL engines should read external files. They capture information such as delimited text settings or parquet/orc usage.`, `External-File-Formate beschreiben, wie SQL-Engines externe Dateien lesen sollen. Sie erfassen Informationen wie Einstellungen für Trenntext oder die Verwendung von Parquet/ORC.`], [`Think parser and file interpretation, not security or compute.`, `Denken Sie an Parser und Dateiauswertung, nicht an Sicherheit oder Compute.`], refs.synapseExternal),
    q('multiple', 'dp203-222', storage, 'hard', null, [`Which two actions usually help Synapse serverless SQL reduce the amount of data scanned?`, `Welche zwei Aktionen helfen Synapse serverlosem SQL normalerweise dabei, die gescannte Datenmenge zu reduzieren?`], [['A', 'Store files in Parquet format', 'Dateien im Parquet-Format speichern'], ['B', 'Filter on partition columns such as year and month', 'Auf Partitionierungsspalten wie Jahr und Monat filtern'], ['C', 'Use SELECT * on every query', 'In jeder Abfrage SELECT * verwenden'], ['D', 'Partition by GUID values', 'Nach GUID-Werten partitionieren']], ['A', 'B'], [`Columnar formats and partition filters both reduce how much data must be read. SELECT * and GUID-based partitioning usually increase the amount of work.`, `Spaltenorientierte Formate und Partitionsfilter reduzieren beide, wie viele Daten gelesen werden müssen. SELECT * und eine GUID-basierte Partitionierung erhöhen die Arbeit in der Regel.`], [`Focus on scan reduction techniques, not habits that expand scans.`, `Konzentrieren Sie sich auf Techniken zur Scan-Reduzierung und nicht auf Gewohnheiten, die Scans vergrößern.`], refs.serverlessBest),
    q('single', 'dp203-223', storage, 'medium', null, [`Why are millions of tiny files in a data lake usually bad for analytics performance?`, `Warum sind Millionen winziger Dateien in einem Data Lake normalerweise schlecht für die Analyseleistung?`], [['A', 'They increase file and metadata overhead compared to fewer larger files', 'Sie erhöhen Datei- und Metadaten-Overhead im Vergleich zu weniger größeren Dateien'], ['B', 'They automatically disable partition pruning', 'Sie deaktivieren Partition Pruning automatisch'], ['C', 'They force every query into dedicated SQL pool', 'Sie erzwingen jede Abfrage in einen Dedicated SQL Pool'], ['D', 'They make RBAC stop working', 'Sie führen dazu, dass RBAC nicht mehr funktioniert']], ['A'], [`Large numbers of small files create metadata overhead and reduce scan efficiency for engines such as Spark and serverless SQL.`, `Große Mengen kleiner Dateien erzeugen Metadaten-Overhead und verringern die Scaneffizienz für Engines wie Spark und serverloses SQL.`], [`Think about file-open overhead and fragmented work.`, `Denken Sie an Dateizugriffs-Overhead und fragmentierte Arbeit.`], refs.serverlessBest),
    q('multiple', 'dp203-224', storage, 'medium', null, [`Which two statements correctly describe a star schema?`, `Welche zwei Aussagen beschreiben ein Sternschema korrekt?`], [['A', 'Fact tables usually contain measures and foreign keys to dimensions', 'Faktentabellen enthalten normalerweise Kennzahlen und Fremdschlüssel zu Dimensionen'], ['B', 'Dimension tables contain descriptive business attributes', 'Dimensionstabellen enthalten beschreibende fachliche Attribute'], ['C', 'Fact tables should avoid relationships to dimensions', 'Faktentabellen sollten Beziehungen zu Dimensionen vermeiden'], ['D', 'Dimension tables should contain only numeric measures', 'Dimensionstabellen sollten nur numerische Kennzahlen enthalten']], ['A', 'B'], [`A star schema centers on measurable events in fact tables and descriptive context in dimensions. The relationship between them is fundamental to analytical modeling.`, `Ein Sternschema konzentriert sich auf messbare Ereignisse in Faktentabellen und den beschreibenden Kontext in Dimensionen. Die Beziehung zwischen beiden ist grundlegend für analytische Modellierung.`], [`Separate measurable events from descriptive context.`, `Trennen Sie messbare Ereignisse vom beschreibenden Kontext.`], refs.starSchema),
    q('single', 'dp203-225', storage, 'medium', null, [`What is the primary purpose of an external data source object in Synapse SQL?`, `Was ist der primäre Zweck eines External-Data-Source-Objekts in Synapse SQL?`], [['A', 'To define a location and optional credential for external data access', 'Einen Speicherort und eine optionale Anmeldeinformation für den Zugriff auf externe Daten zu definieren'], ['B', 'To set the distribution policy of internal tables', 'Die Verteilungsrichtlinie interner Tabellen festzulegen'], ['C', 'To enable Azure Monitor alerts', 'Azure-Monitor-Warnungen zu aktivieren'], ['D', 'To configure Spark autoscale', 'Spark-Autoskalierung zu konfigurieren']], ['A'], [`External data sources point SQL objects to storage systems and can reference credentials used to access those systems.`, `Externe Datenquellen verweisen SQL-Objekte auf Speichersysteme und können Anmeldeinformationen referenzieren, die für den Zugriff darauf verwendet werden.`], [`It is about where the data lives and how to reach it.`, `Es geht darum, wo die Daten liegen und wie sie erreicht werden.`], refs.synapseExternal),
    q('single', 'dp203-226', storage, 'medium', null, [`A product dimension is reused across several subject areas so that reports interpret product attributes consistently. What is this commonly called?`, `Eine Produktdimension wird über mehrere Fachbereiche hinweg wiederverwendet, damit Berichte Produktattribute konsistent interpretieren. Wie wird dies üblicherweise genannt?`], [['A', 'Conformed dimension', 'Konforme Dimension'], ['B', 'Transient dimension', 'Transiente Dimension'], ['C', 'Masked dimension', 'Maskierte Dimension'], ['D', 'Streaming dimension', 'Streaming-Dimension']], ['A'], [`A conformed dimension is shared and standardized across marts or models. It supports consistent analysis and comparable metrics.`, `Eine konforme Dimension ist zwischen Data Marts oder Modellen geteilt und standardisiert. Sie unterstützt konsistente Analysen und vergleichbare Kennzahlen.`], [`The key idea is reuse with consistent business meaning.`, `Die Schlüsselidee ist Wiederverwendung mit konsistenter fachlicher Bedeutung.`], refs.warehousing),
    q('single', 'dp203-227', storage, 'hard', null, [`A fact table is loaded by day and old data is regularly archived by day. Why might table partitioning by OrderDate be useful in a dedicated SQL pool?`, `Eine Faktentabelle wird täglich geladen und alte Daten werden regelmäßig täglich archiviert. Warum kann die Tabellenpartitionierung nach OrderDate in einem Dedicated SQL Pool nützlich sein?`], [['A', 'It can simplify partition switching and targeted maintenance for date ranges', 'Sie kann Partitionswechsel und gezielte Wartung für Datumsbereiche vereinfachen'], ['B', 'It replaces the need for indexes entirely', 'Sie ersetzt den Bedarf an Indizes vollständig'], ['C', 'It forces row-level security', 'Sie erzwingt Row-Level Security'], ['D', 'It stores data outside the database', 'Sie speichert Daten außerhalb der Datenbank']], ['A'], [`Table partitioning can help manage large date-based fact tables by isolating ranges for maintenance, archival, and some pruning scenarios.`, `Die Tabellenpartitionierung kann helfen, große datumsbasierte Faktentabellen zu verwalten, indem Bereiche für Wartung, Archivierung und einige Pruning-Szenarien isoliert werden.`], [`Think operational manageability by date window.`, `Denken Sie an betriebliche Verwaltbarkeit nach Datumsfenstern.`], refs.synapseOptimize),
    q('single', 'dp203-228', storage, 'easy', null, [`Which Azure Blob Storage access tier is usually the worst fit for data that must be queried frequently with low latency?`, `Welche Azure-Blob-Storage-Zugriffsebene ist normalerweise am wenigsten für Daten geeignet, die häufig mit niedriger Latenz abgefragt werden müssen?`], [['A', 'Hot', 'Hot'], ['B', 'Cool', 'Cool'], ['C', 'Archive', 'Archive'], ['D', 'Premium block blob', 'Premium Block Blob']], ['C'], [`Archive storage is designed for infrequently accessed data with retrieval delays. It is not a good fit for active analytical datasets.`, `Archive Storage ist für selten abgerufene Daten mit Abrufverzögerungen ausgelegt. Für aktiv analytisch genutzte Datensätze ist es ungeeignet.`], [`Choose the tier intended for long-term cold retention.`, `Wählen Sie die Ebene, die für langfristige kalte Aufbewahrung gedacht ist.`], refs.blobTiers),
    q('single', 'dp203-229', storage, 'medium', null, [`A source system emits deeply nested JSON documents, and the team wants to retain the original payload before later flattening. Which landing format is most appropriate in the raw zone?`, `Ein Quellsystem sendet stark verschachtelte JSON-Dokumente, und das Team möchte die Original-Payload vor einer späteren Abflachung beibehalten. Welches Landing-Format ist in der Raw-Zone am geeignetsten?`], [['A', 'JSON', 'JSON'], ['B', 'A fully flattened star schema only', 'Nur ein vollständig abgeflachtes Sternschema'], ['C', 'Bitmap images', 'Bitmap-Bilder'], ['D', 'A replicated SQL table only', 'Nur eine replizierte SQL-Tabelle']], ['A'], [`The raw zone should preserve source fidelity. Landing the data as JSON keeps the original nested structure available for later transformations.`, `Die Raw-Zone sollte die Originaltreue der Quelle bewahren. Das Landen der Daten als JSON hält die ursprüngliche verschachtelte Struktur für spätere Transformationen verfügbar.`], [`Preserve first, model later.`, `Zuerst bewahren, später modellieren.`], refs.lakeZones),
    q('single', 'dp203-230', storage, 'hard', [`A Delta Lake notebook contains:
MERGE INTO dim_customer AS t
USING stage_changes AS s
ON t.CustomerId = s.CustomerId AND t.IsCurrent = true
WHEN MATCHED AND t.HashValue <> s.HashValue THEN UPDATE SET t.IsCurrent = false, t.EffectiveTo = current_date()
WHEN NOT MATCHED THEN INSERT *;`, `Ein Delta-Lake-Notebook enthält:
MERGE INTO dim_customer AS t
USING stage_changes AS s
ON t.CustomerId = s.CustomerId AND t.IsCurrent = true
WHEN MATCHED AND t.HashValue <> s.HashValue THEN UPDATE SET t.IsCurrent = false, t.EffectiveTo = current_date()
WHEN NOT MATCHED THEN INSERT *;`], [`What data engineering task is this pattern commonly used for?`, `Für welche Data-Engineering-Aufgabe wird dieses Muster häufig verwendet?`], [['A', 'Applying upserts and SCD-style changes into a Delta table', 'Anwenden von Upserts und SCD-artigen Änderungen in eine Delta-Tabelle'], ['B', 'Creating an Event Hubs namespace', 'Erstellen eines Event-Hubs-Namespace'], ['C', 'Masking sensitive columns in SQL results', 'Maskieren sensibler Spalten in SQL-Ergebnissen'], ['D', 'Configuring a managed private endpoint', 'Konfigurieren eines Managed Private Endpoint']], ['A'], [`MERGE is commonly used for incremental upserts and for dimension maintenance patterns in Delta Lake. It can combine insert and update logic in one statement.`, `MERGE wird häufig für inkrementelle Upserts und für Muster zur Dimensionspflege in Delta Lake verwendet. Es kann Insert- und Update-Logik in einer Anweisung kombinieren.`], [`The clue is matching source changes to target rows.`, `Der Hinweis liegt im Abgleich von Quelländerungen mit Zielzeilen.`], refs.databricksMerge),
    q('single', 'dp203-231', storage, 'medium', null, [`What happens to the source files when you create an external table over data in a lake?`, `Was passiert mit den Quelldateien, wenn Sie eine externe Tabelle über Daten in einem Lake erstellen?`], [['A', 'The files remain in place and are referenced, not copied into the database', 'Die Dateien bleiben an Ort und Stelle und werden referenziert, nicht in die Datenbank kopiert'], ['B', 'They are always imported into an internal table immediately', 'Sie werden immer sofort in eine interne Tabelle importiert'], ['C', 'They are automatically encrypted with Always Encrypted', 'Sie werden automatisch mit Always Encrypted verschlüsselt'], ['D', 'They are deleted after metadata creation', 'Sie werden nach der Metadatenerstellung gelöscht']], ['A'], [`External tables provide schema metadata over external data. They do not inherently move the data into internal storage.`, `Externe Tabellen stellen Schemametadaten über externe Daten bereit. Sie verschieben die Daten nicht automatisch in internen Speicher.`], [`External means the data stays external.`, `Extern bedeutet, dass die Daten extern bleiben.`], refs.synapseExternal),
    q('single', 'dp203-232', storage, 'medium', null, [`In medallion architecture terms, which mapping is correct?`, `Welche Zuordnung ist in Begriffen der Medallion-Architektur korrekt?`], [['A', 'Bronze = raw, Silver = refined, Gold = curated', 'Bronze = raw, Silver = veredelt, Gold = kuratiert'], ['B', 'Bronze = curated, Silver = raw, Gold = transient', 'Bronze = kuratiert, Silver = raw, Gold = transient'], ['C', 'Bronze = archive only, Silver = security, Gold = ingestion', 'Bronze = nur Archiv, Silver = Sicherheit, Gold = Ingestion'], ['D', 'Bronze = replicated SQL, Silver = Event Hubs, Gold = Spark logs', 'Bronze = repliziertes SQL, Silver = Event Hubs, Gold = Spark-Protokolle']], ['A'], [`Medallion architecture usually progresses from raw ingestion to cleaned refinement and then to curated, consumer-ready outputs.`, `Die Medallion-Architektur entwickelt sich üblicherweise von roher Ingestion über bereinigte Veredelung hin zu kuratierten, konsumfertigen Ausgaben.`], [`Think bronze first, gold last.`, `Denken Sie an Bronze zuerst und Gold zuletzt.`], refs.medallion),
    q('single', 'dp203-233', storage, 'hard', null, [`What is a major risk when you choose a highly skewed column as the hash distribution key for a dedicated SQL pool table?`, `Was ist ein wesentliches Risiko, wenn Sie eine stark verzerrte Spalte als Hash-Verteilungsschlüssel für eine Dedicated-SQL-Pool-Tabelle wählen?`], [['A', 'Some distributions receive far more rows than others, causing skew and slower queries', 'Einige Verteilungen erhalten weit mehr Zeilen als andere, was zu Schieflage und langsameren Abfragen führt'], ['B', 'The table becomes replicated automatically', 'Die Tabelle wird automatisch repliziert'], ['C', 'External tables stop working', 'Externe Tabellen funktionieren nicht mehr'], ['D', 'Parquet files are converted to JSON', 'Parquet-Dateien werden in JSON konvertiert']], ['A'], [`A skewed hash key leads to uneven distribution of data across compute nodes. That reduces parallel efficiency and can hurt performance significantly.`, `Ein verzerrter Hash-Schlüssel führt zu einer ungleichmäßigen Verteilung der Daten über Compute-Knoten. Das reduziert die Parallelität und kann die Leistung deutlich verschlechtern.`], [`Even distribution across nodes is important.`, `Eine gleichmäßige Verteilung über die Knoten ist wichtig.`], refs.synapseDist),
    q('single', 'dp203-234', storage, 'medium', null, [`A serverless SQL workload must minimize scanned bytes and usually reads only a few columns. Which storage choice best supports that goal?`, `Ein serverloser SQL-Workload muss gescannte Bytes minimieren und liest normalerweise nur wenige Spalten. Welche Speicherwahl unterstützt dieses Ziel am besten?`], [['A', 'Parquet files', 'Parquet-Dateien'], ['B', 'Wide CSV files only', 'Nur breite CSV-Dateien'], ['C', 'Plain text logs', 'Einfache Textprotokolle'], ['D', 'BMP files', 'BMP-Dateien']], ['A'], [`Parquet is columnar, so serverless SQL can read only required columns instead of scanning the entire row structure of text-based formats.`, `Parquet ist spaltenorientiert, sodass serverloses SQL nur erforderliche Spalten lesen kann, anstatt die gesamte Zeilenstruktur textbasierter Formate zu scannen.`], [`Columnar storage is the clue.`, `Spaltenorientierter Speicher ist der Hinweis.`], refs.serverlessBest),
    q('single', 'dp203-235', storage, 'hard', null, [`Which statement correctly differentiates table distribution from table partitioning in a dedicated SQL pool?`, `Welche Aussage unterscheidet Tabellenverteilung korrekt von Tabellenpartitionierung in einem Dedicated SQL Pool?`], [['A', 'Distribution spreads rows across compute nodes; partitioning divides a table into logical ranges such as dates', 'Verteilung verteilt Zeilen über Compute-Knoten; Partitionierung teilt eine Tabelle in logische Bereiche wie Datumsbereiche'], ['B', 'Distribution controls encryption; partitioning controls RBAC', 'Verteilung steuert Verschlüsselung; Partitionierung steuert RBAC'], ['C', 'Distribution is only for Spark; partitioning is only for Event Hubs', 'Verteilung ist nur für Spark; Partitionierung ist nur für Event Hubs'], ['D', 'Both terms mean exactly the same thing', 'Beide Begriffe bedeuten genau dasselbe']], ['A'], [`Distribution is about parallel data placement across nodes, while partitioning is about dividing data into manageable segments, often by a business key such as date.`, `Verteilung betrifft die parallele Platzierung von Daten über Knoten hinweg, während Partitionierung die Aufteilung der Daten in beherrschbare Segmente betrifft, oft nach einem Geschäftsschlüssel wie Datum.`], [`One concept is node placement; the other is logical segmentation.`, `Ein Konzept betrifft die Platzierung auf Knoten, das andere die logische Segmentierung.`], refs.synapseDist),

    q('single', 'dp203-236', processing, 'easy', null, [`You need a relational analytics engine with persistent storage and predictable performance for a warehouse that serves many concurrent BI queries. Which Synapse option should you choose?`, `Sie benötigen eine relationale Analyse-Engine mit persistentem Speicher und vorhersehbarer Leistung für ein Warehouse, das viele gleichzeitige BI-Abfragen bedient. Welche Synapse-Option sollten Sie wählen?`], [['A', 'Dedicated SQL pool', 'Dedicated SQL Pool'], ['B', 'Serverless SQL pool', 'Serverless SQL Pool'], ['C', 'Event Hubs', 'Event Hubs'], ['D', 'Azure Blob archive tier', 'Azure Blob Archive Tier']], ['A'], [`Dedicated SQL pools are designed for enterprise data warehousing with persisted tables, workload management, and predictable performance characteristics.`, `Dedicated SQL Pools sind für Enterprise-Data-Warehousing mit persistenten Tabellen, Workload-Management und vorhersehbaren Leistungsmerkmalen ausgelegt.`], [`Look for the provisioned warehouse engine.`, `Suchen Sie nach der bereitgestellten Warehouse-Engine.`], refs.synapseOptimize),
    q('single', 'dp203-237', processing, 'easy', null, [`Which Synapse option is best for ad hoc SQL analysis directly over files in a data lake with no infrastructure to manage?`, `Welche Synapse-Option ist am besten für Ad-hoc-SQL-Analysen direkt über Dateien in einem Data Lake geeignet, ohne verwaltende Infrastruktur?`], [['A', 'Serverless SQL pool', 'Serverloser SQL Pool'], ['B', 'Dedicated SQL pool', 'Dedicated SQL Pool'], ['C', 'Azure Key Vault', 'Azure Key Vault'], ['D', 'Azure DNS', 'Azure DNS']], ['A'], [`Serverless SQL pools let you query files in a lake on demand and pay primarily for data processed, without provisioning warehouse compute.`, `Serverlose SQL Pools ermöglichen die bedarfsgesteuerte Abfrage von Dateien in einem Lake und berechnen hauptsächlich die verarbeiteten Daten, ohne Warehouse-Compute bereitzustellen.`], [`Choose the no-infrastructure SQL option.`, `Wählen Sie die SQL-Option ohne Infrastrukturverwaltung.`], refs.synapseServerless),
    q('single', 'dp203-238', processing, 'easy', null, [`Which Synapse option is best when you need Apache Spark for large-scale transformations or machine learning?`, `Welche Synapse-Option ist am besten, wenn Sie Apache Spark für groß angelegte Transformationen oder maschinelles Lernen benötigen?`], [['A', 'Spark pool', 'Spark-Pool'], ['B', 'Dedicated SQL pool only', 'Nur Dedicated SQL Pool'], ['C', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['D', 'Blob access tiering', 'Blob-Zugriffsebenen']], ['A'], [`Spark pools provide Apache Spark execution for distributed data processing, notebooks, and advanced transformation workloads.`, `Spark-Pools stellen Apache-Spark-Ausführung für verteilte Datenverarbeitung, Notebooks und erweiterte Transformationsworkloads bereit.`], [`The clue is Apache Spark itself.`, `Der Hinweis ist Apache Spark selbst.`], refs.synapseSpark),
    q('single', 'dp203-239', processing, 'easy', null, [`You need an Azure Data Factory pipeline to run every night at 01:00. Which trigger should you use?`, `Sie benötigen eine Azure-Data-Factory-Pipeline, die jede Nacht um 01:00 Uhr ausgeführt wird. Welchen Trigger sollten Sie verwenden?`], [['A', 'Schedule trigger', 'Schedule-Trigger'], ['B', 'Event trigger', 'Event-Trigger'], ['C', 'Manual trigger only', 'Nur manueller Trigger'], ['D', 'Debug trigger', 'Debug-Trigger']], ['A'], [`A schedule trigger starts a pipeline at defined times based on a calendar schedule.`, `Ein Schedule-Trigger startet eine Pipeline zu definierten Zeiten auf Basis eines Kalenders.`], [`The requirement is time based, not file or event based.`, `Die Anforderung ist zeitbasiert und nicht datei- oder ereignisbasiert.`], refs.adfTriggers),
    q('single', 'dp203-240', processing, 'medium', null, [`A pipeline must process exactly one non-overlapping hourly slice at a time and maintain awareness of time windows. Which trigger type is the best fit?`, `Eine Pipeline muss genau einen nicht überlappenden stündlichen Abschnitt nach dem anderen verarbeiten und Zeitfenster berücksichtigen. Welcher Trigger-Typ passt am besten?`], [['A', 'Tumbling window trigger', 'Tumbling-Window-Trigger'], ['B', 'Manual trigger', 'Manueller Trigger'], ['C', 'Debug trigger', 'Debug-Trigger'], ['D', 'Linked service trigger', 'Linked-Service-Trigger']], ['A'], [`Tumbling window triggers are designed for fixed-size, contiguous, non-overlapping time intervals and are useful for dependency-aware periodic processing.`, `Tumbling-Window-Trigger sind für feste, zusammenhängende, nicht überlappende Zeitintervalle ausgelegt und nützlich für periodische Verarbeitung mit Abhängigkeiten.`], [`Think fixed windows, not just a simple clock schedule.`, `Denken Sie an feste Fenster, nicht nur an einen einfachen Zeitplan.`], refs.adfTriggers),
    q('single', 'dp203-241', processing, 'medium', null, [`You are building one generic ADF pipeline that should load different tables based on metadata. Which feature should you use to pass source and target values at runtime?`, `Sie erstellen eine generische ADF-Pipeline, die unterschiedliche Tabellen anhand von Metadaten laden soll. Welche Funktion sollten Sie verwenden, um Quell- und Zielwerte zur Laufzeit zu übergeben?`], [['A', 'Pipeline parameters', 'Pipeline-Parameter'], ['B', 'Hard-coded values in every activity', 'Fest codierte Werte in jeder Aktivität'], ['C', 'Archive tier settings', 'Archive-Tier-Einstellungen'], ['D', 'Role definitions', 'Rollendefinitionen']], ['A'], [`Parameters make pipelines reusable and metadata driven. You can pass table names, paths, and other values without duplicating the pipeline.`, `Parameter machen Pipelines wiederverwendbar und metadatengesteuert. Sie können Tabellennamen, Pfade und andere Werte übergeben, ohne die Pipeline zu duplizieren.`], [`The goal is reuse with runtime values.`, `Das Ziel ist Wiederverwendung mit Laufzeitwerten.`], refs.adfParameters),
    q('single', 'dp203-242', processing, 'medium', null, [`An ADF pipeline retrieves a list of 50 file names and must process each file with the same activity chain. Which control flow activity should you use?`, `Eine ADF-Pipeline ruft eine Liste mit 50 Dateinamen ab und muss jede Datei mit derselben Aktivitätskette verarbeiten. Welche Control-Flow-Aktivität sollten Sie verwenden?`], [['A', 'ForEach', 'ForEach'], ['B', 'Wait', 'Wait'], ['C', 'Lookup only', 'Nur Lookup'], ['D', 'Delete', 'Delete']], ['A'], [`ForEach iterates over a collection and executes contained activities for each item. It is a standard pattern for file-by-file orchestration.`, `ForEach iteriert über eine Sammlung und führt enthaltene Aktivitäten für jedes Element aus. Es ist ein Standardmuster für die Orchestrierung Datei für Datei.`], [`This is the loop construct in ADF.`, `Dies ist das Schleifenkonstrukt in ADF.`], refs.adfControlFlow),
    q('single', 'dp203-243', processing, 'medium', null, [`Which ADF feature provides code-free graphical transformations such as joins, derived columns, and aggregates at scale?`, `Welche ADF-Funktion bietet codefreie grafische Transformationen wie Joins, abgeleitete Spalten und Aggregationen in großem Maßstab?`], [['A', 'Mapping data flow', 'Mapping Data Flow'], ['B', 'Integration runtime', 'Integration Runtime'], ['C', 'Linked service', 'Linked Service'], ['D', 'Trigger recurrence', 'Trigger-Wiederholung']], ['A'], [`Mapping data flows provide a visual transformation experience backed by Spark compute. They are intended for complex transformations without hand-written Spark code.`, `Mapping Data Flows bieten eine visuelle Transformationserfahrung auf Spark-Compute-Basis. Sie sind für komplexe Transformationen ohne handgeschriebenen Spark-Code gedacht.`], [`Choose the visual transformation feature, not the orchestration feature.`, `Wählen Sie die visuelle Transformationsfunktion und nicht die Orchestrierungsfunktion.`], refs.adfDataFlow),
    q('single', 'dp203-244', processing, 'easy', null, [`You only need to move data from one store to another with little or no transformation. Which ADF activity should you use first?`, `Sie müssen Daten nur mit wenig oder keiner Transformation von einem Speicher in einen anderen verschieben. Welche ADF-Aktivität sollten Sie zuerst verwenden?`], [['A', 'Copy activity', 'Copy-Aktivität'], ['B', 'Until activity', 'Until-Aktivität'], ['C', 'If Condition activity', 'If-Condition-Aktivität'], ['D', 'Web activity', 'Web-Aktivität']], ['A'], [`Copy activity is optimized for data movement between sources and sinks. It is the first choice when transformation requirements are minimal.`, `Die Copy-Aktivität ist für die Datenbewegung zwischen Quellen und Zielen optimiert. Sie ist die erste Wahl, wenn die Transformationsanforderungen minimal sind.`], [`This is about movement, not rich transformation logic.`, `Hier geht es um Bewegung, nicht um umfangreiche Transformationslogik.`], refs.adfControlFlow),
    q('single', 'dp203-245', processing, 'medium', null, [`You must copy data from an on-premises SQL Server into Azure Data Factory. Which integration runtime is required?`, `Sie müssen Daten von einem lokalen SQL Server in Azure Data Factory kopieren. Welche Integration Runtime wird benötigt?`], [['A', 'Self-hosted integration runtime', 'Self-hosted Integration Runtime'], ['B', 'Azure integration runtime only', 'Nur Azure Integration Runtime'], ['C', 'Managed VNet private endpoint only', 'Nur Managed-VNet-Private-Endpoint'], ['D', 'Event Hubs consumer runtime', 'Event-Hubs-Consumer-Runtime']], ['A'], [`A self-hosted integration runtime is used when ADF must connect to data stores inside your private network or on premises.`, `Eine Self-hosted Integration Runtime wird verwendet, wenn ADF auf Datenspeicher in Ihrem privaten Netzwerk oder lokal zugreifen muss.`], [`The source system is not publicly reachable from Azure-managed compute.`, `Das Quellsystem ist von Azure-verwaltetem Compute aus nicht öffentlich erreichbar.`], refs.adfIR),
    q('single', 'dp203-246', processing, 'medium', null, [`A Synapse pipeline must execute a Spark notebook as part of an orchestration. Which activity should you add?`, `Eine Synapse-Pipeline muss im Rahmen einer Orchestrierung ein Spark-Notebook ausführen. Welche Aktivität sollten Sie hinzufügen?`], [['A', 'Notebook activity', 'Notebook-Aktivität'], ['B', 'Delete activity', 'Delete-Aktivität'], ['C', 'Append variable activity', 'Append-Variable-Aktivität'], ['D', 'Validation activity', 'Validierungsaktivität']], ['A'], [`Notebook activities let a pipeline invoke notebooks, making it easy to combine orchestration with Spark-based transformations.`, `Notebook-Aktivitäten ermöglichen es einer Pipeline, Notebooks aufzurufen, wodurch sich Orchestrierung und Spark-basierte Transformationen leicht kombinieren lassen.`], [`The requirement is to run notebook code from a pipeline.`, `Die Anforderung ist, Notebook-Code aus einer Pipeline auszuführen.`], refs.synapseSpark),
    q('single', 'dp203-247', processing, 'medium', null, [`You must capture inserts, updates, and deletes from Azure SQL Database for downstream processing. Which source-side feature should you enable?`, `Sie müssen Inserts, Updates und Deletes aus Azure SQL Database für die nachgelagerte Verarbeitung erfassen. Welche Quellfunktion sollten Sie aktivieren?`], [['A', 'Change Data Capture', 'Change Data Capture'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'Dynamic Data Masking', 'Dynamische Datenmaskierung'], ['D', 'Result set caching', 'Resultset-Caching']], ['A'], [`CDC records row-level data changes, including deletes, in change tables. That makes it useful for incremental ETL or ELT patterns.`, `CDC zeichnet zeilenweise Datenänderungen einschließlich Deletes in Änderungstabellen auf. Das macht es für inkrementelle ETL- oder ELT-Muster nützlich.`], [`The requirement explicitly includes deletes.`, `Die Anforderung schließt Deletes ausdrücklich ein.`], refs.sqlCdc),
    q('single', 'dp203-248', processing, 'medium', null, [`A source table has a reliable LastModifiedDate column but no CDC. Which incremental loading pattern is commonly used?`, `Eine Quelltabelle verfügt über eine zuverlässige LastModifiedDate-Spalte, aber nicht über CDC. Welches inkrementelle Lademuster wird häufig verwendet?`], [['A', 'Watermark-based loading', 'Watermark-basiertes Laden'], ['B', 'Full reload only', 'Nur vollständiges Neuladen'], ['C', 'Archive rehydration', 'Archiv-Rehydrierung'], ['D', 'Dynamic masking', 'Dynamische Maskierung']], ['A'], [`A watermark pattern stores the last successfully processed value and uses it to fetch only rows changed since that point.`, `Ein Watermark-Muster speichert den zuletzt erfolgreich verarbeiteten Wert und verwendet ihn, um nur seit diesem Zeitpunkt geänderte Zeilen abzurufen.`], [`Use the reliable change timestamp as the boundary.`, `Verwenden Sie den zuverlässigen Änderungszeitstempel als Grenze.`], refs.adfParameters),
    q('single', 'dp203-249', processing, 'hard', [`A Structured Streaming job contains:
streamDf.writeStream
  .format('delta')
  .option('checkpointLocation', '/mnt/chk/orders')
  .start('/mnt/gold/orders')`, `Ein Structured-Streaming-Job enthält:
streamDf.writeStream
  .format('delta')
  .option('checkpointLocation', '/mnt/chk/orders')
  .start('/mnt/gold/orders')`], [`Why is checkpointLocation important here?`, `Warum ist checkpointLocation hier wichtig?`], [['A', 'It stores streaming progress and state so the job can recover correctly', 'Es speichert Streaming-Fortschritt und Status, damit sich der Job korrekt wiederherstellen kann'], ['B', 'It encrypts the output files with TDE', 'Es verschlüsselt die Ausgabedateien mit TDE'], ['C', 'It creates a consumer group in Event Hubs', 'Es erstellt eine Consumer Group in Event Hubs'], ['D', 'It changes the file format to Parquet', 'Es ändert das Dateiformat zu Parquet']], ['A'], [`Structured Streaming checkpoints track offsets and state information. They are critical for reliable recovery and exactly-once-style processing semantics where supported.`, `Structured-Streaming-Checkpoints verfolgen Offsets und Zustandsinformationen. Sie sind entscheidend für zuverlässige Wiederherstellung und, wo unterstützt, genau-einmal-ähnliche Verarbeitungssemantik.`], [`This option is about state and progress, not encryption.`, `Diese Option betrifft Status und Fortschritt, nicht Verschlüsselung.`], refs.databricksStreaming),
    q('single', 'dp203-250', processing, 'easy', null, [`Two independent applications must read the same stream from Event Hubs at their own pace. What should each application use?`, `Zwei unabhängige Anwendungen müssen denselben Stream aus Event Hubs in ihrem eigenen Tempo lesen. Was sollte jede Anwendung verwenden?`], [['A', 'A separate consumer group', 'Eine separate Consumer Group'], ['B', 'A separate archive tier', 'Eine separate Archive-Stufe'], ['C', 'A replicated table', 'Eine replizierte Tabelle'], ['D', 'A row-level security policy', 'Eine Row-Level-Security-Richtlinie']], ['A'], [`Consumer groups provide independent views of an Event Hubs stream so multiple applications can maintain their own offsets.`, `Consumer Groups bieten unabhängige Sichten auf einen Event-Hubs-Stream, sodass mehrere Anwendungen ihre eigenen Offsets verwalten können.`], [`The readers must not interfere with each other's position tracking.`, `Die Leser dürfen sich bei der Positionsverfolgung nicht gegenseitig beeinflussen.`], refs.eventHubs),
    q('single', 'dp203-251', processing, 'medium', null, [`What is the most accurate statement about Event Hubs partitions?`, `Welche Aussage über Event-Hubs-Partitionen ist am treffendsten?`], [['A', 'They enable parallelism, and event ordering is guaranteed only within a partition', 'Sie ermöglichen Parallelität, und die Ereignisreihenfolge ist nur innerhalb einer Partition garantiert'], ['B', 'They automatically mask sensitive columns', 'Sie maskieren sensible Spalten automatisch'], ['C', 'They store query results for serverless SQL', 'Sie speichern Abfrageergebnisse für serverloses SQL'], ['D', 'They eliminate the need for checkpoints', 'Sie machen Checkpoints überflüssig']], ['A'], [`Partitions allow a stream to be scaled out. Ordering guarantees apply within an individual partition, not across the whole namespace.`, `Partitionen ermöglichen die horizontale Skalierung eines Streams. Reihenfolgegarantien gelten innerhalb einer einzelnen Partition, nicht über den gesamten Namespace hinweg.`], [`Think scale-out plus partition-scoped ordering.`, `Denken Sie an Scale-out plus partitionsbezogene Reihenfolge.`], refs.eventHubs),
    q('single', 'dp203-252', processing, 'medium', null, [`You want a near-real-time stream in Event Hubs to be landed automatically in Azure Data Lake Storage for later batch analytics. Which feature should you enable?`, `Sie möchten, dass ein nahezu Echtzeitstream in Event Hubs automatisch in Azure Data Lake Storage für spätere Batch-Analysen landet. Welche Funktion sollten Sie aktivieren?`], [['A', 'Event Hubs Capture', 'Event Hubs Capture'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Query Store', 'Query Store'], ['D', 'Clustered columnstore index', 'Geclusterter Columnstore-Index']], ['A'], [`Event Hubs Capture automatically writes streamed events to storage, which is useful when you want both streaming and batch processing paths.`, `Event Hubs Capture schreibt gestreamte Ereignisse automatisch in Storage, was nützlich ist, wenn Sie sowohl Streaming- als auch Batch-Verarbeitungspfade wünschen.`], [`The keyword is automatically land the stream in storage.`, `Das Schlüsselwort ist, den Stream automatisch im Storage landen zu lassen.`], refs.eventHubsCapture),
    q('single', 'dp203-253', processing, 'medium', [`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 does the TumblingWindow function do in this query?`, `Was macht die Funktion TumblingWindow in dieser Abfrage?`], [['A', 'It groups events into fixed, non-overlapping 5-minute windows', 'Sie gruppiert Ereignisse in feste, nicht überlappende 5-Minuten-Fenster'], ['B', 'It broadcasts a dimension table', 'Sie sendet eine Dimensionstabelle per Broadcast'], ['C', 'It creates a dedicated SQL pool', 'Sie erstellt einen Dedicated SQL Pool'], ['D', 'It encrypts event payloads', 'Sie verschlüsselt Event-Payloads']], ['A'], [`A tumbling window creates fixed-size windows that do not overlap. It is commonly used for periodic aggregations over streaming data.`, `Ein Tumbling Window erstellt Fenster fester Größe, die sich nicht überlappen. Es wird häufig für periodische Aggregationen über Streamingdaten verwendet.`], [`Tumbling means fixed slices with no overlap.`, `Tumbling bedeutet feste Abschnitte ohne Überlappung.`], refs.streamWindows),
    q('single', 'dp203-254', processing, 'medium', null, [`Which Stream Analytics window type produces overlapping windows, for example every minute across the last 5 minutes?`, `Welcher Stream-Analytics-Fenstertyp erzeugt überlappende Fenster, zum Beispiel jede Minute über die letzten 5 Minuten?`], [['A', 'Hopping window', 'Hopping Window'], ['B', 'Tumbling window', 'Tumbling Window'], ['C', 'Security window', 'Security Window'], ['D', 'Replication window', 'Replication Window']], ['A'], [`Hopping windows advance by a hop size that can be smaller than the window size, which creates overlap between windows.`, `Hopping Windows bewegen sich mit einer Hop-Größe, die kleiner als die Fenstergröße sein kann, wodurch eine Überlappung zwischen Fenstern entsteht.`], [`The answer is the window type that overlaps by design.`, `Die Antwort ist der Fenstertyp, der sich absichtlich überlappt.`], refs.streamWindows),
    q('single', 'dp203-255', processing, 'hard', null, [`A streaming source sometimes sends events late or out of order. What should you configure in Stream Analytics to handle this correctly?`, `Eine Streamingquelle sendet Ereignisse manchmal verspätet oder in falscher Reihenfolge. Was sollten Sie in Stream Analytics konfigurieren, um dies korrekt zu behandeln?`], [['A', 'Late arrival and out-of-order event policies', 'Richtlinien für verspätete und falsch geordnete Ereignisse'], ['B', 'Columnstore indexes', 'Columnstore-Indizes'], ['C', 'Dedicated SQL pool pause settings', 'Pauseneinstellungen für Dedicated SQL Pools'], ['D', 'Blob archive tier rehydration', 'Rehydrierung des Blob-Archive-Tiers']], ['A'], [`Stream Analytics provides event ordering controls so the job can account for late-arriving and out-of-order events based on event time.`, `Stream Analytics bietet Steuerelemente für die Ereignisreihenfolge, damit der Job verspätet eintreffende und falsch geordnete Ereignisse anhand der Ereigniszeit berücksichtigen kann.`], [`The issue is event time correctness, not storage format.`, `Das Problem betrifft die Korrektheit der Ereigniszeit und nicht das Speicherformat.`], refs.streamOrdering),
    q('single', 'dp203-256', processing, 'medium', null, [`A Stream Analytics job must enrich each live event with a static device lookup table stored in Azure Blob Storage. Which feature supports this pattern?`, `Ein Stream-Analytics-Job muss jedes Live-Ereignis mit einer statischen Gerätesuchtabelle anreichern, die in Azure Blob Storage gespeichert ist. Welche Funktion unterstützt dieses Muster?`], [['A', 'Reference data input', 'Reference-Data-Eingabe'], ['B', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['C', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['D', 'Result set caching', 'Resultset-Caching']], ['A'], [`Reference data inputs let Stream Analytics join live streams to relatively static lookup data for enrichment scenarios.`, `Reference-Data-Eingaben ermöglichen es Stream Analytics, Live-Streams mit relativ statischen Lookup-Daten für Anreicherungsszenarien zu verknüpfen.`], [`The lookup table is static compared to the stream.`, `Die Lookup-Tabelle ist im Vergleich zum Stream statisch.`], refs.streamWindows),
    q('single', 'dp203-257', processing, 'medium', [`A serverless SQL script contains:
SELECT COUNT(*)
FROM OPENROWSET(
    BULK 'https://acct.dfs.core.windows.net/sales/year=*/month=*/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`, `Ein serverloses SQL-Skript enthält:
SELECT COUNT(*)
FROM OPENROWSET(
    BULK 'https://acct.dfs.core.windows.net/sales/year=*/month=*/*.parquet',
    FORMAT = 'PARQUET'
) AS rows;`], [`What is this query pattern primarily used for?`, `Wofür wird dieses Abfragemuster hauptsächlich verwendet?`], [['A', 'Querying many lake files directly without first loading them into internal tables', 'Direktes Abfragen vieler Lake-Dateien, ohne sie zuerst in interne Tabellen zu laden'], ['B', 'Creating a row-level security policy', 'Erstellen einer Row-Level-Security-Richtlinie'], ['C', 'Assigning a workload classifier', 'Zuweisen eines Workload-Classifiers'], ['D', 'Capturing Event Hubs messages', 'Erfassen von Event-Hubs-Nachrichten']], ['A'], [`OPENROWSET with wildcards lets serverless SQL scan groups of files directly in storage. It is useful for flexible file-based analysis.`, `OPENROWSET mit Wildcards ermöglicht serverlosem SQL, Gruppen von Dateien direkt im Storage zu scannen. Es ist nützlich für flexible dateibasierte Analysen.`], [`The data stays in the lake and is queried in place.`, `Die Daten bleiben im Lake und werden direkt dort abgefragt.`], refs.synapseServerless),
    q('single', 'dp203-258', processing, 'medium', null, [`Why might you use CETAS in a serverless SQL solution after filtering and reshaping raw data?`, `Warum könnten Sie CETAS in einer serverlosen SQL-Lösung verwenden, nachdem Rohdaten gefiltert und umgeformt wurden?`], [['A', 'To persist the transformed result set back to the lake for reuse', 'Um die transformierte Ergebnismenge zur Wiederverwendung zurück in den Lake zu schreiben'], ['B', 'To create a managed private endpoint', 'Um einen Managed Private Endpoint zu erstellen'], ['C', 'To enable TDE on storage', 'Um TDE für Storage zu aktivieren'], ['D', 'To rotate Event Hubs keys', 'Um Event-Hubs-Schlüssel zu rotieren']], ['A'], [`CETAS is useful when you want to materialize serverless SQL output as files in the data lake for downstream reuse.`, `CETAS ist nützlich, wenn Sie die Ausgabe von serverlosem SQL als Dateien im Data Lake für die nachgelagerte Wiederverwendung materialisieren möchten.`], [`It writes query output, not just metadata.`, `Es schreibt Abfrageausgaben und nicht nur Metadaten.`], refs.synapseExternal),
    q('single', 'dp203-259', processing, 'hard', [`A Delta Lake script contains:
MERGE INTO fact_orders AS t
USING cdc_changes AS s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;`, `Ein Delta-Lake-Skript enthält:
MERGE INTO fact_orders AS t
USING cdc_changes AS s
ON t.OrderId = s.OrderId
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;`], [`Which processing requirement does this script address?`, `Welche Verarbeitungsanforderung adressiert dieses Skript?`], [['A', 'Applying incremental change data to a target table', 'Anwenden inkrementeller Änderungsdaten auf eine Zieltabelle'], ['B', 'Encrypting files at rest', 'Verschlüsseln von Dateien im Ruhezustand'], ['C', 'Scheduling a nightly trigger', 'Planen eines nächtlichen Triggers'], ['D', 'Creating a consumer group', 'Erstellen einer Consumer Group']], ['A'], [`MERGE is a common way to apply incremental changes from a CDC stream or staging table into a Delta target.`, `MERGE ist eine häufige Methode, um inkrementelle Änderungen aus einem CDC-Stream oder einer Staging-Tabelle in ein Delta-Ziel zu übernehmen.`], [`The code matches source changes to existing target rows.`, `Der Code gleicht Quelländerungen mit vorhandenen Zielzeilen ab.`], refs.databricksMerge),
    q('single', 'dp203-260', processing, 'easy', null, [`Which statement best defines ELT?`, `Welche Aussage definiert ELT am besten?`], [['A', 'Data is extracted, loaded into the target platform, and then transformed there', 'Daten werden extrahiert, in die Zielplattform geladen und dann dort transformiert'], ['B', 'Data is transformed before extraction', 'Daten werden vor der Extraktion transformiert'], ['C', 'Data is encrypted, logged, and truncated', 'Daten werden verschlüsselt, protokolliert und gekürzt'], ['D', 'Data is exposed, linked, and tokenized', 'Daten werden offengelegt, verknüpft und tokenisiert']], ['A'], [`ELT uses the target platform's compute engine for transformations after loading the raw or staged data.`, `ELT nutzt die Compute-Engine der Zielplattform für Transformationen, nachdem die Roh- oder Staging-Daten geladen wurden.`], [`Load comes before transform.`, `Laden kommt vor Transformieren.`], refs.synapseOptimize),
    q('single', 'dp203-261', processing, 'easy', null, [`Which statement best defines ETL?`, `Welche Aussage definiert ETL am besten?`], [['A', 'Data is transformed before it is loaded into the target system', 'Daten werden transformiert, bevor sie in das Zielsystem geladen werden'], ['B', 'Data is always queried in place', 'Daten werden immer direkt am Speicherort abgefragt'], ['C', 'Data is stored only in Delta Lake', 'Daten werden nur in Delta Lake gespeichert'], ['D', 'Data is streamed only through Event Hubs', 'Daten werden nur über Event Hubs gestreamt']], ['A'], [`In ETL, transformation occurs before load into the final target. This can be useful when the target should receive already curated data.`, `Bei ETL erfolgt die Transformation vor dem Laden in das endgültige Ziel. Das kann nützlich sein, wenn das Ziel bereits kuratierte Daten erhalten soll.`], [`Transform comes before load in this pattern.`, `Bei diesem Muster kommt Transformieren vor dem Laden.`], refs.adfControlFlow),
    q('single', 'dp203-262', processing, 'medium', null, [`You want to break a large orchestration into reusable child pipelines. Which ADF activity should the parent pipeline use?`, `Sie möchten eine große Orchestrierung in wiederverwendbare untergeordnete Pipelines aufteilen. Welche ADF-Aktivität sollte die übergeordnete Pipeline verwenden?`], [['A', 'Execute Pipeline', 'Execute Pipeline'], ['B', 'Delete', 'Delete'], ['C', 'Set Variable', 'Set Variable'], ['D', 'Validation', 'Validation']], ['A'], [`Execute Pipeline lets you invoke child pipelines and pass parameters, which is useful for modular orchestration designs.`, `Execute Pipeline ermöglicht das Aufrufen untergeordneter Pipelines und das Übergeben von Parametern, was für modulare Orchestrierungsdesigns nützlich ist.`], [`The goal is pipeline composition and reuse.`, `Das Ziel ist Pipeline-Komposition und Wiederverwendung.`], refs.adfControlFlow),
    q('single', 'dp203-263', processing, 'medium', null, [`A Synapse pipeline must trigger a PySpark notebook that performs feature engineering. What is the most direct approach?`, `Eine Synapse-Pipeline muss ein PySpark-Notebook auslösen, das Feature Engineering durchführt. Was ist der direkteste Ansatz?`], [['A', 'Use a notebook activity in the pipeline', 'Verwenden Sie eine Notebook-Aktivität in der Pipeline'], ['B', 'Use dynamic data masking', 'Verwenden Sie dynamische Datenmaskierung'], ['C', 'Use an archive tier trigger', 'Verwenden Sie einen Archive-Tier-Trigger'], ['D', 'Use a result set cache', 'Verwenden Sie ein Resultset-Cache']], ['A'], [`Notebook activities are the direct orchestration mechanism for notebook execution in Synapse pipelines.`, `Notebook-Aktivitäten sind der direkte Orchestrierungsmechanismus für die Notebook-Ausführung in Synapse-Pipelines.`], [`The pipeline needs to call notebook compute directly.`, `Die Pipeline muss Notebook-Compute direkt aufrufen.`], refs.synapseSpark),
    q('single', 'dp203-264', processing, 'medium', null, [`Which Databricks compute choice is usually most suitable for scheduled production ETL jobs?`, `Welche Databricks-Compute-Wahl ist normalerweise am besten für geplante Produktions-ETL-Jobs geeignet?`], [['A', 'Job clusters', 'Job-Cluster'], ['B', 'Leaving an all-purpose cluster running permanently', 'Ein dauerhaft laufender All-Purpose-Cluster'], ['C', 'Archive storage', 'Archive Storage'], ['D', 'Dynamic data masking', 'Dynamische Datenmaskierung']], ['A'], [`Job clusters are created for the job and terminated afterward. They are a common fit for scheduled production pipelines.`, `Job-Cluster werden für den Job erstellt und danach beendet. Sie sind eine gängige Wahl für geplante Produktionspipelines.`], [`Think automation and short-lived execution for batch jobs.`, `Denken Sie an Automatisierung und kurzlebige Ausführung für Batch-Jobs.`], refs.databricksClusters),
    q('single', 'dp203-265', processing, 'medium', [`A PySpark job ends with:
df.coalesce(10).write.mode('overwrite').parquet('/mnt/curated/sales')`, `Ein PySpark-Job endet mit:
df.coalesce(10).write.mode('overwrite').parquet('/mnt/curated/sales')`], [`What is the main purpose of coalesce(10) in this scenario?`, `Was ist der Hauptzweck von coalesce(10) in diesem Szenario?`], [['A', 'To reduce the number of output partitions and therefore the number of output files', 'Die Anzahl der Ausgabepartitionen und damit die Anzahl der Ausgabedateien zu verringern'], ['B', 'To encrypt the output', 'Die Ausgabe zu verschlüsseln'], ['C', 'To create a managed identity', 'Eine verwaltete Identität zu erstellen'], ['D', 'To force a CDC scan', 'Einen CDC-Scan zu erzwingen']], ['A'], [`coalesce reduces the number of partitions without a full reshuffle in many cases. It is commonly used to control output file counts.`, `coalesce reduziert in vielen Fällen die Anzahl der Partitionen ohne vollständiges Reshuffle. Es wird häufig verwendet, um die Anzahl der Ausgabedateien zu steuern.`], [`The goal is file-count control after processing.`, `Das Ziel ist die Kontrolle der Dateianzahl nach der Verarbeitung.`], refs.synapseSpark),
    q('single', 'dp203-266', processing, 'medium', null, [`In ADF, which activity can inspect a folder and return child items so you can loop through discovered files?`, `Welche ADF-Aktivität kann einen Ordner prüfen und Child Items zurückgeben, damit Sie gefundene Dateien durchlaufen können?`], [['A', 'Get Metadata', 'Get Metadata'], ['B', 'Wait', 'Wait'], ['C', 'Fail', 'Fail'], ['D', 'Delete', 'Delete']], ['A'], [`Get Metadata can return childItems and other file or folder properties. It is often paired with ForEach for file-driven pipelines.`, `Get Metadata kann childItems und andere Datei- oder Ordnereigenschaften zurückgeben. Es wird oft zusammen mit ForEach für dateigesteuerte Pipelines verwendet.`], [`You need discovery before iteration.`, `Sie benötigen Ermittlung vor der Iteration.`], refs.adfGetMetadata),
    q('single', 'dp203-267', processing, 'medium', null, [`You want producers and consumers of Avro messages to share centrally managed schemas in Azure. Which Event Hubs-related feature should you use?`, `Sie möchten, dass Produzenten und Konsumenten von Avro-Nachrichten zentral verwaltete Schemas in Azure gemeinsam nutzen. Welche zu Event Hubs gehörende Funktion sollten Sie verwenden?`], [['A', 'Schema Registry', 'Schema Registry'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Result set caching', 'Resultset-Caching'], ['D', 'Dedicated SQL distribution', 'Dedicated-SQL-Verteilung']], ['A'], [`Schema Registry stores and manages schemas so producers and consumers can validate and evolve message structures consistently.`, `Schema Registry speichert und verwaltet Schemas, sodass Produzenten und Konsumenten Nachrichtenstrukturen konsistent validieren und weiterentwickeln können.`], [`This is about shared message contracts.`, `Hier geht es um gemeinsame Nachrichtenverträge.`], refs.schemaRegistry),
    q('single', 'dp203-268', processing, 'hard', null, [`In an ADF mapping data flow, which transformation is used to define whether rows should be inserted, updated, deleted, or upserted at the sink?`, `Welche Transformation wird in einem ADF Mapping Data Flow verwendet, um festzulegen, ob Zeilen im Ziel eingefügt, aktualisiert, gelöscht oder upserted werden sollen?`], [['A', 'Alter Row', 'Alter Row'], ['B', 'Select', 'Select'], ['C', 'Derived Column', 'Derived Column'], ['D', 'Surrogate Key', 'Surrogate Key']], ['A'], [`Alter Row lets you assign row policies such as insert, update, delete, and upsert for supported sinks.`, `Alter Row ermöglicht es Ihnen, Zeilenrichtlinien wie Insert, Update, Delete und Upsert für unterstützte Ziele zuzuweisen.`], [`The question asks about sink action policies.`, `Die Frage betrifft Richtlinien für Zielaktionen.`], refs.adfDataFlow),

    q('single', 'dp203-269', security, 'easy', null, [`You must ensure that sales managers can view only rows for their own sales region in a SQL-based warehouse. Which feature should you implement?`, `Sie müssen sicherstellen, dass Vertriebsleiter in einem SQL-basierten Warehouse nur Zeilen für ihre eigene Vertriebsregion sehen können. Welche Funktion sollten Sie implementieren?`], [['A', 'Row-level security', 'Row-Level Security'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'Archive tiering', 'Archive-Tiering'], ['D', 'Result set caching', 'Resultset-Caching']], ['A'], [`Row-level security applies predicates that filter visible rows based on the executing user or context.`, `Row-Level Security wendet Prädikate an, die sichtbare Zeilen basierend auf dem ausführenden Benutzer oder Kontext filtern.`], [`The requirement is to restrict which rows are visible.`, `Die Anforderung besteht darin, zu beschränken, welche Zeilen sichtbar sind.`], refs.rowLevelSecurity),
    q('single', 'dp203-270', security, 'easy', null, [`Users in a support role should see email addresses in query results as partially obscured values, while privileged users can still view the real values. Which feature is most appropriate?`, `Benutzer in einer Support-Rolle sollen E-Mail-Adressen in Abfrageergebnissen teilweise verschleiert sehen, während privilegierte Benutzer weiterhin die echten Werte sehen können. Welche Funktion ist am geeignetsten?`], [['A', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['B', 'Always Encrypted', 'Always Encrypted'], ['C', 'Hash distribution', 'Hash-Verteilung'], ['D', 'Spark caching', 'Spark-Caching']], ['A'], [`Dynamic data masking obfuscates sensitive values in result sets for non-privileged users. It does not change the underlying stored data.`, `Die dynamische Datenmaskierung verschleiert sensible Werte in Resultsets für nicht privilegierte Benutzer. Sie ändert nicht die zugrunde liegenden gespeicherten Daten.`], [`The requirement is masked display in query output.`, `Die Anforderung betrifft eine maskierte Anzeige in Abfrageausgaben.`], refs.ddm),
    q('single', 'dp203-271', security, 'medium', null, [`Which SQL protection feature is designed so that sensitive column values remain encrypted in the database and are decrypted only by authorized client applications?`, `Welche SQL-Schutzfunktion ist dafür ausgelegt, dass sensible Spaltenwerte in der Datenbank verschlüsselt bleiben und nur von autorisierten Clientanwendungen entschlüsselt werden?`], [['A', 'Always Encrypted', 'Always Encrypted'], ['B', 'Dynamic data masking', 'Dynamische Datenmaskierung'], ['C', 'Result set caching', 'Resultset-Caching'], ['D', 'Serverless SQL', 'Serverloses SQL']], ['A'], [`Always Encrypted keeps protected column values encrypted at rest, in memory on the server, and in transit, with decryption happening client side for authorized applications.`, `Always Encrypted hält geschützte Spaltenwerte im Ruhezustand, im Speicher auf dem Server und bei der Übertragung verschlüsselt, wobei die Entschlüsselung clientseitig für autorisierte Anwendungen erfolgt.`], [`This goes beyond obfuscation in query output.`, `Dies geht über bloße Verschleierung in Abfrageausgaben hinaus.`], refs.alwaysEncrypted),
    q('single', 'dp203-272', security, 'easy', null, [`Which feature primarily protects database files, backups, and logs by encrypting data at rest?`, `Welche Funktion schützt Datenbankdateien, Backups und Protokolle primär durch Verschlüsselung ruhender Daten?`], [['A', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['B', 'Row-level security', 'Row-Level Security'], ['C', 'Consumer groups', 'Consumer Groups'], ['D', 'Broadcast join', 'Broadcast Join']], ['A'], [`Transparent Data Encryption encrypts the database storage layer. It is focused on protecting data at rest.`, `Transparent Data Encryption verschlüsselt die Speicherebene der Datenbank. Sie konzentriert sich auf den Schutz ruhender Daten.`], [`The clue is files, backups, and logs.`, `Der Hinweis sind Dateien, Backups und Protokolle.`], refs.tde),
    q('single', 'dp203-273', security, 'medium', null, [`You must prevent a reporting user from selecting the Salary column while still allowing access to other columns in the same table. Which approach is most suitable?`, `Sie müssen verhindern, dass ein Reporting-Benutzer die Spalte Salary auswählt, während der Zugriff auf andere Spalten derselben Tabelle erlaubt bleibt. Welcher Ansatz ist am geeignetsten?`], [['A', 'Column-level permissions', 'Spaltenebenenberechtigungen'], ['B', 'Round-robin distribution', 'Round-Robin-Verteilung'], ['C', 'Event Hubs Capture', 'Event Hubs Capture'], ['D', 'Tumbling windows', 'Tumbling Windows']], ['A'], [`Column-level permissions let you grant or deny access to specific columns. That is more precise than blocking the entire table.`, `Berechtigungen auf Spaltenebene erlauben das Gewähren oder Verweigern des Zugriffs auf bestimmte Spalten. Das ist präziser, als die gesamte Tabelle zu blockieren.`], [`The requirement targets one sensitive column.`, `Die Anforderung betrifft eine einzelne sensible Spalte.`], refs.columnSecurity),
    q('single', 'dp203-274', security, 'medium', null, [`You want ADF or Synapse to authenticate to Azure SQL Database without storing usernames and passwords in pipeline definitions. Which approach should you prefer?`, `Sie möchten, dass sich ADF oder Synapse gegenüber Azure SQL Database authentifiziert, ohne Benutzernamen und Kennwörter in Pipelinedefinitionen zu speichern. Welchen Ansatz sollten Sie bevorzugen?`], [['A', 'Managed identity authentication', 'Authentifizierung mit verwalteter Identität'], ['B', 'Embedded SQL login credentials', 'Eingebettete SQL-Login-Anmeldedaten'], ['C', 'Anonymous access', 'Anonymer Zugriff'], ['D', 'Archive rehydration', 'Archiv-Rehydrierung']], ['A'], [`Managed identities provide passwordless service-to-service authentication to supported Azure resources.`, `Verwaltete Identitäten ermöglichen passwortlose Dienst-zu-Dienst-Authentifizierung gegenüber unterstützten Azure-Ressourcen.`], [`The goal is not to store secrets at all.`, `Das Ziel ist, überhaupt keine Geheimnisse zu speichern.`], refs.managedIdentity),
    q('single', 'dp203-275', security, 'medium', null, [`A linked service needs a secret such as a connection string or key. Where should you store and retrieve that secret from for better security?`, `Ein Linked Service benötigt ein Geheimnis wie eine Verbindungszeichenfolge oder einen Schlüssel. Wo sollten Sie dieses Geheimnis für bessere Sicherheit speichern und abrufen?`], [['A', 'Azure Key Vault', 'Azure Key Vault'], ['B', 'A comment inside the pipeline JSON', 'Ein Kommentar innerhalb des Pipeline-JSON'], ['C', 'A public GitHub issue', 'Ein öffentliches GitHub-Issue'], ['D', 'A CSV file in the raw zone', 'Eine CSV-Datei in der Raw-Zone']], ['A'], [`Azure Key Vault is the recommended secret store for keeping credentials out of code and pipeline definitions.`, `Azure Key Vault ist der empfohlene Geheimnisspeicher, um Anmeldeinformationen aus Code und Pipelinedefinitionen herauszuhalten.`], [`Use the dedicated secret-management service.`, `Verwenden Sie den dedizierten Dienst für Geheimnisverwaltung.`], refs.keyVault),
    q('single', 'dp203-276', security, 'medium', null, [`A Synapse workspace runs inside a managed virtual network and must access an Azure Storage account privately. What should you create?`, `Ein Synapse-Workspace läuft in einem verwalteten virtuellen Netzwerk und muss privat auf ein Azure-Storage-Konto zugreifen. Was sollten Sie erstellen?`], [['A', 'A managed private endpoint', 'Einen Managed Private Endpoint'], ['B', 'A row-level security predicate', 'Ein Row-Level-Security-Prädikat'], ['C', 'A clustered index', 'Einen geclusterten Index'], ['D', 'A consumer group', 'Eine Consumer Group']], ['A'], [`Managed private endpoints allow Synapse managed VNet resources to reach supported Azure services over private connectivity.`, `Managed Private Endpoints ermöglichen es Ressourcen im verwalteten Synapse-VNet, unterstützte Azure-Dienste über private Konnektivität zu erreichen.`], [`The access must stay on private networking.`, `Der Zugriff muss im privaten Netzwerk bleiben.`], refs.managedVnet),
    q('single', 'dp203-277', security, 'hard', null, [`What is a main security benefit of placing Synapse resources in a managed virtual network with approved private endpoints?`, `Was ist ein wesentlicher Sicherheitsvorteil, wenn Synapse-Ressourcen in ein verwaltetes virtuelles Netzwerk mit genehmigten privaten Endpunkten gestellt werden?`], [['A', 'It reduces exposure by keeping data access on private network paths and limiting outbound connectivity', 'Es reduziert die Angriffsfläche, indem Datenzugriffe auf privaten Netzwerkpfaden bleiben und ausgehende Konnektivität begrenzt wird'], ['B', 'It automatically creates columnstore indexes', 'Es erstellt automatisch Columnstore-Indizes'], ['C', 'It changes Parquet to Delta automatically', 'Es wandelt Parquet automatisch in Delta um'], ['D', 'It replaces RBAC and ACLs', 'Es ersetzt RBAC und ACLs']], ['A'], [`Managed VNets and private endpoints help isolate data movement and reduce dependence on public network exposure.`, `Verwaltete VNets und Private Endpoints helfen dabei, Datenbewegungen zu isolieren und die Abhängigkeit von öffentlicher Netzexponierung zu verringern.`], [`Think network isolation and controlled egress.`, `Denken Sie an Netzisolation und kontrollierten ausgehenden Verkehr.`], refs.managedVnet),
    q('single', 'dp203-278', 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 primarily used for?`, `Wofür wird diese DMV-Abfrage hauptsächlich verwendet?`], [['A', 'Monitoring query and request execution status in a dedicated SQL pool', 'Überwachen des Ausführungsstatus von Abfragen und Anforderungen in einem Dedicated SQL Pool'], ['B', 'Managing Event Hubs partitions', 'Verwalten von Event-Hubs-Partitionen'], ['C', 'Creating Spark checkpoints', 'Erstellen von Spark-Checkpoints'], ['D', 'Applying dynamic masking rules', 'Anwenden dynamischer Maskierungsregeln']], ['A'], [`sys.dm_pdw_exec_requests shows information about submitted requests, including status and elapsed time, which helps with operational monitoring and troubleshooting.`, `sys.dm_pdw_exec_requests zeigt Informationen über eingereichte Anforderungen, einschließlich Status und verstrichener Zeit, was bei operativer Überwachung und Fehlerbehebung hilft.`], [`The DMV is about requests, not file formats.`, `Die DMV betrifft Anforderungen und nicht Dateiformate.`], refs.synapseMonitor),
    q('single', 'dp203-279', security, 'hard', [`A query is slow in a dedicated SQL pool. Which DMV is especially useful when you want to inspect the individual execution steps and possible data movement operations?`, `Eine Abfrage ist in einem Dedicated SQL Pool langsam. Welche DMV ist besonders nützlich, wenn Sie einzelne Ausführungsschritte und mögliche Datenbewegungsoperationen prüfen möchten?`], [['A', 'sys.dm_pdw_request_steps', 'sys.dm_pdw_request_steps'], ['B', 'sys.database_principals', 'sys.database_principals'], ['C', 'sys.external_data_sources', 'sys.external_data_sources'], ['D', 'sys.schemas', 'sys.schemas']], ['A'], [`sys.dm_pdw_request_steps breaks a request into execution steps, which helps you see shuffles, moves, and other operations contributing to runtime.`, `sys.dm_pdw_request_steps zerlegt eine Anforderung in Ausführungsschritte, wodurch Sie Shuffles, Verschiebungen und andere Laufzeit-beitragende Operationen erkennen können.`], [`You want step-by-step execution details.`, `Sie möchten Ausführungsdetails Schritt für Schritt.`], refs.synapseMonitor),
    q('single', 'dp203-280', security, 'medium', null, [`What is usually the best index choice for a very large fact table in a dedicated SQL pool?`, `Welche Indexwahl ist für eine sehr große Faktentabelle in einem Dedicated SQL Pool normalerweise am besten?`], [['A', 'Clustered columnstore index', 'Geclusterter Columnstore-Index'], ['B', 'No index on any large fact table', 'Kein Index auf einer großen Faktentabelle'], ['C', 'XML index', 'XML-Index'], ['D', 'Spatial index', 'Räumlicher Index']], ['A'], [`Clustered columnstore indexes are the default and common best practice for large analytical fact tables because they compress well and accelerate scan-heavy queries.`, `Geclusterte Columnstore-Indizes sind die Standard- und häufige Best Practice für große analytische Faktentabellen, weil sie gut komprimieren und scanlastige Abfragen beschleunigen.`], [`Think warehouse-scale scans and compression.`, `Denken Sie an Warehouse-Scans im großen Maßstab und Komprimierung.`], refs.synapseOptimize),
    q('single', 'dp203-281', security, 'medium', null, [`Which table structure is often used for fast initial loading into a staging table before later transformation into optimized warehouse storage?`, `Welche Tabellenstruktur wird oft für das schnelle anfängliche Laden in eine Staging-Tabelle verwendet, bevor später in optimierten Warehouse-Speicher transformiert wird?`], [['A', 'Heap', 'Heap'], ['B', 'Replicated dimension only', 'Nur replizierte Dimension'], ['C', 'Row-level security policy', 'Row-Level-Security-Richtlinie'], ['D', 'Schema registry', 'Schema Registry']], ['A'], [`Heaps are often used for staging because they can support fast bulk loads before data is reorganized into a more optimized final table design.`, `Heaps werden oft für Staging verwendet, weil sie schnelle Bulk Loads unterstützen können, bevor Daten in ein stärker optimiertes endgültiges Tabellendesign umorganisiert werden.`], [`This is about landing speed, not final query optimization.`, `Hier geht es um Landing-Geschwindigkeit und nicht um endgültige Abfrageoptimierung.`], refs.synapseOptimize),
    q('single', 'dp203-282', security, 'medium', null, [`A dashboard repeatedly queries the same expensive aggregation over billions of rows. Which dedicated SQL pool feature can precompute and store that aggregation for faster queries?`, `Ein Dashboard fragt wiederholt dieselbe teure Aggregation über Milliarden von Zeilen ab. Welche Funktion des Dedicated SQL Pools kann diese Aggregation für schnellere Abfragen vorberechnen und speichern?`], [['A', 'Materialized view', 'Materialisierte Sicht'], ['B', 'Consumer group', 'Consumer Group'], ['C', 'Late arrival policy', 'Richtlinie für verspätete Ereignisse'], ['D', 'Archive tier', 'Archive-Tier']], ['A'], [`Materialized views store precomputed query results and can significantly reduce runtime for repeated aggregations and joins.`, `Materialisierte Sichten speichern vorberechnete Abfrageergebnisse und können die Laufzeit für wiederholte Aggregationen und Joins deutlich reduzieren.`], [`The key idea is precomputation.`, `Die Schlüsselidee ist Vorberechnung.`], refs.synapseMaterialized),
    q('single', 'dp203-283', security, 'medium', null, [`Users keep rerunning the same read-only query against unchanged data in a dedicated SQL pool. Which feature can return the cached result instead of recomputing it?`, `Benutzer führen dieselbe schreibgeschützte Abfrage gegen unveränderte Daten in einem Dedicated SQL Pool immer wieder aus. Welche Funktion kann das zwischengespeicherte Ergebnis zurückgeben, anstatt es neu zu berechnen?`], [['A', 'Result set caching', 'Resultset-Caching'], ['B', 'Transparent Data Encryption', 'Transparent Data Encryption'], ['C', 'Event Hubs Capture', 'Event Hubs Capture'], ['D', 'Schema drift', 'Schema Drift']], ['A'], [`Result set caching can improve response time for identical repeated queries when the underlying data has not changed.`, `Resultset-Caching kann die Antwortzeit für identische wiederholte Abfragen verbessern, 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.synapseResultCache),
    q('single', 'dp203-284', security, 'medium', null, [`When choosing a hash distribution key for a large table, which property is most desirable?`, `Welche Eigenschaft ist bei der Wahl eines Hash-Verteilungsschlüssels für eine große Tabelle am wünschenswertesten?`], [['A', 'Values are distributed evenly across rows', 'Werte sind gleichmäßig über die Zeilen verteilt'], ['B', 'All rows use the same value', 'Alle Zeilen verwenden denselben Wert'], ['C', 'The column changes data type every day', 'Die Spalte ändert täglich den Datentyp'], ['D', 'The column is always NULL', 'Die Spalte ist immer NULL']], ['A'], [`Evenly distributed values reduce data skew and help the dedicated SQL pool use compute nodes more efficiently.`, `Gleichmäßig verteilte Werte reduzieren Datenskew und helfen dem Dedicated SQL Pool, Compute-Knoten effizienter zu nutzen.`], [`Uniformity matters more than randomness in name only.`, `Gleichmäßigkeit ist wichtiger als bloße Zufälligkeit im Namen.`], refs.synapseDist),
    q('single', 'dp203-285', security, 'hard', null, [`A large load into a dedicated SQL pool fails to compress rows efficiently into columnstore rowgroups because the session lacks enough memory. What should you consider increasing for the loading user?`, `Ein großer Ladevorgang in einen Dedicated SQL Pool kann Zeilen nicht effizient in Columnstore-Rowgroups komprimieren, weil der Sitzung nicht genug Speicher zur Verfügung steht. Was sollten Sie für den ladenden Benutzer erhöhen?`], [['A', 'The resource class', 'Die Resource Class'], ['B', 'The number of consumer groups in Event Hubs', 'Die Anzahl der Consumer Groups in Event Hubs'], ['C', 'The dynamic masking function', 'Die Funktion für dynamische Maskierung'], ['D', 'The archive retention period', 'Die Aufbewahrungsdauer im Archiv']], ['A'], [`Resource classes influence memory allocation for queries and loads in dedicated SQL pools. Larger classes can help memory-intensive operations perform better.`, `Resource Classes beeinflussen die Speicherzuweisung für Abfragen und Ladevorgänge in Dedicated SQL Pools. Größere Klassen können speicherintensive Operationen besser unterstützen.`], [`The symptom points to workload memory, not storage format.`, `Das Symptom deutet auf Workload-Speicher und nicht auf das Speicherformat hin.`], refs.synapseOptimize),
    q('single', 'dp203-286', security, 'hard', [`A Spark SQL query joins a 5 TB fact table to a 30 MB dimension:
SELECT /*+ BROADCAST(dim) */ *
FROM fact
JOIN dim ON fact.CustomerKey = dim.CustomerKey;`, `Eine Spark-SQL-Abfrage verknüpft eine 5-TB-Faktentabelle mit einer 30-MB-Dimension:
SELECT /*+ BROADCAST(dim) */ *
FROM fact
JOIN dim ON fact.CustomerKey = dim.CustomerKey;`], [`What is the purpose of the BROADCAST hint?`, `Was ist der Zweck des BROADCAST-Hints?`], [['A', 'To send the small table to executors and reduce shuffle of the large table', 'Die kleine Tabelle an die Executors zu senden und Shuffle der großen Tabelle zu reduzieren'], ['B', 'To encrypt the dimension table', 'Die Dimensionstabelle zu verschlüsseln'], ['C', 'To create a serverless external table', 'Eine serverlose externe Tabelle zu erstellen'], ['D', 'To enable CDC on the source', 'CDC auf der Quelle zu aktivieren']], ['A'], [`Broadcast joins are effective when one side is small enough to distribute to executors, allowing the large side to avoid expensive shuffles.`, `Broadcast Joins sind wirksam, wenn eine Seite klein genug ist, um an Executors verteilt zu werden, sodass die große Seite teure Shuffles vermeiden kann.`], [`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-287', security, 'medium', [`A notebook does this before several expensive actions:
baseDf.cache()`, `Ein Notebook führt vor mehreren teuren Aktionen Folgendes aus:
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', 'Es hält wiederverwendete Daten im Speicher, um wiederholte Neuberechnung zu vermeiden'], ['B', 'It encrypts the DataFrame', 'Es verschlüsselt das DataFrame'], ['C', 'It creates a materialized view in SQL', 'Es erstellt eine materialisierte Sicht in SQL'], ['D', 'It configures a private endpoint', 'Es konfiguriert einen Private Endpoint']], ['A'], [`Caching is helpful when the same DataFrame is reused multiple times in a single session and recomputation would be expensive.`, `Caching ist hilfreich, wenn dasselbe DataFrame in einer Sitzung mehrfach wiederverwendet wird und die Neuberechnung teuer wäre.`], [`The clue is repeated reuse in later actions.`, `Der Hinweis ist die wiederholte Wiederverwendung in späteren Aktionen.`], refs.sparkUI),
    q('single', 'dp203-288', security, '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 execution plan at runtime based on observed statistics', 'Den physischen Ausführungsplan zur Laufzeit basierend auf beobachteten Statistiken anzupassen'], ['B', 'Create linked services in ADF', 'Linked Services in ADF zu erstellen'], ['C', 'Mask result columns for support users', 'Ergebnisspalten für Support-Benutzer zu maskieren'], ['D', 'Pause a dedicated SQL pool', 'Einen Dedicated SQL Pool zu pausieren']], ['A'], [`AQE can optimize join strategies, shuffle partition counts, and skew handling while the query is running.`, `AQE kann Join-Strategien, die Anzahl der Shuffle-Partitionen und die Behandlung von Skew optimieren, während die Abfrage läuft.`], [`This feature makes runtime adjustments, not just compile-time decisions.`, `Diese Funktion nimmt Laufzeitanpassungen vor und nicht nur Entscheidungen zur Kompilierzeit.`], refs.sparkUI),
    q('single', 'dp203-289', security, 'medium', [`A Databricks notebook runs:
OPTIMIZE sales_delta;`, `Ein Databricks-Notebook führt aus:
OPTIMIZE sales_delta;`], [`What is the main purpose of this command?`, `Was ist der Hauptzweck dieses Befehls?`], [['A', 'To compact many small files into fewer larger files', 'Viele kleine Dateien zu weniger größeren Dateien zu verdichten'], ['B', 'To enable row-level security', 'Row-Level Security zu aktivieren'], ['C', 'To create a CDC change table', 'Eine CDC-Änderungstabelle zu erstellen'], ['D', 'To rotate encryption keys', 'Verschlüsselungsschlüssel zu rotieren']], ['A'], [`OPTIMIZE improves Delta file layout by compacting small files, which often helps read performance.`, `OPTIMIZE verbessert das Delta-Dateilayout durch Verdichten kleiner Dateien, was häufig die Leseleistung verbessert.`], [`This is file-layout maintenance, not security configuration.`, `Dies ist Dateilayout-Wartung und keine Sicherheitskonfiguration.`], refs.deltaOptimize),
    q('single', 'dp203-290', 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 in this statement?`, `Was ist das Ziel von ZORDER in dieser Anweisung?`], [['A', 'To improve data skipping for filters on those columns', 'Das Data Skipping für Filter auf diese Spalten zu verbessern'], ['B', 'To encrypt the selected columns', 'Die ausgewählten Spalten zu verschlüsseln'], ['C', 'To convert the table to CSV', 'Die Tabelle in CSV umzuwandeln'], ['D', 'To create a private endpoint', 'Einen Private Endpoint zu erstellen']], ['A'], [`ZORDER colocates related values to make selective reads more efficient when queries frequently filter on those columns.`, `ZORDER platziert zusammengehörige Werte näher beieinander, um selektive Lesevorgänge effizienter zu machen, wenn Abfragen häufig auf diese Spalten filtern.`], [`The target is read efficiency, not access control.`, `Das Ziel ist Leseeffizienz und nicht Zugriffskontrolle.`], refs.deltaOptimize),
    q('single', 'dp203-291', 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 for a Delta table?`, `Was bewirkt VACUUM für eine Delta-Tabelle?`], [['A', 'It removes obsolete files no longer needed after the retention period', 'Es entfernt veraltete Dateien, die nach dem Aufbewahrungszeitraum nicht mehr benötigt werden'], ['B', 'It creates a new Spark pool', 'Es erstellt einen neuen Spark-Pool'], ['C', 'It enables TDE', 'Es aktiviert TDE'], ['D', 'It rotates Event Hubs partitions', 'Es rotiert Event-Hubs-Partitionen']], ['A'], [`VACUUM cleans up files that Delta no longer needs, subject to the retention period and time-travel requirements.`, `VACUUM bereinigt Dateien, die Delta nicht mehr benötigt, vorbehaltlich des Aufbewahrungszeitraums und der Time-Travel-Anforderungen.`], [`Think cleanup after file history ages out.`, `Denken Sie an Bereinigung, nachdem die Dateihistorie veraltet ist.`], refs.databricksDelta),
    q('single', 'dp203-292', security, 'easy', null, [`A dedicated SQL pool is not used overnight. Which action most directly reduces compute cost during that idle period?`, `Ein Dedicated SQL Pool wird nachts nicht verwendet. Welche Aktion reduziert die Compute-Kosten in dieser Leerlaufphase 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 consumer group', 'Eine Event-Hubs-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 warehouse is completely idle for that period.`, `Das Warehouse ist in diesem Zeitraum vollständig untätig.`], refs.costMgmt),
    q('single', 'dp203-293', 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 Kosten-Leistungs-Ansatz?`], [['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', 'Keep the highest compute level all day', 'Die höchste Compute-Stufe den ganzen Tag beibehalten'], ['C', 'Move all data to archive every morning', 'Jeden Morgen alle Daten ins Archiv verschieben'], ['D', 'Disable all indexes permanently', 'Alle Indizes dauerhaft deaktivieren']], ['A'], [`Dedicated SQL pools can be scaled to match workload windows. Using higher compute only when needed helps balance performance and cost.`, `Dedicated SQL Pools können passend zu Workload-Fenstern skaliert werden. Höhere Compute-Leistung nur bei Bedarf zu verwenden, hilft, Leistung und Kosten auszubalancieren.`], [`The requirement changes by time of day.`, `Die Anforderung ändert sich je nach Tageszeit.`], refs.costMgmt),
    q('single', 'dp203-294', security, 'easy', 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 von Abfragen verarbeitete Datenmenge'], ['B', 'You pay for reserved DWUs 24x7', 'Sie zahlen für reservierte DWUs rund um die Uhr'], ['C', 'You pay per materialized view created', 'Sie zahlen pro erstellter materialisierter Sicht'], ['D', 'You pay only when using RBAC', 'Sie zahlen nur bei Verwendung von RBAC']], ['A'], [`Serverless SQL is billed by data processed, which is why efficient formats, projection, and pruning matter for cost control.`, `Serverloses SQL wird nach verarbeiteten Datenmengen abgerechnet, weshalb effiziente Formate, Projektion und Pruning für die Kostenkontrolle wichtig sind.`], [`This is a scan-based charging model.`, `Dies ist ein scanbasiertes Abrechnungsmodell.`], refs.serverlessBest),
    q('multiple', 'dp203-295', 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 where possible', 'Wenn möglich auf Partitionierungsspalten filtern'], ['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'], [`Reading fewer columns and pruning file sets both reduce the amount of data processed. SELECT * and inefficient file layouts generally increase cost.`, `Das Lesen weniger Spalten und das Prunen von Dateigruppen reduzieren beide die verarbeitete Datenmenge. SELECT * und ineffiziente Dateilayouts erhöhen die Kosten in der Regel.`], [`The pricing model rewards scan minimization.`, `Das Preismodell belohnt die Minimierung gescannter Daten.`], refs.serverlessBest),
    q('single', 'dp203-296', security, 'medium', null, [`A Synapse Spark pool supports autoscale and autopause. Why are these settings useful?`, `Ein Synapse-Spark-Pool unterstützt Autoscale und Autopause. Warum sind diese Einstellungen nützlich?`], [['A', 'They help match compute to workload demand and reduce idle cost', 'Sie helfen, Compute an den Workload-Bedarf anzupassen und Leerlaufkosten zu reduzieren'], ['B', 'They enforce row-level security predicates', 'Sie erzwingen Row-Level-Security-Prädikate'], ['C', 'They replace CDC', 'Sie ersetzen CDC'], ['D', 'They create external tables automatically', 'Sie erstellen automatisch externe Tabellen']], ['A'], [`Autoscale adjusts cluster size to workload demand, and autopause reduces cost when the pool is idle.`, `Autoscale passt die Clustergröße an den Workload-Bedarf an, und Autopause reduziert Kosten, wenn der Pool untätig ist.`], [`This is about elastic Spark cost management.`, `Hier geht es um elastisches Kostenmanagement für Spark.`], refs.synapseSpark),
    q('single', 'dp203-297', security, 'easy', null, [`Where can you visually review pipeline run history, activity status, and failures for Azure Data Factory or Synapse pipelines?`, `Wo können Sie den Verlauf von Pipelineausführungen, Aktivitätsstatus und Fehlern für Azure Data Factory oder Synapse-Pipelines visuell prüfen?`], [['A', 'The Monitor hub', 'Im Monitor-Hub'], ['B', 'The Blob archive tier', 'Im Blob-Archive-Tier'], ['C', 'The schema registry', 'In der Schema Registry'], ['D', 'The DMF cache', 'Im DMF-Cache']], ['A'], [`The Monitor hub provides run history and operational details for pipelines and activities, making it the main UI for monitoring orchestration.`, `Der Monitor-Hub bietet Ausführungsverlauf und betriebliche Details für Pipelines und Aktivitäten und ist damit die zentrale Oberfläche zur Überwachung der Orchestrierung.`], [`The question asks for the visual monitoring surface.`, `Die Frage zielt auf die visuelle Überwachungsoberfläche ab.`], refs.pipelineMonitor),
    q('single', 'dp203-298', security, 'medium', null, [`You want to centralize platform metrics and diagnostic logs for alerting and trend analysis across your data services. Which Azure capability should you integrate with?`, `Sie möchten Plattformmetriken und Diagnoseprotokolle für Warnungen und Trendanalysen über Ihre Datendienste hinweg zentralisieren. Mit welcher Azure-Funktion sollten Sie integrieren?`], [['A', 'Azure Monitor and Log Analytics', 'Azure Monitor und Log Analytics'], ['B', 'Archive tier only', 'Nur Archive Tier'], ['C', 'Delta time travel', 'Delta Time Travel'], ['D', 'Round-robin distribution', 'Round-Robin-Verteilung']], ['A'], [`Azure Monitor and Log Analytics are the standard services for centralized metrics, logs, alerting, and retention analysis across Azure resources.`, `Azure Monitor und Log Analytics sind die Standarddienste für zentralisierte Metriken, Protokolle, Warnungen und Retentionsanalysen über Azure-Ressourcen hinweg.`], [`Think centralized observability, not data layout.`, `Denken Sie an zentralisierte Beobachtbarkeit und nicht an Datenlayout.`], refs.pipelineMonitor),
    q('single', 'dp203-299', security, 'medium', null, [`Which tool is especially useful for diagnosing Spark job stages, shuffles, skew, and task execution details?`, `Welches Tool ist besonders nützlich, um Spark-Job-Stages, Shuffles, Skew und Details der Task-Ausführung zu diagnostizieren?`], [['A', 'Spark UI', 'Spark UI'], ['B', 'Azure Key Vault', 'Azure Key Vault'], ['C', 'Dynamic data masking policy', 'Richtlinie für dynamische Datenmaskierung'], ['D', 'Event Hubs Capture', 'Event Hubs Capture']], ['A'], [`The Spark UI exposes stage-level execution information and is one of the primary tools for Spark performance troubleshooting.`, `Die Spark UI stellt Ausführungsinformationen auf Stage-Ebene bereit und ist eines der wichtigsten Werkzeuge für die Spark-Leistungsfehlerbehebung.`], [`The problem is Spark execution analysis.`, `Das Problem betrifft die Analyse der Spark-Ausführung.`], refs.sparkUI),
    q('single', 'dp203-300', security, 'hard', null, [`In Always Encrypted, which encryption mode supports equality comparisons on protected columns but reveals more value patterns than the other mode?`, `Welcher Verschlüsselungsmodus in Always Encrypted unterstützt Gleichheitsvergleiche auf geschützten Spalten, offenbart jedoch mehr Wertmuster 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, which enables equality comparisons but leaks repetition patterns.`, `Deterministische Verschlüsselung erzeugt für denselben Klartext immer denselben Chiffretext, was Gleichheitsvergleiche ermöglicht, aber Wiederholungsmuster preisgibt.`], [`The trade-off is queryability versus stronger concealment of patterns.`, `Der Trade-off besteht zwischen Abfragbarkeit und stärkerer Verbergung von Mustern.`], refs.alwaysEncrypted),
    q('single', 'dp203-301', security, 'medium', null, [`Which statement about dynamic data masking is correct?`, `Welche Aussage über dynamische Datenmaskierung ist korrekt?`], [['A', 'It obfuscates query results for some users, but it is not a replacement for encryption or full access control', 'Sie verschleiert Abfrageergebnisse für einige Benutzer, ist aber kein Ersatz für Verschlüsselung oder vollständige Zugriffskontrolle'], ['B', 'It encrypts data so even privileged administrators cannot read it', 'Sie verschlüsselt Daten so, dass selbst privilegierte Administratoren sie nicht lesen können'], ['C', 'It stores data in Parquet format automatically', 'Sie speichert Daten automatisch im Parquet-Format'], ['D', 'It scales dedicated SQL compute up and down', 'Sie skaliert Dedicated-SQL-Compute hoch und herunter']], ['A'], [`Dynamic data masking affects how data appears in result sets for non-privileged users. It does not provide the same security guarantees as encryption or strict authorization boundaries.`, `Die dynamische Datenmaskierung beeinflusst, wie Daten in Resultsets für nicht privilegierte Benutzer erscheinen. Sie bietet nicht dieselben Sicherheitsgarantien wie Verschlüsselung oder strenge Autorisierungsgrenzen.`], [`Masking changes presentation, not the underlying protection model.`, `Maskierung ändert die Darstellung und nicht das zugrunde liegende Schutzmodell.`], refs.ddm),
  ];

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