(function() {
  function t(en, de) { return { en: en, de: de }; }
  function o(id, en, de) { return { id: id, text: t(en, de) }; }
  function q(id, type, domain, difficulty, scenario, question, options, correct, explanation, hint, reference) {
    return {
      id: id,
      type: type,
      domain: domain,
      difficulty: difficulty,
      scenario: scenario,
      question: question,
      options: options,
      correct: correct,
      explanation: explanation,
      hint: hint,
      reference: reference
    };
  }

  var plan = t('Plan, Implement, and Manage a Solution', 'Lösung planen, implementieren und verwalten');
  var prepare = t('Prepare and Serve Data', 'Daten vorbereiten und bereitstellen');
  var semantic = t('Implement and Manage Semantic Models', 'Semantische Modelle implementieren und verwalten');
  var explore = t('Explore and Analyze Data', 'Daten erkunden und analysieren');

  var ref = {
    workspaces: 'https://learn.microsoft.com/en-us/fabric/get-started/workspaces',
    admin: 'https://learn.microsoft.com/en-us/fabric/admin/admin-center',
    domains: 'https://learn.microsoft.com/en-us/fabric/governance/domains',
    capacity: 'https://learn.microsoft.com/en-us/fabric/enterprise/optimize-capacity',
    throttling: 'https://learn.microsoft.com/en-us/fabric/enterprise/throttling',
    smoothing: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/compute-capacity-smoothing-throttling',
    onelake: 'https://learn.microsoft.com/en-us/fabric/onelake/onelake-overview',
    catalog: 'https://learn.microsoft.com/en-us/fabric/get-started/onelake-data-hub',
    shortcuts: 'https://learn.microsoft.com/en-us/fabric/onelake/onelake-shortcuts',
    mirroring: 'https://learn.microsoft.com/en-us/fabric/mirroring/overview',
    lakehouse: 'https://learn.microsoft.com/en-us/fabric/data-engineering/lakehouse-overview',
    delta: 'https://learn.microsoft.com/en-us/fabric/data-engineering/lakehouse-and-delta-tables',
    vorder: 'https://learn.microsoft.com/en-us/fabric/data-engineering/delta-optimization-and-v-order',
    notebook: 'https://learn.microsoft.com/en-us/fabric/data-engineering/author-execute-notebook',
    sparkJobs: 'https://learn.microsoft.com/en-us/fabric/data-engineering/spark-job-definition',
    warehouse: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/data-warehousing',
    warehouseTables: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/tables',
    queryWarehouse: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/query-warehouse',
    crossWarehouse: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/tutorial-sql-cross-warehouse-query-editor',
    clone: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/clone-table',
    pipelines: 'https://learn.microsoft.com/en-us/fabric/data-factory/pipeline-overview',
    dataflows: 'https://learn.microsoft.com/en-us/fabric/data-factory/dataflows-gen2-overview',
    eventstream: 'https://learn.microsoft.com/en-us/fabric/real-time-intelligence/event-streams/overview',
    directLake: 'https://learn.microsoft.com/en-us/fabric/get-started/direct-lake-overview',
    star: 'https://learn.microsoft.com/en-us/power-bi/guidance/star-schema',
    relationships: 'https://learn.microsoft.com/en-us/power-bi/transform-model/desktop-relationships-understand',
    rls: 'https://learn.microsoft.com/en-us/power-bi/enterprise/service-admin-rls',
    ols: 'https://learn.microsoft.com/en-us/fabric/security/service-admin-object-level-security',
    deployment: 'https://learn.microsoft.com/en-us/fabric/cicd/deployment-pipelines/intro-to-deployment-pipelines',
    incremental: 'https://learn.microsoft.com/en-us/power-bi/connect-data/incremental-refresh-overview',
    largeModels: 'https://learn.microsoft.com/en-us/power-bi/enterprise/service-premium-large-models',
    aggregations: 'https://learn.microsoft.com/en-us/power-bi/transform-model/aggregations-advanced',
    calcGroups: 'https://learn.microsoft.com/en-us/analysis-services/tabular-models/calculation-groups?view=power-bi-premium-current',
    daxCalculate: 'https://learn.microsoft.com/en-us/dax/calculate-function-dax',
    daxSumx: 'https://learn.microsoft.com/en-us/dax/sumx-function-dax',
    daxVar: 'https://learn.microsoft.com/en-us/dax/var-dax',
    daxAll: 'https://learn.microsoft.com/en-us/dax/all-function-dax',
    daxUserRelationship: 'https://learn.microsoft.com/en-us/dax/userelationship-function-dax',
    drillthrough: 'https://learn.microsoft.com/en-us/power-bi/create-reports/desktop-drillthrough',
    bookmarks: 'https://learn.microsoft.com/en-us/power-bi/create-reports/desktop-bookmarks',
    qa: 'https://learn.microsoft.com/en-us/power-bi/natural-language/q-and-a-tooling-intro',
    paginated: 'https://learn.microsoft.com/en-us/power-bi/paginated-reports/paginated-reports-report-builder-power-bi',
    kql: 'https://learn.microsoft.com/en-us/kusto/query/?view=microsoft-fabric',
    queryset: 'https://learn.microsoft.com/en-us/fabric/real-time-intelligence/kusto-query-set',
    dashboard: 'https://learn.microsoft.com/en-us/fabric/real-time-intelligence/dashboard-real-time-create',
    activator: 'https://learn.microsoft.com/en-us/fabric/data-activator/data-activator-introduction'
  };

  var extra = [
    q('dp700-206', 'single', plan, 'easy',
      t('A central Fabric workspace contains lakehouses, notebooks, and published reports. Business analysts must create new reports in the workspace but must not manage permissions or tenant settings.', 'Ein zentraler Fabric-Arbeitsbereich enthält Lakehouses, Notebooks und veröffentlichte Berichte. Fachanalysten müssen neue Berichte im Arbeitsbereich erstellen können, dürfen jedoch weder Berechtigungen noch Mandanteneinstellungen verwalten.'),
      t('Which workspace role should you assign to the analysts?', 'Welche Arbeitsbereichsrolle sollten Sie den Analysten zuweisen?'),
      [
        o('A', 'Admin', 'Administrator'),
        o('B', 'Member', 'Mitglied'),
        o('C', 'Contributor', 'Mitwirkender'),
        o('D', 'Viewer', 'Betrachter')
      ],
      ['C'],
      t('Contributor allows users to create and edit items without granting workspace administration. That aligns with least privilege when users must build content but not manage access.', 'Mitwirkender erlaubt Benutzern, Elemente zu erstellen und zu bearbeiten, ohne eine Arbeitsbereichsadministration zu gewähren. Das entspricht dem Least-Privilege-Prinzip, wenn Benutzer Inhalte erstellen, aber keinen Zugriff verwalten sollen.'),
      t('Choose the role for content authors, not workspace managers.', 'Wählen Sie die Rolle für Inhaltsersteller und nicht für Arbeitsbereichsverwalter.'),
      ref.workspaces),

    q('dp700-207', 'multiple', plan, 'medium',
      null,
      t('Which two actions best support governance of domain-owned data products in Fabric?', 'Welche zwei Maßnahmen unterstützen die Governance domäneneigener Datenprodukte in Fabric am besten?'),
      [
        o('A', 'Assign workspaces to business domains', 'Ordnen Sie Arbeitsbereiche Geschäftsdomänen zu'),
        o('B', 'Use endorsements such as Promoted or Certified for trusted assets', 'Verwenden Sie Endorsements wie Hervorgehoben oder Zertifiziert für vertrauenswürdige Artefakte'),
        o('C', 'Give every workspace user the Admin role', 'Geben Sie jedem Arbeitsbereichsbenutzer die Rolle Administrator'),
        o('D', 'Disable the data catalog for self-service users', 'Deaktivieren Sie den Datenkatalog für Self-Service-Benutzer')
      ],
      ['A', 'B'],
      t('Domains provide clear ownership boundaries, and endorsements help consumers identify trusted data products. Broad admin rights and hiding the catalog reduce governance and discoverability instead of improving them.', 'Domänen schaffen klare Verantwortungsgrenzen, und Endorsements helfen Verbrauchern, vertrauenswürdige Datenprodukte zu erkennen. Breite Administratorrechte und ein ausgeblendeter Katalog verschlechtern Governance und Auffindbarkeit statt sie zu verbessern.'),
      t('Look for one ownership feature and one trust feature.', 'Suchen Sie nach einer Funktion für Eigentümerschaft und einer Funktion für Vertrauen.'),
      ref.domains),

    q('dp700-208', 'single', plan, 'hard',
      t('A single F64 capacity hosts notebooks, warehouse loads, and heavy interactive reporting. After several large overnight engineering jobs, morning report users see delayed queries even before new jobs start.', 'Eine einzelne F64-Kapazität hostet Notebooks, Warehouse-Ladevorgänge und intensive interaktive Berichte. Nach mehreren großen nächtlichen Engineering-Jobs sehen Berichtsnutzer am Morgen verzögerte Abfragen, noch bevor neue Jobs starten.'),
      t('What is the best explanation for this behavior?', 'Was ist die beste Erklärung für dieses Verhalten?'),
      [
        o('A', 'Capacity smoothing accounts for background usage over time, and sustained overages can lead to throttling', 'Kapazitätsglättung verbucht Hintergrundnutzung über die Zeit, und anhaltende Überlastungen können zu Drosselung führen'),
        o('B', 'Interactive report queries never share capacity with notebooks', 'Interaktive Berichtsabfragen teilen sich niemals Kapazität mit Notebooks'),
        o('C', 'Notebook jobs consume capacity only while the Spark UI is open', 'Notebook-Jobs verbrauchen nur dann Kapazität, wenn die Spark-Benutzeroberfläche geöffnet ist'),
        o('D', 'Throttling applies only to trial capacities', 'Drosselung gilt nur für Testkapazitäten')
      ],
      ['A'],
      t('Fabric smooths some background compute over time, but the usage is still charged to the capacity. If overages accumulate, later operations can be throttled, including interactive workloads.', 'Fabric glättet einen Teil der Hintergrund-Compute über die Zeit, aber die Nutzung wird der Kapazität weiterhin belastet. Wenn sich Überlastungen ansammeln, können spätere Vorgänge gedrosselt werden, einschließlich interaktiver Workloads.'),
      t('Think about smoothed usage still counting against the capacity.', 'Denken Sie daran, dass geglättete Nutzung weiterhin gegen die Kapazität zählt.'),
      ref.smoothing),

    q('dp700-209', 'multiple', plan, 'medium',
      null,
      t('Which two practices align best with a data mesh implementation in Microsoft Fabric?', 'Welche zwei Vorgehensweisen passen am besten zu einer Data-Mesh-Umsetzung in Microsoft Fabric?'),
      [
        o('A', 'Organize workspaces and data products by business domain', 'Organisieren Sie Arbeitsbereiche und Datenprodukte nach Geschäftsdomänen'),
        o('B', 'Require one central team to publish every table and report', 'Verlangen Sie, dass ein zentrales Team jede Tabelle und jeden Bericht veröffentlicht'),
        o('C', 'Let domain teams own and publish their curated products', 'Lassen Sie Domänenteams ihre kuratierten Produkte selbst besitzen und veröffentlichen'),
        o('D', 'Store all domain assets in one shared workspace without boundaries', 'Speichern Sie alle Domänenartefakte ohne Grenzen in einem gemeinsamen Arbeitsbereich')
      ],
      ['A', 'C'],
      t('Data mesh emphasizes domain ownership and domain-aligned products. Fabric domains and separate workspaces support those boundaries, while a single central publishing team works against the pattern.', 'Data Mesh betont Domänenverantwortung und domänenorientierte Produkte. Fabric-Domänen und separate Arbeitsbereiche unterstützen diese Grenzen, während ein einziges zentrales Veröffentlichungsteam dem Muster entgegenwirkt.'),
      t('Choose the answers that reinforce domain ownership.', 'Wählen Sie die Antworten, die Domänenverantwortung stärken.'),
      ref.domains),

    q('dp700-210', 'single', plan, 'easy',
      null,
      t('What is a key architectural benefit of OneLake in Microsoft Fabric?', 'Was ist ein zentraler architektonischer Vorteil von OneLake in Microsoft Fabric?'),
      [
        o('A', 'It gives each item its own isolated storage account outside Fabric', 'Es gibt jedem Element ein eigenes isoliertes Speicherkonto außerhalb von Fabric'),
        o('B', 'It provides a single logical data lake for Fabric items', 'Es stellt einen einzigen logischen Data Lake für Fabric-Elemente bereit'),
        o('C', 'It forces all analytics workloads to use Import mode', 'Es zwingt alle Analyse-Workloads zur Verwendung des Importmodus'),
        o('D', 'It replaces workspace security roles', 'Es ersetzt Arbeitsbereichs-Sicherheitsrollen')
      ],
      ['B'],
      t('OneLake is the unified storage layer for Fabric and reduces fragmentation between experiences. It enables multiple engines to work over the same logical data estate.', 'OneLake ist die einheitliche Speicherschicht für Fabric und reduziert Fragmentierung zwischen den Erfahrungen. Es ermöglicht mehreren Engines, über denselben logischen Datenbestand zu arbeiten.'),
      t('Think unified lake, not isolated stores.', 'Denken Sie an einen einheitlichen Lake und nicht an isolierte Speicher.'),
      ref.onelake),

    q('dp700-211', 'single', plan, 'medium',
      t('A team needs open Delta tables for Spark engineering, but finance users also want SQL access over the same curated data with minimal duplication.', 'Ein Team benötigt offene Delta-Tabellen für Spark-Engineering, aber Finanzanwender möchten auch SQL-Zugriff auf dieselben kuratierten Daten mit minimaler Duplizierung.'),
      t('Which Fabric item should be the primary storage layer?', 'Welches Fabric-Element sollte die primäre Speicherschicht sein?'),
      [
        o('A', 'Lakehouse', 'Lakehouse'),
        o('B', 'KQL Queryset', 'KQL-Queryset'),
        o('C', 'Dashboard', 'Dashboard'),
        o('D', 'Deployment pipeline', 'Deployment-Pipeline')
      ],
      ['A'],
      t('A lakehouse stores Delta tables in OneLake for Spark and also exposes a SQL analytics endpoint. That matches the requirement for open-format engineering plus SQL consumption without extra copies.', 'Ein Lakehouse speichert Delta-Tabellen in OneLake für Spark und stellt zusätzlich einen SQL-Analyseendpunkt bereit. Das passt zur Anforderung nach Engineering im offenen Format plus SQL-Nutzung ohne zusätzliche Kopien.'),
      t('Pick the storage option that serves both Spark and SQL.', 'Wählen Sie die Speicheroption, die sowohl Spark als auch SQL bedient.'),
      ref.lakehouse),

    q('dp700-212', 'single', plan, 'medium',
      null,
      t('Which Fabric admin-center feature lets tenant administrators enable or restrict specific Fabric capabilities for selected users or groups?', 'Welche Funktion im Fabric Admin Center ermöglicht es Mandantenadministratoren, bestimmte Fabric-Funktionen für ausgewählte Benutzer oder Gruppen zu aktivieren oder einzuschränken?'),
      [
        o('A', 'Tenant settings', 'Mandanteneinstellungen'),
        o('B', 'Bookmarks', 'Lesezeichen'),
        o('C', 'Calculation groups', 'Berechnungsgruppen'),
        o('D', 'Table clones', 'Tabellenklone')
      ],
      ['A'],
      t('Tenant settings are the central governance surface for controlling feature availability across the organization. They can be scoped to specific security groups when needed.', 'Mandanteneinstellungen sind die zentrale Governance-Oberfläche zur Steuerung der Funktionsverfügbarkeit in der gesamten Organisation. Sie können bei Bedarf auf bestimmte Sicherheitsgruppen beschränkt werden.'),
      t('Look for the tenant-wide control plane.', 'Suchen Sie nach der mandantenweiten Steuerungsebene.'),
      ref.admin),

    q('dp700-213', 'single', plan, 'medium',
      t('A Fabric capacity shows repeated slowdowns, and you need evidence about which workloads and time windows are causing the pressure before resizing the SKU.', 'Eine Fabric-Kapazität zeigt wiederholte Verlangsamungen, und Sie benötigen Belege dafür, welche Workloads und Zeitfenster den Druck verursachen, bevor Sie die SKU vergrößern.'),
      t('What should you do first?', 'Was sollten Sie zuerst tun?'),
      [
        o('A', 'Review capacity metrics and workload placement', 'Überprüfen Sie Kapazitätsmetriken und die Platzierung der Workloads'),
        o('B', 'Delete old workspaces immediately', 'Löschen Sie sofort alte Arbeitsbereiche'),
        o('C', 'Convert all lakehouses to warehouses', 'Konvertieren Sie alle Lakehouses in Warehouses'),
        o('D', 'Disable semantic models for all users', 'Deaktivieren Sie semantische Modelle für alle Benutzer')
      ],
      ['A'],
      t('Capacity metrics provide the evidence needed to see which operations are driving pressure and when they occur. Resizing without that information can waste cost or miss the true source of contention.', 'Kapazitätsmetriken liefern die notwendigen Belege, um zu sehen, welche Vorgänge Druck verursachen und wann sie auftreten. Eine Größenänderung ohne diese Informationen kann Kosten verschwenden oder die eigentliche Konfliktquelle übersehen.'),
      t('Measure before you resize.', 'Messen Sie, bevor Sie die Größe ändern.'),
      ref.capacity),

    q('dp700-214', 'single', plan, 'medium',
      t('Your company stores source files in Amazon S3 and must analyze them from Fabric. Legal policy does not allow copying the data into OneLake.', 'Ihr Unternehmen speichert Quelldateien in Amazon S3 und muss sie aus Fabric analysieren. Die Rechtsabteilung erlaubt nicht, die Daten nach OneLake zu kopieren.'),
      t('Which approach should you choose?', 'Welchen Ansatz sollten Sie wählen?'),
      [
        o('A', 'Create a OneLake shortcut to the S3 data', 'Erstellen Sie einen OneLake-Shortcut zu den S3-Daten'),
        o('B', 'Mirror the S3 files into a warehouse', 'Spiegeln Sie die S3-Dateien in ein Warehouse'),
        o('C', 'Export the files to CSV and upload them manually', 'Exportieren Sie die Dateien nach CSV und laden Sie sie manuell hoch'),
        o('D', 'Create a paginated report directly over the bucket', 'Erstellen Sie direkt über dem Bucket einen paginierten Bericht')
      ],
      ['A'],
      t('Shortcuts virtualize access to external data without copying it into OneLake storage. That satisfies the no-duplication requirement while still making the data available in Fabric.', 'Shortcuts virtualisieren den Zugriff auf externe Daten, ohne sie in den OneLake-Speicher zu kopieren. Das erfüllt die Anforderung ohne Duplizierung und macht die Daten dennoch in Fabric verfügbar.'),
      t('The requirement is access without replication.', 'Die Anforderung lautet Zugriff ohne Replikation.'),
      ref.shortcuts),

    q('dp700-215', 'single', plan, 'medium',
      t('You need near real-time analytics on Azure SQL operational tables inside Fabric, and downstream workloads must query local replicated copies in OneLake.', 'Sie benötigen nahezu Echtzeitanalysen für operative Azure-SQL-Tabellen in Fabric, und nachgelagerte Workloads müssen lokale replizierte Kopien in OneLake abfragen können.'),
      t('Which approach best fits this requirement?', 'Welcher Ansatz passt am besten zu dieser Anforderung?'),
      [
        o('A', 'Create a shortcut to the Azure SQL database', 'Erstellen Sie einen Shortcut zur Azure-SQL-Datenbank'),
        o('B', 'Use mirroring for the Azure SQL source', 'Verwenden Sie Mirroring für die Azure-SQL-Quelle'),
        o('C', 'Publish a dashboard on top of the source', 'Veröffentlichen Sie ein Dashboard auf der Quelle'),
        o('D', 'Use Q&A over the operational database', 'Verwenden Sie Q&A über der operativen Datenbank')
      ],
      ['B'],
      t('Mirroring is designed to replicate supported operational data sources into Fabric with low latency. Unlike a shortcut, it creates local replicated data for downstream analytics.', 'Mirroring ist dafür vorgesehen, unterstützte operative Datenquellen mit geringer Latenz nach Fabric zu replizieren. Anders als ein Shortcut erzeugt es lokale replizierte Daten für nachgelagerte Analysen.'),
      t('The key phrase is local replicated copies.', 'Die Schlüsselformulierung lautet lokale replizierte Kopien.'),
      ref.mirroring),

    q('dp700-216', 'single', plan, 'medium',
      t('An executive only needs to consume a sensitive finance report. The executive must not edit workspace items or browse engineering notebooks stored in the same workspace.', 'Eine Führungskraft muss nur einen sensiblen Finanzbericht konsumieren. Die Führungskraft darf keine Arbeitsbereichselemente bearbeiten und keine Engineering-Notebooks im selben Arbeitsbereich durchsuchen.'),
      t('What is the best access design?', 'Was ist das beste Zugriffskonzept?'),
      [
        o('A', 'Grant the Member role in the workspace', 'Gewähren Sie die Rolle Mitglied im Arbeitsbereich'),
        o('B', 'Grant the Admin role in the workspace', 'Gewähren Sie die Rolle Administrator im Arbeitsbereich'),
        o('C', 'Share only the report or app instead of broad workspace edit access', 'Teilen Sie nur den Bericht oder die App statt breiten Bearbeitungszugriff auf den Arbeitsbereich zu geben'),
        o('D', 'Move the notebooks to another file format', 'Konvertieren Sie die Notebooks in ein anderes Dateiformat')
      ],
      ['C'],
      t('Sharing only the report or app follows least privilege and limits exposure to unrelated items. Broad workspace roles would grant more visibility and control than the executive needs.', 'Das Teilen nur des Berichts oder der App folgt dem Least-Privilege-Prinzip und begrenzt die Einsicht in nicht relevante Elemente. Breite Arbeitsbereichsrollen würden mehr Sichtbarkeit und Kontrolle gewähren, als die Führungskraft benötigt.'),
      t('Avoid broad workspace access for simple report consumption.', 'Vermeiden Sie breiten Arbeitsbereichszugriff für reine Berichtsnutzung.'),
      ref.workspaces),

    q('dp700-217', 'multiple', plan, 'hard',
      t('A capacity runs large notebook jobs overnight and high-value interactive reports during business hours. You need to reduce contention before requesting a larger SKU.', 'Eine Kapazität führt nachts große Notebook-Jobs und während der Geschäftszeiten wertvolle interaktive Berichte aus. Sie müssen Ressourcenkonflikte reduzieren, bevor Sie eine größere SKU anfordern.'),
      t('Which two actions should you take first?', 'Welche zwei Maßnahmen sollten Sie zuerst ergreifen?'),
      [
        o('A', 'Review capacity metrics to identify pressure patterns', 'Überprüfen Sie Kapazitätsmetriken, um Belastungsmuster zu identifizieren'),
        o('B', 'Convert Delta tables to CSV', 'Konvertieren Sie Delta-Tabellen in CSV'),
        o('C', 'Separate heavy engineering workloads through workspace and capacity planning', 'Trennen Sie schwere Engineering-Workloads durch Arbeitsbereichs- und Kapazitätsplanung'),
        o('D', 'Remove report relationships from semantic models', 'Entfernen Sie Berichtsbeziehungen aus semantischen Modellen')
      ],
      ['A', 'C'],
      t('The correct first steps are to understand when pressure occurs and to isolate competing workloads where possible. File format changes and unrelated model edits do not address capacity contention.', 'Die richtigen ersten Schritte sind, zu verstehen, wann Belastung auftritt, und konkurrierende Workloads nach Möglichkeit zu isolieren. Dateiformatänderungen und nicht verwandte Modelländerungen beheben keine Kapazitätskonflikte.'),
      t('Focus on evidence and workload isolation.', 'Konzentrieren Sie sich auf Nachweise und Workload-Isolation.'),
      ref.capacity),

    q('dp700-218', 'single', plan, 'easy',
      null,
      t('Why should you assign a critical workspace to a Fabric capacity instead of relying only on shared capacity?', 'Warum sollten Sie einen kritischen Arbeitsbereich einer Fabric-Kapazität zuweisen, statt sich nur auf gemeinsame Kapazität zu verlassen?'),
      [
        o('A', 'It provides dedicated compute and more predictable performance', 'Es stellt dedizierte Compute und besser planbare Leistung bereit'),
        o('B', 'It removes the need for workspace permissions', 'Es macht Arbeitsbereichsberechtigungen überflüssig'),
        o('C', 'It stores data outside OneLake', 'Es speichert Daten außerhalb von OneLake'),
        o('D', 'It forces DirectLake for all models', 'Es erzwingt DirectLake für alle Modelle')
      ],
      ['A'],
      t('A dedicated capacity gives more predictable resource behavior for important workloads. Workspace roles, storage location, and semantic model mode remain separate design decisions.', 'Eine dedizierte Kapazität bietet für wichtige Workloads ein besser planbares Ressourcenverhalten. Arbeitsbereichsrollen, Speicherort und der Modus semantischer Modelle bleiben separate Entwurfsentscheidungen.'),
      t('Think compute isolation and predictability.', 'Denken Sie an Compute-Isolation und Vorhersehbarkeit.'),
      ref.capacity),

    q('dp700-219', 'multiple', plan, 'medium',
      null,
      t('Which two actions help users discover trusted data products in OneLake Data Hub?', 'Welche zwei Maßnahmen helfen Benutzern, vertrauenswürdige Datenprodukte im OneLake Data Hub zu finden?'),
      [
        o('A', 'Use Promoted or Certified endorsements', 'Verwenden Sie die Endorsements Hervorgehoben oder Zertifiziert'),
        o('B', 'Maintain clear descriptions and lineage for important items', 'Pflegen Sie klare Beschreibungen und Lineage für wichtige Elemente'),
        o('C', 'Hide all shared items from search', 'Blenden Sie alle freigegebenen Elemente aus der Suche aus'),
        o('D', 'Grant all consumers the Admin role', 'Geben Sie allen Verbrauchern die Rolle Administrator')
      ],
      ['A', 'B'],
      t('Endorsements help consumers identify trusted content, and rich metadata improves search and understanding. Hiding content or granting broad admin rights does not improve trusted discovery.', 'Endorsements helfen Verbrauchern, vertrauenswürdige Inhalte zu erkennen, und umfangreiche Metadaten verbessern Suche und Verständnis. Inhalte auszublenden oder breite Administratorrechte zu vergeben verbessert die vertrauenswürdige Auffindbarkeit nicht.'),
      t('Choose one trust indicator and one discoverability aid.', 'Wählen Sie einen Vertrauensindikator und eine Hilfe für die Auffindbarkeit.'),
      ref.catalog),

    q('dp700-220', 'single', plan, 'hard',
      t('A finance team needs full T-SQL support for tables, views, stored procedures, and transactional write patterns. Spark notebooks are not part of the requirement.', 'Ein Finanzteam benötigt vollständige T-SQL-Unterstützung für Tabellen, Sichten, gespeicherte Prozeduren und transaktionale Schreibmuster. Spark-Notebooks sind nicht Teil der Anforderung.'),
      t('Which Fabric item should you choose first?', 'Welches Fabric-Element sollten Sie zuerst wählen?'),
      [
        o('A', 'Warehouse', 'Warehouse'),
        o('B', 'Lakehouse', 'Lakehouse'),
        o('C', 'Eventstream', 'Eventstream'),
        o('D', 'KQL Database', 'KQL-Datenbank')
      ],
      ['A'],
      t('A warehouse is built for relational T-SQL authoring and write-heavy SQL patterns. A lakehouse is excellent for open-format analytics, but it is not the primary choice for the stated relational requirement.', 'Ein Warehouse ist für relationale T-SQL-Entwicklung und SQL-Schreibmuster ausgelegt. Ein Lakehouse eignet sich hervorragend für Analysen im offenen Format, ist aber nicht die primäre Wahl für die genannte relationale Anforderung.'),
      t('The requirement is full relational T-SQL authoring.', 'Die Anforderung ist vollständige relationale T-SQL-Entwicklung.'),
      ref.warehouse),

    q('dp700-221', 'single', prepare, 'medium',
      null,
      t('Why is MERGE often preferred when loading curated Delta tables?', 'Warum wird MERGE häufig beim Laden kuratierter Delta-Tabellen bevorzugt?'),
      [
        o('A', 'It supports insert, update, and delete logic in one transactional statement', 'Es unterstützt Insert-, Update- und Delete-Logik in einer transaktionalen Anweisung'),
        o('B', 'It automatically converts Delta tables to CSV', 'Es konvertiert Delta-Tabellen automatisch in CSV'),
        o('C', 'It removes the need for business keys', 'Es macht Geschäftsschlüssel überflüssig'),
        o('D', 'It runs only from a warehouse', 'Es läuft nur aus einem Warehouse')
      ],
      ['A'],
      t('MERGE is designed for upsert and change-processing patterns because it combines matching and nonmatching logic in one operation. That makes curated Delta loading more reliable and easier to maintain.', 'MERGE ist für Upsert- und Änderungsverarbeitungsmuster vorgesehen, weil es Logik für passende und nicht passende Zeilen in einem Vorgang kombiniert. Das macht das Laden kuratierter Delta-Tabellen zuverlässiger und leichter wartbar.'),
      t('Think one statement for insert and update behavior.', 'Denken Sie an eine Anweisung für Insert- und Update-Verhalten.'),
      ref.delta),

    q('dp700-222', 'single', prepare, 'easy',
      t('In a notebook, you run `df.write.format("delta").mode("overwrite").saveAsTable("silver.sales")`.', 'In einem Notebook führen Sie `df.write.format("delta").mode("overwrite").saveAsTable("silver.sales")` aus.'),
      t('What does this command do?', 'Was bewirkt dieser Befehl?'),
      [
        o('A', 'It writes the DataFrame as a Delta table and replaces existing table data', 'Er schreibt den DataFrame als Delta-Tabelle und ersetzt vorhandene Tabellendaten'),
        o('B', 'It reads an existing Delta table into memory', 'Er liest eine vorhandene Delta-Tabelle in den Arbeitsspeicher'),
        o('C', 'It exports the table to a CSV file', 'Er exportiert die Tabelle in eine CSV-Datei'),
        o('D', 'It creates a shortcut to OneLake', 'Er erstellt einen Shortcut zu OneLake')
      ],
      ['A'],
      t('The code writes the DataFrame in Delta format and registers it as a table named silver.sales. Because the mode is overwrite, existing table data is replaced.', 'Der Code schreibt den DataFrame im Delta-Format und registriert ihn als Tabelle mit dem Namen silver.sales. Da der Modus overwrite verwendet wird, werden vorhandene Tabellendaten ersetzt.'),
      t('Focus on format, write mode, and table registration.', 'Achten Sie auf Format, Schreibmodus und Tabellenregistrierung.'),
      ref.notebook),

    q('dp700-223', 'single', prepare, 'easy',
      null,
      t('In PySpark, what does `spark.read.format("delta").load("Tables/silver/sales")` do?', 'Was bewirkt `spark.read.format("delta").load("Tables/silver/sales")` in PySpark?'),
      [
        o('A', 'It reads Delta data from the specified path into a DataFrame', 'Es liest Delta-Daten vom angegebenen Pfad in einen DataFrame'),
        o('B', 'It optimizes the table for reporting', 'Es optimiert die Tabelle für Berichte'),
        o('C', 'It clones the table', 'Es klont die Tabelle'),
        o('D', 'It creates a semantic model', 'Es erstellt ein semantisches Modell')
      ],
      ['A'],
      t('The snippet uses the Spark reader with the Delta format to load table data from a path. The result is a DataFrame that can be transformed or explored in the notebook.', 'Das Snippet verwendet den Spark-Reader mit dem Delta-Format, um Tabellendaten von einem Pfad zu laden. Das Ergebnis ist ein DataFrame, der im Notebook transformiert oder untersucht werden kann.'),
      t('Read plus load means ingest into a DataFrame.', 'Read plus load bedeutet Laden in einen DataFrame.'),
      ref.notebook),

    q('dp700-224', 'single', prepare, 'medium',
      t('A Delta target table stores `CustomerId` as INT. A new DataFrame contains `CustomerId` as STRING, and the team attempts an append without any schema handling.', 'Eine Delta-Zieltabelle speichert `CustomerId` als INT. Ein neuer DataFrame enthält `CustomerId` als STRING, und das Team versucht ein Append ohne Schema-Behandlung.'),
      t('What should you expect?', 'Was ist zu erwarten?'),
      [
        o('A', 'Delta schema enforcement rejects the incompatible write', 'Die Delta-Schemaerzwingung weist den inkompatiblen Schreibvorgang zurück'),
        o('B', 'Delta silently converts all strings to integers', 'Delta konvertiert alle Zeichenfolgen stillschweigend in Ganzzahlen'),
        o('C', 'The write succeeds and changes the existing table type automatically', 'Der Schreibvorgang gelingt und ändert den vorhandenen Tabellentyp automatisch'),
        o('D', 'The table becomes a warehouse table', 'Die Tabelle wird zu einer Warehouse-Tabelle')
      ],
      ['A'],
      t('Delta tables enforce schema compatibility to protect table quality. If the incoming schema is incompatible and no explicit evolution or conversion is used, the write fails.', 'Delta-Tabellen erzwingen Schemakompatibilität, um die Tabellenqualität zu schützen. Wenn das eingehende Schema inkompatibel ist und keine explizite Evolution oder Konvertierung verwendet wird, schlägt der Schreibvorgang fehl.'),
      t('Delta protects the existing schema by default.', 'Delta schützt standardmäßig das vorhandene Schema.'),
      ref.delta),

    q('dp700-225', 'single', prepare, 'hard',
      null,
      t('When would you use `df.write.format("delta").mode("overwrite").option("overwriteSchema", "true").saveAsTable("gold.sales")`?', 'Wann würden Sie `df.write.format("delta").mode("overwrite").option("overwriteSchema", "true").saveAsTable("gold.sales")` verwenden?'),
      [
        o('A', 'When replacing a Delta table and intentionally updating its schema', 'Wenn Sie eine Delta-Tabelle ersetzen und ihr Schema bewusst aktualisieren'),
        o('B', 'When you want to create a read-only SQL endpoint', 'Wenn Sie einen schreibgeschützten SQL-Endpunkt erstellen möchten'),
        o('C', 'When you want to enable row-level security', 'Wenn Sie Row-Level-Security aktivieren möchten'),
        o('D', 'When you need to trigger a Power BI bookmark', 'Wenn Sie ein Power-BI-Lesezeichen auslösen müssen')
      ],
      ['A'],
      t('overwriteSchema is used when the table definition itself needs to change during an overwrite operation. It is not a security or reporting feature.', 'overwriteSchema wird verwendet, wenn sich die Tabellendefinition selbst während eines Overwrite-Vorgangs ändern muss. Es ist keine Sicherheits- oder Berichtsfunktion.'),
      t('The keyword is schema replacement during overwrite.', 'Das Schlüsselwort ist Schemaersetzung während eines Overwrite-Vorgangs.'),
      ref.delta),

    q('dp700-226', 'multiple', prepare, 'hard',
      t('A large Delta table receives frequent upserts, contains many small files, and is often filtered by a few business columns.', 'Eine große Delta-Tabelle erhält häufig Upserts, enthält viele kleine Dateien und wird oft nach einigen Geschäftsspalten gefiltert.'),
      t('Which two actions are most appropriate to improve performance?', 'Welche zwei Maßnahmen sind am geeignetsten, um die Leistung zu verbessern?'),
      [
        o('A', 'Run optimization or compaction to reduce small-file fragmentation', 'Führen Sie Optimierung oder Kompaktierung aus, um die Fragmentierung durch kleine Dateien zu reduzieren'),
        o('B', 'Use V-Order to improve scan efficiency', 'Verwenden Sie V-Order, um die Scan-Effizienz zu verbessern'),
        o('C', 'Convert the table to JSON', 'Konvertieren Sie die Tabelle in JSON'),
        o('D', 'Disable the Delta log', 'Deaktivieren Sie das Delta-Protokoll')
      ],
      ['A', 'B'],
      t('Compaction reduces the overhead created by many small files, and V-Order can improve analytical read performance. Converting away from Delta or disabling the log removes important platform benefits.', 'Kompaktierung reduziert den Aufwand durch viele kleine Dateien, und V-Order kann die analytische Leseleistung verbessern. Ein Wechsel weg von Delta oder das Deaktivieren des Protokolls entfernt wichtige Plattformvorteile.'),
      t('Address file layout and scan efficiency together.', 'Behandeln Sie Dateilayout und Scan-Effizienz gemeinsam.'),
      ref.vorder),

    q('dp700-227', 'single', prepare, 'medium',
      t('A developer runs the query `SELECT * FROM sales VERSION AS OF 15` against a Delta table.', 'Ein Entwickler führt die Abfrage `SELECT * FROM sales VERSION AS OF 15` gegen eine Delta-Tabelle aus.'),
      t('Which Delta capability is being used?', 'Welche Delta-Funktion wird verwendet?'),
      [
        o('A', 'Time travel', 'Time Travel'),
        o('B', 'Mirroring', 'Mirroring'),
        o('C', 'Object-level security', 'Object-Level-Security'),
        o('D', 'Cross-highlighting', 'Kreuzhervorhebung')
      ],
      ['A'],
      t('Time travel lets you query an earlier table version by version number or timestamp. This is useful for validation, recovery, and audit scenarios.', 'Time Travel ermöglicht die Abfrage einer früheren Tabellenversion über Versionsnummer oder Zeitstempel. Das ist nützlich für Validierungs-, Wiederherstellungs- und Auditszenarien.'),
      t('The query points to an older table version.', 'Die Abfrage verweist auf eine ältere Tabellenversion.'),
      ref.delta),

    q('dp700-228', 'single', prepare, 'easy',
      null,
      t('What is the main purpose of VACUUM for a Delta table after the retention period has passed?', 'Was ist der Hauptzweck von VACUUM für eine Delta-Tabelle, nachdem die Aufbewahrungsfrist abgelaufen ist?'),
      [
        o('A', 'Remove obsolete files that are no longer needed by table history', 'Veraltete Dateien entfernen, die von der Tabellenhistorie nicht mehr benötigt werden'),
        o('B', 'Create a semantic model automatically', 'Automatisch ein semantisches Modell erstellen'),
        o('C', 'Change table ownership', 'Den Tabelleneigentümer ändern'),
        o('D', 'Create a warehouse clone', 'Einen Warehouse-Klon erstellen')
      ],
      ['A'],
      t('VACUUM cleans up old physical files that remain after updates and deletes once they are outside the retention window. This helps reclaim storage and reduce clutter.', 'VACUUM bereinigt alte physische Dateien, die nach Updates und Deletes verbleiben, sobald sie außerhalb des Aufbewahrungsfensters liegen. Das hilft, Speicher zurückzugewinnen und Unordnung zu reduzieren.'),
      t('Think cleanup of stale files.', 'Denken Sie an die Bereinigung veralteter Dateien.'),
      ref.delta),

    q('dp700-229', 'single', prepare, 'medium',
      t('A notebook uses `df.write.format("delta").partitionBy("OrderDate").saveAsTable("silver.orders")` for a large table.', 'Ein Notebook verwendet `df.write.format("delta").partitionBy("OrderDate").saveAsTable("silver.orders")` für eine große Tabelle.'),
      t('Why can partitioning help in this case?', 'Warum kann Partitionierung in diesem Fall helfen?'),
      [
        o('A', 'It can reduce data scanned when queries frequently filter on OrderDate', 'Sie kann die gescannte Datenmenge verringern, wenn Abfragen häufig nach OrderDate filtern'),
        o('B', 'It removes the need for Delta logs', 'Sie macht Delta-Protokolle überflüssig'),
        o('C', 'It forces DirectLake mode for reports', 'Sie erzwingt DirectLake für Berichte'),
        o('D', 'It converts the table into a warehouse dimension', 'Sie konvertiert die Tabelle in eine Warehouse-Dimension')
      ],
      ['A'],
      t('Partitioning can improve pruning when query predicates align with the partition column. It should be chosen carefully, but it is often useful for large date-filtered tables.', 'Partitionierung kann das Pruning verbessern, wenn Abfrageprädikate mit der Partitionsspalte übereinstimmen. Sie sollte sorgfältig gewählt werden, ist aber häufig für große datumsgefilterte Tabellen nützlich.'),
      t('Think partition pruning on a common filter column.', 'Denken Sie an Partition Pruning auf einer häufigen Filterspalte.'),
      ref.delta),

    q('dp700-230', 'single', prepare, 'medium',
      null,
      t('What is a primary advantage of using `saveAsTable` instead of writing only to a file path in a Fabric lakehouse notebook?', 'Was ist ein primärer Vorteil der Verwendung von `saveAsTable` anstelle des Schreibens nur in einen Dateipfad in einem Fabric-Lakehouse-Notebook?'),
      [
        o('A', 'It registers the output as a table that can be queried more easily', 'Es registriert die Ausgabe als Tabelle, die leichter abgefragt werden kann'),
        o('B', 'It disables schema enforcement', 'Es deaktiviert die Schemaerzwingung'),
        o('C', 'It makes the table read-only', 'Es macht die Tabelle schreibgeschützt'),
        o('D', 'It bypasses OneLake storage', 'Es umgeht den OneLake-Speicher')
      ],
      ['A'],
      t('saveAsTable writes the data and registers it in the lakehouse catalog so it is easier to consume through Spark and SQL experiences. Writing only to a path does not provide the same table registration behavior.', 'saveAsTable schreibt die Daten und registriert sie im Lakehouse-Katalog, sodass sie über Spark- und SQL-Erfahrungen leichter genutzt werden können. Das Schreiben nur in einen Pfad bietet dieses Tabellenregistrierungsverhalten nicht.'),
      t('Look for table registration and discoverability.', 'Achten Sie auf Tabellenregistrierung und Auffindbarkeit.'),
      ref.notebook),

    q('dp700-231', 'single', prepare, 'easy',
      null,
      t('Which statement is true about the SQL analytics endpoint of a lakehouse?', 'Welche Aussage über den SQL-Analyseendpunkt eines Lakehouse ist richtig?'),
      [
        o('A', 'It is a read-only T-SQL surface over lakehouse tables', 'Er ist eine schreibgeschützte T-SQL-Oberfläche über Lakehouse-Tabellen'),
        o('B', 'It is used to manage tenant settings', 'Er wird zum Verwalten von Mandanteneinstellungen verwendet'),
        o('C', 'It replaces Spark for distributed ETL', 'Er ersetzt Spark für verteiltes ETL'),
        o('D', 'It stores data outside OneLake', 'Er speichert Daten außerhalb von OneLake')
      ],
      ['A'],
      t('The SQL analytics endpoint lets SQL users query lakehouse tables without moving the data. It is intended for read access rather than general relational write-back.', 'Der SQL-Analyseendpunkt ermöglicht SQL-Benutzern das Abfragen von Lakehouse-Tabellen, ohne die Daten zu verschieben. Er ist für Lesezugriff und nicht für allgemeine relationale Schreibvorgänge gedacht.'),
      t('Remember query access, not full write authoring.', 'Denken Sie an Abfragezugriff und nicht an vollständige Schreibentwicklung.'),
      ref.queryWarehouse),

    q('dp700-232', 'single', prepare, 'medium',
      t('During deployment, a warehouse team must create a summary table from an existing fact table in one T-SQL operation.', 'Während einer Bereitstellung muss ein Warehouse-Team in einem T-SQL-Vorgang eine Summierungstabelle aus einer vorhandenen Faktentabelle erstellen.'),
      t('Which approach is most appropriate?', 'Welcher Ansatz ist am geeignetsten?'),
      [
        o('A', 'Use CREATE TABLE AS SELECT', 'Verwenden Sie CREATE TABLE AS SELECT'),
        o('B', 'Use VACUUM', 'Verwenden Sie VACUUM'),
        o('C', 'Use a bookmark', 'Verwenden Sie ein Lesezeichen'),
        o('D', 'Use a data activator reflex', 'Verwenden Sie einen Data-Activator-Reflex')
      ],
      ['A'],
      t('CTAS creates a new table from a query result in one step. It is a common pattern for staging, snapshots, and derived summary tables in SQL warehouses.', 'CTAS erstellt in einem Schritt eine neue Tabelle aus einem Abfrageergebnis. Es ist ein häufiges Muster für Staging, Snapshots und abgeleitete Summierungstabellen in SQL-Warehouses.'),
      t('Think create plus load in one statement.', 'Denken Sie an Erstellen plus Laden in einer Anweisung.'),
      ref.warehouse),

    q('dp700-233', 'single', prepare, 'medium',
      t('A warehouse engineer runs `COPY INTO dbo.Sales FROM \'https://contoso.dfs.core.windows.net/raw/sales/\' WITH (FILE_TYPE = \'PARQUET\')`.', 'Ein Warehouse-Ingenieur führt `COPY INTO dbo.Sales FROM \'https://contoso.dfs.core.windows.net/raw/sales/\' WITH (FILE_TYPE = \'PARQUET\')` aus.'),
      t('What is this command used for?', 'Wofür wird dieser Befehl verwendet?'),
      [
        o('A', 'Load files from storage into an existing warehouse table', 'Dateien aus dem Speicher in eine vorhandene Warehouse-Tabelle laden'),
        o('B', 'Create a semantic model measure', 'Ein Measure im semantischen Modell erstellen'),
        o('C', 'Enable incremental refresh', 'Incremental Refresh aktivieren'),
        o('D', 'Optimize a Delta table with V-Order', 'Eine Delta-Tabelle mit V-Order optimieren')
      ],
      ['A'],
      t('COPY INTO is used to ingest files into a warehouse table with explicit file format options. It is designed for efficient file-based loading rather than semantic modeling or Delta maintenance.', 'COPY INTO wird verwendet, um Dateien mit expliziten Dateiformatoptionen in eine Warehouse-Tabelle zu laden. Es ist für effizientes dateibasiertes Laden und nicht für semantische Modellierung oder Delta-Wartung gedacht.'),
      t('It is a warehouse file-loading command.', 'Es handelt sich um einen Warehouse-Befehl zum Laden von Dateien.'),
      ref.warehouseTables),

    q('dp700-234', 'single', prepare, 'medium',
      null,
      t('Why would you encapsulate repeatable load and validation logic in a stored procedure in a Fabric warehouse?', 'Warum würden Sie wiederholbare Lade- und Validierungslogik in einer gespeicherten Prozedur in einem Fabric Warehouse kapseln?'),
      [
        o('A', 'To reuse SQL logic from pipelines or manual execution', 'Um SQL-Logik aus Pipelines oder manueller Ausführung wiederzuverwenden'),
        o('B', 'To create notebook charts', 'Um Notebook-Diagramme zu erstellen'),
        o('C', 'To assign workspace roles', 'Um Arbeitsbereichsrollen zuzuweisen'),
        o('D', 'To replace bookmarks', 'Um Lesezeichen zu ersetzen')
      ],
      ['A'],
      t('Stored procedures package repeatable SQL steps behind a callable interface. This improves reuse and keeps orchestration cleaner when pipelines invoke warehouse logic.', 'Gespeicherte Prozeduren kapseln wiederholbare SQL-Schritte hinter einer aufrufbaren Schnittstelle. Das verbessert die Wiederverwendung und hält die Orchestrierung sauberer, wenn Pipelines Warehouse-Logik aufrufen.'),
      t('Choose the reusable SQL execution object.', 'Wählen Sie das wiederverwendbare SQL-Ausführungsobjekt.'),
      ref.queryWarehouse),

    q('dp700-235', 'single', prepare, 'hard',
      t('A warehouse developer writes `SELECT * FROM SalesWH.dbo.FactSales s JOIN FinanceWH.dbo.DimDate d ON s.DateKey = d.DateKey` inside a Fabric SQL editor.', 'Ein Warehouse-Entwickler schreibt `SELECT * FROM SalesWH.dbo.FactSales s JOIN FinanceWH.dbo.DimDate d ON s.DateKey = d.DateKey` in einem Fabric-SQL-Editor.'),
      t('Which Fabric capability makes this possible?', 'Welche Fabric-Funktion macht dies möglich?'),
      [
        o('A', 'Cross-warehouse query support', 'Unterstützung für Cross-Warehouse-Abfragen'),
        o('B', 'A paginated report dataset', 'Ein paginierter Berichtsdataset'),
        o('C', 'A bookmark group', 'Eine Lesezeichengruppe'),
        o('D', 'Row-level security', 'Row-Level-Security')
      ],
      ['A'],
      t('Fabric supports cross-warehouse SQL queries so you can reference objects from multiple warehouses in the same workspace. This is a T-SQL capability, not a report-layer feature.', 'Fabric unterstützt Cross-Warehouse-SQL-Abfragen, sodass Sie Objekte aus mehreren Warehouses im selben Arbeitsbereich referenzieren können. Dies ist eine T-SQL-Funktion und keine Berichtsfunktion.'),
      t('Notice the query references two warehouse databases.', 'Beachten Sie, dass die Abfrage auf zwei Warehouse-Datenbanken verweist.'),
      ref.crossWarehouse),

    q('dp700-236', 'single', prepare, 'medium',
      t('A team needs a safe copy of a production warehouse table for testing today, and the copy must be created immediately with minimal extra storage.', 'Ein Team benötigt heute eine sichere Kopie einer Produktions-Warehouse-Tabelle für Tests, und die Kopie muss sofort mit minimalem zusätzlichem Speicher erstellt werden.'),
      t('Which feature best fits?', 'Welche Funktion passt am besten?'),
      [
        o('A', 'Table clone', 'Tabellenklon'),
        o('B', 'Shortcut', 'Shortcut'),
        o('C', 'Bookmark', 'Lesezeichen'),
        o('D', 'Object-level security', 'Object-Level-Security')
      ],
      ['A'],
      t('A table clone creates a fast copy-on-write style copy with minimal initial storage overhead. It is designed for testing and recovery scenarios.', 'Ein Tabellenklon erstellt eine schnelle Copy-on-Write-artige Kopie mit minimalem anfänglichem Speicheraufwand. Er ist für Test- und Wiederherstellungsszenarien vorgesehen.'),
      t('Think instant low-storage copy.', 'Denken Sie an eine sofortige Kopie mit geringem Speicherbedarf.'),
      ref.clone),

    q('dp700-237', 'single', prepare, 'easy',
      null,
      t('Which Fabric experience lets analysts shape data with Power Query and then load it into a lakehouse or warehouse?', 'Welche Fabric-Erfahrung ermöglicht es Analysten, Daten mit Power Query aufzubereiten und anschließend in ein Lakehouse oder Warehouse zu laden?'),
      [
        o('A', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('B', 'KQL dashboard', 'KQL-Dashboard'),
        o('C', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('D', 'Capacity metrics app', 'Kapazitätsmetriken-App')
      ],
      ['A'],
      t('Dataflows Gen2 provide a low-code Power Query authoring experience and can write to Fabric destinations. They are well suited for analyst-friendly transformation workflows.', 'Dataflows Gen2 bieten eine Low-Code-Authoring-Erfahrung mit Power Query und können in Fabric-Ziele schreiben. Sie eignen sich gut für analystenfreundliche Transformationsworkflows.'),
      t('Think Power Query plus Fabric destination.', 'Denken Sie an Power Query plus Fabric-Ziel.'),
      ref.dataflows),

    q('dp700-238', 'multiple', prepare, 'medium',
      null,
      t('Which two pipeline capabilities should you use for a nightly load that must run on a schedule and accept different source paths in dev and prod?', 'Welche zwei Pipeline-Funktionen sollten Sie für einen nächtlichen Ladevorgang verwenden, der nach Zeitplan laufen und unterschiedliche Quellpfade in Entwicklung und Produktion akzeptieren muss?'),
      [
        o('A', 'A schedule trigger', 'Einen Zeitplan-Trigger'),
        o('B', 'Pipeline parameters', 'Pipeline-Parameter'),
        o('C', 'A bookmark navigator', 'Einen Lesezeichen-Navigator'),
        o('D', 'Object-level security', 'Object-Level-Security')
      ],
      ['A', 'B'],
      t('A schedule trigger controls when the pipeline runs, and parameters let the same logic use different values by environment. Together they support reusable nightly orchestration.', 'Ein Zeitplan-Trigger steuert, wann die Pipeline läuft, und Parameter erlauben derselben Logik, je nach Umgebung unterschiedliche Werte zu verwenden. Zusammen unterstützen sie wiederverwendbare nächtliche Orchestrierung.'),
      t('One feature controls timing, the other controls input values.', 'Eine Funktion steuert das Timing, die andere die Eingabewerte.'),
      ref.pipelines),

    q('dp700-239', 'multiple', prepare, 'medium',
      t('A metadata table lists 500 source files that must each be copied and then validated. You want one reusable orchestration pattern instead of hundreds of duplicated activities.', 'Eine Metadatentabelle listet 500 Quelldateien auf, die jeweils kopiert und anschließend validiert werden müssen. Sie möchten ein wiederverwendbares Orchestrierungsmuster statt hunderter duplizierter Aktivitäten.'),
      t('Which two pipeline concepts should you use?', 'Welche zwei Pipeline-Konzepte sollten Sie verwenden?'),
      [
        o('A', 'Lookup activity to read metadata', 'Lookup-Aktivität zum Lesen der Metadaten'),
        o('B', 'ForEach activity to iterate through items', 'ForEach-Aktivität zum Durchlaufen der Elemente'),
        o('C', 'Bookmark navigator to branch logic', 'Lesezeichen-Navigator zum Verzweigen der Logik'),
        o('D', 'Q&A visual to parameterize activity names', 'Q&A-Visual zur Parametrisierung von Aktivitätsnamen')
      ],
      ['A', 'B'],
      t('Metadata-driven pipelines commonly use a Lookup to read control data and a ForEach to execute the same pattern for each row. This avoids hardcoding hundreds of repeated activities.', 'Metadatengesteuerte Pipelines verwenden häufig ein Lookup zum Lesen von Steuerdaten und ein ForEach, um dasselbe Muster für jede Zeile auszuführen. Dadurch werden Hunderte fest verdrahteter Wiederholungen vermieden.'),
      t('Think metadata first, then iteration.', 'Denken Sie zuerst an Metadaten und dann an Iteration.'),
      ref.pipelines),

    q('dp700-240', 'single', prepare, 'medium',
      t('You need transformations with custom Python libraries, complex branching logic, and distributed processing over hundreds of gigabytes.', 'Sie benötigen Transformationen mit benutzerdefinierten Python-Bibliotheken, komplexer Verzweigungslogik und verteilter Verarbeitung über mehrere hundert Gigabyte.'),
      t('Which Fabric capability is the best fit?', 'Welche Fabric-Funktion ist am besten geeignet?'),
      [
        o('A', 'Notebook with Spark', 'Notebook mit Spark'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'Q&A visual', 'Q&A-Visual'),
        o('D', 'Sensitivity label', 'Vertraulichkeitsbezeichnung')
      ],
      ['A'],
      t('Spark notebooks are designed for code-first distributed transformations and can use custom libraries. That makes them the right choice for complex engineering workloads.', 'Spark-Notebooks sind für codebasierte verteilte Transformationen ausgelegt und können benutzerdefinierte Bibliotheken verwenden. Das macht sie zur richtigen Wahl für komplexe Engineering-Workloads.'),
      t('Look for the distributed code-first option.', 'Suchen Sie nach der verteilten codebasierten Option.'),
      ref.notebook),

    q('dp700-241', 'single', prepare, 'medium',
      t('A data engineering team wants reusable Spark code packaged as a deployable artifact that can run without opening an interactive notebook session.', 'Ein Data-Engineering-Team möchte wiederverwendbaren Spark-Code als bereitstellbares Artefakt verpacken, das ohne interaktive Notebook-Sitzung ausgeführt werden kann.'),
      t('Which Fabric item should they use?', 'Welches Fabric-Element sollten sie verwenden?'),
      [
        o('A', 'Spark job definition', 'Spark-Job-Definition'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'KQL dashboard', 'KQL-Dashboard'),
        o('D', 'Paginated report', 'Paginierter Bericht')
      ],
      ['A'],
      t('Spark job definitions are intended for reusable, scheduled, or operationalized Spark execution. They separate job execution from interactive notebook authoring.', 'Spark-Job-Definitionen sind für wiederverwendbare, geplante oder operationalisierte Spark-Ausführung vorgesehen. Sie trennen die Jobausführung von der interaktiven Notebook-Entwicklung.'),
      t('Choose the artifact meant for operational Spark jobs.', 'Wählen Sie das Artefakt, das für operative Spark-Jobs gedacht ist.'),
      ref.sparkJobs),

    q('dp700-242', 'single', prepare, 'medium',
      t('A lakehouse must analyze data already stored in Azure Data Lake Storage Gen2, but governance rules prohibit copying the files into OneLake.', 'Ein Lakehouse muss bereits in Azure Data Lake Storage Gen2 gespeicherte Daten analysieren, aber Governance-Regeln verbieten das Kopieren der Dateien nach OneLake.'),
      t('Which feature should you use?', 'Welche Funktion sollten Sie verwenden?'),
      [
        o('A', 'OneLake shortcut', 'OneLake-Shortcut'),
        o('B', 'Warehouse clone', 'Warehouse-Klon'),
        o('C', 'Paginated report', 'Paginierter Bericht'),
        o('D', 'Calculation group', 'Berechnungsgruppe')
      ],
      ['A'],
      t('A shortcut gives Fabric logical access to external data without physically copying it into OneLake. This is the correct choice when duplication is not allowed.', 'Ein Shortcut gibt Fabric logischen Zugriff auf externe Daten, ohne sie physisch nach OneLake zu kopieren. Das ist die richtige Wahl, wenn Duplizierung nicht zulässig ist.'),
      t('The requirement is access without copy.', 'Die Anforderung lautet Zugriff ohne Kopie.'),
      ref.shortcuts),

    q('dp700-243', 'single', prepare, 'medium',
      t('An operations database in Azure SQL must be replicated continuously into Fabric so downstream analytics can use local copies with low latency.', 'Eine operative Datenbank in Azure SQL muss kontinuierlich nach Fabric repliziert werden, damit nachgelagerte Analysen lokale Kopien mit geringer Latenz verwenden können.'),
      t('Which feature should you use?', 'Welche Funktion sollten Sie verwenden?'),
      [
        o('A', 'Mirroring', 'Mirroring'),
        o('B', 'Shortcut', 'Shortcut'),
        o('C', 'Bookmarks', 'Lesezeichen'),
        o('D', 'Object-level security', 'Object-Level-Security')
      ],
      ['A'],
      t('Mirroring keeps a low-latency replicated copy of supported operational sources inside Fabric. That is different from a shortcut, which does not replicate the data.', 'Mirroring hält eine replizierte Kopie unterstützter operativer Quellen mit geringer Latenz innerhalb von Fabric. Das unterscheidet sich von einem Shortcut, der die Daten nicht repliziert.'),
      t('Local replicated copies point to mirroring.', 'Lokale replizierte Kopien weisen auf Mirroring hin.'),
      ref.mirroring),

    q('dp700-244', 'single', prepare, 'medium',
      t('A manufacturing solution streams sensor events and must route them with low latency to analytical destinations in Fabric.', 'Eine Fertigungslösung streamt Sensordaten und muss sie mit geringer Latenz an analytische Ziele in Fabric weiterleiten.'),
      t('Which Fabric capability is designed for this requirement?', 'Welche Fabric-Funktion ist für diese Anforderung vorgesehen?'),
      [
        o('A', 'Eventstream', 'Eventstream'),
        o('B', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('C', 'Calculation group', 'Berechnungsgruppe'),
        o('D', 'Workspace role', 'Arbeitsbereichsrolle')
      ],
      ['A'],
      t('Eventstream is built for ingesting, routing, and processing streaming events in Fabric. It is the right fit for low-latency event-driven analytics pipelines.', 'Eventstream ist für die Aufnahme, Weiterleitung und Verarbeitung von Streaming-Ereignissen in Fabric ausgelegt. Es ist die richtige Wahl für ereignisgesteuerte Analysepipelines mit geringer Latenz.'),
      t('Choose the real-time ingestion and routing service.', 'Wählen Sie den Dienst für Echtzeitaufnahme und Weiterleitung.'),
      ref.eventstream),

    q('dp700-245', 'multiple', prepare, 'hard',
      null,
      t('Which two statements correctly describe Fabric Eventstream capabilities?', 'Welche zwei Aussagen beschreiben die Fähigkeiten von Fabric Eventstream korrekt?'),
      [
        o('A', 'It can ingest events from streaming sources', 'Es kann Ereignisse aus Streaming-Quellen aufnehmen'),
        o('B', 'It can route or transform events toward destinations', 'Es kann Ereignisse in Richtung Ziele weiterleiten oder transformieren'),
        o('C', 'It is used to define DAX relationships', 'Es wird zum Definieren von DAX-Beziehungen verwendet'),
        o('D', 'It assigns workspace roles automatically', 'Es weist automatisch Arbeitsbereichsrollen zu')
      ],
      ['A', 'B'],
      t('Eventstream is meant for ingestion, shaping, and routing of real-time event data. It is not a semantic-model or security administration feature.', 'Eventstream ist für die Aufnahme, Aufbereitung und Weiterleitung von Echtzeit-Ereignisdaten vorgesehen. Es ist keine Funktion für semantische Modelle oder Sicherheitsadministration.'),
      t('Stay in the real-time ingestion domain.', 'Bleiben Sie im Bereich der Echtzeitaufnahme.'),
      ref.eventstream),

    q('dp700-246', 'multiple', prepare, 'medium',
      null,
      t('Which two design choices are hallmarks of a good star schema for reporting?', 'Welche zwei Entwurfsentscheidungen sind Kennzeichen eines guten Star-Schemas für Berichte?'),
      [
        o('A', 'Keep fact tables at a consistent grain', 'Halten Sie Faktentabellen auf einer konsistenten Granularität'),
        o('B', 'Store all attributes in one wide denormalized fact table', 'Speichern Sie alle Attribute in einer breiten denormalisierten Faktentabelle'),
        o('C', 'Use dimension tables for descriptive filtering attributes', 'Verwenden Sie Dimensionstabellen für beschreibende Filterattribute'),
        o('D', 'Avoid relationships between facts and dimensions', 'Vermeiden Sie Beziehungen zwischen Fakten und Dimensionen')
      ],
      ['A', 'C'],
      t('A star schema works best when facts are modeled at a clear grain and descriptive attributes are placed in dimensions. This improves filtering, slicing, and semantic clarity.', 'Ein Star-Schema funktioniert am besten, wenn Fakten auf einer klaren Granularität modelliert werden und beschreibende Attribute in Dimensionen liegen. Das verbessert Filtern, Slice-and-Dice und semantische Klarheit.'),
      t('Pick one answer about grain and one about dimensions.', 'Wählen Sie eine Antwort zur Granularität und eine zu Dimensionen.'),
      ref.star),

    q('dp700-247', 'single', prepare, 'medium',
      t('A semantic model needs to relate customers to multiple marketing campaigns, and each campaign can target many customers.', 'Ein semantisches Modell muss Kunden mit mehreren Marketingkampagnen verknüpfen, und jede Kampagne kann viele Kunden ansprechen.'),
      t('Which modeling approach is most appropriate?', 'Welcher Modellierungsansatz ist am geeignetsten?'),
      [
        o('A', 'Use a bridge table between the entities', 'Verwenden Sie eine Brückentabelle zwischen den Entitäten'),
        o('B', 'Duplicate the fact table for each campaign', 'Duplizieren Sie die Faktentabelle für jede Kampagne'),
        o('C', 'Remove the customer dimension', 'Entfernen Sie die Kundendimension'),
        o('D', 'Convert the model to paginated report format', 'Konvertieren Sie das Modell in ein paginiertes Berichtsformat')
      ],
      ['A'],
      t('A bridge table is the standard way to resolve many-to-many relationships while keeping the model understandable. It preserves a controlled relational design for filtering and analysis.', 'Eine Brückentabelle ist der Standardweg, um Viele-zu-viele-Beziehungen aufzulösen und das Modell gleichzeitig verständlich zu halten. Sie bewahrt ein kontrolliertes relationales Design für Filterung und Analyse.'),
      t('Many-to-many usually points to a bridge.', 'Viele-zu-viele weist in der Regel auf eine Brücke hin.'),
      ref.relationships),

    q('dp700-248', 'single', prepare, 'easy',
      null,
      t('In a medallion-style lakehouse design, which layer should contain raw landed source data with minimal transformation?', 'Welche Schicht sollte in einem Lakehouse-Design im Medallion-Stil rohe gelandete Quelldaten mit minimaler Transformation enthalten?'),
      [
        o('A', 'Bronze', 'Bronze'),
        o('B', 'Silver', 'Silber'),
        o('C', 'Gold', 'Gold'),
        o('D', 'Semantic', 'Semantisch')
      ],
      ['A'],
      t('The bronze layer is commonly used for raw or minimally processed landed data. Silver and gold layers are typically used for cleansed and curated outputs.', 'Die Bronze-Schicht wird üblicherweise für rohe oder minimal verarbeitete gelandete Daten verwendet. Silver- und Gold-Schichten werden typischerweise für bereinigte und kuratierte Ausgaben genutzt.'),
      t('Raw data lands first in bronze.', 'Rohdaten landen zuerst in Bronze.'),
      ref.lakehouse),

    q('dp700-249', 'single', prepare, 'medium',
      null,
      t('Why would a notebook author call `df.createOrReplaceTempView("staging_sales")` after loading a DataFrame?', 'Warum würde ein Notebook-Autor `df.createOrReplaceTempView("staging_sales")` aufrufen, nachdem ein DataFrame geladen wurde?'),
      [
        o('A', 'To query the DataFrame with Spark SQL in the current session', 'Um den DataFrame in der aktuellen Sitzung mit Spark SQL abzufragen'),
        o('B', 'To persist the data automatically as a warehouse table', 'Um die Daten automatisch als Warehouse-Tabelle zu persistieren'),
        o('C', 'To enable OneLake shortcuts', 'Um OneLake-Shortcuts zu aktivieren'),
        o('D', 'To create row-level security', 'Um Row-Level-Security zu erstellen')
      ],
      ['A'],
      t('A temporary view exposes the DataFrame to Spark SQL for the current session. It is a convenient bridge between DataFrame code and SQL-based exploration or transformation.', 'Eine temporäre Sicht stellt den DataFrame für Spark SQL in der aktuellen Sitzung bereit. Sie ist eine praktische Brücke zwischen DataFrame-Code und SQL-basierter Exploration oder Transformation.'),
      t('Think session-scoped SQL access to the DataFrame.', 'Denken Sie an sitzungsbezogenen SQL-Zugriff auf den DataFrame.'),
      ref.notebook),

    q('dp700-250', 'single', prepare, 'medium',
      t('Business analysts need a reusable low-code transformation process with familiar Power Query steps rather than custom Spark code.', 'Fachanalysten benötigen einen wiederverwendbaren Low-Code-Transformationsprozess mit vertrauten Power-Query-Schritten statt benutzerdefiniertem Spark-Code.'),
      t('Which Fabric capability is the best fit?', 'Welche Fabric-Funktion ist am besten geeignet?'),
      [
        o('A', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('B', 'Spark job definition', 'Spark-Job-Definition'),
        o('C', 'Capacity metrics app', 'Kapazitätsmetriken-App'),
        o('D', 'KQL Queryset', 'KQL-Queryset')
      ],
      ['A'],
      t('Dataflows Gen2 target low-code transformation authoring with Power Query and are easy for analysts to maintain. That is a better fit than custom Spark code when code-first engineering is not required.', 'Dataflows Gen2 zielen auf Low-Code-Transformationsentwicklung mit Power Query ab und sind für Analysten leicht zu pflegen. Das ist besser geeignet als benutzerdefinierter Spark-Code, wenn kein codebasiertes Engineering erforderlich ist.'),
      t('Power Query is the clue.', 'Power Query ist der Hinweis.'),
      ref.dataflows),

    q('dp700-251', 'multiple', prepare, 'hard',
      null,
      t('Which two benefits are typical reasons to use `COPY INTO` for warehouse ingestion?', 'Welche zwei Vorteile sind typische Gründe für die Verwendung von `COPY INTO` bei der Warehouse-Aufnahme?'),
      [
        o('A', 'It loads files directly from storage into a warehouse table', 'Es lädt Dateien direkt aus dem Speicher in eine Warehouse-Tabelle'),
        o('B', 'It lets you specify file format options for the load', 'Es ermöglicht die Angabe von Dateiformatoptionen für den Ladevorgang'),
        o('C', 'It creates calculation groups automatically', 'Es erstellt automatisch Berechnungsgruppen'),
        o('D', 'It configures workspace roles for the destination', 'Es konfiguriert Arbeitsbereichsrollen für das Ziel')
      ],
      ['A', 'B'],
      t('COPY INTO is intended for controlled file-based loading into warehouse tables. File location and format handling are core parts of the command.', 'COPY INTO ist für kontrolliertes dateibasiertes Laden in Warehouse-Tabellen gedacht. Speicherort und Formatbehandlung sind zentrale Bestandteile des Befehls.'),
      t('Stay in the file ingestion space.', 'Bleiben Sie im Bereich der Dateiaufnahme.'),
      ref.warehouseTables),

    q('dp700-252', 'single', prepare, 'hard',
      t('A notebook contains the code `MERGE INTO gold.customer t USING updates s ON t.CustomerId = s.CustomerId WHEN MATCHED THEN UPDATE SET * WHEN NOT MATCHED THEN INSERT *`.', 'Ein Notebook enthält den Code `MERGE INTO gold.customer t USING updates s ON t.CustomerId = s.CustomerId WHEN MATCHED THEN UPDATE SET * WHEN NOT MATCHED THEN INSERT *`.'),
      t('What business pattern does this statement implement?', 'Welches Geschäftsmuster implementiert diese Anweisung?'),
      [
        o('A', 'Upsert processing for changed and new rows', 'Upsert-Verarbeitung für geänderte und neue Zeilen'),
        o('B', 'A one-time full export to CSV', 'Einen einmaligen Voll-Export nach CSV'),
        o('C', 'A dashboard subscription', 'Ein Dashboard-Abonnement'),
        o('D', 'A row-level security role', 'Eine Row-Level-Security-Rolle')
      ],
      ['A'],
      t('MERGE applies different actions depending on whether a match is found, which is the classic upsert pattern. It is widely used for curated dimensions and facts.', 'MERGE wendet unterschiedliche Aktionen an, je nachdem, ob eine Übereinstimmung gefunden wird. Das ist das klassische Upsert-Muster. Es wird häufig für kuratierte Dimensionen und Fakten verwendet.'),
      t('Matched rows update, unmatched rows insert.', 'Übereinstimmende Zeilen werden aktualisiert, nicht übereinstimmende eingefügt.'),
      ref.delta),

    q('dp700-253', 'single', prepare, 'easy',
      t('In a notebook, you run `display(df.groupBy("Region").count())`.', 'In einem Notebook führen Sie `display(df.groupBy("Region").count())` aus.'),
      t('What do you get?', 'Was erhalten Sie?'),
      [
        o('A', 'A visual table of row counts by Region', 'Eine visuelle Tabelle mit Zeilenanzahlen nach Region'),
        o('B', 'A clone of the source table', 'Einen Klon der Quelltabelle'),
        o('C', 'A deployment pipeline', 'Eine Deployment-Pipeline'),
        o('D', 'A new workspace role', 'Eine neue Arbeitsbereichsrolle')
      ],
      ['A'],
      t('The code groups rows by Region, counts them, and displays the result in the notebook. This is a common quick check after data preparation steps.', 'Der Code gruppiert Zeilen nach Region, zählt sie und zeigt das Ergebnis im Notebook an. Dies ist eine häufige schnelle Prüfung nach Datenaufbereitungsschritten.'),
      t('Group, count, then display the result.', 'Gruppieren, zählen und dann das Ergebnis anzeigen.'),
      ref.notebook),

    q('dp700-254', 'multiple', prepare, 'medium',
      null,
      t('Which two situations make Dataflow Gen2 a better choice than a Spark notebook?', 'Welche zwei Situationen machen Dataflow Gen2 zu einer besseren Wahl als ein Spark-Notebook?'),
      [
        o('A', 'Business users prefer Power Query for transformations', 'Fachanwender bevorzugen Power Query für Transformationen'),
        o('B', 'The solution should be maintained with a low-code experience', 'Die Lösung soll mit einer Low-Code-Erfahrung gepflegt werden'),
        o('C', 'You need custom distributed Python libraries', 'Sie benötigen benutzerdefinierte verteilte Python-Bibliotheken'),
        o('D', 'You must debug low-level Spark partitioning', 'Sie müssen Low-Level-Spark-Partitionierung debuggen')
      ],
      ['A', 'B'],
      t('Dataflows Gen2 are ideal when the transformation authors prefer Power Query and low-code maintenance. Deep custom Python and low-level Spark control are reasons to choose notebooks instead.', 'Dataflows Gen2 sind ideal, wenn die Autoren der Transformation Power Query und Low-Code-Wartung bevorzugen. Tiefgehende benutzerdefinierte Python-Logik und Low-Level-Spark-Kontrolle sprechen stattdessen für Notebooks.'),
      t('Look for the low-code authoring scenarios.', 'Achten Sie auf die Low-Code-Authoring-Szenarien.'),
      ref.dataflows),

    q('dp700-255', 'single', prepare, 'medium',
      t('A warehouse team must guarantee exact data types before loading a finance table from files. They plan to run `CREATE TABLE dbo.FactLedger (...)` first and then load the data.', 'Ein Warehouse-Team muss exakte Datentypen garantieren, bevor eine Finanztabelle aus Dateien geladen wird. Es plant zuerst `CREATE TABLE dbo.FactLedger (...)` auszuführen und dann die Daten zu laden.'),
      t('Why is this approach useful?', 'Warum ist dieser Ansatz sinnvoll?'),
      [
        o('A', 'It lets the team control schema and data types before ingestion', 'Er ermöglicht dem Team, Schema und Datentypen vor der Aufnahme zu kontrollieren'),
        o('B', 'It automatically creates a semantic model', 'Er erstellt automatisch ein semantisches Modell'),
        o('C', 'It disables capacity throttling', 'Er deaktiviert Kapazitätsdrosselung'),
        o('D', 'It creates a OneLake shortcut', 'Er erstellt einen OneLake-Shortcut')
      ],
      ['A'],
      t('Explicit CREATE TABLE is useful when you need strong control over column names, types, and nullability before loading data. That is common in finance and governed warehouse scenarios.', 'Ein explizites CREATE TABLE ist nützlich, wenn Sie starke Kontrolle über Spaltennamen, Typen und Nullbarkeit vor dem Laden der Daten benötigen. Das ist in Finanz- und regulierten Warehouse-Szenarien üblich.'),
      t('The goal is schema control before load.', 'Das Ziel ist Schemakontrolle vor dem Laden.'),
      ref.warehouseTables),

    q('dp700-256', 'single', semantic, 'easy',
      t('A Fabric semantic model must query OneLake data with near-import performance, but the team wants to avoid copying the data into the model during refresh.', 'Ein semantisches Fabric-Modell muss OneLake-Daten mit nahezu Import-Leistung abfragen, aber das Team möchte vermeiden, die Daten während der Aktualisierung in das Modell zu kopieren.'),
      t('Which storage mode best fits this requirement?', 'Welcher Speichermodus passt am besten zu dieser Anforderung?'),
      [
        o('A', 'DirectLake', 'DirectLake'),
        o('B', 'Import', 'Import'),
        o('C', 'DirectQuery', 'DirectQuery'),
        o('D', 'Live connection only', 'Nur Liveverbindung')
      ],
      ['A'],
      t('DirectLake is designed to read data from OneLake without the classic import copy process while still delivering very fast performance. That makes it a strong choice for Fabric-native semantic models over lake data.', 'DirectLake ist dafür ausgelegt, Daten aus OneLake ohne den klassischen Importkopierprozess zu lesen und dennoch sehr schnelle Leistung zu liefern. Das macht es zu einer starken Wahl für Fabric-native semantische Modelle über Lake-Daten.'),
      t('The clue is no copied data plus near-import speed.', 'Der Hinweis lautet keine kopierten Daten plus nahezu Importgeschwindigkeit.'),
      ref.directLake),

    q('dp700-257', 'multiple', semantic, 'medium',
      t('A team is evaluating DirectLake for a semantic model on top of Fabric data.', 'Ein Team bewertet DirectLake für ein semantisches Modell auf Basis von Fabric-Daten.'),
      t('Which two statements about DirectLake are correct?', 'Welche zwei Aussagen zu DirectLake sind korrekt?'),
      [
        o('A', 'It can read OneLake data without a traditional import copy', 'Es kann OneLake-Daten ohne traditionelle Importkopie lesen'),
        o('B', 'It can fall back to DirectQuery behavior in some situations', 'Es kann in bestimmten Situationen auf DirectQuery-Verhalten zurückfallen'),
        o('C', 'It always requires an on-premises gateway', 'Es erfordert immer ein lokales Gateway'),
        o('D', 'It stores model data only in SQL Server', 'Es speichert Modelldaten nur in SQL Server')
      ],
      ['A', 'B'],
      t('DirectLake is optimized for Fabric-native storage access, and the platform can fall back in some scenarios when needed. It does not depend on an on-premises gateway for Fabric-hosted data.', 'DirectLake ist für Fabric-native Speicherzugriffe optimiert, und die Plattform kann bei Bedarf in einigen Szenarien zurückfallen. Für in Fabric gehostete Daten hängt es nicht von einem lokalen Gateway ab.'),
      t('Think Fabric-native access with fallback behavior.', 'Denken Sie an Fabric-nativen Zugriff mit Rückfallverhalten.'),
      ref.directLake),

    q('dp700-258', 'single', semantic, 'medium',
      null,
      t('When is Import mode usually the best choice for a semantic model?', 'Wann ist der Importmodus normalerweise die beste Wahl für ein semantisches Modell?'),
      [
        o('A', 'When the model fits in memory and the fastest query performance is required', 'Wenn das Modell in den Speicher passt und die schnellste Abfrageleistung erforderlich ist'),
        o('B', 'When zero-copy access to OneLake is mandatory', 'Wenn Zero-Copy-Zugriff auf OneLake zwingend erforderlich ist'),
        o('C', 'When every query must execute on the source system', 'Wenn jede Abfrage auf dem Quellsystem ausgeführt werden muss'),
        o('D', 'When a model must avoid refresh entirely', 'Wenn ein Modell jegliche Aktualisierung vermeiden muss')
      ],
      ['A'],
      t('Import mode keeps data in the model for very fast query response, assuming the model size is manageable and scheduled refresh is acceptable. The trade-off is that data must be refreshed to stay current.', 'Der Importmodus hält Daten im Modell für sehr schnelle Abfrageantworten, sofern die Modellgröße beherrschbar ist und geplante Aktualisierung akzeptabel ist. Der Nachteil ist, dass die Daten aktualisiert werden müssen, um aktuell zu bleiben.'),
      t('Fastest queries plus manageable size point to Import.', 'Schnellste Abfragen plus beherrschbare Größe sprechen für Import.'),
      ref.largeModels),

    q('dp700-259', 'multiple', semantic, 'hard',
      t('A model must use imported summary tables for speed while keeping detailed operational data queryable without importing all of it.', 'Ein Modell muss importierte Summierungstabellen für hohe Geschwindigkeit verwenden und gleichzeitig operative Detaildaten abfragbar halten, ohne alles zu importieren.'),
      t('Which two characteristics describe the best design?', 'Welche zwei Merkmale beschreiben das beste Design?'),
      [
        o('A', 'Use a composite model with mixed storage modes', 'Verwenden Sie ein zusammengesetztes Modell mit gemischten Speichermodi'),
        o('B', 'Pair imported aggregations with a live detail table', 'Kombinieren Sie importierte Aggregationen mit einer Live-Detailtabelle'),
        o('C', 'Force every table to use the same storage mode', 'Erzwingen Sie für jede Tabelle denselben Speichermodus'),
        o('D', 'Avoid measures in the model', 'Vermeiden Sie Measures im Modell')
      ],
      ['A', 'B'],
      t('Composite models let you mix storage modes so aggregated data can be served fast while detail remains live. This pattern is commonly used with aggregation tables to balance speed and freshness.', 'Zusammengesetzte Modelle erlauben das Mischen von Speichermodi, sodass aggregierte Daten schnell bereitgestellt werden können, während Details live bleiben. Dieses Muster wird häufig mit Aggregationstabellen verwendet, um Geschwindigkeit und Aktualität auszugleichen.'),
      t('Think imported summaries plus live detail.', 'Denken Sie an importierte Summen plus Live-Details.'),
      ref.aggregations),

    q('dp700-260', 'single', semantic, 'medium',
      null,
      t('What does `CALCULATE([Total Revenue], Product[Color] = "Blue")` do in DAX?', 'Was bewirkt `CALCULATE([Total Revenue], Product[Color] = "Blue")` in DAX?'),
      [
        o('A', 'It evaluates the measure after modifying filter context to Blue products', 'Es wertet das Measure aus, nachdem der Filterkontext auf blaue Produkte geändert wurde'),
        o('B', 'It creates a new relationship', 'Es erstellt eine neue Beziehung'),
        o('C', 'It iterates row by row over the product table', 'Es iteriert zeilenweise über die Produkttabelle'),
        o('D', 'It removes all filters from the model', 'Es entfernt alle Filter aus dem Modell')
      ],
      ['A'],
      t('CALCULATE changes filter context before evaluating the expression. In this case, the measure is computed only for rows where Product Color equals Blue.', 'CALCULATE ändert den Filterkontext, bevor der Ausdruck ausgewertet wird. In diesem Fall wird das Measure nur für Zeilen berechnet, bei denen die Produktfarbe Blau ist.'),
      t('CALCULATE is about filter context modification.', 'CALCULATE dreht sich um die Änderung des Filterkontexts.'),
      ref.daxCalculate),

    q('dp700-261', 'single', semantic, 'medium',
      null,
      t('Why would you write `SUMX(Sales, Sales[Quantity] * Sales[Net Price])` instead of a simple SUM?', 'Warum würden Sie `SUMX(Sales, Sales[Quantity] * Sales[Net Price])` statt eines einfachen SUM schreiben?'),
      [
        o('A', 'Because SUMX evaluates an expression row by row before summing', 'Weil SUMX einen Ausdruck zeilenweise auswertet, bevor summiert wird'),
        o('B', 'Because SUMX removes filters automatically', 'Weil SUMX Filter automatisch entfernt'),
        o('C', 'Because SUMX creates a role', 'Weil SUMX eine Rolle erstellt'),
        o('D', 'Because SUMX activates inactive relationships', 'Weil SUMX inaktive Beziehungen aktiviert')
      ],
      ['A'],
      t('SUMX is an iterator that computes an expression for each row and then sums the results. It is the correct pattern when the value to sum does not exist as a single stored column.', 'SUMX ist ein Iterator, der einen Ausdruck für jede Zeile berechnet und anschließend die Ergebnisse summiert. Das ist das richtige Muster, wenn der zu summierende Wert nicht als einzelne gespeicherte Spalte existiert.'),
      t('Iterator functions evaluate an expression per row.', 'Iteratorfunktionen werten einen Ausdruck pro Zeile aus.'),
      ref.daxSumx),

    q('dp700-262', 'single', semantic, 'medium',
      null,
      t('What is a main benefit of using `VAR` in a DAX measure?', 'Was ist ein Hauptvorteil der Verwendung von `VAR` in einem DAX-Measure?'),
      [
        o('A', 'It stores intermediate results for readability and reuse', 'Es speichert Zwischenergebnisse für Lesbarkeit und Wiederverwendung'),
        o('B', 'It disables filter context', 'Es deaktiviert den Filterkontext'),
        o('C', 'It converts Import mode to DirectLake', 'Es konvertiert den Importmodus in DirectLake'),
        o('D', 'It defines row-level security roles', 'Es definiert Row-Level-Security-Rollen')
      ],
      ['A'],
      t('VAR lets you name intermediate calculations and reuse them later in the measure. This often improves readability and can avoid recalculating the same expression multiple times.', 'VAR ermöglicht es, Zwischenergebnisse zu benennen und später im Measure wiederzuverwenden. Das verbessert häufig die Lesbarkeit und kann vermeiden, denselben Ausdruck mehrfach zu berechnen.'),
      t('Think intermediate calculation storage.', 'Denken Sie an die Speicherung von Zwischenergebnissen.'),
      ref.daxVar),

    q('dp700-263', 'single', semantic, 'medium',
      null,
      t('A measure for percent of total uses `ALL(Product)` in the denominator. Why?', 'Ein Measure für Prozent des Gesamtwerts verwendet `ALL(Product)` im Nenner. Warum?'),
      [
        o('A', 'To remove product filters so the denominator represents the full total', 'Um Produktfilter zu entfernen, damit der Nenner den Gesamttotalwert darstellt'),
        o('B', 'To activate an inactive date relationship', 'Um eine inaktive Datumsbeziehung zu aktivieren'),
        o('C', 'To hide the Product table', 'Um die Produkttabelle auszublenden'),
        o('D', 'To convert the measure to DirectQuery', 'Um das Measure in DirectQuery zu konvertieren')
      ],
      ['A'],
      t('ALL removes filters from the specified table or columns. In a percent-of-total pattern, that allows the denominator to represent the unfiltered total instead of the filtered subtotal.', 'ALL entfernt Filter aus der angegebenen Tabelle oder den angegebenen Spalten. In einem Prozent-vom-Gesamt-Muster kann der Nenner dadurch den ungefilterten Gesamtwert statt des gefilterten Teilwerts darstellen.'),
      t('The denominator needs the full total.', 'Der Nenner benötigt den vollständigen Gesamtwert.'),
      ref.daxAll),

    q('dp700-264', 'multiple', semantic, 'hard',
      t('A report keeps Year in context but needs to remove other Date filters for a calculation.', 'Ein Bericht behält Jahr im Kontext, muss aber andere Datumsfilter für eine Berechnung entfernen.'),
      t('Which two statements about ALL and ALLEXCEPT are correct?', 'Welche zwei Aussagen zu ALL und ALLEXCEPT sind korrekt?'),
      [
        o('A', 'ALL removes filters from the specified table or columns', 'ALL entfernt Filter aus der angegebenen Tabelle oder den angegebenen Spalten'),
        o('B', 'ALLEXCEPT removes all filters except the listed columns', 'ALLEXCEPT entfernt alle Filter außer den angegebenen Spalten'),
        o('C', 'Both functions change relationship direction', 'Beide Funktionen ändern die Beziehungsrichtung'),
        o('D', 'Both functions define security rules', 'Beide Funktionen definieren Sicherheitsregeln')
      ],
      ['A', 'B'],
      t('ALL and ALLEXCEPT are filter-modification functions used inside DAX calculations. They affect filter context, not model relationships or security configuration.', 'ALL und ALLEXCEPT sind Funktionen zur Filteränderung, die in DAX-Berechnungen verwendet werden. Sie beeinflussen den Filterkontext und nicht Modellbeziehungen oder Sicherheitskonfigurationen.'),
      t('Stay in the filter context domain.', 'Bleiben Sie im Bereich des Filterkontexts.'),
      ref.daxAll),

    q('dp700-265', 'single', semantic, 'hard',
      t('A sales model has an active relationship to OrderDate and an inactive relationship to ShipDate. A measure uses `CALCULATE([Sales Amount], USERELATIONSHIP(Sales[ShipDateKey], \'Date\'[DateKey]))`.', 'Ein Vertriebsmodell hat eine aktive Beziehung zu OrderDate und eine inaktive Beziehung zu ShipDate. Ein Measure verwendet `CALCULATE([Sales Amount], USERELATIONSHIP(Sales[ShipDateKey], \'Date\'[DateKey]))`.'),
      t('Why is USERELATIONSHIP needed here?', 'Warum wird USERELATIONSHIP hier benötigt?'),
      [
        o('A', 'To temporarily activate the ShipDate relationship for this calculation', 'Um die ShipDate-Beziehung für diese Berechnung vorübergehend zu aktivieren'),
        o('B', 'To remove all date filters', 'Um alle Datumsfilter zu entfernen'),
        o('C', 'To create a new table in memory', 'Um eine neue Tabelle im Speicher zu erstellen'),
        o('D', 'To enable DirectLake mode', 'Um DirectLake zu aktivieren')
      ],
      ['A'],
      t('USERELATIONSHIP lets a measure use an existing inactive relationship during evaluation. This is the standard approach for alternate date roles such as Ship Date versus Order Date.', 'USERELATIONSHIP erlaubt einem Measure, während der Auswertung eine vorhandene inaktive Beziehung zu verwenden. Dies ist der Standardansatz für alternative Datumsrollen wie Versanddatum gegenüber Bestelldatum.'),
      t('The model already has the relationship; the measure activates it.', 'Das Modell enthält die Beziehung bereits; das Measure aktiviert sie.'),
      ref.daxUserRelationship),

    q('dp700-266', 'single', semantic, 'medium',
      null,
      t('What does the measure `Sales YTD = TOTALYTD([Total Sales], \'Date\'[Date])` return?', 'Was gibt das Measure `Sales YTD = TOTALYTD([Total Sales], \'Date\'[Date])` zurück?'),
      [
        o('A', 'A cumulative total from the start of the year to the current date context', 'Einen kumulierten Gesamtwert vom Jahresbeginn bis zum aktuellen Datumskontext'),
        o('B', 'Only the sales value for the current day', 'Nur den Verkaufswert für den aktuellen Tag'),
        o('C', 'The total for the previous year', 'Den Gesamtwert für das Vorjahr'),
        o('D', 'A count of rows in the Date table', 'Eine Anzahl von Zeilen in der Datumstabelle')
      ],
      ['A'],
      t('TOTALYTD is a time-intelligence function that accumulates a measure from the beginning of the year through the current filter context date. It is commonly used for year-to-date reporting.', 'TOTALYTD ist eine Zeitintelligenzfunktion, die ein Measure vom Jahresbeginn bis zum aktuellen Datum im Filterkontext aufsummiert. Sie wird häufig für Berichte zum Jahresverlauf verwendet.'),
      t('YTD means cumulative within the current year.', 'YTD bedeutet kumuliert innerhalb des aktuellen Jahres.'),
      ref.daxCalculate),

    q('dp700-267', 'single', semantic, 'medium',
      null,
      t('What does `CALCULATE([Total Sales], SAMEPERIODLASTYEAR(\'Date\'[Date]))` typically return?', 'Was gibt `CALCULATE([Total Sales], SAMEPERIODLASTYEAR(\'Date\'[Date]))` typischerweise zurück?'),
      [
        o('A', 'Sales for the equivalent period in the previous year', 'Verkäufe für den entsprechenden Zeitraum des Vorjahres'),
        o('B', 'Sales for the next year', 'Verkäufe für das nächste Jahr'),
        o('C', 'Sales with all filters removed', 'Verkäufe mit entfernten Filtern'),
        o('D', 'A list of all years in the model', 'Eine Liste aller Jahre im Modell')
      ],
      ['A'],
      t('SAMEPERIODLASTYEAR shifts the date context back one year while preserving the shape of the selected period. Combined with CALCULATE, it is a classic prior-year comparison pattern.', 'SAMEPERIODLASTYEAR verschiebt den Datumskontext um ein Jahr zurück und behält dabei die Form des ausgewählten Zeitraums bei. In Kombination mit CALCULATE ist es ein klassisches Muster für Vorjahresvergleiche.'),
      t('Think same dates, previous year.', 'Denken Sie an dieselben Daten im Vorjahr.'),
      ref.daxCalculate),

    q('dp700-268', 'single', semantic, 'hard',
      null,
      t('Why would a measure use `CALCULATE([Sales], FILTER(Sales, Sales[MarginPct] > 0.3))`?', 'Warum würde ein Measure `CALCULATE([Sales], FILTER(Sales, Sales[MarginPct] > 0.3))` verwenden?'),
      [
        o('A', 'To apply a row-level table filter before evaluating Sales', 'Um vor der Auswertung von Sales einen zeilenweisen Tabellenfilter anzuwenden'),
        o('B', 'To create a new relationship in the model', 'Um eine neue Beziehung im Modell zu erstellen'),
        o('C', 'To enable incremental refresh', 'Um Incremental Refresh zu aktivieren'),
        o('D', 'To load data into OneLake', 'Um Daten in OneLake zu laden')
      ],
      ['A'],
      t('FILTER returns a table that CALCULATE can use as a filter argument. This pattern is useful when the filter condition is more complex than a simple column equals value expression.', 'FILTER gibt eine Tabelle zurück, die CALCULATE als Filterargument verwenden kann. Dieses Muster ist nützlich, wenn die Filterbedingung komplexer ist als ein einfacher Spalte-gleich-Wert-Ausdruck.'),
      t('FILTER creates the filtered table expression.', 'FILTER erstellt den gefilterten Tabellenausdruck.'),
      ref.daxCalculate),

    q('dp700-269', 'single', semantic, 'easy',
      null,
      t('Why is `DIVIDE([Margin], [Sales])` usually preferred over `[Margin] / [Sales]` in DAX?', 'Warum wird `DIVIDE([Margin], [Sales])` in DAX normalerweise gegenüber `[Margin] / [Sales]` bevorzugt?'),
      [
        o('A', 'It handles divide-by-zero and blank cases more safely', 'Es behandelt Division durch null und Leerwerte sicherer'),
        o('B', 'It makes the measure automatically cumulative', 'Es macht das Measure automatisch kumulativ'),
        o('C', 'It activates inactive relationships', 'Es aktiviert inaktive Beziehungen'),
        o('D', 'It bypasses filter context', 'Es umgeht den Filterkontext')
      ],
      ['A'],
      t('DIVIDE is designed for safe division and can return blank or an alternate result when the denominator is zero. That makes measures more robust than using the slash operator directly.', 'DIVIDE ist für sichere Division vorgesehen und kann leer oder ein alternatives Ergebnis zurückgeben, wenn der Nenner null ist. Das macht Measures robuster, als den Schrägstrichoperator direkt zu verwenden.'),
      t('The key is safer handling of zero denominators.', 'Entscheidend ist die sicherere Behandlung von Null im Nenner.'),
      ref.daxCalculate),

    q('dp700-270', 'single', semantic, 'hard',
      t('A model contains OrderDate and ShipDate relationships to the same Date table. Most reports analyze orders by OrderDate, but a few measures must analyze shipment timing.', 'Ein Modell enthält Beziehungen von OrderDate und ShipDate zur selben Datumstabelle. Die meisten Berichte analysieren Bestellungen nach OrderDate, aber einige Measures müssen Versandzeitpunkte analysieren.'),
      t('What should you do?', 'Was sollten Sie tun?'),
      [
        o('A', 'Keep OrderDate active and use USERELATIONSHIP in ShipDate measures', 'Lassen Sie OrderDate aktiv und verwenden Sie USERELATIONSHIP in ShipDate-Measures'),
        o('B', 'Make both relationships active at the same time', 'Machen Sie beide Beziehungen gleichzeitig aktiv'),
        o('C', 'Delete the Date table', 'Löschen Sie die Datumstabelle'),
        o('D', 'Disable all date filters', 'Deaktivieren Sie alle Datumsfilter')
      ],
      ['A'],
      t('The active relationship should represent the most common analysis path. Alternate date paths are typically handled with inactive relationships plus USERELATIONSHIP in specific measures.', 'Die aktive Beziehung sollte den häufigsten Analysepfad darstellen. Alternative Datumspfade werden typischerweise mit inaktiven Beziehungen plus USERELATIONSHIP in bestimmten Measures behandelt.'),
      t('Use one active path and activate the alternate path only when needed.', 'Verwenden Sie einen aktiven Pfad und aktivieren Sie den alternativen Pfad nur bei Bedarf.'),
      ref.daxUserRelationship),

    q('dp700-271', 'multiple', semantic, 'medium',
      t('A model must represent many-to-many relationships between accounts and customers for reporting.', 'Ein Modell muss Viele-zu-viele-Beziehungen zwischen Konten und Kunden für Berichte darstellen.'),
      t('Which two design actions are best?', 'Welche zwei Entwurfsmaßnahmen sind am besten?'),
      [
        o('A', 'Create a bridge table to resolve the many-to-many relationship', 'Erstellen Sie eine Brückentabelle, um die Viele-zu-viele-Beziehung aufzulösen'),
        o('B', 'Duplicate every fact row once per customer', 'Duplizieren Sie jede Faktenzeile einmal pro Kunde'),
        o('C', 'Maintain one-to-many relationships from the bridge to each side', 'Behalten Sie Eins-zu-viele-Beziehungen von der Brücke zu jeder Seite bei'),
        o('D', 'Remove one of the dimensions from the model', 'Entfernen Sie eine der Dimensionen aus dem Modell')
      ],
      ['A', 'C'],
      t('A bridge table is the standard pattern for modeling controlled many-to-many relationships. It keeps filter behavior understandable and avoids uncontrolled duplication.', 'Eine Brückentabelle ist das Standardmuster zur Modellierung kontrollierter Viele-zu-viele-Beziehungen. Sie hält das Filterverhalten verständlich und vermeidet unkontrollierte Duplizierung.'),
      t('Many-to-many usually needs a bridge plus one-to-many paths.', 'Viele-zu-viele erfordert in der Regel eine Brücke plus Eins-zu-viele-Pfade.'),
      ref.relationships),

    q('dp700-272', 'single', semantic, 'medium',
      null,
      t('Why should bidirectional filtering be used carefully in a semantic model?', 'Warum sollte bidirektionale Filterung in einem semantischen Modell mit Vorsicht verwendet werden?'),
      [
        o('A', 'It can introduce ambiguous filter paths and unexpected results', 'Sie kann mehrdeutige Filterpfade und unerwartete Ergebnisse erzeugen'),
        o('B', 'It is required for every one-to-many relationship', 'Sie ist für jede Eins-zu-viele-Beziehung erforderlich'),
        o('C', 'It disables row-level security', 'Sie deaktiviert Row-Level-Security'),
        o('D', 'It forces Import mode', 'Sie erzwingt den Importmodus')
      ],
      ['A'],
      t('Bidirectional filtering can be useful in specific cases, but it can also create ambiguity and harder-to-predict propagation. Single-direction relationships are usually the safer default.', 'Bidirektionale Filterung kann in bestimmten Fällen nützlich sein, aber sie kann auch Mehrdeutigkeit und schwerer vorhersehbare Weitergabe erzeugen. Beziehungen mit einfacher Richtung sind normalerweise die sicherere Standardeinstellung.'),
      t('Prefer simple filter flow unless there is a clear reason otherwise.', 'Bevorzugen Sie einen einfachen Filterfluss, sofern es keinen klaren Grund dagegen gibt.'),
      ref.relationships),

    q('dp700-273', 'multiple', semantic, 'hard',
      t('Each sales manager must see only rows for regions assigned to that manager in a user-to-region mapping table.', 'Jeder Vertriebsleiter darf nur Zeilen für Regionen sehen, die diesem Leiter in einer Benutzer-zu-Region-Zuordnungstabelle zugewiesen sind.'),
      t('Which two components are required for this design?', 'Welche zwei Komponenten sind für dieses Design erforderlich?'),
      [
        o('A', 'A role with a filter expression', 'Eine Rolle mit einem Filterausdruck'),
        o('B', 'Relationships that propagate filters from the mapping table to facts', 'Beziehungen, die Filter von der Zuordnungstabelle auf Fakten weitergeben'),
        o('C', 'A calculation group', 'Eine Berechnungsgruppe'),
        o('D', 'A paginated report subscription', 'Ein Abonnement für einen paginierten Bericht')
      ],
      ['A', 'B'],
      t('Dynamic RLS needs both a role definition and model relationships that allow the security filter to flow to the protected data. Without the propagation path, the role cannot restrict the fact rows correctly.', 'Dynamische RLS benötigt sowohl eine Rollendefinition als auch Modellbeziehungen, die den Sicherheitsfilter zu den geschützten Daten weiterleiten. Ohne den Weitergabepfad kann die Rolle die Faktenzeilen nicht korrekt einschränken.'),
      t('Security rules need both logic and a filter path.', 'Sicherheitsregeln benötigen sowohl Logik als auch einen Filterpfad.'),
      ref.rls),

    q('dp700-274', 'single', semantic, 'medium',
      null,
      t('What is the purpose of object-level security in a Fabric semantic model?', 'Was ist der Zweck von Object-Level-Security in einem semantischen Fabric-Modell?'),
      [
        o('A', 'Hide specific tables or columns from certain users', 'Bestimmte Tabellen oder Spalten für bestimmte Benutzer ausblenden'),
        o('B', 'Filter rows by region', 'Zeilen nach Region filtern'),
        o('C', 'Optimize DirectLake performance', 'DirectLake-Leistung optimieren'),
        o('D', 'Schedule pipeline runs', 'Pipeline-Läufe planen')
      ],
      ['A'],
      t('Object-level security is used when users should not even see certain tables or columns. Row-level security, by contrast, filters which rows a user can access.', 'Object-Level-Security wird verwendet, wenn Benutzer bestimmte Tabellen oder Spalten nicht einmal sehen sollen. Row-Level-Security filtert dagegen, auf welche Zeilen ein Benutzer zugreifen kann.'),
      t('OLS hides objects; RLS filters rows.', 'OLS blendet Objekte aus; RLS filtert Zeilen.'),
      ref.ols),

    q('dp700-275', 'single', semantic, 'medium',
      null,
      t('Why would a Fabric team use deployment pipelines for semantic models and reports?', 'Warum würde ein Fabric-Team Deployment-Pipelines für semantische Modelle und Berichte verwenden?'),
      [
        o('A', 'To promote content through dev, test, and prod stages', 'Um Inhalte durch Entwicklungs-, Test- und Produktionsstufen zu fördern'),
        o('B', 'To replace DAX measures with SQL views', 'Um DAX-Measures durch SQL-Sichten zu ersetzen'),
        o('C', 'To bypass workspace security', 'Um Arbeitsbereichssicherheit zu umgehen'),
        o('D', 'To create Eventstream routes', 'Um Eventstream-Routen zu erstellen')
      ],
      ['A'],
      t('Deployment pipelines are built for controlled movement of content across lifecycle stages. They help teams manage release flow and reduce manual promotion errors.', 'Deployment-Pipelines sind für die kontrollierte Verschiebung von Inhalten über Lebenszyklusstufen hinweg vorgesehen. Sie helfen Teams, den Releasefluss zu steuern und manuelle Bereitstellungsfehler zu reduzieren.'),
      t('Think lifecycle promotion, not authoring.', 'Denken Sie an Lebenszyklusförderung und nicht an Authoring.'),
      ref.deployment),

    q('dp700-276', 'single', semantic, 'hard',
      t('A fact table contains several years of history, but only the latest few days change regularly. Full refreshes are taking too long.', 'Eine Faktentabelle enthält mehrere Jahre Historie, aber nur die letzten wenigen Tage ändern sich regelmäßig. Vollständige Aktualisierungen dauern zu lange.'),
      t('Which feature should you implement?', 'Welche Funktion sollten Sie implementieren?'),
      [
        o('A', 'Incremental refresh', 'Incremental Refresh'),
        o('B', 'Bookmarks', 'Lesezeichen'),
        o('C', 'Cross-highlighting', 'Kreuzhervorhebung'),
        o('D', 'Table clone', 'Tabellenklon')
      ],
      ['A'],
      t('Incremental refresh partitions the model so only recent data is refreshed regularly while historical partitions remain unchanged. This can dramatically reduce refresh duration and resource consumption.', 'Incremental Refresh partitioniert das Modell, sodass nur aktuelle Daten regelmäßig aktualisiert werden, während historische Partitionen unverändert bleiben. Das kann die Aktualisierungsdauer und den Ressourcenverbrauch erheblich reduzieren.'),
      t('Refresh only the changing window.', 'Aktualisieren Sie nur das sich ändernde Fenster.'),
      ref.incremental),

    q('dp700-277', 'single', semantic, 'medium',
      t('A semantic model is growing beyond the limits of standard dataset storage and must scale to larger sizes.', 'Ein semantisches Modell wächst über die Grenzen des Standardspeichers für Datasets hinaus und muss auf größere Größen skaliert werden.'),
      t('Which capability should you enable?', 'Welche Funktion sollten Sie aktivieren?'),
      [
        o('A', 'Large semantic model storage format', 'Speicherformat für große semantische Modelle'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'Shortcut', 'Shortcut'),
        o('D', 'Eventstream', 'Eventstream')
      ],
      ['A'],
      t('The large semantic model storage format is intended for models that need to exceed standard size patterns. It supports scaling larger import-based models in supported capacities.', 'Das Speicherformat für große semantische Modelle ist für Modelle vorgesehen, die Standardgrößen überschreiten müssen. Es unterstützt die Skalierung größerer importbasierter Modelle in unterstützten Kapazitäten.'),
      t('The question is about model storage scale.', 'Die Frage betrifft die Skalierung des Modellspeichers.'),
      ref.largeModels),

    q('dp700-278', 'multiple', semantic, 'hard',
      t('A semantic model uses DirectQuery for detailed data, but most report visuals ask for common summaries by product and month.', 'Ein semantisches Modell verwendet DirectQuery für Detaildaten, aber die meisten Berichtvisuals fragen häufige Zusammenfassungen nach Produkt und Monat ab.'),
      t('Which two actions can improve performance?', 'Welche zwei Maßnahmen können die Leistung verbessern?'),
      [
        o('A', 'Create an imported aggregation table', 'Erstellen Sie eine importierte Aggregationstabelle'),
        o('B', 'Map the aggregation table so matching queries can hit it', 'Ordnen Sie die Aggregationstabelle zu, damit passende Abfragen sie nutzen können'),
        o('C', 'Remove all dimensions', 'Entfernen Sie alle Dimensionen'),
        o('D', 'Disable relationships', 'Deaktivieren Sie Beziehungen')
      ],
      ['A', 'B'],
      t('Aggregation tables can answer common summary queries much faster than a detailed DirectQuery source. They must also be mapped correctly so the engine can redirect eligible queries to them.', 'Aggregationstabellen können häufige Summenabfragen viel schneller beantworten als eine detaillierte DirectQuery-Quelle. Sie müssen außerdem korrekt zugeordnet werden, damit die Engine geeignete Abfragen auf sie umleiten kann.'),
      t('One answer builds the summary table, the other enables its use.', 'Eine Antwort erstellt die Summierungstabelle, die andere ermöglicht ihre Nutzung.'),
      ref.aggregations),

    q('dp700-279', 'multiple', semantic, 'medium',
      t('A model contains dozens of base measures and needs reusable YTD, MTD, and YoY logic without creating separate copies of every measure.', 'Ein Modell enthält Dutzende Basemeasures und benötigt wiederverwendbare Logik für YTD, MTD und YoY, ohne für jedes Measure separate Kopien zu erstellen.'),
      t('Which two benefits do calculation groups provide?', 'Welche zwei Vorteile bieten Berechnungsgruppen?'),
      [
        o('A', 'They reduce measure proliferation', 'Sie reduzieren die Anzahl explodierender Measures'),
        o('B', 'They centralize reusable calculation logic', 'Sie zentralisieren wiederverwendbare Berechnungslogik'),
        o('C', 'They replace relationships', 'Sie ersetzen Beziehungen'),
        o('D', 'They create workspace roles automatically', 'Sie erstellen automatisch Arbeitsbereichsrollen')
      ],
      ['A', 'B'],
      t('Calculation groups let one reusable definition apply time-intelligence or similar logic across many measures. This reduces maintenance and keeps models cleaner.', 'Berechnungsgruppen ermöglichen es, dass eine wiederverwendbare Definition Zeitintelligenz oder ähnliche Logik über viele Measures hinweg anwendet. Das reduziert Wartungsaufwand und hält Modelle sauberer.'),
      t('Think reusable logic across many measures.', 'Denken Sie an wiederverwendbare Logik über viele Measures hinweg.'),
      ref.calcGroups),

    q('dp700-280', 'single', semantic, 'medium',
      null,
      t('Compared with Import mode, what is a key advantage of DirectLake for Fabric-native data?', 'Was ist im Vergleich zum Importmodus ein zentraler Vorteil von DirectLake für Fabric-native Daten?'),
      [
        o('A', 'It can query OneLake data without creating a separate imported copy', 'Es kann OneLake-Daten abfragen, ohne eine separate importierte Kopie zu erstellen'),
        o('B', 'It removes the need for relationships', 'Es macht Beziehungen überflüssig'),
        o('C', 'It works only with on-premises sources', 'Es funktioniert nur mit lokalen Quellen'),
        o('D', 'It disables security roles', 'Es deaktiviert Sicherheitsrollen')
      ],
      ['A'],
      t('DirectLake is attractive because it avoids the traditional import duplication step for supported Fabric data. This can simplify freshness and reduce processing overhead for Fabric-native models.', 'DirectLake ist attraktiv, weil es den traditionellen Importduplikationsschritt für unterstützte Fabric-Daten vermeidet. Das kann die Aktualität vereinfachen und den Verarbeitungsaufwand für Fabric-native Modelle reduzieren.'),
      t('No separate imported copy is the main clue.', 'Keine separate importierte Kopie ist der zentrale Hinweis.'),
      ref.directLake),

    q('dp700-281', 'single', semantic, 'medium',
      null,
      t('What is a major benefit of incremental refresh for historical partitions in a large semantic model?', 'Was ist ein wesentlicher Vorteil von Incremental Refresh für historische Partitionen in einem großen semantischen Modell?'),
      [
        o('A', 'Historical partitions can remain unchanged while only recent data refreshes', 'Historische Partitionen können unverändert bleiben, während nur aktuelle Daten aktualisiert werden'),
        o('B', 'Historical data is automatically hidden from users', 'Historische Daten werden automatisch vor Benutzern verborgen'),
        o('C', 'It removes the need for a Date table', 'Es macht eine Datumstabelle überflüssig'),
        o('D', 'It turns the model into DirectLake', 'Es verwandelt das Modell in DirectLake')
      ],
      ['A'],
      t('Incremental refresh keeps stable historical partitions intact and processes only the refresh window that changes. This saves time and capacity compared with repeatedly reprocessing all history.', 'Incremental Refresh lässt stabile historische Partitionen unverändert und verarbeitet nur das sich ändernde Aktualisierungsfenster. Das spart Zeit und Kapazität im Vergleich zur wiederholten Neuverarbeitung der gesamten Historie.'),
      t('The value is avoiding full reprocessing of history.', 'Der Nutzen besteht darin, die vollständige Neuverarbeitung der Historie zu vermeiden.'),
      ref.incremental),

    q('dp700-282', 'multiple', semantic, 'medium',
      null,
      t('Which two tasks are supported by deployment pipelines in Fabric?', 'Welche zwei Aufgaben werden von Deployment-Pipelines in Fabric unterstützt?'),
      [
        o('A', 'Deploy content from one stage to the next', 'Inhalte von einer Stufe zur nächsten bereitstellen'),
        o('B', 'Compare content between lifecycle stages', 'Inhalte zwischen Lebenszyklusstufen vergleichen'),
        o('C', 'Author DAX measures automatically from prompts', 'DAX-Measures automatisch aus Eingaben erstellen'),
        o('D', 'Assign tenant settings to users', 'Mandanteneinstellungen Benutzern zuweisen')
      ],
      ['A', 'B'],
      t('Deployment pipelines help teams compare and promote content across stages such as dev, test, and prod. They are not a feature for semantic authoring or tenant administration.', 'Deployment-Pipelines helfen Teams, Inhalte über Stufen wie Entwicklung, Test und Produktion hinweg zu vergleichen und bereitzustellen. Sie sind keine Funktion für semantisches Authoring oder Mandantenadministration.'),
      t('Stay in the release management scope.', 'Bleiben Sie im Bereich des Release-Managements.'),
      ref.deployment),

    q('dp700-283', 'single', semantic, 'medium',
      t('A finance model allows users to see rows in a table but must hide the SalaryAmount column completely from most users.', 'Ein Finanzmodell erlaubt Benutzern, Zeilen in einer Tabelle zu sehen, muss aber die Spalte SalaryAmount für die meisten Benutzer vollständig ausblenden.'),
      t('Which security feature should you use?', 'Welche Sicherheitsfunktion sollten Sie verwenden?'),
      [
        o('A', 'Object-level security', 'Object-Level-Security'),
        o('B', 'Row-level security', 'Row-Level-Security'),
        o('C', 'Incremental refresh', 'Incremental Refresh'),
        o('D', 'Bookmark navigation', 'Lesezeichennavigation')
      ],
      ['A'],
      t('The requirement is to hide an object, not just filter which rows are visible. OLS is the correct feature for removing access to specific columns or tables.', 'Die Anforderung besteht darin, ein Objekt auszublenden und nicht nur sichtbare Zeilen zu filtern. OLS ist die richtige Funktion, um den Zugriff auf bestimmte Spalten oder Tabellen zu entfernen.'),
      t('Hide columns with OLS, filter rows with RLS.', 'Blenden Sie Spalten mit OLS aus, filtern Sie Zeilen mit RLS.'),
      ref.ols),

    q('dp700-284', 'single', semantic, 'medium',
      t('A model uses imported dimensions for speed and a DirectQuery fact table for fresh transaction detail.', 'Ein Modell verwendet importierte Dimensionen für Geschwindigkeit und eine DirectQuery-Faktentabelle für aktuelle Transaktionsdetails.'),
      t('What type of semantic model is this?', 'Welcher Typ semantischen Modells ist dies?'),
      [
        o('A', 'Composite model', 'Zusammengesetztes Modell'),
        o('B', 'Import-only model', 'Nur-Import-Modell'),
        o('C', 'DirectLake-only model', 'Nur-DirectLake-Modell'),
        o('D', 'Paginated dataset', 'Paginiertes Dataset')
      ],
      ['A'],
      t('A composite model mixes storage modes within the same semantic model. This allows designers to combine fast imported data with live detail where needed.', 'Ein zusammengesetztes Modell mischt Speichermodi innerhalb desselben semantischen Modells. Dadurch können Designer schnelle importierte Daten mit Live-Details kombinieren, wo dies erforderlich ist.'),
      t('Mixed storage modes indicate a composite model.', 'Gemischte Speichermodi weisen auf ein zusammengesetztes Modell hin.'),
      ref.aggregations),

    q('dp700-285', 'single', semantic, 'hard',
      t('Finance wants a single reusable set of YTD, QTD, MTD, and YoY calculations that works across dozens of existing base measures.', 'Finance möchte einen einzigen wiederverwendbaren Satz von Berechnungen für YTD, QTD, MTD und YoY, der über Dutzende vorhandener Basemeasures funktioniert.'),
      t('What should you implement?', 'Was sollten Sie implementieren?'),
      [
        o('A', 'A calculation group', 'Eine Berechnungsgruppe'),
        o('B', 'A table clone', 'Einen Tabellenklon'),
        o('C', 'An Eventstream', 'Einen Eventstream'),
        o('D', 'A OneLake shortcut', 'Einen OneLake-Shortcut')
      ],
      ['A'],
      t('Calculation groups apply reusable calculation logic across many measures without duplicating the measure definitions. That is exactly the problem they are meant to solve.', 'Berechnungsgruppen wenden wiederverwendbare Berechnungslogik über viele Measures hinweg an, ohne die Measure-Definitionen zu duplizieren. Genau dieses Problem sollen sie lösen.'),
      t('One reusable time-intelligence layer points to calculation groups.', 'Eine wiederverwendbare Zeitintelligenzschicht weist auf Berechnungsgruppen hin.'),
      ref.calcGroups),

    q('dp700-286', 'single', explore, 'easy',
      t('A data engineer runs `df.describe().show()` in a Fabric notebook while profiling a newly loaded table.', 'Ein Data Engineer führt `df.describe().show()` in einem Fabric-Notebook aus, während er eine neu geladene Tabelle profiliert.'),
      t('What does this command help identify?', 'Was hilft dieser Befehl zu erkennen?'),
      [
        o('A', 'Basic summary statistics such as count, mean, and min/max', 'Grundlegende Zusammenfassungsstatistiken wie Anzahl, Mittelwert und Min/Max'),
        o('B', 'Workspace roles for the notebook', 'Arbeitsbereichsrollen für das Notebook'),
        o('C', 'Deployment pipeline stages', 'Deployment-Pipeline-Stufen'),
        o('D', 'RLS filters for the model', 'RLS-Filter für das Modell')
      ],
      ['A'],
      t('describe produces quick descriptive statistics that are useful for initial profiling and anomaly detection. It is a common first step in exploratory notebook analysis.', 'describe liefert schnelle deskriptive Statistiken, die für das erste Profiling und die Erkennung von Auffälligkeiten nützlich sind. Es ist ein häufiger erster Schritt in der explorativen Notebook-Analyse.'),
      t('Think descriptive statistics, not security or deployment.', 'Denken Sie an deskriptive Statistiken und nicht an Sicherheit oder Bereitstellung.'),
      ref.notebook),

    q('dp700-287', 'single', explore, 'easy',
      null,
      t('What is the main purpose of `display(df.limit(100))` in a notebook?', 'Was ist der Hauptzweck von `display(df.limit(100))` in einem Notebook?'),
      [
        o('A', 'Quickly preview a sample of rows', 'Schnell eine Stichprobe von Zeilen anzeigen'),
        o('B', 'Persist the DataFrame as a table', 'Den DataFrame als Tabelle persistieren'),
        o('C', 'Configure tenant settings', 'Mandanteneinstellungen konfigurieren'),
        o('D', 'Create a paginated report', 'Einen paginierten Bericht erstellen')
      ],
      ['A'],
      t('limit restricts the number of rows, and display renders the sample for quick inspection. This is useful when you want a fast visual check before deeper analysis.', 'limit begrenzt die Anzahl der Zeilen, und display stellt die Stichprobe zur schnellen Sichtprüfung dar. Das ist nützlich, wenn Sie vor einer tieferen Analyse einen schnellen visuellen Check durchführen möchten.'),
      t('Sample first, analyze deeper second.', 'Zuerst eine Stichprobe, dann tiefer analysieren.'),
      ref.notebook),

    q('dp700-288', 'single', explore, 'medium',
      null,
      t('In PySpark, what does `df.groupBy("Product").agg({"Sales": "sum"})` produce?', 'Was erzeugt `df.groupBy("Product").agg({"Sales": "sum"})` in PySpark?'),
      [
        o('A', 'A grouped result with total Sales per Product', 'Ein gruppiertes Ergebnis mit den Gesamtverkäufen pro Produkt'),
        o('B', 'A new relationship between Product and Sales', 'Eine neue Beziehung zwischen Product und Sales'),
        o('C', 'A clone of the source table', 'Einen Klon der Quelltabelle'),
        o('D', 'A KQL dashboard tile', 'Eine KQL-Dashboard-Kachel')
      ],
      ['A'],
      t('The code groups rows by Product and aggregates the Sales column using SUM. This is a standard exploration pattern for checking totals by category.', 'Der Code gruppiert Zeilen nach Product und aggregiert die Spalte Sales mit SUM. Das ist ein Standardmuster für Explorationen, um Gesamtsummen nach Kategorien zu prüfen.'),
      t('Group by dimension, aggregate the measure.', 'Nach Dimension gruppieren, das Measure aggregieren.'),
      ref.notebook),

    q('dp700-289', 'multiple', explore, 'medium',
      t('Analysts need browser-based SQL surfaces to explore both lakehouse data and warehouse data interactively.', 'Analysten benötigen browserbasierte SQL-Oberflächen, um sowohl Lakehouse- als auch Warehouse-Daten interaktiv zu untersuchen.'),
      t('Which two options provide that capability?', 'Welche zwei Optionen bieten diese Funktion?'),
      [
        o('A', 'A lakehouse SQL analytics endpoint', 'Ein SQL-Analyseendpunkt eines Lakehouse'),
        o('B', 'A warehouse SQL query editor', 'Ein Warehouse-SQL-Abfrageeditor'),
        o('C', 'A bookmark navigator', 'Ein Lesezeichen-Navigator'),
        o('D', 'Data Activator', 'Data Activator')
      ],
      ['A', 'B'],
      t('Lakehouse SQL analytics endpoints and warehouse SQL editors are both SQL exploration surfaces in Fabric. Bookmarks and Activator serve different purposes.', 'Lakehouse-SQL-Analyseendpunkte und Warehouse-SQL-Editoren sind beide SQL-Oberflächen zur Exploration in Fabric. Lesezeichen und Activator dienen anderen Zwecken.'),
      t('Choose the two SQL authoring surfaces.', 'Wählen Sie die zwei SQL-Authoring-Oberflächen.'),
      ref.queryWarehouse),

    q('dp700-290', 'single', explore, 'easy',
      null,
      t('In KQL, what does `requests | summarize count() by ResultCode` do?', 'Was bewirkt `requests | summarize count() by ResultCode` in KQL?'),
      [
        o('A', 'It groups rows by ResultCode and returns a count for each group', 'Es gruppiert Zeilen nach ResultCode und liefert eine Anzahl pro Gruppe'),
        o('B', 'It hides the ResultCode column', 'Es blendet die Spalte ResultCode aus'),
        o('C', 'It creates a dashboard subscription', 'Es erstellt ein Dashboard-Abonnement'),
        o('D', 'It changes workspace permissions', 'Es ändert Arbeitsbereichsberechtigungen')
      ],
      ['A'],
      t('summarize is the KQL aggregation operator. Here it counts rows per ResultCode value.', 'summarize ist der KQL-Aggregationsoperator. Hier zählt er die Zeilen pro ResultCode-Wert.'),
      t('summarize usually means aggregate results.', 'summarize bedeutet in der Regel Ergebnisse aggregieren.'),
      ref.kql),

    q('dp700-291', 'single', explore, 'medium',
      t('An operations team runs `requests | summarize count() by bin(timestamp, 1h) | render timechart`.', 'Ein Betriebsteam führt `requests | summarize count() by bin(timestamp, 1h) | render timechart` aus.'),
      t('What insight does this query provide?', 'Welche Erkenntnis liefert diese Abfrage?'),
      [
        o('A', 'An hourly trend of request volume over time', 'Einen stündlichen Trend des Anforderungsvolumens im Zeitverlauf'),
        o('B', 'A list of all workspace admins', 'Eine Liste aller Arbeitsbereichsadministratoren'),
        o('C', 'A semantic model deployment plan', 'Einen Bereitstellungsplan für ein semantisches Modell'),
        o('D', 'A OneLake shortcut map', 'Eine OneLake-Shortcut-Karte')
      ],
      ['A'],
      t('The query bins timestamps into one-hour intervals, counts requests in each bucket, and renders the result as a timechart. That is a standard pattern for operational trend analysis.', 'Die Abfrage gruppiert Zeitstempel in Ein-Stunden-Intervalle, zählt die Anforderungen pro Bucket und rendert das Ergebnis als timechart. Das ist ein Standardmuster für die operative Trendanalyse.'),
      t('Time buckets plus timechart mean trend over time.', 'Zeit-Buckets plus timechart bedeuten Trend über die Zeit.'),
      ref.kql),

    q('dp700-292', 'single', explore, 'easy',
      null,
      t('In KQL, what is the purpose of `project State, EventType, DamageProperty`?', 'Was ist in KQL der Zweck von `project State, EventType, DamageProperty`?'),
      [
        o('A', 'Return only the selected columns', 'Nur die ausgewählten Spalten zurückgeben'),
        o('B', 'Filter rows where State is null', 'Zeilen filtern, bei denen State null ist'),
        o('C', 'Sort rows by EventType', 'Zeilen nach EventType sortieren'),
        o('D', 'Create a relationship', 'Eine Beziehung erstellen')
      ],
      ['A'],
      t('project selects and shapes the output columns of a KQL result. It is useful when you want a cleaner focused result set.', 'project wählt die Ausgabespalten eines KQL-Ergebnisses aus und formt sie. Es ist nützlich, wenn Sie ein saubereres und fokussiertes Resultset möchten.'),
      t('project is about column selection.', 'project betrifft die Spaltenauswahl.'),
      ref.kql),

    q('dp700-293', 'single', explore, 'easy',
      null,
      t('What does `logs | where Severity == "Error"` do in KQL?', 'Was bewirkt `logs | where Severity == "Error"` in KQL?'),
      [
        o('A', 'It filters the rows to only errors', 'Es filtert die Zeilen auf Fehler'),
        o('B', 'It groups rows by severity', 'Es gruppiert Zeilen nach Schweregrad'),
        o('C', 'It renders a chart automatically', 'Es rendert automatisch ein Diagramm'),
        o('D', 'It creates a saved query', 'Es erstellt eine gespeicherte Abfrage')
      ],
      ['A'],
      t('where is the KQL filtering operator. It keeps only rows that satisfy the condition.', 'where ist der KQL-Filteroperator. Er behält nur Zeilen, die die Bedingung erfüllen.'),
      t('where means filter rows.', 'where bedeutet Zeilen filtern.'),
      ref.kql),

    q('dp700-294', 'multiple', explore, 'medium',
      t('A monitoring team wants a saved place in Fabric to organize reusable KQL queries, visuals, and analysis tabs.', 'Ein Monitoring-Team möchte in Fabric einen gespeicherten Ort, um wiederverwendbare KQL-Abfragen, Visuals und Analyse-Registerkarten zu organisieren.'),
      t('Which two benefits does a KQL queryset provide?', 'Welche zwei Vorteile bietet ein KQL-Queryset?'),
      [
        o('A', 'It stores and organizes reusable KQL queries', 'Es speichert und organisiert wiederverwendbare KQL-Abfragen'),
        o('B', 'It supports collaborative analysis in a dedicated item', 'Es unterstützt kollaborative Analyse in einem dedizierten Element'),
        o('C', 'It replaces semantic model security roles', 'Es ersetzt Sicherheitsrollen des semantischen Modells'),
        o('D', 'It configures tenant settings', 'Es konfiguriert Mandanteneinstellungen')
      ],
      ['A', 'B'],
      t('A KQL queryset is a Fabric item for saving, organizing, and reusing KQL analysis work. It helps teams collaborate on query-driven investigation.', 'Ein KQL-Queryset ist ein Fabric-Element zum Speichern, Organisieren und Wiederverwenden von KQL-Analysearbeit. Es hilft Teams, bei abfragegestützten Untersuchungen zusammenzuarbeiten.'),
      t('Think saved KQL analysis workspace.', 'Denken Sie an einen gespeicherten Arbeitsbereich für KQL-Analysen.'),
      ref.queryset),

    q('dp700-295', 'single', explore, 'medium',
      null,
      t('What is a real-time dashboard in Fabric best suited for?', 'Wofür eignet sich ein Echtzeit-Dashboard in Fabric am besten?'),
      [
        o('A', 'Monitoring live or near-real-time KPIs and trends', 'Die Überwachung von Live- oder nahezu Echtzeit-KPIs und Trends'),
        o('B', 'Authoring DAX calculation groups', 'Das Erstellen von DAX-Berechnungsgruppen'),
        o('C', 'Managing workspace roles', 'Das Verwalten von Arbeitsbereichsrollen'),
        o('D', 'Cloning warehouse tables', 'Das Klonen von Warehouse-Tabellen')
      ],
      ['A'],
      t('Real-time dashboards are designed to visualize streaming or frequently updated analytical metrics. They are focused on operational visibility rather than model administration.', 'Echtzeit-Dashboards sind dafür ausgelegt, Streaming- oder häufig aktualisierte analytische Kennzahlen zu visualisieren. Sie konzentrieren sich auf operative Transparenz und nicht auf Modelladministration.'),
      t('The emphasis is monitoring current conditions.', 'Der Schwerpunkt liegt auf der Überwachung aktueller Zustände.'),
      ref.dashboard),

    q('dp700-296', 'single', explore, 'hard',
      t('Finance must distribute printable invoices with exact page breaks, repeated headers, and strict layout requirements.', 'Finance muss druckbare Rechnungen mit exakten Seitenumbrüchen, wiederholten Kopfzeilen und strengen Layoutanforderungen verteilen.'),
      t('Which reporting option should you choose?', 'Welche Berichtsoption sollten Sie wählen?'),
      [
        o('A', 'Paginated report', 'Paginierter Bericht'),
        o('B', 'Standard interactive Power BI report', 'Standardmäßiger interaktiver Power-BI-Bericht'),
        o('C', 'KQL dashboard', 'KQL-Dashboard'),
        o('D', 'Data Activator reflex', 'Data-Activator-Reflex')
      ],
      ['A'],
      t('Paginated reports are intended for pixel-perfect, printable output with precise layout control. They are the right choice for invoices, statements, and other formal documents.', 'Paginierte Berichte sind für pixelgenaue, druckbare Ausgaben mit präziser Layoutkontrolle gedacht. Sie sind die richtige Wahl für Rechnungen, Kontoauszüge und andere formale Dokumente.'),
      t('Strict print layout points to paginated reports.', 'Strenges Drucklayout weist auf paginierte Berichte hin.'),
      ref.paginated),

    q('dp700-297', 'multiple', explore, 'medium',
      null,
      t('Which two capabilities are typical strengths of paginated reports?', 'Welche zwei Fähigkeiten sind typische Stärken paginierter Berichte?'),
      [
        o('A', 'Parameters for filtered report execution', 'Parameter für gefilterte Berichtsausführung'),
        o('B', 'Subscriptions for scheduled delivery', 'Abonnements für geplante Zustellung'),
        o('C', 'Cross-highlighting between visuals', 'Kreuzhervorhebung zwischen Visuals'),
        o('D', 'Natural-language Q&A authoring', 'Authoring mit natürlicher Sprache in Q&A')
      ],
      ['A', 'B'],
      t('Paginated reports commonly support report parameters and subscription-based distribution. Cross-highlighting and Q&A are associated with interactive Power BI experiences instead.', 'Paginierte Berichte unterstützen üblicherweise Berichtsparameter und abonnementsbasierte Verteilung. Kreuzhervorhebung und Q&A gehören stattdessen zu interaktiven Power-BI-Erfahrungen.'),
      t('Think formal reporting and scheduled delivery.', 'Denken Sie an formale Berichterstattung und geplante Zustellung.'),
      ref.paginated),

    q('dp700-298', 'single', explore, 'medium',
      t('Executives want buttons that switch a report page between overview, finance, and operations perspectives without rebuilding visuals each time.', 'Führungskräfte möchten Schaltflächen, die eine Berichtsseite zwischen Überblick, Finanzen und Betrieb umschalten, ohne Visuals jedes Mal neu aufzubauen.'),
      t('Which feature should you use?', 'Welche Funktion sollten Sie verwenden?'),
      [
        o('A', 'Bookmarks', 'Lesezeichen'),
        o('B', 'Object-level security', 'Object-Level-Security'),
        o('C', 'Warehouse clone', 'Warehouse-Klon'),
        o('D', 'Dataflow Gen2', 'Dataflow Gen2')
      ],
      ['A'],
      t('Bookmarks capture report states and are commonly used for guided navigation or storytelling. Buttons can trigger those saved states for a polished interactive experience.', 'Lesezeichen speichern Berichtsstände und werden häufig für geführte Navigation oder Storytelling verwendet. Schaltflächen können diese gespeicherten Zustände auslösen und so eine hochwertige interaktive Erfahrung schaffen.'),
      t('Saved report states indicate bookmarks.', 'Gespeicherte Berichtszustände weisen auf Lesezeichen hin.'),
      ref.bookmarks),

    q('dp700-299', 'single', explore, 'medium',
      null,
      t('What is the main purpose of drillthrough in a Power BI report?', 'Was ist der Hauptzweck von Drillthrough in einem Power-BI-Bericht?'),
      [
        o('A', 'Navigate from a summary visual to a detail page while preserving context', 'Von einem Übersichtsvisual zu einer Detailseite navigieren und dabei den Kontext beibehalten'),
        o('B', 'Create a new semantic model', 'Ein neues semantisches Modell erstellen'),
        o('C', 'Assign workspace roles', 'Arbeitsbereichsrollen zuweisen'),
        o('D', 'Mirror a source system into OneLake', 'Ein Quellsystem nach OneLake spiegeln')
      ],
      ['A'],
      t('Drillthrough passes filters from the selected data point into a dedicated detail page. It is ideal for moving from summary analysis to investigation of the underlying detail.', 'Drillthrough übergibt Filter vom ausgewählten Datenpunkt an eine dedizierte Detailseite. Es eignet sich ideal, um von der Zusammenfassung zur Untersuchung der zugrunde liegenden Details zu wechseln.'),
      t('It is a summary-to-detail navigation pattern.', 'Es ist ein Navigationsmuster von der Zusammenfassung zum Detail.'),
      ref.drillthrough),

    q('dp700-300', 'single', explore, 'easy',
      null,
      t('What does the Power BI Q&A feature enable users to do?', 'Was ermöglicht die Power-BI-Funktion Q&A Benutzern?'),
      [
        o('A', 'Ask natural-language questions against a semantic model', 'Fragen in natürlicher Sprache an ein semantisches Modell stellen'),
        o('B', 'Create OneLake shortcuts', 'OneLake-Shortcuts erstellen'),
        o('C', 'Configure pipeline triggers', 'Pipeline-Trigger konfigurieren'),
        o('D', 'Clone warehouse tables', 'Warehouse-Tabellen klonen')
      ],
      ['A'],
      t('Q&A lets users explore data by typing business-style questions instead of building queries manually. It relies on the semantic model to interpret those questions.', 'Q&A ermöglicht Benutzern die Datenexploration durch geschäftsnahe Fragen, statt Abfragen manuell zu erstellen. Es stützt sich auf das semantische Modell, um diese Fragen zu interpretieren.'),
      t('Natural language over a model points to Q&A.', 'Natürliche Sprache über einem Modell weist auf Q&A hin.'),
      ref.qa),

    q('dp700-301', 'single', explore, 'medium',
      t('A manufacturing team wants an alert when temperature stays above 80 degrees for 10 minutes so operators can react quickly.', 'Ein Fertigungsteam möchte einen Alarm, wenn die Temperatur 10 Minuten lang über 80 Grad bleibt, damit Bediener schnell reagieren können.'),
      t('Which Fabric capability is built for this?', 'Welche Fabric-Funktion ist dafür ausgelegt?'),
      [
        o('A', 'Data Activator', 'Data Activator'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'Table clone', 'Tabellenklon'),
        o('D', 'Warehouse view', 'Warehouse-Sicht')
      ],
      ['A'],
      t('Data Activator watches data conditions and triggers actions when configured thresholds or patterns occur. That makes it suitable for operational alerting scenarios.', 'Data Activator überwacht Datenbedingungen und löst Aktionen aus, wenn konfigurierte Schwellenwerte oder Muster auftreten. Dadurch eignet er sich für operative Warnszenarien.'),
      t('Think event-driven alerts from data conditions.', 'Denken Sie an ereignisgesteuerte Warnungen aus Datenbedingungen.'),
      ref.activator),

    q('dp700-302', 'multiple', explore, 'hard',
      null,
      t('Which two actions can Data Activator take when a condition is met?', 'Welche zwei Aktionen kann Data Activator ausführen, wenn eine Bedingung erfüllt ist?'),
      [
        o('A', 'Send notifications such as alerts to users', 'Benachrichtigungen wie Warnungen an Benutzer senden'),
        o('B', 'Trigger downstream actions such as Power Automate workflows', 'Nachgelagerte Aktionen wie Power-Automate-Workflows auslösen'),
        o('C', 'Create a warehouse clone', 'Einen Warehouse-Klon erstellen'),
        o('D', 'Assign tenant settings', 'Mandanteneinstellungen zuweisen')
      ],
      ['A', 'B'],
      t('Data Activator is about reacting to data events with notifications and automated follow-up actions. It is not a storage-management or tenant-administration feature.', 'Data Activator dient dazu, auf Datenereignisse mit Benachrichtigungen und automatisierten Folgeaktionen zu reagieren. Er ist keine Funktion für Speichermanagement oder Mandantenadministration.'),
      t('Stay in the alerting and action domain.', 'Bleiben Sie im Bereich Warnungen und Aktionen.'),
      ref.activator),

    q('dp700-303', 'single', explore, 'medium',
      t('A notebook query returns a numeric column with a few extreme values. You want a quick way to spot the outliers before deeper analysis.', 'Eine Notebook-Abfrage liefert eine numerische Spalte mit einigen extremen Werten. Sie möchten schnell Ausreißer erkennen, bevor Sie tiefer analysieren.'),
      t('What should you do first?', 'Was sollten Sie zuerst tun?'),
      [
        o('A', 'Use a notebook visualization such as a histogram', 'Verwenden Sie eine Notebook-Visualisierung wie ein Histogramm'),
        o('B', 'Assign new workspace roles', 'Weisen Sie neue Arbeitsbereichsrollen zu'),
        o('C', 'Create a deployment pipeline', 'Erstellen Sie eine Deployment-Pipeline'),
        o('D', 'Mirror the source system', 'Spiegeln Sie das Quellsystem')
      ],
      ['A'],
      t('A quick visual such as a histogram can reveal skew, spread, and extreme values immediately. That is often the fastest first step for notebook-based exploration.', 'Eine schnelle Visualisierung wie ein Histogramm kann Schiefe, Streuung und Extremwerte sofort sichtbar machen. Das ist oft der schnellste erste Schritt für notebookbasierte Exploration.'),
      t('Visualize the distribution before deeper modeling.', 'Visualisieren Sie die Verteilung vor einer tieferen Modellierung.'),
      ref.notebook),

    q('dp700-304', 'single', explore, 'easy',
      null,
      t('What does cross-highlighting in a Power BI report allow users to do?', 'Was ermöglicht Kreuzhervorhebung in einem Power-BI-Bericht Benutzern?'),
      [
        o('A', 'Select data in one visual and see related portions emphasized in another visual', 'Daten in einem Visual auswählen und die zugehörigen Anteile in einem anderen Visual hervorgehoben sehen'),
        o('B', 'Change tenant settings from the report canvas', 'Mandanteneinstellungen auf der Berichtsfläche ändern'),
        o('C', 'Mirror a database into OneLake', 'Eine Datenbank nach OneLake spiegeln'),
        o('D', 'Create a table clone', 'Einen Tabellenklon erstellen')
      ],
      ['A'],
      t('Cross-highlighting is part of interactive report exploration. Selecting data in one visual highlights related data in other visuals on the page.', 'Kreuzhervorhebung ist Teil der interaktiven Berichtsexploration. Wenn Daten in einem Visual ausgewählt werden, werden zugehörige Daten in anderen Visuals auf der Seite hervorgehoben.'),
      t('Think interaction between visuals on the same page.', 'Denken Sie an Interaktion zwischen Visuals auf derselben Seite.'),
      ref.drillthrough),

    q('dp700-305', 'single', explore, 'hard',
      t('Operations managers need a monthly statement emailed automatically, and each recipient must be able to run the report for a selected business unit with a clean printable layout.', 'Betriebsleiter benötigen einen monatlichen Kontoauszug, der automatisch per E-Mail versendet wird, und jeder Empfänger muss den Bericht für eine ausgewählte Geschäftseinheit mit sauberem druckbarem Layout ausführen können.'),
      t('Which reporting solution best fits?', 'Welche Berichtslösung passt am besten?'),
      [
        o('A', 'A paginated report with parameters and subscriptions', 'Ein paginierter Bericht mit Parametern und Abonnements'),
        o('B', 'A bookmark-driven interactive report', 'Ein interaktiver Bericht mit Lesezeichensteuerung'),
        o('C', 'A KQL dashboard', 'Ein KQL-Dashboard'),
        o('D', 'A notebook output cell', 'Eine Notebook-Ausgabezelle')
      ],
      ['A'],
      t('The requirement combines printable layout, parameterized execution, and scheduled distribution, which is exactly where paginated reports excel. Interactive reports and dashboards are not designed for this formal document scenario.', 'Die Anforderung kombiniert druckbares Layout, parametrisierte Ausführung und geplante Verteilung, genau dort sind paginierte Berichte stark. Interaktive Berichte und Dashboards sind für dieses formale Dokumentenszenario nicht ausgelegt.'),
      t('Print layout plus parameters plus delivery points to paginated reports.', 'Drucklayout plus Parameter plus Zustellung weist auf paginierte Berichte hin.'),
      ref.paginated)

  ];

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